networking/netstat.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * Mini netstat implementation(s) for busybox
   4  * based in part on the netstat implementation from net-tools.
   5  *
   6  * Copyright (C) 2002 by Bart Visscher <magick@linux-fan.com>
   7  *
   8  * 2002-04-20
   9  * IPV6 support added by Bart Visscher <magick@linux-fan.com>
  10  *
  11  * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
  12  */
  13
  14 #include "busybox.h"
  15 #include "inet_common.h"
  16
  17 #ifdef CONFIG_ROUTE
  18 extern void displayroutes(int noresolve, int netstatfmt);
  19 #endif
  20
  21 #define NETSTAT_CONNECTED       0x01
  22 #define NETSTAT_LISTENING       0x02
  23 #define NETSTAT_NUMERIC         0x04
  24 /* Must match getopt32 option string */
  25 #define NETSTAT_TCP             0x10
  26 #define NETSTAT_UDP             0x20
  27 #define NETSTAT_RAW             0x40
  28 #define NETSTAT_UNIX            0x80
  29 #define NETSTAT_ALLPROTO (NETSTAT_TCP|NETSTAT_UDP|NETSTAT_RAW|NETSTAT_UNIX)
  30
  31 static int flags = NETSTAT_CONNECTED | NETSTAT_ALLPROTO;
  32
  33 #define PROGNAME_WIDTHs PROGNAME_WIDTH1(PROGNAME_WIDTH)
  34 #define PROGNAME_WIDTH1(s) PROGNAME_WIDTH2(s)
  35 #define PROGNAME_WIDTH2(s) #s
  36
  37 #define PRG_HASH_SIZE 211
  38
  39 enum {
  40     TCP_ESTABLISHED = 1,
  41     TCP_SYN_SENT,
  42     TCP_SYN_RECV,
  43     TCP_FIN_WAIT1,
  44     TCP_FIN_WAIT2,
  45     TCP_TIME_WAIT,
  46     TCP_CLOSE,
  47     TCP_CLOSE_WAIT,
  48     TCP_LAST_ACK,
  49     TCP_LISTEN,
  50     TCP_CLOSING                 /* now a valid state */
  51 };
  52
  53 static const char * const tcp_state[] =
  54 {
  55     "",
  56     "ESTABLISHED",
  57     "SYN_SENT",
  58     "SYN_RECV",
  59     "FIN_WAIT1",
  60     "FIN_WAIT2",
  61     "TIME_WAIT",
  62     "CLOSE",
  63     "CLOSE_WAIT",
  64     "LAST_ACK",
  65     "LISTEN",
  66     "CLOSING"
  67 };
  68
  69 typedef enum {
  70     SS_FREE = 0,                /* not allocated                */
  71     SS_UNCONNECTED,             /* unconnected to any socket    */
  72     SS_CONNECTING,              /* in process of connecting     */
  73     SS_CONNECTED,               /* connected to socket          */
  74     SS_DISCONNECTING            /* in process of disconnecting  */
  75 } socket_state;
  76
  77 #define SO_ACCEPTCON    (1<<16) /* performed a listen           */
  78 #define SO_WAITDATA     (1<<17) /* wait data to read            */
  79 #define SO_NOSPACE      (1<<18) /* no space to write            */
  80
  81 static char *get_sname(int port, const char *proto, int num)
  82 {
  83         char *str=itoa(ntohs(port));
  84         if (num) {
  85         } else {
  86                 struct servent *se=getservbyport(port,proto);
  87                 if (se)
  88                         str=se->s_name;
  89         }
  90         if (!port) {
  91                 str="*";
  92         }
  93         return str;
  94 }
  95
  96 static void snprint_ip_port(char *ip_port, int size, struct sockaddr *addr, int port, char *proto, int numeric)
  97 {
  98         char *port_name;
  99
 100 #ifdef CONFIG_FEATURE_IPV6
 101         if (addr->sa_family == AF_INET6) {
 102                 INET6_rresolve(ip_port, size, (struct sockaddr_in6 *)addr,
 103                                            (numeric&NETSTAT_NUMERIC) ? 0x0fff : 0);
 104         } else
 105 #endif
 106         {
 107         INET_rresolve(ip_port, size, (struct sockaddr_in *)addr,
 108                 0x4000 | ((numeric&NETSTAT_NUMERIC) ? 0x0fff : 0),
 109                 0xffffffff);
 110         }
 111         port_name=get_sname(htons(port), proto, numeric);
 112         if ((strlen(ip_port) + strlen(port_name)) > 22)
 113                 ip_port[22 - strlen(port_name)] = '\0';
 114         ip_port+=strlen(ip_port);
 115         strcat(ip_port, ":");
 116         strcat(ip_port, port_name);
 117 }
 118
 119 static void tcp_do_one(int lnr, const char *line)
 120 {
 121         char local_addr[64], rem_addr[64];
 122         const char *state_str;
 123         char more[512];
 124         int num, local_port, rem_port, d, state, timer_run, uid, timeout;
 125 #ifdef CONFIG_FEATURE_IPV6
 126         struct sockaddr_in6 localaddr, remaddr;
 127         char addr6[INET6_ADDRSTRLEN];
 128         struct in6_addr in6;
 129 #else
 130         struct sockaddr_in localaddr, remaddr;
 131 #endif
 132         unsigned long rxq, txq, time_len, retr, inode;
 133
 134         if (lnr == 0)
 135                 return;
 136
 137         more[0] = '\0';
 138         num = sscanf(line,
 139                                  "%d: %64[0-9A-Fa-f]:%X %64[0-9A-Fa-f]:%X %X %lX:%lX %X:%lX %lX %d %d %ld %512s\n",
 140                                  &d, local_addr, &local_port,
 141                                  rem_addr, &rem_port, &state,
 142                                  &txq, &rxq, &timer_run, &time_len, &retr, &uid, &timeout, &inode, more);
 143
 144         if (strlen(local_addr) > 8) {
 145 #ifdef CONFIG_FEATURE_IPV6
 146                 sscanf(local_addr, "%08X%08X%08X%08X",
 147                            &in6.s6_addr32[0], &in6.s6_addr32[1],
 148                            &in6.s6_addr32[2], &in6.s6_addr32[3]);
 149                 inet_ntop(AF_INET6, &in6, addr6, sizeof(addr6));
 150                 inet_pton(AF_INET6, addr6, (struct sockaddr *) &localaddr.sin6_addr);
 151                 sscanf(rem_addr, "%08X%08X%08X%08X",
 152                            &in6.s6_addr32[0], &in6.s6_addr32[1],
 153                            &in6.s6_addr32[2], &in6.s6_addr32[3]);
 154                 inet_ntop(AF_INET6, &in6, addr6, sizeof(addr6));
 155                 inet_pton(AF_INET6, addr6, (struct sockaddr *) &remaddr.sin6_addr);
 156                 localaddr.sin6_family = AF_INET6;
 157                 remaddr.sin6_family = AF_INET6;
 158 #endif
 159         } else {
 160                 sscanf(local_addr, "%X",
 161                            &((struct sockaddr_in *) &localaddr)->sin_addr.s_addr);
 162                 sscanf(rem_addr, "%X",
 163                            &((struct sockaddr_in *) &remaddr)->sin_addr.s_addr);
 164                 ((struct sockaddr *) &localaddr)->sa_family = AF_INET;
 165                 ((struct sockaddr *) &remaddr)->sa_family = AF_INET;
 166         }
 167
 168         if (num < 10) {
 169                 bb_error_msg("warning, got bogus tcp line");
 170                 return;
 171         }
 172         state_str = tcp_state[state];
 173         if ((rem_port && (flags&NETSTAT_CONNECTED)) ||
 174                 (!rem_port && (flags&NETSTAT_LISTENING)))
 175         {
 176                 snprint_ip_port(local_addr, sizeof(local_addr),
 177                                                 (struct sockaddr *) &localaddr, local_port,
 178                                                 "tcp", flags&NETSTAT_NUMERIC);
 179
 180                 snprint_ip_port(rem_addr, sizeof(rem_addr),
 181                                                 (struct sockaddr *) &remaddr, rem_port,
 182                                                 "tcp", flags&NETSTAT_NUMERIC);
 183
 184                 printf("tcp   %6ld %6ld %-23s %-23s %-12s\n",
 185                            rxq, txq, local_addr, rem_addr, state_str);
 186
 187         }
 188 }
 189
 190 static void udp_do_one(int lnr, const char *line)
 191 {
 192         char local_addr[64], rem_addr[64];
 193         char *state_str, more[512];
 194         int num, local_port, rem_port, d, state, timer_run, uid, timeout;
 195 #ifdef CONFIG_FEATURE_IPV6
 196         struct sockaddr_in6 localaddr, remaddr;
 197         char addr6[INET6_ADDRSTRLEN];
 198         struct in6_addr in6;
 199 #else
 200         struct sockaddr_in localaddr, remaddr;
 201 #endif
 202         unsigned long rxq, txq, time_len, retr, inode;
 203
 204         if (lnr == 0)
 205                 return;
 206
 207         more[0] = '\0';
 208         num = sscanf(line,
 209                                  "%d: %64[0-9A-Fa-f]:%X %64[0-9A-Fa-f]:%X %X %lX:%lX %X:%lX %lX %d %d %ld %512s\n",
 210                                  &d, local_addr, &local_port,
 211                                  rem_addr, &rem_port, &state,
 212                                  &txq, &rxq, &timer_run, &time_len, &retr, &uid, &timeout, &inode, more);
 213
 214         if (strlen(local_addr) > 8) {
 215 #ifdef CONFIG_FEATURE_IPV6
 216         /* Demangle what the kernel gives us */
 217                 sscanf(local_addr, "%08X%08X%08X%08X",
 218                            &in6.s6_addr32[0], &in6.s6_addr32[1],
 219                            &in6.s6_addr32[2], &in6.s6_addr32[3]);
 220                 inet_ntop(AF_INET6, &in6, addr6, sizeof(addr6));
 221                 inet_pton(AF_INET6, addr6, (struct sockaddr *) &localaddr.sin6_addr);
 222                 sscanf(rem_addr, "%08X%08X%08X%08X",
 223                            &in6.s6_addr32[0], &in6.s6_addr32[1],
 224                            &in6.s6_addr32[2], &in6.s6_addr32[3]);
 225                 inet_ntop(AF_INET6, &in6, addr6, sizeof(addr6));
 226                 inet_pton(AF_INET6, addr6, (struct sockaddr *) &remaddr.sin6_addr);
 227                 localaddr.sin6_family = AF_INET6;
 228                 remaddr.sin6_family = AF_INET6;
 229 #endif
 230         } else {
 231                 sscanf(local_addr, "%X",
 232                            &((struct sockaddr_in *) &localaddr)->sin_addr.s_addr);
 233                 sscanf(rem_addr, "%X",
 234                            &((struct sockaddr_in *) &remaddr)->sin_addr.s_addr);
 235                 ((struct sockaddr *) &localaddr)->sa_family = AF_INET;
 236                 ((struct sockaddr *) &remaddr)->sa_family = AF_INET;
 237         }
 238
 239         if (num < 10) {
 240                 bb_error_msg("warning, got bogus udp line");
 241                 return;
 242         }
 243         switch (state) {
 244                 case TCP_ESTABLISHED:
 245                         state_str = "ESTABLISHED";
 246                         break;
 247
 248                 case TCP_CLOSE:
 249                         state_str = "";
 250                         break;
 251
 252                 default:
 253                         state_str = "UNKNOWN";
 254                         break;
 255         }
 256
 257 #ifdef CONFIG_FEATURE_IPV6
 258 # define notnull(A) (((A.sin6_family == AF_INET6) &&            \
 259                                          ((A.sin6_addr.s6_addr32[0]) ||            \
 260                                           (A.sin6_addr.s6_addr32[1]) ||            \
 261                                           (A.sin6_addr.s6_addr32[2]) ||            \
 262                                           (A.sin6_addr.s6_addr32[3]))) ||          \
 263                                         ((A.sin6_family == AF_INET) &&             \
 264                                          ((struct sockaddr_in *) &A)->sin_addr.s_addr))
 265 #else
 266 # define notnull(A) (A.sin_addr.s_addr)
 267 #endif
 268         if ((notnull(remaddr) && (flags&NETSTAT_CONNECTED)) ||
 269                 (!notnull(remaddr) && (flags&NETSTAT_LISTENING)))
 270         {
 271                 snprint_ip_port(local_addr, sizeof(local_addr),
 272                                                 (struct sockaddr *) &localaddr, local_port,
 273                                                 "udp", flags&NETSTAT_NUMERIC);
 274
 275                 snprint_ip_port(rem_addr, sizeof(rem_addr),
 276                                                 (struct sockaddr *) &remaddr, rem_port,
 277                                                 "udp", flags&NETSTAT_NUMERIC);
 278
 279                 printf("udp   %6ld %6ld %-23s %-23s %-12s\n",
 280                            rxq, txq, local_addr, rem_addr, state_str);
 281
 282         }
 283 }
 284
 285 static void raw_do_one(int lnr, const char *line)
 286 {
 287         char local_addr[64], rem_addr[64];
 288         char *state_str, more[512];
 289         int num, local_port, rem_port, d, state, timer_run, uid, timeout;
 290 #ifdef CONFIG_FEATURE_IPV6
 291         struct sockaddr_in6 localaddr, remaddr;
 292         char addr6[INET6_ADDRSTRLEN];
 293         struct in6_addr in6;
 294 #else
 295         struct sockaddr_in localaddr, remaddr;
 296 #endif
 297         unsigned long rxq, txq, time_len, retr, inode;
 298
 299         if (lnr == 0)
 300                 return;
 301
 302         more[0] = '\0';
 303         num = sscanf(line,
 304                                  "%d: %64[0-9A-Fa-f]:%X %64[0-9A-Fa-f]:%X %X %lX:%lX %X:%lX %lX %d %d %ld %512s\n",
 305                                  &d, local_addr, &local_port,
 306                                  rem_addr, &rem_port, &state,
 307                                  &txq, &rxq, &timer_run, &time_len, &retr, &uid, &timeout, &inode, more);
 308
 309         if (strlen(local_addr) > 8) {
 310 #ifdef CONFIG_FEATURE_IPV6
 311                 sscanf(local_addr, "%08X%08X%08X%08X",
 312                            &in6.s6_addr32[0], &in6.s6_addr32[1],
 313                            &in6.s6_addr32[2], &in6.s6_addr32[3]);
 314                 inet_ntop(AF_INET6, &in6, addr6, sizeof(addr6));
 315                 inet_pton(AF_INET6, addr6, (struct sockaddr *) &localaddr.sin6_addr);
 316                 sscanf(rem_addr, "%08X%08X%08X%08X",
 317                            &in6.s6_addr32[0], &in6.s6_addr32[1],
 318                            &in6.s6_addr32[2], &in6.s6_addr32[3]);
 319                 inet_ntop(AF_INET6, &in6, addr6, sizeof(addr6));
 320                 inet_pton(AF_INET6, addr6, (struct sockaddr *) &remaddr.sin6_addr);
 321                 localaddr.sin6_family = AF_INET6;
 322                 remaddr.sin6_family = AF_INET6;
 323 #endif
 324         } else {
 325                 sscanf(local_addr, "%X",
 326                            &((struct sockaddr_in *) &localaddr)->sin_addr.s_addr);
 327                 sscanf(rem_addr, "%X",
 328                            &((struct sockaddr_in *) &remaddr)->sin_addr.s_addr);
 329                 ((struct sockaddr *) &localaddr)->sa_family = AF_INET;
 330                 ((struct sockaddr *) &remaddr)->sa_family = AF_INET;
 331         }
 332
 333         if (num < 10) {
 334                 bb_error_msg("warning, got bogus raw line");
 335                 return;
 336         }
 337         state_str=itoa(state);
 338
 339 #ifdef CONFIG_FEATURE_IPV6
 340 # define notnull(A) (((A.sin6_family == AF_INET6) &&            \
 341                                          ((A.sin6_addr.s6_addr32[0]) ||            \
 342                                           (A.sin6_addr.s6_addr32[1]) ||            \
 343                                           (A.sin6_addr.s6_addr32[2]) ||            \
 344                                           (A.sin6_addr.s6_addr32[3]))) ||          \
 345                                         ((A.sin6_family == AF_INET) &&             \
 346                                          ((struct sockaddr_in *) &A)->sin_addr.s_addr))
 347 #else
 348 # define notnull(A) (A.sin_addr.s_addr)
 349 #endif
 350         if ((notnull(remaddr) && (flags&NETSTAT_CONNECTED)) ||
 351                 (!notnull(remaddr) && (flags&NETSTAT_LISTENING)))
 352         {
 353                 snprint_ip_port(local_addr, sizeof(local_addr),
 354                                                 (struct sockaddr *) &localaddr, local_port,
 355                                                 "raw", flags&NETSTAT_NUMERIC);
 356
 357                 snprint_ip_port(rem_addr, sizeof(rem_addr),
 358                                                 (struct sockaddr *) &remaddr, rem_port,
 359                                                 "raw", flags&NETSTAT_NUMERIC);
 360
 361                 printf("raw   %6ld %6ld %-23s %-23s %-12s\n",
 362                            rxq, txq, local_addr, rem_addr, state_str);
 363
 364         }
 365 }
 366
 367 #define HAS_INODE 1
 368
 369 static void unix_do_one(int nr, const char *line)
 370 {
 371         static int has = 0;
 372         char path[PATH_MAX], ss_flags[32];
 373         char *ss_proto, *ss_state, *ss_type;
 374         int num, state, type, inode;
 375         void *d;
 376         unsigned long refcnt, proto, unix_flags;
 377
 378         if (nr == 0) {
 379                 if (strstr(line, "Inode"))
 380                         has |= HAS_INODE;
 381                 return;
 382         }
 383         path[0] = '\0';
 384         num = sscanf(line, "%p: %lX %lX %lX %X %X %d %s",
 385                                  &d, &refcnt, &proto, &unix_flags, &type, &state, &inode, path);
 386         if (num < 6) {
 387                 bb_error_msg("warning, got bogus unix line");
 388                 return;
 389         }
 390         if (!(has & HAS_INODE))
 391                 snprintf(path,sizeof(path),"%d",inode);
 392
 393         if ((flags&(NETSTAT_LISTENING|NETSTAT_CONNECTED))!=(NETSTAT_LISTENING|NETSTAT_CONNECTED)) {
 394                 if ((state == SS_UNCONNECTED) && (unix_flags & SO_ACCEPTCON)) {
 395                         if (!(flags&NETSTAT_LISTENING))
 396                                 return;
 397                 } else {
 398                         if (!(flags&NETSTAT_CONNECTED))
 399                                 return;
 400                 }
 401         }
 402
 403         switch (proto) {
 404                 case 0:
 405                         ss_proto = "unix";
 406                         break;
 407
 408                 default:
 409                         ss_proto = "??";
 410         }
 411
 412         switch (type) {
 413                 case SOCK_STREAM:
 414                         ss_type = "STREAM";
 415                         break;
 416
 417                 case SOCK_DGRAM:
 418                         ss_type = "DGRAM";
 419                         break;
 420
 421                 case SOCK_RAW:
 422                         ss_type = "RAW";
 423                         break;
 424
 425                 case SOCK_RDM:
 426                         ss_type = "RDM";
 427                         break;
 428
 429                 case SOCK_SEQPACKET:
 430                         ss_type = "SEQPACKET";
 431                         break;
 432
 433                 default:
 434                         ss_type = "UNKNOWN";
 435         }
 436
 437         switch (state) {
 438                 case SS_FREE:
 439                         ss_state = "FREE";
 440                         break;
 441
 442                 case SS_UNCONNECTED:
 443                         /*
 444                          * Unconnected sockets may be listening
 445                          * for something.
 446                          */
 447                         if (unix_flags & SO_ACCEPTCON) {
 448                                 ss_state = "LISTENING";
 449                         } else {
 450                                 ss_state = "";
 451                         }
 452                         break;
 453
 454                 case SS_CONNECTING:
 455                         ss_state = "CONNECTING";
 456                         break;
 457
 458                 case SS_CONNECTED:
 459                         ss_state = "CONNECTED";
 460                         break;
 461
 462                 case SS_DISCONNECTING:
 463                         ss_state = "DISCONNECTING";
 464                         break;
 465
 466                 default:
 467                         ss_state = "UNKNOWN";
 468         }
 469
 470         strcpy(ss_flags, "[ ");
 471         if (unix_flags & SO_ACCEPTCON)
 472                 strcat(ss_flags, "ACC ");
 473         if (unix_flags & SO_WAITDATA)
 474                 strcat(ss_flags, "W ");
 475         if (unix_flags & SO_NOSPACE)
 476                 strcat(ss_flags, "N ");
 477
 478         strcat(ss_flags, "]");
 479
 480         printf("%-5s %-6ld %-11s %-10s %-13s ",
 481                    ss_proto, refcnt, ss_flags, ss_type, ss_state);
 482         if (has & HAS_INODE)
 483                 printf("%-6d ",inode);
 484         else
 485                 printf("-      ");
 486         puts(path);
 487 }
 488
 489 #define _PATH_PROCNET_UDP "/proc/net/udp"
 490 #define _PATH_PROCNET_UDP6 "/proc/net/udp6"
 491 #define _PATH_PROCNET_TCP "/proc/net/tcp"
 492 #define _PATH_PROCNET_TCP6 "/proc/net/tcp6"
 493 #define _PATH_PROCNET_RAW "/proc/net/raw"
 494 #define _PATH_PROCNET_RAW6 "/proc/net/raw6"
 495 #define _PATH_PROCNET_UNIX "/proc/net/unix"
 496
 497 static void do_info(const char *file, const char *name, void (*proc)(int, const char *))
 498 {
 499         char buffer[8192];
 500         int lnr = 0;
 501         FILE *procinfo;
 502
 503         procinfo = fopen(file, "r");
 504         if (procinfo == NULL) {
 505                 if (errno != ENOENT) {
 506                         perror(file);
 507                 } else {
 508                 bb_error_msg("no support for `%s' on this system", name);
 509                 }
 510         } else {
 511                 do {
 512                         if (fgets(buffer, sizeof(buffer), procinfo))
 513                                 (proc)(lnr++, buffer);
 514                 } while (!feof(procinfo));
 515                 fclose(procinfo);
 516         }
 517 }
 518
 519 /*
 520  * Our main function.
 521  */
 522
 523 int netstat_main(int argc, char **argv)
 524 {
 525         enum {
 526                 OPT_extended = 0x4,
 527                 OPT_showroute = 0x100,
 528         };
 529         unsigned opt;
 530 #ifdef CONFIG_FEATURE_IPV6
 531         int inet = 1;
 532         int inet6 = 1;
 533 #else
 534 # define inet 1
 535 # define inet6 0
 536 #endif
 537
 538         /* Option string must match NETSTAT_xxx constants */
 539         opt = getopt32(argc, argv, "laentuwxr");
 540         if (opt & 0x1) { // -l
 541                 flags &= ~NETSTAT_CONNECTED;
 542                 flags |= NETSTAT_LISTENING;
 543         }
 544         if (opt & 0x2) flags |= NETSTAT_LISTENING | NETSTAT_CONNECTED; // -a
 545         //if (opt & 0x4) // -e
 546         if (opt & 0x8) flags |= NETSTAT_NUMERIC; // -n
 547         //if (opt & 0x10) // -t: NETSTAT_TCP
 548         //if (opt & 0x20) // -u: NETSTAT_UDP
 549         //if (opt & 0x40) // -w: NETSTAT_RAW
 550         //if (opt & 0x80) // -x: NETSTAT_UNIX
 551         if (opt & OPT_showroute) { // -r
 552 #ifdef CONFIG_ROUTE
 553                 displayroutes(flags & NETSTAT_NUMERIC, !(opt & OPT_extended));
 554                 return 0;
 555 #else
 556                 bb_error_msg_and_die("-r (display routing table) is not compiled in");
 557 #endif
 558         }
 559
 560         opt &= NETSTAT_ALLPROTO;
 561         if (opt) {
 562                 flags &= ~NETSTAT_ALLPROTO;
 563                 flags |= opt;
 564         }
 565         if (flags & (NETSTAT_TCP|NETSTAT_UDP|NETSTAT_RAW)) {
 566                 printf("Active Internet connections "); /* xxx */
 567
 568                 if ((flags&(NETSTAT_LISTENING|NETSTAT_CONNECTED))==(NETSTAT_LISTENING|NETSTAT_CONNECTED))
 569                         printf("(servers and established)");
 570                 else {
 571                         if (flags & NETSTAT_LISTENING)
 572                                 printf("(only servers)");
 573                         else
 574                                 printf("(w/o servers)");
 575                 }
 576                 printf("\nProto Recv-Q Send-Q Local Address           Foreign Address         State      \n");
 577         }
 578         if (inet && flags&NETSTAT_TCP)
 579                 do_info(_PATH_PROCNET_TCP,"AF INET (tcp)",tcp_do_one);
 580 #ifdef CONFIG_FEATURE_IPV6
 581         if (inet6 && flags&NETSTAT_TCP)
 582                 do_info(_PATH_PROCNET_TCP6,"AF INET6 (tcp)",tcp_do_one);
 583 #endif
 584         if (inet && flags&NETSTAT_UDP)
 585                 do_info(_PATH_PROCNET_UDP,"AF INET (udp)",udp_do_one);
 586 #ifdef CONFIG_FEATURE_IPV6
 587         if (inet6 && flags&NETSTAT_UDP)
 588                 do_info(_PATH_PROCNET_UDP6,"AF INET6 (udp)",udp_do_one);
 589 #endif
 590         if (inet && flags&NETSTAT_RAW)
 591                 do_info(_PATH_PROCNET_RAW,"AF INET (raw)",raw_do_one);
 592 #ifdef CONFIG_FEATURE_IPV6
 593         if (inet6 && flags&NETSTAT_RAW)
 594                 do_info(_PATH_PROCNET_RAW6,"AF INET6 (raw)",raw_do_one);
 595 #endif
 596         if (flags&NETSTAT_UNIX) {
 597                 printf("Active UNIX domain sockets ");
 598                 if ((flags&(NETSTAT_LISTENING|NETSTAT_CONNECTED))==(NETSTAT_LISTENING|NETSTAT_CONNECTED))
 599                         printf("(servers and established)");
 600                 else {
 601                         if (flags&NETSTAT_LISTENING)
 602                                 printf("(only servers)");
 603                         else
 604                                 printf("(w/o servers)");
 605                 }
 606
 607                 printf("\nProto RefCnt Flags       Type       State         I-Node Path\n");
 608                 do_info(_PATH_PROCNET_UNIX,"AF UNIX",unix_do_one);
 609         }
 610         return 0;
 611 }