networking/interface.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * stolen from net-tools-1.59 and stripped down for busybox by
   4  *                      Erik Andersen <andersen@codepoet.org>
   5  *
   6  * Heavily modified by Manuel Novoa III       Mar 12, 2001
   7  *
   8  * Added print_bytes_scaled function to reduce code size.
   9  * Added some (potentially) missing defines.
  10  * Improved display support for -a and for a named interface.
  11  *
  12  * -----------------------------------------------------------
  13  *
  14  * ifconfig   This file contains an implementation of the command
  15  *              that either displays or sets the characteristics of
  16  *              one or more of the system's networking interfaces.
  17  *
  18  *
  19  * Author:      Fred N. van Kempen, <waltje@uwalt.nl.mugnet.org>
  20  *              and others.  Copyright 1993 MicroWalt Corporation
  21  *
  22  * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  23  *
  24  * Patched to support 'add' and 'del' keywords for INET(4) addresses
  25  * by Mrs. Brisby <mrs.brisby@nimh.org>
  26  *
  27  * {1.34} - 19980630 - Arnaldo Carvalho de Melo <acme@conectiva.com.br>
  28  *                     - gettext instead of catgets for i18n
  29  *          10/1998  - Andi Kleen. Use interface list primitives.
  30  *          20001008 - Bernd Eckenfels, Patch from RH for setting mtu
  31  *                      (default AF was wrong)
  32  */
  33 #include "libbb.h"
  34 #include "inet_common.h"
  35 #include <net/if.h>
  36 #include <net/if_arp.h>
  37 #ifdef HAVE_NET_ETHERNET_H
  38 # include <net/ethernet.h>
  39 #endif
  40
  41 #if ENABLE_FEATURE_HWIB
  42 /* #include <linux/if_infiniband.h> */
  43 # undef INFINIBAND_ALEN
  44 # define INFINIBAND_ALEN 20
  45 #endif
  46
  47 #if ENABLE_FEATURE_IPV6
  48 # define HAVE_AFINET6 1
  49 #else
  50 # undef HAVE_AFINET6
  51 #endif
  52
  53 #define _PATH_PROCNET_DEV               "/proc/net/dev"
  54 #define _PATH_PROCNET_IFINET6           "/proc/net/if_inet6"
  55
  56 #ifdef HAVE_AFINET6
  57 # ifndef _LINUX_IN6_H
  58 /*
  59  * This is from linux/include/net/ipv6.h
  60  */
  61 struct in6_ifreq {
  62         struct in6_addr ifr6_addr;
  63         uint32_t ifr6_prefixlen;
  64         unsigned int ifr6_ifindex;
  65 };
  66 # endif
  67 #endif /* HAVE_AFINET6 */
  68
  69 /* Defines for glibc2.0 users. */
  70 #ifndef SIOCSIFTXQLEN
  71 # define SIOCSIFTXQLEN      0x8943
  72 # define SIOCGIFTXQLEN      0x8942
  73 #endif
  74
  75 /* ifr_qlen is ifru_ivalue, but it isn't present in 2.0 kernel headers */
  76 #ifndef ifr_qlen
  77 # define ifr_qlen        ifr_ifru.ifru_mtu
  78 #endif
  79
  80 #ifndef HAVE_TXQUEUELEN
  81 # define HAVE_TXQUEUELEN 1
  82 #endif
  83
  84 #ifndef IFF_DYNAMIC
  85 # define IFF_DYNAMIC     0x8000 /* dialup device with changing addresses */
  86 #endif
  87
  88 /* Display an Internet socket address. */
  89 static const char* FAST_FUNC INET_sprint(struct sockaddr *sap, int numeric)
  90 {
  91         if (sap->sa_family == 0xFFFF || sap->sa_family == 0)
  92                 return "[NONE SET]";
  93         return auto_string(INET_rresolve((struct sockaddr_in *) sap, numeric, 0xffffff00));
  94 }
  95
  96 #ifdef UNUSED_AND_BUGGY
  97 static int INET_getsock(char *bufp, struct sockaddr *sap)
  98 {
  99         char *sp = bufp, *bp;
 100         unsigned int i;
 101         unsigned val;
 102         struct sockaddr_in *sock_in;
 103
 104         sock_in = (struct sockaddr_in *) sap;
 105         sock_in->sin_family = AF_INET;
 106         sock_in->sin_port = 0;
 107
 108         val = 0;
 109         bp = (char *) &val;
 110         for (i = 0; i < sizeof(sock_in->sin_addr.s_addr); i++) {
 111                 *sp = toupper(*sp);
 112
 113                 if ((unsigned)(*sp - 'A') <= 5)
 114                         bp[i] |= (int) (*sp - ('A' - 10));
 115                 else if (isdigit(*sp))
 116                         bp[i] |= (int) (*sp - '0');
 117                 else
 118                         return -1;
 119
 120                 bp[i] <<= 4;
 121                 sp++;
 122                 *sp = toupper(*sp);
 123
 124                 if ((unsigned)(*sp - 'A') <= 5)
 125                         bp[i] |= (int) (*sp - ('A' - 10));
 126                 else if (isdigit(*sp))
 127                         bp[i] |= (int) (*sp - '0');
 128                 else
 129                         return -1;
 130
 131                 sp++;
 132         }
 133         sock_in->sin_addr.s_addr = htonl(val);
 134
 135         return (sp - bufp);
 136 }
 137 #endif
 138
 139 static int FAST_FUNC INET_input(/*int type,*/ const char *bufp, struct sockaddr *sap)
 140 {
 141         return INET_resolve(bufp, (struct sockaddr_in *) sap, 0);
 142 /*
 143         switch (type) {
 144         case 1:
 145                 return (INET_getsock(bufp, sap));
 146         case 256:
 147                 return (INET_resolve(bufp, (struct sockaddr_in *) sap, 1));
 148         default:
 149                 return (INET_resolve(bufp, (struct sockaddr_in *) sap, 0));
 150         }
 151 */
 152 }
 153
 154 static const struct aftype inet_aftype = {
 155         .name   = "inet",
 156         .title  = "DARPA Internet",
 157         .af     = AF_INET,
 158         .alen   = 4,
 159         .sprint = INET_sprint,
 160         .input  = INET_input,
 161 };
 162
 163 #ifdef HAVE_AFINET6
 164
 165 /* Display an Internet socket address. */
 166 /* dirty! struct sockaddr usually doesn't suffer for inet6 addresses, fst. */
 167 static const char* FAST_FUNC INET6_sprint(struct sockaddr *sap, int numeric)
 168 {
 169         if (sap->sa_family == 0xFFFF || sap->sa_family == 0)
 170                 return "[NONE SET]";
 171         return auto_string(INET6_rresolve((struct sockaddr_in6 *) sap, numeric));
 172 }
 173
 174 #ifdef UNUSED
 175 static int INET6_getsock(char *bufp, struct sockaddr *sap)
 176 {
 177         struct sockaddr_in6 *sin6;
 178
 179         sin6 = (struct sockaddr_in6 *) sap;
 180         sin6->sin6_family = AF_INET6;
 181         sin6->sin6_port = 0;
 182
 183         if (inet_pton(AF_INET6, bufp, sin6->sin6_addr.s6_addr) <= 0)
 184                 return -1;
 185
 186         return 16;                      /* ?;) */
 187 }
 188 #endif
 189
 190 static int FAST_FUNC INET6_input(/*int type,*/ const char *bufp, struct sockaddr *sap)
 191 {
 192         return INET6_resolve(bufp, (struct sockaddr_in6 *) sap);
 193 /*
 194         switch (type) {
 195         case 1:
 196                 return (INET6_getsock(bufp, sap));
 197         default:
 198                 return (INET6_resolve(bufp, (struct sockaddr_in6 *) sap));
 199         }
 200 */
 201 }
 202
 203 static const struct aftype inet6_aftype = {
 204         .name   = "inet6",
 205         .title  = "IPv6",
 206         .af     = AF_INET6,
 207         .alen   = sizeof(struct in6_addr),
 208         .sprint = INET6_sprint,
 209         .input  = INET6_input,
 210 };
 211
 212 #endif /* HAVE_AFINET6 */
 213
 214 /* Display an UNSPEC address. */
 215 static char* FAST_FUNC UNSPEC_print(unsigned char *ptr)
 216 {
 217         char *buff;
 218         char *pos;
 219         unsigned int i;
 220
 221         buff = auto_string(xmalloc(sizeof(struct sockaddr) * 3 + 1));
 222         pos = buff;
 223         for (i = 0; i < sizeof(struct sockaddr); i++) {
 224                 /* careful -- not every libc's sprintf returns # bytes written */
 225                 sprintf(pos, "%02X-", *ptr++);
 226                 pos += 3;
 227         }
 228         /* Erase trailing "-".  Works as long as sizeof(struct sockaddr) != 0 */
 229         *--pos = '\0';
 230         return buff;
 231 }
 232
 233 /* Display an UNSPEC socket address. */
 234 static const char* FAST_FUNC UNSPEC_sprint(struct sockaddr *sap, int numeric UNUSED_PARAM)
 235 {
 236         if (sap->sa_family == 0xFFFF || sap->sa_family == 0)
 237                 return "[NONE SET]";
 238         return UNSPEC_print((unsigned char *)sap->sa_data);
 239 }
 240
 241 static const struct aftype unspec_aftype = {
 242         .name   = "unspec",
 243         .title  = "UNSPEC",
 244         .af     = AF_UNSPEC,
 245         .alen   = 0,
 246         .print  = UNSPEC_print,
 247         .sprint = UNSPEC_sprint,
 248 };
 249
 250 static const struct aftype *const aftypes[] = {
 251         &inet_aftype,
 252 #ifdef HAVE_AFINET6
 253         &inet6_aftype,
 254 #endif
 255         &unspec_aftype,
 256         NULL
 257 };
 258
 259 /* Check our protocol family table for this family. */
 260 const struct aftype* FAST_FUNC get_aftype(const char *name)
 261 {
 262         const struct aftype *const *afp;
 263
 264         afp = aftypes;
 265         while (*afp != NULL) {
 266                 if (strcmp((*afp)->name, name) == 0)
 267                         return (*afp);
 268                 afp++;
 269         }
 270         return NULL;
 271 }
 272
 273 /* Check our protocol family table for this family. */
 274 static const struct aftype *get_afntype(int af)
 275 {
 276         const struct aftype *const *afp;
 277
 278         afp = aftypes;
 279         while (*afp != NULL) {
 280                 if ((*afp)->af == af)
 281                         return *afp;
 282                 afp++;
 283         }
 284         return NULL;
 285 }
 286
 287 struct user_net_device_stats {
 288         unsigned long long rx_packets;  /* total packets received       */
 289         unsigned long long tx_packets;  /* total packets transmitted    */
 290         unsigned long long rx_bytes;    /* total bytes received         */
 291         unsigned long long tx_bytes;    /* total bytes transmitted      */
 292         unsigned long rx_errors;        /* bad packets received         */
 293         unsigned long tx_errors;        /* packet transmit problems     */
 294         unsigned long rx_dropped;       /* no space in linux buffers    */
 295         unsigned long tx_dropped;       /* no space available in linux  */
 296         unsigned long rx_multicast;     /* multicast packets received   */
 297         unsigned long rx_compressed;
 298         unsigned long tx_compressed;
 299         unsigned long collisions;
 300
 301         /* detailed rx_errors: */
 302         unsigned long rx_length_errors;
 303         unsigned long rx_over_errors;   /* receiver ring buff overflow  */
 304         unsigned long rx_crc_errors;    /* recved pkt with crc error    */
 305         unsigned long rx_frame_errors;  /* recv'd frame alignment error */
 306         unsigned long rx_fifo_errors;   /* recv'r fifo overrun          */
 307         unsigned long rx_missed_errors; /* receiver missed packet     */
 308         /* detailed tx_errors */
 309         unsigned long tx_aborted_errors;
 310         unsigned long tx_carrier_errors;
 311         unsigned long tx_fifo_errors;
 312         unsigned long tx_heartbeat_errors;
 313         unsigned long tx_window_errors;
 314 };
 315
 316 struct interface {
 317         struct interface *next, *prev;
 318         char name[IFNAMSIZ];                    /* interface name        */
 319         short type;                             /* if type               */
 320         short flags;                            /* various flags         */
 321         int metric;                             /* routing metric        */
 322         int mtu;                                /* MTU value             */
 323         int tx_queue_len;                       /* transmit queue length */
 324         struct ifmap map;                       /* hardware setup        */
 325         struct sockaddr addr;                   /* IP address            */
 326         struct sockaddr dstaddr;                /* P-P IP address        */
 327         struct sockaddr broadaddr;              /* IP broadcast address  */
 328         struct sockaddr netmask;                /* IP network mask       */
 329         int has_ip;
 330         char hwaddr[32];                        /* HW address            */
 331         int statistics_valid;
 332         struct user_net_device_stats stats;     /* statistics            */
 333         int keepalive;                          /* keepalive value for SLIP */
 334         int outfill;                            /* outfill value for SLIP */
 335 };
 336
 337
 338 smallint interface_opt_a;       /* show all interfaces */
 339
 340 static struct interface *int_list, *int_last;
 341
 342
 343 #if 0
 344 /* like strcmp(), but knows about numbers */
 345 except that the freshly added calls to xatoul() brf on ethernet aliases with
 346 uClibc with e.g.: ife->name='lo'  name='eth0:1'
 347 static int nstrcmp(const char *a, const char *b)
 348 {
 349         const char *a_ptr = a;
 350         const char *b_ptr = b;
 351
 352         while (*a == *b) {
 353                 if (*a == '\0') {
 354                         return 0;
 355                 }
 356                 if (!isdigit(*a) && isdigit(*(a+1))) {
 357                         a_ptr = a+1;
 358                         b_ptr = b+1;
 359                 }
 360                 a++;
 361                 b++;
 362         }
 363
 364         if (isdigit(*a) && isdigit(*b)) {
 365                 return xatoul(a_ptr) > xatoul(b_ptr) ? 1 : -1;
 366         }
 367         return *a - *b;
 368 }
 369 #endif
 370
 371 static struct interface *add_interface(char *name)
 372 {
 373         struct interface *ife, **nextp, *new;
 374
 375         for (ife = int_last; ife; ife = ife->prev) {
 376                 int n = /*n*/strcmp(ife->name, name);
 377
 378                 if (n == 0)
 379                         return ife;
 380                 if (n < 0)
 381                         break;
 382         }
 383
 384         new = xzalloc(sizeof(*new));
 385         strncpy_IFNAMSIZ(new->name, name);
 386         nextp = ife ? &ife->next : &int_list;
 387         new->prev = ife;
 388         new->next = *nextp;
 389         if (new->next)
 390                 new->next->prev = new;
 391         else
 392                 int_last = new;
 393         *nextp = new;
 394         return new;
 395 }
 396
 397 static char *get_name(char *name, char *p)
 398 {
 399         /* Extract <name> from nul-terminated p where p matches
 400          * <name>: after leading whitespace.
 401          * If match is not made, set name empty and return unchanged p
 402          */
 403         char *nameend;
 404         char *namestart = skip_whitespace(p);
 405
 406         nameend = namestart;
 407         while (*nameend && *nameend != ':' && !isspace(*nameend))
 408                 nameend++;
 409         if (*nameend == ':') {
 410                 if ((nameend - namestart) < IFNAMSIZ) {
 411                         memcpy(name, namestart, nameend - namestart);
 412                         name[nameend - namestart] = '\0';
 413                         p = nameend;
 414                 } else {
 415                         /* Interface name too large */
 416                         name[0] = '\0';
 417                 }
 418         } else {
 419                 /* trailing ':' not found - return empty */
 420                 name[0] = '\0';
 421         }
 422         return p + 1;
 423 }
 424
 425 /* If scanf supports size qualifiers for %n conversions, then we can
 426  * use a modified fmt that simply stores the position in the fields
 427  * having no associated fields in the proc string.  Of course, we need
 428  * to zero them again when we're done.  But that is smaller than the
 429  * old approach of multiple scanf occurrences with large numbers of
 430  * args. */
 431
 432 /* static const char *const ss_fmt[] = { */
 433 /*      "%lln%llu%lu%lu%lu%lu%ln%ln%lln%llu%lu%lu%lu%lu%lu", */
 434 /*      "%llu%llu%lu%lu%lu%lu%ln%ln%llu%llu%lu%lu%lu%lu%lu", */
 435 /*      "%llu%llu%lu%lu%lu%lu%lu%lu%llu%llu%lu%lu%lu%lu%lu%lu" */
 436 /* }; */
 437
 438         /* Lie about the size of the int pointed to for %n. */
 439 #if INT_MAX == LONG_MAX
 440 static const char *const ss_fmt[] = {
 441         "%n%llu%u%u%u%u%n%n%n%llu%u%u%u%u%u",
 442         "%llu%llu%u%u%u%u%n%n%llu%llu%u%u%u%u%u",
 443         "%llu%llu%u%u%u%u%u%u%llu%llu%u%u%u%u%u%u"
 444 };
 445 #else
 446 static const char *const ss_fmt[] = {
 447         "%n%llu%lu%lu%lu%lu%n%n%n%llu%lu%lu%lu%lu%lu",
 448         "%llu%llu%lu%lu%lu%lu%n%n%llu%llu%lu%lu%lu%lu%lu",
 449         "%llu%llu%lu%lu%lu%lu%lu%lu%llu%llu%lu%lu%lu%lu%lu%lu"
 450 };
 451
 452 #endif
 453
 454 static void get_dev_fields(char *bp, struct interface *ife, int procnetdev_vsn)
 455 {
 456         memset(&ife->stats, 0, sizeof(struct user_net_device_stats));
 457
 458         sscanf(bp, ss_fmt[procnetdev_vsn],
 459                    &ife->stats.rx_bytes, /* missing for 0 */
 460                    &ife->stats.rx_packets,
 461                    &ife->stats.rx_errors,
 462                    &ife->stats.rx_dropped,
 463                    &ife->stats.rx_fifo_errors,
 464                    &ife->stats.rx_frame_errors,
 465                    &ife->stats.rx_compressed, /* missing for <= 1 */
 466                    &ife->stats.rx_multicast, /* missing for <= 1 */
 467                    &ife->stats.tx_bytes, /* missing for 0 */
 468                    &ife->stats.tx_packets,
 469                    &ife->stats.tx_errors,
 470                    &ife->stats.tx_dropped,
 471                    &ife->stats.tx_fifo_errors,
 472                    &ife->stats.collisions,
 473                    &ife->stats.tx_carrier_errors,
 474                    &ife->stats.tx_compressed /* missing for <= 1 */
 475                    );
 476
 477         if (procnetdev_vsn <= 1) {
 478                 if (procnetdev_vsn == 0) {
 479                         ife->stats.rx_bytes = 0;
 480                         ife->stats.tx_bytes = 0;
 481                 }
 482                 ife->stats.rx_multicast = 0;
 483                 ife->stats.rx_compressed = 0;
 484                 ife->stats.tx_compressed = 0;
 485         }
 486 }
 487
 488 static int procnetdev_version(char *buf)
 489 {
 490         if (strstr(buf, "compressed"))
 491                 return 2;
 492         if (strstr(buf, "bytes"))
 493                 return 1;
 494         return 0;
 495 }
 496
 497 static int if_readconf(void)
 498 {
 499         int numreqs = 30;
 500         struct ifconf ifc;
 501         struct ifreq *ifr;
 502         int n, err = -1;
 503         int skfd;
 504
 505         ifc.ifc_buf = NULL;
 506
 507         /* SIOCGIFCONF currently seems to only work properly on AF_INET sockets
 508            (as of 2.1.128) */
 509         skfd = socket(AF_INET, SOCK_DGRAM, 0);
 510         if (skfd < 0) {
 511                 bb_perror_msg("error: no inet socket available");
 512                 return -1;
 513         }
 514
 515         for (;;) {
 516                 ifc.ifc_len = sizeof(struct ifreq) * numreqs;
 517                 ifc.ifc_buf = xrealloc(ifc.ifc_buf, ifc.ifc_len);
 518
 519                 if (ioctl_or_warn(skfd, SIOCGIFCONF, &ifc) < 0) {
 520                         goto out;
 521                 }
 522                 if (ifc.ifc_len == (int)(sizeof(struct ifreq) * numreqs)) {
 523                         /* assume it overflowed and try again */
 524                         numreqs += 10;
 525                         continue;
 526                 }
 527                 break;
 528         }
 529
 530         ifr = ifc.ifc_req;
 531         for (n = 0; n < ifc.ifc_len; n += sizeof(struct ifreq)) {
 532                 add_interface(ifr->ifr_name);
 533                 ifr++;
 534         }
 535         err = 0;
 536
 537  out:
 538         close(skfd);
 539         free(ifc.ifc_buf);
 540         return err;
 541 }
 542
 543 static int if_readlist_proc(char *target)
 544 {
 545         static smallint proc_read;
 546
 547         FILE *fh;
 548         char buf[512];
 549         struct interface *ife;
 550         int err, procnetdev_vsn;
 551
 552         if (proc_read)
 553                 return 0;
 554         if (!target)
 555                 proc_read = 1;
 556
 557         fh = fopen_or_warn(_PATH_PROCNET_DEV, "r");
 558         if (!fh) {
 559                 return if_readconf();
 560         }
 561         fgets(buf, sizeof buf, fh);     /* eat line */
 562         fgets(buf, sizeof buf, fh);
 563
 564         procnetdev_vsn = procnetdev_version(buf);
 565
 566         err = 0;
 567         while (fgets(buf, sizeof buf, fh)) {
 568                 char *s, name[128];
 569
 570                 s = get_name(name, buf);
 571                 ife = add_interface(name);
 572                 get_dev_fields(s, ife, procnetdev_vsn);
 573                 ife->statistics_valid = 1;
 574                 if (target && strcmp(target, name) == 0)
 575                         break;
 576         }
 577         if (ferror(fh)) {
 578                 bb_perror_msg(_PATH_PROCNET_DEV);
 579                 err = -1;
 580                 proc_read = 0;
 581         }
 582         fclose(fh);
 583         return err;
 584 }
 585
 586 static int if_readlist(void)
 587 {
 588         int err = if_readlist_proc(NULL);
 589         /* Needed in order to get ethN:M aliases */
 590         if (!err)
 591                 err = if_readconf();
 592         return err;
 593 }
 594
 595 /* Fetch the interface configuration from the kernel. */
 596 static int if_fetch(struct interface *ife)
 597 {
 598         struct ifreq ifr;
 599         char *ifname = ife->name;
 600         int skfd;
 601
 602         skfd = xsocket(AF_INET, SOCK_DGRAM, 0);
 603
 604         strncpy_IFNAMSIZ(ifr.ifr_name, ifname);
 605         if (ioctl(skfd, SIOCGIFFLAGS, &ifr) < 0) {
 606                 close(skfd);
 607                 return -1;
 608         }
 609         ife->flags = ifr.ifr_flags;
 610
 611         strncpy_IFNAMSIZ(ifr.ifr_name, ifname);
 612         memset(ife->hwaddr, 0, 32);
 613         if (ioctl(skfd, SIOCGIFHWADDR, &ifr) >= 0)
 614                 memcpy(ife->hwaddr, ifr.ifr_hwaddr.sa_data, 8);
 615
 616         ife->type = ifr.ifr_hwaddr.sa_family;
 617
 618         strncpy_IFNAMSIZ(ifr.ifr_name, ifname);
 619         ife->metric = 0;
 620         if (ioctl(skfd, SIOCGIFMETRIC, &ifr) >= 0)
 621                 ife->metric = ifr.ifr_metric;
 622
 623         strncpy_IFNAMSIZ(ifr.ifr_name, ifname);
 624         ife->mtu = 0;
 625         if (ioctl(skfd, SIOCGIFMTU, &ifr) >= 0)
 626                 ife->mtu = ifr.ifr_mtu;
 627
 628         memset(&ife->map, 0, sizeof(struct ifmap));
 629 #ifdef SIOCGIFMAP
 630         strncpy_IFNAMSIZ(ifr.ifr_name, ifname);
 631         if (ioctl(skfd, SIOCGIFMAP, &ifr) == 0)
 632                 ife->map = ifr.ifr_map;
 633 #endif
 634
 635 #ifdef HAVE_TXQUEUELEN
 636         strncpy_IFNAMSIZ(ifr.ifr_name, ifname);
 637         ife->tx_queue_len = -1; /* unknown value */
 638         if (ioctl(skfd, SIOCGIFTXQLEN, &ifr) >= 0)
 639                 ife->tx_queue_len = ifr.ifr_qlen;
 640 #else
 641         ife->tx_queue_len = -1; /* unknown value */
 642 #endif
 643
 644         strncpy_IFNAMSIZ(ifr.ifr_name, ifname);
 645         ifr.ifr_addr.sa_family = AF_INET;
 646         memset(&ife->addr, 0, sizeof(struct sockaddr));
 647         if (ioctl(skfd, SIOCGIFADDR, &ifr) == 0) {
 648                 ife->has_ip = 1;
 649                 ife->addr = ifr.ifr_addr;
 650                 strncpy_IFNAMSIZ(ifr.ifr_name, ifname);
 651                 memset(&ife->dstaddr, 0, sizeof(struct sockaddr));
 652                 if (ioctl(skfd, SIOCGIFDSTADDR, &ifr) >= 0)
 653                         ife->dstaddr = ifr.ifr_dstaddr;
 654
 655                 strncpy_IFNAMSIZ(ifr.ifr_name, ifname);
 656                 memset(&ife->broadaddr, 0, sizeof(struct sockaddr));
 657                 if (ioctl(skfd, SIOCGIFBRDADDR, &ifr) >= 0)
 658                         ife->broadaddr = ifr.ifr_broadaddr;
 659
 660                 strncpy_IFNAMSIZ(ifr.ifr_name, ifname);
 661                 memset(&ife->netmask, 0, sizeof(struct sockaddr));
 662                 if (ioctl(skfd, SIOCGIFNETMASK, &ifr) >= 0)
 663                         ife->netmask = ifr.ifr_netmask;
 664         }
 665
 666         close(skfd);
 667         return 0;
 668 }
 669
 670 static int do_if_fetch(struct interface *ife)
 671 {
 672         if (if_fetch(ife) < 0) {
 673                 const char *errmsg;
 674
 675                 if (errno == ENODEV) {
 676                         /* Give better error message for this case. */
 677                         errmsg = "Device not found";
 678                 } else {
 679                         errmsg = strerror(errno);
 680                 }
 681                 bb_error_msg("%s: error fetching interface information: %s",
 682                                 ife->name, errmsg);
 683                 return -1;
 684         }
 685         return 0;
 686 }
 687
 688 static const struct hwtype unspec_hwtype = {
 689         .name =         "unspec",
 690         .title =        "UNSPEC",
 691         .type =         -1,
 692         .print =        UNSPEC_print
 693 };
 694
 695 static const struct hwtype loop_hwtype = {
 696         .name =         "loop",
 697         .title =        "Local Loopback",
 698         .type =         ARPHRD_LOOPBACK
 699 };
 700
 701 /* Display an Ethernet address in readable format. */
 702 static char* FAST_FUNC ether_print(unsigned char *ptr)
 703 {
 704         char *buff;
 705         buff = xasprintf("%02X:%02X:%02X:%02X:%02X:%02X",
 706                 ptr[0], ptr[1], ptr[2], ptr[3], ptr[4], ptr[5]
 707         );
 708         return auto_string(buff);
 709 }
 710
 711 static const struct hwtype ether_hwtype = {
 712         .name  = "ether",
 713         .title = "Ethernet",
 714         .type  = ARPHRD_ETHER,
 715         .alen  = ETH_ALEN,
 716         .print = ether_print,
 717         .input = in_ether
 718 };
 719
 720 static const struct hwtype ppp_hwtype = {
 721         .name =         "ppp",
 722         .title =        "Point-to-Point Protocol",
 723         .type =         ARPHRD_PPP
 724 };
 725
 726 #if ENABLE_FEATURE_IPV6
 727 static const struct hwtype sit_hwtype = {
 728         .name =                 "sit",
 729         .title =                "IPv6-in-IPv4",
 730         .type =                 ARPHRD_SIT,
 731         .print =                UNSPEC_print,
 732         .suppress_null_addr =   1
 733 };
 734 #endif
 735 #if ENABLE_FEATURE_HWIB
 736 static const struct hwtype ib_hwtype = {
 737         .name  = "infiniband",
 738         .title = "InfiniBand",
 739         .type  = ARPHRD_INFINIBAND,
 740         .alen  = INFINIBAND_ALEN,
 741         .print = UNSPEC_print,
 742         .input = in_ib,
 743 };
 744 #endif
 745
 746
 747 static const struct hwtype *const hwtypes[] = {
 748         &loop_hwtype,
 749         &ether_hwtype,
 750         &ppp_hwtype,
 751         &unspec_hwtype,
 752 #if ENABLE_FEATURE_IPV6
 753         &sit_hwtype,
 754 #endif
 755 #if ENABLE_FEATURE_HWIB
 756         &ib_hwtype,
 757 #endif
 758         NULL
 759 };
 760
 761 #ifdef IFF_PORTSEL
 762 static const char *const if_port_text[] = {
 763         /* Keep in step with <linux/netdevice.h> */
 764         "unknown",
 765         "10base2",
 766         "10baseT",
 767         "AUI",
 768         "100baseT",
 769         "100baseTX",
 770         "100baseFX",
 771         NULL
 772 };
 773 #endif
 774
 775 /* Check our hardware type table for this type. */
 776 const struct hwtype* FAST_FUNC get_hwtype(const char *name)
 777 {
 778         const struct hwtype *const *hwp;
 779
 780         hwp = hwtypes;
 781         while (*hwp != NULL) {
 782                 if (strcmp((*hwp)->name, name) == 0)
 783                         return (*hwp);
 784                 hwp++;
 785         }
 786         return NULL;
 787 }
 788
 789 /* Check our hardware type table for this type. */
 790 const struct hwtype* FAST_FUNC get_hwntype(int type)
 791 {
 792         const struct hwtype *const *hwp;
 793
 794         hwp = hwtypes;
 795         while (*hwp != NULL) {
 796                 if ((*hwp)->type == type)
 797                         return *hwp;
 798                 hwp++;
 799         }
 800         return NULL;
 801 }
 802
 803 /* return 1 if address is all zeros */
 804 static int hw_null_address(const struct hwtype *hw, void *ap)
 805 {
 806         int i;
 807         unsigned char *address = (unsigned char *) ap;
 808
 809         for (i = 0; i < hw->alen; i++)
 810                 if (address[i])
 811                         return 0;
 812         return 1;
 813 }
 814
 815 static const char TRext[] ALIGN1 = "\0\0\0Ki\0Mi\0Gi\0Ti";
 816
 817 static void print_bytes_scaled(unsigned long long ull, const char *end)
 818 {
 819         unsigned long long int_part;
 820         const char *ext;
 821         unsigned int frac_part;
 822         int i;
 823
 824         frac_part = 0;
 825         ext = TRext;
 826         int_part = ull;
 827         i = 4;
 828         do {
 829                 if (int_part >= 1024) {
 830                         frac_part = ((((unsigned int) int_part) & (1024-1)) * 10) / 1024;
 831                         int_part /= 1024;
 832                         ext += 3;       /* KiB, MiB, GiB, TiB */
 833                 }
 834                 --i;
 835         } while (i);
 836
 837         printf("X bytes:%llu (%llu.%u %sB)%s", ull, int_part, frac_part, ext, end);
 838 }
 839
 840
 841 #ifdef HAVE_AFINET6
 842 #define IPV6_ADDR_ANY           0x0000U
 843
 844 #define IPV6_ADDR_UNICAST       0x0001U
 845 #define IPV6_ADDR_MULTICAST     0x0002U
 846 #define IPV6_ADDR_ANYCAST       0x0004U
 847
 848 #define IPV6_ADDR_LOOPBACK      0x0010U
 849 #define IPV6_ADDR_LINKLOCAL     0x0020U
 850 #define IPV6_ADDR_SITELOCAL     0x0040U
 851
 852 #define IPV6_ADDR_COMPATv4      0x0080U
 853
 854 #define IPV6_ADDR_SCOPE_MASK    0x00f0U
 855
 856 #define IPV6_ADDR_MAPPED        0x1000U
 857 #define IPV6_ADDR_RESERVED      0x2000U /* reserved address space */
 858
 859
 860 static void ife_print6(struct interface *ptr)
 861 {
 862         FILE *f;
 863         char addr6[40], devname[21];
 864         struct sockaddr_in6 sap;
 865         int plen, scope, dad_status, if_idx;
 866         char addr6p[8][5];
 867
 868         f = fopen_for_read(_PATH_PROCNET_IFINET6);
 869         if (f == NULL)
 870                 return;
 871
 872         while (fscanf
 873                    (f, "%4s%4s%4s%4s%4s%4s%4s%4s %08x %02x %02x %02x %20s\n",
 874                         addr6p[0], addr6p[1], addr6p[2], addr6p[3], addr6p[4],
 875                         addr6p[5], addr6p[6], addr6p[7], &if_idx, &plen, &scope,
 876                         &dad_status, devname) != EOF
 877         ) {
 878                 if (strcmp(devname, ptr->name) == 0) {
 879                         sprintf(addr6, "%s:%s:%s:%s:%s:%s:%s:%s",
 880                                         addr6p[0], addr6p[1], addr6p[2], addr6p[3],
 881                                         addr6p[4], addr6p[5], addr6p[6], addr6p[7]);
 882                         memset(&sap, 0, sizeof(sap));
 883                         inet_pton(AF_INET6, addr6,
 884                                           (struct sockaddr *) &sap.sin6_addr);
 885                         sap.sin6_family = AF_INET6;
 886                         printf("          inet6 addr: %s/%d",
 887                                 INET6_sprint((struct sockaddr *) &sap, 1),
 888                                 plen);
 889                         printf(" Scope:");
 890                         switch (scope & IPV6_ADDR_SCOPE_MASK) {
 891                         case 0:
 892                                 puts("Global");
 893                                 break;
 894                         case IPV6_ADDR_LINKLOCAL:
 895                                 puts("Link");
 896                                 break;
 897                         case IPV6_ADDR_SITELOCAL:
 898                                 puts("Site");
 899                                 break;
 900                         case IPV6_ADDR_COMPATv4:
 901                                 puts("Compat");
 902                                 break;
 903                         case IPV6_ADDR_LOOPBACK:
 904                                 puts("Host");
 905                                 break;
 906                         default:
 907                                 puts("Unknown");
 908                         }
 909                 }
 910         }
 911         fclose(f);
 912 }
 913 #else
 914 #define ife_print6(a) ((void)0)
 915 #endif
 916
 917 static void ife_print(struct interface *ptr)
 918 {
 919         const struct aftype *ap;
 920         const struct hwtype *hw;
 921         int hf;
 922         int can_compress = 0;
 923
 924         ap = get_afntype(ptr->addr.sa_family);
 925         if (ap == NULL)
 926                 ap = get_afntype(0);
 927
 928         hf = ptr->type;
 929
 930         if (hf == ARPHRD_CSLIP || hf == ARPHRD_CSLIP6)
 931                 can_compress = 1;
 932
 933         hw = get_hwntype(hf);
 934         if (hw == NULL)
 935                 hw = get_hwntype(-1);
 936
 937         printf("%-9s Link encap:%s  ", ptr->name, hw->title);
 938         /* For some hardware types (eg Ash, ATM) we don't print the
 939            hardware address if it's null.  */
 940         if (hw->print != NULL
 941          && !(hw_null_address(hw, ptr->hwaddr) && hw->suppress_null_addr)
 942         ) {
 943                 printf("HWaddr %s  ", hw->print((unsigned char *)ptr->hwaddr));
 944         }
 945 #ifdef IFF_PORTSEL
 946         if (ptr->flags & IFF_PORTSEL) {
 947                 printf("Media:%s", if_port_text[ptr->map.port] /* [0] */);
 948                 if (ptr->flags & IFF_AUTOMEDIA)
 949                         printf("(auto)");
 950         }
 951 #endif
 952         bb_putchar('\n');
 953
 954         if (ptr->has_ip) {
 955                 printf("          %s addr:%s ", ap->name,
 956                         ap->sprint(&ptr->addr, 1));
 957                 if (ptr->flags & IFF_POINTOPOINT) {
 958                         printf(" P-t-P:%s ", ap->sprint(&ptr->dstaddr, 1));
 959                 }
 960                 if (ptr->flags & IFF_BROADCAST) {
 961                         printf(" Bcast:%s ", ap->sprint(&ptr->broadaddr, 1));
 962                 }
 963                 printf(" Mask:%s\n", ap->sprint(&ptr->netmask, 1));
 964         }
 965
 966         ife_print6(ptr);
 967
 968         printf("          ");
 969         /* DONT FORGET TO ADD THE FLAGS IN ife_print_short, too */
 970
 971         if (ptr->flags == 0) {
 972                 printf("[NO FLAGS] ");
 973         } else {
 974                 static const char ife_print_flags_strs[] ALIGN1 =
 975                         "UP\0"
 976                         "BROADCAST\0"
 977                         "DEBUG\0"
 978                         "LOOPBACK\0"
 979                         "POINTOPOINT\0"
 980                         "NOTRAILERS\0"
 981                         "RUNNING\0"
 982                         "NOARP\0"
 983                         "PROMISC\0"
 984                         "ALLMULTI\0"
 985                         "SLAVE\0"
 986                         "MASTER\0"
 987                         "MULTICAST\0"
 988 #ifdef HAVE_DYNAMIC
 989                         "DYNAMIC\0"
 990 #endif
 991                         ;
 992                 static const unsigned short ife_print_flags_mask[] ALIGN2 = {
 993                         IFF_UP,
 994                         IFF_BROADCAST,
 995                         IFF_DEBUG,
 996                         IFF_LOOPBACK,
 997                         IFF_POINTOPOINT,
 998                         IFF_NOTRAILERS,
 999                         IFF_RUNNING,
1000                         IFF_NOARP,
1001                         IFF_PROMISC,
1002                         IFF_ALLMULTI,
1003                         IFF_SLAVE,
1004                         IFF_MASTER,
1005                         IFF_MULTICAST
1006 #ifdef HAVE_DYNAMIC
1007                         ,IFF_DYNAMIC
1008 #endif
1009                 };
1010                 const unsigned short *mask = ife_print_flags_mask;
1011                 const char *str = ife_print_flags_strs;
1012                 do {
1013                         if (ptr->flags & *mask) {
1014                                 printf("%s ", str);
1015                         }
1016                         mask++;
1017                         str += strlen(str) + 1;
1018                 } while (*str);
1019         }
1020
1021         /* DONT FORGET TO ADD THE FLAGS IN ife_print_short */
1022         printf(" MTU:%d  Metric:%d", ptr->mtu, ptr->metric ? ptr->metric : 1);
1023 #ifdef SIOCSKEEPALIVE
1024         if (ptr->outfill || ptr->keepalive)
1025                 printf("  Outfill:%d  Keepalive:%d", ptr->outfill, ptr->keepalive);
1026 #endif
1027         bb_putchar('\n');
1028
1029         /* If needed, display the interface statistics. */
1030
1031         if (ptr->statistics_valid) {
1032                 /* XXX: statistics are currently only printed for the primary address,
1033                  *      not for the aliases, although strictly speaking they're shared
1034                  *      by all addresses.
1035                  */
1036                 printf("          ");
1037
1038                 printf("RX packets:%llu errors:%lu dropped:%lu overruns:%lu frame:%lu\n",
1039                         ptr->stats.rx_packets, ptr->stats.rx_errors,
1040                         ptr->stats.rx_dropped, ptr->stats.rx_fifo_errors,
1041                         ptr->stats.rx_frame_errors);
1042                 if (can_compress)
1043                         printf("             compressed:%lu\n",
1044                                 ptr->stats.rx_compressed);
1045                 printf("          ");
1046                 printf("TX packets:%llu errors:%lu dropped:%lu overruns:%lu carrier:%lu\n",
1047                         ptr->stats.tx_packets, ptr->stats.tx_errors,
1048                         ptr->stats.tx_dropped, ptr->stats.tx_fifo_errors,
1049                         ptr->stats.tx_carrier_errors);
1050                 printf("          collisions:%lu ", ptr->stats.collisions);
1051                 if (can_compress)
1052                         printf("compressed:%lu ", ptr->stats.tx_compressed);
1053                 if (ptr->tx_queue_len != -1)
1054                         printf("txqueuelen:%d ", ptr->tx_queue_len);
1055                 printf("\n          R");
1056                 print_bytes_scaled(ptr->stats.rx_bytes, "  T");
1057                 print_bytes_scaled(ptr->stats.tx_bytes, "\n");
1058         }
1059
1060         if (ptr->map.irq || ptr->map.mem_start
1061          || ptr->map.dma || ptr->map.base_addr
1062         ) {
1063                 printf("          ");
1064                 if (ptr->map.irq)
1065                         printf("Interrupt:%d ", ptr->map.irq);
1066                 if (ptr->map.base_addr >= 0x100) /* Only print devices using it for I/O maps */
1067                         printf("Base address:0x%lx ",
1068                                 (unsigned long) ptr->map.base_addr);
1069                 if (ptr->map.mem_start) {
1070                         printf("Memory:%lx-%lx ", ptr->map.mem_start,
1071                                 ptr->map.mem_end);
1072                 }
1073                 if (ptr->map.dma)
1074                         printf("DMA chan:%x ", ptr->map.dma);
1075                 bb_putchar('\n');
1076         }
1077         bb_putchar('\n');
1078 }
1079
1080 static int do_if_print(struct interface *ife) /*, int *opt_a)*/
1081 {
1082         int res;
1083
1084         res = do_if_fetch(ife);
1085         if (res >= 0) {
1086                 if ((ife->flags & IFF_UP) || interface_opt_a)
1087                         ife_print(ife);
1088         }
1089         return res;
1090 }
1091
1092 static struct interface *lookup_interface(char *name)
1093 {
1094         struct interface *ife = NULL;
1095
1096         if (if_readlist_proc(name) < 0)
1097                 return NULL;
1098         ife = add_interface(name);
1099         return ife;
1100 }
1101
1102 #ifdef UNUSED
1103 static int for_all_interfaces(int (*doit) (struct interface *, void *),
1104                                                         void *cookie)
1105 {
1106         struct interface *ife;
1107
1108         if (!int_list && (if_readlist() < 0))
1109                 return -1;
1110         for (ife = int_list; ife; ife = ife->next) {
1111                 int err = doit(ife, cookie);
1112                 if (err)
1113                         return err;
1114         }
1115         return 0;
1116 }
1117 #endif
1118
1119 /* for ipv4 add/del modes */
1120 static int if_print(char *ifname)
1121 {
1122         struct interface *ife;
1123         int res;
1124
1125         if (!ifname) {
1126                 /*res = for_all_interfaces(do_if_print, &interface_opt_a);*/
1127                 if (!int_list && (if_readlist() < 0))
1128                         return -1;
1129                 for (ife = int_list; ife; ife = ife->next) {
1130                         int err = do_if_print(ife); /*, &interface_opt_a);*/
1131                         if (err)
1132                                 return err;
1133                 }
1134                 return 0;
1135         }
1136         ife = lookup_interface(ifname);
1137         res = do_if_fetch(ife);
1138         if (res >= 0)
1139                 ife_print(ife);
1140         return res;
1141 }
1142
1143 #if ENABLE_FEATURE_HWIB
1144 /* Input an Infiniband address and convert to binary. */
1145 int FAST_FUNC in_ib(const char *bufp, struct sockaddr *sap)
1146 {
1147         sap->sa_family = ib_hwtype.type;
1148 //TODO: error check?
1149         hex2bin((char*)sap->sa_data, bufp, INFINIBAND_ALEN);
1150 # ifdef HWIB_DEBUG
1151         fprintf(stderr, "in_ib(%s): %s\n", bufp, UNSPEC_print(sap->sa_data));
1152 # endif
1153         return 0;
1154 }
1155 #endif
1156
1157 int FAST_FUNC display_interfaces(char *ifname)
1158 {
1159         int status;
1160
1161         status = if_print(ifname);
1162
1163         return (status < 0); /* status < 0 == 1 -- error */
1164 }