← Back to branch summary

~ubuntu-branches/debian/sid/net-tools/sid

« back to all changes in this revision

Viewing changes to netstat.c

  • Committer: Package Import Robot
  • Author(s): Martín Ferrari
  • Date: 2015-09-07 01:54:07 UTC
  • mfrom: (1.1.1)
  • Revision ID: package-import@ubuntu.com-20150907015407-v2tfsgxayjd3iq4i
Tags: 1.60+git20150829.73cef8a-1
http://bugs.debian.org/391495
http://bugs.debian.org/486448
http://bugs.debian.org/323261
http://bugs.debian.org/260587
http://bugs.debian.org/545328
http://bugs.debian.org/511395
* After 14 years without an upstream release, I am producing a new package
  based on today's upstream repository.
  Closes: #391495, #486448, #323261, #260587, #545328, #511395.
* Remove many patches now merged upstream, delete unmaintainable and
  undocumented local changes, and update the rest.

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.73 2011-04-20 01:35:22 ecki 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>
23
23
 * Modified:
24
24
 *
25
25
 *960116 {1.01} Bernd Eckenfels:        verbose, cleanups
26
 
 *960204 {1.10} Bernd Eckenfels:        aftrans, usage, new route_info, 
 
26
 *960204 {1.10} Bernd Eckenfels:        aftrans, usage, new route_info,
27
27
 *                                      DLFT_AF
28
28
 *960204 {1.11} Bernd Eckenfels:        netlink support
29
29
 *960204 {1.12} Bernd Eckenfels:        route_init()
30
30
 *960215 {1.13} Bernd Eckenfels:        netlink_print honors HAVE_
31
 
 *960217 {1.14} Bernd Eckenfels:        masq_info from Jos Vos and 
 
31
 *960217 {1.14} Bernd Eckenfels:        masq_info from Jos Vos and
32
32
 *                                      ax25_info from Jonathan Naylor.
33
33
 *960218 {1.15} Bernd Eckenfels:        ipx_info rewritten, -e for tcp/ipx
34
34
 *960220 {1.16} Bernd Eckenfels:        minor output reformats, -a for -x
35
35
 *960221 {1.17} Bernd Eckenfels:        route_init->getroute_init
36
36
 *960426 {1.18} Bernd Eckenfels:        new RTACTION, SYM/NUM, FIB/CACHE
37
 
 *960517 {1.19} Bernd Eckenfels:        usage() spelling fix and --unix inode, 
 
37
 *960517 {1.19} Bernd Eckenfels:        usage() spelling fix and --unix inode,
38
38
 *                                      ':' is part of sock_addr for --inet
39
39
 *960822 {x.xx} Frank Strauss:          INET6 support
40
40
 *
41
41
 *970406 {1.33} Philip Copeland         Added snmp reporting support module -s
42
42
 *                                      code provided by Andi Kleen
43
 
 *                                      (relly needs to be kernel hooked but 
 
43
 *                                      (relly needs to be kernel hooked but
44
44
 *                                      this will do in the meantime)
45
45
 *                                      minor header file misplacement tidy up.
46
46
 *980815 {1.xx} Stephane Fillod:       X.25 support
58
58
 *
59
59
 *990420 {1.38} Tuan Hoang              removed a useless assignment from igmp_do_one()
60
60
 *20010404 {1.39} Arnaldo Carvalho de Melo - use setlocale
 
61
 *20081201 {1.42} Brian Micek           added -L|--udplite options for RFC 3828
 
62
 *20020722 {1.51} Thomas Preusser       added SCTP over IPv4 support
61
63
 *
62
64
 *              This program is free software; you can redistribute it
63
65
 *              and/or  modify it under  the terms of  the GNU General
83
85
#include <arpa/inet.h>
84
86
#include <netinet/in.h>
85
87
#include <sys/ioctl.h>
 
88
#include <sys/stat.h>
86
89
#include <net/if.h>
87
90
#include <dirent.h>
88
 
#include <sys/stat.h>
89
91
#include <sys/types.h>
90
92
 
91
93
#include "net-support.h"
98
100
#include "util.h"
99
101
#include "proc.h"
100
102
 
 
103
#if HAVE_SELINUX
 
104
#include <selinux/selinux.h>
 
105
#endif
 
106
 
 
107
#if HAVE_AFBLUETOOTH
 
108
#include <bluetooth/bluetooth.h>
 
109
#endif
 
110
 
101
111
#define PROGNAME_WIDTH 20
 
112
#define SELINUX_WIDTH 50
102
113
 
103
114
#if !defined(s6_addr32) && defined(in6a_words)
104
115
#define s6_addr32 in6a_words    /* libinet6                     */
105
116
#endif
106
117
 
107
118
/* prototypes for statistics.c */
108
 
void parsesnmp(int, int, int);
109
 
void inittab(void);
 
119
void parsesnmp(int, int, int, int);
110
120
void parsesnmp6(int, int, int);
111
 
void inittab6(void);
112
121
 
113
122
typedef enum {
114
123
    SS_FREE = 0,                /* not allocated                */
127
136
#define FEATURE_NETSTAT
128
137
#include "lib/net-features.h"
129
138
 
130
 
char *Release = RELEASE, *Version = "netstat 1.42 (2001-04-15)", *Signature = "Fred Baumgarten, Alan Cox, Bernd Eckenfels, Phil Blundell, Tuan Hoang and others";
 
139
static char *Release = RELEASE, *Signature = "Fred Baumgarten, Alan Cox, Bernd Eckenfels, Phil Blundell, Tuan Hoang, Brian Micek and others";
131
140
 
132
141
 
133
142
#define E_READ  -1
147
156
int flag_opt = 0;
148
157
int flag_raw = 0;
149
158
int flag_tcp = 0;
 
159
int flag_sctp= 0;
150
160
int flag_udp = 0;
 
161
int flag_udplite = 0;
151
162
int flag_igmp= 0;
152
163
int flag_rom = 0;
153
164
int flag_exp = 1;
154
165
int flag_wide= 0;
155
166
int flag_prg = 0;
156
167
int flag_arg = 0;
 
168
int flag_noprot = 0;
157
169
int flag_ver = 0;
 
170
int flag_l2cap = 0;
 
171
int flag_rfcomm = 0;
 
172
int flag_selinux = 0;
158
173
 
159
174
FILE *procinfo;
160
175
 
161
 
#define INFO_GUTS1(file,name,proc)                      \
 
176
#define INFO_GUTS1(file,name,proc,prot)                 \
162
177
  procinfo = proc_fopen((file));                        \
163
178
  if (procinfo == NULL) {                               \
164
 
    if (errno != ENOENT) {                              \
 
179
    if (errno != ENOENT && errno != EACCES) {           \
165
180
      perror((file));                                   \
166
181
      return -1;                                        \
167
182
    }                                                   \
168
 
    if (flag_arg || flag_ver)                           \
 
183
    if (!flag_noprot && (flag_arg || flag_ver))         \
169
184
      ESYSNOT("netstat", (name));                       \
170
 
    if (flag_arg)                                       \
 
185
    if (!flag_noprot && flag_arg)                       \
171
186
      rc = 1;                                           \
172
187
  } else {                                              \
173
188
    do {                                                \
174
189
      if (fgets(buffer, sizeof(buffer), procinfo))      \
175
 
        (proc)(lnr++, buffer);                          \
 
190
        (proc)(lnr++, buffer,prot);                     \
176
191
    } while (!feof(procinfo));                          \
177
192
    fclose(procinfo);                                   \
178
193
  }
179
194
 
180
195
#if HAVE_AFINET6
181
 
#define INFO_GUTS2(file,proc)                           \
 
196
#define INFO_GUTS2(file,proc,prot)                      \
182
197
  lnr = 0;                                              \
183
198
  procinfo = proc_fopen((file));                        \
184
199
  if (procinfo != NULL) {                               \
185
200
    do {                                                \
186
201
      if (fgets(buffer, sizeof(buffer), procinfo))      \
187
 
        (proc)(lnr++, buffer);                          \
 
202
        (proc)(lnr++, buffer,prot);                     \
188
203
    } while (!feof(procinfo));                          \
189
204
    fclose(procinfo);                                   \
190
205
  }
191
206
#else
192
 
#define INFO_GUTS2(file,proc)
 
207
#define INFO_GUTS2(file,proc,prot)
193
208
#endif
194
209
 
195
210
#define INFO_GUTS3                                      \
196
211
 return rc;
197
212
 
198
 
#define INFO_GUTS6(file,file6,name,proc)                \
 
213
#define INFO_GUTS6(file,file6,name,proc,prot4,prot6)    \
199
214
 char buffer[8192];                                     \
200
215
 int rc = 0;                                            \
201
216
 int lnr = 0;                                           \
202
217
 if (!flag_arg || flag_inet) {                          \
203
 
    INFO_GUTS1(file,name,proc)                          \
 
218
    INFO_GUTS1(file,name,proc,prot4)                    \
204
219
 }                                                      \
205
220
 if (!flag_arg || flag_inet6) {                         \
206
 
    INFO_GUTS2(file6,proc)                              \
 
221
    INFO_GUTS2(file6,proc,prot6)                        \
207
222
 }                                                      \
208
223
 INFO_GUTS3
209
224
 
210
 
#define INFO_GUTS(file,name,proc)                       \
 
225
#define INFO_GUTS(file,name,proc,prot)                  \
211
226
 char buffer[8192];                                     \
212
227
 int rc = 0;                                            \
213
228
 int lnr = 0;                                           \
214
 
 INFO_GUTS1(file,name,proc)                             \
 
229
 INFO_GUTS1(file,name,proc,prot)                        \
215
230
 INFO_GUTS3
216
231
 
217
232
#define PROGNAME_WIDTHs PROGNAME_WIDTH1(PROGNAME_WIDTH)
218
233
#define PROGNAME_WIDTH1(s) PROGNAME_WIDTH2(s)
219
234
#define PROGNAME_WIDTH2(s) #s
220
235
 
 
236
#define SELINUX_WIDTHs SELINUX_WIDTH1(SELINUX_WIDTH)
 
237
#define SELINUX_WIDTH1(s) SELINUX_WIDTH2(s)
 
238
#define SELINUX_WIDTH2(s) #s
 
239
 
221
240
#define PRG_HASH_SIZE 211
222
241
 
223
242
static struct prg_node {
224
243
    struct prg_node *next;
225
244
    unsigned long inode;
226
245
    char name[PROGNAME_WIDTH];
 
246
    char scon[SELINUX_WIDTH];
227
247
} *prg_hash[PRG_HASH_SIZE];
228
248
 
229
249
static char prg_cache_loaded = 0;
231
251
#define PRG_HASHIT(x) ((x) % PRG_HASH_SIZE)
232
252
 
233
253
#define PROGNAME_BANNER "PID/Program name"
234
 
 
235
 
#define print_progname_banner() do { if (flag_prg) printf("%-" PROGNAME_WIDTHs "s"," " PROGNAME_BANNER); } while (0)
 
254
#define SELINUX_BANNER "Security Context"
 
255
 
 
256
#define print_progname_banner() do { if (flag_prg) printf(" %-" PROGNAME_WIDTHs "s",PROGNAME_BANNER); } while (0)
 
257
 
 
258
#define print_selinux_banner() do { if (flag_selinux) printf("%-" SELINUX_WIDTHs "s"," " SELINUX_BANNER); } while (0)
236
259
 
237
260
#define PRG_LOCAL_ADDRESS "local_address"
238
261
#define PRG_INODE        "inode"
252
275
#define PATH_PROC_X_FD      PATH_PROC "/%s/" PATH_FD_SUFF
253
276
#define PATH_CMDLINE    "cmdline"
254
277
#define PATH_CMDLINEl       strlen(PATH_CMDLINE)
255
 
/* NOT working as of glibc-2.0.7: */
256
 
#undef  DIRENT_HAVE_D_TYPE_WORKS
257
278
 
258
 
static void prg_cache_add(unsigned long inode, char *name)
 
279
static void prg_cache_add(unsigned long inode, char *name, const char *scon)
259
280
{
260
281
    unsigned hi = PRG_HASHIT(inode);
261
282
    struct prg_node **pnp,*pn;
262
283
 
263
 
    prg_cache_loaded=2;
264
 
    for (pnp=prg_hash+hi;(pn=*pnp);pnp=&pn->next) {
265
 
        if (pn->inode==inode) {
 
284
    prg_cache_loaded = 2;
 
285
    for (pnp = prg_hash + hi; (pn = *pnp); pnp = &pn->next) {
 
286
        if (pn->inode == inode) {
266
287
            /* Some warning should be appropriate here
267
288
               as we got multiple processes for one i-node */
268
289
            return;
269
290
        }
270
291
    }
271
 
    if (!(*pnp=malloc(sizeof(**pnp)))) 
 
292
    if (!(*pnp = malloc(sizeof(**pnp))))
272
293
        return;
273
 
    pn=*pnp;
274
 
    pn->next=NULL;
275
 
    pn->inode=inode;
276
 
    if (strlen(name)>sizeof(pn->name)-1) 
277
 
        name[sizeof(pn->name)-1]='\0';
278
 
    strcpy(pn->name,name);
 
294
    pn = *pnp;
 
295
    pn->next = NULL;
 
296
    pn->inode = inode;
 
297
    safe_strncpy(pn->name, name, sizeof(pn->name));
 
298
 
 
299
    {
 
300
        int len = (strlen(scon) - sizeof(pn->scon)) + 1;
 
301
        if (len > 0)
 
302
            safe_strncpy(pn->scon, &scon[len + 1], sizeof(pn->scon));
 
303
        else
 
304
            safe_strncpy(pn->scon, scon, sizeof(pn->scon));
 
305
    }
 
306
 
279
307
}
280
308
 
281
309
static const char *prg_cache_get(unsigned long inode)
282
310
{
283
 
    unsigned hi=PRG_HASHIT(inode);
284
 
    struct prg_node *pn;
285
 
 
286
 
    for (pn=prg_hash[hi];pn;pn=pn->next)
287
 
        if (pn->inode==inode) return(pn->name);
288
 
    return("-");
 
311
    unsigned hi = PRG_HASHIT(inode);
 
312
    struct prg_node *pn;
 
313
 
 
314
    for (pn = prg_hash[hi]; pn; pn = pn->next)
 
315
        if (pn->inode == inode)
 
316
            return (pn->name);
 
317
    return ("-");
 
318
}
 
319
 
 
320
static const char *prg_cache_get_con(unsigned long inode)
 
321
{
 
322
    unsigned hi = PRG_HASHIT(inode);
 
323
    struct prg_node *pn;
 
324
 
 
325
    for (pn = prg_hash[hi]; pn; pn = pn->next)
 
326
        if (pn->inode == inode)
 
327
            return (pn->scon);
 
328
    return ("-");
289
329
}
290
330
 
291
331
static void prg_cache_clear(void)
293
333
    struct prg_node **pnp,*pn;
294
334
 
295
335
    if (prg_cache_loaded == 2)
296
 
        for (pnp=prg_hash;pnp<prg_hash+PRG_HASH_SIZE;pnp++)
297
 
            while ((pn=*pnp)) {
298
 
                *pnp=pn->next;
 
336
        for (pnp = prg_hash; pnp < prg_hash + PRG_HASH_SIZE; pnp++)
 
337
            while ((pn = *pnp)) {
 
338
                *pnp = pn->next;
299
339
                free(pn);
300
340
            }
301
 
    prg_cache_loaded=0;
 
341
    prg_cache_loaded = 0;
 
342
}
 
343
 
 
344
static void wait_continous(void)
 
345
{
 
346
    fflush(stdout);
 
347
    sleep(1);
302
348
}
303
349
 
304
350
static int extract_type_1_socket_inode(const char lname[], unsigned long * inode_p) {
308
354
       */
309
355
 
310
356
    if (strlen(lname) < PRG_SOCKET_PFXl+3) return(-1);
311
 
    
 
357
 
312
358
    if (memcmp(lname, PRG_SOCKET_PFX, PRG_SOCKET_PFXl)) return(-1);
313
359
    if (lname[strlen(lname)-1] != ']') return(-1);
314
360
 
319
365
 
320
366
        strncpy(inode_str, lname+PRG_SOCKET_PFXl, inode_str_len);
321
367
        inode_str[inode_str_len] = '\0';
322
 
        *inode_p = strtoul(inode_str,&serr,0);
323
 
        if (!serr || *serr)
 
368
        *inode_p = strtoul(inode_str, &serr, 0);
 
369
        if (!serr || *serr || *inode_p == ~0)
324
370
            return(-1);
325
371
    }
326
372
    return(0);
340
386
    {
341
387
        char *serr;
342
388
 
343
 
        *inode_p=strtoul(lname + PRG_SOCKET_PFX2l,&serr,0);
344
 
        if (!serr || *serr)
 
389
        *inode_p = strtoul(lname + PRG_SOCKET_PFX2l, &serr, 0);
 
390
        if (!serr || *serr || *inode_p == ~0)
345
391
            return(-1);
346
392
    }
347
393
    return(0);
352
398
 
353
399
static void prg_cache_load(void)
354
400
{
355
 
    char line[LINE_MAX],eacces=0;
356
 
    int procfdlen,fd,cmdllen,lnamelen;
357
 
    char lname[30],cmdlbuf[512],finbuf[PROGNAME_WIDTH];
 
401
    char line[LINE_MAX], eacces=0;
 
402
    int procfdlen, fd, cmdllen, lnamelen;
 
403
    char lname[30], cmdlbuf[512], finbuf[PROGNAME_WIDTH];
358
404
    unsigned long inode;
359
 
    const char *cs,*cmdlp;
360
 
    DIR *dirproc=NULL,*dirfd=NULL;
361
 
    struct dirent *direproc,*direfd;
 
405
    const char *cs, *cmdlp;
 
406
    DIR *dirproc = NULL, *dirfd = NULL;
 
407
    struct dirent *direproc, *direfd;
 
408
#if HAVE_SELINUX
 
409
    security_context_t scon = NULL;
 
410
#endif
362
411
 
363
412
    if (prg_cache_loaded || !flag_prg) return;
364
 
    prg_cache_loaded=1;
365
 
    cmdlbuf[sizeof(cmdlbuf)-1]='\0';
 
413
    prg_cache_loaded = 1;
 
414
    cmdlbuf[sizeof(cmdlbuf) - 1] = '\0';
366
415
    if (!(dirproc=opendir(PATH_PROC))) goto fail;
367
 
    while (errno=0,direproc=readdir(dirproc)) {
368
 
#ifdef DIRENT_HAVE_D_TYPE_WORKS
369
 
        if (direproc->d_type!=DT_DIR) continue;
370
 
#endif
371
 
        for (cs=direproc->d_name;*cs;cs++)
372
 
            if (!isdigit(*cs)) 
 
416
    while (errno = 0, direproc = readdir(dirproc)) {
 
417
        for (cs = direproc->d_name; *cs; cs++)
 
418
            if (!isdigit(*cs))
373
419
                break;
374
 
        if (*cs) 
375
 
            continue;
376
 
        procfdlen=snprintf(line,sizeof(line),PATH_PROC_X_FD,direproc->d_name);
377
 
        if (procfdlen<=0 || procfdlen>=sizeof(line)-5) 
378
 
            continue;
379
 
        errno=0;
380
 
        dirfd=opendir(line);
 
420
        if (*cs)
 
421
            continue;
 
422
        procfdlen = snprintf(line,sizeof(line),PATH_PROC_X_FD,direproc->d_name);
 
423
        if (procfdlen <= 0 || procfdlen >= sizeof(line) - 5)
 
424
            continue;
 
425
        errno = 0;
 
426
        dirfd = opendir(line);
381
427
        if (! dirfd) {
382
 
            if (errno==EACCES) 
383
 
                eacces=1;
 
428
            if (errno == EACCES)
 
429
                eacces = 1;
384
430
            continue;
385
431
        }
386
432
        line[procfdlen] = '/';
387
433
        cmdlp = NULL;
388
434
        while ((direfd = readdir(dirfd))) {
389
 
#ifdef DIRENT_HAVE_D_TYPE_WORKS
390
 
            if (direfd->d_type!=DT_LNK) 
391
 
                continue;
392
 
#else
393
 
            /* Skip . and .. */
394
 
            if (!isdigit(direfd->d_name[0]))
395
 
                continue;
396
 
#endif
397
 
            if (procfdlen+1+strlen(direfd->d_name)+1>sizeof(line)) 
 
435
           /* Skip . and .. */
 
436
           if (!isdigit(direfd->d_name[0]))
 
437
               continue;
 
438
            if (procfdlen + 1 + strlen(direfd->d_name) + 1 > sizeof(line))
398
439
                continue;
399
440
            memcpy(line + procfdlen - PATH_FD_SUFFl, PATH_FD_SUFF "/",
400
 
                   PATH_FD_SUFFl+1);
401
 
            strcpy(line + procfdlen + 1, direfd->d_name);
402
 
            lnamelen=readlink(line,lname,sizeof(lname)-1);
 
441
                   PATH_FD_SUFFl + 1);
 
442
        safe_strncpy(line + procfdlen + 1, direfd->d_name,
 
443
                        sizeof(line) - procfdlen - 1);
 
444
            lnamelen = readlink(line, lname, sizeof(lname) - 1);
 
445
            if (lnamelen == -1)
 
446
                    continue;
403
447
            lname[lnamelen] = '\0';  /*make it a null-terminated string*/
404
448
 
405
449
            if (extract_type_1_socket_inode(lname, &inode) < 0)
407
451
                continue;
408
452
 
409
453
            if (!cmdlp) {
410
 
                if (procfdlen - PATH_FD_SUFFl + PATH_CMDLINEl >= 
411
 
                    sizeof(line) - 5) 
 
454
                if (procfdlen - PATH_FD_SUFFl + PATH_CMDLINEl >=
 
455
                    sizeof(line) - 5)
412
456
                    continue;
413
 
                strcpy(line + procfdlen-PATH_FD_SUFFl, PATH_CMDLINE);
 
457
        safe_strncpy(line + procfdlen - PATH_FD_SUFFl, PATH_CMDLINE,
 
458
                        sizeof(line) - procfdlen + PATH_FD_SUFFl);
414
459
                fd = open(line, O_RDONLY);
415
 
                if (fd < 0) 
 
460
                if (fd < 0)
416
461
                    continue;
417
462
                cmdllen = read(fd, cmdlbuf, sizeof(cmdlbuf) - 1);
418
 
                if (close(fd)) 
419
 
                    continue;
420
 
                if (cmdllen == -1) 
421
 
                    continue;
422
 
                if (cmdllen < sizeof(cmdlbuf) - 1) 
 
463
                if (close(fd))
 
464
                    continue;
 
465
                if (cmdllen == -1)
 
466
                    continue;
 
467
                if (cmdllen < sizeof(cmdlbuf) - 1)
423
468
                    cmdlbuf[cmdllen]='\0';
424
 
                if ((cmdlp = strrchr(cmdlbuf, '/'))) 
 
469
                if (cmdlbuf[0] == '/' && (cmdlp = strrchr(cmdlbuf, '/')))
425
470
                    cmdlp++;
426
 
                else 
 
471
                else
427
472
                    cmdlp = cmdlbuf;
428
473
            }
429
474
 
430
475
            snprintf(finbuf, sizeof(finbuf), "%s/%s", direproc->d_name, cmdlp);
431
 
            prg_cache_add(inode, finbuf);
 
476
#if HAVE_SELINUX
 
477
            if (getpidcon(atoi(direproc->d_name), &scon) == -1) {
 
478
                    scon=xstrdup("-");
 
479
            }
 
480
            prg_cache_add(inode, finbuf, scon);
 
481
            freecon(scon);
 
482
#else
 
483
            prg_cache_add(inode, finbuf, "-");
 
484
#endif
432
485
        }
433
 
        closedir(dirfd); 
 
486
        closedir(dirfd);
434
487
        dirfd = NULL;
435
488
    }
436
 
    if (dirproc) 
 
489
    if (dirproc)
437
490
        closedir(dirproc);
438
 
    if (dirfd) 
 
491
    if (dirfd)
439
492
        closedir(dirfd);
440
 
    if (!eacces) 
 
493
    if (!eacces)
441
494
        return;
442
495
    if (prg_cache_loaded == 1) {
443
496
    fail:
479
532
    }
480
533
    printf(_("Active NET/ROM sockets\n"));
481
534
    printf(_("User       Dest       Source     Device  State        Vr/Vs    Send-Q  Recv-Q\n"));
482
 
    fgets(buffer, 256, f);
 
535
    if (fgets(buffer, 256, f))
 
536
        /* eat line */;
483
537
 
484
538
    while (fgets(buffer, 256, f)) {
485
539
        buffer[9] = 0;
544
598
            printf(" %-10s ", pw->pw_name);
545
599
        else
546
600
            printf(" %-10d ", uid);
547
 
        printf("%-10lu ",inode);
 
601
        printf("%-10lu",inode);
548
602
    }
549
603
    if (flag_prg)
550
 
        printf(" %-16s",prg_cache_get(inode));
 
604
        printf(" %-" PROGNAME_WIDTHs "s",prg_cache_get(inode));
 
605
    if (flag_selinux)
 
606
        printf(" %-" SELINUX_WIDTHs "s",prg_cache_get_con(inode));
 
607
 
551
608
    if (flag_opt)
552
609
        printf(" %s", timers);
553
610
    putchar('\n');
554
611
}
555
612
 
556
 
static void igmp_do_one(int lnr, const char *line)
 
613
static void igmp_do_one(int lnr, const char *line,const char *prot)
557
614
{
558
615
    char mcast_addr[128];
559
616
#if HAVE_AFINET6
564
621
#else
565
622
    struct sockaddr_in mcastaddr;
566
623
#endif
567
 
    struct aftype *ap;
 
624
    const struct aftype *ap;
568
625
    static int idx_flag = 0;
569
626
    static int igmp6_flag = 0;
570
627
    static char device[16];
612
669
                    ((struct sockaddr *) &mcastaddr)->sa_family);
613
670
            return;
614
671
        }
615
 
        safe_strncpy(mcast_addr, ap->sprint((struct sockaddr *) &mcastaddr, 
616
 
                                      flag_not), sizeof(mcast_addr));
 
672
        safe_strncpy(mcast_addr, ap->sprint((struct sockaddr *) &mcastaddr,
 
673
                                      flag_not & FLAG_NUM_HOST), sizeof(mcast_addr));
617
674
        printf("%-15s %-6d %s\n", device, refcnt, mcast_addr);
618
675
#endif
619
676
    } else {    /* IPV4 */
644
701
            fprintf(stderr, _("warning, got bogus igmp line %d.\n"), lnr);
645
702
            return;
646
703
        }
647
 
        
 
704
 
648
705
        if ((ap = get_afntype(((struct sockaddr *) &mcastaddr)->sa_family)) == NULL) {
649
706
            fprintf(stderr, _("netstat: unsupported address family %d !\n"),
650
707
                    ((struct sockaddr *) &mcastaddr)->sa_family);
651
708
            return;
652
709
        }
653
 
        safe_strncpy(mcast_addr, ap->sprint((struct sockaddr *) &mcastaddr, 
654
 
                                      flag_not), sizeof(mcast_addr));
 
710
        safe_strncpy(mcast_addr, ap->sprint((struct sockaddr *) &mcastaddr,
 
711
                                      flag_not & FLAG_NUM_HOST), sizeof(mcast_addr));
655
712
        printf("%-15s %-6d %s\n", device, refcnt, mcast_addr );
656
713
#endif
657
714
    }    /* IPV4 */
671
728
               "ESTABLISHED",
672
729
               "RECOVERY"
673
730
       };
674
 
       if(!(f=proc_fopen(_PATH_PROCNET_X25)))
 
731
       if(!f)
675
732
       {
676
733
               if (errno != ENOENT) {
677
734
                       perror(_PATH_PROCNET_X25);
687
744
       printf( _("Active X.25 sockets\n"));
688
745
       /* IMHO, Vr/Vs is not very usefull --SF */
689
746
       printf( _("Dest         Source          Device  LCI  State        Vr/Vs  Send-Q  Recv-Q\n"));
690
 
       fgets(buffer,256,f);
 
747
       if (fgets(buffer,256,f))
 
748
               /* eat line */;
691
749
       while(fgets(buffer,256,f))
692
750
       {
693
751
               buffer[10]=0;
704
762
                       vr,vs,sendq,recvq);
705
763
       }
706
764
       fclose(f);
707
 
       return 0;               
 
765
       return 0;
708
766
}
709
767
#endif
710
768
 
711
769
static int igmp_info(void)
712
770
{
713
771
    INFO_GUTS6(_PATH_PROCNET_IGMP, _PATH_PROCNET_IGMP6, "AF INET (igmp)",
714
 
               igmp_do_one);
715
 
}
716
 
 
717
 
static void tcp_do_one(int lnr, const char *line)
 
772
               igmp_do_one, "igmp", "igmp6");
 
773
}
 
774
 
 
775
static const char *sctp_socket_state_str(int state)
 
776
{
 
777
    if (state >= 0 && state < ARRAY_SIZE(tcp_state))
 
778
        return tcp_state[state];
 
779
    else {
 
780
        static char state_str_buf[64];
 
781
        sprintf(state_str_buf, "UNKNOWN(%d)", state);
 
782
        return state_str_buf;
 
783
    }
 
784
}
 
785
 
 
786
static const struct aftype *process_sctp_addr_str(const char *addr_str, struct sockaddr *sa)
 
787
{
 
788
    if (strchr(addr_str,':')) {
 
789
#if HAVE_AFINET6
 
790
        extern struct aftype inet6_aftype;
 
791
        /* Demangle what the kernel gives us */
 
792
        struct in6_addr in6;
 
793
        char addr6_str[INET6_ADDRSTRLEN];
 
794
        unsigned u0, u1, u2, u3, u4, u5, u6, u7;
 
795
        sscanf(addr_str, "%04X:%04X:%04X:%04X:%04X:%04X:%04X:%04X",
 
796
               &u0, &u1, &u2, &u3, &u4, &u5, &u6, &u7);
 
797
        in6.s6_addr16[0] = htons(u0);
 
798
        in6.s6_addr16[1] = htons(u1);
 
799
        in6.s6_addr16[2] = htons(u2);
 
800
        in6.s6_addr16[3] = htons(u3);
 
801
        in6.s6_addr16[4] = htons(u4);
 
802
        in6.s6_addr16[5] = htons(u5);
 
803
        in6.s6_addr16[6] = htons(u6);
 
804
        in6.s6_addr16[7] = htons(u7);
 
805
 
 
806
        inet_ntop(AF_INET6, &in6, addr6_str, sizeof(addr6_str));
 
807
        inet6_aftype.input(1, addr6_str, sa);
 
808
        sa->sa_family = AF_INET6;
 
809
#endif
 
810
    } else {
 
811
        struct sockaddr_in *sin = (struct sockaddr_in *)sa;
 
812
        sin->sin_addr.s_addr = inet_addr(addr_str);
 
813
        sa->sa_family = AF_INET;
 
814
    }
 
815
    return get_afntype(sa->sa_family);
 
816
}
 
817
 
 
818
static void sctp_eps_do_one(int lnr, char *line, const char *proto)
 
819
{
 
820
    char buffer[1024];
 
821
    int state, port;
 
822
    int uid;
 
823
    unsigned long inode;
 
824
    const struct aftype *ap;
 
825
    struct sockaddr_storage localsas;
 
826
    struct sockaddr *localsa = (struct sockaddr *)&localsas;
 
827
    const char *sst_str;
 
828
    const char *lport_str;
 
829
    const char *uid_str;
 
830
    const char *inode_str;
 
831
    char *laddrs_str;
 
832
 
 
833
    if (lnr == 0) {
 
834
        /* ENDPT     SOCK   STY SST HBKT LPORT   UID INODE LADDRS */
 
835
        return;
 
836
    }
 
837
    strtok(line, " \t\n");      /* skip endpt */
 
838
    strtok(0, " \t\n");         /* skip sock */
 
839
    strtok(0, " \t\n");         /* skip sty */
 
840
    sst_str = strtok(0, " \t\n");
 
841
    strtok(0, " \t\n");         /* skip hash bucket */
 
842
    lport_str = strtok(0, " \t\n");
 
843
    uid_str = strtok(0, " \t\n");
 
844
    inode_str = strtok(0, " \t\n");
 
845
    laddrs_str = strtok(0, "\t\n");
 
846
 
 
847
    if (!sst_str || !lport_str || !uid_str || !inode_str) {
 
848
        fprintf(stderr, _("warning, got bogus sctp eps line.\n"));
 
849
        return;
 
850
    }
 
851
    state = atoi(sst_str);
 
852
    port = atoi(lport_str);
 
853
    uid = atoi(uid_str);
 
854
    inode = strtoul(inode_str,0,0);
 
855
 
 
856
    const char *this_local_addr;
 
857
    int first = 1;
 
858
    char local_port[16];
 
859
    snprintf(local_port, sizeof(local_port), "%s",
 
860
        get_sname(htons(port), proto, flag_not & FLAG_NUM_PORT));
 
861
    for (this_local_addr = strtok(laddrs_str, " \t\n");
 
862
         this_local_addr;
 
863
         this_local_addr = strtok(0, " \t\n")) {
 
864
        char local_addr[64];
 
865
        ap = process_sctp_addr_str(this_local_addr, localsa);
 
866
        if (ap)
 
867
            safe_strncpy(local_addr, ap->sprint(localsa, flag_not), sizeof(local_addr));
 
868
        else
 
869
            sprintf(local_addr, _("unsupported address family %d"), localsa->sa_family);
 
870
 
 
871
        if (first)
 
872
            printf("sctp                ");
 
873
        else
 
874
            printf("\n                    ");
 
875
        sprintf(buffer, "%s:%s", local_addr, local_port);
 
876
        printf("%-47s", buffer);
 
877
        printf(" %-11s", first ? sctp_socket_state_str(state) : "");
 
878
        first = 0;
 
879
    }
 
880
    finish_this_one(uid, inode, "");
 
881
}
 
882
 
 
883
static void sctp_assoc_do_one(int lnr, char *line, const char *proto)
 
884
{
 
885
    char buffer[1024];
 
886
    int state, lport,rport;
 
887
    int uid;
 
888
    unsigned rxqueue,txqueue;
 
889
    unsigned long inode;
 
890
 
 
891
    const struct aftype *ap;
 
892
    struct sockaddr_storage localsas, remotesas;
 
893
    struct sockaddr *localsa = (struct sockaddr *)&localsas;
 
894
    struct sockaddr *remotesa = (struct sockaddr *)&remotesas;
 
895
    const char *sst_str;
 
896
    const char *txqueue_str;
 
897
    const char *rxqueue_str;
 
898
    const char *lport_str, *rport_str;
 
899
    const char *uid_str;
 
900
    const char *inode_str;
 
901
    char *laddrs_str;
 
902
    char *raddrs_str;
 
903
 
 
904
    if (lnr == 0) {
 
905
        /* ASSOC     SOCK   STY SST ST HBKT ASSOC-ID TX_QUEUE RX_QUEUE UID INODE LPORT RPORT LADDRS <-> RADDRS */
 
906
        return;
 
907
    }
 
908
 
 
909
    strtok(line, " \t\n");      /* skip assoc */
 
910
    strtok(0, " \t\n");         /* skip sock */
 
911
    strtok(0, " \t\n");         /* skip sty */
 
912
    sst_str = strtok(0, " \t\n");
 
913
    strtok(0, " \t\n");
 
914
    strtok(0, " \t\n");         /* skip hash bucket */
 
915
    strtok(0, " \t\n");         /* skip hash assoc-id */
 
916
    txqueue_str =  strtok(0, " \t\n");
 
917
    rxqueue_str =  strtok(0, " \t\n");
 
918
    uid_str = strtok(0, " \t\n");
 
919
    inode_str = strtok(0, " \t\n");
 
920
    lport_str = strtok(0, " \t\n");
 
921
    rport_str = strtok(0, " \t\n");
 
922
    laddrs_str = strtok(0, "<->\t\n");
 
923
    raddrs_str = strtok(0, "<->\t\n");
 
924
 
 
925
    if (!sst_str || !txqueue_str || !rxqueue_str || !uid_str ||
 
926
        !inode_str || !lport_str || !rport_str) {
 
927
        fprintf(stderr, _("warning, got bogus sctp assoc line.\n"));
 
928
        return;
 
929
    }
 
930
 
 
931
    state = atoi(sst_str);
 
932
    txqueue = atoi(txqueue_str);
 
933
    rxqueue = atoi(rxqueue_str);
 
934
    uid = atoi(uid_str);
 
935
    inode = strtoul(inode_str, 0, 0);
 
936
    lport = atoi(lport_str);
 
937
    rport = atoi(rport_str);
 
938
 
 
939
    /*print all addresses*/
 
940
    const char *this_local_addr;
 
941
    const char *this_remote_addr;
 
942
    char *ss1, *ss2;
 
943
    int first = 1;
 
944
    char local_port[16];
 
945
    char remote_port[16];
 
946
    snprintf(local_port, sizeof(local_port), "%s",
 
947
             get_sname(htons(lport), proto,
 
948
             flag_not & FLAG_NUM_PORT));
 
949
    snprintf(remote_port, sizeof(remote_port), "%s",
 
950
             get_sname(htons(rport), proto,
 
951
             flag_not & FLAG_NUM_PORT));
 
952
 
 
953
    this_local_addr = strtok_r(laddrs_str, " \t\n", &ss1);
 
954
    this_remote_addr = strtok_r(raddrs_str, " \t\n", &ss2);
 
955
    while (this_local_addr || this_remote_addr) {
 
956
        char local_addr[64];
 
957
        char remote_addr[64];
 
958
 
 
959
        if (this_local_addr) {
 
960
            if (this_local_addr[0] == '*') {
 
961
                /* skip * */
 
962
                this_local_addr++;
 
963
            }
 
964
            ap = process_sctp_addr_str(this_local_addr, localsa);
 
965
            if (ap)
 
966
                safe_strncpy(local_addr,
 
967
                             ap->sprint(localsa, flag_not), sizeof(local_addr));
 
968
            else
 
969
                sprintf(local_addr, _("unsupported address family %d"), localsa->sa_family);
 
970
        }
 
971
        if (this_remote_addr) {
 
972
            if (this_remote_addr[0] == '*') {
 
973
                /* skip * */
 
974
                this_remote_addr++;
 
975
            }
 
976
            ap = process_sctp_addr_str(this_remote_addr, remotesa);
 
977
            if (ap)
 
978
                safe_strncpy(remote_addr,
 
979
                             ap->sprint(remotesa, flag_not), sizeof(remote_addr));
 
980
            else
 
981
                sprintf(remote_addr, _("unsupported address family %d"), remotesa->sa_family);
 
982
        }
 
983
 
 
984
        if (first)
 
985
            printf("sctp  %6u %6u ", rxqueue, txqueue);
 
986
        else
 
987
            printf("\n                    ");
 
988
        if (this_local_addr) {
 
989
            if (first)
 
990
                sprintf(buffer, "%s:%s", local_addr, local_port);
 
991
            else
 
992
                sprintf(buffer, "%s", local_addr);
 
993
            printf("%-23s", buffer);
 
994
        } else
 
995
            printf("%-23s", "");
 
996
        printf(" ");
 
997
        if (this_remote_addr) {
 
998
            if (first)
 
999
                sprintf(buffer, "%s:%s", remote_addr, remote_port);
 
1000
            else
 
1001
                sprintf(buffer, "%s", remote_addr);
 
1002
            printf("%-23s", buffer);
 
1003
        } else
 
1004
            printf("%-23s", "");
 
1005
 
 
1006
       printf(" %-11s", first ? sctp_socket_state_str(state) : "");
 
1007
 
 
1008
       first = 0;
 
1009
       this_local_addr = strtok_r(0, " \t\n", &ss1);
 
1010
       this_remote_addr = strtok_r(0, " \t\n", &ss2);
 
1011
    }
 
1012
    finish_this_one(uid, inode, "");
 
1013
}
 
1014
 
 
1015
static int sctp_info_eps(void)
 
1016
{
 
1017
    INFO_GUTS6(_PATH_PROCNET_SCTPEPTS, _PATH_PROCNET_SCTP6EPTS, "AF INET (sctp)",
 
1018
               sctp_eps_do_one, "sctp", "sctp6");
 
1019
}
 
1020
 
 
1021
static int sctp_info_assocs(void)
 
1022
{
 
1023
    INFO_GUTS6(_PATH_PROCNET_SCTPASSOCS, _PATH_PROCNET_SCTP6ASSOCS, "AF INET (sctp)",
 
1024
               sctp_assoc_do_one, "sctp", "sctp6");
 
1025
}
 
1026
 
 
1027
static int sctp_info(void)
 
1028
{
 
1029
  int res = sctp_info_eps();
 
1030
  return res ? res : sctp_info_assocs();
 
1031
}
 
1032
 
 
1033
static void addr_do_one(char *buf, size_t buf_len, size_t short_len, const struct aftype *ap,
 
1034
#if HAVE_AFINET6
 
1035
                        struct sockaddr_in6 *addr,
 
1036
#else
 
1037
                        struct sockaddr_in *addr,
 
1038
#endif
 
1039
                        int port, const char *proto
 
1040
)
 
1041
{
 
1042
    const char *sport, *saddr;
 
1043
    size_t port_len, addr_len;
 
1044
 
 
1045
    saddr = ap->sprint((struct sockaddr *)addr, flag_not & FLAG_NUM_HOST);
 
1046
    sport = get_sname(htons(port), proto, flag_not & FLAG_NUM_PORT);
 
1047
    addr_len = strlen(saddr);
 
1048
    port_len = strlen(sport);
 
1049
    if (!flag_wide && (addr_len + port_len > short_len)) {
 
1050
        /* Assume port name is short */
 
1051
        port_len = netmin(port_len, short_len - 4);
 
1052
        addr_len = short_len - port_len;
 
1053
        strncpy(buf, saddr, addr_len);
 
1054
        buf[addr_len] = '\0';
 
1055
        strcat(buf, ":");
 
1056
        strncat(buf, sport, port_len);
 
1057
    } else
 
1058
        snprintf(buf, buf_len, "%s:%s", saddr, sport);
 
1059
}
 
1060
 
 
1061
static void tcp_do_one(int lnr, const char *line, const char *prot)
718
1062
{
719
1063
    unsigned long rxq, txq, time_len, retr, inode;
720
1064
    int num, local_port, rem_port, d, state, uid, timer_run, timeout;
721
 
    char rem_addr[128], local_addr[128], timers[64], buffer[1024], more[512];
722
 
    char *protname;
723
 
    struct aftype *ap;
 
1065
    char rem_addr[128], local_addr[128], timers[64];
 
1066
    const struct aftype *ap;
724
1067
#if HAVE_AFINET6
725
1068
    struct sockaddr_in6 localaddr, remaddr;
726
1069
    char addr6[INET6_ADDRSTRLEN];
729
1072
#else
730
1073
    struct sockaddr_in localaddr, remaddr;
731
1074
#endif
 
1075
    long clk_tck = ticks_per_second();
732
1076
 
733
1077
    if (lnr == 0)
734
1078
        return;
735
1079
 
736
1080
    num = sscanf(line,
737
 
    "%d: %64[0-9A-Fa-f]:%X %64[0-9A-Fa-f]:%X %X %lX:%lX %X:%lX %lX %d %d %lu %512s\n",
 
1081
    "%d: %64[0-9A-Fa-f]:%X %64[0-9A-Fa-f]:%X %X %lX:%lX %X:%lX %lX %d %d %lu %*s\n",
738
1082
                 &d, local_addr, &local_port, rem_addr, &rem_port, &state,
739
 
                 &txq, &rxq, &timer_run, &time_len, &retr, &uid, &timeout, &inode, more);
740
 
 
741
 
    if (strlen(local_addr) > 8) {
742
 
#if HAVE_AFINET6
743
 
        protname = "tcp6";
744
 
        /* Demangle what the kernel gives us */
745
 
        sscanf(local_addr, "%08X%08X%08X%08X",
746
 
               &in6.s6_addr32[0], &in6.s6_addr32[1],
747
 
           &in6.s6_addr32[2], &in6.s6_addr32[3]);
748
 
        inet_ntop(AF_INET6, &in6, addr6, sizeof(addr6));
749
 
        inet6_aftype.input(1, addr6, (struct sockaddr *) &localaddr);
750
 
        sscanf(rem_addr, "%08X%08X%08X%08X",
751
 
               &in6.s6_addr32[0], &in6.s6_addr32[1],
752
 
               &in6.s6_addr32[2], &in6.s6_addr32[3]);
753
 
        inet_ntop(AF_INET6, &in6, addr6, sizeof(addr6));
754
 
        inet6_aftype.input(1, addr6, (struct sockaddr *) &remaddr);
755
 
        localaddr.sin6_family = AF_INET6;
756
 
        remaddr.sin6_family = AF_INET6;
757
 
#endif
758
 
    } else {
759
 
        protname = "tcp";
760
 
        sscanf(local_addr, "%X",
761
 
               &((struct sockaddr_in *) &localaddr)->sin_addr.s_addr);
762
 
        sscanf(rem_addr, "%X",
763
 
               &((struct sockaddr_in *) &remaddr)->sin_addr.s_addr);
764
 
        ((struct sockaddr *) &localaddr)->sa_family = AF_INET;
765
 
        ((struct sockaddr *) &remaddr)->sa_family = AF_INET;
766
 
    }
 
1083
                 &txq, &rxq, &timer_run, &time_len, &retr, &uid, &timeout, &inode);
767
1084
 
768
1085
    if (num < 11) {
769
1086
        fprintf(stderr, _("warning, got bogus tcp line.\n"));
770
1087
        return;
771
1088
    }
 
1089
 
 
1090
    if (!flag_all && ((flag_lst && rem_port) || (!flag_lst && !rem_port)))
 
1091
      return;
 
1092
 
 
1093
    if (strlen(local_addr) > 8) {
 
1094
#if HAVE_AFINET6
 
1095
        /* Demangle what the kernel gives us */
 
1096
        sscanf(local_addr, "%08X%08X%08X%08X",
 
1097
               &in6.s6_addr32[0], &in6.s6_addr32[1],
 
1098
           &in6.s6_addr32[2], &in6.s6_addr32[3]);
 
1099
        inet_ntop(AF_INET6, &in6, addr6, sizeof(addr6));
 
1100
        inet6_aftype.input(1, addr6, (struct sockaddr *) &localaddr);
 
1101
        sscanf(rem_addr, "%08X%08X%08X%08X",
 
1102
               &in6.s6_addr32[0], &in6.s6_addr32[1],
 
1103
               &in6.s6_addr32[2], &in6.s6_addr32[3]);
 
1104
        inet_ntop(AF_INET6, &in6, addr6, sizeof(addr6));
 
1105
        inet6_aftype.input(1, addr6, (struct sockaddr *) &remaddr);
 
1106
        localaddr.sin6_family = AF_INET6;
 
1107
        remaddr.sin6_family = AF_INET6;
 
1108
#endif
 
1109
    } else {
 
1110
        sscanf(local_addr, "%X",
 
1111
               &((struct sockaddr_in *) &localaddr)->sin_addr.s_addr);
 
1112
        sscanf(rem_addr, "%X",
 
1113
               &((struct sockaddr_in *) &remaddr)->sin_addr.s_addr);
 
1114
        ((struct sockaddr *) &localaddr)->sa_family = AF_INET;
 
1115
        ((struct sockaddr *) &remaddr)->sa_family = AF_INET;
 
1116
    }
 
1117
 
772
1118
    if ((ap = get_afntype(((struct sockaddr *) &localaddr)->sa_family)) == NULL) {
773
1119
        fprintf(stderr, _("netstat: unsupported address family %d !\n"),
774
1120
                ((struct sockaddr *) &localaddr)->sa_family);
775
1121
        return;
776
1122
    }
777
 
    if (state == TCP_LISTEN) {
778
 
        time_len = 0;
779
 
        retr = 0L;
780
 
        rxq = 0L;
781
 
        txq = 0L;
782
 
    }
783
 
    safe_strncpy(local_addr, ap->sprint((struct sockaddr *) &localaddr, 
784
 
                                        flag_not), sizeof(local_addr));
785
 
    safe_strncpy(rem_addr, ap->sprint((struct sockaddr *) &remaddr, flag_not),
786
 
                 sizeof(rem_addr));
787
 
    if (flag_all || (flag_lst && !rem_port) || (!flag_lst && rem_port)) {
788
 
        snprintf(buffer, sizeof(buffer), "%s",
789
 
                 get_sname(htons(local_port), "tcp",
790
 
                           flag_not & FLAG_NUM_PORT));
791
 
 
792
 
        if (!flag_wide) {
793
 
            if ((strlen(local_addr) + strlen(buffer)) > 22)
794
 
                local_addr[22 - strlen(buffer)] = '\0';
795
 
        }
796
 
 
797
 
        strcat(local_addr, ":");
798
 
        strcat(local_addr, buffer);
799
 
        snprintf(buffer, sizeof(buffer), "%s",
800
 
                 get_sname(htons(rem_port), "tcp", flag_not & FLAG_NUM_PORT));
801
 
 
802
 
        if (!flag_wide) {
803
 
            if ((strlen(rem_addr) + strlen(buffer)) > 22)
804
 
                rem_addr[22 - strlen(buffer)] = '\0';
805
 
        }
806
 
 
807
 
        strcat(rem_addr, ":");
808
 
        strcat(rem_addr, buffer);
 
1123
 
 
1124
        addr_do_one(local_addr, sizeof(local_addr), 22, ap, &localaddr, local_port, "tcp");
 
1125
        addr_do_one(rem_addr, sizeof(rem_addr), 22, ap, &remaddr, rem_port, "tcp");
 
1126
 
809
1127
        timers[0] = '\0';
810
 
 
811
1128
        if (flag_opt)
812
1129
            switch (timer_run) {
813
1130
            case 0:
816
1133
 
817
1134
            case 1:
818
1135
                snprintf(timers, sizeof(timers), _("on (%2.2f/%ld/%d)"),
819
 
                         (double) time_len / HZ, retr, timeout);
 
1136
                         (double) time_len / clk_tck, retr, timeout);
820
1137
                break;
821
1138
 
822
1139
            case 2:
823
1140
                snprintf(timers, sizeof(timers), _("keepalive (%2.2f/%ld/%d)"),
824
 
                         (double) time_len / HZ, retr, timeout);
 
1141
                         (double) time_len / clk_tck, retr, timeout);
825
1142
                break;
826
1143
 
827
1144
            case 3:
828
1145
                snprintf(timers, sizeof(timers), _("timewait (%2.2f/%ld/%d)"),
829
 
                         (double) time_len / HZ, retr, timeout);
 
1146
                         (double) time_len / clk_tck, retr, timeout);
 
1147
                break;
 
1148
 
 
1149
            case 4:
 
1150
                snprintf(timers, sizeof(timers), _("probe (%2.2f/%ld/%d)"),
 
1151
                         (double) time_len / clk_tck, retr, timeout);
830
1152
                break;
831
1153
 
832
1154
            default:
833
1155
                snprintf(timers, sizeof(timers), _("unkn-%d (%2.2f/%ld/%d)"),
834
 
                         timer_run, (double) time_len / HZ, retr, timeout);
 
1156
                         timer_run, (double) time_len / clk_tck, retr, timeout);
835
1157
                break;
836
1158
            }
 
1159
 
837
1160
        printf("%-4s  %6ld %6ld %-*s %-*s %-11s",
838
 
               protname, rxq, txq, netmax(23,strlen(local_addr)), local_addr, netmax(23,strlen(rem_addr)), rem_addr, _(tcp_state[state]));
 
1161
               prot, rxq, txq, (int)netmax(23,strlen(local_addr)), local_addr, (int)netmax(23,strlen(rem_addr)), rem_addr, _(tcp_state[state]));
839
1162
 
840
1163
        finish_this_one(uid,inode,timers);
841
 
    }
842
1164
}
843
1165
 
844
1166
static int tcp_info(void)
845
1167
{
846
1168
    INFO_GUTS6(_PATH_PROCNET_TCP, _PATH_PROCNET_TCP6, "AF INET (tcp)",
847
 
               tcp_do_one);
 
1169
               tcp_do_one, "tcp", "tcp6");
848
1170
}
849
1171
 
850
 
static void udp_do_one(int lnr, const char *line)
 
1172
static void udp_do_one(int lnr, const char *line,const char *prot)
851
1173
{
852
 
    char buffer[8192], local_addr[64], rem_addr[64];
853
 
    char *udp_state, timers[64], more[512];
 
1174
    char local_addr[64], rem_addr[64];
 
1175
    char *udp_state, timers[64];
854
1176
    int num, local_port, rem_port, d, state, timer_run, uid, timeout;
855
 
    char *protname;
856
1177
#if HAVE_AFINET6
857
1178
    struct sockaddr_in6 localaddr, remaddr;
858
1179
    char addr6[INET6_ADDRSTRLEN];
861
1182
#else
862
1183
    struct sockaddr_in localaddr, remaddr;
863
1184
#endif
864
 
    struct aftype *ap;
 
1185
    const struct aftype *ap;
865
1186
    unsigned long rxq, txq, time_len, retr, inode;
866
1187
 
867
1188
    if (lnr == 0)
868
1189
        return;
869
1190
 
870
 
    more[0] = '\0';
871
1191
    num = sscanf(line,
872
 
                 "%d: %64[0-9A-Fa-f]:%X %64[0-9A-Fa-f]:%X %X %lX:%lX %X:%lX %lX %d %d %lu %512s\n",
 
1192
                 "%d: %64[0-9A-Fa-f]:%X %64[0-9A-Fa-f]:%X %X %lX:%lX %X:%lX %lX %d %d %lu %*s\n",
873
1193
                 &d, local_addr, &local_port,
874
1194
                 rem_addr, &rem_port, &state,
875
 
          &txq, &rxq, &timer_run, &time_len, &retr, &uid, &timeout, &inode, more);
 
1195
          &txq, &rxq, &timer_run, &time_len, &retr, &uid, &timeout, &inode);
 
1196
 
 
1197
    if (num < 10) {
 
1198
        fprintf(stderr, _("warning, got bogus udp line.\n"));
 
1199
        return;
 
1200
    }
876
1201
 
877
1202
    if (strlen(local_addr) > 8) {
878
1203
#if HAVE_AFINET6
879
 
        protname="udp6";
880
1204
        sscanf(local_addr, "%08X%08X%08X%08X",
881
1205
               &in6.s6_addr32[0], &in6.s6_addr32[1],
882
1206
               &in6.s6_addr32[2], &in6.s6_addr32[3]);
891
1215
        remaddr.sin6_family = AF_INET6;
892
1216
#endif
893
1217
    } else {
894
 
        protname="udp";
895
1218
        sscanf(local_addr, "%X",
896
1219
               &((struct sockaddr_in *) &localaddr)->sin_addr.s_addr);
897
1220
        sscanf(rem_addr, "%X",
901
1224
    }
902
1225
 
903
1226
    retr = 0L;
904
 
    if (!flag_opt)
905
 
        more[0] = '\0';
906
1227
 
907
 
    if (num < 10) {
908
 
        fprintf(stderr, _("warning, got bogus udp line.\n"));
909
 
        return;
910
 
    }
911
1228
    if ((ap = get_afntype(((struct sockaddr *) &localaddr)->sa_family)) == NULL) {
912
1229
        fprintf(stderr, _("netstat: unsupported address family %d !\n"),
913
1230
                ((struct sockaddr *) &localaddr)->sa_family);
941
1258
 
942
1259
    if (flag_all || (notnull(remaddr) && !flag_lst) || (!notnull(remaddr) && flag_lst))
943
1260
    {
944
 
        safe_strncpy(local_addr, ap->sprint((struct sockaddr *) &localaddr, 
945
 
                                            flag_not), sizeof(local_addr));
946
 
        snprintf(buffer, sizeof(buffer), "%s",
947
 
                 get_sname(htons(local_port), "udp",
948
 
                           flag_not & FLAG_NUM_PORT));
949
 
        if (!flag_wide) {
950
 
            if ((strlen(local_addr) + strlen(buffer)) > 22)
951
 
                local_addr[22 - strlen(buffer)] = '\0';
952
 
        }
953
 
        strcat(local_addr, ":");
954
 
        strcat(local_addr, buffer);
955
 
 
956
 
        snprintf(buffer, sizeof(buffer), "%s",
957
 
                 get_sname(htons(rem_port), "udp", flag_not & FLAG_NUM_PORT));
958
 
        safe_strncpy(rem_addr, ap->sprint((struct sockaddr *) &remaddr, 
959
 
                                          flag_not), sizeof(rem_addr));
960
 
        if (!flag_wide) {
961
 
            if ((strlen(rem_addr) + strlen(buffer)) > 22)
962
 
                rem_addr[22 - strlen(buffer)] = '\0';
963
 
        }
964
 
        strcat(rem_addr, ":");
965
 
        strcat(rem_addr, buffer);
 
1261
        addr_do_one(local_addr, sizeof(local_addr), 22, ap, &localaddr, local_port, "udp");
 
1262
        addr_do_one(rem_addr, sizeof(rem_addr), 22, ap, &remaddr, rem_port, "udp");
966
1263
 
967
1264
        timers[0] = '\0';
968
1265
        if (flag_opt)
981
1278
                         retr, timeout);
982
1279
                break;
983
1280
            }
984
 
        printf("%-4s  %6ld %6ld %-23s %-23s %-11s",
985
 
               protname, rxq, txq, local_addr, rem_addr, udp_state);
 
1281
        printf("%-5s %6ld %6ld %-23s %-23s %-11s",
 
1282
               prot, rxq, txq, local_addr, rem_addr, udp_state);
986
1283
 
987
1284
        finish_this_one(uid,inode,timers);
988
1285
    }
991
1288
static int udp_info(void)
992
1289
{
993
1290
    INFO_GUTS6(_PATH_PROCNET_UDP, _PATH_PROCNET_UDP6, "AF INET (udp)",
994
 
               udp_do_one);
995
 
}
996
 
 
997
 
static void raw_do_one(int lnr, const char *line)
998
 
{
999
 
    char buffer[8192], local_addr[64], rem_addr[64];
1000
 
    char timers[64], more[512];
 
1291
               udp_do_one, "udp", "udp6");
 
1292
}
 
1293
 
 
1294
static int udplite_info(void)
 
1295
{
 
1296
    INFO_GUTS6(_PATH_PROCNET_UDPLITE, _PATH_PROCNET_UDPLITE6,
 
1297
               "AF INET (udplite)", udp_do_one, "udpl", "udpl6" );
 
1298
}
 
1299
 
 
1300
static void raw_do_one(int lnr, const char *line,const char *prot)
 
1301
{
 
1302
    char local_addr[64], rem_addr[64];
 
1303
    char timers[64];
1001
1304
    int num, local_port, rem_port, d, state, timer_run, uid, timeout;
1002
 
    char *protname;
1003
1305
#if HAVE_AFINET6
1004
1306
    struct sockaddr_in6 localaddr, remaddr;
1005
1307
    char addr6[INET6_ADDRSTRLEN];
1008
1310
#else
1009
1311
    struct sockaddr_in localaddr, remaddr;
1010
1312
#endif
1011
 
    struct aftype *ap;
 
1313
    const struct aftype *ap;
1012
1314
    unsigned long rxq, txq, time_len, retr, inode;
1013
1315
 
1014
1316
    if (lnr == 0)
1015
1317
        return;
1016
1318
 
1017
 
    more[0] = '\0';
1018
1319
    num = sscanf(line,
1019
 
                 "%d: %64[0-9A-Fa-f]:%X %64[0-9A-Fa-f]:%X %X %lX:%lX %X:%lX %lX %d %d %lu %512s\n",
 
1320
                 "%d: %64[0-9A-Fa-f]:%X %64[0-9A-Fa-f]:%X %X %lX:%lX %X:%lX %lX %d %d %lu %*s\n",
1020
1321
                 &d, local_addr, &local_port, rem_addr, &rem_port, &state,
1021
 
          &txq, &rxq, &timer_run, &time_len, &retr, &uid, &timeout, &inode, more);
 
1322
          &txq, &rxq, &timer_run, &time_len, &retr, &uid, &timeout, &inode);
 
1323
 
 
1324
    if (num < 10) {
 
1325
        fprintf(stderr, _("warning, got bogus raw line.\n"));
 
1326
        return;
 
1327
    }
1022
1328
 
1023
1329
    if (strlen(local_addr) > 8) {
1024
1330
#if HAVE_AFINET6
1025
 
        protname = "raw6";
1026
1331
        sscanf(local_addr, "%08X%08X%08X%08X",
1027
1332
               &in6.s6_addr32[0], &in6.s6_addr32[1],
1028
1333
           &in6.s6_addr32[2], &in6.s6_addr32[3]);
1037
1342
        remaddr.sin6_family = AF_INET6;
1038
1343
#endif
1039
1344
    } else {
1040
 
        protname = "raw";
1041
1345
        sscanf(local_addr, "%X",
1042
1346
               &((struct sockaddr_in *) &localaddr)->sin_addr.s_addr);
1043
1347
        sscanf(rem_addr, "%X",
1057
1361
    }
1058
1362
#endif
1059
1363
 
1060
 
    if (!flag_opt)
1061
 
        more[0] = '\0';
1062
 
 
1063
 
    if (num < 10) {
1064
 
        fprintf(stderr, _("warning, got bogus raw line.\n"));
1065
 
        return;
1066
 
    }
1067
 
 
1068
1364
    if (flag_all || (notnull(remaddr) && !flag_lst) || (!notnull(remaddr) && flag_lst))
1069
1365
    {
1070
 
        snprintf(buffer, sizeof(buffer), "%s",
1071
 
                 get_sname(htons(local_port), "raw",
1072
 
                           flag_not & FLAG_NUM_PORT));
1073
 
        safe_strncpy(local_addr, ap->sprint((struct sockaddr *) &localaddr, 
1074
 
                                            flag_not), sizeof(local_addr));
1075
 
        if (!flag_wide) {
1076
 
            if ((strlen(local_addr) + strlen(buffer)) > 22)
1077
 
                local_addr[22 - strlen(buffer)] = '\0';
1078
 
        }
1079
 
        strcat(local_addr, ":");
1080
 
        strcat(local_addr, buffer);
1081
 
 
1082
 
        snprintf(buffer, sizeof(buffer), "%s",
1083
 
                 get_sname(htons(rem_port), "raw", flag_not & FLAG_NUM_PORT));
1084
 
        safe_strncpy(rem_addr, ap->sprint((struct sockaddr *) &remaddr, 
1085
 
                                          flag_not), sizeof(rem_addr));
1086
 
        if (!flag_wide) {
1087
 
            if ((strlen(rem_addr) + strlen(buffer)) > 22)
1088
 
                rem_addr[22 - strlen(buffer)] = '\0';
1089
 
        }
1090
 
        strcat(rem_addr, ":");
1091
 
        strcat(rem_addr, buffer);
 
1366
        addr_do_one(local_addr, sizeof(local_addr), 22, ap, &localaddr, local_port, "raw");
 
1367
        addr_do_one(rem_addr, sizeof(rem_addr), 22, ap, &remaddr, rem_port, "raw");
1092
1368
 
1093
1369
        timers[0] = '\0';
1094
1370
        if (flag_opt)
1110
1386
                break;
1111
1387
            }
1112
1388
        printf("%-4s  %6ld %6ld %-23s %-23s %-11d",
1113
 
               protname, rxq, txq, local_addr, rem_addr, state);
 
1389
               prot, rxq, txq, local_addr, rem_addr, state);
1114
1390
 
1115
1391
        finish_this_one(uid,inode,timers);
1116
1392
    }
1119
1395
static int raw_info(void)
1120
1396
{
1121
1397
    INFO_GUTS6(_PATH_PROCNET_RAW, _PATH_PROCNET_RAW6, "AF INET (raw)",
1122
 
               raw_do_one);
 
1398
               raw_do_one, "raw", "raw6");
1123
1399
}
1124
1400
 
1125
1401
#endif
1129
1405
 
1130
1406
#define HAS_INODE 1
1131
1407
 
1132
 
static void unix_do_one(int nr, const char *line)
 
1408
static void unix_do_one(int nr, const char *line, const char *prot)
1133
1409
{
1134
1410
    static int has = 0;
1135
1411
    char path[MAXPATHLEN], ss_flags[32];
1230
1506
        ss_state = _("UNKNOWN");
1231
1507
    }
1232
1508
 
1233
 
    strcpy(ss_flags, "[ ");
 
1509
    safe_strncpy(ss_flags, "[ ", sizeof(ss_flags));
1234
1510
    if (flags & SO_ACCEPTCON)
1235
1511
        strcat(ss_flags, "ACC ");
1236
1512
    if (flags & SO_WAITDATA)
1243
1519
    printf("%-5s %-6ld %-11s %-10s %-13s ",
1244
1520
           ss_proto, refcnt, ss_flags, ss_type, ss_state);
1245
1521
    if (has & HAS_INODE)
1246
 
        printf("%-8lu ",inode);
 
1522
        printf("%-8lu",inode);
1247
1523
    else
1248
 
        printf("-        ");
 
1524
        printf("-       ");
1249
1525
    if (flag_prg)
1250
 
        printf("%-" PROGNAME_WIDTHs "s",(has & HAS_INODE?prg_cache_get(inode):"-"));
1251
 
    puts(path);
 
1526
        printf(" %-" PROGNAME_WIDTHs "s",(has & HAS_INODE?prg_cache_get(inode):"-"));
 
1527
    if (flag_selinux)
 
1528
        printf(" %-" SELINUX_WIDTHs "s",(has & HAS_INODE?prg_cache_get_con(inode):"-"));
 
1529
 
 
1530
    printf(" %s\n", path);
1252
1531
}
1253
1532
 
1254
1533
static int unix_info(void)
1266
1545
 
1267
1546
    printf(_("\nProto RefCnt Flags       Type       State         I-Node  "));
1268
1547
    print_progname_banner();
 
1548
    print_selinux_banner();
1269
1549
    printf(_(" Path\n"));       /* xxx */
1270
1550
 
1271
1551
    {
1272
 
        INFO_GUTS(_PATH_PROCNET_UNIX, "AF UNIX", unix_do_one);
 
1552
        INFO_GUTS(_PATH_PROCNET_UNIX, "AF UNIX", unix_do_one, "unix");
1273
1553
    }
1274
1554
}
1275
1555
#endif
1380
1660
    unsigned int uid;
1381
1661
    char *st;
1382
1662
    int nc;
1383
 
    struct aftype *ap;
 
1663
    const struct aftype *ap;
1384
1664
    struct passwd *pw;
1385
1665
    char sad[50], dad[50];
1386
1666
    struct sockaddr sa;
1387
1667
    unsigned sport = 0, dport = 0;
1388
1668
    struct stat s;
1389
 
    
 
1669
 
1390
1670
    f = proc_fopen(_PATH_PROCNET_IPX_SOCKET1);
1391
1671
    if (!f) {
1392
1672
        if (errno != ENOENT) {
1397
1677
 
1398
1678
        /* We need to check for directory */
1399
1679
        if (f) {
1400
 
            fstat(fileno(f), &s);
1401
 
            if (!S_ISREG(s.st_mode)) {
 
1680
            if (fstat (fileno(f), &s) == -1 ||
 
1681
                !S_ISREG(s.st_mode)) {
1402
1682
                fclose(f);
1403
1683
                f=NULL;
1404
1684
            }
1423
1703
    printf("\n");
1424
1704
    if ((ap = get_afntype(AF_IPX)) == NULL) {
1425
1705
        EINTERN("netstat.c", "AF_IPX missing");
 
1706
        fclose(f);
1426
1707
        return (-1);
1427
1708
    }
1428
 
    fgets(buf, 255, f);
 
1709
    if (fgets(buf, 255, f))
 
1710
        /* eat line */;
1429
1711
 
1430
1712
    while (fgets(buf, 255, f) != NULL) {
1431
 
        sscanf(buf, "%s %s %lX %lX %d %d",
 
1713
        sscanf(buf, "%s %s %lX %lX %u %u",
1432
1714
               sad, dad, &txq, &rxq, &state, &uid);
1433
1715
        if ((st = rindex(sad, ':'))) {
1434
1716
            *st++ = '\0';
1436
1718
            sport = ntohs(sport);
1437
1719
        } else {
1438
1720
            EINTERN("netstat.c", "ipx socket format error in source port");
 
1721
            fclose(f);
1439
1722
            return (-1);
1440
1723
        }
1441
1724
        nc = 0;
1445
1728
                sscanf(st, "%X", &dport);       /* net byt order */
1446
1729
                dport = ntohs(dport);
1447
1730
            } else {
1448
 
                EINTERN("netstat.c", "ipx soket format error in destination port");
 
1731
                EINTERN("netstat.c", "ipx socket format error in destination port");
 
1732
                fclose(f);
1449
1733
                return (-1);
1450
1734
            }
1451
1735
        } else
1466
1750
        }
1467
1751
 
1468
1752
        /* Fetch and resolve the Source */
1469
 
        (void) ap->input(4, sad, &sa);
1470
 
        safe_strncpy(buf, ap->sprint(&sa, flag_not), sizeof(buf));
 
1753
        (void) ap->input(0, sad, &sa);
 
1754
        safe_strncpy(buf, ap->sprint(&sa, flag_not & FLAG_NUM_HOST), sizeof(buf));
1471
1755
        snprintf(sad, sizeof(sad), "%s:%04X", buf, sport);
1472
1756
 
1473
1757
        if (!nc) {
1474
1758
            /* Fetch and resolve the Destination */
1475
 
            (void) ap->input(4, dad, &sa);
1476
 
            safe_strncpy(buf, ap->sprint(&sa, flag_not), sizeof(buf));
 
1759
            (void) ap->input(0, dad, &sa);
 
1760
            safe_strncpy(buf, ap->sprint(&sa, flag_not & FLAG_NUM_HOST), sizeof(buf));
1477
1761
            snprintf(dad, sizeof(dad), "%s:%04X", buf, dport);
1478
1762
        } else
1479
 
            strcpy(dad, "-");
 
1763
        safe_strncpy(dad, "-", sizeof(dad));
1480
1764
 
1481
1765
        printf("IPX   %6ld %6ld %-26s %-26s %-5s", txq, rxq, sad, dad, st);
1482
1766
        if (flag_exp > 1) {
1492
1776
}
1493
1777
#endif
1494
1778
 
 
1779
#if HAVE_AFBLUETOOTH
 
1780
const char *bluetooth_state(int state)
 
1781
{
 
1782
    switch (state) {
 
1783
        case BT_CONNECTED:
 
1784
            return _("CONNECTED");
 
1785
        case BT_OPEN:
 
1786
            return _("OPEN");
 
1787
        case BT_BOUND:
 
1788
            return _("BOUND");
 
1789
        case BT_LISTEN:
 
1790
            return _("LISTEN");
 
1791
        case BT_CONNECT:
 
1792
            return _("CONNECT");
 
1793
        case BT_CONNECT2:
 
1794
            return _("CONNECT2");
 
1795
        case BT_CONFIG:
 
1796
            return _("CONFIG");
 
1797
        case BT_DISCONN:
 
1798
            return _("DISCONN");
 
1799
        case BT_CLOSED:
 
1800
            return _("CLOSED");
 
1801
        default:
 
1802
            return _("UNKNOWN");
 
1803
    }
 
1804
}
 
1805
 
 
1806
static void l2cap_do_one(int nr, const char *line, const char *prot)
 
1807
{
 
1808
    char daddr[18], saddr[18];
 
1809
    unsigned dtype, stype, state, psm, dcid, scid, imtu, omtu, sec_level;
 
1810
    int num;
 
1811
    const char *bt_state, *bt_sec_level;
 
1812
 
 
1813
    num = sscanf(line, "%17s (%u) %17s (%u) %d %d 0x%04x 0x%04x %d %d %d",
 
1814
        daddr, &dtype, saddr, &stype, &state, &psm, &dcid, &scid, &imtu, &omtu, &sec_level);
 
1815
 
 
1816
    if (num != 11) {
 
1817
        num = sscanf(line, "%17s %17s %d %d 0x%04x 0x%04x %d %d %d",
 
1818
            daddr, saddr, &state, &psm, &dcid, &scid, &imtu, &omtu, &sec_level);
 
1819
 
 
1820
        if (num != 9) {
 
1821
            fprintf(stderr, _("warning, got bogus l2cap line.\n"));
 
1822
            return;
 
1823
        }
 
1824
    }
 
1825
 
 
1826
    if (flag_lst && !(state == BT_LISTEN || state == BT_BOUND))
 
1827
        return;
 
1828
    if (!(flag_all || flag_lst) && (state == BT_LISTEN || state == BT_BOUND))
 
1829
        return;
 
1830
 
 
1831
    bt_state = bluetooth_state(state);
 
1832
    switch (sec_level) {
 
1833
        case BT_SECURITY_SDP:
 
1834
            bt_sec_level = _("SDP");
 
1835
            break;
 
1836
        case BT_SECURITY_LOW:
 
1837
            bt_sec_level = _("LOW");
 
1838
            break;
 
1839
        case BT_SECURITY_MEDIUM:
 
1840
            bt_sec_level = _("MEDIUM");
 
1841
            break;
 
1842
        case BT_SECURITY_HIGH:
 
1843
            bt_sec_level = _("HIGH");
 
1844
            break;
 
1845
        default:
 
1846
            bt_sec_level = _("UNKNOWN");
 
1847
    }
 
1848
 
 
1849
    printf("l2cap  %-17s %-17s %-9s %7d 0x%04x 0x%04x %7d %7d %-7s\n",
 
1850
        (strcmp (daddr, "00:00:00:00:00:00") == 0 ? "*" : daddr),
 
1851
        (strcmp (saddr, "00:00:00:00:00:00") == 0 ? "*" : saddr),
 
1852
        bt_state, psm, dcid, scid, imtu, omtu, bt_sec_level);
 
1853
}
 
1854
 
 
1855
static int l2cap_info(void)
 
1856
{
 
1857
    printf("%-6s %-17s %-17s %-9s %7s %-6s %-6s %7s %7s %-7s\n",
 
1858
        "Proto", "Destination", "Source", "State", "PSM", "DCID", "SCID", "IMTU", "OMTU", "Security");
 
1859
    INFO_GUTS(_PATH_SYS_BLUETOOTH_L2CAP, "BTPROTO L2CAP", l2cap_do_one, "l2cap");
 
1860
}
 
1861
 
 
1862
static void rfcomm_do_one(int nr, const char *line, const char *prot)
 
1863
{
 
1864
    char daddr[18], saddr[18];
 
1865
    unsigned state, channel;
 
1866
    int num;
 
1867
    const char *bt_state;
 
1868
 
 
1869
    num = sscanf(line, "%17s %17s %d %d", daddr, saddr, &state, &channel);
 
1870
    if (num < 4) {
 
1871
        fprintf(stderr, _("warning, got bogus rfcomm line.\n"));
 
1872
        return;
 
1873
    }
 
1874
 
 
1875
    if (flag_lst && !(state == BT_LISTEN || state == BT_BOUND))
 
1876
        return;
 
1877
    if (!(flag_all || flag_lst) && (state == BT_LISTEN || state == BT_BOUND))
 
1878
        return;
 
1879
 
 
1880
    bt_state = bluetooth_state(state);
 
1881
    printf("rfcomm %-17s %-17s %-9s %7d\n",
 
1882
        (strcmp (daddr, "00:00:00:00:00:00") == 0 ? "*" : daddr),
 
1883
        (strcmp (saddr, "00:00:00:00:00:00") == 0 ? "*" : saddr),
 
1884
        bt_state, channel);
 
1885
}
 
1886
 
 
1887
static int rfcomm_info(void)
 
1888
{
 
1889
    printf("%-6s %-17s %-17s %-9s %7s\n", "Proto", "Destination", "Source", "State", "Channel");
 
1890
    INFO_GUTS(_PATH_SYS_BLUETOOTH_RFCOMM, "BTPROTO RFCOMM", rfcomm_do_one, "rfcomm");
 
1891
}
 
1892
#endif
 
1893
 
1495
1894
static int iface_info(void)
1496
1895
{
1497
1896
    if (skfd < 0) {
1503
1902
    }
1504
1903
    if (flag_exp < 2) {
1505
1904
        ife_short = 1;
1506
 
        printf(_("Iface   MTU Met   RX-OK RX-ERR RX-DRP RX-OVR    TX-OK TX-ERR TX-DRP TX-OVR Flg\n"));
 
1905
        printf(_("Iface      MTU    RX-OK RX-ERR RX-DRP RX-OVR    TX-OK TX-ERR TX-DRP TX-OVR Flg\n"));
1507
1906
    }
1508
1907
 
1509
1908
    if (for_all_interfaces(do_if_print, &flag_all) < 0) {
1523
1922
 
1524
1923
static void version(void)
1525
1924
{
1526
 
    printf("%s\n%s\n%s\n%s\n", Release, Version, Signature, Features);
 
1925
    printf("%s\n%s\n%s\n", Release, Signature, Features);
1527
1926
    exit(E_VERSION);
1528
1927
}
1529
1928
 
1532
1931
{
1533
1932
    fprintf(stderr, _("usage: netstat [-vWeenNcCF] [<Af>] -r         netstat {-V|--version|-h|--help}\n"));
1534
1933
    fprintf(stderr, _("       netstat [-vWnNcaeol] [<Socket> ...]\n"));
1535
 
    fprintf(stderr, _("       netstat { [-vWeenNac] -i | [-cWnNe] -M | -s }\n\n"));
 
1934
    fprintf(stderr, _("       netstat { [-vWeenNac] -i | [-cnNe] -M | -s [-6tuw] }\n\n"));
1536
1935
 
1537
1936
    fprintf(stderr, _("        -r, --route              display routing table\n"));
1538
1937
    fprintf(stderr, _("        -i, --interfaces         display interface table\n"));
1541
1940
#if HAVE_FW_MASQUERADE
1542
1941
    fprintf(stderr, _("        -M, --masquerade         display masqueraded connections\n\n"));
1543
1942
#endif
 
1943
 
1544
1944
    fprintf(stderr, _("        -v, --verbose            be verbose\n"));
1545
1945
    fprintf(stderr, _("        -W, --wide               don't truncate IP addresses\n"));
1546
1946
    fprintf(stderr, _("        -n, --numeric            don't resolve names\n"));
1550
1950
    fprintf(stderr, _("        -N, --symbolic           resolve hardware names\n"));
1551
1951
    fprintf(stderr, _("        -e, --extend             display other/more information\n"));
1552
1952
    fprintf(stderr, _("        -p, --programs           display PID/Program name for sockets\n"));
 
1953
    fprintf(stderr, _("        -o, --timers             display timers\n"));
1553
1954
    fprintf(stderr, _("        -c, --continuous         continuous listing\n\n"));
1554
1955
    fprintf(stderr, _("        -l, --listening          display listening server sockets\n"));
1555
 
    fprintf(stderr, _("        -a, --all, --listening   display all sockets (default: connected)\n"));
1556
 
    fprintf(stderr, _("        -o, --timers             display timers\n"));
 
1956
    fprintf(stderr, _("        -a, --all                display all sockets (default: connected)\n"));
1557
1957
    fprintf(stderr, _("        -F, --fib                display Forwarding Information Base (default)\n"));
1558
 
    fprintf(stderr, _("        -C, --cache              display routing cache instead of FIB\n\n"));
 
1958
    fprintf(stderr, _("        -C, --cache              display routing cache instead of FIB\n"));
 
1959
#if HAVE_SELINUX
 
1960
    fprintf(stderr, _("        -Z, --context            display SELinux security context for sockets\n"));
 
1961
#endif
1559
1962
 
1560
 
    fprintf(stderr, _("  <Socket>={-t|--tcp} {-u|--udp} {-w|--raw} {-x|--unix} --ax25 --ipx --netrom\n"));
 
1963
    fprintf(stderr, _("\n  <Socket>={-t|--tcp} {-u|--udp} {-U|--udplite} {-S|--sctp} {-w|--raw}\n"));
 
1964
    fprintf(stderr, _("           {-x|--unix} --ax25 --ipx --netrom\n"));
1561
1965
    fprintf(stderr, _("  <AF>=Use '-6|-4' or '-A <af>' or '--<af>'; default: %s\n"), DFLT_AF);
1562
1966
    fprintf(stderr, _("  List of possible address families (which support routing):\n"));
1563
1967
    print_aflist(1); /* 1 = routeable */
1581
1985
#endif
1582
1986
        {"protocol", 1, 0, 'A'},
1583
1987
        {"tcp", 0, 0, 't'},
 
1988
        {"sctp", 0, 0, 'S'},
1584
1989
        {"udp", 0, 0, 'u'},
 
1990
        {"udplite", 0, 0, 'U'},
1585
1991
        {"raw", 0, 0, 'w'},
1586
1992
        {"unix", 0, 0, 'x'},
 
1993
        {"l2cap", 0, 0, '2'},
 
1994
        {"rfcomm", 0, 0, 'f'},
1587
1995
        {"listening", 0, 0, 'l'},
1588
1996
        {"all", 0, 0, 'a'},
1589
1997
        {"timers", 0, 0, 'o'},
1601
2009
        {"cache", 0, 0, 'C'},
1602
2010
        {"fib", 0, 0, 'F'},
1603
2011
        {"groups", 0, 0, 'g'},
 
2012
        {"context", 0, 0, 'Z'},
1604
2013
        {NULL, 0, 0, 0}
1605
2014
    };
1606
2015
 
1612
2021
    getroute_init();            /* Set up AF routing support */
1613
2022
 
1614
2023
    afname[0] = '\0';
1615
 
    while ((i = getopt_long(argc, argv, "MCFA:acdegphinNorstuWVv?wxl64", longopts, &lop)) != EOF)
 
2024
    while ((i = getopt_long(argc, argv, "A:CFMacdeghilnNoprsStuUvVWw2fx64?Z", longopts, &lop)) != EOF)
1616
2025
        switch (i) {
1617
2026
        case -1:
1618
2027
            break;
1700
2109
        case 'r':
1701
2110
            flag_rou++;
1702
2111
            break;
1703
 
 
1704
2112
        case 't':
1705
2113
            flag_tcp++;
1706
2114
            break;
1707
 
 
 
2115
        case 'S':
 
2116
            flag_sctp++;
 
2117
            break;
1708
2118
        case 'u':
1709
2119
            flag_udp++;
1710
2120
            break;
 
2121
        case 'U':
 
2122
            flag_udplite++;
 
2123
            break;
1711
2124
        case 'w':
1712
2125
            flag_raw++;
1713
2126
            break;
 
2127
        case '2':
 
2128
            flag_l2cap++;
 
2129
            break;
 
2130
        case 'f':
 
2131
            flag_rfcomm++;
 
2132
            break;
1714
2133
        case 'x':
1715
2134
            if (aftrans_opt("unix"))
1716
2135
                exit(1);
1717
2136
            break;
 
2137
        case 'Z':
 
2138
#if HAVE_SELINUX
 
2139
            if (is_selinux_enabled() <= 0) {
 
2140
                fprintf(stderr, _("SELinux is not enabled on this machine.\n"));
 
2141
                exit(1);
 
2142
            }
 
2143
            flag_prg++;
 
2144
            flag_selinux++;
 
2145
#else
 
2146
            fprintf(stderr, _("SELinux is not enabled for this application.\n"));
 
2147
            exit(1);
 
2148
#endif
 
2149
 
 
2150
            break;
1718
2151
        case '?':
1719
2152
        case 'h':
1720
2153
            usage();
1725
2158
    if (flag_int + flag_rou + flag_mas + flag_sta > 1)
1726
2159
        usage();
1727
2160
 
1728
 
    if ((flag_inet || flag_inet6 || flag_sta) && !(flag_tcp || flag_udp || flag_raw))
1729
 
        flag_tcp = flag_udp = flag_raw = 1;
 
2161
    if ((flag_inet || flag_inet6 || flag_sta) &&
 
2162
        !(flag_tcp || flag_sctp || flag_udp || flag_udplite || flag_raw))
 
2163
           flag_noprot = flag_tcp = flag_sctp = flag_udp = flag_udplite = flag_raw = 1;
1730
2164
 
1731
 
    if ((flag_tcp || flag_udp || flag_raw || flag_igmp) && !(flag_inet || flag_inet6))
 
2165
    if ((flag_tcp || flag_sctp || flag_udp || flag_udplite || flag_raw || flag_igmp) &&
 
2166
        !(flag_inet || flag_inet6))
1732
2167
        flag_inet = flag_inet6 = 1;
1733
2168
 
1734
 
    flag_arg = flag_tcp + flag_udp + flag_raw + flag_unx + flag_ipx
1735
 
        + flag_ax25 + flag_netrom + flag_igmp + flag_x25;
 
2169
    if (flag_bluetooth && !(flag_l2cap || flag_rfcomm))
 
2170
           flag_l2cap = flag_rfcomm = 1;
 
2171
 
 
2172
    flag_arg = flag_tcp + flag_sctp + flag_udplite + flag_udp + flag_raw + flag_unx
 
2173
        + flag_ipx + flag_ax25 + flag_netrom + flag_igmp + flag_x25 + flag_rose
 
2174
        + flag_l2cap + flag_rfcomm;
1736
2175
 
1737
2176
    if (flag_mas) {
1738
2177
#if HAVE_FW_MASQUERADE && HAVE_AFINET
1739
2178
#if MORE_THAN_ONE_MASQ_AF
1740
2179
        if (!afname[0])
1741
 
            strcpy(afname, DFLT_AF);
 
2180
        safe_strncpy(afname, DFLT_AF, sizeof(afname));
1742
2181
#endif
1743
2182
        for (;;) {
1744
2183
            i = ip_masq_info(flag_not & FLAG_NUM_HOST,
1745
2184
                             flag_not & FLAG_NUM_PORT, flag_exp);
1746
2185
            if (i || !flag_cnt)
1747
2186
                break;
1748
 
            sleep(1);
 
2187
            wait_continous();
1749
2188
        }
1750
2189
#else
1751
 
        ENOSUPP("netstat.c", "FW_MASQUERADE");
 
2190
        ENOSUPP("netstat", "FW_MASQUERADE");
1752
2191
        i = -1;
1753
2192
#endif
1754
2193
        return (i);
1755
2194
    }
1756
2195
 
1757
2196
    if (flag_sta) {
1758
 
        char *tmp1, *tmp2;
1759
 
        char buf[256];
1760
 
        if (!afname[0]) {
1761
 
            inittab();
1762
 
            parsesnmp(flag_raw, flag_tcp, flag_udp);
 
2197
        if (!afname[0])
 
2198
            safe_strncpy(afname, DFLT_AF, sizeof(afname));
 
2199
 
 
2200
        if (!strcmp(afname, "inet")) {
 
2201
#if HAVE_AFINET
 
2202
            parsesnmp(flag_raw, flag_tcp, flag_udp, flag_sctp);
 
2203
#else
 
2204
            ENOSUPP("netstat", "AF INET");
 
2205
            exit(1);
 
2206
#endif
 
2207
        } else if(!strcmp(afname, "inet6")) {
 
2208
#if HAVE_AFINET6
 
2209
            parsesnmp6(flag_raw, flag_tcp, flag_udp);
 
2210
#else
 
2211
            ENOSUPP("netstat", "AF INET6");
 
2212
            exit(1);
 
2213
#endif
1763
2214
        } else {
1764
 
            safe_strncpy(buf, afname, sizeof(buf));
1765
 
            tmp1 = buf;
1766
 
            if ((tmp2 = index(tmp1, ',')))
1767
 
                 printf("Multiple interface\n");
1768
 
            else if(!strncmp(buf,"inet6",5)) {
1769
 
#if HAVE_AFINET6
1770
 
                 inittab6();
1771
 
                 parsesnmp6(flag_raw, flag_tcp, flag_udp);
1772
 
#else
1773
 
                 printf("Address type not supported for stats\n");
1774
 
                 exit(1);
1775
 
#endif
1776
 
            } else {
1777
 
                 printf("Address type not supported for stats\n");
1778
 
                 exit(1);
1779
 
            }
 
2215
          printf(_("netstat: No statistics support for specified address family: %s\n"), afname);
 
2216
          exit(1);
1780
2217
        }
1781
2218
        exit(0);
1782
2219
    }
1783
 
    
 
2220
 
1784
2221
    if (flag_rou) {
1785
2222
        int options = 0;
1786
2223
 
1787
2224
        if (!afname[0])
1788
 
            strcpy(afname, DFLT_AF);
 
2225
        safe_strncpy(afname, DFLT_AF, sizeof(afname));
1789
2226
 
1790
2227
        if (flag_exp == 2)
1791
2228
            flag_exp = 1;
1800
2237
            i = route_info(afname, options);
1801
2238
            if (i || !flag_cnt)
1802
2239
                break;
1803
 
            sleep(1);
 
2240
            wait_continous();
1804
2241
        }
1805
2242
        return (i);
1806
2243
    }
1809
2246
            i = iface_info();
1810
2247
            if (!flag_cnt || i)
1811
2248
                break;
1812
 
            sleep(1);
 
2249
            wait_continous();
1813
2250
        }
1814
2251
        return (i);
1815
2252
    }
1816
2253
    for (;;) {
1817
 
        if (!flag_arg || flag_tcp || flag_udp || flag_raw) {
 
2254
        if (!flag_arg || flag_tcp || flag_sctp || flag_udp || flag_udplite || flag_raw) {
1818
2255
#if HAVE_AFINET
1819
2256
            prg_cache_load();
1820
2257
            printf(_("Active Internet connections "));  /* xxx */
1829
2266
            }
1830
2267
            printf(_("\nProto Recv-Q Send-Q Local Address           Foreign Address         State      "));     /* xxx */
1831
2268
            if (flag_exp > 1)
1832
 
                printf(_(" User       Inode      "));
1833
 
            if (flag_prg)
1834
 
                printf(_(" PID/Program name"));
 
2269
                printf(_(" User       Inode     "));
 
2270
            print_progname_banner();
 
2271
            print_selinux_banner();
1835
2272
            if (flag_opt)
1836
 
                printf(_(" Timer"));
 
2273
                printf(_(" Timer"));    /* xxx */
1837
2274
            printf("\n");
1838
2275
#else
1839
2276
            if (flag_arg) {
1848
2285
            if (i)
1849
2286
                return (i);
1850
2287
        }
 
2288
 
 
2289
        if (!flag_arg || flag_sctp) {
 
2290
            i = sctp_info();
 
2291
            if (i)
 
2292
                return (i);
 
2293
        }
 
2294
 
1851
2295
        if (!flag_arg || flag_udp) {
1852
2296
            i = udp_info();
1853
2297
            if (i)
1854
2298
                return (i);
1855
2299
        }
 
2300
 
 
2301
        if (!flag_arg || flag_udplite) {
 
2302
            i = udplite_info();
 
2303
            if (i)
 
2304
                return (i);
 
2305
        }
 
2306
 
1856
2307
        if (!flag_arg || flag_raw) {
1857
2308
            i = raw_info();
1858
2309
            if (i)
1934
2385
            }
1935
2386
#endif
1936
2387
        }
1937
 
                    
 
2388
        if (!flag_arg || flag_rose) {
 
2389
#if 0 && HAVE_AFROSE
 
2390
          i = rose_info();
 
2391
          if (i)
 
2392
            return (i);
 
2393
#else
 
2394
          if (flag_arg) {
 
2395
            i = 1;
 
2396
            ENOSUPP("netstat", "AF ROSE");
 
2397
          }
 
2398
#endif
 
2399
        }
 
2400
 
 
2401
        if (!flag_arg || flag_l2cap || flag_rfcomm) {
 
2402
#if HAVE_AFBLUETOOTH
 
2403
            printf(_("Active Bluetooth connections ")); /* xxx */
 
2404
 
 
2405
            if (flag_all)
 
2406
                printf(_("(servers and established)"));
 
2407
            else {
 
2408
              if (flag_lst)
 
2409
                printf(_("(only servers)"));
 
2410
              else
 
2411
                printf(_("(w/o servers)"));
 
2412
            }
 
2413
            printf("\n");
 
2414
#else
 
2415
            if (flag_arg) {
 
2416
                i = 1;
 
2417
                ENOSUPP("netstat", "AF BLUETOOTH");
 
2418
            }
 
2419
#endif
 
2420
        }
 
2421
#if HAVE_AFBLUETOOTH
 
2422
        if (!flag_arg || flag_l2cap) {
 
2423
            i = l2cap_info();
 
2424
            if (i)
 
2425
                return (i);
 
2426
        }
 
2427
        if (!flag_arg || flag_rfcomm) {
 
2428
            i = rfcomm_info();
 
2429
            if (i)
 
2430
                return (i);
 
2431
        }
 
2432
#endif
 
2433
 
1938
2434
        if (!flag_cnt || i)
1939
2435
            break;
1940
 
        sleep(1);
 
2436
        wait_continous();
1941
2437
        prg_cache_clear();
1942
2438
    }
1943
2439
    return (i);