networking/libiproute/iproute.c

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