networking/libiproute/iproute.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * Licensed under GPLv2 or later, see file LICENSE in this source tree.
   4  *
   5  * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
   6  *
   7  * Changes:
   8  *
   9  * Rani Assaf <rani@magic.metawire.com> 980929: resolve addresses
  10  * Kunihiro Ishiguro <kunihiro@zebra.org> 001102: rtnh_ifindex was not initialized
  11  */
  12
  13 #include "ip_common.h"  /* #include "libbb.h" is inside */
  14 #include "rt_names.h"
  15 #include "utils.h"
  16
  17 #ifndef RTAX_RTTVAR
  18 #define RTAX_RTTVAR RTAX_HOPS
  19 #endif
  20
  21
  22 struct filter_t {
  23         int tb;
  24         smallint flushed;
  25         char *flushb;
  26         int flushp;
  27         int flushe;
  28         struct rtnl_handle *rth;
  29         //int protocol, protocolmask; - write-only fields?!
  30         //int scope, scopemask; - unused
  31         //int type; - read-only
  32         //int typemask; - unused
  33         //int tos, tosmask; - unused
  34         int iif;
  35         int oif;
  36         //int realm, realmmask; - unused
  37         //inet_prefix rprefsrc; - read-only
  38         inet_prefix rvia;
  39         inet_prefix rdst;
  40         inet_prefix mdst;
  41         inet_prefix rsrc;
  42         inet_prefix msrc;
  43 } FIX_ALIASING;
  44 typedef struct filter_t filter_t;
  45
  46 #define G_filter (*(filter_t*)&bb_common_bufsiz1)
  47
  48 static int flush_update(void)
  49 {
  50         if (rtnl_send(G_filter.rth, G_filter.flushb, G_filter.flushp) < 0) {
  51                 bb_perror_msg("can't send flush request");
  52                 return -1;
  53         }
  54         G_filter.flushp = 0;
  55         return 0;
  56 }
  57
  58 static unsigned get_hz(void)
  59 {
  60         static unsigned hz_internal;
  61         FILE *fp;
  62
  63         if (hz_internal)
  64                 return hz_internal;
  65
  66         fp = fopen_for_read("/proc/net/psched");
  67         if (fp) {
  68                 unsigned nom, denom;
  69
  70                 if (fscanf(fp, "%*08x%*08x%08x%08x", &nom, &denom) == 2)
  71                         if (nom == 1000000)
  72                                 hz_internal = denom;
  73                 fclose(fp);
  74         }
  75         if (!hz_internal)
  76                 hz_internal = bb_clk_tck();
  77         return hz_internal;
  78 }
  79
  80 static int FAST_FUNC print_route(const struct sockaddr_nl *who UNUSED_PARAM,
  81                 struct nlmsghdr *n, void *arg UNUSED_PARAM)
  82 {
  83         struct rtmsg *r = NLMSG_DATA(n);
  84         int len = n->nlmsg_len;
  85         struct rtattr *tb[RTA_MAX+1];
  86         char abuf[256];
  87         inet_prefix dst;
  88         inet_prefix src;
  89         int host_len = -1;
  90         SPRINT_BUF(b1);
  91
  92         if (n->nlmsg_type != RTM_NEWROUTE && n->nlmsg_type != RTM_DELROUTE) {
  93                 fprintf(stderr, "Not a route: %08x %08x %08x\n",
  94                         n->nlmsg_len, n->nlmsg_type, n->nlmsg_flags);
  95                 return 0;
  96         }
  97         if (G_filter.flushb && n->nlmsg_type != RTM_NEWROUTE)
  98                 return 0;
  99         len -= NLMSG_LENGTH(sizeof(*r));
 100         if (len < 0)
 101                 bb_error_msg_and_die("wrong nlmsg len %d", len);
 102
 103         if (r->rtm_family == AF_INET6)
 104                 host_len = 128;
 105         else if (r->rtm_family == AF_INET)
 106                 host_len = 32;
 107
 108         if (r->rtm_family == AF_INET6) {
 109                 if (G_filter.tb) {
 110                         if (G_filter.tb < 0) {
 111                                 if (!(r->rtm_flags & RTM_F_CLONED)) {
 112                                         return 0;
 113                                 }
 114                         } else {
 115                                 if (r->rtm_flags & RTM_F_CLONED) {
 116                                         return 0;
 117                                 }
 118                                 if (G_filter.tb == RT_TABLE_LOCAL) {
 119                                         if (r->rtm_type != RTN_LOCAL) {
 120                                                 return 0;
 121                                         }
 122                                 } else if (G_filter.tb == RT_TABLE_MAIN) {
 123                                         if (r->rtm_type == RTN_LOCAL) {
 124                                                 return 0;
 125                                         }
 126                                 } else {
 127                                         return 0;
 128                                 }
 129                         }
 130                 }
 131         } else {
 132                 if (G_filter.tb > 0 && G_filter.tb != r->rtm_table) {
 133                         return 0;
 134                 }
 135         }
 136         if (G_filter.rdst.family
 137          && (r->rtm_family != G_filter.rdst.family || G_filter.rdst.bitlen > r->rtm_dst_len)
 138         ) {
 139                 return 0;
 140         }
 141         if (G_filter.mdst.family
 142          && (r->rtm_family != G_filter.mdst.family
 143             || (G_filter.mdst.bitlen >= 0 && G_filter.mdst.bitlen < r->rtm_dst_len)
 144             )
 145         ) {
 146                 return 0;
 147         }
 148         if (G_filter.rsrc.family
 149          && (r->rtm_family != G_filter.rsrc.family || G_filter.rsrc.bitlen > r->rtm_src_len)
 150         ) {
 151                 return 0;
 152         }
 153         if (G_filter.msrc.family
 154          && (r->rtm_family != G_filter.msrc.family
 155             || (G_filter.msrc.bitlen >= 0 && G_filter.msrc.bitlen < r->rtm_src_len)
 156             )
 157         ) {
 158                 return 0;
 159         }
 160
 161         memset(tb, 0, sizeof(tb));
 162         memset(&src, 0, sizeof(src));
 163         memset(&dst, 0, sizeof(dst));
 164         parse_rtattr(tb, RTA_MAX, RTM_RTA(r), len);
 165
 166         if (tb[RTA_SRC]) {
 167                 src.bitlen = r->rtm_src_len;
 168                 src.bytelen = (r->rtm_family == AF_INET6 ? 16 : 4);
 169                 memcpy(src.data, RTA_DATA(tb[RTA_SRC]), src.bytelen);
 170         }
 171         if (tb[RTA_DST]) {
 172                 dst.bitlen = r->rtm_dst_len;
 173                 dst.bytelen = (r->rtm_family == AF_INET6 ? 16 : 4);
 174                 memcpy(dst.data, RTA_DATA(tb[RTA_DST]), dst.bytelen);
 175         }
 176
 177         if (G_filter.rdst.family
 178          && inet_addr_match(&dst, &G_filter.rdst, G_filter.rdst.bitlen)
 179         ) {
 180                 return 0;
 181         }
 182         if (G_filter.mdst.family
 183          && G_filter.mdst.bitlen >= 0
 184          && inet_addr_match(&dst, &G_filter.mdst, r->rtm_dst_len)
 185         ) {
 186                 return 0;
 187         }
 188         if (G_filter.rsrc.family
 189          && inet_addr_match(&src, &G_filter.rsrc, G_filter.rsrc.bitlen)
 190         ) {
 191                 return 0;
 192         }
 193         if (G_filter.msrc.family && G_filter.msrc.bitlen >= 0
 194          && inet_addr_match(&src, &G_filter.msrc, r->rtm_src_len)
 195         ) {
 196                 return 0;
 197         }
 198         if (G_filter.oif != 0) {
 199                 if (!tb[RTA_OIF])
 200                         return 0;
 201                 if (G_filter.oif != *(int*)RTA_DATA(tb[RTA_OIF]))
 202                         return 0;
 203         }
 204
 205         if (G_filter.flushb) {
 206                 struct nlmsghdr *fn;
 207
 208                 /* We are creating route flush commands */
 209
 210                 if (r->rtm_family == AF_INET6
 211                  && r->rtm_dst_len == 0
 212                  && r->rtm_type == RTN_UNREACHABLE
 213                  && tb[RTA_PRIORITY]
 214                  && *(int*)RTA_DATA(tb[RTA_PRIORITY]) == -1
 215                 ) {
 216                         return 0;
 217                 }
 218
 219                 if (NLMSG_ALIGN(G_filter.flushp) + n->nlmsg_len > G_filter.flushe) {
 220                         if (flush_update())
 221                                 bb_error_msg_and_die("flush");
 222                 }
 223                 fn = (void*)(G_filter.flushb + NLMSG_ALIGN(G_filter.flushp));
 224                 memcpy(fn, n, n->nlmsg_len);
 225                 fn->nlmsg_type = RTM_DELROUTE;
 226                 fn->nlmsg_flags = NLM_F_REQUEST;
 227                 fn->nlmsg_seq = ++G_filter.rth->seq;
 228                 G_filter.flushp = (((char*)fn) + n->nlmsg_len) - G_filter.flushb;
 229                 G_filter.flushed = 1;
 230                 return 0;
 231         }
 232
 233         /* We are printing routes */
 234
 235         if (n->nlmsg_type == RTM_DELROUTE) {
 236                 printf("Deleted ");
 237         }
 238         if (r->rtm_type != RTN_UNICAST /* && !G_filter.type - always 0 */) {
 239                 printf("%s ", rtnl_rtntype_n2a(r->rtm_type, b1));
 240         }
 241
 242         if (tb[RTA_DST]) {
 243                 if (r->rtm_dst_len != host_len) {
 244                         printf("%s/%u ", rt_addr_n2a(r->rtm_family,
 245                                                 RTA_DATA(tb[RTA_DST]),
 246                                                 abuf, sizeof(abuf)),
 247                                         r->rtm_dst_len
 248                                         );
 249                 } else {
 250                         printf("%s ", format_host(r->rtm_family,
 251                                                 RTA_PAYLOAD(tb[RTA_DST]),
 252                                                 RTA_DATA(tb[RTA_DST]),
 253                                                 abuf, sizeof(abuf))
 254                                         );
 255                 }
 256         } else if (r->rtm_dst_len) {
 257                 printf("0/%d ", r->rtm_dst_len);
 258         } else {
 259                 printf("default ");
 260         }
 261         if (tb[RTA_SRC]) {
 262                 if (r->rtm_src_len != host_len) {
 263                         printf("from %s/%u ", rt_addr_n2a(r->rtm_family,
 264                                                 RTA_DATA(tb[RTA_SRC]),
 265                                                 abuf, sizeof(abuf)),
 266                                         r->rtm_src_len
 267                                         );
 268                 } else {
 269                         printf("from %s ", format_host(r->rtm_family,
 270                                                 RTA_PAYLOAD(tb[RTA_SRC]),
 271                                                 RTA_DATA(tb[RTA_SRC]),
 272                                                 abuf, sizeof(abuf))
 273                                         );
 274                 }
 275         } else if (r->rtm_src_len) {
 276                 printf("from 0/%u ", r->rtm_src_len);
 277         }
 278         if (tb[RTA_GATEWAY] && G_filter.rvia.bitlen != host_len) {
 279                 printf("via %s ", format_host(r->rtm_family,
 280                                         RTA_PAYLOAD(tb[RTA_GATEWAY]),
 281                                         RTA_DATA(tb[RTA_GATEWAY]),
 282                                         abuf, sizeof(abuf)));
 283         }
 284         if (tb[RTA_OIF]) {
 285                 printf("dev %s ", ll_index_to_name(*(int*)RTA_DATA(tb[RTA_OIF])));
 286         }
 287
 288         /* Todo: parse & show "proto kernel", "scope link" here */
 289
 290         if (tb[RTA_PREFSRC] && /*G_filter.rprefsrc.bitlen - always 0*/ 0 != host_len) {
 291                 /* Do not use format_host(). It is our local addr
 292                    and symbolic name will not be useful.
 293                  */
 294                 printf(" src %s ", rt_addr_n2a(r->rtm_family,
 295                                         RTA_DATA(tb[RTA_PREFSRC]),
 296                                         abuf, sizeof(abuf)));
 297         }
 298         if (tb[RTA_PRIORITY]) {
 299                 printf(" metric %d ", *(uint32_t*)RTA_DATA(tb[RTA_PRIORITY]));
 300         }
 301         if (r->rtm_flags & RTNH_F_DEAD) {
 302                 printf("dead ");
 303         }
 304         if (r->rtm_flags & RTNH_F_ONLINK) {
 305                 printf("onlink ");
 306         }
 307         if (r->rtm_flags & RTNH_F_PERVASIVE) {
 308                 printf("pervasive ");
 309         }
 310         if (r->rtm_flags & RTM_F_NOTIFY) {
 311                 printf("notify ");
 312         }
 313
 314         if (r->rtm_family == AF_INET6) {
 315                 struct rta_cacheinfo *ci = NULL;
 316                 if (tb[RTA_CACHEINFO]) {
 317                         ci = RTA_DATA(tb[RTA_CACHEINFO]);
 318                 }
 319                 if ((r->rtm_flags & RTM_F_CLONED) || (ci && ci->rta_expires)) {
 320                         if (r->rtm_flags & RTM_F_CLONED) {
 321                                 printf("%c    cache ", _SL_);
 322                         }
 323                         if (ci->rta_expires) {
 324                                 printf(" expires %dsec", ci->rta_expires / get_hz());
 325                         }
 326                         if (ci->rta_error != 0) {
 327                                 printf(" error %d", ci->rta_error);
 328                         }
 329                 } else if (ci) {
 330                         if (ci->rta_error != 0)
 331                                 printf(" error %d", ci->rta_error);
 332                 }
 333         }
 334         if (tb[RTA_IIF] && G_filter.iif == 0) {
 335                 printf(" iif %s", ll_index_to_name(*(int*)RTA_DATA(tb[RTA_IIF])));
 336         }
 337         bb_putchar('\n');
 338         return 0;
 339 }
 340
 341 /* Return value becomes exitcode. It's okay to not return at all */
 342 static int iproute_modify(int cmd, unsigned flags, char **argv)
 343 {
 344         static const char keywords[] ALIGN1 =
 345                 "src\0""via\0""mtu\0""lock\0""protocol\0"IF_FEATURE_IP_RULE("table\0")
 346                 "dev\0""oif\0""to\0""metric\0""onlink\0";
 347         enum {
 348                 ARG_src,
 349                 ARG_via,
 350                 ARG_mtu, PARM_lock,
 351                 ARG_protocol,
 352 IF_FEATURE_IP_RULE(ARG_table,)
 353                 ARG_dev,
 354                 ARG_oif,
 355                 ARG_to,
 356                 ARG_metric,
 357                 ARG_onlink,
 358         };
 359         enum {
 360                 gw_ok = 1 << 0,
 361                 dst_ok = 1 << 1,
 362                 proto_ok = 1 << 2,
 363                 type_ok = 1 << 3
 364         };
 365         struct rtnl_handle rth;
 366         struct {
 367                 struct nlmsghdr n;
 368                 struct rtmsg    r;
 369                 char            buf[1024];
 370         } req;
 371         char mxbuf[256];
 372         struct rtattr * mxrta = (void*)mxbuf;
 373         unsigned mxlock = 0;
 374         char *d = NULL;
 375         smalluint ok = 0;
 376         int arg;
 377
 378         memset(&req, 0, sizeof(req));
 379
 380         req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
 381         req.n.nlmsg_flags = NLM_F_REQUEST | flags;
 382         req.n.nlmsg_type = cmd;
 383         req.r.rtm_family = preferred_family;
 384         if (RT_TABLE_MAIN) /* if it is zero, memset already did it */
 385                 req.r.rtm_table = RT_TABLE_MAIN;
 386         if (RT_SCOPE_NOWHERE)
 387                 req.r.rtm_scope = RT_SCOPE_NOWHERE;
 388
 389         if (cmd != RTM_DELROUTE) {
 390                 req.r.rtm_protocol = RTPROT_BOOT;
 391                 req.r.rtm_scope = RT_SCOPE_UNIVERSE;
 392                 req.r.rtm_type = RTN_UNICAST;
 393         }
 394
 395         mxrta->rta_type = RTA_METRICS;
 396         mxrta->rta_len = RTA_LENGTH(0);
 397
 398         while (*argv) {
 399                 arg = index_in_substrings(keywords, *argv);
 400                 if (arg == ARG_src) {
 401                         inet_prefix addr;
 402                         NEXT_ARG();
 403                         get_addr(&addr, *argv, req.r.rtm_family);
 404                         if (req.r.rtm_family == AF_UNSPEC)
 405                                 req.r.rtm_family = addr.family;
 406                         addattr_l(&req.n, sizeof(req), RTA_PREFSRC, &addr.data, addr.bytelen);
 407                 } else if (arg == ARG_via) {
 408                         inet_prefix addr;
 409                         ok |= gw_ok;
 410                         NEXT_ARG();
 411                         get_addr(&addr, *argv, req.r.rtm_family);
 412                         if (req.r.rtm_family == AF_UNSPEC) {
 413                                 req.r.rtm_family = addr.family;
 414                         }
 415                         addattr_l(&req.n, sizeof(req), RTA_GATEWAY, &addr.data, addr.bytelen);
 416                 } else if (arg == ARG_mtu) {
 417                         unsigned mtu;
 418                         NEXT_ARG();
 419                         if (index_in_strings(keywords, *argv) == PARM_lock) {
 420                                 mxlock |= (1 << RTAX_MTU);
 421                                 NEXT_ARG();
 422                         }
 423                         mtu = get_unsigned(*argv, "mtu");
 424                         rta_addattr32(mxrta, sizeof(mxbuf), RTAX_MTU, mtu);
 425                 } else if (arg == ARG_protocol) {
 426                         uint32_t prot;
 427                         NEXT_ARG();
 428                         if (rtnl_rtprot_a2n(&prot, *argv))
 429                                 invarg(*argv, "protocol");
 430                         req.r.rtm_protocol = prot;
 431                         ok |= proto_ok;
 432 #if ENABLE_FEATURE_IP_RULE
 433                 } else if (arg == ARG_table) {
 434                         uint32_t tid;
 435                         NEXT_ARG();
 436                         if (rtnl_rttable_a2n(&tid, *argv))
 437                                 invarg(*argv, "table");
 438                         req.r.rtm_table = tid;
 439 #endif
 440                 } else if (arg == ARG_dev || arg == ARG_oif) {
 441                         NEXT_ARG();
 442                         d = *argv;
 443                 } else if (arg == ARG_metric) {
 444                         uint32_t metric;
 445                         NEXT_ARG();
 446                         metric = get_u32(*argv, "metric");
 447                         addattr32(&req.n, sizeof(req), RTA_PRIORITY, metric);
 448                 } else if (arg == ARG_onlink) {
 449                         req.r.rtm_flags |= RTNH_F_ONLINK;
 450                 } else {
 451                         int type;
 452                         inet_prefix dst;
 453
 454                         if (arg == ARG_to) {
 455                                 NEXT_ARG();
 456                         }
 457                         if ((**argv < '0' || **argv > '9')
 458                          && rtnl_rtntype_a2n(&type, *argv) == 0
 459                         ) {
 460                                 NEXT_ARG();
 461                                 req.r.rtm_type = type;
 462                                 ok |= type_ok;
 463                         }
 464
 465                         if (ok & dst_ok) {
 466                                 duparg2("to", *argv);
 467                         }
 468                         get_prefix(&dst, *argv, req.r.rtm_family);
 469                         if (req.r.rtm_family == AF_UNSPEC) {
 470                                 req.r.rtm_family = dst.family;
 471                         }
 472                         req.r.rtm_dst_len = dst.bitlen;
 473                         ok |= dst_ok;
 474                         if (dst.bytelen) {
 475                                 addattr_l(&req.n, sizeof(req), RTA_DST, &dst.data, dst.bytelen);
 476                         }
 477                 }
 478                 argv++;
 479         }
 480
 481         xrtnl_open(&rth);
 482
 483         if (d)  {
 484                 int idx;
 485
 486                 ll_init_map(&rth);
 487
 488                 if (d) {
 489                         idx = xll_name_to_index(d);
 490                         addattr32(&req.n, sizeof(req), RTA_OIF, idx);
 491                 }
 492         }
 493
 494         if (mxrta->rta_len > RTA_LENGTH(0)) {
 495                 if (mxlock) {
 496                         rta_addattr32(mxrta, sizeof(mxbuf), RTAX_LOCK, mxlock);
 497                 }
 498                 addattr_l(&req.n, sizeof(req), RTA_METRICS, RTA_DATA(mxrta), RTA_PAYLOAD(mxrta));
 499         }
 500
 501         if (req.r.rtm_type == RTN_LOCAL || req.r.rtm_type == RTN_NAT)
 502                 req.r.rtm_scope = RT_SCOPE_HOST;
 503         else
 504         if (req.r.rtm_type == RTN_BROADCAST
 505          || req.r.rtm_type == RTN_MULTICAST
 506          || req.r.rtm_type == RTN_ANYCAST
 507         ) {
 508                 req.r.rtm_scope = RT_SCOPE_LINK;
 509         }
 510         else if (req.r.rtm_type == RTN_UNICAST || req.r.rtm_type == RTN_UNSPEC) {
 511                 if (cmd == RTM_DELROUTE)
 512                         req.r.rtm_scope = RT_SCOPE_NOWHERE;
 513                 else if (!(ok & gw_ok))
 514                         req.r.rtm_scope = RT_SCOPE_LINK;
 515         }
 516
 517         if (req.r.rtm_family == AF_UNSPEC) {
 518                 req.r.rtm_family = AF_INET;
 519         }
 520
 521         if (rtnl_talk(&rth, &req.n, 0, 0, NULL, NULL, NULL) < 0) {
 522                 return 2;
 523         }
 524
 525         return 0;
 526 }
 527
 528 static int rtnl_rtcache_request(struct rtnl_handle *rth, int family)
 529 {
 530         struct {
 531                 struct nlmsghdr nlh;
 532                 struct rtmsg rtm;
 533         } req;
 534         struct sockaddr_nl nladdr;
 535
 536         memset(&nladdr, 0, sizeof(nladdr));
 537         memset(&req, 0, sizeof(req));
 538         nladdr.nl_family = AF_NETLINK;
 539
 540         req.nlh.nlmsg_len = sizeof(req);
 541         if (RTM_GETROUTE)
 542                 req.nlh.nlmsg_type = RTM_GETROUTE;
 543         if (NLM_F_ROOT | NLM_F_REQUEST)
 544                 req.nlh.nlmsg_flags = NLM_F_ROOT | NLM_F_REQUEST;
 545         /*req.nlh.nlmsg_pid = 0; - memset did it already */
 546         req.nlh.nlmsg_seq = rth->dump = ++rth->seq;
 547         req.rtm.rtm_family = family;
 548         if (RTM_F_CLONED)
 549                 req.rtm.rtm_flags = RTM_F_CLONED;
 550
 551         return xsendto(rth->fd, (void*)&req, sizeof(req), (struct sockaddr*)&nladdr, sizeof(nladdr));
 552 }
 553
 554 static void iproute_flush_cache(void)
 555 {
 556         static const char fn[] ALIGN1 = "/proc/sys/net/ipv4/route/flush";
 557         int flush_fd = open_or_warn(fn, O_WRONLY);
 558
 559         if (flush_fd < 0) {
 560                 return;
 561         }
 562
 563         if (write(flush_fd, "-1", 2) < 2) {
 564                 bb_perror_msg("can't flush routing cache");
 565                 return;
 566         }
 567         close(flush_fd);
 568 }
 569
 570 static void iproute_reset_filter(void)
 571 {
 572         memset(&G_filter, 0, sizeof(G_filter));
 573         G_filter.mdst.bitlen = -1;
 574         G_filter.msrc.bitlen = -1;
 575 }
 576
 577 /* Return value becomes exitcode. It's okay to not return at all */
 578 static int iproute_list_or_flush(char **argv, int flush)
 579 {
 580         int do_ipv6 = preferred_family;
 581         struct rtnl_handle rth;
 582         char *id = NULL;
 583         char *od = NULL;
 584         static const char keywords[] ALIGN1 =
 585                 /* "ip route list/flush" parameters: */
 586                 "protocol\0" "dev\0"   "oif\0"   "iif\0"
 587                 "via\0"      "table\0" "cache\0"
 588                 "from\0"     "to\0"
 589                 /* and possible further keywords */
 590                 "all\0"
 591                 "root\0"
 592                 "match\0"
 593                 "exact\0"
 594                 "main\0"
 595                 ;
 596         enum {
 597                 KW_proto, KW_dev,   KW_oif,  KW_iif,
 598                 KW_via,   KW_table, KW_cache,
 599                 KW_from,  KW_to,
 600                 /* */
 601                 KW_all,
 602                 KW_root,
 603                 KW_match,
 604                 KW_exact,
 605                 KW_main,
 606         };
 607         int arg, parm;
 608
 609         iproute_reset_filter();
 610         G_filter.tb = RT_TABLE_MAIN;
 611
 612         if (flush && !*argv)
 613                 bb_error_msg_and_die(bb_msg_requires_arg, "\"ip route flush\"");
 614
 615         while (*argv) {
 616                 arg = index_in_substrings(keywords, *argv);
 617                 if (arg == KW_proto) {
 618                         uint32_t prot = 0;
 619                         NEXT_ARG();
 620                         //G_filter.protocolmask = -1;
 621                         if (rtnl_rtprot_a2n(&prot, *argv)) {
 622                                 if (index_in_strings(keywords, *argv) != KW_all)
 623                                         invarg(*argv, "protocol");
 624                                 prot = 0;
 625                                 //G_filter.protocolmask = 0;
 626                         }
 627                         //G_filter.protocol = prot;
 628                 } else if (arg == KW_dev || arg == KW_oif) {
 629                         NEXT_ARG();
 630                         od = *argv;
 631                 } else if (arg == KW_iif) {
 632                         NEXT_ARG();
 633                         id = *argv;
 634                 } else if (arg == KW_via) {
 635                         NEXT_ARG();
 636                         get_prefix(&G_filter.rvia, *argv, do_ipv6);
 637                 } else if (arg == KW_table) { /* table all/cache/main */
 638                         NEXT_ARG();
 639                         parm = index_in_substrings(keywords, *argv);
 640                         if (parm == KW_cache)
 641                                 G_filter.tb = -1;
 642                         else if (parm == KW_all)
 643                                 G_filter.tb = 0;
 644                         else if (parm != KW_main) {
 645 #if ENABLE_FEATURE_IP_RULE
 646                                 uint32_t tid;
 647                                 if (rtnl_rttable_a2n(&tid, *argv))
 648                                         invarg(*argv, "table");
 649                                 G_filter.tb = tid;
 650 #else
 651                                 invarg(*argv, "table");
 652 #endif
 653                         }
 654                 } else if (arg == KW_cache) {
 655                         /* The command 'ip route flush cache' is used by OpenSWAN.
 656                          * Assuming it's a synonym for 'ip route flush table cache' */
 657                         G_filter.tb = -1;
 658                 } else if (arg == KW_from) {
 659                         NEXT_ARG();
 660                         parm = index_in_substrings(keywords, *argv);
 661                         if (parm == KW_root) {
 662                                 NEXT_ARG();
 663                                 get_prefix(&G_filter.rsrc, *argv, do_ipv6);
 664                         } else if (parm == KW_match) {
 665                                 NEXT_ARG();
 666                                 get_prefix(&G_filter.msrc, *argv, do_ipv6);
 667                         } else {
 668                                 if (parm == KW_exact)
 669                                         NEXT_ARG();
 670                                 get_prefix(&G_filter.msrc, *argv, do_ipv6);
 671                                 G_filter.rsrc = G_filter.msrc;
 672                         }
 673                 } else { /* "to" is the default parameter */
 674                         if (arg == KW_to) {
 675                                 NEXT_ARG();
 676                                 arg = index_in_substrings(keywords, *argv);
 677                         }
 678                         /* parm = arg; - would be more plausible, but we reuse 'arg' here */
 679                         if (arg == KW_root) {
 680                                 NEXT_ARG();
 681                                 get_prefix(&G_filter.rdst, *argv, do_ipv6);
 682                         } else if (arg == KW_match) {
 683                                 NEXT_ARG();
 684                                 get_prefix(&G_filter.mdst, *argv, do_ipv6);
 685                         } else { /* "to exact" is the default */
 686                                 if (arg == KW_exact)
 687                                         NEXT_ARG();
 688                                 get_prefix(&G_filter.mdst, *argv, do_ipv6);
 689                                 G_filter.rdst = G_filter.mdst;
 690                         }
 691                 }
 692                 argv++;
 693         }
 694
 695         if (do_ipv6 == AF_UNSPEC && G_filter.tb) {
 696                 do_ipv6 = AF_INET;
 697         }
 698
 699         xrtnl_open(&rth);
 700         ll_init_map(&rth);
 701
 702         if (id || od)  {
 703                 int idx;
 704
 705                 if (id) {
 706                         idx = xll_name_to_index(id);
 707                         G_filter.iif = idx;
 708                 }
 709                 if (od) {
 710                         idx = xll_name_to_index(od);
 711                         G_filter.oif = idx;
 712                 }
 713         }
 714
 715         if (flush) {
 716                 char flushb[4096-512];
 717
 718                 if (G_filter.tb == -1) { /* "flush table cache" */
 719                         if (do_ipv6 != AF_INET6)
 720                                 iproute_flush_cache();
 721                         if (do_ipv6 == AF_INET)
 722                                 return 0;
 723                 }
 724
 725                 G_filter.flushb = flushb;
 726                 G_filter.flushp = 0;
 727                 G_filter.flushe = sizeof(flushb);
 728                 G_filter.rth = &rth;
 729
 730                 for (;;) {
 731                         xrtnl_wilddump_request(&rth, do_ipv6, RTM_GETROUTE);
 732                         G_filter.flushed = 0;
 733                         xrtnl_dump_filter(&rth, print_route, NULL);
 734                         if (G_filter.flushed == 0)
 735                                 return 0;
 736                         if (flush_update())
 737                                 return 1;
 738                 }
 739         }
 740
 741         if (G_filter.tb != -1) {
 742                 xrtnl_wilddump_request(&rth, do_ipv6, RTM_GETROUTE);
 743         } else if (rtnl_rtcache_request(&rth, do_ipv6) < 0) {
 744                 bb_perror_msg_and_die("can't send dump request");
 745         }
 746         xrtnl_dump_filter(&rth, print_route, NULL);
 747
 748         return 0;
 749 }
 750
 751
 752 /* Return value becomes exitcode. It's okay to not return at all */
 753 static int iproute_get(char **argv)
 754 {
 755         struct rtnl_handle rth;
 756         struct {
 757                 struct nlmsghdr n;
 758                 struct rtmsg    r;
 759                 char            buf[1024];
 760         } req;
 761         char *idev = NULL;
 762         char *odev = NULL;
 763         bool connected = 0;
 764         bool from_ok = 0;
 765         static const char options[] ALIGN1 =
 766                 "from\0""iif\0""oif\0""dev\0""notify\0""connected\0""to\0";
 767
 768         memset(&req, 0, sizeof(req));
 769
 770         iproute_reset_filter();
 771
 772         req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
 773         if (NLM_F_REQUEST)
 774                 req.n.nlmsg_flags = NLM_F_REQUEST;
 775         if (RTM_GETROUTE)
 776                 req.n.nlmsg_type = RTM_GETROUTE;
 777         req.r.rtm_family = preferred_family;
 778         /*req.r.rtm_table = 0; - memset did this already */
 779         /*req.r.rtm_protocol = 0;*/
 780         /*req.r.rtm_scope = 0;*/
 781         /*req.r.rtm_type = 0;*/
 782         /*req.r.rtm_src_len = 0;*/
 783         /*req.r.rtm_dst_len = 0;*/
 784         /*req.r.rtm_tos = 0;*/
 785
 786         while (*argv) {
 787                 switch (index_in_strings(options, *argv)) {
 788                         case 0: /* from */
 789                         {
 790                                 inet_prefix addr;
 791                                 NEXT_ARG();
 792                                 from_ok = 1;
 793                                 get_prefix(&addr, *argv, req.r.rtm_family);
 794                                 if (req.r.rtm_family == AF_UNSPEC) {
 795                                         req.r.rtm_family = addr.family;
 796                                 }
 797                                 if (addr.bytelen) {
 798                                         addattr_l(&req.n, sizeof(req), RTA_SRC, &addr.data, addr.bytelen);
 799                                 }
 800                                 req.r.rtm_src_len = addr.bitlen;
 801                                 break;
 802                         }
 803                         case 1: /* iif */
 804                                 NEXT_ARG();
 805                                 idev = *argv;
 806                                 break;
 807                         case 2: /* oif */
 808                         case 3: /* dev */
 809                                 NEXT_ARG();
 810                                 odev = *argv;
 811                                 break;
 812                         case 4: /* notify */
 813                                 req.r.rtm_flags |= RTM_F_NOTIFY;
 814                                 break;
 815                         case 5: /* connected */
 816                                 connected = 1;
 817                                 break;
 818                         case 6: /* to */
 819                                 NEXT_ARG();
 820                         default:
 821                         {
 822                                 inet_prefix addr;
 823                                 get_prefix(&addr, *argv, req.r.rtm_family);
 824                                 if (req.r.rtm_family == AF_UNSPEC) {
 825                                         req.r.rtm_family = addr.family;
 826                                 }
 827                                 if (addr.bytelen) {
 828                                         addattr_l(&req.n, sizeof(req), RTA_DST, &addr.data, addr.bytelen);
 829                                 }
 830                                 req.r.rtm_dst_len = addr.bitlen;
 831                         }
 832                 }
 833                 argv++;
 834         }
 835
 836         if (req.r.rtm_dst_len == 0) {
 837                 bb_error_msg_and_die("need at least destination address");
 838         }
 839
 840         xrtnl_open(&rth);
 841
 842         ll_init_map(&rth);
 843
 844         if (idev || odev)  {
 845                 int idx;
 846
 847                 if (idev) {
 848                         idx = xll_name_to_index(idev);
 849                         addattr32(&req.n, sizeof(req), RTA_IIF, idx);
 850                 }
 851                 if (odev) {
 852                         idx = xll_name_to_index(odev);
 853                         addattr32(&req.n, sizeof(req), RTA_OIF, idx);
 854                 }
 855         }
 856
 857         if (req.r.rtm_family == AF_UNSPEC) {
 858                 req.r.rtm_family = AF_INET;
 859         }
 860
 861         if (rtnl_talk(&rth, &req.n, 0, 0, &req.n, NULL, NULL) < 0) {
 862                 return 2;
 863         }
 864
 865         if (connected && !from_ok) {
 866                 struct rtmsg *r = NLMSG_DATA(&req.n);
 867                 int len = req.n.nlmsg_len;
 868                 struct rtattr * tb[RTA_MAX+1];
 869
 870                 print_route(NULL, &req.n, NULL);
 871
 872                 if (req.n.nlmsg_type != RTM_NEWROUTE) {
 873                         bb_error_msg_and_die("not a route?");
 874                 }
 875                 len -= NLMSG_LENGTH(sizeof(*r));
 876                 if (len < 0) {
 877                         bb_error_msg_and_die("wrong len %d", len);
 878                 }
 879
 880                 memset(tb, 0, sizeof(tb));
 881                 parse_rtattr(tb, RTA_MAX, RTM_RTA(r), len);
 882
 883                 if (tb[RTA_PREFSRC]) {
 884                         tb[RTA_PREFSRC]->rta_type = RTA_SRC;
 885                         r->rtm_src_len = 8*RTA_PAYLOAD(tb[RTA_PREFSRC]);
 886                 } else if (!tb[RTA_SRC]) {
 887                         bb_error_msg_and_die("can't connect the route");
 888                 }
 889                 if (!odev && tb[RTA_OIF]) {
 890                         tb[RTA_OIF]->rta_type = 0;
 891                 }
 892                 if (tb[RTA_GATEWAY]) {
 893                         tb[RTA_GATEWAY]->rta_type = 0;
 894                 }
 895                 if (!idev && tb[RTA_IIF]) {
 896                         tb[RTA_IIF]->rta_type = 0;
 897                 }
 898                 req.n.nlmsg_flags = NLM_F_REQUEST;
 899                 req.n.nlmsg_type = RTM_GETROUTE;
 900
 901                 if (rtnl_talk(&rth, &req.n, 0, 0, &req.n, NULL, NULL) < 0) {
 902                         return 2;
 903                 }
 904         }
 905         print_route(NULL, &req.n, NULL);
 906         return 0;
 907 }
 908
 909 /* Return value becomes exitcode. It's okay to not return at all */
 910 int FAST_FUNC do_iproute(char **argv)
 911 {
 912         static const char ip_route_commands[] ALIGN1 =
 913         /*0-3*/ "add\0""append\0""change\0""chg\0"
 914         /*4-7*/ "delete\0""get\0""list\0""show\0"
 915         /*8..*/ "prepend\0""replace\0""test\0""flush\0";
 916         int command_num;
 917         unsigned flags = 0;
 918         int cmd = RTM_NEWROUTE;
 919
 920         if (!*argv)
 921                 return iproute_list_or_flush(argv, 0);
 922
 923         /* "Standard" 'ip r a' treats 'a' as 'add', not 'append' */
 924         /* It probably means that it is using "first match" rule */
 925         command_num = index_in_substrings(ip_route_commands, *argv);
 926
 927         switch (command_num) {
 928                 case 0: /* add */
 929                         flags = NLM_F_CREATE|NLM_F_EXCL;
 930                         break;
 931                 case 1: /* append */
 932                         flags = NLM_F_CREATE|NLM_F_APPEND;
 933                         break;
 934                 case 2: /* change */
 935                 case 3: /* chg */
 936                         flags = NLM_F_REPLACE;
 937                         break;
 938                 case 4: /* delete */
 939                         cmd = RTM_DELROUTE;
 940                         break;
 941                 case 5: /* get */
 942                         return iproute_get(argv+1);
 943                 case 6: /* list */
 944                 case 7: /* show */
 945                         return iproute_list_or_flush(argv+1, 0);
 946                 case 8: /* prepend */
 947                         flags = NLM_F_CREATE;
 948                         break;
 949                 case 9: /* replace */
 950                         flags = NLM_F_CREATE|NLM_F_REPLACE;
 951                         break;
 952                 case 10: /* test */
 953                         flags = NLM_F_EXCL;
 954                         break;
 955                 case 11: /* flush */
 956                         return iproute_list_or_flush(argv+1, 1);
 957                 default:
 958                         bb_error_msg_and_die("unknown command %s", *argv);
 959         }
 960
 961         return iproute_modify(cmd, flags, argv+1);
 962 }