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.26 2004/03/19 23:27:08 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 = NULL;
 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                 char *prefix;
 188
 189                 /* recognize x.x.x.x/mask format. */
 190                 prefix = strchr(target, '/');
 191                 if(prefix) {
 192                         int prefix_len;
 193
 194                         prefix_len = bb_xgetularg10_bnd(prefix+1, 0, 32);
 195                         mask_in_addr(rt) = htonl( ~ (0xffffffffUL >> prefix_len));
 196                         *prefix = '\0';
 197 #if HAVE_NEW_ADDRT
 198                         rt.rt_genmask.sa_family = AF_INET;
 199 #endif
 200                 } else {
 201                         /* Default netmask. */
 202                         netmask = bb_INET_default;
 203                 }
 204                 /* Prefer hostname lookup is -host flag (xflag==1) was given. */
 205                 isnet = INET_resolve(target, (struct sockaddr_in *) &rt.rt_dst,
 206                                                          (xflag & HOST_FLAG));
 207                 if (isnet < 0) {
 208                         bb_error_msg_and_die("resolving %s", target);
 209                 }
 210                 if(prefix) {
 211                         /* do not destroy prefix for process args */
 212                         *prefix = '/';
 213                 }
 214         }
 215
 216         if (xflag) {            /* Reinit isnet if -net or -host was specified. */
 217                 isnet = (xflag & NET_FLAG);
 218         }
 219
 220         /* Fill in the other fields. */
 221         rt.rt_flags = ((isnet) ? RTF_UP : (RTF_UP | RTF_HOST));
 222
 223         while (*args) {
 224                 int k = kw_lookup(tbl_ipvx, &args);
 225                 const char *args_m1 = args[-1];
 226
 227                 if (k & KW_IPVx_FLAG_ONLY) {
 228                         rt.rt_flags |= flags_ipvx[k & 3];
 229                         continue;
 230                 }
 231
 232 #if HAVE_NEW_ADDRT
 233                 if (k == KW_IPVx_METRIC) {
 234                         rt.rt_metric = bb_xgetularg10(args_m1) + 1;
 235                         continue;
 236                 }
 237 #endif
 238
 239                 if (k == KW_IPVx_NETMASK) {
 240                         struct sockaddr mask;
 241
 242                         if (mask_in_addr(rt)) {
 243                                 bb_show_usage();
 244                         }
 245
 246                         netmask = args_m1;
 247                         isnet = INET_resolve(netmask, (struct sockaddr_in *) &mask, 0);
 248                         if (isnet < 0) {
 249                                 bb_error_msg_and_die("resolving %s", netmask);
 250                         }
 251                         rt.rt_genmask = full_mask(mask);
 252                         continue;
 253                 }
 254
 255                 if (k == KW_IPVx_GATEWAY) {
 256                         if (rt.rt_flags & RTF_GATEWAY) {
 257                                 bb_show_usage();
 258                         }
 259
 260                         isnet = INET_resolve(args_m1,
 261                                                                  (struct sockaddr_in *) &rt.rt_gateway, 1);
 262                         rt.rt_flags |= RTF_GATEWAY;
 263
 264                         if (isnet) {
 265                                 if (isnet < 0) {
 266                                         bb_error_msg_and_die("resolving %s", args_m1);
 267                                 }
 268                                 bb_error_msg_and_die("gateway %s is a NETWORK", args_m1);
 269                         }
 270                         continue;
 271                 }
 272
 273                 if (k == KW_IPVx_MSS) { /* Check valid MSS bounds. */
 274                         rt.rt_flags |= RTF_MSS;
 275                         rt.rt_mss = bb_xgetularg10_bnd(args_m1, 64, 32768);
 276                         continue;
 277                 }
 278
 279                 if (k == KW_IPVx_WINDOW) {      /* Check valid window bounds. */
 280                         rt.rt_flags |= RTF_WINDOW;
 281                         rt.rt_window = bb_xgetularg10_bnd(args_m1, 128, INT_MAX);
 282                         continue;
 283                 }
 284
 285 #ifdef RTF_IRTT
 286                 if (k == KW_IPVx_IRTT) {
 287                         rt.rt_flags |= RTF_IRTT;
 288                         rt.rt_irtt = bb_xgetularg10(args_m1);
 289                         rt.rt_irtt *= (sysconf(_SC_CLK_TCK) / 100);     /* FIXME */
 290 #if 0                                   /* FIXME: do we need to check anything of this? */
 291                         if (rt.rt_irtt < 1 || rt.rt_irtt > (120 * HZ)) {
 292                                 bb_error_msg_and_die("bad irtt");
 293                         }
 294 #endif
 295                         continue;
 296                 }
 297 #endif
 298
 299                 /* Device is special in that it can be the last arg specified
 300                  * and doesn't requre the dev/device keyword in that case. */
 301                 if (!rt.rt_dev && ((k == KW_IPVx_DEVICE) || (!k && !*++args))) {
 302                         /* Don't use args_m1 here since args may have changed! */
 303                         rt.rt_dev = args[-1];
 304                         continue;
 305                 }
 306
 307                 /* Nothing matched. */
 308                 bb_show_usage();
 309         }
 310
 311 #ifdef RTF_REJECT
 312         if ((rt.rt_flags & RTF_REJECT) && !rt.rt_dev) {
 313                 rt.rt_dev = "lo";
 314         }
 315 #endif
 316
 317         /* sanity checks.. */
 318         if (mask_in_addr(rt)) {
 319                 unsigned long mask = mask_in_addr(rt);
 320
 321                 mask = ~ntohl(mask);
 322                 if ((rt.rt_flags & RTF_HOST) && mask != 0xffffffff) {
 323                         bb_error_msg_and_die("netmask %.8x and host route conflict",
 324                                                                  (unsigned int) mask);
 325                 }
 326                 if (mask & (mask + 1)) {
 327                         bb_error_msg_and_die("bogus netmask %s", netmask);
 328                 }
 329                 mask = ((struct sockaddr_in *) &rt.rt_dst)->sin_addr.s_addr;
 330                 if (mask & ~mask_in_addr(rt)) {
 331                         bb_error_msg_and_die("netmask and route address conflict");
 332                 }
 333         }
 334
 335         /* Fill out netmask if still unset */
 336         if ((action == RTACTION_ADD) && (rt.rt_flags & RTF_HOST)) {
 337                 mask_in_addr(rt) = 0xffffffff;
 338         }
 339
 340         /* Create a socket to the INET kernel. */
 341         if ((skfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
 342                 bb_perror_msg_and_die("socket");
 343         }
 344
 345         if (ioctl(skfd, ((action==RTACTION_ADD) ? SIOCADDRT : SIOCDELRT), &rt)<0) {
 346                 bb_perror_msg_and_die("SIOC[ADD|DEL]RT");
 347         }
 348
 349         if (ENABLE_FEATURE_CLEAN_UP) close(skfd);
 350 }
 351
 352 #ifdef CONFIG_FEATURE_IPV6
 353
 354 static void INET6_setroute(int action, char **args)
 355 {
 356         struct sockaddr_in6 sa6;
 357         struct in6_rtmsg rt;
 358         int prefix_len, skfd;
 359         const char *devname;
 360
 361         assert((action == RTACTION_ADD) || (action == RTACTION_DEL));
 362
 363         {
 364                 /* We know args isn't NULL from the check in route_main. */
 365                 const char *target = *args++;
 366
 367                 if (strcmp(target, bb_INET_default) == 0) {
 368                         prefix_len = 0;
 369                         memset(&sa6, 0, sizeof(sa6));
 370                 } else {
 371                         char *cp;
 372                         if ((cp = strchr(target, '/'))) { /* Yes... const to non is ok. */
 373                                 *cp = 0;
 374                                 prefix_len = bb_xgetularg10_bnd(cp+1, 0, 128);
 375                         } else {
 376                                 prefix_len = 128;
 377                         }
 378                         if (INET6_resolve(target, (struct sockaddr_in6 *) &sa6) < 0) {
 379                                 bb_error_msg_and_die("resolving %s", target);
 380                         }
 381                 }
 382         }
 383
 384         /* Clean out the RTREQ structure. */
 385         memset((char *) &rt, 0, sizeof(struct in6_rtmsg));
 386
 387         memcpy(&rt.rtmsg_dst, sa6.sin6_addr.s6_addr, sizeof(struct in6_addr));
 388
 389         /* Fill in the other fields. */
 390         rt.rtmsg_dst_len = prefix_len;
 391         rt.rtmsg_flags = ((prefix_len == 128) ? (RTF_UP|RTF_HOST) : RTF_UP);
 392         rt.rtmsg_metric = 1;
 393
 394         devname = NULL;
 395
 396         while (*args) {
 397                 int k = kw_lookup(tbl_ipvx, &args);
 398                 const char *args_m1 = args[-1];
 399
 400                 if ((k == KW_IPVx_MOD) || (k == KW_IPVx_DYN)) {
 401                         rt.rtmsg_flags |= flags_ipvx[k & 3];
 402                         continue;
 403                 }
 404
 405                 if (k == KW_IPVx_METRIC) {
 406                         rt.rtmsg_metric = bb_xgetularg10(args_m1);
 407                         continue;
 408                 }
 409
 410                 if (k == KW_IPVx_GATEWAY) {
 411                         if (rt.rtmsg_flags & RTF_GATEWAY) {
 412                                 bb_show_usage();
 413                         }
 414
 415                         if (INET6_resolve(args_m1, (struct sockaddr_in6 *) &sa6) < 0) {
 416                                 bb_error_msg_and_die("resolving %s", args_m1);
 417                         }
 418                         memcpy(&rt.rtmsg_gateway, sa6.sin6_addr.s6_addr,
 419                                    sizeof(struct in6_addr));
 420                         rt.rtmsg_flags |= RTF_GATEWAY;
 421                         continue;
 422                 }
 423
 424                 /* Device is special in that it can be the last arg specified
 425                  * and doesn't requre the dev/device keyword in that case. */
 426                 if (!devname && ((k == KW_IPVx_DEVICE) || (!k && !*++args))) {
 427                         /* Don't use args_m1 here since args may have changed! */
 428                         devname = args[-1];
 429                         continue;
 430                 }
 431
 432                 /* Nothing matched. */
 433                 bb_show_usage();
 434         }
 435
 436         /* Create a socket to the INET6 kernel. */
 437         if ((skfd = socket(AF_INET6, SOCK_DGRAM, 0)) < 0) {
 438                 bb_perror_msg_and_die("socket");
 439         }
 440
 441         rt.rtmsg_ifindex = 0;
 442
 443         if (devname) {
 444                 struct ifreq ifr;
 445                 memset(&ifr, 0, sizeof(ifr));
 446                 strcpy(ifr.ifr_name, devname);
 447
 448                 if (ioctl(skfd, SIOGIFINDEX, &ifr) < 0) {
 449                         bb_perror_msg_and_die("SIOGIFINDEX");
 450                 }
 451                 rt.rtmsg_ifindex = ifr.ifr_ifindex;
 452         }
 453
 454         /* Tell the kernel to accept this route. */
 455         if (ioctl(skfd, ((action==RTACTION_ADD) ? SIOCADDRT : SIOCDELRT), &rt)<0) {
 456                 bb_perror_msg_and_die("SIOC[ADD|DEL]RT");
 457         }
 458
 459         if (ENABLE_FEATURE_CLEAN_UP) close(skfd);
 460 }
 461 #endif
 462
 463 static const unsigned int flagvals[] = { /* Must agree with flagchars[]. */
 464         RTF_GATEWAY,
 465         RTF_HOST,
 466         RTF_REINSTATE,
 467         RTF_DYNAMIC,
 468         RTF_MODIFIED,
 469 #ifdef CONFIG_FEATURE_IPV6
 470         RTF_DEFAULT,
 471         RTF_ADDRCONF,
 472         RTF_CACHE
 473 #endif
 474 };
 475
 476 #define IPV4_MASK (RTF_GATEWAY|RTF_HOST|RTF_REINSTATE|RTF_DYNAMIC|RTF_MODIFIED)
 477 #define IPV6_MASK (RTF_GATEWAY|RTF_HOST|RTF_DEFAULT|RTF_ADDRCONF|RTF_CACHE)
 478
 479 static const char flagchars[] =         /* Must agree with flagvals[]. */
 480         "GHRDM"
 481 #ifdef CONFIG_FEATURE_IPV6
 482         "DAC"
 483 #endif
 484 ;
 485
 486 static
 487 #ifndef CONFIG_FEATURE_IPV6
 488 __inline
 489 #endif
 490 void set_flags(char *flagstr, int flags)
 491 {
 492         int i;
 493
 494         *flagstr++ = 'U';
 495
 496         for (i=0 ; (*flagstr = flagchars[i]) != 0 ; i++) {
 497                 if (flags & flagvals[i]) {
 498                         ++flagstr;
 499                 }
 500         }
 501 }
 502
 503 /* also used in netstat */
 504 void displayroutes(int noresolve, int netstatfmt)
 505 {
 506         char devname[64], flags[16], sdest[16], sgw[16];
 507         unsigned long int d, g, m;
 508         int flgs, ref, use, metric, mtu, win, ir;
 509         struct sockaddr_in s_addr;
 510         struct in_addr mask;
 511
 512         FILE *fp = bb_xfopen("/proc/net/route", "r");
 513
 514         bb_printf("Kernel IP routing table\n"
 515                           "Destination     Gateway         Genmask"
 516                           "         Flags %s Iface\n",
 517                           netstatfmt ? "  MSS Window  irtt" : "Metric Ref    Use");
 518
 519         if (fscanf(fp, "%*[^\n]\n") < 0) { /* Skip the first line. */
 520                 goto ERROR;                /* Empty or missing line, or read error. */
 521         }
 522         while (1) {
 523                 int r;
 524                 r = fscanf(fp, "%63s%lx%lx%X%d%d%d%lx%d%d%d\n",
 525                                    devname, &d, &g, &flgs, &ref, &use, &metric, &m,
 526                                    &mtu, &win, &ir);
 527                 if (r != 11) {
 528                         if ((r < 0) && feof(fp)) { /* EOF with no (nonspace) chars read. */
 529                                 break;
 530                         }
 531                 ERROR:
 532                         bb_error_msg_and_die("fscanf");
 533                 }
 534
 535                 if (!(flgs & RTF_UP)) { /* Skip interfaces that are down. */
 536                         continue;
 537                 }
 538
 539                 set_flags(flags, (flgs & IPV4_MASK));
 540 #ifdef RTF_REJECT
 541                 if (flgs & RTF_REJECT) {
 542                         flags[0] = '!';
 543                 }
 544 #endif
 545
 546                 memset(&s_addr, 0, sizeof(struct sockaddr_in));
 547                 s_addr.sin_family = AF_INET;
 548                 s_addr.sin_addr.s_addr = d;
 549                 INET_rresolve(sdest, sizeof(sdest), &s_addr,
 550                                           (noresolve | 0x8000), m);     /* Default instead of *. */
 551
 552                 s_addr.sin_addr.s_addr = g;
 553                 INET_rresolve(sgw, sizeof(sgw), &s_addr,
 554                                           (noresolve | 0x4000), m);     /* Host instead of net. */
 555
 556                 mask.s_addr = m;
 557                 bb_printf("%-16s%-16s%-16s%-6s", sdest, sgw, inet_ntoa(mask), flags);
 558                 if (netstatfmt) {
 559                         bb_printf("%5d %-5d %6d %s\n", mtu, win, ir, devname);
 560                 } else {
 561                         bb_printf("%-6d %-2d %7d %s\n", metric, ref, use, devname);
 562                 }
 563         }
 564 }
 565
 566 #ifdef CONFIG_FEATURE_IPV6
 567
 568 static void INET6_displayroutes(int noresolve)
 569 {
 570         char addr6[128], naddr6[128];
 571         /* In addr6x, we store both 40-byte ':'-delimited ipv6 addresses.
 572          * We read the non-delimited strings into the tail of the buffer
 573          * using fscanf and then modify the buffer by shifting forward
 574          * while inserting ':'s and the nul terminator for the first string.
 575          * Hence the strings are at addr6x and addr6x+40.  This generates
 576          * _much_ less code than the previous (upstream) approach. */
 577         char addr6x[80];
 578         char iface[16], flags[16];
 579         int iflags, metric, refcnt, use, prefix_len, slen;
 580         struct sockaddr_in6 snaddr6;
 581
 582         FILE *fp = bb_xfopen("/proc/net/ipv6_route", "r");
 583
 584         bb_printf("Kernel IPv6 routing table\n%-44s%-40s"
 585                           "Flags Metric Ref    Use Iface\n",
 586                           "Destination", "Next Hop");
 587
 588         while (1) {
 589                 int r;
 590                 r = fscanf(fp, "%32s%x%*s%x%32s%x%x%x%x%s\n",
 591                                    addr6x+14, &prefix_len, &slen, addr6x+40+7,
 592                                    &metric, &use, &refcnt, &iflags, iface);
 593                 if (r != 9) {
 594                         if ((r < 0) && feof(fp)) { /* EOF with no (nonspace) chars read. */
 595                                 break;
 596                         }
 597                 ERROR:
 598                         bb_error_msg_and_die("fscanf");
 599                 }
 600
 601                 /* Do the addr6x shift-and-insert changes to ':'-delimit addresses.
 602                  * For now, always do this to validate the proc route format, even
 603                  * if the interface is down. */
 604                 {
 605                         int i = 0;
 606                         char *p = addr6x+14;
 607
 608                         do {
 609                                 if (!*p) {
 610                                         if (i==40) { /* nul terminator for 1st address? */
 611                                                 addr6x[39] = 0; /* Fixup... need 0 instead of ':'. */
 612                                                 ++p;    /* Skip and continue. */
 613                                                 continue;
 614                                         }
 615                                         goto ERROR;
 616                                 }
 617                                 addr6x[i++] = *p++;
 618                                 if (!((i+1)%5)) {
 619                                         addr6x[i++] = ':';
 620                                 }
 621                         } while (i < 40+28+7);
 622                 }
 623
 624                 if (!(iflags & RTF_UP)) { /* Skip interfaces that are down. */
 625                         continue;
 626                 }
 627
 628                 set_flags(flags, (iflags & IPV6_MASK));
 629
 630                 r = 0;
 631                 do {
 632                         inet_pton(AF_INET6, addr6x + r,
 633                                           (struct sockaddr *) &snaddr6.sin6_addr);
 634                         snaddr6.sin6_family = AF_INET6;
 635                         INET6_rresolve(naddr6, sizeof(naddr6),
 636                                                    (struct sockaddr_in6 *) &snaddr6,
 637 #if 0
 638                                                    (noresolve | 0x8000) /* Default instead of *. */
 639 #else
 640                                                    0x0fff /* Apparently, upstream never resolves. */
 641 #endif
 642                                                    );
 643
 644                         if (!r) {                       /* 1st pass */
 645                                 snprintf(addr6, sizeof(addr6), "%s/%d", naddr6, prefix_len);
 646                                 r += 40;
 647                         } else {                        /* 2nd pass */
 648                                 /* Print the info. */
 649                                 bb_printf("%-43s %-39s %-5s %-6d %-2d %7d %-8s\n",
 650                                                   addr6, naddr6, flags, metric, refcnt, use, iface);
 651                                 break;
 652                         }
 653                 } while (1);
 654         }
 655 }
 656
 657 #endif
 658
 659 #define ROUTE_OPT_A                     0x01
 660 #define ROUTE_OPT_n                     0x02
 661 #define ROUTE_OPT_e                     0x04
 662 #define ROUTE_OPT_INET6         0x08 /* Not an actual option. See below. */
 663
 664 /* 1st byte is offset to next entry offset.  2nd byte is return value. */
 665 static const char tbl_verb[] =  /* 2nd byte matches RTACTION_* code */
 666         "\006\001add\0"
 667         "\006\002del\0"
 668 /*      "\011\002delete\0" */
 669         "\010\002delete"                        /* Since last, we can save a byte. */
 670 ;
 671
 672 int route_main(int argc, char **argv)
 673 {
 674         unsigned long opt;
 675         int what;
 676         char *family;
 677
 678         /* First, remap '-net' and '-host' to avoid getopt problems. */
 679         {
 680                 char **p = argv;
 681
 682                 while (*++p) {
 683                         if ((strcmp(*p, "-net") == 0) || (strcmp(*p, "-host") == 0)) {
 684                                 p[0][0] = '#';
 685                         }
 686                 }
 687         }
 688
 689         opt = bb_getopt_ulflags(argc, argv, "A:ne", &family);
 690
 691         if ((opt & ROUTE_OPT_A) && strcmp(family, "inet")) {
 692 #ifdef CONFIG_FEATURE_IPV6
 693                 if (strcmp(family, "inet6") == 0) {
 694                         opt |= ROUTE_OPT_INET6; /* Set flag for ipv6. */
 695                 } else
 696 #endif
 697                 bb_show_usage();
 698         }
 699
 700         argv += optind;
 701
 702         /* No more args means display the routing table. */
 703         if (!*argv) {
 704                 int noresolve = (opt & ROUTE_OPT_n) ? 0x0fff : 0;
 705 #ifdef CONFIG_FEATURE_IPV6
 706                 if (opt & ROUTE_OPT_INET6)
 707                         INET6_displayroutes(noresolve);
 708                 else
 709 #endif
 710                         displayroutes(noresolve, opt & ROUTE_OPT_e);
 711
 712                 bb_xferror_stdout();
 713                 bb_fflush_stdout_and_exit(EXIT_SUCCESS);
 714         }
 715
 716         /* Check verb.  At the moment, must be add, del, or delete. */
 717         what = kw_lookup(tbl_verb, &argv);
 718         if (!what || !*argv) {          /* Unknown verb or no more args. */
 719                 bb_show_usage();
 720         }
 721
 722 #ifdef CONFIG_FEATURE_IPV6
 723         if (opt & ROUTE_OPT_INET6)
 724                 INET6_setroute(what, argv);
 725         else
 726 #endif
 727                 INET_setroute(what, argv);
 728
 729         return EXIT_SUCCESS;
 730 }