← Back to branch summary

~ubuntu-branches/ubuntu/saucy/net-tools/saucy-proposed

« back to all changes in this revision

Viewing changes to netstat.c

  • Committer: Bazaar Package Importer
  • Author(s): Muharem Hrnjadovic
  • Date: 2009-05-04 12:29:43 UTC
  • mfrom: (3.1.3 squeeze)
  • Revision ID: james.westby@ubuntu.com-20090504122943-6zyafjosb8a1u21q
Tags: 1.60-23ubuntu1
https://launchpad.net/bugs/240073
https://launchpad.net/bugs/66209
* Merge from debian unstable, remaining changes:
  Ubuntu_unit_conversion.patch:
    - the diff-style patch was converted into quilt format
    - Ubuntu Policy: output using standard SI unit multiples:
      KB (10^3), MB (10^6), GB (10^9), TB (10^12) and PB (10^15).
      Includes manpage update to remove comment about IEC units.
      LP: #240073.
  Dropped patches, already in debian:
    - lib/ec_hw.c: #include <stddef.h to get definition of NULL.
    - lib/fddi.c: #include <linux/types.h> to get types.  LP: #66209.

Show diffs side-by-side

added added

removed removed

Lines of Context:
netstat.c
6
6
 *              NET-3 Networking Distribution for the LINUX operating
7
7
 *              system.
8
8
 *
9
 
 * Version:     $Id: netstat.c,v 1.55 2007/12/01 19:00:40 ecki Exp $
 
9
 * Version:     $Id: netstat.c,v 1.43 2001/04/15 14:41:17 pb Exp $
10
10
 *
11
11
 * Authors:     Fred Baumgarten, <dc6iq@insu1.etec.uni-karlsruhe.de>
12
12
 *              Fred N. van Kempen, <waltje@uwalt.nl.mugnet.org>
94
94
#include "sockets.h"
95
95
#include "interface.h"
96
96
#include "util.h"
97
 
#include "proc.h"
98
97
 
99
98
#define PROGNAME_WIDTH 20
100
99
 
105
104
/* prototypes for statistics.c */
106
105
void parsesnmp(int, int, int);
107
106
void inittab(void);
108
 
void parsesnmp6(int, int, int);
109
 
void inittab6(void);
110
107
 
111
108
typedef enum {
112
109
    SS_FREE = 0,                /* not allocated                */
156
153
FILE *procinfo;
157
154
 
158
155
#define INFO_GUTS1(file,name,proc)                      \
159
 
  procinfo = proc_fopen((file));                        \
 
156
  procinfo = fopen((file), "r");                        \
160
157
  if (procinfo == NULL) {                               \
161
158
    if (errno != ENOENT) {                              \
162
159
      perror((file));                                   \
177
174
#if HAVE_AFINET6
178
175
#define INFO_GUTS2(file,proc)                           \
179
176
  lnr = 0;                                              \
180
 
  procinfo = proc_fopen((file));                        \
 
177
  procinfo = fopen((file), "r");                        \
181
178
  if (procinfo != NULL) {                               \
182
179
    do {                                                \
183
180
      if (fgets(buffer, sizeof(buffer), procinfo))      \
219
216
 
220
217
static struct prg_node {
221
218
    struct prg_node *next;
222
 
    unsigned long inode;
 
219
    int inode;
223
220
    char name[PROGNAME_WIDTH];
224
221
} *prg_hash[PRG_HASH_SIZE];
225
222
 
252
249
/* NOT working as of glibc-2.0.7: */
253
250
#undef  DIRENT_HAVE_D_TYPE_WORKS
254
251
 
255
 
static void prg_cache_add(unsigned long inode, char *name)
 
252
static void prg_cache_add(int inode, char *name)
256
253
{
257
254
    unsigned hi = PRG_HASHIT(inode);
258
255
    struct prg_node **pnp,*pn;
275
272
    strcpy(pn->name,name);
276
273
}
277
274
 
278
 
static const char *prg_cache_get(unsigned long inode)
 
275
static const char *prg_cache_get(int inode)
279
276
{
280
277
    unsigned hi=PRG_HASHIT(inode);
281
278
    struct prg_node *pn;
298
295
    prg_cache_loaded=0;
299
296
}
300
297
 
301
 
static int extract_type_1_socket_inode(const char lname[], unsigned long * inode_p) {
 
298
static void extract_type_1_socket_inode(const char lname[], long * inode_p) {
302
299
 
303
300
    /* If lname is of the form "socket:[12345]", extract the "12345"
304
301
       as *inode_p.  Otherwise, return -1 as *inode_p.
305
302
       */
306
303
 
307
 
    if (strlen(lname) < PRG_SOCKET_PFXl+3) return(-1);
308
 
    
309
 
    if (memcmp(lname, PRG_SOCKET_PFX, PRG_SOCKET_PFXl)) return(-1);
310
 
    if (lname[strlen(lname)-1] != ']') return(-1);
311
 
 
312
 
    {
 
304
    if (strlen(lname) < PRG_SOCKET_PFXl+3) *inode_p = -1;
 
305
    else if (memcmp(lname, PRG_SOCKET_PFX, PRG_SOCKET_PFXl)) *inode_p = -1;
 
306
    else if (lname[strlen(lname)-1] != ']') *inode_p = -1;
 
307
    else {
313
308
        char inode_str[strlen(lname + 1)];  /* e.g. "12345" */
314
309
        const int inode_str_len = strlen(lname) - PRG_SOCKET_PFXl - 1;
315
310
        char *serr;
318
313
        inode_str[inode_str_len] = '\0';
319
314
        *inode_p = strtol(inode_str,&serr,0);
320
315
        if (!serr || *serr || *inode_p < 0 || *inode_p >= INT_MAX) 
321
 
            return(-1);
 
316
            *inode_p = -1;
322
317
    }
323
 
    return(0);
324
318
}
325
319
 
326
320
 
327
321
 
328
 
static int extract_type_2_socket_inode(const char lname[], unsigned long * inode_p) {
 
322
static void extract_type_2_socket_inode(const char lname[], long * inode_p) {
329
323
 
330
324
    /* If lname is of the form "[0000]:12345", extract the "12345"
331
325
       as *inode_p.  Otherwise, return -1 as *inode_p.
332
326
       */
333
327
 
334
 
    if (strlen(lname) < PRG_SOCKET_PFX2l+1) return(-1);
335
 
    if (memcmp(lname, PRG_SOCKET_PFX2, PRG_SOCKET_PFX2l)) return(-1);
336
 
 
337
 
    {
 
328
    if (strlen(lname) < PRG_SOCKET_PFX2l+1) *inode_p = -1;
 
329
    else if (memcmp(lname, PRG_SOCKET_PFX2, PRG_SOCKET_PFX2l)) *inode_p = -1;
 
330
    else {
338
331
        char *serr;
339
332
 
340
333
        *inode_p=strtol(lname + PRG_SOCKET_PFX2l,&serr,0);
341
334
        if (!serr || *serr || *inode_p < 0 || *inode_p >= INT_MAX) 
342
 
            return(-1);
 
335
            *inode_p = -1;
343
336
    }
344
 
    return(0);
345
337
}
346
338
 
347
339
 
348
340
 
349
 
 
350
341
static void prg_cache_load(void)
351
342
{
352
343
    char line[LINE_MAX],eacces=0;
353
344
    int procfdlen,fd,cmdllen,lnamelen;
354
345
    char lname[30],cmdlbuf[512],finbuf[PROGNAME_WIDTH];
355
 
    unsigned long inode;
 
346
    long inode;
356
347
    const char *cs,*cmdlp;
357
348
    DIR *dirproc=NULL,*dirfd=NULL;
358
349
    struct dirent *direproc,*direfd;
386
377
#ifdef DIRENT_HAVE_D_TYPE_WORKS
387
378
            if (direfd->d_type!=DT_LNK) 
388
379
                continue;
389
 
#else
390
 
            /* Skip . and .. */
391
 
            if (!isdigit(direfd->d_name[0]))
392
 
                continue;
393
380
#endif
394
381
            if (procfdlen+1+strlen(direfd->d_name)+1>sizeof(line)) 
395
382
                continue;
399
386
            lnamelen=readlink(line,lname,sizeof(lname)-1);
400
387
            lname[lnamelen] = '\0';  /*make it a null-terminated string*/
401
388
 
402
 
            if (extract_type_1_socket_inode(lname, &inode) < 0)
403
 
              if (extract_type_2_socket_inode(lname, &inode) < 0)
404
 
                continue;
 
389
            extract_type_1_socket_inode(lname, &inode);
 
390
 
 
391
            if (inode < 0) extract_type_2_socket_inode(lname, &inode);
 
392
 
 
393
            if (inode < 0) continue;
405
394
 
406
395
            if (!cmdlp) {
407
396
                if (procfdlen - PATH_FD_SUFFl + PATH_CMDLINEl >= 
461
450
    char buffer[256], dev[16];
462
451
    int st, vs, vr, sendq, recvq, ret;
463
452
 
464
 
    f = proc_fopen(_PATH_PROCNET_NR);
 
453
    f = fopen(_PATH_PROCNET_NR, "r");
465
454
    if (f == NULL) {
466
455
        if (errno != ENOENT) {
467
456
            perror(_PATH_PROCNET_NR);
538
527
 
539
528
    if (flag_exp > 1) {
540
529
        if (!(flag_not & FLAG_NUM_USER) && ((pw = getpwuid(uid)) != NULL))
541
 
            printf(" %-10s ", pw->pw_name);
 
530
            printf("%-10s ", pw->pw_name);
542
531
        else
543
 
            printf(" %-10d ", uid);
544
 
        printf("%-10lu ",inode);
 
532
            printf("%-10d ", uid);
 
533
        printf("%-10ld ",inode);
545
534
    }
546
535
    if (flag_prg)
547
 
        printf(" %-16s",prg_cache_get(inode));
 
536
        printf("%-" PROGNAME_WIDTHs "s",prg_cache_get(inode));
548
537
    if (flag_opt)
549
 
        printf(" %s", timers);
 
538
        printf("%s", timers);
550
539
    putchar('\n');
551
540
}
552
541
 
657
646
#if HAVE_AFX25
658
647
static int x25_info(void)
659
648
{
660
 
       FILE *f=proc_fopen(_PATH_PROCNET_X25);
 
649
       FILE *f=fopen(_PATH_PROCNET_X25, "r");
661
650
       char buffer[256],dev[16];
662
651
       int st,vs,vr,sendq,recvq,lci;
663
652
       static char *x25_state[5]=
668
657
               "ESTABLISHED",
669
658
               "RECOVERY"
670
659
       };
671
 
       if(!(f=proc_fopen(_PATH_PROCNET_X25)))
 
660
       if(!(f=fopen(_PATH_PROCNET_X25, "r")))
672
661
       {
673
662
               if (errno != ENOENT) {
674
663
                       perror(_PATH_PROCNET_X25);
716
705
    unsigned long rxq, txq, time_len, retr, inode;
717
706
    int num, local_port, rem_port, d, state, uid, timer_run, timeout;
718
707
    char rem_addr[128], local_addr[128], timers[64], buffer[1024], more[512];
719
 
    char *protname;
720
708
    struct aftype *ap;
721
709
#if HAVE_AFINET6
722
710
    struct sockaddr_in6 localaddr, remaddr;
731
719
        return;
732
720
 
733
721
    num = sscanf(line,
734
 
    "%d: %64[0-9A-Fa-f]:%X %64[0-9A-Fa-f]:%X %X %lX:%lX %X:%lX %lX %d %d %lu %512s\n",
 
722
    "%d: %64[0-9A-Fa-f]:%X %64[0-9A-Fa-f]:%X %X %lX:%lX %X:%lX %lX %d %d %ld %512s\n",
735
723
                 &d, local_addr, &local_port, rem_addr, &rem_port, &state,
736
724
                 &txq, &rxq, &timer_run, &time_len, &retr, &uid, &timeout, &inode, more);
737
725
 
738
726
    if (strlen(local_addr) > 8) {
739
727
#if HAVE_AFINET6
740
 
        protname = "tcp6";
741
728
        /* Demangle what the kernel gives us */
742
729
        sscanf(local_addr, "%08X%08X%08X%08X",
743
730
               &in6.s6_addr32[0], &in6.s6_addr32[1],
753
740
        remaddr.sin6_family = AF_INET6;
754
741
#endif
755
742
    } else {
756
 
        protname = "tcp";
757
743
        sscanf(local_addr, "%X",
758
744
               &((struct sockaddr_in *) &localaddr)->sin_addr.s_addr);
759
745
        sscanf(rem_addr, "%X",
827
813
                         timer_run, (double) time_len / HZ, retr, timeout);
828
814
                break;
829
815
            }
830
 
        printf("%-4s  %6ld %6ld %-*s %-*s %-11s",
831
 
               protname, rxq, txq, netmax(23,strlen(local_addr)), local_addr, netmax(23,strlen(rem_addr)), rem_addr, _(tcp_state[state]));
 
816
        printf("tcp   %6ld %6ld %-23s %-23s %-12s",
 
817
               rxq, txq, local_addr, rem_addr, _(tcp_state[state]));
832
818
 
833
819
        finish_this_one(uid,inode,timers);
834
820
    }
845
831
    char buffer[8192], local_addr[64], rem_addr[64];
846
832
    char *udp_state, timers[64], more[512];
847
833
    int num, local_port, rem_port, d, state, timer_run, uid, timeout;
848
 
    char *protname;
849
834
#if HAVE_AFINET6
850
835
    struct sockaddr_in6 localaddr, remaddr;
851
836
    char addr6[INET6_ADDRSTRLEN];
862
847
 
863
848
    more[0] = '\0';
864
849
    num = sscanf(line,
865
 
                 "%d: %64[0-9A-Fa-f]:%X %64[0-9A-Fa-f]:%X %X %lX:%lX %X:%lX %lX %d %d %lu %512s\n",
 
850
                 "%d: %64[0-9A-Fa-f]:%X %64[0-9A-Fa-f]:%X %X %lX:%lX %X:%lX %lX %d %d %ld %512s\n",
866
851
                 &d, local_addr, &local_port,
867
852
                 rem_addr, &rem_port, &state,
868
853
          &txq, &rxq, &timer_run, &time_len, &retr, &uid, &timeout, &inode, more);
869
854
 
870
855
    if (strlen(local_addr) > 8) {
871
856
#if HAVE_AFINET6
872
 
        protname="udp6";
873
857
        sscanf(local_addr, "%08X%08X%08X%08X",
874
858
               &in6.s6_addr32[0], &in6.s6_addr32[1],
875
859
               &in6.s6_addr32[2], &in6.s6_addr32[3]);
884
868
        remaddr.sin6_family = AF_INET6;
885
869
#endif
886
870
    } else {
887
 
        protname="udp";
888
871
        sscanf(local_addr, "%X",
889
872
               &((struct sockaddr_in *) &localaddr)->sin_addr.s_addr);
890
873
        sscanf(rem_addr, "%X",
970
953
                         retr, timeout);
971
954
                break;
972
955
            }
973
 
        printf("%-4s  %6ld %6ld %-23s %-23s %-11s",
974
 
               protname, rxq, txq, local_addr, rem_addr, udp_state);
 
956
        printf("udp   %6ld %6ld %-23s %-23s %-12s",
 
957
               rxq, txq, local_addr, rem_addr, udp_state);
975
958
 
976
959
        finish_this_one(uid,inode,timers);
977
960
    }
988
971
    char buffer[8192], local_addr[64], rem_addr[64];
989
972
    char timers[64], more[512];
990
973
    int num, local_port, rem_port, d, state, timer_run, uid, timeout;
991
 
    char *protname;
992
974
#if HAVE_AFINET6
993
975
    struct sockaddr_in6 localaddr, remaddr;
994
976
    char addr6[INET6_ADDRSTRLEN];
1005
987
 
1006
988
    more[0] = '\0';
1007
989
    num = sscanf(line,
1008
 
                 "%d: %64[0-9A-Fa-f]:%X %64[0-9A-Fa-f]:%X %X %lX:%lX %X:%lX %lX %d %d %lu %512s\n",
 
990
                 "%d: %64[0-9A-Fa-f]:%X %64[0-9A-Fa-f]:%X %X %lX:%lX %X:%lX %lX %d %d %ld %512s\n",
1009
991
                 &d, local_addr, &local_port, rem_addr, &rem_port, &state,
1010
992
          &txq, &rxq, &timer_run, &time_len, &retr, &uid, &timeout, &inode, more);
1011
993
 
1012
994
    if (strlen(local_addr) > 8) {
1013
995
#if HAVE_AFINET6
1014
 
        protname = "raw6";
1015
996
        sscanf(local_addr, "%08X%08X%08X%08X",
1016
997
               &in6.s6_addr32[0], &in6.s6_addr32[1],
1017
998
           &in6.s6_addr32[2], &in6.s6_addr32[3]);
1026
1007
        remaddr.sin6_family = AF_INET6;
1027
1008
#endif
1028
1009
    } else {
1029
 
        protname = "raw";
1030
1010
        sscanf(local_addr, "%X",
1031
1011
               &((struct sockaddr_in *) &localaddr)->sin_addr.s_addr);
1032
1012
        sscanf(rem_addr, "%X",
1094
1074
                         retr, timeout);
1095
1075
                break;
1096
1076
            }
1097
 
        printf("%-4s  %6ld %6ld %-23s %-23s %-11d",
1098
 
               protname, rxq, txq, local_addr, rem_addr, state);
 
1077
        printf("raw   %6ld %6ld %-23s %-23s %-12d",
 
1078
               rxq, txq, local_addr, rem_addr, state);
1099
1079
 
1100
1080
        finish_this_one(uid,inode,timers);
1101
1081
    }
1119
1099
    static int has = 0;
1120
1100
    char path[MAXPATHLEN], ss_flags[32];
1121
1101
    char *ss_proto, *ss_state, *ss_type;
1122
 
    int num, state, type;
 
1102
    int num, state, type, inode;
1123
1103
    void *d;
1124
 
    unsigned long refcnt, proto, flags, inode;
 
1104
    unsigned long refcnt, proto, flags;
1125
1105
 
1126
1106
    if (nr == 0) {
1127
1107
        if (strstr(line, "Inode"))
1129
1109
        return;
1130
1110
    }
1131
1111
    path[0] = '\0';
1132
 
    num = sscanf(line, "%p: %lX %lX %lX %X %X %lu %s",
 
1112
    num = sscanf(line, "%p: %lX %lX %lX %X %X %d %s",
1133
1113
                 &d, &refcnt, &proto, &flags, &type, &state, &inode, path);
1134
1114
    if (num < 6) {
1135
1115
        fprintf(stderr, _("warning, got bogus unix line.\n"));
1136
1116
        return;
1137
1117
    }
1138
1118
    if (!(has & HAS_INODE))
1139
 
        snprintf(path,sizeof(path),"%lu",inode);
 
1119
        snprintf(path,sizeof(path),"%d",inode);
1140
1120
 
1141
1121
    if (!flag_all) {
1142
1122
        if ((state == SS_UNCONNECTED) && (flags & SO_ACCEPTCON)) {
1228
1208
    printf("%-5s %-6ld %-11s %-10s %-13s ",
1229
1209
           ss_proto, refcnt, ss_flags, ss_type, ss_state);
1230
1210
    if (has & HAS_INODE)
1231
 
        printf("%-8lu ",inode);
 
1211
        printf("%-6d ",inode);
1232
1212
    else
1233
 
        printf("-        ");
 
1213
        printf("-      ");
1234
1214
    if (flag_prg)
1235
1215
        printf("%-" PROGNAME_WIDTHs "s",(has & HAS_INODE?prg_cache_get(inode):"-"));
1236
1216
    puts(path);
1249
1229
        printf(_("(w/o servers)"));
1250
1230
    }
1251
1231
 
1252
 
    printf(_("\nProto RefCnt Flags       Type       State         I-Node  "));
 
1232
    printf(_("\nProto RefCnt Flags       Type       State         I-Node"));
1253
1233
    print_progname_banner();
1254
1234
    printf(_(" Path\n"));       /* xxx */
1255
1235
 
1276
1256
        N_("ESTABLISHED"),
1277
1257
        N_("RECOVERY")
1278
1258
    };
1279
 
    if (!(f = proc_fopen(_PATH_PROCNET_AX25))) {
 
1259
    if (!(f = fopen(_PATH_PROCNET_AX25, "r"))) {
1280
1260
        if (errno != ENOENT) {
1281
1261
            perror(_PATH_PROCNET_AX25);
1282
1262
            return (-1);
1370
1350
    char sad[50], dad[50];
1371
1351
    struct sockaddr sa;
1372
1352
    unsigned sport = 0, dport = 0;
1373
 
    struct stat s;
1374
 
    
1375
 
    f = proc_fopen(_PATH_PROCNET_IPX_SOCKET1);
1376
 
    if (!f) {
1377
 
        if (errno != ENOENT) {
1378
 
            perror(_PATH_PROCNET_IPX_SOCKET1);
1379
 
            return (-1);
1380
 
        }
1381
 
        f = proc_fopen(_PATH_PROCNET_IPX_SOCKET2);
1382
 
 
1383
 
        /* We need to check for directory */
1384
 
        if (f) {
1385
 
            fstat(fileno(f), &s);
1386
 
            if (!S_ISREG(s.st_mode)) {
1387
 
                fclose(f);
1388
 
                f=NULL;
1389
 
            }
1390
 
        }
1391
 
 
1392
 
        if (!f) {
1393
 
            if (errno != ENOENT) {
1394
 
                perror(_PATH_PROCNET_IPX_SOCKET2);
1395
 
                return (-1);
1396
 
            }
1397
 
            if (flag_arg || flag_ver)
1398
 
                ESYSNOT("netstat", "AF IPX");
1399
 
            if (flag_arg)
1400
 
                return (1);
1401
 
            else
1402
 
                return (0);
1403
 
        }
 
1353
 
 
1354
    if (!(f = fopen(_PATH_PROCNET_IPX, "r"))) {
 
1355
        if (errno != ENOENT) {
 
1356
            perror(_PATH_PROCNET_IPX);
 
1357
            return (-1);
 
1358
        }
 
1359
        if (flag_arg || flag_ver)
 
1360
            ESYSNOT("netstat", "AF IPX");
 
1361
        if (flag_arg)
 
1362
            return (1);
 
1363
        else
 
1364
            return (0);
1404
1365
    }
1405
1366
    printf(_("Active IPX sockets\nProto Recv-Q Send-Q Local Address              Foreign Address            State"));   /* xxx */
1406
1367
    if (flag_exp > 1)
1420
1381
            sscanf(st, "%X", &sport);   /* net byt order */
1421
1382
            sport = ntohs(sport);
1422
1383
        } else {
1423
 
            EINTERN("netstat.c", "ipx socket format error in source port");
 
1384
            EINTERN("netstat.c", _PATH_PROCNET_IPX " sport format error");
1424
1385
            return (-1);
1425
1386
        }
1426
1387
        nc = 0;
1430
1391
                sscanf(st, "%X", &dport);       /* net byt order */
1431
1392
                dport = ntohs(dport);
1432
1393
            } else {
1433
 
                EINTERN("netstat.c", "ipx soket format error in destination port");
 
1394
                EINTERN("netstat.c", _PATH_PROCNET_IPX " dport format error");
1434
1395
                return (-1);
1435
1396
            }
1436
1397
        } else
1488
1449
    }
1489
1450
    if (flag_exp < 2) {
1490
1451
        ife_short = 1;
1491
 
        printf(_("Iface   MTU Met   RX-OK RX-ERR RX-DRP RX-OVR    TX-OK TX-ERR TX-DRP TX-OVR Flg\n"));
 
1452
        printf(_("Iface   MTU Met   RX-OK RX-ERR RX-DRP RX-OVR   TX-OK TX-ERR TX-DRP TX-OVR Flg\n"));
1492
1453
    }
1493
1454
 
1494
1455
    if (for_all_interfaces(do_if_print, &flag_all) < 0) {
1496
1457
        exit(1);
1497
1458
    }
1498
1459
    if (flag_cnt)
1499
 
        if_cache_free();
 
1460
        free_interface_list();
1500
1461
    else {
1501
1462
        close(skfd);
1502
1463
        skfd = -1;
1542
1503
    fprintf(stderr, _("        -C, --cache              display routing cache instead of FIB\n\n"));
1543
1504
 
1544
1505
    fprintf(stderr, _("  <Socket>={-t|--tcp} {-u|--udp} {-w|--raw} {-x|--unix} --ax25 --ipx --netrom\n"));
1545
 
    fprintf(stderr, _("  <AF>=Use '-6|-4' or '-A <af>' or '--<af>'; default: %s\n"), DFLT_AF);
 
1506
    fprintf(stderr, _("  <AF>=Use '-A <af>' or '--<af>'; default: %s\n"), DFLT_AF);
1546
1507
    fprintf(stderr, _("  List of possible address families (which support routing):\n"));
1547
1508
    print_aflist(1); /* 1 = routeable */
1548
1509
    exit(E_USAGE);
1553
1514
 (int argc, char *argv[]) {
1554
1515
    int i;
1555
1516
    int lop;
1556
 
    static struct option longopts[] =
 
1517
    struct option longopts[] =
1557
1518
    {
1558
1519
        AFTRANS_OPTS,
1559
1520
        {"version", 0, 0, 'V'},
1595
1556
    getroute_init();            /* Set up AF routing support */
1596
1557
 
1597
1558
    afname[0] = '\0';
1598
 
    while ((i = getopt_long(argc, argv, "MCFA:acdegphinNorstuVv?wxl64", longopts, &lop)) != EOF)
 
1559
    while ((i = getopt_long(argc, argv, "MCFA:acdegphinNorstuVv?wxl", longopts, &lop)) != EOF)
1599
1560
        switch (i) {
1600
1561
        case -1:
1601
1562
            break;
1663
1624
        case 'o':
1664
1625
            flag_opt++;
1665
1626
            break;
1666
 
        case '6':
1667
 
            if (aftrans_opt("inet6"))
1668
 
                exit(1);
1669
 
            break;
1670
 
        case '4':
1671
 
            if (aftrans_opt("inet"))
1672
 
                exit(1);
1673
 
            break;
1674
1627
        case 'V':
1675
1628
            version();
1676
1629
            /*NOTREACHED */
1735
1688
    }
1736
1689
 
1737
1690
    if (flag_sta) {
1738
 
        char *tmp1, *tmp2;
1739
 
        char buf[256];
1740
 
        if (!afname[0]) {
1741
 
            inittab();
1742
 
            parsesnmp(flag_raw, flag_tcp, flag_udp);
1743
 
        } else {
1744
 
            safe_strncpy(buf, afname, sizeof(buf));
1745
 
            tmp1 = buf;
1746
 
            if ((tmp2 = index(tmp1, ',')))
1747
 
                 printf("Multiple interface\n");
1748
 
            else if(!strncmp(buf,"inet6",5)) {
1749
 
#if HAVE_AFINET6
1750
 
                 inittab6();
1751
 
                 parsesnmp6(flag_raw, flag_tcp, flag_udp);
1752
 
#else
1753
 
                 printf("Address type not supported for stats\n");
1754
 
#endif
1755
 
            }
1756
 
            else
1757
 
                 printf("Address type not supported for stats\n");
1758
 
        }
1759
 
        exit(1);
 
1691
        inittab();
 
1692
        parsesnmp(flag_raw, flag_tcp, flag_udp);
 
1693
        exit(0);
1760
1694
    }
1761
1695
    
1762
1696
    if (flag_rou) {
1807
1741
            }
1808
1742
            printf(_("\nProto Recv-Q Send-Q Local Address           Foreign Address         State      "));     /* xxx */
1809
1743
            if (flag_exp > 1)
1810
 
                printf(_(" User       Inode      "));
1811
 
            if (flag_prg)
1812
 
                printf(_(" PID/Program name"));
 
1744
                printf(_(" User       Inode     "));
 
1745
            print_progname_banner();
1813
1746
            if (flag_opt)
1814
 
                printf(_(" Timer"));
 
1747
                printf(_(" Timer"));    /* xxx */
1815
1748
            printf("\n");
1816
1749
#else
1817
1750
            if (flag_arg) {
1912
1845
            }
1913
1846
#endif
1914
1847
        }
1915
 
                    
1916
1848
        if (!flag_cnt || i)
1917
1849
            break;
1918
1850
        sleep(1);