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;
 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                         /* Don't use args_m1 here since args may have changed! */
 286                         rt.rt_dev = args[-1];
 287                         continue;
 288                 }
 289
 290                 /* Nothing matched. */
 291                 bb_show_usage();
 292         }
 293
 294 #ifdef RTF_REJECT
 295         if ((rt.rt_flags & RTF_REJECT) && !rt.rt_dev) {
 296                 rt.rt_dev = "lo";
 297         }
 298 #endif
 299
 300         /* sanity checks.. */
 301         if (mask_in_addr(rt)) {
 302                 unsigned long mask = mask_in_addr(rt);
 303
 304                 mask = ~ntohl(mask);
 305                 if ((rt.rt_flags & RTF_HOST) && mask != 0xffffffff) {
 306                         bb_error_msg_and_die("netmask %.8x and host route conflict",
 307                                                                  (unsigned int) mask);
 308                 }
 309                 if (mask & (mask + 1)) {
 310                         bb_error_msg_and_die("bogus netmask %s", netmask);
 311                 }
 312                 mask = ((struct sockaddr_in *) &rt.rt_dst)->sin_addr.s_addr;
 313                 if (mask & ~mask_in_addr(rt)) {
 314                         bb_error_msg_and_die("netmask and route address conflict");
 315                 }
 316         }
 317
 318         /* Fill out netmask if still unset */
 319         if ((action == RTACTION_ADD) && (rt.rt_flags & RTF_HOST)) {
 320                 mask_in_addr(rt) = 0xffffffff;
 321         }
 322
 323         /* Create a socket to the INET kernel. */
 324         if ((skfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
 325                 bb_perror_msg_and_die("socket");
 326         }
 327
 328         if (ioctl(skfd, ((action==RTACTION_ADD) ? SIOCADDRT : SIOCDELRT), &rt)<0) {
 329                 bb_perror_msg_and_die("SIOC[ADD|DEL]RT");
 330         }
 331
 332         if (ENABLE_FEATURE_CLEAN_UP) 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, bb_INET_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                         /* Don't use args_m1 here since args may have changed! */
 411                         devname = args[-1];
 412                         continue;
 413                 }
 414
 415                 /* Nothing matched. */
 416                 bb_show_usage();
 417         }
 418
 419         /* Create a socket to the INET6 kernel. */
 420         if ((skfd = socket(AF_INET6, SOCK_DGRAM, 0)) < 0) {
 421                 bb_perror_msg_and_die("socket");
 422         }
 423
 424         rt.rtmsg_ifindex = 0;
 425
 426         if (devname) {
 427                 struct ifreq ifr;
 428                 memset(&ifr, 0, sizeof(ifr));
 429                 strcpy(ifr.ifr_name, devname);
 430
 431                 if (ioctl(skfd, SIOGIFINDEX, &ifr) < 0) {
 432                         bb_perror_msg_and_die("SIOGIFINDEX");
 433                 }
 434                 rt.rtmsg_ifindex = ifr.ifr_ifindex;
 435         }
 436
 437         /* Tell the kernel to accept this route. */
 438         if (ioctl(skfd, ((action==RTACTION_ADD) ? SIOCADDRT : SIOCDELRT), &rt)<0) {
 439                 bb_perror_msg_and_die("SIOC[ADD|DEL]RT");
 440         }
 441
 442         if (ENABLE_FEATURE_CLEAN_UP) 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 /* also used in netstat */
 487 void displayroutes(int noresolve, int netstatfmt)
 488 {
 489         char devname[64], flags[16], sdest[16], sgw[16];
 490         unsigned long int d, g, m;
 491         int flgs, ref, use, metric, mtu, win, ir;
 492         struct sockaddr_in s_addr;
 493         struct in_addr mask;
 494
 495         FILE *fp = bb_xfopen("/proc/net/route", "r");
 496
 497         bb_printf("Kernel IP routing table\n"
 498                           "Destination     Gateway         Genmask"
 499                           "         Flags %s Iface\n",
 500                           netstatfmt ? "  MSS Window  irtt" : "Metric Ref    Use");
 501
 502         if (fscanf(fp, "%*[^\n]\n") < 0) { /* Skip the first line. */
 503                 goto ERROR;                /* Empty or missing line, or read error. */
 504         }
 505         while (1) {
 506                 int r;
 507                 r = fscanf(fp, "%63s%lx%lx%X%d%d%d%lx%d%d%d\n",
 508                                    devname, &d, &g, &flgs, &ref, &use, &metric, &m,
 509                                    &mtu, &win, &ir);
 510                 if (r != 11) {
 511                         if ((r < 0) && feof(fp)) { /* EOF with no (nonspace) chars read. */
 512                                 break;
 513                         }
 514                 ERROR:
 515                         bb_error_msg_and_die("fscanf");
 516                 }
 517
 518                 if (!(flgs & RTF_UP)) { /* Skip interfaces that are down. */
 519                         continue;
 520                 }
 521
 522                 set_flags(flags, (flgs & IPV4_MASK));
 523 #ifdef RTF_REJECT
 524                 if (flgs & RTF_REJECT) {
 525                         flags[0] = '!';
 526                 }
 527 #endif
 528
 529                 memset(&s_addr, 0, sizeof(struct sockaddr_in));
 530                 s_addr.sin_family = AF_INET;
 531                 s_addr.sin_addr.s_addr = d;
 532                 INET_rresolve(sdest, sizeof(sdest), &s_addr,
 533                                           (noresolve | 0x8000), m);     /* Default instead of *. */
 534
 535                 s_addr.sin_addr.s_addr = g;
 536                 INET_rresolve(sgw, sizeof(sgw), &s_addr,
 537                                           (noresolve | 0x4000), m);     /* Host instead of net. */
 538
 539                 mask.s_addr = m;
 540                 bb_printf("%-16s%-16s%-16s%-6s", sdest, sgw, inet_ntoa(mask), flags);
 541                 if (netstatfmt) {
 542                         bb_printf("%5d %-5d %6d %s\n", mtu, win, ir, devname);
 543                 } else {
 544                         bb_printf("%-6d %-2d %7d %s\n", metric, ref, use, devname);
 545                 }
 546         }
 547 }
 548
 549 #ifdef CONFIG_FEATURE_IPV6
 550
 551 static void INET6_displayroutes(int noresolve)
 552 {
 553         char addr6[128], naddr6[128];
 554         /* In addr6x, we store both 40-byte ':'-delimited ipv6 addresses.
 555          * We read the non-delimited strings into the tail of the buffer
 556          * using fscanf and then modify the buffer by shifting forward
 557          * while inserting ':'s and the nul terminator for the first string.
 558          * Hence the strings are at addr6x and addr6x+40.  This generates
 559          * _much_ less code than the previous (upstream) approach. */
 560         char addr6x[80];
 561         char iface[16], flags[16];
 562         int iflags, metric, refcnt, use, prefix_len, slen;
 563         struct sockaddr_in6 snaddr6;
 564
 565         FILE *fp = bb_xfopen("/proc/net/ipv6_route", "r");
 566
 567         bb_printf("Kernel IPv6 routing table\n%-44s%-40s"
 568                           "Flags Metric Ref    Use Iface\n",
 569                           "Destination", "Next Hop");
 570
 571         while (1) {
 572                 int r;
 573                 r = fscanf(fp, "%32s%x%*s%x%32s%x%x%x%x%s\n",
 574                                    addr6x+14, &prefix_len, &slen, addr6x+40+7,
 575                                    &metric, &use, &refcnt, &iflags, iface);
 576                 if (r != 9) {
 577                         if ((r < 0) && feof(fp)) { /* EOF with no (nonspace) chars read. */
 578                                 break;
 579                         }
 580                 ERROR:
 581                         bb_error_msg_and_die("fscanf");
 582                 }
 583
 584                 /* Do the addr6x shift-and-insert changes to ':'-delimit addresses.
 585                  * For now, always do this to validate the proc route format, even
 586                  * if the interface is down. */
 587                 {
 588                         int i = 0;
 589                         char *p = addr6x+14;
 590
 591                         do {
 592                                 if (!*p) {
 593                                         if (i==40) { /* nul terminator for 1st address? */
 594                                                 addr6x[39] = 0; /* Fixup... need 0 instead of ':'. */
 595                                                 ++p;    /* Skip and continue. */
 596                                                 continue;
 597                                         }
 598                                         goto ERROR;
 599                                 }
 600                                 addr6x[i++] = *p++;
 601                                 if (!((i+1)%5)) {
 602                                         addr6x[i++] = ':';
 603                                 }
 604                         } while (i < 40+28+7);
 605                 }
 606
 607                 if (!(iflags & RTF_UP)) { /* Skip interfaces that are down. */
 608                         continue;
 609                 }
 610
 611                 set_flags(flags, (iflags & IPV6_MASK));
 612
 613                 r = 0;
 614                 do {
 615                         inet_pton(AF_INET6, addr6x + r,
 616                                           (struct sockaddr *) &snaddr6.sin6_addr);
 617                         snaddr6.sin6_family = AF_INET6;
 618                         INET6_rresolve(naddr6, sizeof(naddr6),
 619                                                    (struct sockaddr_in6 *) &snaddr6,
 620 #if 0
 621                                                    (noresolve | 0x8000) /* Default instead of *. */
 622 #else
 623                                                    0x0fff /* Apparently, upstream never resolves. */
 624 #endif
 625                                                    );
 626
 627                         if (!r) {                       /* 1st pass */
 628                                 snprintf(addr6, sizeof(addr6), "%s/%d", naddr6, prefix_len);
 629                                 r += 40;
 630                         } else {                        /* 2nd pass */
 631                                 /* Print the info. */
 632                                 bb_printf("%-43s %-39s %-5s %-6d %-2d %7d %-8s\n",
 633                                                   addr6, naddr6, flags, metric, refcnt, use, iface);
 634                                 break;
 635                         }
 636                 } while (1);
 637         }
 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 static const char tbl_verb[] =  /* 2nd byte matches RTACTION_* code */
 649         "\006\001add\0"
 650         "\006\002del\0"
 651 /*      "\011\002delete\0" */
 652         "\010\002delete"                        /* Since last, we can save a byte. */
 653 ;
 654
 655 int route_main(int argc, char **argv)
 656 {
 657         unsigned long opt;
 658         int what;
 659         char *family;
 660
 661         /* First, remap '-net' and '-host' to avoid getopt problems. */
 662         {
 663                 char **p = argv;
 664
 665                 while (*++p) {
 666                         if ((strcmp(*p, "-net") == 0) || (strcmp(*p, "-host") == 0)) {
 667                                 p[0][0] = '#';
 668                         }
 669                 }
 670         }
 671
 672         opt = bb_getopt_ulflags(argc, argv, "A:ne", &family);
 673
 674         if ((opt & ROUTE_OPT_A) && strcmp(family, "inet")) {
 675 #ifdef CONFIG_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 #ifdef CONFIG_FEATURE_IPV6
 689                 if (opt & ROUTE_OPT_INET6)
 690                         INET6_displayroutes(noresolve);
 691                 else
 692 #endif
 693                         displayroutes(noresolve, opt & ROUTE_OPT_e);
 694
 695                 bb_xferror_stdout();
 696                 bb_fflush_stdout_and_exit(EXIT_SUCCESS);
 697         }
 698
 699         /* Check verb.  At the moment, must be add, del, or delete. */
 700         what = kw_lookup(tbl_verb, &argv);
 701         if (!what || !*argv) {          /* Unknown verb or no more args. */
 702                 bb_show_usage();
 703         }
 704
 705 #ifdef CONFIG_FEATURE_IPV6
 706         if (opt & ROUTE_OPT_INET6)
 707                 INET6_setroute(what, argv);
 708         else
 709 #endif
 710                 INET_setroute(what, argv);
 711
 712         return EXIT_SUCCESS;
 713 }