networking/route.c

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