networking/libiproute/iprule.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * This program is free software; you can redistribute it and/or
   4  * modify it under the terms of the GNU General Public License
   5  * as published by the Free Software Foundation; either version
   6  * 2 of the License, or (at your option) any later version.
   7  *
   8  * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
   9  *
  10  * Changes:
  11  *
  12  * Rani Assaf <rani@magic.metawire.com> 980929: resolve addresses
  13  * initially integrated into busybox by Bernhard Reutner-Fischer
  14  */
  15
  16 #include <netinet/in.h>
  17 #include <netinet/ip.h>
  18 #include <arpa/inet.h>
  19
  20 /* from <linux/fib_rules.h>: */
  21 #define FRA_SUPPRESS_IFGROUP   13
  22 #define FRA_SUPPRESS_PREFIXLEN 14
  23
  24 #include "ip_common.h"  /* #include "libbb.h" is inside */
  25 #include "rt_names.h"
  26 #include "utils.h"
  27
  28 /* If you add stuff here, update iprule_full_usage */
  29 static const char keywords[] ALIGN1 =
  30         "from\0""to\0""preference\0""order\0""priority\0"
  31         "tos\0""fwmark\0""realms\0""table\0""lookup\0"
  32         "suppress_prefixlength\0""suppress_ifgroup\0"
  33         "dev\0""iif\0""nat\0""map-to\0""type\0""help\0"
  34         ;
  35 #define keyword_preference            (keywords           + sizeof("from") + sizeof("to"))
  36 #define keyword_fwmark                (keyword_preference + sizeof("preference") + sizeof("order") + sizeof("priority") + sizeof("tos"))
  37 #define keyword_realms                (keyword_fwmark     + sizeof("fwmark"))
  38 #define keyword_suppress_prefixlength (keyword_realms     + sizeof("realms") + sizeof("table") + sizeof("lookup"))
  39 #define keyword_suppress_ifgroup      (keyword_suppress_prefixlength + sizeof("suppress_prefixlength"))
  40 enum {
  41         ARG_from = 1, ARG_to, ARG_preference, ARG_order, ARG_priority,
  42         ARG_tos, ARG_fwmark, ARG_realms, ARG_table, ARG_lookup,
  43         ARG_suppress_prefixlength, ARG_suppress_ifgroup,
  44         ARG_dev, ARG_iif, ARG_nat, ARG_map_to, ARG_type, ARG_help,
  45 };
  46
  47 static int FAST_FUNC print_rule(const struct sockaddr_nl *who UNUSED_PARAM,
  48                                         struct nlmsghdr *n, void *arg UNUSED_PARAM)
  49 {
  50         struct rtmsg *r = NLMSG_DATA(n);
  51         int len = n->nlmsg_len;
  52         int host_len = -1;
  53         struct rtattr * tb[RTA_MAX+1];
  54
  55         if (n->nlmsg_type != RTM_NEWRULE)
  56                 return 0;
  57
  58         len -= NLMSG_LENGTH(sizeof(*r));
  59         if (len < 0)
  60                 return -1;
  61
  62         memset(tb, 0, sizeof(tb));
  63         parse_rtattr(tb, RTA_MAX, RTM_RTA(r), len);
  64
  65         if (r->rtm_family == AF_INET)
  66                 host_len = 32;
  67         else if (r->rtm_family == AF_INET6)
  68                 host_len = 128;
  69 /*      else if (r->rtm_family == AF_DECnet)
  70                 host_len = 16;
  71         else if (r->rtm_family == AF_IPX)
  72                 host_len = 80;
  73 */
  74         printf("%u:\t", tb[RTA_PRIORITY] ?
  75                                         *(unsigned*)RTA_DATA(tb[RTA_PRIORITY])
  76                                         : 0);
  77         printf("from ");
  78         if (tb[RTA_SRC]) {
  79                 if (r->rtm_src_len != host_len) {
  80                         printf("%s/%u",
  81                                 rt_addr_n2a(r->rtm_family, RTA_DATA(tb[RTA_SRC])),
  82                                 r->rtm_src_len
  83                         );
  84                 } else {
  85                         fputs(format_host(r->rtm_family,
  86                                                 RTA_PAYLOAD(tb[RTA_SRC]),
  87                                                 RTA_DATA(tb[RTA_SRC])),
  88                                 stdout
  89                         );
  90                 }
  91         } else if (r->rtm_src_len) {
  92                 printf("0/%d", r->rtm_src_len);
  93         } else {
  94                 printf("all");
  95         }
  96         bb_putchar(' ');
  97
  98         if (tb[RTA_DST]) {
  99                 if (r->rtm_dst_len != host_len) {
 100                         printf("to %s/%u ", rt_addr_n2a(r->rtm_family,
 101                                                          RTA_DATA(tb[RTA_DST])),
 102                                 r->rtm_dst_len
 103                                 );
 104                 } else {
 105                         printf("to %s ", format_host(r->rtm_family,
 106                                                        RTA_PAYLOAD(tb[RTA_DST]),
 107                                                        RTA_DATA(tb[RTA_DST])));
 108                 }
 109         } else if (r->rtm_dst_len) {
 110                 printf("to 0/%d ", r->rtm_dst_len);
 111         }
 112
 113         if (r->rtm_tos) {
 114                 printf("tos %s ", rtnl_dsfield_n2a(r->rtm_tos));
 115         }
 116         if (tb[RTA_PROTOINFO]) {
 117                 printf("fwmark %#x ", *(uint32_t*)RTA_DATA(tb[RTA_PROTOINFO]));
 118         }
 119
 120         if (tb[RTA_IIF]) {
 121                 printf("iif %s ", (char*)RTA_DATA(tb[RTA_IIF]));
 122         }
 123
 124         if (tb[RTA_TABLE])
 125                 printf("lookup %s ", rtnl_rttable_n2a(*(uint32_t*)RTA_DATA(tb[RTA_TABLE])));
 126         else if (r->rtm_table)
 127                 printf("lookup %s ", rtnl_rttable_n2a(r->rtm_table));
 128
 129         if (tb[FRA_SUPPRESS_PREFIXLEN]) {
 130                 int pl = *(uint32_t*)RTA_DATA(tb[FRA_SUPPRESS_PREFIXLEN]);
 131                 if (pl != -1)
 132                         printf("%s %d ", keyword_suppress_prefixlength, pl);
 133         }
 134         if (tb[FRA_SUPPRESS_IFGROUP]) {
 135                 int grp = *(uint32_t*)RTA_DATA(tb[FRA_SUPPRESS_IFGROUP]);
 136                 if (grp != -1)
 137                         printf("%s %d ", keyword_suppress_ifgroup, grp);
 138         }
 139
 140         if (tb[RTA_FLOW]) {
 141                 uint32_t to = *(uint32_t*)RTA_DATA(tb[RTA_FLOW]);
 142                 uint32_t from = to>>16;
 143                 to &= 0xFFFF;
 144                 if (from) {
 145                         printf("realms %s/",
 146                                 rtnl_rtrealm_n2a(from));
 147                 }
 148                 printf("%s ",
 149                         rtnl_rtrealm_n2a(to));
 150         }
 151
 152         if (r->rtm_type == RTN_NAT) {
 153                 if (tb[RTA_GATEWAY]) {
 154                         printf("map-to %s ",
 155                                 format_host(r->rtm_family,
 156                                             RTA_PAYLOAD(tb[RTA_GATEWAY]),
 157                                             RTA_DATA(tb[RTA_GATEWAY]))
 158                         );
 159                 } else
 160                         printf("masquerade");
 161         } else if (r->rtm_type != RTN_UNICAST)
 162                 fputs(rtnl_rtntype_n2a(r->rtm_type), stdout);
 163
 164         bb_putchar('\n');
 165         /*fflush_all();*/
 166         return 0;
 167 }
 168
 169 /* Return value becomes exitcode. It's okay to not return at all */
 170 static int iprule_list(char **argv)
 171 {
 172         struct rtnl_handle rth;
 173         int af = preferred_family;
 174
 175         if (af == AF_UNSPEC)
 176                 af = AF_INET;
 177
 178         if (*argv) {
 179                 //bb_error_msg("\"rule show\" needs no arguments");
 180                 bb_warn_ignoring_args(*argv);
 181                 return -1;
 182         }
 183
 184         xrtnl_open(&rth);
 185
 186         xrtnl_wilddump_request(&rth, af, RTM_GETRULE);
 187         xrtnl_dump_filter(&rth, print_rule, NULL);
 188
 189         return 0;
 190 }
 191
 192 /* Return value becomes exitcode. It's okay to not return at all */
 193 static int iprule_modify(int cmd, char **argv)
 194 {
 195         bool table_ok = 0;
 196         struct rtnl_handle rth;
 197         struct {
 198                 struct nlmsghdr n;
 199                 struct rtmsg    r;
 200                 char            buf[1024];
 201         } req;
 202         smalluint key;
 203
 204         memset(&req, 0, sizeof(req));
 205
 206         req.n.nlmsg_type = cmd;
 207         req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
 208         req.n.nlmsg_flags = NLM_F_REQUEST;
 209         req.r.rtm_family = preferred_family;
 210         req.r.rtm_protocol = RTPROT_BOOT;
 211         if (RT_SCOPE_UNIVERSE != 0)
 212                 req.r.rtm_scope = RT_SCOPE_UNIVERSE;
 213         /*req.r.rtm_table = 0; - already is */
 214         if (RTN_UNSPEC != 0)
 215                 req.r.rtm_type = RTN_UNSPEC;
 216
 217         if (cmd == RTM_NEWRULE) {
 218                 req.n.nlmsg_flags |= NLM_F_CREATE|NLM_F_EXCL;
 219                 req.r.rtm_type = RTN_UNICAST;
 220         }
 221
 222         while (*argv) {
 223                 key = index_in_substrings(keywords, *argv) + 1;
 224                 if (key == 0) /* no match found in keywords array, bail out. */
 225                         invarg_1_to_2(*argv, applet_name);
 226                 if (key == ARG_from) {
 227                         inet_prefix dst;
 228                         NEXT_ARG();
 229                         get_prefix(&dst, *argv, req.r.rtm_family);
 230                         req.r.rtm_src_len = dst.bitlen;
 231                         addattr_l(&req.n, sizeof(req), RTA_SRC, &dst.data, dst.bytelen);
 232                 } else if (key == ARG_to) {
 233                         inet_prefix dst;
 234                         NEXT_ARG();
 235                         get_prefix(&dst, *argv, req.r.rtm_family);
 236                         req.r.rtm_dst_len = dst.bitlen;
 237                         addattr_l(&req.n, sizeof(req), RTA_DST, &dst.data, dst.bytelen);
 238                 } else if (key == ARG_preference ||
 239                            key == ARG_order ||
 240                            key == ARG_priority
 241                 ) {
 242                         uint32_t pref;
 243                         NEXT_ARG();
 244                         pref = get_u32(*argv, keyword_preference);
 245                         addattr32(&req.n, sizeof(req), RTA_PRIORITY, pref);
 246                 } else if (key == ARG_tos) {
 247                         uint32_t tos;
 248                         NEXT_ARG();
 249                         if (rtnl_dsfield_a2n(&tos, *argv))
 250                                 invarg_1_to_2(*argv, "TOS");
 251                         req.r.rtm_tos = tos;
 252                 } else if (key == ARG_fwmark) {
 253                         uint32_t fwmark;
 254                         NEXT_ARG();
 255                         fwmark = get_u32(*argv, keyword_fwmark);
 256                         addattr32(&req.n, sizeof(req), RTA_PROTOINFO, fwmark);
 257                 } else if (key == ARG_realms) {
 258                         uint32_t realm;
 259                         NEXT_ARG();
 260                         if (get_rt_realms(&realm, *argv))
 261                                 invarg_1_to_2(*argv, keyword_realms);
 262                         addattr32(&req.n, sizeof(req), RTA_FLOW, realm);
 263                 } else if (key == ARG_table ||
 264                            key == ARG_lookup
 265                 ) {
 266                         uint32_t tid;
 267                         NEXT_ARG();
 268                         if (rtnl_rttable_a2n(&tid, *argv))
 269                                 invarg_1_to_2(*argv, "table ID");
 270                         if (tid < 256)
 271                                 req.r.rtm_table = tid;
 272                         else {
 273                                 req.r.rtm_table = RT_TABLE_UNSPEC;
 274                                 addattr32(&req.n, sizeof(req), RTA_TABLE, tid);
 275                         }
 276                         table_ok = 1;
 277                 } else if (key == ARG_suppress_prefixlength) {
 278                         int prefix_length;
 279                         NEXT_ARG();
 280                         prefix_length = get_u32(*argv, keyword_suppress_prefixlength);
 281                         addattr32(&req.n, sizeof(req), FRA_SUPPRESS_PREFIXLEN, prefix_length);
 282                 } else if (key == ARG_suppress_ifgroup) {
 283                         int grp;
 284                         NEXT_ARG();
 285                         grp = get_u32(*argv, keyword_suppress_ifgroup);
 286                         addattr32(&req.n, sizeof(req), FRA_SUPPRESS_IFGROUP, grp);
 287                 } else if (key == ARG_dev ||
 288                            key == ARG_iif
 289                 ) {
 290                         NEXT_ARG();
 291                         addattr_l(&req.n, sizeof(req), RTA_IIF, *argv, strlen(*argv)+1);
 292                 } else if (key == ARG_nat ||
 293                            key == ARG_map_to
 294                 ) {
 295                         NEXT_ARG();
 296                         addattr32(&req.n, sizeof(req), RTA_GATEWAY, get_addr32(*argv));
 297                         req.r.rtm_type = RTN_NAT;
 298                 } else {
 299                         int type;
 300
 301                         if (key == ARG_type) {
 302                                 NEXT_ARG();
 303                         }
 304                         if (key == ARG_help)
 305                                 bb_show_usage();
 306                         if (rtnl_rtntype_a2n(&type, *argv))
 307                                 invarg_1_to_2(*argv, "type");
 308                         req.r.rtm_type = type;
 309                 }
 310                 argv++;
 311         }
 312
 313         if (req.r.rtm_family == AF_UNSPEC)
 314                 req.r.rtm_family = AF_INET;
 315
 316         if (!table_ok && cmd == RTM_NEWRULE)
 317                 req.r.rtm_table = RT_TABLE_MAIN;
 318
 319         xrtnl_open(&rth);
 320
 321         if (rtnl_talk(&rth, &req.n, 0, 0, NULL, NULL, NULL) < 0)
 322                 return 2;
 323
 324         return 0;
 325 }
 326
 327 /* Return value becomes exitcode. It's okay to not return at all */
 328 int FAST_FUNC do_iprule(char **argv)
 329 {
 330         static const char ip_rule_commands[] ALIGN1 =
 331                 "add\0""delete\0""list\0""show\0";
 332         if (*argv) {
 333                 int cmd = index_in_substrings(ip_rule_commands, *argv);
 334                 if (cmd < 0)
 335                         invarg_1_to_2(*argv, applet_name);
 336                 argv++;
 337                 if (cmd < 2)
 338                         return iprule_modify((cmd == 0) ? RTM_NEWRULE : RTM_DELRULE, argv);
 339         }
 340         return iprule_list(argv);
 341 }