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