networking/route.c

   1 /* vi: set sw=4 ts=4: */
   2 /* route
   3  *
   4  * Similar to the standard Unix route, but with only the necessary
   5  * parts for AF_INET and AF_INET6
   6  *
   7  * Bjorn Wesen, Axis Communications AB
   8  *
   9  * Author of the original route:
  10  *              Fred N. van Kempen, <waltje@uwalt.nl.mugnet.org>
  11  *              (derived from FvK's 'route.c     1.70    01/04/94')
  12  *
  13  * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  14  *
  15  *
  16  * displayroute() code added by Vladimir N. Oleynik <dzo@simtreas.ru>
  17  * adjustments by Larry Doolittle  <LRDoolittle@lbl.gov>
  18  *
  19  * IPV6 support added by Bart Visscher <magick@linux-fan.com>
  20  */
  21
  22 /* 2004/03/09  Manuel Novoa III <mjn3@codepoet.org>
  23  *
  24  * Rewritten to fix several bugs, add additional error checking, and
  25  * remove ridiculous amounts of bloat.
  26  */
  27
  28 //usage:#define route_trivial_usage
  29 //usage:       "[{add|del|delete}]"
  30 //usage:#define route_full_usage "\n\n"
  31 //usage:       "Edit kernel routing tables\n"
  32 //usage:     "\n        -n      Don't resolve names"
  33 //usage:     "\n        -e      Display other/more information"
  34 //usage:     "\n        -A inet" IF_FEATURE_IPV6("{6}") "       Select address family"
  35
  36 #include <net/route.h>
  37 #include <net/if.h>
  38
  39 #include "libbb.h"
  40 #include "inet_common.h"
  41
  42
  43 #ifndef RTF_UP
  44 /* Keep this in sync with /usr/src/linux/include/linux/route.h */
  45 #define RTF_UP          0x0001  /* route usable                 */
  46 #define RTF_GATEWAY     0x0002  /* destination is a gateway     */
  47 #define RTF_HOST        0x0004  /* host entry (net otherwise)   */
  48 #define RTF_REINSTATE   0x0008  /* reinstate route after tmout  */
  49 #define RTF_DYNAMIC     0x0010  /* created dyn. (by redirect)   */
  50 #define RTF_MODIFIED    0x0020  /* modified dyn. (by redirect)  */
  51 #define RTF_MTU         0x0040  /* specific MTU for this route  */
  52 #ifndef RTF_MSS
  53 #define RTF_MSS         RTF_MTU /* Compatibility :-(            */
  54 #endif
  55 #define RTF_WINDOW      0x0080  /* per route window clamping    */
  56 #define RTF_IRTT        0x0100  /* Initial round trip time      */
  57 #define RTF_REJECT      0x0200  /* Reject route                 */
  58 #endif
  59
  60 #if defined(SIOCADDRTOLD) || defined(RTF_IRTT)  /* route */
  61 #define HAVE_NEW_ADDRT 1
  62 #endif
  63
  64 #if HAVE_NEW_ADDRT
  65 #define mask_in_addr(x) (((struct sockaddr_in *)&((x).rt_genmask))->sin_addr.s_addr)
  66 #define full_mask(x) (x)
  67 #else
  68 #define mask_in_addr(x) ((x).rt_genmask)
  69 #define full_mask(x) (((struct sockaddr_in *)&(x))->sin_addr.s_addr)
  70 #endif
  71
  72 /* The RTACTION entries must agree with tbl_verb[] below! */
  73 #define RTACTION_ADD 1
  74 #define RTACTION_DEL 2
  75
  76 /* For the various tbl_*[] arrays, the 1st byte is the offset to
  77  * the next entry and the 2nd byte is return value. */
  78
  79 #define NET_FLAG  1
  80 #define HOST_FLAG 2
  81
  82 /* We remap '-' to '#' to avoid problems with getopt. */
  83 static const char tbl_hash_net_host[] ALIGN1 =
  84         "\007\001#net\0"
  85 /*      "\010\002#host\0" */
  86         "\007\002#host"                         /* Since last, we can save a byte. */
  87 ;
  88
  89 #define KW_TAKES_ARG            020
  90 #define KW_SETS_FLAG            040
  91
  92 #define KW_IPVx_METRIC          020
  93 #define KW_IPVx_NETMASK         021
  94 #define KW_IPVx_GATEWAY         022
  95 #define KW_IPVx_MSS             023
  96 #define KW_IPVx_WINDOW          024
  97 #define KW_IPVx_IRTT            025
  98 #define KW_IPVx_DEVICE          026
  99
 100 #define KW_IPVx_FLAG_ONLY       040
 101 #define KW_IPVx_REJECT          040
 102 #define KW_IPVx_MOD             041
 103 #define KW_IPVx_DYN             042
 104 #define KW_IPVx_REINSTATE       043
 105
 106 static const char tbl_ipvx[] ALIGN1 =
 107         /* 020 is the "takes an arg" bit */
 108 #if HAVE_NEW_ADDRT
 109         "\011\020metric\0"
 110 #endif
 111         "\012\021netmask\0"
 112         "\005\022gw\0"
 113         "\012\022gateway\0"
 114         "\006\023mss\0"
 115         "\011\024window\0"
 116 #ifdef RTF_IRTT
 117         "\007\025irtt\0"
 118 #endif
 119         "\006\026dev\0"
 120         "\011\026device\0"
 121         /* 040 is the "sets a flag" bit - MUST match flags_ipvx[] values below. */
 122 #ifdef RTF_REJECT
 123         "\011\040reject\0"
 124 #endif
 125         "\006\041mod\0"
 126         "\006\042dyn\0"
 127 /*      "\014\043reinstate\0" */
 128         "\013\043reinstate"                     /* Since last, we can save a byte. */
 129 ;
 130
 131 static const int flags_ipvx[] = { /* MUST match tbl_ipvx[] values above. */
 132 #ifdef RTF_REJECT
 133         RTF_REJECT,
 134 #endif
 135         RTF_MODIFIED,
 136         RTF_DYNAMIC,
 137         RTF_REINSTATE
 138 };
 139
 140 static int kw_lookup(const char *kwtbl, char ***pargs)
 141 {
 142         if (**pargs) {
 143                 do {
 144                         if (strcmp(kwtbl+2, **pargs) == 0) { /* Found a match. */
 145                                 *pargs += 1;
 146                                 if (kwtbl[1] & KW_TAKES_ARG) {
 147                                         if (!**pargs) { /* No more args! */
 148                                                 bb_show_usage();
 149                                         }
 150                                         *pargs += 1; /* Calling routine will use args[-1]. */
 151                                 }
 152                                 return kwtbl[1];
 153                         }
 154                         kwtbl += *kwtbl;
 155                 } while (*kwtbl);
 156         }
 157         return 0;
 158 }
 159
 160 /* Add or delete a route, depending on action. */
 161
 162 static NOINLINE void INET_setroute(int action, char **args)
 163 {
 164         /* char buffer instead of bona-fide struct avoids aliasing warning */
 165         char rt_buf[sizeof(struct rtentry)];
 166         struct rtentry *const rt = (void *)rt_buf;
 167
 168         const char *netmask = NULL;
 169         int skfd, isnet, xflag;
 170
 171         /* Grab the -net or -host options.  Remember they were transformed. */
 172         xflag = kw_lookup(tbl_hash_net_host, &args);
 173
 174         /* If we did grab -net or -host, make sure we still have an arg left. */
 175         if (*args == NULL) {
 176                 bb_show_usage();
 177         }
 178
 179         /* Clean out the RTREQ structure. */
 180         memset(rt, 0, sizeof(*rt));
 181
 182         {
 183                 const char *target = *args++;
 184                 char *prefix;
 185
 186                 /* recognize x.x.x.x/mask format. */
 187                 prefix = strchr(target, '/');
 188                 if (prefix) {
 189                         int prefix_len;
 190
 191                         prefix_len = xatoul_range(prefix+1, 0, 32);
 192                         mask_in_addr(*rt) = htonl( ~(0xffffffffUL >> prefix_len));
 193                         *prefix = '\0';
 194 #if HAVE_NEW_ADDRT
 195                         rt->rt_genmask.sa_family = AF_INET;
 196 #endif
 197                 } else {
 198                         /* Default netmask. */
 199                         netmask = "default";
 200                 }
 201                 /* Prefer hostname lookup is -host flag (xflag==1) was given. */
 202                 isnet = INET_resolve(target, (struct sockaddr_in *) &rt->rt_dst,
 203                                                          (xflag & HOST_FLAG));
 204                 if (isnet < 0) {
 205                         bb_error_msg_and_die("resolving %s", target);
 206                 }
 207                 if (prefix) {
 208                         /* do not destroy prefix for process args */
 209                         *prefix = '/';
 210                 }
 211         }
 212
 213         if (xflag) {            /* Reinit isnet if -net or -host was specified. */
 214                 isnet = (xflag & NET_FLAG);
 215         }
 216
 217         /* Fill in the other fields. */
 218         rt->rt_flags = ((isnet) ? RTF_UP : (RTF_UP | RTF_HOST));
 219
 220         while (*args) {
 221                 int k = kw_lookup(tbl_ipvx, &args);
 222                 const char *args_m1 = args[-1];
 223
 224                 if (k & KW_IPVx_FLAG_ONLY) {
 225                         rt->rt_flags |= flags_ipvx[k & 3];
 226                         continue;
 227                 }
 228
 229 #if HAVE_NEW_ADDRT
 230                 if (k == KW_IPVx_METRIC) {
 231                         rt->rt_metric = xatoul(args_m1) + 1;
 232                         continue;
 233                 }
 234 #endif
 235
 236                 if (k == KW_IPVx_NETMASK) {
 237                         struct sockaddr mask;
 238
 239                         if (mask_in_addr(*rt)) {
 240                                 bb_show_usage();
 241                         }
 242
 243                         netmask = args_m1;
 244                         isnet = INET_resolve(netmask, (struct sockaddr_in *) &mask, 0);
 245                         if (isnet < 0) {
 246                                 bb_error_msg_and_die("resolving %s", netmask);
 247                         }
 248                         rt->rt_genmask = full_mask(mask);
 249                         continue;
 250                 }
 251
 252                 if (k == KW_IPVx_GATEWAY) {
 253                         if (rt->rt_flags & RTF_GATEWAY) {
 254                                 bb_show_usage();
 255                         }
 256
 257                         isnet = INET_resolve(args_m1,
 258                                                 (struct sockaddr_in *) &rt->rt_gateway, 1);
 259                         rt->rt_flags |= RTF_GATEWAY;
 260
 261                         if (isnet) {
 262                                 if (isnet < 0) {
 263                                         bb_error_msg_and_die("resolving %s", args_m1);
 264                                 }
 265                                 bb_error_msg_and_die("gateway %s is a NETWORK", args_m1);
 266                         }
 267                         continue;
 268                 }
 269
 270                 if (k == KW_IPVx_MSS) { /* Check valid MSS bounds. */
 271                         rt->rt_flags |= RTF_MSS;
 272                         rt->rt_mss = xatoul_range(args_m1, 64, 32768);
 273                         continue;
 274                 }
 275
 276                 if (k == KW_IPVx_WINDOW) {      /* Check valid window bounds. */
 277                         rt->rt_flags |= RTF_WINDOW;
 278                         rt->rt_window = xatoul_range(args_m1, 128, INT_MAX);
 279                         continue;
 280                 }
 281
 282 #ifdef RTF_IRTT
 283                 if (k == KW_IPVx_IRTT) {
 284                         rt->rt_flags |= RTF_IRTT;
 285                         rt->rt_irtt = xatoul(args_m1);
 286                         rt->rt_irtt *= (sysconf(_SC_CLK_TCK) / 100);    /* FIXME */
 287 #if 0                                   /* FIXME: do we need to check anything of this? */
 288                         if (rt->rt_irtt < 1 || rt->rt_irtt > (120 * HZ)) {
 289                                 bb_error_msg_and_die("bad irtt");
 290                         }
 291 #endif
 292                         continue;
 293                 }
 294 #endif
 295
 296                 /* Device is special in that it can be the last arg specified
 297                  * and doesn't requre the dev/device keyword in that case. */
 298                 if (!rt->rt_dev && ((k == KW_IPVx_DEVICE) || (!k && !*++args))) {
 299                         /* Don't use args_m1 here since args may have changed! */
 300                         rt->rt_dev = args[-1];
 301                         continue;
 302                 }
 303
 304                 /* Nothing matched. */
 305                 bb_show_usage();
 306         }
 307
 308 #ifdef RTF_REJECT
 309         if ((rt->rt_flags & RTF_REJECT) && !rt->rt_dev) {
 310                 rt->rt_dev = (char*)"lo";
 311         }
 312 #endif
 313
 314         /* sanity checks.. */
 315         if (mask_in_addr(*rt)) {
 316                 uint32_t mask = mask_in_addr(*rt);
 317
 318                 mask = ~ntohl(mask);
 319                 if ((rt->rt_flags & RTF_HOST) && mask != 0xffffffff) {
 320                         bb_error_msg_and_die("netmask %.8x and host route conflict",
 321                                                                  (unsigned int) mask);
 322                 }
 323                 if (mask & (mask + 1)) {
 324                         bb_error_msg_and_die("bogus netmask %s", netmask);
 325                 }
 326                 mask = ((struct sockaddr_in *) &rt->rt_dst)->sin_addr.s_addr;
 327                 if (mask & ~(uint32_t)mask_in_addr(*rt)) {
 328                         bb_error_msg_and_die("netmask and route address conflict");
 329                 }
 330         }
 331
 332         /* Fill out netmask if still unset */
 333         if ((action == RTACTION_ADD) && (rt->rt_flags & RTF_HOST)) {
 334                 mask_in_addr(*rt) = 0xffffffff;
 335         }
 336
 337         /* Create a socket to the INET kernel. */
 338         skfd = xsocket(AF_INET, SOCK_DGRAM, 0);
 339
 340         if (action == RTACTION_ADD)
 341                 xioctl(skfd, SIOCADDRT, rt);
 342         else
 343                 xioctl(skfd, SIOCDELRT, rt);
 344
 345         if (ENABLE_FEATURE_CLEAN_UP) close(skfd);
 346 }
 347
 348 #if ENABLE_FEATURE_IPV6
 349
 350 static NOINLINE void INET6_setroute(int action, char **args)
 351 {
 352         struct sockaddr_in6 sa6;
 353         struct in6_rtmsg rt;
 354         int prefix_len, skfd;
 355         const char *devname;
 356
 357                 /* We know args isn't NULL from the check in route_main. */
 358                 const char *target = *args++;
 359
 360                 if (strcmp(target, "default") == 0) {
 361                         prefix_len = 0;
 362                         memset(&sa6, 0, sizeof(sa6));
 363                 } else {
 364                         char *cp;
 365                         cp = strchr(target, '/'); /* Yes... const to non is ok. */
 366                         if (cp) {
 367                                 *cp = '\0';
 368                                 prefix_len = xatoul_range(cp + 1, 0, 128);
 369                         } else {
 370                                 prefix_len = 128;
 371                         }
 372                         if (INET6_resolve(target, (struct sockaddr_in6 *) &sa6) < 0) {
 373                                 bb_error_msg_and_die("resolving %s", target);
 374                         }
 375                 }
 376
 377         /* Clean out the RTREQ structure. */
 378         memset(&rt, 0, sizeof(rt));
 379
 380         memcpy(&rt.rtmsg_dst, sa6.sin6_addr.s6_addr, sizeof(struct in6_addr));
 381
 382         /* Fill in the other fields. */
 383         rt.rtmsg_dst_len = prefix_len;
 384         rt.rtmsg_flags = ((prefix_len == 128) ? (RTF_UP|RTF_HOST) : RTF_UP);
 385         rt.rtmsg_metric = 1;
 386
 387         devname = NULL;
 388
 389         while (*args) {
 390                 int k = kw_lookup(tbl_ipvx, &args);
 391                 const char *args_m1 = args[-1];
 392
 393                 if ((k == KW_IPVx_MOD) || (k == KW_IPVx_DYN)) {
 394                         rt.rtmsg_flags |= flags_ipvx[k & 3];
 395                         continue;
 396                 }
 397
 398                 if (k == KW_IPVx_METRIC) {
 399                         rt.rtmsg_metric = xatoul(args_m1);
 400                         continue;
 401                 }
 402
 403                 if (k == KW_IPVx_GATEWAY) {
 404                         if (rt.rtmsg_flags & RTF_GATEWAY) {
 405                                 bb_show_usage();
 406                         }
 407
 408                         if (INET6_resolve(args_m1, (struct sockaddr_in6 *) &sa6) < 0) {
 409                                 bb_error_msg_and_die("resolving %s", args_m1);
 410                         }
 411                         memcpy(&rt.rtmsg_gateway, sa6.sin6_addr.s6_addr,
 412                                         sizeof(struct in6_addr));
 413                         rt.rtmsg_flags |= RTF_GATEWAY;
 414                         continue;
 415                 }
 416
 417                 /* Device is special in that it can be the last arg specified
 418                  * and doesn't requre the dev/device keyword in that case. */
 419                 if (!devname && ((k == KW_IPVx_DEVICE) || (!k && !*++args))) {
 420                         /* Don't use args_m1 here since args may have changed! */
 421                         devname = args[-1];
 422                         continue;
 423                 }
 424
 425                 /* Nothing matched. */
 426                 bb_show_usage();
 427         }
 428
 429         /* Create a socket to the INET6 kernel. */
 430         skfd = xsocket(AF_INET6, SOCK_DGRAM, 0);
 431
 432         rt.rtmsg_ifindex = 0;
 433
 434         if (devname) {
 435                 struct ifreq ifr;
 436                 memset(&ifr, 0, sizeof(ifr));
 437                 strncpy_IFNAMSIZ(ifr.ifr_name, devname);
 438                 xioctl(skfd, SIOCGIFINDEX, &ifr);
 439                 rt.rtmsg_ifindex = ifr.ifr_ifindex;
 440         }
 441
 442         /* Tell the kernel to accept this route. */
 443         if (action == RTACTION_ADD)
 444                 xioctl(skfd, SIOCADDRT, &rt);
 445         else
 446                 xioctl(skfd, SIOCDELRT, &rt);
 447
 448         if (ENABLE_FEATURE_CLEAN_UP) close(skfd);
 449 }
 450 #endif
 451
 452 static const unsigned flagvals[] = { /* Must agree with flagchars[]. */
 453         RTF_GATEWAY,
 454         RTF_HOST,
 455         RTF_REINSTATE,
 456         RTF_DYNAMIC,
 457         RTF_MODIFIED,
 458 #if ENABLE_FEATURE_IPV6
 459         RTF_DEFAULT,
 460         RTF_ADDRCONF,
 461         RTF_CACHE
 462 #endif
 463 };
 464
 465 #define IPV4_MASK (RTF_GATEWAY|RTF_HOST|RTF_REINSTATE|RTF_DYNAMIC|RTF_MODIFIED)
 466 #define IPV6_MASK (RTF_GATEWAY|RTF_HOST|RTF_DEFAULT|RTF_ADDRCONF|RTF_CACHE)
 467
 468 /* Must agree with flagvals[]. */
 469 static const char flagchars[] ALIGN1 =
 470         "GHRDM"
 471 #if ENABLE_FEATURE_IPV6
 472         "DAC"
 473 #endif
 474 ;
 475
 476 static void set_flags(char *flagstr, int flags)
 477 {
 478         int i;
 479
 480         *flagstr++ = 'U';
 481
 482         for (i = 0; (*flagstr = flagchars[i]) != 0; i++) {
 483                 if (flags & flagvals[i]) {
 484                         ++flagstr;
 485                 }
 486         }
 487 }
 488
 489 /* also used in netstat */
 490 void FAST_FUNC bb_displayroutes(int noresolve, int netstatfmt)
 491 {
 492         char devname[64], flags[16], *sdest, *sgw;
 493         unsigned long d, g, m;
 494         int flgs, ref, use, metric, mtu, win, ir;
 495         struct sockaddr_in s_addr;
 496         struct in_addr mask;
 497
 498         FILE *fp = xfopen_for_read("/proc/net/route");
 499
 500         printf("Kernel IP routing table\n"
 501                 "Destination     Gateway         Genmask         Flags %s Iface\n",
 502                         netstatfmt ? "  MSS Window  irtt" : "Metric Ref    Use");
 503
 504         if (fscanf(fp, "%*[^\n]\n") < 0) { /* Skip the first line. */
 505                 goto ERROR;                /* Empty or missing line, or read error. */
 506         }
 507         while (1) {
 508                 int r;
 509                 r = fscanf(fp, "%63s%lx%lx%X%d%d%d%lx%d%d%d\n",
 510                                 devname, &d, &g, &flgs, &ref, &use, &metric, &m,
 511                                 &mtu, &win, &ir);
 512                 if (r != 11) {
 513                         if ((r < 0) && feof(fp)) { /* EOF with no (nonspace) chars read. */
 514                                 break;
 515                         }
 516  ERROR:
 517                         bb_error_msg_and_die("fscanf");
 518                 }
 519
 520                 if (!(flgs & RTF_UP)) { /* Skip interfaces that are down. */
 521                         continue;
 522                 }
 523
 524                 set_flags(flags, (flgs & IPV4_MASK));
 525 #ifdef RTF_REJECT
 526                 if (flgs & RTF_REJECT) {
 527                         flags[0] = '!';
 528                 }
 529 #endif
 530
 531                 memset(&s_addr, 0, sizeof(struct sockaddr_in));
 532                 s_addr.sin_family = AF_INET;
 533                 s_addr.sin_addr.s_addr = d;
 534                 sdest = INET_rresolve(&s_addr, (noresolve | 0x8000), m); /* 'default' instead of '*' */
 535                 s_addr.sin_addr.s_addr = g;
 536                 sgw = INET_rresolve(&s_addr, (noresolve | 0x4000), m); /* Host instead of net */
 537                 mask.s_addr = m;
 538                 /* "%15.15s" truncates hostnames, do we really want that? */
 539                 printf("%-15.15s %-15.15s %-16s%-6s", sdest, sgw, inet_ntoa(mask), flags);
 540                 free(sdest);
 541                 free(sgw);
 542                 if (netstatfmt) {
 543                         printf("%5d %-5d %6d %s\n", mtu, win, ir, devname);
 544                 } else {
 545                         printf("%-6d %-2d %7d %s\n", metric, ref, use, devname);
 546                 }
 547         }
 548         fclose(fp);
 549 }
 550
 551 #if ENABLE_FEATURE_IPV6
 552
 553 static void INET6_displayroutes(void)
 554 {
 555         char addr6[128], *naddr6;
 556         /* In addr6x, we store both 40-byte ':'-delimited ipv6 addresses.
 557          * We read the non-delimited strings into the tail of the buffer
 558          * using fscanf and then modify the buffer by shifting forward
 559          * while inserting ':'s and the nul terminator for the first string.
 560          * Hence the strings are at addr6x and addr6x+40.  This generates
 561          * _much_ less code than the previous (upstream) approach. */
 562         char addr6x[80];
 563         char iface[16], flags[16];
 564         int iflags, metric, refcnt, use, prefix_len, slen;
 565         struct sockaddr_in6 snaddr6;
 566
 567         FILE *fp = xfopen_for_read("/proc/net/ipv6_route");
 568
 569         printf("Kernel IPv6 routing table\n%-44s%-40s"
 570                         "Flags Metric Ref    Use Iface\n",
 571                         "Destination", "Next Hop");
 572
 573         while (1) {
 574                 int r;
 575                 r = fscanf(fp, "%32s%x%*s%x%32s%x%x%x%x%s\n",
 576                                 addr6x+14, &prefix_len, &slen, addr6x+40+7,
 577                                 &metric, &use, &refcnt, &iflags, iface);
 578                 if (r != 9) {
 579                         if ((r < 0) && feof(fp)) { /* EOF with no (nonspace) chars read. */
 580                                 break;
 581                         }
 582  ERROR:
 583                         bb_error_msg_and_die("fscanf");
 584                 }
 585
 586                 /* Do the addr6x shift-and-insert changes to ':'-delimit addresses.
 587                  * For now, always do this to validate the proc route format, even
 588                  * if the interface is down. */
 589                 {
 590                         int i = 0;
 591                         char *p = addr6x+14;
 592
 593                         do {
 594                                 if (!*p) {
 595                                         if (i == 40) { /* nul terminator for 1st address? */
 596                                                 addr6x[39] = 0; /* Fixup... need 0 instead of ':'. */
 597                                                 ++p;    /* Skip and continue. */
 598                                                 continue;
 599                                         }
 600                                         goto ERROR;
 601                                 }
 602                                 addr6x[i++] = *p++;
 603                                 if (!((i+1) % 5)) {
 604                                         addr6x[i++] = ':';
 605                                 }
 606                         } while (i < 40+28+7);
 607                 }
 608
 609                 if (!(iflags & RTF_UP)) { /* Skip interfaces that are down. */
 610                         continue;
 611                 }
 612
 613                 set_flags(flags, (iflags & IPV6_MASK));
 614
 615                 r = 0;
 616                 while (1) {
 617                         inet_pton(AF_INET6, addr6x + r,
 618                                           (struct sockaddr *) &snaddr6.sin6_addr);
 619                         snaddr6.sin6_family = AF_INET6;
 620                         naddr6 = INET6_rresolve((struct sockaddr_in6 *) &snaddr6,
 621                                                 0x0fff /* Apparently, upstream never resolves. */
 622                                                 );
 623
 624                         if (!r) {                       /* 1st pass */
 625                                 snprintf(addr6, sizeof(addr6), "%s/%d", naddr6, prefix_len);
 626                                 r += 40;
 627                                 free(naddr6);
 628                         } else {                        /* 2nd pass */
 629                                 /* Print the info. */
 630                                 printf("%-43s %-39s %-5s %-6d %-2d %7d %-8s\n",
 631                                                 addr6, naddr6, flags, metric, refcnt, use, iface);
 632                                 free(naddr6);
 633                                 break;
 634                         }
 635                 }
 636         }
 637         fclose(fp);
 638 }
 639
 640 #endif
 641
 642 #define ROUTE_OPT_A     0x01
 643 #define ROUTE_OPT_n     0x02
 644 #define ROUTE_OPT_e     0x04
 645 #define ROUTE_OPT_INET6 0x08 /* Not an actual option. See below. */
 646
 647 /* 1st byte is offset to next entry offset.  2nd byte is return value. */
 648 /* 2nd byte matches RTACTION_* code */
 649 static const char tbl_verb[] ALIGN1 =
 650         "\006\001add\0"
 651         "\006\002del\0"
 652 /*      "\011\002delete\0" */
 653         "\010\002delete"  /* Since it's last, we can save a byte. */
 654 ;
 655
 656 int route_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 657 int route_main(int argc UNUSED_PARAM, char **argv)
 658 {
 659         unsigned opt;
 660         int what;
 661         char *family;
 662         char **p;
 663
 664         /* First, remap '-net' and '-host' to avoid getopt problems. */
 665         p = argv;
 666         while (*++p) {
 667                 if (strcmp(*p, "-net") == 0 || strcmp(*p, "-host") == 0) {
 668                         p[0][0] = '#';
 669                 }
 670         }
 671
 672         opt = getopt32(argv, "A:ne", &family);
 673
 674         if ((opt & ROUTE_OPT_A) && strcmp(family, "inet") != 0) {
 675 #if ENABLE_FEATURE_IPV6
 676                 if (strcmp(family, "inet6") == 0) {
 677                         opt |= ROUTE_OPT_INET6; /* Set flag for ipv6. */
 678                 } else
 679 #endif
 680                 bb_show_usage();
 681         }
 682
 683         argv += optind;
 684
 685         /* No more args means display the routing table. */
 686         if (!*argv) {
 687                 int noresolve = (opt & ROUTE_OPT_n) ? 0x0fff : 0;
 688 #if ENABLE_FEATURE_IPV6
 689                 if (opt & ROUTE_OPT_INET6)
 690                         INET6_displayroutes();
 691                 else
 692 #endif
 693                         bb_displayroutes(noresolve, opt & ROUTE_OPT_e);
 694
 695                 fflush_stdout_and_exit(EXIT_SUCCESS);
 696         }
 697
 698         /* Check verb.  At the moment, must be add, del, or delete. */
 699         what = kw_lookup(tbl_verb, &argv);
 700         if (!what || !*argv) {          /* Unknown verb or no more args. */
 701                 bb_show_usage();
 702         }
 703
 704 #if ENABLE_FEATURE_IPV6
 705         if (opt & ROUTE_OPT_INET6)
 706                 INET6_setroute(what, argv);
 707         else
 708 #endif
 709                 INET_setroute(what, argv);
 710
 711         return EXIT_SUCCESS;
 712 }