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 tarball for details.
  14  *
  15  * $Id: route.c,v 1.26 2004/03/19 23:27:08 mjn3 Exp $
  16  *
  17  * displayroute() code added by Vladimir N. Oleynik <dzo@simtreas.ru>
  18  * adjustments by Larry Doolittle  <LRDoolittle@lbl.gov>
  19  *
  20  * IPV6 support added by Bart Visscher <magick@linux-fan.com>
  21  */
  22
  23 /* 2004/03/09  Manuel Novoa III <mjn3@codepoet.org>
  24  *
  25  * Rewritten to fix several bugs, add additional error checking, and
  26  * remove ridiculous amounts of bloat.
  27  */
  28
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include <errno.h>
  33 #include <assert.h>
  34 #include <unistd.h>
  35 #include <fcntl.h>
  36 #include <getopt.h>
  37 #include <sys/types.h>
  38 #include <sys/ioctl.h>
  39 #include <net/route.h>
  40 #include <net/if.h>
  41 #include "busybox.h"
  42 #include "inet_common.h"
  43
  44 #ifndef RTF_UP
  45 /* Keep this in sync with /usr/src/linux/include/linux/route.h */
  46 #define RTF_UP          0x0001  /* route usable                 */
  47 #define RTF_GATEWAY     0x0002  /* destination is a gateway     */
  48 #define RTF_HOST        0x0004  /* host entry (net otherwise)   */
  49 #define RTF_REINSTATE   0x0008  /* reinstate route after tmout  */
  50 #define RTF_DYNAMIC     0x0010  /* created dyn. (by redirect)   */
  51 #define RTF_MODIFIED    0x0020  /* modified dyn. (by redirect)  */
  52 #define RTF_MTU         0x0040  /* specific MTU for this route  */
  53 #ifndef RTF_MSS
  54 #define RTF_MSS         RTF_MTU /* Compatibility :-(            */
  55 #endif
  56 #define RTF_WINDOW      0x0080  /* per route window clamping    */
  57 #define RTF_IRTT        0x0100  /* Initial round trip time      */
  58 #define RTF_REJECT      0x0200  /* Reject route                 */
  59 #endif
  60
  61 #if defined (SIOCADDRTOLD) || defined (RTF_IRTT)        /* route */
  62 #define HAVE_NEW_ADDRT 1
  63 #endif
  64
  65 #if HAVE_NEW_ADDRT
  66 #define mask_in_addr(x) (((struct sockaddr_in *)&((x).rt_genmask))->sin_addr.s_addr)
  67 #define full_mask(x) (x)
  68 #else
  69 #define mask_in_addr(x) ((x).rt_genmask)
  70 #define full_mask(x) (((struct sockaddr_in *)&(x))->sin_addr.s_addr)
  71 #endif
  72
  73 /* The RTACTION entries must agree with tbl_verb[] below! */
  74 #define RTACTION_ADD            1
  75 #define RTACTION_DEL            2
  76
  77 /* For the various tbl_*[] arrays, the 1st byte is the offset to
  78  * the next entry and the 2nd byte is return value. */
  79
  80 #define NET_FLAG                        1
  81 #define HOST_FLAG                       2
  82
  83 /* We remap '-' to '#' to avoid problems with getopt. */
  84 static const char tbl_hash_net_host[] =
  85         "\007\001#net\0"
  86 /*      "\010\002#host\0" */
  87         "\007\002#host"                         /* Since last, we can save a byte. */
  88 ;
  89
  90 #define KW_TAKES_ARG            020
  91 #define KW_SETS_FLAG            040
  92
  93 #define KW_IPVx_METRIC          020
  94 #define KW_IPVx_NETMASK         021
  95 #define KW_IPVx_GATEWAY         022
  96 #define KW_IPVx_MSS                     023
  97 #define KW_IPVx_WINDOW          024
  98 #define KW_IPVx_IRTT            025
  99 #define KW_IPVx_DEVICE          026
 100
 101 #define KW_IPVx_FLAG_ONLY       040
 102 #define KW_IPVx_REJECT          040
 103 #define KW_IPVx_MOD                     041
 104 #define KW_IPVx_DYN                     042
 105 #define KW_IPVx_REINSTATE       043
 106
 107 static const char tbl_ipvx[] =
 108         /* 020 is the "takes an arg" bit */
 109 #if HAVE_NEW_ADDRT
 110         "\011\020metric\0"
 111 #endif
 112         "\012\021netmask\0"
 113         "\005\022gw\0"
 114         "\012\022gateway\0"
 115         "\006\023mss\0"
 116         "\011\024window\0"
 117 #ifdef RTF_IRTT
 118         "\007\025irtt\0"
 119 #endif
 120         "\006\026dev\0"
 121         "\011\026device\0"
 122         /* 040 is the "sets a flag" bit - MUST match flags_ipvx[] values below. */
 123 #ifdef RTF_REJECT
 124         "\011\040reject\0"
 125 #endif
 126         "\006\041mod\0"
 127         "\006\042dyn\0"
 128 /*      "\014\043reinstate\0" */
 129         "\013\043reinstate"                     /* Since last, we can save a byte. */
 130 ;
 131
 132 static const int flags_ipvx[] = { /* MUST match tbl_ipvx[] values above. */
 133 #ifdef RTF_REJECT
 134         RTF_REJECT,
 135 #endif
 136         RTF_MODIFIED,
 137         RTF_DYNAMIC,
 138         RTF_REINSTATE
 139 };
 140
 141 static int kw_lookup(const char *kwtbl, char ***pargs)
 142 {
 143         if (**pargs) {
 144                 do {
 145                         if (strcmp(kwtbl+2, **pargs) == 0) { /* Found a match. */
 146                                 *pargs += 1;
 147                                 if (kwtbl[1] & KW_TAKES_ARG) {
 148                                         if (!**pargs) { /* No more args! */
 149                                                 bb_show_usage();
 150                                         }
 151                                         *pargs += 1; /* Calling routine will use args[-1]. */
 152                                 }
 153                                 return kwtbl[1];
 154                         }
 155                         kwtbl += *kwtbl;
 156                 } while (*kwtbl);
 157         }
 158         return 0;
 159 }
 160
 161 /* Add or delete a route, depending on action. */
 162
 163 static void INET_setroute(int action, char **args)
 164 {
 165         struct rtentry rt;
 166         const char *netmask = NULL;
 167         int skfd, isnet, xflag;
 168
 169         assert((action == RTACTION_ADD) || (action == RTACTION_DEL));
 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((char *) &rt, 0, sizeof(struct rtentry));
 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 = bb_xgetularg10_bnd(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 = bb_INET_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 = bb_xgetularg10(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 = bb_xgetularg10_bnd(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 = bb_xgetularg10_bnd(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 = bb_xgetularg10(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 = "lo";
 311         }
 312 #endif
 313
 314         /* sanity checks.. */
 315         if (mask_in_addr(rt)) {
 316                 unsigned long 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 & ~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 = bb_xsocket(AF_INET, SOCK_DGRAM, 0);
 339
 340         if (ioctl(skfd, ((action==RTACTION_ADD) ? SIOCADDRT : SIOCDELRT), &rt)<0) {
 341                 bb_perror_msg_and_die("SIOC[ADD|DEL]RT");
 342         }
 343
 344         if (ENABLE_FEATURE_CLEAN_UP) close(skfd);
 345 }
 346
 347 #ifdef CONFIG_FEATURE_IPV6
 348
 349 static void INET6_setroute(int action, char **args)
 350 {
 351         struct sockaddr_in6 sa6;
 352         struct in6_rtmsg rt;
 353         int prefix_len, skfd;
 354         const char *devname;
 355
 356         assert((action == RTACTION_ADD) || (action == RTACTION_DEL));
 357
 358         {
 359                 /* We know args isn't NULL from the check in route_main. */
 360                 const char *target = *args++;
 361
 362                 if (strcmp(target, bb_INET_default) == 0) {
 363                         prefix_len = 0;
 364                         memset(&sa6, 0, sizeof(sa6));
 365                 } else {
 366                         char *cp;
 367                         if ((cp = strchr(target, '/'))) { /* Yes... const to non is ok. */
 368                                 *cp = 0;
 369                                 prefix_len = bb_xgetularg10_bnd(cp+1, 0, 128);
 370                         } else {
 371                                 prefix_len = 128;
 372                         }
 373                         if (INET6_resolve(target, (struct sockaddr_in6 *) &sa6) < 0) {
 374                                 bb_error_msg_and_die("resolving %s", target);
 375                         }
 376                 }
 377         }
 378
 379         /* Clean out the RTREQ structure. */
 380         memset((char *) &rt, 0, sizeof(struct in6_rtmsg));
 381
 382         memcpy(&rt.rtmsg_dst, sa6.sin6_addr.s6_addr, sizeof(struct in6_addr));
 383
 384         /* Fill in the other fields. */
 385         rt.rtmsg_dst_len = prefix_len;
 386         rt.rtmsg_flags = ((prefix_len == 128) ? (RTF_UP|RTF_HOST) : RTF_UP);
 387         rt.rtmsg_metric = 1;
 388
 389         devname = NULL;
 390
 391         while (*args) {
 392                 int k = kw_lookup(tbl_ipvx, &args);
 393                 const char *args_m1 = args[-1];
 394
 395                 if ((k == KW_IPVx_MOD) || (k == KW_IPVx_DYN)) {
 396                         rt.rtmsg_flags |= flags_ipvx[k & 3];
 397                         continue;
 398                 }
 399
 400                 if (k == KW_IPVx_METRIC) {
 401                         rt.rtmsg_metric = bb_xgetularg10(args_m1);
 402                         continue;
 403                 }
 404
 405                 if (k == KW_IPVx_GATEWAY) {
 406                         if (rt.rtmsg_flags & RTF_GATEWAY) {
 407                                 bb_show_usage();
 408                         }
 409
 410                         if (INET6_resolve(args_m1, (struct sockaddr_in6 *) &sa6) < 0) {
 411                                 bb_error_msg_and_die("resolving %s", args_m1);
 412                         }
 413                         memcpy(&rt.rtmsg_gateway, sa6.sin6_addr.s6_addr,
 414                                    sizeof(struct in6_addr));
 415                         rt.rtmsg_flags |= RTF_GATEWAY;
 416                         continue;
 417                 }
 418
 419                 /* Device is special in that it can be the last arg specified
 420                  * and doesn't requre the dev/device keyword in that case. */
 421                 if (!devname && ((k == KW_IPVx_DEVICE) || (!k && !*++args))) {
 422                         /* Don't use args_m1 here since args may have changed! */
 423                         devname = args[-1];
 424                         continue;
 425                 }
 426
 427                 /* Nothing matched. */
 428                 bb_show_usage();
 429         }
 430
 431         /* Create a socket to the INET6 kernel. */
 432         skfd = bb_xsocket(AF_INET6, SOCK_DGRAM, 0);
 433
 434         rt.rtmsg_ifindex = 0;
 435
 436         if (devname) {
 437                 struct ifreq ifr;
 438                 memset(&ifr, 0, sizeof(ifr));
 439                 strcpy(ifr.ifr_name, devname);
 440
 441                 if (ioctl(skfd, SIOGIFINDEX, &ifr) < 0) {
 442                         bb_perror_msg_and_die("SIOGIFINDEX");
 443                 }
 444                 rt.rtmsg_ifindex = ifr.ifr_ifindex;
 445         }
 446
 447         /* Tell the kernel to accept this route. */
 448         if (ioctl(skfd, ((action==RTACTION_ADD) ? SIOCADDRT : SIOCDELRT), &rt)<0) {
 449                 bb_perror_msg_and_die("SIOC[ADD|DEL]RT");
 450         }
 451
 452         if (ENABLE_FEATURE_CLEAN_UP) close(skfd);
 453 }
 454 #endif
 455
 456 static const unsigned int flagvals[] = { /* Must agree with flagchars[]. */
 457         RTF_GATEWAY,
 458         RTF_HOST,
 459         RTF_REINSTATE,
 460         RTF_DYNAMIC,
 461         RTF_MODIFIED,
 462 #ifdef CONFIG_FEATURE_IPV6
 463         RTF_DEFAULT,
 464         RTF_ADDRCONF,
 465         RTF_CACHE
 466 #endif
 467 };
 468
 469 #define IPV4_MASK (RTF_GATEWAY|RTF_HOST|RTF_REINSTATE|RTF_DYNAMIC|RTF_MODIFIED)
 470 #define IPV6_MASK (RTF_GATEWAY|RTF_HOST|RTF_DEFAULT|RTF_ADDRCONF|RTF_CACHE)
 471
 472 static const char flagchars[] =         /* Must agree with flagvals[]. */
 473         "GHRDM"
 474 #ifdef CONFIG_FEATURE_IPV6
 475         "DAC"
 476 #endif
 477 ;
 478
 479 static
 480 #ifndef CONFIG_FEATURE_IPV6
 481 __inline
 482 #endif
 483 void set_flags(char *flagstr, int flags)
 484 {
 485         int i;
 486
 487         *flagstr++ = 'U';
 488
 489         for (i=0 ; (*flagstr = flagchars[i]) != 0 ; i++) {
 490                 if (flags & flagvals[i]) {
 491                         ++flagstr;
 492                 }
 493         }
 494 }
 495
 496 /* also used in netstat */
 497 void displayroutes(int noresolve, int netstatfmt);
 498 void displayroutes(int noresolve, int netstatfmt)
 499 {
 500         char devname[64], flags[16], sdest[16], sgw[16];
 501         unsigned long int d, g, m;
 502         int flgs, ref, use, metric, mtu, win, ir;
 503         struct sockaddr_in s_addr;
 504         struct in_addr mask;
 505
 506         FILE *fp = bb_xfopen("/proc/net/route", "r");
 507
 508         bb_printf("Kernel IP routing table\n"
 509                           "Destination     Gateway         Genmask"
 510                           "         Flags %s Iface\n",
 511                           netstatfmt ? "  MSS Window  irtt" : "Metric Ref    Use");
 512
 513         if (fscanf(fp, "%*[^\n]\n") < 0) { /* Skip the first line. */
 514                 goto ERROR;                /* Empty or missing line, or read error. */
 515         }
 516         while (1) {
 517                 int r;
 518                 r = fscanf(fp, "%63s%lx%lx%X%d%d%d%lx%d%d%d\n",
 519                                    devname, &d, &g, &flgs, &ref, &use, &metric, &m,
 520                                    &mtu, &win, &ir);
 521                 if (r != 11) {
 522                         if ((r < 0) && feof(fp)) { /* EOF with no (nonspace) chars read. */
 523                                 break;
 524                         }
 525                 ERROR:
 526                         bb_error_msg_and_die("fscanf");
 527                 }
 528
 529                 if (!(flgs & RTF_UP)) { /* Skip interfaces that are down. */
 530                         continue;
 531                 }
 532
 533                 set_flags(flags, (flgs & IPV4_MASK));
 534 #ifdef RTF_REJECT
 535                 if (flgs & RTF_REJECT) {
 536                         flags[0] = '!';
 537                 }
 538 #endif
 539
 540                 memset(&s_addr, 0, sizeof(struct sockaddr_in));
 541                 s_addr.sin_family = AF_INET;
 542                 s_addr.sin_addr.s_addr = d;
 543                 INET_rresolve(sdest, sizeof(sdest), &s_addr,
 544                                           (noresolve | 0x8000), m);     /* Default instead of *. */
 545
 546                 s_addr.sin_addr.s_addr = g;
 547                 INET_rresolve(sgw, sizeof(sgw), &s_addr,
 548                                           (noresolve | 0x4000), m);     /* Host instead of net. */
 549
 550                 mask.s_addr = m;
 551                 bb_printf("%-16s%-16s%-16s%-6s", sdest, sgw, inet_ntoa(mask), flags);
 552                 if (netstatfmt) {
 553                         bb_printf("%5d %-5d %6d %s\n", mtu, win, ir, devname);
 554                 } else {
 555                         bb_printf("%-6d %-2d %7d %s\n", metric, ref, use, devname);
 556                 }
 557         }
 558 }
 559
 560 #ifdef CONFIG_FEATURE_IPV6
 561
 562 static void INET6_displayroutes(int noresolve)
 563 {
 564         char addr6[128], naddr6[128];
 565         /* In addr6x, we store both 40-byte ':'-delimited ipv6 addresses.
 566          * We read the non-delimited strings into the tail of the buffer
 567          * using fscanf and then modify the buffer by shifting forward
 568          * while inserting ':'s and the nul terminator for the first string.
 569          * Hence the strings are at addr6x and addr6x+40.  This generates
 570          * _much_ less code than the previous (upstream) approach. */
 571         char addr6x[80];
 572         char iface[16], flags[16];
 573         int iflags, metric, refcnt, use, prefix_len, slen;
 574         struct sockaddr_in6 snaddr6;
 575
 576         FILE *fp = bb_xfopen("/proc/net/ipv6_route", "r");
 577
 578         bb_printf("Kernel IPv6 routing table\n%-44s%-40s"
 579                           "Flags Metric Ref    Use Iface\n",
 580                           "Destination", "Next Hop");
 581
 582         while (1) {
 583                 int r;
 584                 r = fscanf(fp, "%32s%x%*s%x%32s%x%x%x%x%s\n",
 585                                    addr6x+14, &prefix_len, &slen, addr6x+40+7,
 586                                    &metric, &use, &refcnt, &iflags, iface);
 587                 if (r != 9) {
 588                         if ((r < 0) && feof(fp)) { /* EOF with no (nonspace) chars read. */
 589                                 break;
 590                         }
 591                 ERROR:
 592                         bb_error_msg_and_die("fscanf");
 593                 }
 594
 595                 /* Do the addr6x shift-and-insert changes to ':'-delimit addresses.
 596                  * For now, always do this to validate the proc route format, even
 597                  * if the interface is down. */
 598                 {
 599                         int i = 0;
 600                         char *p = addr6x+14;
 601
 602                         do {
 603                                 if (!*p) {
 604                                         if (i==40) { /* nul terminator for 1st address? */
 605                                                 addr6x[39] = 0; /* Fixup... need 0 instead of ':'. */
 606                                                 ++p;    /* Skip and continue. */
 607                                                 continue;
 608                                         }
 609                                         goto ERROR;
 610                                 }
 611                                 addr6x[i++] = *p++;
 612                                 if (!((i+1)%5)) {
 613                                         addr6x[i++] = ':';
 614                                 }
 615                         } while (i < 40+28+7);
 616                 }
 617
 618                 if (!(iflags & RTF_UP)) { /* Skip interfaces that are down. */
 619                         continue;
 620                 }
 621
 622                 set_flags(flags, (iflags & IPV6_MASK));
 623
 624                 r = 0;
 625                 do {
 626                         inet_pton(AF_INET6, addr6x + r,
 627                                           (struct sockaddr *) &snaddr6.sin6_addr);
 628                         snaddr6.sin6_family = AF_INET6;
 629                         INET6_rresolve(naddr6, sizeof(naddr6),
 630                                                    (struct sockaddr_in6 *) &snaddr6,
 631 #if 0
 632                                                    (noresolve | 0x8000) /* Default instead of *. */
 633 #else
 634                                                    0x0fff /* Apparently, upstream never resolves. */
 635 #endif
 636                                                    );
 637
 638                         if (!r) {                       /* 1st pass */
 639                                 snprintf(addr6, sizeof(addr6), "%s/%d", naddr6, prefix_len);
 640                                 r += 40;
 641                         } else {                        /* 2nd pass */
 642                                 /* Print the info. */
 643                                 bb_printf("%-43s %-39s %-5s %-6d %-2d %7d %-8s\n",
 644                                                   addr6, naddr6, flags, metric, refcnt, use, iface);
 645                                 break;
 646                         }
 647                 } while (1);
 648         }
 649 }
 650
 651 #endif
 652
 653 #define ROUTE_OPT_A                     0x01
 654 #define ROUTE_OPT_n                     0x02
 655 #define ROUTE_OPT_e                     0x04
 656 #define ROUTE_OPT_INET6         0x08 /* Not an actual option. See below. */
 657
 658 /* 1st byte is offset to next entry offset.  2nd byte is return value. */
 659 static const char tbl_verb[] =  /* 2nd byte matches RTACTION_* code */
 660         "\006\001add\0"
 661         "\006\002del\0"
 662 /*      "\011\002delete\0" */
 663         "\010\002delete"                        /* Since last, we can save a byte. */
 664 ;
 665
 666 int route_main(int argc, char **argv)
 667 {
 668         unsigned long opt;
 669         int what;
 670         char *family;
 671
 672         /* First, remap '-net' and '-host' to avoid getopt problems. */
 673         {
 674                 char **p = argv;
 675
 676                 while (*++p) {
 677                         if ((strcmp(*p, "-net") == 0) || (strcmp(*p, "-host") == 0)) {
 678                                 p[0][0] = '#';
 679                         }
 680                 }
 681         }
 682
 683         opt = bb_getopt_ulflags(argc, argv, "A:ne", &family);
 684
 685         if ((opt & ROUTE_OPT_A) && strcmp(family, "inet")) {
 686 #ifdef CONFIG_FEATURE_IPV6
 687                 if (strcmp(family, "inet6") == 0) {
 688                         opt |= ROUTE_OPT_INET6; /* Set flag for ipv6. */
 689                 } else
 690 #endif
 691                 bb_show_usage();
 692         }
 693
 694         argv += optind;
 695
 696         /* No more args means display the routing table. */
 697         if (!*argv) {
 698                 int noresolve = (opt & ROUTE_OPT_n) ? 0x0fff : 0;
 699 #ifdef CONFIG_FEATURE_IPV6
 700                 if (opt & ROUTE_OPT_INET6)
 701                         INET6_displayroutes(noresolve);
 702                 else
 703 #endif
 704                         displayroutes(noresolve, opt & ROUTE_OPT_e);
 705
 706                 bb_xferror_stdout();
 707                 bb_fflush_stdout_and_exit(EXIT_SUCCESS);
 708         }
 709
 710         /* Check verb.  At the moment, must be add, del, or delete. */
 711         what = kw_lookup(tbl_verb, &argv);
 712         if (!what || !*argv) {          /* Unknown verb or no more args. */
 713                 bb_show_usage();
 714         }
 715
 716 #ifdef CONFIG_FEATURE_IPV6
 717         if (opt & ROUTE_OPT_INET6)
 718                 INET6_setroute(what, argv);
 719         else
 720 #endif
 721                 INET_setroute(what, argv);
 722
 723         return EXIT_SUCCESS;
 724 }