]> git.proxmox.com Git - mirror_iproute2.git/blame - misc/ss.c
projects / mirror_iproute2.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ss: Introduce columns lightweight abstraction
[mirror_iproute2.git] / misc / ss.c
CommitLineData
b9de3ecf 1/*
aba5acdf
SH		 2 * ss.c "sockstat", socket statistics
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; either version
7 * 2 of the License, or (at your option) any later version.
8 *
9 * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
10 */
11
12#include <stdio.h>
13#include <stdlib.h>
14#include <unistd.h>
aba5acdf
SH		 15#include <fcntl.h>
16#include <sys/ioctl.h>
17#include <sys/socket.h>
18#include <sys/uio.h>
19#include <netinet/in.h>
20#include <string.h>
21#include <errno.h>
22#include <netdb.h>
23#include <arpa/inet.h>
aba5acdf
SH		 24#include <dirent.h>
25#include <fnmatch.h>
ab61159a 26#include <getopt.h>
bf4ceee6 27#include <stdbool.h>
6b376ebd 28#include <limits.h>
90351722 29#include <stdarg.h>
aba5acdf
SH		 30
31#include "utils.h"
32#include "rt_names.h"
33#include "ll_map.h"
34#include "libnetlink.h"
95ce04bc 35#include "namespace.h"
aba5acdf
SH		 36#include "SNAPSHOT.h"
37
9cb1eccf 38#include <linux/tcp.h>
f6062360 39#include <linux/sock_diag.h>
351efcde 40#include <linux/inet_diag.h>
dfbaa90d 41#include <linux/unix_diag.h>
372c30d2
ND		 42#include <linux/netdevice.h> /* for MAX_ADDR_LEN */
43#include <linux/filter.h>
44#include <linux/packet_diag.h>
ecb928c8 45#include <linux/netlink_diag.h>
f89d46ad 46#include <linux/sctp.h>
c759116a 47#include <linux/vm_sockets_diag.h>
aba5acdf 48
8a4025f6 49#define MAGIC_SEQ 123456
50
5fb421d4 51#define DIAG_REQUEST(_req, _r) \
52 struct { \
53 struct nlmsghdr nlh; \
54 _r; \
55 } _req = { \
56 .nlh = { \
57 .nlmsg_type = SOCK_DIAG_BY_FAMILY, \
58 .nlmsg_flags = NLM_F_ROOT|NLM_F_MATCH|NLM_F_REQUEST,\
8a4025f6 59 .nlmsg_seq = MAGIC_SEQ, \
5fb421d4 60 .nlmsg_len = sizeof(_req), \
61 }, \
62 }
63
116ac927
RH		 64#if HAVE_SELINUX
65#include <selinux/selinux.h>
66#else
67/* Stubs for SELinux functions */
68static int is_selinux_enabled(void)
69{
70 return -1;
71}
72
73static int getpidcon(pid_t pid, char **context)
74{
75 *context = NULL;
76 return -1;
77}
78
79static int getfilecon(char *path, char **context)
80{
81 *context = NULL;
82 return -1;
83}
84
85static int security_get_initial_context(char *name, char **context)
86{
87 *context = NULL;
88 return -1;
89}
90#endif
91
aba5acdf
SH		 92int resolve_services = 1;
93int preferred_family = AF_UNSPEC;
acd1e437
SH		 94int show_options;
95int show_details;
96int show_users;
97int show_mem;
98int show_tcpinfo;
99int show_bpf;
100int show_proc_ctx;
101int show_sock_ctx;
7a4559f6 102int show_header = 1;
acd1e437 103int follow_events;
f89d46ad 104int sctp_ino;
aba5acdf 105
59f46b7b
SB		 106enum col_id {
107 COL_NETID,
108 COL_STATE,
109 COL_RECVQ,
110 COL_SENDQ,
111 COL_ADDR,
112 COL_SERV,
113 COL_RADDR,
114 COL_RSERV,
115 COL_EXT,
116 COL_MAX
117};
118
119enum col_align {
120 ALIGN_LEFT,
121 ALIGN_CENTER,
122 ALIGN_RIGHT
123};
124
125struct column {
126 const enum col_align align;
127 const char *header;
128 const char *ldelim;
129 int width; /* Including delimiter. -1: fit to content, 0: hide */
130 int stored; /* Characters buffered */
131 int printed; /* Characters printed so far */
132};
133
134static struct column columns[] = {
135 { ALIGN_LEFT, "Netid", "", 0, 0, 0 },
136 { ALIGN_LEFT, "State", " ", 0, 0, 0 },
137 { ALIGN_LEFT, "Recv-Q", " ", 7, 0, 0 },
138 { ALIGN_LEFT, "Send-Q", " ", 7, 0, 0 },
139 { ALIGN_RIGHT, "Local Address:", " ", 0, 0, 0 },
140 { ALIGN_LEFT, "Port", "", 0, 0, 0 },
141 { ALIGN_RIGHT, "Peer Address:", " ", 0, 0, 0 },
142 { ALIGN_LEFT, "Port", "", 0, 0, 0 },
143 { ALIGN_LEFT, "", "", -1, 0, 0 },
144};
145
146static struct column *current_field = columns;
147static char field_buf[BUFSIZ];
aba5acdf
SH		 148
149static const char *TCP_PROTO = "tcp";
f89d46ad 150static const char *SCTP_PROTO = "sctp";
aba5acdf
SH		 151static const char *UDP_PROTO = "udp";
152static const char *RAW_PROTO = "raw";
acd1e437 153static const char *dg_proto;
aba5acdf 154
acd1e437 155enum {
aba5acdf 156 TCP_DB,
351efcde 157 DCCP_DB,
aba5acdf
SH		 158 UDP_DB,
159 RAW_DB,
160 UNIX_DG_DB,
161 UNIX_ST_DB,
30b669d7 162 UNIX_SQ_DB,
aba5acdf
SH		 163 PACKET_DG_DB,
164 PACKET_R_DB,
165 NETLINK_DB,
f89d46ad 166 SCTP_DB,
c759116a
SH		 167 VSOCK_ST_DB,
168 VSOCK_DG_DB,
aba5acdf
SH		 169 MAX_DB
170};
171
172#define PACKET_DBM ((1<<PACKET_DG_DB)|(1<<PACKET_R_DB))
30b669d7 173#define UNIX_DBM ((1<<UNIX_DG_DB)|(1<<UNIX_ST_DB)|(1<<UNIX_SQ_DB))
aba5acdf 174#define ALL_DB ((1<<MAX_DB)-1)
168d97f9
SH		 175#define INET_L4_DBM ((1<<TCP_DB)|(1<<UDP_DB)|(1<<DCCP_DB)|(1<<SCTP_DB))
176#define INET_DBM (INET_L4_DBM | (1<<RAW_DB))
c759116a 177#define VSOCK_DBM ((1<<VSOCK_ST_DB)|(1<<VSOCK_DG_DB))
aba5acdf
SH		 178
179enum {
7d105b56
SH		 180 SS_UNKNOWN,
181 SS_ESTABLISHED,
182 SS_SYN_SENT,
183 SS_SYN_RECV,
184 SS_FIN_WAIT1,
185 SS_FIN_WAIT2,
186 SS_TIME_WAIT,
187 SS_CLOSE,
188 SS_CLOSE_WAIT,
189 SS_LAST_ACK,
190 SS_LISTEN,
191 SS_CLOSING,
192 SS_MAX
aba5acdf
SH		 193};
194
f89d46ad
PS		 195enum {
196 SCTP_STATE_CLOSED = 0,
197 SCTP_STATE_COOKIE_WAIT = 1,
198 SCTP_STATE_COOKIE_ECHOED = 2,
199 SCTP_STATE_ESTABLISHED = 3,
200 SCTP_STATE_SHUTDOWN_PENDING = 4,
201 SCTP_STATE_SHUTDOWN_SENT = 5,
202 SCTP_STATE_SHUTDOWN_RECEIVED = 6,
203 SCTP_STATE_SHUTDOWN_ACK_SENT = 7,
204};
205
9db7bf15
VK		 206#define SS_ALL ((1 << SS_MAX) - 1)
207#define SS_CONN (SS_ALL & ~((1<<SS_LISTEN)|(1<<SS_CLOSE)|(1<<SS_TIME_WAIT)|(1<<SS_SYN_RECV)))
aba5acdf
SH		 208
209#include "ssfilter.h"
210
acd1e437 211struct filter {
aba5acdf
SH		 212 int dbs;
213 int states;
b338a3e7 214 uint64_t families;
aba5acdf 215 struct ssfilter *f;
fb2594c1 216 bool kill;
aba5acdf
SH		 217};
218
b338a3e7
SH		 219#define FAMILY_MASK(family) ((uint64_t)1 << (family))
220
9db7bf15
VK		 221static const struct filter default_dbs[MAX_DB] = {
222 [TCP_DB] = {
223 .states = SS_CONN,
b338a3e7 224 .families = FAMILY_MASK(AF_INET) | FAMILY_MASK(AF_INET6),
9db7bf15
VK		 225 },
226 [DCCP_DB] = {
227 .states = SS_CONN,
b338a3e7 228 .families = FAMILY_MASK(AF_INET) | FAMILY_MASK(AF_INET6),
9db7bf15
VK		 229 },
230 [UDP_DB] = {
f42a4574 231 .states = (1 << SS_ESTABLISHED),
b338a3e7 232 .families = FAMILY_MASK(AF_INET) | FAMILY_MASK(AF_INET6),
9db7bf15
VK		 233 },
234 [RAW_DB] = {
f42a4574 235 .states = (1 << SS_ESTABLISHED),
b338a3e7 236 .families = FAMILY_MASK(AF_INET) | FAMILY_MASK(AF_INET6),
9db7bf15
VK		 237 },
238 [UNIX_DG_DB] = {
239 .states = (1 << SS_CLOSE),
b338a3e7 240 .families = FAMILY_MASK(AF_UNIX),
9db7bf15
VK		 241 },
242 [UNIX_ST_DB] = {
243 .states = SS_CONN,
b338a3e7 244 .families = FAMILY_MASK(AF_UNIX),
9db7bf15
VK		 245 },
246 [UNIX_SQ_DB] = {
247 .states = SS_CONN,
b338a3e7 248 .families = FAMILY_MASK(AF_UNIX),
9db7bf15
VK		 249 },
250 [PACKET_DG_DB] = {
251 .states = (1 << SS_CLOSE),
b338a3e7 252 .families = FAMILY_MASK(AF_PACKET),
9db7bf15
VK		 253 },
254 [PACKET_R_DB] = {
255 .states = (1 << SS_CLOSE),
b338a3e7 256 .families = FAMILY_MASK(AF_PACKET),
9db7bf15
VK		 257 },
258 [NETLINK_DB] = {
259 .states = (1 << SS_CLOSE),
b338a3e7 260 .families = FAMILY_MASK(AF_NETLINK),
9db7bf15 261 },
f89d46ad
PS		 262 [SCTP_DB] = {
263 .states = SS_CONN,
b338a3e7 264 .families = FAMILY_MASK(AF_INET) | FAMILY_MASK(AF_INET6),
f89d46ad 265 },
c759116a
SH		 266 [VSOCK_ST_DB] = {
267 .states = SS_CONN,
268 .families = FAMILY_MASK(AF_VSOCK),
269 },
270 [VSOCK_DG_DB] = {
271 .states = SS_CONN,
272 .families = FAMILY_MASK(AF_VSOCK),
273 },
aba5acdf
SH		 274};
275
9db7bf15
VK		 276static const struct filter default_afs[AF_MAX] = {
277 [AF_INET] = {
278 .dbs = INET_DBM,
279 .states = SS_CONN,
280 },
281 [AF_INET6] = {
282 .dbs = INET_DBM,
283 .states = SS_CONN,
284 },
285 [AF_UNIX] = {
286 .dbs = UNIX_DBM,
287 .states = SS_CONN,
288 },
289 [AF_PACKET] = {
290 .dbs = PACKET_DBM,
291 .states = (1 << SS_CLOSE),
292 },
293 [AF_NETLINK] = {
294 .dbs = (1 << NETLINK_DB),
295 .states = (1 << SS_CLOSE),
296 },
c759116a
SH		 297 [AF_VSOCK] = {
298 .dbs = VSOCK_DBM,
299 .states = SS_CONN,
300 },
9db7bf15
VK		 301};
302
303static int do_default = 1;
304static struct filter current_filter;
305
306static void filter_db_set(struct filter *f, int db)
307{
308 f->states |= default_dbs[db].states;
9db7bf15
VK		 309 f->dbs |= 1 << db;
310 do_default = 0;
311}
312
313static void filter_af_set(struct filter *f, int af)
314{
1527a17e 315 f->states |= default_afs[af].states;
b338a3e7 316 f->families |= FAMILY_MASK(af);
1527a17e
VK		 317 do_default = 0;
318 preferred_family = af;
9db7bf15
VK		 319}
320
321static int filter_af_get(struct filter *f, int af)
322{
b338a3e7 323 return !!(f->families & FAMILY_MASK(af));
9db7bf15
VK		 324}
325
326static void filter_default_dbs(struct filter *f)
327{
328 filter_db_set(f, UDP_DB);
329 filter_db_set(f, DCCP_DB);
330 filter_db_set(f, TCP_DB);
331 filter_db_set(f, RAW_DB);
332 filter_db_set(f, UNIX_ST_DB);
333 filter_db_set(f, UNIX_DG_DB);
334 filter_db_set(f, UNIX_SQ_DB);
335 filter_db_set(f, PACKET_R_DB);
336 filter_db_set(f, PACKET_DG_DB);
337 filter_db_set(f, NETLINK_DB);
f89d46ad 338 filter_db_set(f, SCTP_DB);
c759116a
SH		 339 filter_db_set(f, VSOCK_ST_DB);
340 filter_db_set(f, VSOCK_DG_DB);
9db7bf15
VK		 341}
342
57ff5a10 343static void filter_states_set(struct filter *f, int states)
9db7bf15 344{
57ff5a10 345 if (states)
9d320e1e 346 f->states = states;
57ff5a10 347}
9db7bf15 348
57ff5a10
VK		 349static void filter_merge_defaults(struct filter *f)
350{
351 int db;
352 int af;
9db7bf15 353
57ff5a10
VK		 354 for (db = 0; db < MAX_DB; db++) {
355 if (!(f->dbs & (1 << db)))
356 continue;
9db7bf15 357
57ff5a10
VK		 358 if (!(default_dbs[db].families & f->families))
359 f->families |= default_dbs[db].families;
360 }
361 for (af = 0; af < AF_MAX; af++) {
b338a3e7 362 if (!(f->families & FAMILY_MASK(af)))
57ff5a10
VK		 363 continue;
364
365 if (!(default_afs[af].dbs & f->dbs))
366 f->dbs |= default_afs[af].dbs;
367 }
9db7bf15 368}
aba5acdf 369
ab01dbbb 370static FILE *generic_proc_open(const char *env, const char *name)
aba5acdf 371{
ab01dbbb 372 const char *p = getenv(env);
aba5acdf 373 char store[128];
ab01dbbb 374
aba5acdf
SH		 375 if (!p) {
376 p = getenv("PROC_ROOT") ? : "/proc";
377 snprintf(store, sizeof(store)-1, "%s/%s", p, name);
378 p = store;
379 }
ab01dbbb
SH		 380
381 return fopen(p, "r");
aba5acdf 382}
0cb74a86
PS		 383#define net_tcp_open() generic_proc_open("PROC_NET_TCP", "net/tcp")
384#define net_tcp6_open() generic_proc_open("PROC_NET_TCP6", "net/tcp6")
385#define net_udp_open() generic_proc_open("PROC_NET_UDP", "net/udp")
386#define net_udp6_open() generic_proc_open("PROC_NET_UDP6", "net/udp6")
387#define net_raw_open() generic_proc_open("PROC_NET_RAW", "net/raw")
388#define net_raw6_open() generic_proc_open("PROC_NET_RAW6", "net/raw6")
389#define net_unix_open() generic_proc_open("PROC_NET_UNIX", "net/unix")
390#define net_packet_open() generic_proc_open("PROC_NET_PACKET", \
391 "net/packet")
392#define net_netlink_open() generic_proc_open("PROC_NET_NETLINK", \
393 "net/netlink")
394#define slabinfo_open() generic_proc_open("PROC_SLABINFO", "slabinfo")
395#define net_sockstat_open() generic_proc_open("PROC_NET_SOCKSTAT", \
396 "net/sockstat")
397#define net_sockstat6_open() generic_proc_open("PROC_NET_SOCKSTAT6", \
398 "net/sockstat6")
399#define net_snmp_open() generic_proc_open("PROC_NET_SNMP", "net/snmp")
400#define ephemeral_ports_open() generic_proc_open("PROC_IP_LOCAL_PORT_RANGE", \
401 "sys/net/ipv4/ip_local_port_range")
aba5acdf 402
fbc0f876
SF		 403struct user_ent {
404 struct user_ent *next;
405 unsigned int ino;
406 int pid;
407 int fd;
116ac927
RH		 408 char *process;
409 char *process_ctx;
410 char *socket_ctx;
fbc0f876
SF		 411};
412
413#define USER_ENT_HASH_SIZE 256
414struct user_ent *user_ent_hash[USER_ENT_HASH_SIZE];
415
416static int user_ent_hashfn(unsigned int ino)
aba5acdf 417{
fbc0f876 418 int val = (ino >> 24) ^ (ino >> 16) ^ (ino >> 8) ^ ino;
aba5acdf 419
fbc0f876
SF		 420 return val & (USER_ENT_HASH_SIZE - 1);
421}
422
116ac927
RH		 423static void user_ent_add(unsigned int ino, char *process,
424 int pid, int fd,
425 char *proc_ctx,
426 char *sock_ctx)
fbc0f876
SF		 427{
428 struct user_ent *p, **pp;
aba5acdf 429
116ac927
RH		 430 p = malloc(sizeof(struct user_ent));
431 if (!p) {
432 fprintf(stderr, "ss: failed to malloc buffer\n");
fbc0f876 433 abort();
116ac927 434 }
fbc0f876
SF		 435 p->next = NULL;
436 p->ino = ino;
437 p->pid = pid;
438 p->fd = fd;
116ac927
RH		 439 p->process = strdup(process);
440 p->process_ctx = strdup(proc_ctx);
441 p->socket_ctx = strdup(sock_ctx);
fbc0f876
SF		 442
443 pp = &user_ent_hash[user_ent_hashfn(ino)];
444 p->next = *pp;
445 *pp = p;
446}
aba5acdf 447
116ac927
RH		 448static void user_ent_destroy(void)
449{
450 struct user_ent *p, *p_next;
451 int cnt = 0;
452
453 while (cnt != USER_ENT_HASH_SIZE) {
454 p = user_ent_hash[cnt];
455 while (p) {
456 free(p->process);
457 free(p->process_ctx);
458 free(p->socket_ctx);
459 p_next = p->next;
460 free(p);
461 p = p_next;
462 }
463 cnt++;
464 }
465}
466
fbc0f876
SF		 467static void user_ent_hash_build(void)
468{
469 const char *root = getenv("PROC_ROOT") ? : "/proc/";
470 struct dirent *d;
471 char name[1024];
472 int nameoff;
473 DIR *dir;
116ac927
RH		 474 char *pid_context;
475 char *sock_context;
476 const char *no_ctx = "unavailable";
b25bad2f 477 static int user_ent_hash_build_init;
116ac927
RH		 478
479 /* If show_users & show_proc_ctx set only do this once */
480 if (user_ent_hash_build_init != 0)
481 return;
482
483 user_ent_hash_build_init = 1;
fbc0f876 484
18f156bf 485 strlcpy(name, root, sizeof(name));
0ee9052f 486
fbc0f876 487 if (strlen(name) == 0 || name[strlen(name)-1] != '/')
aba5acdf 488 strcat(name, "/");
fbc0f876 489
aba5acdf 490 nameoff = strlen(name);
fbc0f876
SF		 491
492 dir = opendir(name);
493 if (!dir)
494 return;
aba5acdf
SH		 495
496 while ((d = readdir(dir)) != NULL) {
aba5acdf 497 struct dirent *d1;
aba5acdf 498 char process[16];
116ac927 499 char *p;
fbc0f876
SF		 500 int pid, pos;
501 DIR *dir1;
502 char crap;
aba5acdf
SH		 503
504 if (sscanf(d->d_name, "%d%c", &pid, &crap) != 1)
505 continue;
506
116ac927
RH		 507 if (getpidcon(pid, &pid_context) != 0)
508 pid_context = strdup(no_ctx);
509
0ee9052f 510 snprintf(name + nameoff, sizeof(name) - nameoff, "%d/fd/", pid);
aba5acdf 511 pos = strlen(name);
a02371fb
PS		 512 if ((dir1 = opendir(name)) == NULL) {
513 free(pid_context);
aba5acdf 514 continue;
a02371fb 515 }
aba5acdf 516
fbc0f876 517 process[0] = '\0';
116ac927 518 p = process;
aba5acdf
SH		 519
520 while ((d1 = readdir(dir1)) != NULL) {
fbc0f876
SF		 521 const char *pattern = "socket:[";
522 unsigned int ino;
aba5acdf 523 char lnk[64];
18445b3e 524 int fd;
788731b3 525 ssize_t link_len;
116ac927 526 char tmp[1024];
aba5acdf
SH		 527
528 if (sscanf(d1->d_name, "%d%c", &fd, &crap) != 1)
529 continue;
530
0ee9052f 531 snprintf(name+pos, sizeof(name) - pos, "%d", fd);
788731b3
TJ		 532
533 link_len = readlink(name, lnk, sizeof(lnk)-1);
534 if (link_len == -1)
535 continue;
536 lnk[link_len] = '\0';
537
538 if (strncmp(lnk, pattern, strlen(pattern)))
aba5acdf
SH		 539 continue;
540
fbc0f876 541 sscanf(lnk, "socket:[%u]", &ino);
aba5acdf 542
116ac927
RH		 543 snprintf(tmp, sizeof(tmp), "%s/%d/fd/%s",
544 root, pid, d1->d_name);
545
546 if (getfilecon(tmp, &sock_context) <= 0)
547 sock_context = strdup(no_ctx);
548
549 if (*p == '\0') {
aba5acdf 550 FILE *fp;
fbc0f876 551
116ac927
RH		 552 snprintf(tmp, sizeof(tmp), "%s/%d/stat",
553 root, pid);
aba5acdf 554 if ((fp = fopen(tmp, "r")) != NULL) {
d572ed4d
PS		 555 if (fscanf(fp, "%*d (%[^)])", p) < 1)
556 ; /* ignore */
aba5acdf
SH		 557 fclose(fp);
558 }
559 }
116ac927
RH		 560 user_ent_add(ino, p, pid, fd,
561 pid_context, sock_context);
562 free(sock_context);
aba5acdf 563 }
116ac927 564 free(pid_context);
aba5acdf
SH		 565 closedir(dir1);
566 }
567 closedir(dir);
fbc0f876
SF		 568}
569
116ac927
RH		 570enum entry_types {
571 USERS,
572 PROC_CTX,
573 PROC_SOCK_CTX
574};
575
576#define ENTRY_BUF_SIZE 512
acd1e437 577static int find_entry(unsigned int ino, char **buf, int type)
fbc0f876
SF		 578{
579 struct user_ent *p;
580 int cnt = 0;
581 char *ptr;
532ca40a 582 char *new_buf;
116ac927
RH		 583 int len, new_buf_len;
584 int buf_used = 0;
585 int buf_len = 0;
fbc0f876
SF		 586
587 if (!ino)
588 return 0;
589
590 p = user_ent_hash[user_ent_hashfn(ino)];
116ac927 591 ptr = *buf = NULL;
fbc0f876
SF		 592 while (p) {
593 if (p->ino != ino)
594 goto next;
595
116ac927
RH		 596 while (1) {
597 ptr = *buf + buf_used;
598 switch (type) {
599 case USERS:
600 len = snprintf(ptr, buf_len - buf_used,
601 "(\"%s\",pid=%d,fd=%d),",
602 p->process, p->pid, p->fd);
603 break;
604 case PROC_CTX:
605 len = snprintf(ptr, buf_len - buf_used,
606 "(\"%s\",pid=%d,proc_ctx=%s,fd=%d),",
607 p->process, p->pid,
608 p->process_ctx, p->fd);
609 break;
610 case PROC_SOCK_CTX:
611 len = snprintf(ptr, buf_len - buf_used,
612 "(\"%s\",pid=%d,proc_ctx=%s,fd=%d,sock_ctx=%s),",
613 p->process, p->pid,
614 p->process_ctx, p->fd,
615 p->socket_ctx);
616 break;
617 default:
618 fprintf(stderr, "ss: invalid type: %d\n", type);
619 abort();
620 }
fbc0f876 621
116ac927
RH		 622 if (len < 0 || len >= buf_len - buf_used) {
623 new_buf_len = buf_len + ENTRY_BUF_SIZE;
532ca40a 624 new_buf = realloc(*buf, new_buf_len);
116ac927
RH		 625 if (!new_buf) {
626 fprintf(stderr, "ss: failed to malloc buffer\n");
627 abort();
628 }
532ca40a 629 *buf = new_buf;
116ac927
RH		 630 buf_len = new_buf_len;
631 continue;
632 } else {
633 buf_used += len;
634 break;
635 }
636 }
fbc0f876 637 cnt++;
116ac927 638next:
fbc0f876
SF		 639 p = p->next;
640 }
116ac927
RH		 641 if (buf_used) {
642 ptr = *buf + buf_used;
fbc0f876 643 ptr[-1] = '\0';
116ac927 644 }
aba5acdf
SH		 645 return cnt;
646}
647
aba5acdf
SH		 648/* Get stats from slab */
649
acd1e437 650struct slabstat {
aba5acdf
SH		 651 int socks;
652 int tcp_ports;
653 int tcp_tws;
654 int tcp_syns;
655 int skbs;
656};
657
a221d621 658static struct slabstat slabstat;
aba5acdf 659
d1f28cf1 660static int get_slabstat(struct slabstat *s)
aba5acdf
SH		 661{
662 char buf[256];
663 FILE *fp;
664 int cnt;
a221d621 665 static int slabstat_valid;
b3535dd6
PS		 666 static const char * const slabstat_ids[] = {
667 "sock",
668 "tcp_bind_bucket",
669 "tcp_tw_bucket",
670 "tcp_open_request",
671 "skbuff_head_cache",
672 };
a221d621
BL		 673
674 if (slabstat_valid)
675 return 0;
aba5acdf
SH		 676
677 memset(s, 0, sizeof(*s));
678
ab01dbbb
SH		 679 fp = slabinfo_open();
680 if (!fp)
aba5acdf
SH		 681 return -1;
682
683 cnt = sizeof(*s)/sizeof(int);
684
d572ed4d
PS		 685 if (!fgets(buf, sizeof(buf), fp)) {
686 fclose(fp);
687 return -1;
688 }
acd1e437 689 while (fgets(buf, sizeof(buf), fp) != NULL) {
aba5acdf 690 int i;
acd1e437 691
62000e51 692 for (i = 0; i < ARRAY_SIZE(slabstat_ids); i++) {
aba5acdf
SH		 693 if (memcmp(buf, slabstat_ids[i], strlen(slabstat_ids[i])) == 0) {
694 sscanf(buf, "%*s%d", ((int *)s) + i);
695 cnt--;
696 break;
697 }
698 }
699 if (cnt <= 0)
700 break;
701 }
702
a221d621
BL		 703 slabstat_valid = 1;
704
aba5acdf
SH		 705 fclose(fp);
706 return 0;
707}
708
2e7e805d 709static unsigned long long cookie_sk_get(const uint32_t *cookie)
f1b39e1b 710{
2e7e805d 711 return (((unsigned long long)cookie[1] << 31) << 1) | cookie[0];
f1b39e1b
VK		 712}
713
f89d46ad
PS		 714static const char *sctp_sstate_name[] = {
715 [SCTP_STATE_CLOSED] = "CLOSED",
716 [SCTP_STATE_COOKIE_WAIT] = "COOKIE_WAIT",
717 [SCTP_STATE_COOKIE_ECHOED] = "COOKIE_ECHOED",
718 [SCTP_STATE_ESTABLISHED] = "ESTAB",
719 [SCTP_STATE_SHUTDOWN_PENDING] = "SHUTDOWN_PENDING",
720 [SCTP_STATE_SHUTDOWN_SENT] = "SHUTDOWN_SENT",
721 [SCTP_STATE_SHUTDOWN_RECEIVED] = "SHUTDOWN_RECEIVED",
722 [SCTP_STATE_SHUTDOWN_ACK_SENT] = "ACK_SENT",
723};
724
acd1e437 725struct sockstat {
ec4d0d8a
VK		 726 struct sockstat *next;
727 unsigned int type;
89f634f9 728 uint16_t prot;
41fe6c34 729 uint16_t raw_prot;
8250bc9f
VK		 730 inet_prefix local;
731 inet_prefix remote;
732 int lport;
733 int rport;
734 int state;
735 int rq, wq;
acd1e437
SH		 736 unsigned int ino;
737 unsigned int uid;
8250bc9f
VK		 738 int refcnt;
739 unsigned int iface;
740 unsigned long long sk;
99bb68ff
VK		 741 char *name;
742 char *peer_name;
ec75249b 743 __u32 mark;
055840f2
VK		 744};
745
acd1e437 746struct dctcpstat {
055840f2
VK		 747 unsigned int ce_state;
748 unsigned int alpha;
749 unsigned int ab_ecn;
750 unsigned int ab_tot;
751 bool enabled;
752};
753
acd1e437 754struct tcpstat {
055840f2 755 struct sockstat ss;
4cbf5224
PS		 756 unsigned int timer;
757 unsigned int timeout;
8250bc9f 758 int probes;
d2055ea5 759 char cong_alg[16];
8250bc9f 760 double rto, ato, rtt, rttvar;
d1f338b3 761 int qack, ssthresh, backoff;
8250bc9f
VK		 762 double send_bps;
763 int snd_wscale;
764 int rcv_wscale;
765 int mss;
38e6dbc4
ED		 766 int rcv_mss;
767 int advmss;
d1f338b3 768 unsigned int cwnd;
8250bc9f
VK		 769 unsigned int lastsnd;
770 unsigned int lastrcv;
771 unsigned int lastack;
772 double pacing_rate;
773 double pacing_rate_max;
2f579872 774 double delivery_rate;
1a4dda71
ED		 775 unsigned long long bytes_acked;
776 unsigned long long bytes_received;
ecb435ea
CG		 777 unsigned int segs_out;
778 unsigned int segs_in;
414aeec9
MKL		 779 unsigned int data_segs_out;
780 unsigned int data_segs_in;
8250bc9f
VK		 781 unsigned int unacked;
782 unsigned int retrans;
783 unsigned int retrans_total;
784 unsigned int lost;
785 unsigned int sacked;
786 unsigned int fackets;
787 unsigned int reordering;
9e99e495 788 unsigned int not_sent;
8250bc9f 789 double rcv_rtt;
9e99e495 790 double min_rtt;
8250bc9f 791 int rcv_space;
00ac78d3 792 unsigned int rcv_ssthresh;
b6c7fc61
YC		 793 unsigned long long busy_time;
794 unsigned long long rwnd_limited;
795 unsigned long long sndbuf_limited;
8250bc9f
VK		 796 bool has_ts_opt;
797 bool has_sack_opt;
798 bool has_ecn_opt;
799 bool has_ecnseen_opt;
800 bool has_fastopen_opt;
801 bool has_wscale_opt;
2f579872 802 bool app_limited;
8250bc9f 803 struct dctcpstat *dctcp;
2f0f9aef 804 struct tcp_bbr_info *bbr_info;
aba5acdf
SH		 805};
806
f89d46ad
PS		 807/* SCTP assocs share the same inode number with their parent endpoint. So if we
808 * have seen the inode number before, it must be an assoc instead of the next
809 * endpoint. */
810static bool is_sctp_assoc(struct sockstat *s, const char *sock_name)
811{
812 if (strcmp(sock_name, "sctp"))
813 return false;
814 if (!sctp_ino || sctp_ino != s->ino)
815 return false;
816 return true;
817}
818
be7e4d20
PS		 819static const char *unix_netid_name(int type)
820{
821 switch (type) {
822 case SOCK_STREAM:
823 return "u_str";
824 case SOCK_SEQPACKET:
825 return "u_seq";
826 case SOCK_DGRAM:
827 default:
828 return "u_dgr";
829 }
830}
831
832static const char *proto_name(int protocol)
2d791bc8 833{
be7e4d20
PS		 834 switch (protocol) {
835 case 0:
836 return "raw";
837 case IPPROTO_UDP:
838 return "udp";
839 case IPPROTO_TCP:
840 return "tcp";
841 case IPPROTO_SCTP:
842 return "sctp";
843 case IPPROTO_DCCP:
844 return "dccp";
572e8936
PS		 845 case IPPROTO_ICMPV6:
846 return "icmp6";
be7e4d20
PS		 847 }
848
849 return "???";
850}
851
c759116a
SH		 852static const char *vsock_netid_name(int type)
853{
854 switch (type) {
855 case SOCK_STREAM:
856 return "v_str";
857 case SOCK_DGRAM:
858 return "v_dgr";
859 default:
860 return "???";
861 }
862}
863
90351722
SB		 864static void out(const char *fmt, ...)
865{
59f46b7b 866 struct column *f = current_field;
90351722
SB		 867 va_list args;
868
869 va_start(args, fmt);
59f46b7b
SB		 870 f->stored += vsnprintf(field_buf + f->stored, BUFSIZ - f->stored,
871 fmt, args);
90351722
SB		 872 va_end(args);
873}
874
59f46b7b
SB		 875static int print_left_spacing(struct column *f)
876{
877 int s;
878
879 if (f->width < 0 || f->align == ALIGN_LEFT)
880 return 0;
881
882 s = f->width - f->stored - f->printed;
883 if (f->align == ALIGN_CENTER)
884 /* If count of total spacing is odd, shift right by one */
885 s = (s + 1) / 2;
886
887 if (s > 0)
888 return printf("%*c", s, ' ');
889
890 return 0;
891}
892
893static void print_right_spacing(struct column *f)
894{
895 int s;
896
897 if (f->width < 0 || f->align == ALIGN_RIGHT)
898 return;
899
900 s = f->width - f->printed;
901 if (f->align == ALIGN_CENTER)
902 s /= 2;
903
904 if (s > 0)
905 printf("%*c", s, ' ');
906}
907
908static int field_needs_delimiter(struct column *f)
909{
910 if (!f->stored)
911 return 0;
912
913 /* Was another field already printed on this line? */
914 for (f--; f >= columns; f--)
915 if (f->width)
916 return 1;
917
918 return 0;
919}
920
921/* Flush given field to screen together with delimiter and spacing */
922static void field_flush(struct column *f)
923{
924 if (!f->width)
925 return;
926
927 if (field_needs_delimiter(f))
928 f->printed = printf("%s", f->ldelim);
929
930 f->printed += print_left_spacing(f);
931 f->printed += printf("%s", field_buf);
932 print_right_spacing(f);
933
934 *field_buf = 0;
935 f->printed = 0;
936 f->stored = 0;
937}
938
939static int field_is_last(struct column *f)
940{
941 return f - columns == COL_MAX - 1;
942}
943
944static void field_next(void)
945{
946 field_flush(current_field);
947
948 if (field_is_last(current_field)) {
949 printf("\n");
950 current_field = columns;
951 } else {
952 current_field++;
953 }
954}
955
956/* Walk through fields and flush them until we reach the desired one */
957static void field_set(enum col_id id)
958{
959 while (id != current_field - columns)
960 field_next();
961}
962
963/* Print header for all non-empty columns */
964static void print_header(void)
965{
966 while (!field_is_last(current_field)) {
967 if (current_field->width)
968 out(current_field->header);
969 field_next();
970 }
971}
972
be7e4d20
PS		 973static void sock_state_print(struct sockstat *s)
974{
975 const char *sock_name;
1882c0db
PS		 976 static const char * const sstate_name[] = {
977 "UNKNOWN",
978 [SS_ESTABLISHED] = "ESTAB",
979 [SS_SYN_SENT] = "SYN-SENT",
980 [SS_SYN_RECV] = "SYN-RECV",
981 [SS_FIN_WAIT1] = "FIN-WAIT-1",
982 [SS_FIN_WAIT2] = "FIN-WAIT-2",
983 [SS_TIME_WAIT] = "TIME-WAIT",
984 [SS_CLOSE] = "UNCONN",
985 [SS_CLOSE_WAIT] = "CLOSE-WAIT",
986 [SS_LAST_ACK] = "LAST-ACK",
987 [SS_LISTEN] = "LISTEN",
988 [SS_CLOSING] = "CLOSING",
989 };
be7e4d20
PS		 990
991 switch (s->local.family) {
992 case AF_UNIX:
993 sock_name = unix_netid_name(s->type);
994 break;
995 case AF_INET:
996 case AF_INET6:
997 sock_name = proto_name(s->type);
998 break;
999 case AF_PACKET:
1000 sock_name = s->type == SOCK_RAW ? "p_raw" : "p_dgr";
1001 break;
1002 case AF_NETLINK:
1003 sock_name = "nl";
1004 break;
c759116a
SH		 1005 case AF_VSOCK:
1006 sock_name = vsock_netid_name(s->type);
1007 break;
be7e4d20
PS		 1008 default:
1009 sock_name = "unknown";
1010 }
1011
59f46b7b
SB		 1012 if (is_sctp_assoc(s, sock_name)) {
1013 field_set(COL_STATE); /* Empty Netid field */
1014 out("`- %s", sctp_sstate_name[s->state]);
1015 } else {
1016 field_set(COL_NETID);
1017 out("%s", sock_name);
1018 field_set(COL_STATE);
1019 out("%s", sstate_name[s->state]);
f89d46ad 1020 }
2d791bc8 1021
59f46b7b
SB		 1022 field_set(COL_RECVQ);
1023 out("%-6d", s->rq);
1024 field_set(COL_SENDQ);
1025 out("%-6d", s->wq);
1026 field_set(COL_ADDR);
2d791bc8
VK		 1027}
1028
f1b39e1b
VK		 1029static void sock_details_print(struct sockstat *s)
1030{
1031 if (s->uid)
90351722 1032 out(" uid:%u", s->uid);
f1b39e1b 1033
90351722
SB		 1034 out(" ino:%u", s->ino);
1035 out(" sk:%llx", s->sk);
ec75249b
LC		 1036
1037 if (s->mark)
90351722 1038 out(" fwmark:0x%x", s->mark);
f1b39e1b
VK		 1039}
1040
b217df10
VK		 1041static void sock_addr_print(const char *addr, char *delim, const char *port,
1042 const char *ifname)
1043{
59f46b7b
SB		 1044 if (ifname)
1045 out("%s" "%%" "%s%s", addr, ifname, delim);
1046 else
1047 out("%s%s", addr, delim);
1048
1049 field_next();
1050 out("%s", port);
1051 field_next();
b217df10
VK		 1052}
1053
4cbf5224 1054static const char *print_ms_timer(unsigned int timeout)
aba5acdf
SH		 1055{
1056 static char buf[64];
1057 int secs, msecs, minutes;
acd1e437 1058
aba5acdf
SH		 1059 secs = timeout/1000;
1060 minutes = secs/60;
1061 secs = secs%60;
1062 msecs = timeout%1000;
1063 buf[0] = 0;
1064 if (minutes) {
1065 msecs = 0;
1066 snprintf(buf, sizeof(buf)-16, "%dmin", minutes);
1067 if (minutes > 9)
1068 secs = 0;
1069 }
1070 if (secs) {
1071 if (secs > 9)
1072 msecs = 0;
1073 sprintf(buf+strlen(buf), "%d%s", secs, msecs ? "." : "sec");
1074 }
1075 if (msecs)
1076 sprintf(buf+strlen(buf), "%03dms", msecs);
1077 return buf;
e7113c61 1078}
aba5acdf 1079
22588a0e 1080struct scache {
aba5acdf
SH		 1081 struct scache *next;
1082 int port;
1083 char *name;
1084 const char *proto;
1085};
1086
1087struct scache *rlist;
1088
d1f28cf1 1089static void init_service_resolver(void)
aba5acdf
SH		 1090{
1091 char buf[128];
1092 FILE *fp = popen("/usr/sbin/rpcinfo -p 2>/dev/null", "r");
596307ea
PS		 1093
1094 if (!fp)
1095 return;
1096
1097 if (!fgets(buf, sizeof(buf), fp)) {
2bcc3c16 1098 pclose(fp);
596307ea
PS		 1099 return;
1100 }
1101 while (fgets(buf, sizeof(buf), fp) != NULL) {
1102 unsigned int progn, port;
1103 char proto[128], prog[128] = "rpc.";
1104 struct scache *c;
1105
1106 if (sscanf(buf, "%u %*d %s %u %s",
acd1e437 1107 &progn, proto, &port, prog+4) != 4)
596307ea
PS		 1108 continue;
1109
1110 if (!(c = malloc(sizeof(*c))))
1111 continue;
1112
1113 c->port = port;
1114 c->name = strdup(prog);
1115 if (strcmp(proto, TCP_PROTO) == 0)
1116 c->proto = TCP_PROTO;
1117 else if (strcmp(proto, UDP_PROTO) == 0)
1118 c->proto = UDP_PROTO;
f89d46ad
PS		 1119 else if (strcmp(proto, SCTP_PROTO) == 0)
1120 c->proto = SCTP_PROTO;
596307ea
PS		 1121 else
1122 c->proto = NULL;
1123 c->next = rlist;
1124 rlist = c;
aba5acdf 1125 }
596307ea 1126 pclose(fp);
aba5acdf
SH		 1127}
1128
ab61159a
SH		 1129/* Even do not try default linux ephemeral port ranges:
1130 * default /etc/services contains so much of useless crap
1131 * wouldbe "allocated" to this area that resolution
1132 * is really harmful. I shrug each time when seeing
1133 * "socks" or "cfinger" in dumps.
1134 */
1135static int is_ephemeral(int port)
1136{
acd1e437 1137 static int min = 0, max;
c29d3792
PS		 1138
1139 if (!min) {
ab01dbbb 1140 FILE *f = ephemeral_ports_open();
acd1e437 1141
c29d3792
PS		 1142 if (!f || fscanf(f, "%d %d", &min, &max) < 2) {
1143 min = 1024;
1144 max = 4999;
ab61159a 1145 }
c29d3792
PS		 1146 if (f)
1147 fclose(f);
ab61159a 1148 }
c29d3792 1149 return port >= min && port <= max;
ab61159a
SH		 1150}
1151
1152
d1f28cf1 1153static const char *__resolve_service(int port)
aba5acdf
SH		 1154{
1155 struct scache *c;
1156
1157 for (c = rlist; c; c = c->next) {
1158 if (c->port == port && c->proto == dg_proto)
1159 return c->name;
1160 }
1161
ab61159a 1162 if (!is_ephemeral(port)) {
aba5acdf
SH		 1163 static int notfirst;
1164 struct servent *se;
acd1e437 1165
aba5acdf
SH		 1166 if (!notfirst) {
1167 setservent(1);
1168 notfirst = 1;
ae665a52 1169 }
aba5acdf
SH		 1170 se = getservbyport(htons(port), dg_proto);
1171 if (se)
1172 return se->s_name;
1173 }
1174
1175 return NULL;
1176}
1177
22588a0e
ED		 1178#define SCACHE_BUCKETS 1024
1179static struct scache *cache_htab[SCACHE_BUCKETS];
aba5acdf 1180
d1f28cf1 1181static const char *resolve_service(int port)
aba5acdf
SH		 1182{
1183 static char buf[128];
22588a0e
ED		 1184 struct scache *c;
1185 const char *res;
1186 int hash;
aba5acdf
SH		 1187
1188 if (port == 0) {
1189 buf[0] = '*';
1190 buf[1] = 0;
1191 return buf;
1192 }
1193
22588a0e
ED		 1194 if (!resolve_services)
1195 goto do_numeric;
aba5acdf 1196
22588a0e
ED		 1197 if (dg_proto == RAW_PROTO)
1198 return inet_proto_n2a(port, buf, sizeof(buf));
1199
1200
1201 hash = (port^(((unsigned long)dg_proto)>>2)) % SCACHE_BUCKETS;
1202
1203 for (c = cache_htab[hash]; c; c = c->next) {
1204 if (c->port == port && c->proto == dg_proto)
1205 goto do_cache;
aba5acdf
SH		 1206 }
1207
22588a0e
ED		 1208 c = malloc(sizeof(*c));
1209 if (!c)
1210 goto do_numeric;
1211 res = __resolve_service(port);
1212 c->port = port;
1213 c->name = res ? strdup(res) : NULL;
1214 c->proto = dg_proto;
1215 c->next = cache_htab[hash];
1216 cache_htab[hash] = c;
1217
1218do_cache:
1219 if (c->name)
1220 return c->name;
1221
1222do_numeric:
aba5acdf
SH		 1223 sprintf(buf, "%u", port);
1224 return buf;
1225}
1226
1267c0b9
PS		 1227static void inet_addr_print(const inet_prefix *a, int port,
1228 unsigned int ifindex, bool v6only)
aba5acdf
SH		 1229{
1230 char buf[1024];
1231 const char *ap = buf;
b217df10 1232 const char *ifname = NULL;
aba5acdf
SH		 1233
1234 if (a->family == AF_INET) {
1267c0b9 1235 ap = format_host(AF_INET, 4, a->data);
aba5acdf 1236 } else {
1267c0b9
PS		 1237 if (!v6only &&
1238 !memcmp(a->data, &in6addr_any, sizeof(in6addr_any))) {
aba9c23a
SH		 1239 buf[0] = '*';
1240 buf[1] = 0;
1241 } else {
1242 ap = format_host(a->family, 16, a->data);
1243
1244 /* Numeric IPv6 addresses should be bracketed */
1245 if (strchr(ap, ':')) {
1246 snprintf(buf, sizeof(buf),
1247 "[%s]", ap);
1248 ap = buf;
1249 }
aba9c23a 1250 }
aba5acdf 1251 }
b217df10 1252
59f46b7b
SB		 1253 if (ifindex)
1254 ifname = ll_index_to_name(ifindex);
7c8a3cfb 1255
59f46b7b 1256 sock_addr_print(ap, ":", resolve_service(port), ifname);
aba5acdf
SH		 1257}
1258
acd1e437 1259struct aafilter {
aba5acdf
SH		 1260 inet_prefix addr;
1261 int port;
2d293212 1262 unsigned int iface;
ec75249b
LC		 1263 __u32 mark;
1264 __u32 mask;
aba5acdf
SH		 1265 struct aafilter *next;
1266};
1267
d1f28cf1
SH		 1268static int inet2_addr_match(const inet_prefix *a, const inet_prefix *p,
1269 int plen)
aba5acdf
SH		 1270{
1271 if (!inet_addr_match(a, p, plen))
1272 return 0;
7d105b56 1273
aba5acdf
SH		 1274 /* Cursed "v4 mapped" addresses: v4 mapped socket matches
1275 * pure IPv4 rule, but v4-mapped rule selects only v4-mapped
1276 * sockets. Fair? */
1277 if (p->family == AF_INET && a->family == AF_INET6) {
1278 if (a->data[0] == 0 && a->data[1] == 0 &&
1279 a->data[2] == htonl(0xffff)) {
1280 inet_prefix tmp = *a;
acd1e437 1281
aba5acdf
SH		 1282 tmp.data[0] = a->data[3];
1283 return inet_addr_match(&tmp, p, plen);
1284 }
1285 }
1286 return 1;
1287}
1288
d1f28cf1 1289static int unix_match(const inet_prefix *a, const inet_prefix *p)
aba5acdf 1290{
99bb68ff 1291 char *addr, *pattern;
acd1e437 1292
99bb68ff
VK		 1293 memcpy(&addr, a->data, sizeof(addr));
1294 memcpy(&pattern, p->data, sizeof(pattern));
aba5acdf
SH		 1295 if (pattern == NULL)
1296 return 1;
1297 if (addr == NULL)
1298 addr = "";
1299 return !fnmatch(pattern, addr, 0);
1300}
1301
055840f2 1302static int run_ssfilter(struct ssfilter *f, struct sockstat *s)
aba5acdf
SH		 1303{
1304 switch (f->type) {
1305 case SSF_S_AUTO:
1306 {
aba5acdf 1307 if (s->local.family == AF_UNIX) {
99bb68ff 1308 char *p;
acd1e437 1309
99bb68ff 1310 memcpy(&p, s->local.data, sizeof(p));
aba5acdf 1311 return p == NULL || (p[0] == '@' && strlen(p) == 6 &&
ae665a52 1312 strspn(p+1, "0123456789abcdef") == 5);
aba5acdf
SH		 1313 }
1314 if (s->local.family == AF_PACKET)
bbd303d1 1315 return s->lport == 0 && s->local.data[0] == 0;
aba5acdf
SH		 1316 if (s->local.family == AF_NETLINK)
1317 return s->lport < 0;
c759116a
SH		 1318 if (s->local.family == AF_VSOCK)
1319 return s->lport > 1023;
aba5acdf 1320
c29d3792 1321 return is_ephemeral(s->lport);
aba5acdf
SH		 1322 }
1323 case SSF_DCOND:
1324 {
acd1e437
SH		 1325 struct aafilter *a = (void *)f->pred;
1326
aba5acdf
SH		 1327 if (a->addr.family == AF_UNIX)
1328 return unix_match(&s->remote, &a->addr);
1329 if (a->port != -1 && a->port != s->rport)
1330 return 0;
1331 if (a->addr.bitlen) {
1332 do {
1333 if (!inet2_addr_match(&s->remote, &a->addr, a->addr.bitlen))
1334 return 1;
1335 } while ((a = a->next) != NULL);
1336 return 0;
1337 }
1338 return 1;
1339 }
1340 case SSF_SCOND:
1341 {
acd1e437
SH		 1342 struct aafilter *a = (void *)f->pred;
1343
aba5acdf
SH		 1344 if (a->addr.family == AF_UNIX)
1345 return unix_match(&s->local, &a->addr);
1346 if (a->port != -1 && a->port != s->lport)
1347 return 0;
1348 if (a->addr.bitlen) {
1349 do {
1350 if (!inet2_addr_match(&s->local, &a->addr, a->addr.bitlen))
1351 return 1;
ae665a52 1352 } while ((a = a->next) != NULL);
aba5acdf
SH		 1353 return 0;
1354 }
1355 return 1;
1356 }
1357 case SSF_D_GE:
1358 {
acd1e437
SH		 1359 struct aafilter *a = (void *)f->pred;
1360
aba5acdf
SH		 1361 return s->rport >= a->port;
1362 }
1363 case SSF_D_LE:
1364 {
acd1e437
SH		 1365 struct aafilter *a = (void *)f->pred;
1366
aba5acdf
SH		 1367 return s->rport <= a->port;
1368 }
1369 case SSF_S_GE:
1370 {
acd1e437
SH		 1371 struct aafilter *a = (void *)f->pred;
1372
aba5acdf
SH		 1373 return s->lport >= a->port;
1374 }
1375 case SSF_S_LE:
1376 {
acd1e437
SH		 1377 struct aafilter *a = (void *)f->pred;
1378
aba5acdf
SH		 1379 return s->lport <= a->port;
1380 }
2d293212
DA		 1381 case SSF_DEVCOND:
1382 {
1383 struct aafilter *a = (void *)f->pred;
aba5acdf 1384
2d293212 1385 return s->iface == a->iface;
ec75249b
LC		 1386 }
1387 case SSF_MARKMASK:
1388 {
1389 struct aafilter *a = (void *)f->pred;
1390
1391 return (s->mark & a->mask) == a->mark;
2d293212 1392 }
aba5acdf
SH		 1393 /* Yup. It is recursion. Sorry. */
1394 case SSF_AND:
1395 return run_ssfilter(f->pred, s) && run_ssfilter(f->post, s);
1396 case SSF_OR:
1397 return run_ssfilter(f->pred, s) || run_ssfilter(f->post, s);
1398 case SSF_NOT:
1399 return !run_ssfilter(f->pred, s);
1400 default:
1401 abort();
1402 }
1403}
1404
ae665a52 1405/* Relocate external jumps by reloc. */
b4b0b7d5 1406static void ssfilter_patch(char *a, int len, int reloc)
aba5acdf
SH		 1407{
1408 while (len > 0) {
acd1e437
SH		 1409 struct inet_diag_bc_op *op = (struct inet_diag_bc_op *)a;
1410
aba5acdf
SH		 1411 if (op->no == len+4)
1412 op->no += reloc;
1413 len -= op->yes;
1414 a += op->yes;
1415 }
1416 if (len < 0)
1417 abort();
1418}
1419
b4b0b7d5 1420static int ssfilter_bytecompile(struct ssfilter *f, char **bytecode)
aba5acdf
SH		 1421{
1422 switch (f->type) {
1423 case SSF_S_AUTO:
1424 {
acd1e437
SH		 1425 if (!(*bytecode = malloc(4))) abort();
1426 ((struct inet_diag_bc_op *)*bytecode)[0] = (struct inet_diag_bc_op){ INET_DIAG_BC_AUTO, 4, 8 };
df39de8d 1427 return 4;
aba5acdf
SH		 1428 }
1429 case SSF_DCOND:
1430 case SSF_SCOND:
1431 {
acd1e437 1432 struct aafilter *a = (void *)f->pred;
aba5acdf
SH		 1433 struct aafilter *b;
1434 char *ptr;
351efcde 1435 int code = (f->type == SSF_DCOND ? INET_DIAG_BC_D_COND : INET_DIAG_BC_S_COND);
aba5acdf
SH		 1436 int len = 0;
1437
acd1e437 1438 for (b = a; b; b = b->next) {
351efcde 1439 len += 4 + sizeof(struct inet_diag_hostcond);
aba5acdf
SH		 1440 if (a->addr.family == AF_INET6)
1441 len += 16;
1442 else
1443 len += 4;
1444 if (b->next)
1445 len += 4;
1446 }
1447 if (!(ptr = malloc(len))) abort();
1448 *bytecode = ptr;
acd1e437 1449 for (b = a; b; b = b->next) {
351efcde 1450 struct inet_diag_bc_op *op = (struct inet_diag_bc_op *)ptr;
aba5acdf 1451 int alen = (a->addr.family == AF_INET6 ? 16 : 4);
351efcde 1452 int oplen = alen + 4 + sizeof(struct inet_diag_hostcond);
acd1e437 1453 struct inet_diag_hostcond *cond = (struct inet_diag_hostcond *)(ptr+4);
aba5acdf 1454
351efcde 1455 *op = (struct inet_diag_bc_op){ code, oplen, oplen+4 };
aba5acdf
SH		 1456 cond->family = a->addr.family;
1457 cond->port = a->port;
1458 cond->prefix_len = a->addr.bitlen;
1459 memcpy(cond->addr, a->addr.data, alen);
1460 ptr += oplen;
1461 if (b->next) {
351efcde
SH		 1462 op = (struct inet_diag_bc_op *)ptr;
1463 *op = (struct inet_diag_bc_op){ INET_DIAG_BC_JMP, 4, len - (ptr-*bytecode)};
aba5acdf
SH		 1464 ptr += 4;
1465 }
1466 }
1467 return ptr - *bytecode;
1468 }
1469 case SSF_D_GE:
1470 {
acd1e437
SH		 1471 struct aafilter *x = (void *)f->pred;
1472
1473 if (!(*bytecode = malloc(8))) abort();
1474 ((struct inet_diag_bc_op *)*bytecode)[0] = (struct inet_diag_bc_op){ INET_DIAG_BC_D_GE, 8, 12 };
1475 ((struct inet_diag_bc_op *)*bytecode)[1] = (struct inet_diag_bc_op){ 0, 0, x->port };
aba5acdf
SH		 1476 return 8;
1477 }
1478 case SSF_D_LE:
1479 {
acd1e437
SH		 1480 struct aafilter *x = (void *)f->pred;
1481
1482 if (!(*bytecode = malloc(8))) abort();
1483 ((struct inet_diag_bc_op *)*bytecode)[0] = (struct inet_diag_bc_op){ INET_DIAG_BC_D_LE, 8, 12 };
1484 ((struct inet_diag_bc_op *)*bytecode)[1] = (struct inet_diag_bc_op){ 0, 0, x->port };
aba5acdf
SH		 1485 return 8;
1486 }
1487 case SSF_S_GE:
1488 {
acd1e437
SH		 1489 struct aafilter *x = (void *)f->pred;
1490
1491 if (!(*bytecode = malloc(8))) abort();
1492 ((struct inet_diag_bc_op *)*bytecode)[0] = (struct inet_diag_bc_op){ INET_DIAG_BC_S_GE, 8, 12 };
1493 ((struct inet_diag_bc_op *)*bytecode)[1] = (struct inet_diag_bc_op){ 0, 0, x->port };
aba5acdf
SH		 1494 return 8;
1495 }
1496 case SSF_S_LE:
1497 {
acd1e437
SH		 1498 struct aafilter *x = (void *)f->pred;
1499
1500 if (!(*bytecode = malloc(8))) abort();
1501 ((struct inet_diag_bc_op *)*bytecode)[0] = (struct inet_diag_bc_op){ INET_DIAG_BC_S_LE, 8, 12 };
1502 ((struct inet_diag_bc_op *)*bytecode)[1] = (struct inet_diag_bc_op){ 0, 0, x->port };
aba5acdf
SH		 1503 return 8;
1504 }
1505
1506 case SSF_AND:
1507 {
376fb868 1508 char *a1 = NULL, *a2 = NULL, *a;
2a4fa1c3 1509 int l1, l2;
acd1e437 1510
aba5acdf
SH		 1511 l1 = ssfilter_bytecompile(f->pred, &a1);
1512 l2 = ssfilter_bytecompile(f->post, &a2);
376fb868
DA		 1513 if (!l1 || !l2) {
1514 free(a1);
1515 free(a2);
1516 return 0;
1517 }
aba5acdf
SH		 1518 if (!(a = malloc(l1+l2))) abort();
1519 memcpy(a, a1, l1);
1520 memcpy(a+l1, a2, l2);
1521 free(a1); free(a2);
1522 ssfilter_patch(a, l1, l2);
1523 *bytecode = a;
1524 return l1+l2;
1525 }
1526 case SSF_OR:
1527 {
376fb868 1528 char *a1 = NULL, *a2 = NULL, *a;
2a4fa1c3 1529 int l1, l2;
acd1e437 1530
aba5acdf
SH		 1531 l1 = ssfilter_bytecompile(f->pred, &a1);
1532 l2 = ssfilter_bytecompile(f->post, &a2);
376fb868
DA		 1533 if (!l1 || !l2) {
1534 free(a1);
1535 free(a2);
1536 return 0;
1537 }
aba5acdf
SH		 1538 if (!(a = malloc(l1+l2+4))) abort();
1539 memcpy(a, a1, l1);
1540 memcpy(a+l1+4, a2, l2);
1541 free(a1); free(a2);
acd1e437 1542 *(struct inet_diag_bc_op *)(a+l1) = (struct inet_diag_bc_op){ INET_DIAG_BC_JMP, 4, l2+4 };
aba5acdf
SH		 1543 *bytecode = a;
1544 return l1+l2+4;
1545 }
1546 case SSF_NOT:
1547 {
376fb868 1548 char *a1 = NULL, *a;
2a4fa1c3 1549 int l1;
acd1e437 1550
aba5acdf 1551 l1 = ssfilter_bytecompile(f->pred, &a1);
376fb868
DA		 1552 if (!l1) {
1553 free(a1);
1554 return 0;
1555 }
aba5acdf
SH		 1556 if (!(a = malloc(l1+4))) abort();
1557 memcpy(a, a1, l1);
1558 free(a1);
acd1e437 1559 *(struct inet_diag_bc_op *)(a+l1) = (struct inet_diag_bc_op){ INET_DIAG_BC_JMP, 4, 8 };
aba5acdf
SH		 1560 *bytecode = a;
1561 return l1+4;
2d293212
DA		 1562 }
1563 case SSF_DEVCOND:
1564 {
1565 /* bytecompile for SSF_DEVCOND not supported yet */
1566 return 0;
ec75249b
LC		 1567 }
1568 case SSF_MARKMASK:
1569 {
1570 struct aafilter *a = (void *)f->pred;
1571 struct instr {
1572 struct inet_diag_bc_op op;
1573 struct inet_diag_markcond cond;
1574 };
1575 int inslen = sizeof(struct instr);
1576
1577 if (!(*bytecode = malloc(inslen))) abort();
1578 ((struct instr *)*bytecode)[0] = (struct instr) {
1579 { INET_DIAG_BC_MARK_COND, inslen, inslen + 4 },
1580 { a->mark, a->mask},
1581 };
1582
1583 return inslen;
aba5acdf
SH		 1584 }
1585 default:
1586 abort();
1587 }
1588}
1589
b4b0b7d5 1590static int remember_he(struct aafilter *a, struct hostent *he)
aba5acdf 1591{
ae665a52 1592 char **ptr = he->h_addr_list;
aba5acdf
SH		 1593 int cnt = 0;
1594 int len;
1595
1596 if (he->h_addrtype == AF_INET)
1597 len = 4;
1598 else if (he->h_addrtype == AF_INET6)
1599 len = 16;
1600 else
1601 return 0;
1602
1603 while (*ptr) {
1604 struct aafilter *b = a;
acd1e437 1605
aba5acdf
SH		 1606 if (a->addr.bitlen) {
1607 if ((b = malloc(sizeof(*b))) == NULL)
1608 return cnt;
1609 *b = *a;
aba5acdf
SH		 1610 a->next = b;
1611 }
1612 memcpy(b->addr.data, *ptr, len);
1613 b->addr.bytelen = len;
1614 b->addr.bitlen = len*8;
1615 b->addr.family = he->h_addrtype;
1616 ptr++;
1617 cnt++;
1618 }
1619 return cnt;
1620}
1621
b4b0b7d5 1622static int get_dns_host(struct aafilter *a, const char *addr, int fam)
aba5acdf
SH		 1623{
1624 static int notfirst;
1625 int cnt = 0;
1626 struct hostent *he;
1627
1628 a->addr.bitlen = 0;
1629 if (!notfirst) {
1630 sethostent(1);
1631 notfirst = 1;
1632 }
1633 he = gethostbyname2(addr, fam == AF_UNSPEC ? AF_INET : fam);
1634 if (he)
1635 cnt = remember_he(a, he);
1636 if (fam == AF_UNSPEC) {
1637 he = gethostbyname2(addr, AF_INET6);
1638 if (he)
1639 cnt += remember_he(a, he);
1640 }
1641 return !cnt;
1642}
1643
acd1e437 1644static int xll_initted;
aba5acdf 1645
b4b0b7d5 1646static void xll_init(void)
aba5acdf
SH		 1647{
1648 struct rtnl_handle rth;
acd1e437 1649
d2468da0
SH		 1650 if (rtnl_open(&rth, 0) < 0)
1651 exit(1);
1652
aba5acdf
SH		 1653 ll_init_map(&rth);
1654 rtnl_close(&rth);
1655 xll_initted = 1;
1656}
1657
b4b0b7d5 1658static const char *xll_index_to_name(int index)
aba5acdf
SH		 1659{
1660 if (!xll_initted)
1661 xll_init();
1662 return ll_index_to_name(index);
1663}
1664
b4b0b7d5 1665static int xll_name_to_index(const char *dev)
aba5acdf
SH		 1666{
1667 if (!xll_initted)
1668 xll_init();
1669 return ll_name_to_index(dev);
1670}
1671
2d293212
DA		 1672void *parse_devcond(char *name)
1673{
1674 struct aafilter a = { .iface = 0 };
1675 struct aafilter *res;
1676
1677 a.iface = xll_name_to_index(name);
1678 if (a.iface == 0) {
1679 char *end;
930d3f28 1680 unsigned long n;
2d293212 1681
930d3f28
DA		 1682 n = strtoul(name, &end, 0);
1683 if (!end || end == name || *end || n > UINT_MAX)
2d293212 1684 return NULL;
930d3f28
DA		 1685
1686 a.iface = n;
2d293212
DA		 1687 }
1688
1689 res = malloc(sizeof(*res));
1690 *res = a;
1691
1692 return res;
1693}
1694
c759116a
SH		 1695static void vsock_set_inet_prefix(inet_prefix *a, __u32 cid)
1696{
1697 *a = (inet_prefix){
1698 .bytelen = sizeof(cid),
1699 .family = AF_VSOCK,
1700 };
1701 memcpy(a->data, &cid, sizeof(cid));
1702}
1703
7871f7db 1704void *parse_hostcond(char *addr, bool is_port)
aba5acdf
SH		 1705{
1706 char *port = NULL;
1527a17e 1707 struct aafilter a = { .port = -1 };
aba5acdf 1708 struct aafilter *res;
1527a17e 1709 int fam = preferred_family;
9db7bf15 1710 struct filter *f = &current_filter;
aba5acdf 1711
1527a17e 1712 if (fam == AF_UNIX || strncmp(addr, "unix:", 5) == 0) {
aba5acdf 1713 char *p;
acd1e437 1714
aba5acdf
SH		 1715 a.addr.family = AF_UNIX;
1716 if (strncmp(addr, "unix:", 5) == 0)
acd1e437 1717 addr += 5;
aba5acdf
SH		 1718 p = strdup(addr);
1719 a.addr.bitlen = 8*strlen(p);
99bb68ff 1720 memcpy(a.addr.data, &p, sizeof(p));
9db7bf15 1721 fam = AF_UNIX;
aba5acdf
SH		 1722 goto out;
1723 }
1724
1527a17e 1725 if (fam == AF_PACKET || strncmp(addr, "link:", 5) == 0) {
aba5acdf
SH		 1726 a.addr.family = AF_PACKET;
1727 a.addr.bitlen = 0;
1728 if (strncmp(addr, "link:", 5) == 0)
acd1e437 1729 addr += 5;
aba5acdf
SH		 1730 port = strchr(addr, ':');
1731 if (port) {
1732 *port = 0;
1733 if (port[1] && strcmp(port+1, "*")) {
1734 if (get_integer(&a.port, port+1, 0)) {
1735 if ((a.port = xll_name_to_index(port+1)) <= 0)
1736 return NULL;
1737 }
1738 }
1739 }
1740 if (addr[0] && strcmp(addr, "*")) {
1741 unsigned short tmp;
acd1e437 1742
aba5acdf
SH		 1743 a.addr.bitlen = 32;
1744 if (ll_proto_a2n(&tmp, addr))
1745 return NULL;
1746 a.addr.data[0] = ntohs(tmp);
1747 }
9db7bf15 1748 fam = AF_PACKET;
aba5acdf
SH		 1749 goto out;
1750 }
1751
1527a17e 1752 if (fam == AF_NETLINK || strncmp(addr, "netlink:", 8) == 0) {
aba5acdf
SH		 1753 a.addr.family = AF_NETLINK;
1754 a.addr.bitlen = 0;
1755 if (strncmp(addr, "netlink:", 8) == 0)
acd1e437 1756 addr += 8;
aba5acdf
SH		 1757 port = strchr(addr, ':');
1758 if (port) {
1759 *port = 0;
1760 if (port[1] && strcmp(port+1, "*")) {
1761 if (get_integer(&a.port, port+1, 0)) {
1762 if (strcmp(port+1, "kernel") == 0)
1763 a.port = 0;
1764 else
1765 return NULL;
1766 }
1767 }
1768 }
1769 if (addr[0] && strcmp(addr, "*")) {
1770 a.addr.bitlen = 32;
b00daf6a 1771 if (nl_proto_a2n(&a.addr.data[0], addr) == -1)
1772 return NULL;
aba5acdf 1773 }
9db7bf15 1774 fam = AF_NETLINK;
aba5acdf
SH		 1775 goto out;
1776 }
1777
c759116a
SH		 1778 if (fam == AF_VSOCK || strncmp(addr, "vsock:", 6) == 0) {
1779 __u32 cid = ~(__u32)0;
1780
1781 a.addr.family = AF_VSOCK;
1782 if (strncmp(addr, "vsock:", 6) == 0)
1783 addr += 6;
1784
1785 if (is_port)
1786 port = addr;
1787 else {
1788 port = strchr(addr, ':');
1789 if (port) {
1790 *port = '\0';
1791 port++;
1792 }
1793 }
1794
1795 if (port && strcmp(port, "*") &&
1796 get_u32((__u32 *)&a.port, port, 0))
1797 return NULL;
1798
1799 if (addr[0] && strcmp(addr, "*")) {
1800 a.addr.bitlen = 32;
1801 if (get_u32(&cid, addr, 0))
1802 return NULL;
1803 }
1804 vsock_set_inet_prefix(&a.addr, cid);
1805 fam = AF_VSOCK;
1806 goto out;
1807 }
1808
1527a17e 1809 if (fam == AF_INET || !strncmp(addr, "inet:", 5)) {
aba5acdf 1810 fam = AF_INET;
1527a17e
VK		 1811 if (!strncmp(addr, "inet:", 5))
1812 addr += 5;
1813 } else if (fam == AF_INET6 || !strncmp(addr, "inet6:", 6)) {
aba5acdf 1814 fam = AF_INET6;
1527a17e
VK		 1815 if (!strncmp(addr, "inet6:", 6))
1816 addr += 6;
aba5acdf
SH		 1817 }
1818
1819 /* URL-like literal [] */
1820 if (addr[0] == '[') {
1821 addr++;
1822 if ((port = strchr(addr, ']')) == NULL)
1823 return NULL;
1824 *port++ = 0;
1825 } else if (addr[0] == '*') {
1826 port = addr+1;
1827 } else {
1828 port = strrchr(strchr(addr, '/') ? : addr, ':');
1829 }
7871f7db
VK		 1830
1831 if (is_port)
1832 port = addr;
1833
aba5acdf 1834 if (port && *port) {
7871f7db
VK		 1835 if (*port == ':')
1836 *port++ = 0;
1837
aba5acdf
SH		 1838 if (*port && *port != '*') {
1839 if (get_integer(&a.port, port, 0)) {
1840 struct servent *se1 = NULL;
1841 struct servent *se2 = NULL;
acd1e437 1842
aba5acdf
SH		 1843 if (current_filter.dbs&(1<<UDP_DB))
1844 se1 = getservbyname(port, UDP_PROTO);
1845 if (current_filter.dbs&(1<<TCP_DB))
1846 se2 = getservbyname(port, TCP_PROTO);
1847 if (se1 && se2 && se1->s_port != se2->s_port) {
1848 fprintf(stderr, "Error: ambiguous port \"%s\".\n", port);
1849 return NULL;
1850 }
1851 if (!se1)
1852 se1 = se2;
1853 if (se1) {
1854 a.port = ntohs(se1->s_port);
1855 } else {
1856 struct scache *s;
acd1e437 1857
aba5acdf
SH		 1858 for (s = rlist; s; s = s->next) {
1859 if ((s->proto == UDP_PROTO &&
1860 (current_filter.dbs&(1<<UDP_DB))) ||
1861 (s->proto == TCP_PROTO &&
1862 (current_filter.dbs&(1<<TCP_DB)))) {
1863 if (s->name && strcmp(s->name, port) == 0) {
1864 if (a.port > 0 && a.port != s->port) {
1865 fprintf(stderr, "Error: ambiguous port \"%s\".\n", port);
1866 return NULL;
1867 }
1868 a.port = s->port;
1869 }
1870 }
1871 }
1872 if (a.port <= 0) {
1873 fprintf(stderr, "Error: \"%s\" does not look like a port.\n", port);
1874 return NULL;
1875 }
1876 }
1877 }
1878 }
1879 }
44448a90 1880 if (!is_port && *addr && *addr != '*') {
aba5acdf
SH		 1881 if (get_prefix_1(&a.addr, addr, fam)) {
1882 if (get_dns_host(&a, addr, fam)) {
1883 fprintf(stderr, "Error: an inet prefix is expected rather than \"%s\".\n", addr);
1884 return NULL;
1885 }
1886 }
1887 }
1888
9db7bf15 1889out:
1527a17e 1890 if (fam != AF_UNSPEC) {
e56a959e 1891 int states = f->states;
1527a17e 1892 f->families = 0;
9db7bf15 1893 filter_af_set(f, fam);
e56a959e 1894 filter_states_set(f, states);
1527a17e 1895 }
9db7bf15 1896
aba5acdf
SH		 1897 res = malloc(sizeof(*res));
1898 if (res)
1899 memcpy(res, &a, sizeof(a));
1900 return res;
1901}
1902
ec75249b
LC		 1903void *parse_markmask(const char *markmask)
1904{
1905 struct aafilter a, *res;
1906
1907 if (strchr(markmask, '/')) {
1908 if (sscanf(markmask, "%i/%i", &a.mark, &a.mask) != 2)
1909 return NULL;
1910 } else {
1911 a.mask = 0xffffffff;
1912 if (sscanf(markmask, "%i", &a.mark) != 1)
1913 return NULL;
1914 }
1915
1916 res = malloc(sizeof(*res));
1917 if (res)
1918 memcpy(res, &a, sizeof(a));
1919 return res;
1920}
1921
5f27ac1d 1922static void proc_ctx_print(struct sockstat *s)
8250bc9f 1923{
5f27ac1d 1924 char *buf;
8250bc9f 1925
8250bc9f
VK		 1926 if (show_proc_ctx || show_sock_ctx) {
1927 if (find_entry(s->ino, &buf,
1928 (show_proc_ctx & show_sock_ctx) ?
1929 PROC_SOCK_CTX : PROC_CTX) > 0) {
90351722 1930 out(" users:(%s)", buf);
8250bc9f
VK		 1931 free(buf);
1932 }
1933 } else if (show_users) {
1934 if (find_entry(s->ino, &buf, USERS) > 0) {
90351722 1935 out(" users:(%s)", buf);
8250bc9f
VK		 1936 free(buf);
1937 }
1938 }
1939}
1940
1267c0b9 1941static void inet_stats_print(struct sockstat *s, bool v6only)
5f27ac1d
PS		 1942{
1943 sock_state_print(s);
1944
1267c0b9
PS		 1945 inet_addr_print(&s->local, s->lport, s->iface, v6only);
1946 inet_addr_print(&s->remote, s->rport, 0, v6only);
5f27ac1d
PS		 1947
1948 proc_ctx_print(s);
1949}
1950
055840f2 1951static int proc_parse_inet_addr(char *loc, char *rem, int family, struct
acd1e437 1952 sockstat * s)
8250bc9f
VK		 1953{
1954 s->local.family = s->remote.family = family;
1955 if (family == AF_INET) {
acd1e437
SH		 1956 sscanf(loc, "%x:%x", s->local.data, (unsigned *)&s->lport);
1957 sscanf(rem, "%x:%x", s->remote.data, (unsigned *)&s->rport);
8250bc9f
VK		 1958 s->local.bytelen = s->remote.bytelen = 4;
1959 return 0;
1960 } else {
1961 sscanf(loc, "%08x%08x%08x%08x:%x",
1962 s->local.data,
1963 s->local.data + 1,
1964 s->local.data + 2,
1965 s->local.data + 3,
1966 &s->lport);
1967 sscanf(rem, "%08x%08x%08x%08x:%x",
1968 s->remote.data,
1969 s->remote.data + 1,
1970 s->remote.data + 2,
1971 s->remote.data + 3,
1972 &s->rport);
1973 s->local.bytelen = s->remote.bytelen = 16;
1974 return 0;
1975 }
1976 return -1;
1977}
1978
1979static int proc_inet_split_line(char *line, char **loc, char **rem, char **data)
aba5acdf 1980{
aba5acdf 1981 char *p;
ae665a52 1982
aba5acdf
SH		 1983 if ((p = strchr(line, ':')) == NULL)
1984 return -1;
ae665a52 1985
8250bc9f
VK		 1986 *loc = p+2;
1987 if ((p = strchr(*loc, ':')) == NULL)
aba5acdf 1988 return -1;
ae665a52 1989
8250bc9f
VK		 1990 p[5] = 0;
1991 *rem = p+6;
1992 if ((p = strchr(*rem, ':')) == NULL)
aba5acdf 1993 return -1;
8250bc9f 1994
aba5acdf 1995 p[5] = 0;
8250bc9f
VK		 1996 *data = p+6;
1997 return 0;
1998}
ae665a52 1999
8250bc9f
VK		 2000static char *sprint_bw(char *buf, double bw)
2001{
2002 if (bw > 1000000.)
acd1e437 2003 sprintf(buf, "%.1fM", bw / 1000000.);
8250bc9f 2004 else if (bw > 1000.)
acd1e437 2005 sprintf(buf, "%.1fK", bw / 1000.);
8250bc9f
VK		 2006 else
2007 sprintf(buf, "%g", bw);
aba5acdf 2008
8250bc9f
VK		 2009 return buf;
2010}
ae665a52 2011
f89d46ad
PS		 2012static void sctp_stats_print(struct sctp_info *s)
2013{
2014 if (s->sctpi_tag)
90351722 2015 out(" tag:%x", s->sctpi_tag);
f89d46ad 2016 if (s->sctpi_state)
90351722 2017 out(" state:%s", sctp_sstate_name[s->sctpi_state]);
f89d46ad 2018 if (s->sctpi_rwnd)
90351722 2019 out(" rwnd:%d", s->sctpi_rwnd);
f89d46ad 2020 if (s->sctpi_unackdata)
90351722 2021 out(" unackdata:%d", s->sctpi_unackdata);
f89d46ad 2022 if (s->sctpi_penddata)
90351722 2023 out(" penddata:%d", s->sctpi_penddata);
f89d46ad 2024 if (s->sctpi_instrms)
90351722 2025 out(" instrms:%d", s->sctpi_instrms);
f89d46ad 2026 if (s->sctpi_outstrms)
90351722 2027 out(" outstrms:%d", s->sctpi_outstrms);
f89d46ad 2028 if (s->sctpi_inqueue)
90351722 2029 out(" inqueue:%d", s->sctpi_inqueue);
f89d46ad 2030 if (s->sctpi_outqueue)
90351722 2031 out(" outqueue:%d", s->sctpi_outqueue);
f89d46ad 2032 if (s->sctpi_overall_error)
90351722 2033 out(" overerr:%d", s->sctpi_overall_error);
f89d46ad 2034 if (s->sctpi_max_burst)
90351722 2035 out(" maxburst:%d", s->sctpi_max_burst);
f89d46ad 2036 if (s->sctpi_maxseg)
90351722 2037 out(" maxseg:%d", s->sctpi_maxseg);
f89d46ad 2038 if (s->sctpi_peer_rwnd)
90351722 2039 out(" prwnd:%d", s->sctpi_peer_rwnd);
f89d46ad 2040 if (s->sctpi_peer_tag)
90351722 2041 out(" ptag:%x", s->sctpi_peer_tag);
f89d46ad 2042 if (s->sctpi_peer_capable)
90351722 2043 out(" pcapable:%d", s->sctpi_peer_capable);
f89d46ad 2044 if (s->sctpi_peer_sack)
90351722 2045 out(" psack:%d", s->sctpi_peer_sack);
f89d46ad 2046 if (s->sctpi_s_autoclose)
90351722 2047 out(" autoclose:%d", s->sctpi_s_autoclose);
f89d46ad 2048 if (s->sctpi_s_adaptation_ind)
90351722 2049 out(" adapind:%d", s->sctpi_s_adaptation_ind);
f89d46ad 2050 if (s->sctpi_s_pd_point)
90351722 2051 out(" pdpoint:%d", s->sctpi_s_pd_point);
f89d46ad 2052 if (s->sctpi_s_nodelay)
90351722 2053 out(" nodealy:%d", s->sctpi_s_nodelay);
f89d46ad 2054 if (s->sctpi_s_disable_fragments)
90351722 2055 out(" nofrag:%d", s->sctpi_s_disable_fragments);
f89d46ad 2056 if (s->sctpi_s_v4mapped)
90351722 2057 out(" v4mapped:%d", s->sctpi_s_v4mapped);
f89d46ad 2058 if (s->sctpi_s_frag_interleave)
90351722 2059 out(" fraginl:%d", s->sctpi_s_frag_interleave);
f89d46ad
PS		 2060}
2061
8250bc9f
VK		 2062static void tcp_stats_print(struct tcpstat *s)
2063{
2064 char b1[64];
2065
2066 if (s->has_ts_opt)
90351722 2067 out(" ts");
8250bc9f 2068 if (s->has_sack_opt)
90351722 2069 out(" sack");
8250bc9f 2070 if (s->has_ecn_opt)
90351722 2071 out(" ecn");
8250bc9f 2072 if (s->has_ecnseen_opt)
90351722 2073 out(" ecnseen");
8250bc9f 2074 if (s->has_fastopen_opt)
90351722 2075 out(" fastopen");
d2055ea5 2076 if (s->cong_alg[0])
90351722 2077 out(" %s", s->cong_alg);
8250bc9f 2078 if (s->has_wscale_opt)
90351722 2079 out(" wscale:%d,%d", s->snd_wscale, s->rcv_wscale);
8250bc9f 2080 if (s->rto)
90351722 2081 out(" rto:%g", s->rto);
8250bc9f 2082 if (s->backoff)
90351722 2083 out(" backoff:%u", s->backoff);
8250bc9f 2084 if (s->rtt)
90351722 2085 out(" rtt:%g/%g", s->rtt, s->rttvar);
8250bc9f 2086 if (s->ato)
90351722 2087 out(" ato:%g", s->ato);
8250bc9f
VK		 2088
2089 if (s->qack)
90351722 2090 out(" qack:%d", s->qack);
8250bc9f 2091 if (s->qack & 1)
90351722 2092 out(" bidir");
8250bc9f
VK		 2093
2094 if (s->mss)
90351722 2095 out(" mss:%d", s->mss);
38e6dbc4 2096 if (s->rcv_mss)
90351722 2097 out(" rcvmss:%d", s->rcv_mss);
38e6dbc4 2098 if (s->advmss)
90351722 2099 out(" advmss:%d", s->advmss);
3bf5445c 2100 if (s->cwnd)
90351722 2101 out(" cwnd:%u", s->cwnd);
8250bc9f 2102 if (s->ssthresh)
90351722 2103 out(" ssthresh:%d", s->ssthresh);
8250bc9f 2104
1a4dda71 2105 if (s->bytes_acked)
90351722 2106 out(" bytes_acked:%llu", s->bytes_acked);
1a4dda71 2107 if (s->bytes_received)
90351722 2108 out(" bytes_received:%llu", s->bytes_received);
ecb435ea 2109 if (s->segs_out)
90351722 2110 out(" segs_out:%u", s->segs_out);
ecb435ea 2111 if (s->segs_in)
90351722 2112 out(" segs_in:%u", s->segs_in);
414aeec9 2113 if (s->data_segs_out)
90351722 2114 out(" data_segs_out:%u", s->data_segs_out);
414aeec9 2115 if (s->data_segs_in)
90351722 2116 out(" data_segs_in:%u", s->data_segs_in);
1a4dda71 2117
8250bc9f
VK		 2118 if (s->dctcp && s->dctcp->enabled) {
2119 struct dctcpstat *dctcp = s->dctcp;
2120
90351722
SB		 2121 out(" dctcp:(ce_state:%u,alpha:%u,ab_ecn:%u,ab_tot:%u)",
2122 dctcp->ce_state, dctcp->alpha, dctcp->ab_ecn,
2123 dctcp->ab_tot);
8250bc9f 2124 } else if (s->dctcp) {
90351722 2125 out(" dctcp:fallback_mode");
8250bc9f
VK		 2126 }
2127
2f0f9aef
NC		 2128 if (s->bbr_info) {
2129 __u64 bw;
2130
2131 bw = s->bbr_info->bbr_bw_hi;
2132 bw <<= 32;
2133 bw |= s->bbr_info->bbr_bw_lo;
2134
90351722
SB		 2135 out(" bbr:(bw:%sbps,mrtt:%g",
2136 sprint_bw(b1, bw * 8.0),
2137 (double)s->bbr_info->bbr_min_rtt / 1000.0);
2f0f9aef 2138 if (s->bbr_info->bbr_pacing_gain)
90351722
SB		 2139 out(",pacing_gain:%g",
2140 (double)s->bbr_info->bbr_pacing_gain / 256.0);
2f0f9aef 2141 if (s->bbr_info->bbr_cwnd_gain)
90351722
SB		 2142 out(",cwnd_gain:%g",
2143 (double)s->bbr_info->bbr_cwnd_gain / 256.0);
2144 out(")");
2f0f9aef
NC		 2145 }
2146
8250bc9f 2147 if (s->send_bps)
90351722 2148 out(" send %sbps", sprint_bw(b1, s->send_bps));
8250bc9f 2149 if (s->lastsnd)
90351722 2150 out(" lastsnd:%u", s->lastsnd);
8250bc9f 2151 if (s->lastrcv)
90351722 2152 out(" lastrcv:%u", s->lastrcv);
8250bc9f 2153 if (s->lastack)
90351722 2154 out(" lastack:%u", s->lastack);
8250bc9f
VK		 2155
2156 if (s->pacing_rate) {
90351722 2157 out(" pacing_rate %sbps", sprint_bw(b1, s->pacing_rate));
8250bc9f 2158 if (s->pacing_rate_max)
90351722 2159 out("/%sbps", sprint_bw(b1, s->pacing_rate_max));
8250bc9f
VK		 2160 }
2161
2f579872 2162 if (s->delivery_rate)
90351722 2163 out(" delivery_rate %sbps", sprint_bw(b1, s->delivery_rate));
2f579872 2164 if (s->app_limited)
90351722 2165 out(" app_limited");
2f579872 2166
b6c7fc61 2167 if (s->busy_time) {
90351722 2168 out(" busy:%llums", s->busy_time / 1000);
b6c7fc61 2169 if (s->rwnd_limited)
90351722
SB		 2170 out(" rwnd_limited:%llums(%.1f%%)",
2171 s->rwnd_limited / 1000,
2172 100.0 * s->rwnd_limited / s->busy_time);
b6c7fc61 2173 if (s->sndbuf_limited)
90351722
SB		 2174 out(" sndbuf_limited:%llums(%.1f%%)",
2175 s->sndbuf_limited / 1000,
2176 100.0 * s->sndbuf_limited / s->busy_time);
b6c7fc61
YC		 2177 }
2178
8250bc9f 2179 if (s->unacked)
90351722 2180 out(" unacked:%u", s->unacked);
8250bc9f 2181 if (s->retrans || s->retrans_total)
90351722 2182 out(" retrans:%u/%u", s->retrans, s->retrans_total);
8250bc9f 2183 if (s->lost)
90351722 2184 out(" lost:%u", s->lost);
055840f2 2185 if (s->sacked && s->ss.state != SS_LISTEN)
90351722 2186 out(" sacked:%u", s->sacked);
8250bc9f 2187 if (s->fackets)
90351722 2188 out(" fackets:%u", s->fackets);
8250bc9f 2189 if (s->reordering != 3)
90351722 2190 out(" reordering:%d", s->reordering);
8250bc9f 2191 if (s->rcv_rtt)
90351722 2192 out(" rcv_rtt:%g", s->rcv_rtt);
8250bc9f 2193 if (s->rcv_space)
90351722 2194 out(" rcv_space:%d", s->rcv_space);
00ac78d3 2195 if (s->rcv_ssthresh)
90351722 2196 out(" rcv_ssthresh:%u", s->rcv_ssthresh);
9e99e495 2197 if (s->not_sent)
90351722 2198 out(" notsent:%u", s->not_sent);
9e99e495 2199 if (s->min_rtt)
90351722 2200 out(" minrtt:%g", s->min_rtt);
8250bc9f
VK		 2201}
2202
055840f2
VK		 2203static void tcp_timer_print(struct tcpstat *s)
2204{
86dfa1be
PS		 2205 static const char * const tmr_name[] = {
2206 "off",
2207 "on",
2208 "keepalive",
2209 "timewait",
2210 "persist",
2211 "unknown"
2212 };
2213
055840f2
VK		 2214 if (s->timer) {
2215 if (s->timer > 4)
2216 s->timer = 5;
90351722
SB		 2217 out(" timer:(%s,%s,%d)",
2218 tmr_name[s->timer],
2219 print_ms_timer(s->timeout),
2220 s->retrans);
055840f2
VK		 2221 }
2222}
2223
f89d46ad
PS		 2224static void sctp_timer_print(struct tcpstat *s)
2225{
2226 if (s->timer)
90351722
SB		 2227 out(" timer:(T3_RTX,%s,%d)",
2228 print_ms_timer(s->timeout), s->retrans);
f89d46ad
PS		 2229}
2230
8250bc9f
VK		 2231static int tcp_show_line(char *line, const struct filter *f, int family)
2232{
2233 int rto = 0, ato = 0;
2234 struct tcpstat s = {};
2235 char *loc, *rem, *data;
2236 char opt[256];
2237 int n;
2238 int hz = get_user_hz();
2239
2240 if (proc_inet_split_line(line, &loc, &rem, &data))
2241 return -1;
2242
2243 int state = (data[1] >= 'A') ? (data[1] - 'A' + 10) : (data[1] - '0');
acd1e437 2244
8250bc9f
VK		 2245 if (!(f->states & (1 << state)))
2246 return 0;
2247
055840f2 2248 proc_parse_inet_addr(loc, rem, family, &s.ss);
ae665a52 2249
055840f2 2250 if (f->f && run_ssfilter(f->f, &s.ss) == 0)
aba5acdf 2251 return 0;
ae665a52 2252
aba5acdf 2253 opt[0] = 0;
d1f338b3 2254 n = sscanf(data, "%x %x:%x %x:%x %x %d %d %u %d %llx %d %d %d %u %d %[^\n]\n",
055840f2
VK		 2255 &s.ss.state, &s.ss.wq, &s.ss.rq,
2256 &s.timer, &s.timeout, &s.retrans, &s.ss.uid, &s.probes,
2257 &s.ss.ino, &s.ss.refcnt, &s.ss.sk, &rto, &ato, &s.qack, &s.cwnd,
2258 &s.ssthresh, opt);
ae665a52 2259
aba5acdf
SH		 2260 if (n < 17)
2261 opt[0] = 0;
ae665a52 2262
aba5acdf 2263 if (n < 12) {
8250bc9f 2264 rto = 0;
aba5acdf
SH		 2265 s.cwnd = 2;
2266 s.ssthresh = -1;
8250bc9f 2267 ato = s.qack = 0;
aba5acdf 2268 }
ae665a52 2269
8250bc9f
VK		 2270 s.retrans = s.timer != 1 ? s.probes : s.retrans;
2271 s.timeout = (s.timeout * 1000 + hz - 1) / hz;
2272 s.ato = (double)ato / hz;
2273 s.qack /= 2;
2274 s.rto = (double)rto;
2275 s.ssthresh = s.ssthresh == -1 ? 0 : s.ssthresh;
2276 s.rto = s.rto != 3 * hz ? s.rto / hz : 0;
be7e4d20 2277 s.ss.type = IPPROTO_TCP;
ae665a52 2278
1267c0b9 2279 inet_stats_print(&s.ss, false);
055840f2
VK		 2280
2281 if (show_options)
2282 tcp_timer_print(&s);
116ac927 2283
aba5acdf 2284 if (show_details) {
f1b39e1b 2285 sock_details_print(&s.ss);
aba5acdf 2286 if (opt[0])
90351722 2287 out(" opt:\"%s\"", opt);
aba5acdf 2288 }
aba5acdf 2289
8250bc9f
VK		 2290 if (show_tcpinfo)
2291 tcp_stats_print(&s);
2292
aba5acdf
SH		 2293 return 0;
2294}
2295
ab01dbbb
SH		 2296static int generic_record_read(FILE *fp,
2297 int (*worker)(char*, const struct filter *, int),
2298 const struct filter *f, int fam)
aba5acdf 2299{
ab01dbbb 2300 char line[256];
aba5acdf 2301
ab01dbbb
SH		 2302 /* skip header */
2303 if (fgets(line, sizeof(line), fp) == NULL)
aba5acdf 2304 goto outerr;
ab01dbbb
SH		 2305
2306 while (fgets(line, sizeof(line), fp) != NULL) {
2307 int n = strlen(line);
acd1e437 2308
ab01dbbb
SH		 2309 if (n == 0 || line[n-1] != '\n') {
2310 errno = -EINVAL;
2311 return -1;
aba5acdf 2312 }
ab01dbbb 2313 line[n-1] = 0;
aba5acdf 2314
ab01dbbb
SH		 2315 if (worker(line, f, fam) < 0)
2316 return 0;
2317 }
aba5acdf 2318outerr:
ab01dbbb
SH		 2319
2320 return ferror(fp) ? -1 : 0;
aba5acdf 2321}
ae665a52 2322
51ff9f24
HFS		 2323static void print_skmeminfo(struct rtattr *tb[], int attrtype)
2324{
2325 const __u32 *skmeminfo;
db08bdb8
VK		 2326
2327 if (!tb[attrtype]) {
2328 if (attrtype == INET_DIAG_SKMEMINFO) {
2329 if (!tb[INET_DIAG_MEMINFO])
2330 return;
2331
2332 const struct inet_diag_meminfo *minfo =
2333 RTA_DATA(tb[INET_DIAG_MEMINFO]);
2334
90351722
SB		 2335 out(" mem:(r%u,w%u,f%u,t%u)",
2336 minfo->idiag_rmem,
2337 minfo->idiag_wmem,
2338 minfo->idiag_fmem,
2339 minfo->idiag_tmem);
db08bdb8 2340 }
51ff9f24 2341 return;
db08bdb8
VK		 2342 }
2343
51ff9f24
HFS		 2344 skmeminfo = RTA_DATA(tb[attrtype]);
2345
90351722
SB		 2346 out(" skmem:(r%u,rb%u,t%u,tb%u,f%u,w%u,o%u",
2347 skmeminfo[SK_MEMINFO_RMEM_ALLOC],
2348 skmeminfo[SK_MEMINFO_RCVBUF],
2349 skmeminfo[SK_MEMINFO_WMEM_ALLOC],
2350 skmeminfo[SK_MEMINFO_SNDBUF],
2351 skmeminfo[SK_MEMINFO_FWD_ALLOC],
2352 skmeminfo[SK_MEMINFO_WMEM_QUEUED],
2353 skmeminfo[SK_MEMINFO_OPTMEM]);
51ff9f24
HFS		 2354
2355 if (RTA_PAYLOAD(tb[attrtype]) >=
2356 (SK_MEMINFO_BACKLOG + 1) * sizeof(__u32))
90351722 2357 out(",bl%u", skmeminfo[SK_MEMINFO_BACKLOG]);
51ff9f24 2358
6df9c7a0
ED		 2359 if (RTA_PAYLOAD(tb[attrtype]) >=
2360 (SK_MEMINFO_DROPS + 1) * sizeof(__u32))
90351722 2361 out(",d%u", skmeminfo[SK_MEMINFO_DROPS]);
6df9c7a0 2362
90351722 2363 out(")");
51ff9f24
HFS		 2364}
2365
da9cc6ab
ID		 2366static void print_md5sig(struct tcp_diag_md5sig *sig)
2367{
90351722
SB		 2368 out("%s/%d=",
2369 format_host(sig->tcpm_family,
2370 sig->tcpm_family == AF_INET6 ? 16 : 4,
2371 &sig->tcpm_addr),
2372 sig->tcpm_prefixlen);
da9cc6ab
ID		 2373 print_escape_buf(sig->tcpm_key, sig->tcpm_keylen, " ,");
2374}
2375
8250bc9f
VK		 2376#define TCPI_HAS_OPT(info, opt) !!(info->tcpi_options & (opt))
2377
5b816047
PE		 2378static void tcp_show_info(const struct nlmsghdr *nlh, struct inet_diag_msg *r,
2379 struct rtattr *tb[])
7d105b56 2380{
b4b0b7d5 2381 double rtt = 0;
8250bc9f 2382 struct tcpstat s = {};
7d105b56 2383
055840f2
VK		 2384 s.ss.state = r->idiag_state;
2385
db08bdb8 2386 print_skmeminfo(tb, INET_DIAG_SKMEMINFO);
7d105b56 2387
351efcde 2388 if (tb[INET_DIAG_INFO]) {
05e18118 2389 struct tcp_info *info;
351efcde 2390 int len = RTA_PAYLOAD(tb[INET_DIAG_INFO]);
05e18118
SH		 2391
2392 /* workaround for older kernels with less fields */
2393 if (len < sizeof(*info)) {
2394 info = alloca(sizeof(*info));
351efcde 2395 memcpy(info, RTA_DATA(tb[INET_DIAG_INFO]), len);
656e8fdd 2396 memset((char *)info + len, 0, sizeof(*info) - len);
05e18118 2397 } else
351efcde 2398 info = RTA_DATA(tb[INET_DIAG_INFO]);
05e18118 2399
b4b0b7d5 2400 if (show_options) {
8250bc9f
VK		 2401 s.has_ts_opt = TCPI_HAS_OPT(info, TCPI_OPT_TIMESTAMPS);
2402 s.has_sack_opt = TCPI_HAS_OPT(info, TCPI_OPT_SACK);
2403 s.has_ecn_opt = TCPI_HAS_OPT(info, TCPI_OPT_ECN);
2404 s.has_ecnseen_opt = TCPI_HAS_OPT(info, TCPI_OPT_ECN_SEEN);
2405 s.has_fastopen_opt = TCPI_HAS_OPT(info, TCPI_OPT_SYN_DATA);
b4b0b7d5 2406 }
52d5ac3f 2407
d2055ea5
ED		 2408 if (tb[INET_DIAG_CONG])
2409 strncpy(s.cong_alg,
2410 rta_getattr_str(tb[INET_DIAG_CONG]),
2411 sizeof(s.cong_alg) - 1);
8250bc9f
VK		 2412
2413 if (TCPI_HAS_OPT(info, TCPI_OPT_WSCALE)) {
2414 s.has_wscale_opt = true;
2415 s.snd_wscale = info->tcpi_snd_wscale;
2416 s.rcv_wscale = info->tcpi_rcv_wscale;
2417 }
ea8fc104 2418
7d105b56 2419 if (info->tcpi_rto && info->tcpi_rto != 3000000)
8250bc9f
VK		 2420 s.rto = (double)info->tcpi_rto / 1000;
2421
2422 s.backoff = info->tcpi_backoff;
2423 s.rtt = (double)info->tcpi_rtt / 1000;
2424 s.rttvar = (double)info->tcpi_rttvar / 1000;
11ba90fc 2425 s.ato = (double)info->tcpi_ato / 1000;
8250bc9f 2426 s.mss = info->tcpi_snd_mss;
38e6dbc4
ED		 2427 s.rcv_mss = info->tcpi_rcv_mss;
2428 s.advmss = info->tcpi_advmss;
8250bc9f
VK		 2429 s.rcv_space = info->tcpi_rcv_space;
2430 s.rcv_rtt = (double)info->tcpi_rcv_rtt / 1000;
2431 s.lastsnd = info->tcpi_last_data_sent;
2432 s.lastrcv = info->tcpi_last_data_recv;
2433 s.lastack = info->tcpi_last_ack_recv;
2434 s.unacked = info->tcpi_unacked;
2435 s.retrans = info->tcpi_retrans;
2436 s.retrans_total = info->tcpi_total_retrans;
2437 s.lost = info->tcpi_lost;
2438 s.sacked = info->tcpi_sacked;
c4be5feb 2439 s.fackets = info->tcpi_fackets;
8250bc9f 2440 s.reordering = info->tcpi_reordering;
00ac78d3 2441 s.rcv_ssthresh = info->tcpi_rcv_ssthresh;
8250bc9f
VK		 2442 s.cwnd = info->tcpi_snd_cwnd;
2443
7d105b56 2444 if (info->tcpi_snd_ssthresh < 0xFFFF)
8250bc9f 2445 s.ssthresh = info->tcpi_snd_ssthresh;
52d5ac3f 2446
b4b0b7d5 2447 rtt = (double) info->tcpi_rtt;
351efcde 2448 if (tb[INET_DIAG_VEGASINFO]) {
05e18118 2449 const struct tcpvegas_info *vinfo
351efcde 2450 = RTA_DATA(tb[INET_DIAG_VEGASINFO]);
7d105b56 2451
ae665a52 2452 if (vinfo->tcpv_enabled &&
8250bc9f 2453 vinfo->tcpv_rtt && vinfo->tcpv_rtt != 0x7fffffff)
ea8fc104 2454 rtt = vinfo->tcpv_rtt;
b4b0b7d5
SH		 2455 }
2456
907e1aca 2457 if (tb[INET_DIAG_DCTCPINFO]) {
8250bc9f
VK		 2458 struct dctcpstat *dctcp = malloc(sizeof(struct
2459 dctcpstat));
2460
907e1aca
DB		 2461 const struct tcp_dctcp_info *dinfo
2462 = RTA_DATA(tb[INET_DIAG_DCTCPINFO]);
2463
8250bc9f
VK		 2464 dctcp->enabled = !!dinfo->dctcp_enabled;
2465 dctcp->ce_state = dinfo->dctcp_ce_state;
2466 dctcp->alpha = dinfo->dctcp_alpha;
2467 dctcp->ab_ecn = dinfo->dctcp_ab_ecn;
2468 dctcp->ab_tot = dinfo->dctcp_ab_tot;
2469 s.dctcp = dctcp;
907e1aca
DB		 2470 }
2471
2f0f9aef
NC		 2472 if (tb[INET_DIAG_BBRINFO]) {
2473 const void *bbr_info = RTA_DATA(tb[INET_DIAG_BBRINFO]);
2474 int len = min(RTA_PAYLOAD(tb[INET_DIAG_BBRINFO]),
2475 sizeof(*s.bbr_info));
2476
2477 s.bbr_info = calloc(1, sizeof(*s.bbr_info));
2478 if (s.bbr_info && bbr_info)
2479 memcpy(s.bbr_info, bbr_info, len);
2480 }
2481
b4b0b7d5 2482 if (rtt > 0 && info->tcpi_snd_mss && info->tcpi_snd_cwnd) {
8250bc9f
VK		 2483 s.send_bps = (double) info->tcpi_snd_cwnd *
2484 (double)info->tcpi_snd_mss * 8000000. / rtt;
7d105b56 2485 }
b4b0b7d5 2486
eb6028b2 2487 if (info->tcpi_pacing_rate &&
8250bc9f
VK		 2488 info->tcpi_pacing_rate != ~0ULL) {
2489 s.pacing_rate = info->tcpi_pacing_rate * 8.;
eb6028b2
ED		 2490
2491 if (info->tcpi_max_pacing_rate &&
8250bc9f
VK		 2492 info->tcpi_max_pacing_rate != ~0ULL)
2493 s.pacing_rate_max = info->tcpi_max_pacing_rate * 8.;
eb6028b2 2494 }
1a4dda71
ED		 2495 s.bytes_acked = info->tcpi_bytes_acked;
2496 s.bytes_received = info->tcpi_bytes_received;
ecb435ea
CG		 2497 s.segs_out = info->tcpi_segs_out;
2498 s.segs_in = info->tcpi_segs_in;
414aeec9
MKL		 2499 s.data_segs_out = info->tcpi_data_segs_out;
2500 s.data_segs_in = info->tcpi_data_segs_in;
9e99e495 2501 s.not_sent = info->tcpi_notsent_bytes;
d9ba887e
ED		 2502 if (info->tcpi_min_rtt && info->tcpi_min_rtt != ~0U)
2503 s.min_rtt = (double) info->tcpi_min_rtt / 1000;
2f579872
NC		 2504 s.delivery_rate = info->tcpi_delivery_rate * 8.;
2505 s.app_limited = info->tcpi_delivery_rate_app_limited;
b6c7fc61
YC		 2506 s.busy_time = info->tcpi_busy_time;
2507 s.rwnd_limited = info->tcpi_rwnd_limited;
2508 s.sndbuf_limited = info->tcpi_sndbuf_limited;
8250bc9f 2509 tcp_stats_print(&s);
92de1c2c 2510 free(s.dctcp);
2f0f9aef 2511 free(s.bbr_info);
77a8ca81 2512 }
da9cc6ab
ID		 2513 if (tb[INET_DIAG_MD5SIG]) {
2514 struct tcp_diag_md5sig *sig = RTA_DATA(tb[INET_DIAG_MD5SIG]);
2515 int len = RTA_PAYLOAD(tb[INET_DIAG_MD5SIG]);
2516
90351722 2517 out(" md5keys:");
da9cc6ab
ID		 2518 print_md5sig(sig++);
2519 for (len -= sizeof(*sig); len > 0; len -= sizeof(*sig)) {
90351722 2520 out(",");
da9cc6ab
ID		 2521 print_md5sig(sig++);
2522 }
2523 }
77a8ca81
PE		 2524}
2525
f89d46ad
PS		 2526static const char *format_host_sa(struct sockaddr_storage *sa)
2527{
2528 union {
2529 struct sockaddr_in sin;
2530 struct sockaddr_in6 sin6;
2531 } *saddr = (void *)sa;
2532
2533 switch (sa->ss_family) {
2534 case AF_INET:
2535 return format_host(AF_INET, 4, &saddr->sin.sin_addr);
2536 case AF_INET6:
2537 return format_host(AF_INET6, 16, &saddr->sin6.sin6_addr);
2538 default:
2539 return "";
2540 }
2541}
2542
2543static void sctp_show_info(const struct nlmsghdr *nlh, struct inet_diag_msg *r,
2544 struct rtattr *tb[])
2545{
2546 struct sockaddr_storage *sa;
2547 int len;
2548
2549 print_skmeminfo(tb, INET_DIAG_SKMEMINFO);
2550
2551 if (tb[INET_DIAG_LOCALS]) {
2552 len = RTA_PAYLOAD(tb[INET_DIAG_LOCALS]);
2553 sa = RTA_DATA(tb[INET_DIAG_LOCALS]);
2554
90351722 2555 out("locals:%s", format_host_sa(sa));
f89d46ad 2556 for (sa++, len -= sizeof(*sa); len > 0; sa++, len -= sizeof(*sa))
90351722 2557 out(",%s", format_host_sa(sa));
f89d46ad
PS		 2558
2559 }
2560 if (tb[INET_DIAG_PEERS]) {
2561 len = RTA_PAYLOAD(tb[INET_DIAG_PEERS]);
2562 sa = RTA_DATA(tb[INET_DIAG_PEERS]);
2563
90351722 2564 out(" peers:%s", format_host_sa(sa));
f89d46ad 2565 for (sa++, len -= sizeof(*sa); len > 0; sa++, len -= sizeof(*sa))
90351722 2566 out(",%s", format_host_sa(sa));
f89d46ad
PS		 2567 }
2568 if (tb[INET_DIAG_INFO]) {
2569 struct sctp_info *info;
2570 len = RTA_PAYLOAD(tb[INET_DIAG_INFO]);
2571
2572 /* workaround for older kernels with less fields */
2573 if (len < sizeof(*info)) {
2574 info = alloca(sizeof(*info));
2575 memcpy(info, RTA_DATA(tb[INET_DIAG_INFO]), len);
2576 memset((char *)info + len, 0, sizeof(*info) - len);
2577 } else
2578 info = RTA_DATA(tb[INET_DIAG_INFO]);
2579
2580 sctp_stats_print(info);
2581 }
2582}
2583
82d73ea0 2584static void parse_diag_msg(struct nlmsghdr *nlh, struct sockstat *s)
aba5acdf 2585{
acd1e437 2586 struct rtattr *tb[INET_DIAG_MAX+1];
351efcde 2587 struct inet_diag_msg *r = NLMSG_DATA(nlh);
aba5acdf 2588
acd1e437 2589 parse_rtattr(tb, INET_DIAG_MAX, (struct rtattr *)(r+1),
5b816047
PE		 2590 nlh->nlmsg_len - NLMSG_LENGTH(sizeof(*r)));
2591
82d73ea0
DA		 2592 s->state = r->idiag_state;
2593 s->local.family = s->remote.family = r->idiag_family;
2594 s->lport = ntohs(r->id.idiag_sport);
2595 s->rport = ntohs(r->id.idiag_dport);
2596 s->wq = r->idiag_wqueue;
2597 s->rq = r->idiag_rqueue;
2598 s->ino = r->idiag_inode;
2599 s->uid = r->idiag_uid;
2600 s->iface = r->id.idiag_if;
2601 s->sk = cookie_sk_get(&r->id.idiag_cookie[0]);
2602
ec75249b
LC		 2603 s->mark = 0;
2604 if (tb[INET_DIAG_MARK])
9f1370c0 2605 s->mark = rta_getattr_u32(tb[INET_DIAG_MARK]);
41fe6c34 2606 if (tb[INET_DIAG_PROTOCOL])
9f1370c0 2607 s->raw_prot = rta_getattr_u8(tb[INET_DIAG_PROTOCOL]);
41fe6c34
CG		 2608 else
2609 s->raw_prot = 0;
ec75249b 2610
82d73ea0
DA		 2611 if (s->local.family == AF_INET)
2612 s->local.bytelen = s->remote.bytelen = 4;
2613 else
2614 s->local.bytelen = s->remote.bytelen = 16;
8250bc9f 2615
82d73ea0
DA		 2616 memcpy(s->local.data, r->id.idiag_src, s->local.bytelen);
2617 memcpy(s->remote.data, r->id.idiag_dst, s->local.bytelen);
2618}
aba5acdf 2619
82d73ea0 2620static int inet_show_sock(struct nlmsghdr *nlh,
be7e4d20 2621 struct sockstat *s)
82d73ea0
DA		 2622{
2623 struct rtattr *tb[INET_DIAG_MAX+1];
2624 struct inet_diag_msg *r = NLMSG_DATA(nlh);
1267c0b9 2625 unsigned char v6only = 0;
82d73ea0
DA		 2626
2627 parse_rtattr(tb, INET_DIAG_MAX, (struct rtattr *)(r+1),
2628 nlh->nlmsg_len - NLMSG_LENGTH(sizeof(*r)));
aba5acdf 2629
6885e3bf 2630 if (tb[INET_DIAG_PROTOCOL])
9f1370c0 2631 s->type = rta_getattr_u8(tb[INET_DIAG_PROTOCOL]);
6885e3bf 2632
1267c0b9
PS		 2633 if (s->local.family == AF_INET6 && tb[INET_DIAG_SKV6ONLY])
2634 v6only = rta_getattr_u8(tb[INET_DIAG_SKV6ONLY]);
2635
2636 inet_stats_print(s, v6only);
116ac927 2637
055840f2
VK		 2638 if (show_options) {
2639 struct tcpstat t = {};
2640
2641 t.timer = r->idiag_timer;
2642 t.timeout = r->idiag_expires;
2643 t.retrans = r->idiag_retrans;
be7e4d20 2644 if (s->type == IPPROTO_SCTP)
f89d46ad
PS		 2645 sctp_timer_print(&t);
2646 else
2647 tcp_timer_print(&t);
055840f2
VK		 2648 }
2649
aba5acdf 2650 if (show_details) {
82d73ea0 2651 sock_details_print(s);
1267c0b9 2652 if (s->local.family == AF_INET6 && tb[INET_DIAG_SKV6ONLY])
90351722 2653 out(" v6only:%u", v6only);
1267c0b9 2654
5b816047
PE		 2655 if (tb[INET_DIAG_SHUTDOWN]) {
2656 unsigned char mask;
acd1e437 2657
9f1370c0 2658 mask = rta_getattr_u8(tb[INET_DIAG_SHUTDOWN]);
90351722
SB		 2659 out(" %c-%c",
2660 mask & 1 ? '-' : '<', mask & 2 ? '-' : '>');
5b816047 2661 }
aba5acdf 2662 }
8250bc9f 2663
be7e4d20 2664 if (show_mem || (show_tcpinfo && s->type != IPPROTO_UDP)) {
90351722 2665 out("\n\t");
be7e4d20 2666 if (s->type == IPPROTO_SCTP)
f89d46ad
PS		 2667 sctp_show_info(nlh, r, tb);
2668 else
2669 tcp_show_info(nlh, r, tb);
aba5acdf 2670 }
f89d46ad 2671 sctp_ino = s->ino;
7d105b56 2672
aba5acdf 2673 return 0;
aba5acdf
SH		 2674}
2675
746a695f 2676static int tcpdiag_send(int fd, int protocol, struct filter *f)
aba5acdf 2677{
d17b136f 2678 struct sockaddr_nl nladdr = { .nl_family = AF_NETLINK };
aba5acdf
SH		 2679 struct {
2680 struct nlmsghdr nlh;
351efcde 2681 struct inet_diag_req r;
d17b136f
PS		 2682 } req = {
2683 .nlh.nlmsg_len = sizeof(req),
2684 .nlh.nlmsg_flags = NLM_F_ROOT | NLM_F_MATCH | NLM_F_REQUEST,
2685 .nlh.nlmsg_seq = MAGIC_SEQ,
2686 .r.idiag_family = AF_INET,
2687 .r.idiag_states = f->states,
2688 };
aba5acdf
SH		 2689 char *bc = NULL;
2690 int bclen;
2691 struct msghdr msg;
2692 struct rtattr rta;
aba5acdf 2693 struct iovec iov[3];
376fb868 2694 int iovlen = 1;
aba5acdf 2695
346f8ca8
PE		 2696 if (protocol == IPPROTO_UDP)
2697 return -1;
2698
3fe5b534
PE		 2699 if (protocol == IPPROTO_TCP)
2700 req.nlh.nlmsg_type = TCPDIAG_GETSOCK;
2701 else
2702 req.nlh.nlmsg_type = DCCPDIAG_GETSOCK;
910b0397 2703 if (show_mem) {
ae665a52 2704 req.r.idiag_ext |= (1<<(INET_DIAG_MEMINFO-1));
910b0397
SW		 2705 req.r.idiag_ext |= (1<<(INET_DIAG_SKMEMINFO-1));
2706 }
b4b0b7d5 2707
7d105b56 2708 if (show_tcpinfo) {
351efcde
SH		 2709 req.r.idiag_ext |= (1<<(INET_DIAG_INFO-1));
2710 req.r.idiag_ext |= (1<<(INET_DIAG_VEGASINFO-1));
2711 req.r.idiag_ext |= (1<<(INET_DIAG_CONG-1));
7d105b56 2712 }
aba5acdf 2713
ae665a52
SH		 2714 iov[0] = (struct iovec){
2715 .iov_base = &req,
2716 .iov_len = sizeof(req)
ea8fc104 2717 };
aba5acdf
SH		 2718 if (f->f) {
2719 bclen = ssfilter_bytecompile(f->f, &bc);
376fb868
DA		 2720 if (bclen) {
2721 rta.rta_type = INET_DIAG_REQ_BYTECODE;
2722 rta.rta_len = RTA_LENGTH(bclen);
2723 iov[1] = (struct iovec){ &rta, sizeof(rta) };
2724 iov[2] = (struct iovec){ bc, bclen };
2725 req.nlh.nlmsg_len += RTA_LENGTH(bclen);
2726 iovlen = 3;
2727 }
aba5acdf
SH		 2728 }
2729
2730 msg = (struct msghdr) {
acd1e437 2731 .msg_name = (void *)&nladdr,
ea8fc104 2732 .msg_namelen = sizeof(nladdr),
ae665a52 2733 .msg_iov = iov,
376fb868 2734 .msg_iovlen = iovlen,
aba5acdf
SH		 2735 };
2736
930a75f9
ED		 2737 if (sendmsg(fd, &msg, 0) < 0) {
2738 close(fd);
aba5acdf 2739 return -1;
930a75f9 2740 }
aba5acdf 2741
746a695f
PE		 2742 return 0;
2743}
2744
886d19d6
PE		 2745static int sockdiag_send(int family, int fd, int protocol, struct filter *f)
2746{
d17b136f 2747 struct sockaddr_nl nladdr = { .nl_family = AF_NETLINK };
5fb421d4 2748 DIAG_REQUEST(req, struct inet_diag_req_v2 r);
886d19d6
PE		 2749 char *bc = NULL;
2750 int bclen;
2751 struct msghdr msg;
2752 struct rtattr rta;
2753 struct iovec iov[3];
376fb868 2754 int iovlen = 1;
886d19d6
PE		 2755
2756 if (family == PF_UNSPEC)
2757 return tcpdiag_send(fd, protocol, f);
2758
886d19d6
PE		 2759 memset(&req.r, 0, sizeof(req.r));
2760 req.r.sdiag_family = family;
2761 req.r.sdiag_protocol = protocol;
2762 req.r.idiag_states = f->states;
2763 if (show_mem) {
2764 req.r.idiag_ext |= (1<<(INET_DIAG_MEMINFO-1));
2765 req.r.idiag_ext |= (1<<(INET_DIAG_SKMEMINFO-1));
2766 }
2767
2768 if (show_tcpinfo) {
2769 req.r.idiag_ext |= (1<<(INET_DIAG_INFO-1));
2770 req.r.idiag_ext |= (1<<(INET_DIAG_VEGASINFO-1));
2771 req.r.idiag_ext |= (1<<(INET_DIAG_CONG-1));
2772 }
2773
2774 iov[0] = (struct iovec){
2775 .iov_base = &req,
2776 .iov_len = sizeof(req)
2777 };
2778 if (f->f) {
2779 bclen = ssfilter_bytecompile(f->f, &bc);
376fb868
DA		 2780 if (bclen) {
2781 rta.rta_type = INET_DIAG_REQ_BYTECODE;
2782 rta.rta_len = RTA_LENGTH(bclen);
2783 iov[1] = (struct iovec){ &rta, sizeof(rta) };
2784 iov[2] = (struct iovec){ bc, bclen };
2785 req.nlh.nlmsg_len += RTA_LENGTH(bclen);
2786 iovlen = 3;
2787 }
886d19d6
PE		 2788 }
2789
2790 msg = (struct msghdr) {
acd1e437 2791 .msg_name = (void *)&nladdr,
886d19d6
PE		 2792 .msg_namelen = sizeof(nladdr),
2793 .msg_iov = iov,
376fb868 2794 .msg_iovlen = iovlen,
886d19d6
PE		 2795 };
2796
2797 if (sendmsg(fd, &msg, 0) < 0) {
2798 close(fd);
2799 return -1;
2800 }
2801
2802 return 0;
2803}
2804
486ccd99
VK		 2805struct inet_diag_arg {
2806 struct filter *f;
2807 int protocol;
fb2594c1 2808 struct rtnl_handle *rth;
486ccd99 2809};
aba5acdf 2810
41fe6c34 2811static int kill_inet_sock(struct nlmsghdr *h, void *arg, struct sockstat *s)
fb2594c1
LC		 2812{
2813 struct inet_diag_msg *d = NLMSG_DATA(h);
2814 struct inet_diag_arg *diag_arg = arg;
2815 struct rtnl_handle *rth = diag_arg->rth;
acd1e437 2816
fb2594c1
LC		 2817 DIAG_REQUEST(req, struct inet_diag_req_v2 r);
2818
2819 req.nlh.nlmsg_type = SOCK_DESTROY;
2820 req.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;
2821 req.nlh.nlmsg_seq = ++rth->seq;
2822 req.r.sdiag_family = d->idiag_family;
2823 req.r.sdiag_protocol = diag_arg->protocol;
2824 req.r.id = d->id;
2825
41fe6c34
CG		 2826 if (diag_arg->protocol == IPPROTO_RAW) {
2827 struct inet_diag_req_raw *raw = (void *)&req.r;
2828
2829 BUILD_BUG_ON(sizeof(req.r) != sizeof(*raw));
2830 raw->sdiag_raw_protocol = s->raw_prot;
2831 }
2832
86bf43c7 2833 return rtnl_talk(rth, &req.nlh, NULL);
fb2594c1
LC		 2834}
2835
486ccd99
VK		 2836static int show_one_inet_sock(const struct sockaddr_nl *addr,
2837 struct nlmsghdr *h, void *arg)
2838{
2839 int err;
2840 struct inet_diag_arg *diag_arg = arg;
2841 struct inet_diag_msg *r = NLMSG_DATA(h);
82d73ea0 2842 struct sockstat s = {};
aba5acdf 2843
b338a3e7 2844 if (!(diag_arg->f->families & FAMILY_MASK(r->idiag_family)))
486ccd99 2845 return 0;
82d73ea0
DA		 2846
2847 parse_diag_msg(h, &s);
be7e4d20 2848 s.type = diag_arg->protocol;
82d73ea0
DA		 2849
2850 if (diag_arg->f->f && run_ssfilter(diag_arg->f->f, &s) == 0)
2851 return 0;
2852
41fe6c34 2853 if (diag_arg->f->kill && kill_inet_sock(h, arg, &s) != 0) {
fb2594c1
LC		 2854 if (errno == EOPNOTSUPP || errno == ENOENT) {
2855 /* Socket can't be closed, or is already closed. */
2856 return 0;
2857 } else {
2858 perror("SOCK_DESTROY answers");
2859 return -1;
2860 }
2861 }
82d73ea0 2862
be7e4d20 2863 err = inet_show_sock(h, &s);
82d73ea0 2864 if (err < 0)
486ccd99 2865 return err;
aba5acdf 2866
486ccd99
VK		 2867 return 0;
2868}
886d19d6 2869
486ccd99
VK		 2870static int inet_show_netlink(struct filter *f, FILE *dump_fp, int protocol)
2871{
2872 int err = 0;
fb2594c1 2873 struct rtnl_handle rth, rth2;
486ccd99
VK		 2874 int family = PF_INET;
2875 struct inet_diag_arg arg = { .f = f, .protocol = protocol };
886d19d6 2876
486ccd99
VK		 2877 if (rtnl_open_byproto(&rth, 0, NETLINK_SOCK_DIAG))
2878 return -1;
fb2594c1
LC		 2879
2880 if (f->kill) {
2881 if (rtnl_open_byproto(&rth2, 0, NETLINK_SOCK_DIAG)) {
2882 rtnl_close(&rth);
2883 return -1;
2884 }
2885 arg.rth = &rth2;
2886 }
2887
486ccd99
VK		 2888 rth.dump = MAGIC_SEQ;
2889 rth.dump_fp = dump_fp;
518af1e0
ED		 2890 if (preferred_family == PF_INET6)
2891 family = PF_INET6;
886d19d6 2892
486ccd99
VK		 2893again:
2894 if ((err = sockdiag_send(family, rth.fd, protocol, f)))
2895 goto Exit;
aba5acdf 2896
486ccd99
VK		 2897 if ((err = rtnl_dump_filter(&rth, show_one_inet_sock, &arg))) {
2898 if (family != PF_UNSPEC) {
2899 family = PF_UNSPEC;
2900 goto again;
aba5acdf 2901 }
486ccd99 2902 goto Exit;
aba5acdf 2903 }
518af1e0 2904 if (family == PF_INET && preferred_family != PF_INET) {
886d19d6
PE		 2905 family = PF_INET6;
2906 goto again;
2907 }
2908
486ccd99
VK		 2909Exit:
2910 rtnl_close(&rth);
fb2594c1
LC		 2911 if (arg.rth)
2912 rtnl_close(arg.rth);
486ccd99 2913 return err;
aba5acdf
SH		 2914}
2915
ab01dbbb 2916static int tcp_show_netlink_file(struct filter *f)
aba5acdf
SH		 2917{
2918 FILE *fp;
e557212e 2919 char buf[16384];
4b45ae22 2920 int err = -1;
aba5acdf
SH		 2921
2922 if ((fp = fopen(getenv("TCPDIAG_FILE"), "r")) == NULL) {
2923 perror("fopen($TCPDIAG_FILE)");
4b45ae22 2924 return err;
aba5acdf
SH		 2925 }
2926
2927 while (1) {
4b45ae22 2928 int status, err2;
acd1e437 2929 struct nlmsghdr *h = (struct nlmsghdr *)buf;
82d73ea0 2930 struct sockstat s = {};
aba5acdf
SH		 2931
2932 status = fread(buf, 1, sizeof(*h), fp);
2933 if (status < 0) {
2934 perror("Reading header from $TCPDIAG_FILE");
4b45ae22 2935 break;
aba5acdf
SH		 2936 }
2937 if (status != sizeof(*h)) {
2938 perror("Unexpected EOF reading $TCPDIAG_FILE");
4b45ae22 2939 break;
aba5acdf
SH		 2940 }
2941
2942 status = fread(h+1, 1, NLMSG_ALIGN(h->nlmsg_len-sizeof(*h)), fp);
2943
2944 if (status < 0) {
2945 perror("Reading $TCPDIAG_FILE");
4b45ae22 2946 break;
aba5acdf
SH		 2947 }
2948 if (status + sizeof(*h) < h->nlmsg_len) {
2949 perror("Unexpected EOF reading $TCPDIAG_FILE");
4b45ae22 2950 break;
aba5acdf
SH		 2951 }
2952
2953 /* The only legal exit point */
4b45ae22
PS		 2954 if (h->nlmsg_type == NLMSG_DONE) {
2955 err = 0;
2956 break;
2957 }
aba5acdf
SH		 2958
2959 if (h->nlmsg_type == NLMSG_ERROR) {
acd1e437
SH		 2960 struct nlmsgerr *err = (struct nlmsgerr *)NLMSG_DATA(h);
2961
aba5acdf
SH		 2962 if (h->nlmsg_len < NLMSG_LENGTH(sizeof(struct nlmsgerr))) {
2963 fprintf(stderr, "ERROR truncated\n");
2964 } else {
2965 errno = -err->error;
2966 perror("TCPDIAG answered");
2967 }
4b45ae22 2968 break;
aba5acdf
SH		 2969 }
2970
82d73ea0 2971 parse_diag_msg(h, &s);
be7e4d20 2972 s.type = IPPROTO_TCP;
82d73ea0
DA		 2973
2974 if (f && f->f && run_ssfilter(f->f, &s) == 0)
2975 continue;
2976
4b45ae22
PS		 2977 err2 = inet_show_sock(h, &s);
2978 if (err2 < 0) {
2979 err = err2;
2980 break;
2981 }
aba5acdf 2982 }
4b45ae22
PS		 2983
2984 fclose(fp);
2985 return err;
aba5acdf
SH		 2986}
2987
6c6bbc30 2988static int tcp_show(struct filter *f)
aba5acdf 2989{
ab01dbbb 2990 FILE *fp = NULL;
aba5acdf
SH		 2991 char *buf = NULL;
2992 int bufsize = 64*1024;
2993
1527a17e
VK		 2994 if (!filter_af_get(f, AF_INET) && !filter_af_get(f, AF_INET6))
2995 return 0;
2996
aba5acdf
SH		 2997 dg_proto = TCP_PROTO;
2998
2999 if (getenv("TCPDIAG_FILE"))
3000 return tcp_show_netlink_file(f);
3001
3002 if (!getenv("PROC_NET_TCP") && !getenv("PROC_ROOT")
6c6bbc30 3003 && inet_show_netlink(f, NULL, IPPROTO_TCP) == 0)
aba5acdf
SH		 3004 return 0;
3005
3006 /* Sigh... We have to parse /proc/net/tcp... */
3007
ab01dbbb 3008
aba5acdf
SH		 3009 /* Estimate amount of sockets and try to allocate
3010 * huge buffer to read all the table at one read.
3011 * Limit it by 16MB though. The assumption is: as soon as
3012 * kernel was able to hold information about N connections,
3013 * it is able to give us some memory for snapshot.
3014 */
3015 if (1) {
a221d621
BL		 3016 get_slabstat(&slabstat);
3017
aba5acdf 3018 int guess = slabstat.socks+slabstat.tcp_syns;
acd1e437 3019
aba5acdf
SH		 3020 if (f->states&(1<<SS_TIME_WAIT))
3021 guess += slabstat.tcp_tws;
3022 if (guess > (16*1024*1024)/128)
3023 guess = (16*1024*1024)/128;
3024 guess *= 128;
3025 if (guess > bufsize)
3026 bufsize = guess;
3027 }
3028 while (bufsize >= 64*1024) {
3029 if ((buf = malloc(bufsize)) != NULL)
3030 break;
3031 bufsize /= 2;
3032 }
3033 if (buf == NULL) {
3034 errno = ENOMEM;
3035 return -1;
3036 }
3037
b338a3e7 3038 if (f->families & FAMILY_MASK(AF_INET)) {
69cae645 3039 if ((fp = net_tcp_open()) == NULL)
aba5acdf 3040 goto outerr;
ab01dbbb
SH		 3041
3042 setbuffer(fp, buf, bufsize);
3043 if (generic_record_read(fp, tcp_show_line, f, AF_INET))
aba5acdf 3044 goto outerr;
ab01dbbb 3045 fclose(fp);
aba5acdf
SH		 3046 }
3047
b338a3e7 3048 if ((f->families & FAMILY_MASK(AF_INET6)) &&
69cae645 3049 (fp = net_tcp6_open()) != NULL) {
ab01dbbb
SH		 3050 setbuffer(fp, buf, bufsize);
3051 if (generic_record_read(fp, tcp_show_line, f, AF_INET6))
aba5acdf 3052 goto outerr;
ab01dbbb 3053 fclose(fp);
aba5acdf
SH		 3054 }
3055
3056 free(buf);
3057 return 0;
3058
3059outerr:
3060 do {
3061 int saved_errno = errno;
acd1e437 3062
92de1c2c 3063 free(buf);
ab01dbbb
SH		 3064 if (fp)
3065 fclose(fp);
aba5acdf
SH		 3066 errno = saved_errno;
3067 return -1;
3068 } while (0);
3069}
3070
6c6bbc30
PS		 3071static int dccp_show(struct filter *f)
3072{
3073 if (!filter_af_get(f, AF_INET) && !filter_af_get(f, AF_INET6))
3074 return 0;
3075
3076 if (!getenv("PROC_NET_DCCP") && !getenv("PROC_ROOT")
3077 && inet_show_netlink(f, NULL, IPPROTO_DCCP) == 0)
3078 return 0;
3079
3080 return 0;
3081}
3082
f89d46ad
PS		 3083static int sctp_show(struct filter *f)
3084{
3085 if (!filter_af_get(f, AF_INET) && !filter_af_get(f, AF_INET6))
3086 return 0;
3087
3088 if (!getenv("PROC_NET_SCTP") && !getenv("PROC_ROOT")
3089 && inet_show_netlink(f, NULL, IPPROTO_SCTP) == 0)
3090 return 0;
3091
3092 return 0;
3093}
aba5acdf 3094
d1f28cf1 3095static int dgram_show_line(char *line, const struct filter *f, int family)
aba5acdf 3096{
055840f2 3097 struct sockstat s = {};
aba5acdf
SH		 3098 char *loc, *rem, *data;
3099 char opt[256];
3100 int n;
aba5acdf 3101
8250bc9f 3102 if (proc_inet_split_line(line, &loc, &rem, &data))
aba5acdf 3103 return -1;
aba5acdf 3104
8250bc9f 3105 int state = (data[1] >= 'A') ? (data[1] - 'A' + 10) : (data[1] - '0');
acd1e437 3106
8250bc9f
VK		 3107 if (!(f->states & (1 << state)))
3108 return 0;
aba5acdf 3109
8250bc9f 3110 proc_parse_inet_addr(loc, rem, family, &s);
aba5acdf
SH		 3111
3112 if (f->f && run_ssfilter(f->f, &s) == 0)
3113 return 0;
3114
3115 opt[0] = 0;
e7113c61 3116 n = sscanf(data, "%x %x:%x %*x:%*x %*x %d %*d %u %d %llx %[^\n]\n",
aba5acdf
SH		 3117 &s.state, &s.wq, &s.rq,
3118 &s.uid, &s.ino,
3119 &s.refcnt, &s.sk, opt);
3120
3121 if (n < 9)
3122 opt[0] = 0;
3123
be7e4d20 3124 s.type = dg_proto == UDP_PROTO ? IPPROTO_UDP : 0;
1267c0b9 3125 inet_stats_print(&s, false);
aba5acdf 3126
f1b39e1b 3127 if (show_details && opt[0])
90351722 3128 out(" opt:\"%s\"", opt);
aba5acdf
SH		 3129
3130 return 0;
3131}
3132
d1f28cf1 3133static int udp_show(struct filter *f)
aba5acdf 3134{
ab01dbbb 3135 FILE *fp = NULL;
aba5acdf 3136
1527a17e
VK		 3137 if (!filter_af_get(f, AF_INET) && !filter_af_get(f, AF_INET6))
3138 return 0;
3139
ace5cb31
VK		 3140 dg_proto = UDP_PROTO;
3141
346f8ca8
PE		 3142 if (!getenv("PROC_NET_UDP") && !getenv("PROC_ROOT")
3143 && inet_show_netlink(f, NULL, IPPROTO_UDP) == 0)
3144 return 0;
3145
b338a3e7 3146 if (f->families&FAMILY_MASK(AF_INET)) {
69cae645 3147 if ((fp = net_udp_open()) == NULL)
aba5acdf 3148 goto outerr;
ab01dbbb 3149 if (generic_record_read(fp, dgram_show_line, f, AF_INET))
aba5acdf 3150 goto outerr;
ab01dbbb 3151 fclose(fp);
aba5acdf
SH		 3152 }
3153
b338a3e7 3154 if ((f->families&FAMILY_MASK(AF_INET6)) &&
69cae645 3155 (fp = net_udp6_open()) != NULL) {
ab01dbbb 3156 if (generic_record_read(fp, dgram_show_line, f, AF_INET6))
aba5acdf 3157 goto outerr;
ab01dbbb 3158 fclose(fp);
aba5acdf
SH		 3159 }
3160 return 0;
3161
3162outerr:
3163 do {
3164 int saved_errno = errno;
acd1e437 3165
ab01dbbb
SH		 3166 if (fp)
3167 fclose(fp);
aba5acdf
SH		 3168 errno = saved_errno;
3169 return -1;
3170 } while (0);
3171}
3172
d1f28cf1 3173static int raw_show(struct filter *f)
aba5acdf 3174{
ab01dbbb 3175 FILE *fp = NULL;
aba5acdf 3176
1527a17e
VK		 3177 if (!filter_af_get(f, AF_INET) && !filter_af_get(f, AF_INET6))
3178 return 0;
3179
aba5acdf
SH		 3180 dg_proto = RAW_PROTO;
3181
41fe6c34
CG		 3182 if (!getenv("PROC_NET_RAW") && !getenv("PROC_ROOT") &&
3183 inet_show_netlink(f, NULL, IPPROTO_RAW) == 0)
3184 return 0;
3185
b338a3e7 3186 if (f->families&FAMILY_MASK(AF_INET)) {
69cae645 3187 if ((fp = net_raw_open()) == NULL)
aba5acdf 3188 goto outerr;
ab01dbbb 3189 if (generic_record_read(fp, dgram_show_line, f, AF_INET))
aba5acdf 3190 goto outerr;
ab01dbbb 3191 fclose(fp);
aba5acdf
SH		 3192 }
3193
b338a3e7 3194 if ((f->families&FAMILY_MASK(AF_INET6)) &&
69cae645 3195 (fp = net_raw6_open()) != NULL) {
ab01dbbb 3196 if (generic_record_read(fp, dgram_show_line, f, AF_INET6))
aba5acdf 3197 goto outerr;
ab01dbbb 3198 fclose(fp);
aba5acdf
SH		 3199 }
3200 return 0;
3201
3202outerr:
3203 do {
3204 int saved_errno = errno;
acd1e437 3205
ab01dbbb
SH		 3206 if (fp)
3207 fclose(fp);
aba5acdf
SH		 3208 errno = saved_errno;
3209 return -1;
3210 } while (0);
3211}
3212
ec4d0d8a 3213#define MAX_UNIX_REMEMBER (1024*1024/sizeof(struct sockstat))
aba5acdf 3214
2d0e538f 3215static void unix_list_drop_first(struct sockstat **list)
aba5acdf 3216{
2d0e538f 3217 struct sockstat *s = *list;
ec4d0d8a 3218
2d0e538f
PS		 3219 (*list) = (*list)->next;
3220 free(s->name);
3221 free(s);
aba5acdf
SH		 3222}
3223
ec4d0d8a 3224static bool unix_type_skip(struct sockstat *s, struct filter *f)
bf4ceee6
VK		 3225{
3226 if (s->type == SOCK_STREAM && !(f->dbs&(1<<UNIX_ST_DB)))
3227 return true;
3228 if (s->type == SOCK_DGRAM && !(f->dbs&(1<<UNIX_DG_DB)))
3229 return true;
3230 if (s->type == SOCK_SEQPACKET && !(f->dbs&(1<<UNIX_SQ_DB)))
3231 return true;
3232 return false;
3233}
3234
2d0e538f 3235static void unix_stats_print(struct sockstat *s, struct filter *f)
aba5acdf 3236{
b217df10 3237 char port_name[30] = {};
aba5acdf 3238
2d0e538f 3239 sock_state_print(s);
2d791bc8 3240
2d0e538f
PS		 3241 sock_addr_print(s->name ?: "*", " ",
3242 int_to_str(s->lport, port_name), NULL);
3243 sock_addr_print(s->peer_name ?: "*", " ",
3244 int_to_str(s->rport, port_name), NULL);
116ac927 3245
2d0e538f 3246 proc_ctx_print(s);
aba5acdf
SH		 3247}
3248
8a4025f6 3249static int unix_show_sock(const struct sockaddr_nl *addr, struct nlmsghdr *nlh,
3250 void *arg)
dfbaa90d 3251{
8a4025f6 3252 struct filter *f = (struct filter *)arg;
dfbaa90d
PE		 3253 struct unix_diag_msg *r = NLMSG_DATA(nlh);
3254 struct rtattr *tb[UNIX_DIAG_MAX+1];
99bb68ff
VK		 3255 char name[128];
3256 struct sockstat stat = { .name = "*", .peer_name = "*" };
dfbaa90d 3257
acd1e437 3258 parse_rtattr(tb, UNIX_DIAG_MAX, (struct rtattr *)(r+1),
dfbaa90d
PE		 3259 nlh->nlmsg_len - NLMSG_LENGTH(sizeof(*r)));
3260
bf4ceee6
VK		 3261 stat.type = r->udiag_type;
3262 stat.state = r->udiag_state;
ec4d0d8a
VK		 3263 stat.ino = stat.lport = r->udiag_ino;
3264 stat.local.family = stat.remote.family = AF_UNIX;
0d2e01c5 3265
bf4ceee6
VK		 3266 if (unix_type_skip(&stat, f))
3267 return 0;
dfbaa90d 3268
defd61ca
HFS		 3269 if (tb[UNIX_DIAG_RQLEN]) {
3270 struct unix_diag_rqlen *rql = RTA_DATA(tb[UNIX_DIAG_RQLEN]);
acd1e437 3271
bf4ceee6
VK		 3272 stat.rq = rql->udiag_rqueue;
3273 stat.wq = rql->udiag_wqueue;
defd61ca 3274 }
dfbaa90d
PE		 3275 if (tb[UNIX_DIAG_NAME]) {
3276 int len = RTA_PAYLOAD(tb[UNIX_DIAG_NAME]);
3277
3278 memcpy(name, RTA_DATA(tb[UNIX_DIAG_NAME]), len);
3279 name[len] = '\0';
1dd0cca7
SH		 3280 if (name[0] == '\0') {
3281 int i;
3282 for (i = 0; i < len; i++)
878dadc7
IB		 3283 if (name[i] == '\0')
3284 name[i] = '@';
1dd0cca7 3285 }
99bb68ff
VK		 3286 stat.name = &name[0];
3287 memcpy(stat.local.data, &stat.name, sizeof(stat.name));
bf4ceee6 3288 }
dfbaa90d 3289 if (tb[UNIX_DIAG_PEER])
ec4d0d8a 3290 stat.rport = rta_getattr_u32(tb[UNIX_DIAG_PEER]);
dfbaa90d 3291
29999b0f
VK		 3292 if (f->f && run_ssfilter(f->f, &stat) == 0)
3293 return 0;
3294
bf4ceee6 3295 unix_stats_print(&stat, f);
dfbaa90d 3296
45199997 3297 if (show_mem)
51ff9f24 3298 print_skmeminfo(tb, UNIX_DIAG_MEMINFO);
5b816047
PE		 3299 if (show_details) {
3300 if (tb[UNIX_DIAG_SHUTDOWN]) {
3301 unsigned char mask;
acd1e437 3302
9f1370c0 3303 mask = rta_getattr_u8(tb[UNIX_DIAG_SHUTDOWN]);
90351722
SB		 3304 out(" %c-%c",
3305 mask & 1 ? '-' : '<', mask & 2 ? '-' : '>');
5b816047
PE		 3306 }
3307 }
ec4d0d8a 3308
dfbaa90d
PE		 3309 return 0;
3310}
3311
8a4025f6 3312static int handle_netlink_request(struct filter *f, struct nlmsghdr *req,
3313 size_t size, rtnl_filter_t show_one_sock)
dfbaa90d 3314{
8a4025f6 3315 int ret = -1;
3316 struct rtnl_handle rth;
dfbaa90d 3317
8a4025f6 3318 if (rtnl_open_byproto(&rth, 0, NETLINK_SOCK_DIAG))
dfbaa90d
PE		 3319 return -1;
3320
8a4025f6 3321 rth.dump = MAGIC_SEQ;
dfbaa90d 3322
8a4025f6 3323 if (rtnl_send(&rth, req, size) < 0)
3324 goto Exit;
dfbaa90d 3325
8a4025f6 3326 if (rtnl_dump_filter(&rth, show_one_sock, f))
3327 goto Exit;
dfbaa90d 3328
8a4025f6 3329 ret = 0;
3330Exit:
3331 rtnl_close(&rth);
3332 return ret;
dfbaa90d
PE		 3333}
3334
8a4025f6 3335static int unix_show_netlink(struct filter *f)
d8402b96 3336{
5fb421d4 3337 DIAG_REQUEST(req, struct unix_diag_req r);
d8402b96
AV		 3338
3339 req.r.sdiag_family = AF_UNIX;
3340 req.r.udiag_states = f->states;
3341 req.r.udiag_show = UDIAG_SHOW_NAME | UDIAG_SHOW_PEER | UDIAG_SHOW_RQLEN;
3342 if (show_mem)
3343 req.r.udiag_show |= UDIAG_SHOW_MEMINFO;
3344
8a4025f6 3345 return handle_netlink_request(f, &req.nlh, sizeof(req), unix_show_sock);
d8402b96
AV		 3346}
3347
d1f28cf1 3348static int unix_show(struct filter *f)
aba5acdf
SH		 3349{
3350 FILE *fp;
3351 char buf[256];
3352 char name[128];
3353 int newformat = 0;
3354 int cnt;
ec4d0d8a 3355 struct sockstat *list = NULL;
96d45daa
PS		 3356 const int unix_state_map[] = { SS_CLOSE, SS_SYN_SENT,
3357 SS_ESTABLISHED, SS_CLOSING };
aba5acdf 3358
9db7bf15
VK		 3359 if (!filter_af_get(f, AF_UNIX))
3360 return 0;
3361
f25062e9
PS		 3362 if (!getenv("PROC_NET_UNIX") && !getenv("PROC_ROOT")
3363 && unix_show_netlink(f) == 0)
dfbaa90d
PE		 3364 return 0;
3365
ab01dbbb 3366 if ((fp = net_unix_open()) == NULL)
aba5acdf 3367 return -1;
61170fd8 3368 if (!fgets(buf, sizeof(buf), fp)) {
d572ed4d
PS		 3369 fclose(fp);
3370 return -1;
3371 }
aba5acdf 3372
ae665a52 3373 if (memcmp(buf, "Peer", 4) == 0)
aba5acdf
SH		 3374 newformat = 1;
3375 cnt = 0;
3376
61170fd8 3377 while (fgets(buf, sizeof(buf), fp)) {
ec4d0d8a 3378 struct sockstat *u, **insp;
aba5acdf
SH		 3379 int flags;
3380
0ee9052f 3381 if (!(u = calloc(1, sizeof(*u))))
aba5acdf 3382 break;
aba5acdf
SH		 3383
3384 if (sscanf(buf, "%x: %x %x %x %x %x %d %s",
ec4d0d8a 3385 &u->rport, &u->rq, &u->wq, &flags, &u->type,
aba5acdf
SH		 3386 &u->state, &u->ino, name) < 8)
3387 name[0] = 0;
3388
ec4d0d8a
VK		 3389 u->lport = u->ino;
3390 u->local.family = u->remote.family = AF_UNIX;
3391
3392 if (flags & (1 << 16)) {
aba5acdf 3393 u->state = SS_LISTEN;
0aa03350
PS		 3394 } else if (u->state > 0 &&
3395 u->state <= ARRAY_SIZE(unix_state_map)) {
aba5acdf 3396 u->state = unix_state_map[u->state-1];
ec4d0d8a 3397 if (u->type == SOCK_DGRAM && u->state == SS_CLOSE && u->rport)
aba5acdf
SH		 3398 u->state = SS_ESTABLISHED;
3399 }
2d0e538f
PS		 3400 if (unix_type_skip(u, f) ||
3401 !(f->states & (1 << u->state))) {
3402 free(u);
3403 continue;
3404 }
aba5acdf
SH		 3405
3406 if (!newformat) {
ec4d0d8a 3407 u->rport = 0;
aba5acdf
SH		 3408 u->rq = 0;
3409 u->wq = 0;
3410 }
3411
2d0e538f
PS		 3412 if (name[0]) {
3413 u->name = strdup(name);
46131577
PS		 3414 if (!u->name) {
3415 free(u);
2d0e538f 3416 break;
46131577 3417 }
2d0e538f
PS		 3418 }
3419
3420 if (u->rport) {
3421 struct sockstat *p;
3422
3423 for (p = list; p; p = p->next) {
3424 if (u->rport == p->lport)
3425 break;
3426 }
3427 if (!p)
3428 u->peer_name = "?";
3429 else
3430 u->peer_name = p->name ? : "*";
3431 }
3432
3433 if (f->f) {
3434 struct sockstat st = {
3435 .local.family = AF_UNIX,
3436 .remote.family = AF_UNIX,
3437 };
3438
3439 memcpy(st.local.data, &u->name, sizeof(u->name));
3440 if (strcmp(u->peer_name, "*"))
3441 memcpy(st.remote.data, &u->peer_name,
3442 sizeof(u->peer_name));
3443 if (run_ssfilter(f->f, &st) == 0) {
3444 free(u->name);
3445 free(u);
3446 continue;
3447 }
3448 }
3449
aba5acdf
SH		 3450 insp = &list;
3451 while (*insp) {
3452 if (u->type < (*insp)->type ||
3453 (u->type == (*insp)->type &&
3454 u->ino < (*insp)->ino))
3455 break;
3456 insp = &(*insp)->next;
3457 }
3458 u->next = *insp;
3459 *insp = u;
3460
aba5acdf 3461 if (++cnt > MAX_UNIX_REMEMBER) {
2d0e538f
PS		 3462 while (list) {
3463 unix_stats_print(list, f);
2d0e538f
PS		 3464 unix_list_drop_first(&list);
3465 }
aba5acdf
SH		 3466 cnt = 0;
3467 }
3468 }
a3fd8e58 3469 fclose(fp);
2d0e538f 3470 while (list) {
bf4ceee6 3471 unix_stats_print(list, f);
2d0e538f 3472 unix_list_drop_first(&list);
aba5acdf
SH		 3473 }
3474
3475 return 0;
3476}
3477
89f634f9 3478static int packet_stats_print(struct sockstat *s, const struct filter *f)
4a0053b6 3479{
b217df10
VK		 3480 const char *addr, *port;
3481 char ll_name[16];
372c30d2 3482
be7e4d20
PS		 3483 s->local.family = s->remote.family = AF_PACKET;
3484
4a0053b6 3485 if (f->f) {
89f634f9 3486 s->local.data[0] = s->prot;
89f634f9 3487 if (run_ssfilter(f->f, s) == 0)
4a0053b6
VK		 3488 return 1;
3489 }
372c30d2 3490
be7e4d20 3491 sock_state_print(s);
372c30d2 3492
b217df10
VK		 3493 if (s->prot == 3)
3494 addr = "*";
3495 else
3496 addr = ll_proto_n2a(htons(s->prot), ll_name, sizeof(ll_name));
3497
3498 if (s->iface == 0)
3499 port = "*";
3500 else
3501 port = xll_index_to_name(s->iface);
372c30d2 3502
b217df10
VK		 3503 sock_addr_print(addr, ":", port, NULL);
3504 sock_addr_print("", "*", "", NULL);
116ac927 3505
5f27ac1d 3506 proc_ctx_print(s);
116ac927 3507
f1b39e1b
VK		 3508 if (show_details)
3509 sock_details_print(s);
3510
4a0053b6
VK		 3511 return 0;
3512}
3513
2631b856
VK		 3514static void packet_show_ring(struct packet_diag_ring *ring)
3515{
90351722
SB		 3516 out("blk_size:%d", ring->pdr_block_size);
3517 out(",blk_nr:%d", ring->pdr_block_nr);
3518 out(",frm_size:%d", ring->pdr_frame_size);
3519 out(",frm_nr:%d", ring->pdr_frame_nr);
3520 out(",tmo:%d", ring->pdr_retire_tmo);
3521 out(",features:0x%x", ring->pdr_features);
2631b856
VK		 3522}
3523
4a0053b6
VK		 3524static int packet_show_sock(const struct sockaddr_nl *addr,
3525 struct nlmsghdr *nlh, void *arg)
3526{
3527 const struct filter *f = arg;
3528 struct packet_diag_msg *r = NLMSG_DATA(nlh);
2631b856
VK		 3529 struct packet_diag_info *pinfo = NULL;
3530 struct packet_diag_ring *ring_rx = NULL, *ring_tx = NULL;
4a0053b6 3531 struct rtattr *tb[PACKET_DIAG_MAX+1];
89f634f9 3532 struct sockstat stat = {};
2631b856
VK		 3533 uint32_t fanout = 0;
3534 bool has_fanout = false;
4a0053b6 3535
acd1e437 3536 parse_rtattr(tb, PACKET_DIAG_MAX, (struct rtattr *)(r+1),
4a0053b6
VK		 3537 nlh->nlmsg_len - NLMSG_LENGTH(sizeof(*r)));
3538
3539 /* use /proc/net/packet if all info are not available */
3540 if (!tb[PACKET_DIAG_MEMINFO])
3541 return -1;
3542
2d791bc8
VK		 3543 stat.type = r->pdiag_type;
3544 stat.prot = r->pdiag_num;
3545 stat.ino = r->pdiag_ino;
3546 stat.state = SS_CLOSE;
f1b39e1b 3547 stat.sk = cookie_sk_get(&r->pdiag_cookie[0]);
4a0053b6
VK		 3548
3549 if (tb[PACKET_DIAG_MEMINFO]) {
3550 __u32 *skmeminfo = RTA_DATA(tb[PACKET_DIAG_MEMINFO]);
acd1e437 3551
4a0053b6
VK		 3552 stat.rq = skmeminfo[SK_MEMINFO_RMEM_ALLOC];
3553 }
3554
3555 if (tb[PACKET_DIAG_INFO]) {
2631b856 3556 pinfo = RTA_DATA(tb[PACKET_DIAG_INFO]);
2d791bc8 3557 stat.lport = stat.iface = pinfo->pdi_index;
4a0053b6
VK		 3558 }
3559
f1b39e1b 3560 if (tb[PACKET_DIAG_UID])
9f1370c0 3561 stat.uid = rta_getattr_u32(tb[PACKET_DIAG_UID]);
f1b39e1b 3562
2631b856
VK		 3563 if (tb[PACKET_DIAG_RX_RING])
3564 ring_rx = RTA_DATA(tb[PACKET_DIAG_RX_RING]);
3565
3566 if (tb[PACKET_DIAG_TX_RING])
3567 ring_tx = RTA_DATA(tb[PACKET_DIAG_TX_RING]);
3568
3569 if (tb[PACKET_DIAG_FANOUT]) {
3570 has_fanout = true;
9f1370c0 3571 fanout = rta_getattr_u32(tb[PACKET_DIAG_FANOUT]);
2631b856
VK		 3572 }
3573
4a0053b6
VK		 3574 if (packet_stats_print(&stat, f))
3575 return 0;
3576
2631b856
VK		 3577 if (show_details) {
3578 if (pinfo) {
90351722
SB		 3579 out("\n\tver:%d", pinfo->pdi_version);
3580 out(" cpy_thresh:%d", pinfo->pdi_copy_thresh);
3581 out(" flags( ");
2631b856 3582 if (pinfo->pdi_flags & PDI_RUNNING)
90351722 3583 out("running");
2631b856 3584 if (pinfo->pdi_flags & PDI_AUXDATA)
90351722 3585 out(" auxdata");
2631b856 3586 if (pinfo->pdi_flags & PDI_ORIGDEV)
90351722 3587 out(" origdev");
2631b856 3588 if (pinfo->pdi_flags & PDI_VNETHDR)
90351722 3589 out(" vnethdr");
2631b856 3590 if (pinfo->pdi_flags & PDI_LOSS)
90351722 3591 out(" loss");
2631b856 3592 if (!pinfo->pdi_flags)
90351722
SB		 3593 out("0");
3594 out(" )");
2631b856
VK		 3595 }
3596 if (ring_rx) {
90351722 3597 out("\n\tring_rx(");
2631b856 3598 packet_show_ring(ring_rx);
90351722 3599 out(")");
2631b856
VK		 3600 }
3601 if (ring_tx) {
90351722 3602 out("\n\tring_tx(");
2631b856 3603 packet_show_ring(ring_tx);
90351722 3604 out(")");
2631b856
VK		 3605 }
3606 if (has_fanout) {
3607 uint16_t type = (fanout >> 16) & 0xffff;
3608
90351722
SB		 3609 out("\n\tfanout(");
3610 out("id:%d,", fanout & 0xffff);
3611 out("type:");
2631b856
VK		 3612
3613 if (type == 0)
90351722 3614 out("hash");
2631b856 3615 else if (type == 1)
90351722 3616 out("lb");
2631b856 3617 else if (type == 2)
90351722 3618 out("cpu");
2631b856 3619 else if (type == 3)
90351722 3620 out("roll");
2631b856 3621 else if (type == 4)
90351722 3622 out("random");
2631b856 3623 else if (type == 5)
90351722 3624 out("qm");
2631b856 3625 else
90351722 3626 out("0x%x", type);
2631b856 3627
90351722 3628 out(")");
2631b856
VK		 3629 }
3630 }
3631
372c30d2
ND		 3632 if (show_bpf && tb[PACKET_DIAG_FILTER]) {
3633 struct sock_filter *fil =
3634 RTA_DATA(tb[PACKET_DIAG_FILTER]);
3635 int num = RTA_PAYLOAD(tb[PACKET_DIAG_FILTER]) /
3636 sizeof(struct sock_filter);
3637
90351722 3638 out("\n\tbpf filter (%d): ", num);
372c30d2 3639 while (num) {
90351722
SB		 3640 out(" 0x%02x %u %u %u,",
3641 fil->code, fil->jt, fil->jf, fil->k);
372c30d2
ND		 3642 num--;
3643 fil++;
3644 }
3645 }
372c30d2
ND		 3646 return 0;
3647}
3648
8a4025f6 3649static int packet_show_netlink(struct filter *f)
372c30d2 3650{
5fb421d4 3651 DIAG_REQUEST(req, struct packet_diag_req r);
372c30d2 3652
372c30d2 3653 req.r.sdiag_family = AF_PACKET;
2631b856
VK		 3654 req.r.pdiag_show = PACKET_SHOW_INFO | PACKET_SHOW_MEMINFO |
3655 PACKET_SHOW_FILTER | PACKET_SHOW_RING_CFG | PACKET_SHOW_FANOUT;
372c30d2 3656
8a4025f6 3657 return handle_netlink_request(f, &req.nlh, sizeof(req), packet_show_sock);
372c30d2
ND		 3658}
3659
4a0053b6
VK		 3660static int packet_show_line(char *buf, const struct filter *f, int fam)
3661{
3662 unsigned long long sk;
89f634f9 3663 struct sockstat stat = {};
4a0053b6
VK		 3664 int type, prot, iface, state, rq, uid, ino;
3665
3666 sscanf(buf, "%llx %*d %d %x %d %d %u %u %u",
3667 &sk,
3668 &type, &prot, &iface, &state,
3669 &rq, &uid, &ino);
3670
3671 if (stat.type == SOCK_RAW && !(f->dbs&(1<<PACKET_R_DB)))
3672 return 0;
3673 if (stat.type == SOCK_DGRAM && !(f->dbs&(1<<PACKET_DG_DB)))
3674 return 0;
3675
3676 stat.type = type;
3677 stat.prot = prot;
2d791bc8 3678 stat.lport = stat.iface = iface;
4a0053b6
VK		 3679 stat.state = state;
3680 stat.rq = rq;
3681 stat.uid = uid;
3682 stat.ino = ino;
2d791bc8
VK		 3683 stat.state = SS_CLOSE;
3684
4a0053b6
VK		 3685 if (packet_stats_print(&stat, f))
3686 return 0;
3687
4a0053b6
VK		 3688 return 0;
3689}
aba5acdf 3690
d1f28cf1 3691static int packet_show(struct filter *f)
aba5acdf
SH		 3692{
3693 FILE *fp;
b95d28c3 3694 int rc = 0;
3d0b7439 3695
9db7bf15 3696 if (!filter_af_get(f, AF_PACKET) || !(f->states & (1 << SS_CLOSE)))
b9ea445d 3697 return 0;
aba5acdf 3698
4a0053b6
VK		 3699 if (!getenv("PROC_NET_PACKET") && !getenv("PROC_ROOT") &&
3700 packet_show_netlink(f) == 0)
372c30d2
ND		 3701 return 0;
3702
ab01dbbb 3703 if ((fp = net_packet_open()) == NULL)
aba5acdf 3704 return -1;
4a0053b6 3705 if (generic_record_read(fp, packet_show_line, f, AF_PACKET))
b95d28c3 3706 rc = -1;
aba5acdf 3707
b95d28c3
PS		 3708 fclose(fp);
3709 return rc;
aba5acdf
SH		 3710}
3711
5f24ec0e 3712static int netlink_show_one(struct filter *f,
acd1e437
SH		 3713 int prot, int pid, unsigned int groups,
3714 int state, int dst_pid, unsigned int dst_group,
129709ae
AV		 3715 int rq, int wq,
3716 unsigned long long sk, unsigned long long cb)
3717{
301826be
PS		 3718 struct sockstat st = {
3719 .state = SS_CLOSE,
3720 .rq = rq,
3721 .wq = wq,
3722 .local.family = AF_NETLINK,
3723 .remote.family = AF_NETLINK,
3724 };
acd1e437 3725
b217df10
VK		 3726 SPRINT_BUF(prot_buf) = {};
3727 const char *prot_name;
3728 char procname[64] = {};
eef43b50 3729
129709ae 3730 if (f->f) {
055840f2
VK		 3731 st.rport = -1;
3732 st.lport = pid;
3733 st.local.data[0] = prot;
055840f2 3734 if (run_ssfilter(f->f, &st) == 0)
5f24ec0e 3735 return 1;
129709ae
AV		 3736 }
3737
be7e4d20 3738 sock_state_print(&st);
eef43b50 3739
b217df10
VK		 3740 if (resolve_services)
3741 prot_name = nl_proto_n2a(prot, prot_buf, sizeof(prot_buf));
3742 else
3743 prot_name = int_to_str(prot, prot_buf);
eef43b50 3744
129709ae 3745 if (pid == -1) {
b217df10 3746 procname[0] = '*';
129709ae
AV		 3747 } else if (resolve_services) {
3748 int done = 0;
acd1e437 3749
129709ae
AV		 3750 if (!pid) {
3751 done = 1;
b217df10 3752 strncpy(procname, "kernel", 6);
129709ae 3753 } else if (pid > 0) {
129709ae 3754 FILE *fp;
acd1e437 3755
0ee9052f 3756 snprintf(procname, sizeof(procname), "%s/%d/stat",
129709ae
AV		 3757 getenv("PROC_ROOT") ? : "/proc", pid);
3758 if ((fp = fopen(procname, "r")) != NULL) {
3759 if (fscanf(fp, "%*d (%[^)])", procname) == 1) {
0ee9052f 3760 snprintf(procname+strlen(procname),
3761 sizeof(procname)-strlen(procname),
3762 "/%d", pid);
129709ae
AV		 3763 done = 1;
3764 }
3765 fclose(fp);
3766 }
3767 }
3768 if (!done)
b217df10 3769 int_to_str(pid, procname);
129709ae 3770 } else {
b217df10 3771 int_to_str(pid, procname);
129709ae 3772 }
f271fe01 3773
b217df10
VK		 3774 sock_addr_print(prot_name, ":", procname, NULL);
3775
f271fe01 3776 if (state == NETLINK_CONNECTED) {
b217df10
VK		 3777 char dst_group_buf[30];
3778 char dst_pid_buf[30];
acd1e437 3779
b217df10
VK		 3780 sock_addr_print(int_to_str(dst_group, dst_group_buf), ":",
3781 int_to_str(dst_pid, dst_pid_buf), NULL);
f271fe01 3782 } else {
b217df10 3783 sock_addr_print("", "*", "", NULL);
f271fe01 3784 }
129709ae 3785
116ac927 3786 char *pid_context = NULL;
acd1e437 3787
116ac927
RH		 3788 if (show_proc_ctx) {
3789 /* The pid value will either be:
3790 * 0 if destination kernel - show kernel initial context.
3791 * A valid process pid - use getpidcon.
3792 * A unique value allocated by the kernel or netlink user
3793 * to the process - show context as "not available".
3794 */
3795 if (!pid)
3796 security_get_initial_context("kernel", &pid_context);
3797 else if (pid > 0)
3798 getpidcon(pid, &pid_context);
3799
90351722 3800 out(" proc_ctx=%s", pid_context ? : "unavailable");
22658ff5 3801 free(pid_context);
116ac927
RH		 3802 }
3803
129709ae 3804 if (show_details) {
90351722 3805 out(" sk=%llx cb=%llx groups=0x%08x", sk, cb, groups);
129709ae 3806 }
129709ae 3807
5f24ec0e 3808 return 0;
129709ae
AV		 3809}
3810
8a4025f6 3811static int netlink_show_sock(const struct sockaddr_nl *addr,
3812 struct nlmsghdr *nlh, void *arg)
ecb928c8 3813{
8a4025f6 3814 struct filter *f = (struct filter *)arg;
ecb928c8
AV		 3815 struct netlink_diag_msg *r = NLMSG_DATA(nlh);
3816 struct rtattr *tb[NETLINK_DIAG_MAX+1];
3817 int rq = 0, wq = 0;
3818 unsigned long groups = 0;
3819
acd1e437 3820 parse_rtattr(tb, NETLINK_DIAG_MAX, (struct rtattr *)(r+1),
ecb928c8
AV		 3821 nlh->nlmsg_len - NLMSG_LENGTH(sizeof(*r)));
3822
3823 if (tb[NETLINK_DIAG_GROUPS] && RTA_PAYLOAD(tb[NETLINK_DIAG_GROUPS]))
3824 groups = *(unsigned long *) RTA_DATA(tb[NETLINK_DIAG_GROUPS]);
3825
3826 if (tb[NETLINK_DIAG_MEMINFO]) {
3827 const __u32 *skmeminfo;
acd1e437 3828
ecb928c8
AV		 3829 skmeminfo = RTA_DATA(tb[NETLINK_DIAG_MEMINFO]);
3830
3831 rq = skmeminfo[SK_MEMINFO_RMEM_ALLOC];
3832 wq = skmeminfo[SK_MEMINFO_WMEM_ALLOC];
3833 }
3834
5f24ec0e 3835 if (netlink_show_one(f, r->ndiag_protocol, r->ndiag_portid, groups,
ecb928c8 3836 r->ndiag_state, r->ndiag_dst_portid, r->ndiag_dst_group,
5f24ec0e
VK		 3837 rq, wq, 0, 0)) {
3838 return 0;
3839 }
ecb928c8
AV		 3840
3841 if (show_mem) {
90351722 3842 out("\t");
ecb928c8 3843 print_skmeminfo(tb, NETLINK_DIAG_MEMINFO);
ecb928c8
AV		 3844 }
3845
3846 return 0;
3847}
3848
8a4025f6 3849static int netlink_show_netlink(struct filter *f)
ecb928c8 3850{
5fb421d4 3851 DIAG_REQUEST(req, struct netlink_diag_req r);
ecb928c8
AV		 3852
3853 req.r.sdiag_family = AF_NETLINK;
3854 req.r.sdiag_protocol = NDIAG_PROTO_ALL;
3855 req.r.ndiag_show = NDIAG_SHOW_GROUPS | NDIAG_SHOW_MEMINFO;
3856
8a4025f6 3857 return handle_netlink_request(f, &req.nlh, sizeof(req), netlink_show_sock);
ecb928c8
AV		 3858}
3859
d1f28cf1 3860static int netlink_show(struct filter *f)
aba5acdf
SH		 3861{
3862 FILE *fp;
3863 char buf[256];
3864 int prot, pid;
acd1e437 3865 unsigned int groups;
aba5acdf
SH		 3866 int rq, wq, rc;
3867 unsigned long long sk, cb;
3868
9db7bf15 3869 if (!filter_af_get(f, AF_NETLINK) || !(f->states & (1 << SS_CLOSE)))
b9ea445d
VK		 3870 return 0;
3871
129709ae 3872 if (!getenv("PROC_NET_NETLINK") && !getenv("PROC_ROOT") &&
8a4025f6 3873 netlink_show_netlink(f) == 0)
129709ae
AV		 3874 return 0;
3875
ab01dbbb 3876 if ((fp = net_netlink_open()) == NULL)
aba5acdf 3877 return -1;
61170fd8 3878 if (!fgets(buf, sizeof(buf), fp)) {
d572ed4d
PS		 3879 fclose(fp);
3880 return -1;
3881 }
aba5acdf 3882
61170fd8 3883 while (fgets(buf, sizeof(buf), fp)) {
aba5acdf
SH		 3884 sscanf(buf, "%llx %d %d %x %d %d %llx %d",
3885 &sk,
3886 &prot, &pid, &groups, &rq, &wq, &cb, &rc);
3887
f271fe01 3888 netlink_show_one(f, prot, pid, groups, 0, 0, 0, rq, wq, sk, cb);
aba5acdf
SH		 3889 }
3890
b95d28c3 3891 fclose(fp);
aba5acdf
SH		 3892 return 0;
3893}
3894
c759116a
SH		 3895static bool vsock_type_skip(struct sockstat *s, struct filter *f)
3896{
3897 if (s->type == SOCK_STREAM && !(f->dbs & (1 << VSOCK_ST_DB)))
3898 return true;
3899 if (s->type == SOCK_DGRAM && !(f->dbs & (1 << VSOCK_DG_DB)))
3900 return true;
3901 return false;
3902}
3903
3904static void vsock_addr_print(inet_prefix *a, __u32 port)
3905{
3906 char cid_str[sizeof("4294967295")];
3907 char port_str[sizeof("4294967295")];
3908 __u32 cid;
3909
3910 memcpy(&cid, a->data, sizeof(cid));
3911
3912 if (cid == ~(__u32)0)
3913 snprintf(cid_str, sizeof(cid_str), "*");
3914 else
3915 snprintf(cid_str, sizeof(cid_str), "%u", cid);
3916
3917 if (port == ~(__u32)0)
3918 snprintf(port_str, sizeof(port_str), "*");
3919 else
3920 snprintf(port_str, sizeof(port_str), "%u", port);
3921
3922 sock_addr_print(cid_str, ":", port_str, NULL);
3923}
3924
3925static void vsock_stats_print(struct sockstat *s, struct filter *f)
3926{
3927 sock_state_print(s);
3928
3929 vsock_addr_print(&s->local, s->lport);
3930 vsock_addr_print(&s->remote, s->rport);
3931
3932 proc_ctx_print(s);
c759116a
SH		 3933}
3934
3935static int vsock_show_sock(const struct sockaddr_nl *addr,
3936 struct nlmsghdr *nlh, void *arg)
3937{
3938 struct filter *f = (struct filter *)arg;
3939 struct vsock_diag_msg *r = NLMSG_DATA(nlh);
3940 struct sockstat stat = {
3941 .type = r->vdiag_type,
3942 .lport = r->vdiag_src_port,
3943 .rport = r->vdiag_dst_port,
3944 .state = r->vdiag_state,
3945 .ino = r->vdiag_ino,
3946 };
3947
3948 vsock_set_inet_prefix(&stat.local, r->vdiag_src_cid);
3949 vsock_set_inet_prefix(&stat.remote, r->vdiag_dst_cid);
3950
3951 if (vsock_type_skip(&stat, f))
3952 return 0;
3953
3954 if (f->f && run_ssfilter(f->f, &stat) == 0)
3955 return 0;
3956
3957 vsock_stats_print(&stat, f);
3958
3959 return 0;
3960}
3961
3962static int vsock_show(struct filter *f)
3963{
3964 DIAG_REQUEST(req, struct vsock_diag_req r);
3965
3966 if (!filter_af_get(f, AF_VSOCK))
3967 return 0;
3968
3969 req.r.sdiag_family = AF_VSOCK;
3970 req.r.vdiag_states = f->states;
3971
3972 return handle_netlink_request(f, &req.nlh, sizeof(req), vsock_show_sock);
3973}
3974
6885e3bf
CG		 3975struct sock_diag_msg {
3976 __u8 sdiag_family;
3977};
3978
3979static int generic_show_sock(const struct sockaddr_nl *addr,
3980 struct nlmsghdr *nlh, void *arg)
3981{
3982 struct sock_diag_msg *r = NLMSG_DATA(nlh);
3983 struct inet_diag_arg inet_arg = { .f = arg, .protocol = IPPROTO_MAX };
3984
3985 switch (r->sdiag_family) {
3986 case AF_INET:
3987 case AF_INET6:
3988 return show_one_inet_sock(addr, nlh, &inet_arg);
3989 case AF_UNIX:
3990 return unix_show_sock(addr, nlh, arg);
3991 case AF_PACKET:
3992 return packet_show_sock(addr, nlh, arg);
3993 case AF_NETLINK:
3994 return netlink_show_sock(addr, nlh, arg);
c759116a
SH		 3995 case AF_VSOCK:
3996 return vsock_show_sock(addr, nlh, arg);
6885e3bf
CG		 3997 default:
3998 return -1;
3999 }
4000}
4001
4002static int handle_follow_request(struct filter *f)
4003{
6b224dad 4004 int ret = 0;
6885e3bf
CG		 4005 int groups = 0;
4006 struct rtnl_handle rth;
4007
b338a3e7 4008 if (f->families & FAMILY_MASK(AF_INET) && f->dbs & (1 << TCP_DB))
6885e3bf 4009 groups |= 1 << (SKNLGRP_INET_TCP_DESTROY - 1);
b338a3e7 4010 if (f->families & FAMILY_MASK(AF_INET) && f->dbs & (1 << UDP_DB))
6885e3bf 4011 groups |= 1 << (SKNLGRP_INET_UDP_DESTROY - 1);
b338a3e7 4012 if (f->families & FAMILY_MASK(AF_INET6) && f->dbs & (1 << TCP_DB))
6885e3bf 4013 groups |= 1 << (SKNLGRP_INET6_TCP_DESTROY - 1);
b338a3e7 4014 if (f->families & FAMILY_MASK(AF_INET6) && f->dbs & (1 << UDP_DB))
6885e3bf
CG		 4015 groups |= 1 << (SKNLGRP_INET6_UDP_DESTROY - 1);
4016
4017 if (groups == 0)
4018 return -1;
4019
4020 if (rtnl_open_byproto(&rth, groups, NETLINK_SOCK_DIAG))
4021 return -1;
4022
4023 rth.dump = 0;
4024 rth.local.nl_pid = 0;
4025
4026 if (rtnl_dump_filter(&rth, generic_show_sock, f))
6b224dad 4027 ret = -1;
6885e3bf 4028
6885e3bf
CG		 4029 rtnl_close(&rth);
4030 return ret;
4031}
4032
d1f28cf1 4033static int get_snmp_int(char *proto, char *key, int *result)
aba5acdf
SH		 4034{
4035 char buf[1024];
4036 FILE *fp;
4037 int protolen = strlen(proto);
4038 int keylen = strlen(key);
4039
4040 *result = 0;
4041
ab01dbbb 4042 if ((fp = net_snmp_open()) == NULL)
aba5acdf
SH		 4043 return -1;
4044
4045 while (fgets(buf, sizeof(buf), fp) != NULL) {
4046 char *p = buf;
4047 int pos = 0;
acd1e437 4048
aba5acdf
SH		 4049 if (memcmp(buf, proto, protolen))
4050 continue;
4051 while ((p = strchr(p, ' ')) != NULL) {
4052 pos++;
4053 p++;
4054 if (memcmp(p, key, keylen) == 0 &&
4055 (p[keylen] == ' ' || p[keylen] == '\n'))
4056 break;
4057 }
4058 if (fgets(buf, sizeof(buf), fp) == NULL)
4059 break;
4060 if (memcmp(buf, proto, protolen))
4061 break;
4062 p = buf;
4063 while ((p = strchr(p, ' ')) != NULL) {
4064 p++;
4065 if (--pos == 0) {
4066 sscanf(p, "%d", result);
4067 fclose(fp);
4068 return 0;
4069 }
4070 }
4071 }
4072
4073 fclose(fp);
4074 errno = ESRCH;
4075 return -1;
4076}
4077
4078
4079/* Get stats from sockstat */
4080
acd1e437 4081struct ssummary {
aba5acdf
SH		 4082 int socks;
4083 int tcp_mem;
4084 int tcp_total;
4085 int tcp_orphans;
4086 int tcp_tws;
4087 int tcp4_hashed;
4088 int udp4;
4089 int raw4;
4090 int frag4;
4091 int frag4_mem;
4092 int tcp6_hashed;
4093 int udp6;
4094 int raw6;
4095 int frag6;
4096 int frag6_mem;
4097};
4098
055840f2 4099static void get_sockstat_line(char *line, struct ssummary *s)
aba5acdf
SH		 4100{
4101 char id[256], rem[256];
4102
4103 if (sscanf(line, "%[^ ] %[^\n]\n", id, rem) != 2)
4104 return;
4105
4106 if (strcmp(id, "sockets:") == 0)
4107 sscanf(rem, "%*s%d", &s->socks);
4108 else if (strcmp(id, "UDP:") == 0)
4109 sscanf(rem, "%*s%d", &s->udp4);
4110 else if (strcmp(id, "UDP6:") == 0)
4111 sscanf(rem, "%*s%d", &s->udp6);
4112 else if (strcmp(id, "RAW:") == 0)
4113 sscanf(rem, "%*s%d", &s->raw4);
4114 else if (strcmp(id, "RAW6:") == 0)
4115 sscanf(rem, "%*s%d", &s->raw6);
4116 else if (strcmp(id, "TCP6:") == 0)
4117 sscanf(rem, "%*s%d", &s->tcp6_hashed);
4118 else if (strcmp(id, "FRAG:") == 0)
4119 sscanf(rem, "%*s%d%*s%d", &s->frag4, &s->frag4_mem);
4120 else if (strcmp(id, "FRAG6:") == 0)
4121 sscanf(rem, "%*s%d%*s%d", &s->frag6, &s->frag6_mem);
4122 else if (strcmp(id, "TCP:") == 0)
4123 sscanf(rem, "%*s%d%*s%d%*s%d%*s%d%*s%d",
4124 &s->tcp4_hashed,
4125 &s->tcp_orphans, &s->tcp_tws, &s->tcp_total, &s->tcp_mem);
4126}
4127
055840f2 4128static int get_sockstat(struct ssummary *s)
aba5acdf
SH		 4129{
4130 char buf[256];
4131 FILE *fp;
4132
4133 memset(s, 0, sizeof(*s));
4134
ab01dbbb 4135 if ((fp = net_sockstat_open()) == NULL)
aba5acdf 4136 return -1;
acd1e437 4137 while (fgets(buf, sizeof(buf), fp) != NULL)
aba5acdf
SH		 4138 get_sockstat_line(buf, s);
4139 fclose(fp);
4140
ab01dbbb 4141 if ((fp = net_sockstat6_open()) == NULL)
aba5acdf 4142 return 0;
acd1e437 4143 while (fgets(buf, sizeof(buf), fp) != NULL)
aba5acdf
SH		 4144 get_sockstat_line(buf, s);
4145 fclose(fp);
4146
4147 return 0;
4148}
4149
d1f28cf1 4150static int print_summary(void)
aba5acdf 4151{
055840f2 4152 struct ssummary s;
2f938ce1 4153 int tcp_estab;
aba5acdf
SH		 4154
4155 if (get_sockstat(&s) < 0)
4156 perror("ss: get_sockstat");
2f938ce1 4157 if (get_snmp_int("Tcp:", "CurrEstab", &tcp_estab) < 0)
aba5acdf
SH		 4158 perror("ss: get_snmpstat");
4159
a221d621
BL		 4160 get_slabstat(&slabstat);
4161
aba5acdf
SH		 4162 printf("Total: %d (kernel %d)\n", s.socks, slabstat.socks);
4163
4164 printf("TCP: %d (estab %d, closed %d, orphaned %d, synrecv %d, timewait %d/%d), ports %d\n",
4165 s.tcp_total + slabstat.tcp_syns + s.tcp_tws,
2f938ce1 4166 tcp_estab,
aba5acdf
SH		 4167 s.tcp_total - (s.tcp4_hashed+s.tcp6_hashed-s.tcp_tws),
4168 s.tcp_orphans,
4169 slabstat.tcp_syns,
4170 s.tcp_tws, slabstat.tcp_tws,
4171 slabstat.tcp_ports
4172 );
4173
4174 printf("\n");
4175 printf("Transport Total IP IPv6\n");
4176 printf("* %-9d %-9s %-9s\n", slabstat.socks, "-", "-");
4177 printf("RAW %-9d %-9d %-9d\n", s.raw4+s.raw6, s.raw4, s.raw6);
4178 printf("UDP %-9d %-9d %-9d\n", s.udp4+s.udp6, s.udp4, s.udp6);
4179 printf("TCP %-9d %-9d %-9d\n", s.tcp4_hashed+s.tcp6_hashed, s.tcp4_hashed, s.tcp6_hashed);
ae665a52 4180 printf("INET %-9d %-9d %-9d\n",
aba5acdf
SH		 4181 s.raw4+s.udp4+s.tcp4_hashed+
4182 s.raw6+s.udp6+s.tcp6_hashed,
4183 s.raw4+s.udp4+s.tcp4_hashed,
4184 s.raw6+s.udp6+s.tcp6_hashed);
4185 printf("FRAG %-9d %-9d %-9d\n", s.frag4+s.frag6, s.frag4, s.frag6);
4186
4187 printf("\n");
4188
4189 return 0;
4190}
4191
7a96e199 4192static void _usage(FILE *dest)
aba5acdf 4193{
7a96e199 4194 fprintf(dest,
aba5acdf
SH		 4195"Usage: ss [ OPTIONS ]\n"
4196" ss [ OPTIONS ] [ FILTER ]\n"
ff041f16
VK		 4197" -h, --help this message\n"
4198" -V, --version output version information\n"
4199" -n, --numeric don't resolve service names\n"
ab61159a 4200" -r, --resolve resolve host names\n"
ff041f16
VK		 4201" -a, --all display all sockets\n"
4202" -l, --listening display listening sockets\n"
ab61159a
SH		 4203" -o, --options show timer information\n"
4204" -e, --extended show detailed socket information\n"
4205" -m, --memory show socket memory usage\n"
ff041f16
VK		 4206" -p, --processes show process using socket\n"
4207" -i, --info show internal TCP information\n"
4208" -s, --summary show socket usage summary\n"
b0f01cf6 4209" -b, --bpf show bpf filter socket information\n"
6885e3bf 4210" -E, --events continually display sockets as they are destroyed\n"
ff041f16
VK		 4211" -Z, --context display process SELinux security contexts\n"
4212" -z, --contexts display process and socket SELinux security contexts\n"
95ce04bc 4213" -N, --net switch to the specified network namespace name\n"
ab61159a
SH		 4214"\n"
4215" -4, --ipv4 display only IP version 4 sockets\n"
4216" -6, --ipv6 display only IP version 6 sockets\n"
ff041f16
VK		 4217" -0, --packet display PACKET sockets\n"
4218" -t, --tcp display only TCP sockets\n"
f89d46ad 4219" -S, --sctp display only SCTP sockets\n"
ff041f16
VK		 4220" -u, --udp display only UDP sockets\n"
4221" -d, --dccp display only DCCP sockets\n"
4222" -w, --raw display only RAW sockets\n"
4223" -x, --unix display only Unix domain sockets\n"
c759116a 4224" --vsock display only vsock sockets\n"
ab61159a 4225" -f, --family=FAMILY display sockets of type FAMILY\n"
c759116a 4226" FAMILY := {inet|inet6|link|unix|netlink|vsock|help}\n"
ab61159a 4227"\n"
fb2594c1 4228" -K, --kill forcibly close sockets, display what was closed\n"
7a4559f6 4229" -H, --no-header Suppress header line\n"
fb2594c1 4230"\n"
583de149 4231" -A, --query=QUERY, --socket=QUERY\n"
c759116a 4232" QUERY := {all|inet|tcp|udp|raw|unix|unix_dgram|unix_stream|unix_seqpacket|packet|netlink|vsock_stream|vsock_dgram}[,QUERY]\n"
ab61159a 4233"\n"
583de149 4234" -D, --diag=FILE Dump raw information about TCP sockets to FILE\n"
ab61159a 4235" -F, --filter=FILE read filter information from FILE\n"
ff041f16
VK		 4236" FILTER := [ state STATE-FILTER ] [ EXPRESSION ]\n"
4237" STATE-FILTER := {all|connected|synchronized|bucket|big|TCP-STATES}\n"
ae4e21c9 4238" TCP-STATES := {established|syn-sent|syn-recv|fin-wait-{1,2}|time-wait|closed|close-wait|last-ack|listening|closing}\n"
ff041f16
VK		 4239" connected := {established|syn-sent|syn-recv|fin-wait-{1,2}|time-wait|close-wait|last-ack|closing}\n"
4240" synchronized := {established|syn-recv|fin-wait-{1,2}|time-wait|close-wait|last-ack|closing}\n"
4241" bucket := {syn-recv|time-wait}\n"
ae4e21c9 4242" big := {established|syn-sent|fin-wait-{1,2}|closed|close-wait|last-ack|listening|closing}\n"
ab61159a 4243 );
7a96e199
AH		 4244}
4245
4246static void help(void) __attribute__((noreturn));
4247static void help(void)
4248{
4249 _usage(stdout);
4250 exit(0);
4251}
4252
4253static void usage(void) __attribute__((noreturn));
4254static void usage(void)
4255{
4256 _usage(stderr);
aba5acdf
SH		 4257 exit(-1);
4258}
4259
4260
d1f28cf1 4261static int scan_state(const char *state)
aba5acdf 4262{
b710a722
PS		 4263 static const char * const sstate_namel[] = {
4264 "UNKNOWN",
4265 [SS_ESTABLISHED] = "established",
4266 [SS_SYN_SENT] = "syn-sent",
4267 [SS_SYN_RECV] = "syn-recv",
4268 [SS_FIN_WAIT1] = "fin-wait-1",
4269 [SS_FIN_WAIT2] = "fin-wait-2",
4270 [SS_TIME_WAIT] = "time-wait",
4271 [SS_CLOSE] = "unconnected",
4272 [SS_CLOSE_WAIT] = "close-wait",
4273 [SS_LAST_ACK] = "last-ack",
4274 [SS_LISTEN] = "listening",
4275 [SS_CLOSING] = "closing",
4276 };
aba5acdf 4277 int i;
acd1e437 4278
aba5acdf
SH		 4279 if (strcasecmp(state, "close") == 0 ||
4280 strcasecmp(state, "closed") == 0)
4281 return (1<<SS_CLOSE);
4282 if (strcasecmp(state, "syn-rcv") == 0)
4283 return (1<<SS_SYN_RECV);
1a5bad5a 4284 if (strcasecmp(state, "established") == 0)
aba5acdf
SH		 4285 return (1<<SS_ESTABLISHED);
4286 if (strcasecmp(state, "all") == 0)
4287 return SS_ALL;
4288 if (strcasecmp(state, "connected") == 0)
4289 return SS_ALL & ~((1<<SS_CLOSE)|(1<<SS_LISTEN));
1a5bad5a 4290 if (strcasecmp(state, "synchronized") == 0)
aba5acdf
SH		 4291 return SS_ALL & ~((1<<SS_CLOSE)|(1<<SS_LISTEN)|(1<<SS_SYN_SENT));
4292 if (strcasecmp(state, "bucket") == 0)
4293 return (1<<SS_SYN_RECV)|(1<<SS_TIME_WAIT);
4294 if (strcasecmp(state, "big") == 0)
4295 return SS_ALL & ~((1<<SS_SYN_RECV)|(1<<SS_TIME_WAIT));
acd1e437 4296 for (i = 0; i < SS_MAX; i++) {
1a5bad5a 4297 if (strcasecmp(state, sstate_namel[i]) == 0)
aba5acdf
SH		 4298 return (1<<i);
4299 }
9db7bf15
VK		 4300
4301 fprintf(stderr, "ss: wrong state name: %s\n", state);
4302 exit(-1);
aba5acdf
SH		 4303}
4304
c759116a
SH		 4305/* Values 'v' and 'V' are already used so a non-character is used */
4306#define OPT_VSOCK 256
4307
ab61159a
SH		 4308static const struct option long_opts[] = {
4309 { "numeric", 0, 0, 'n' },
4310 { "resolve", 0, 0, 'r' },
4311 { "options", 0, 0, 'o' },
4312 { "extended", 0, 0, 'e' },
4313 { "memory", 0, 0, 'm' },
4314 { "info", 0, 0, 'i' },
4315 { "processes", 0, 0, 'p' },
372c30d2 4316 { "bpf", 0, 0, 'b' },
6885e3bf 4317 { "events", 0, 0, 'E' },
351efcde 4318 { "dccp", 0, 0, 'd' },
ab61159a 4319 { "tcp", 0, 0, 't' },
f89d46ad 4320 { "sctp", 0, 0, 'S' },
ab61159a
SH		 4321 { "udp", 0, 0, 'u' },
4322 { "raw", 0, 0, 'w' },
4323 { "unix", 0, 0, 'x' },
c759116a 4324 { "vsock", 0, 0, OPT_VSOCK },
ab61159a
SH		 4325 { "all", 0, 0, 'a' },
4326 { "listening", 0, 0, 'l' },
4327 { "ipv4", 0, 0, '4' },
4328 { "ipv6", 0, 0, '6' },
4329 { "packet", 0, 0, '0' },
4330 { "family", 1, 0, 'f' },
4331 { "socket", 1, 0, 'A' },
583de149 4332 { "query", 1, 0, 'A' },
c3f346b0 4333 { "summary", 0, 0, 's' },
583de149 4334 { "diag", 1, 0, 'D' },
ab61159a
SH		 4335 { "filter", 1, 0, 'F' },
4336 { "version", 0, 0, 'V' },
4337 { "help", 0, 0, 'h' },
116ac927
RH		 4338 { "context", 0, 0, 'Z' },
4339 { "contexts", 0, 0, 'z' },
95ce04bc 4340 { "net", 1, 0, 'N' },
fb2594c1 4341 { "kill", 0, 0, 'K' },
7a4559f6 4342 { "no-header", 0, 0, 'H' },
ab61159a 4343 { 0 }
ae665a52 4344
ab61159a
SH		 4345};
4346
aba5acdf
SH		 4347int main(int argc, char *argv[])
4348{
aba5acdf
SH		 4349 int saw_states = 0;
4350 int saw_query = 0;
4351 int do_summary = 0;
7d105b56 4352 const char *dump_tcpdiag = NULL;
aba5acdf
SH		 4353 FILE *filter_fp = NULL;
4354 int ch;
9db7bf15 4355 int state_filter = 0;
95eafe43 4356 int addrp_width, screen_width = 80;
aba5acdf 4357
168d97f9
SH		 4358 while ((ch = getopt_long(argc, argv,
4359 "dhaletuwxnro460spbEf:miA:D:F:vVzZN:KHS",
ab61159a 4360 long_opts, NULL)) != EOF) {
acd1e437 4361 switch (ch) {
aba5acdf
SH		 4362 case 'n':
4363 resolve_services = 0;
4364 break;
4365 case 'r':
4366 resolve_hosts = 1;
4367 break;
4368 case 'o':
4369 show_options = 1;
4370 break;
4371 case 'e':
4372 show_options = 1;
4373 show_details++;
4374 break;
4375 case 'm':
4376 show_mem = 1;
4377 break;
4378 case 'i':
4379 show_tcpinfo = 1;
4380 break;
4381 case 'p':
4382 show_users++;
fbc0f876 4383 user_ent_hash_build();
aba5acdf 4384 break;
372c30d2
ND		 4385 case 'b':
4386 show_options = 1;
4387 show_bpf++;
4388 break;
6885e3bf
CG		 4389 case 'E':
4390 follow_events = 1;
4391 break;
351efcde 4392 case 'd':
57ff5a10 4393 filter_db_set(&current_filter, DCCP_DB);
351efcde 4394 break;
aba5acdf 4395 case 't':
57ff5a10 4396 filter_db_set(&current_filter, TCP_DB);
aba5acdf 4397 break;
f89d46ad
PS		 4398 case 'S':
4399 filter_db_set(&current_filter, SCTP_DB);
4400 break;
aba5acdf 4401 case 'u':
57ff5a10 4402 filter_db_set(&current_filter, UDP_DB);
aba5acdf
SH		 4403 break;
4404 case 'w':
57ff5a10 4405 filter_db_set(&current_filter, RAW_DB);
aba5acdf
SH		 4406 break;
4407 case 'x':
9db7bf15 4408 filter_af_set(&current_filter, AF_UNIX);
aba5acdf 4409 break;
c759116a
SH		 4410 case OPT_VSOCK:
4411 filter_af_set(&current_filter, AF_VSOCK);
4412 break;
aba5acdf 4413 case 'a':
9db7bf15 4414 state_filter = SS_ALL;
aba5acdf
SH		 4415 break;
4416 case 'l':
9db7bf15 4417 state_filter = (1 << SS_LISTEN) | (1 << SS_CLOSE);
aba5acdf
SH		 4418 break;
4419 case '4':
9db7bf15 4420 filter_af_set(&current_filter, AF_INET);
aba5acdf
SH		 4421 break;
4422 case '6':
9db7bf15 4423 filter_af_set(&current_filter, AF_INET6);
aba5acdf
SH		 4424 break;
4425 case '0':
9db7bf15 4426 filter_af_set(&current_filter, AF_PACKET);
aba5acdf
SH		 4427 break;
4428 case 'f':
4429 if (strcmp(optarg, "inet") == 0)
9db7bf15 4430 filter_af_set(&current_filter, AF_INET);
aba5acdf 4431 else if (strcmp(optarg, "inet6") == 0)
9db7bf15 4432 filter_af_set(&current_filter, AF_INET6);
aba5acdf 4433 else if (strcmp(optarg, "link") == 0)
9db7bf15 4434 filter_af_set(&current_filter, AF_PACKET);
aba5acdf 4435 else if (strcmp(optarg, "unix") == 0)
9db7bf15 4436 filter_af_set(&current_filter, AF_UNIX);
aba5acdf 4437 else if (strcmp(optarg, "netlink") == 0)
9db7bf15 4438 filter_af_set(&current_filter, AF_NETLINK);
c759116a
SH		 4439 else if (strcmp(optarg, "vsock") == 0)
4440 filter_af_set(&current_filter, AF_VSOCK);
aba5acdf 4441 else if (strcmp(optarg, "help") == 0)
7a96e199 4442 help();
aba5acdf 4443 else {
9db7bf15
VK		 4444 fprintf(stderr, "ss: \"%s\" is invalid family\n",
4445 optarg);
aba5acdf
SH		 4446 usage();
4447 }
4448 break;
4449 case 'A':
4450 {
4451 char *p, *p1;
acd1e437 4452
aba5acdf
SH		 4453 if (!saw_query) {
4454 current_filter.dbs = 0;
7f9dddbe 4455 state_filter = state_filter ?
acd1e437 4456 state_filter : SS_CONN;
aba5acdf
SH		 4457 saw_query = 1;
4458 do_default = 0;
4459 }
4460 p = p1 = optarg;
4461 do {
4462 if ((p1 = strchr(p, ',')) != NULL)
ae665a52 4463 *p1 = 0;
aba5acdf 4464 if (strcmp(p, "all") == 0) {
57ff5a10 4465 filter_default_dbs(&current_filter);
aba5acdf 4466 } else if (strcmp(p, "inet") == 0) {
57ff5a10
VK		 4467 filter_db_set(&current_filter, UDP_DB);
4468 filter_db_set(&current_filter, DCCP_DB);
4469 filter_db_set(&current_filter, TCP_DB);
f89d46ad 4470 filter_db_set(&current_filter, SCTP_DB);
57ff5a10 4471 filter_db_set(&current_filter, RAW_DB);
aba5acdf 4472 } else if (strcmp(p, "udp") == 0) {
57ff5a10 4473 filter_db_set(&current_filter, UDP_DB);
351efcde 4474 } else if (strcmp(p, "dccp") == 0) {
57ff5a10 4475 filter_db_set(&current_filter, DCCP_DB);
aba5acdf 4476 } else if (strcmp(p, "tcp") == 0) {
57ff5a10 4477 filter_db_set(&current_filter, TCP_DB);
f89d46ad
PS		 4478 } else if (strcmp(p, "sctp") == 0) {
4479 filter_db_set(&current_filter, SCTP_DB);
aba5acdf 4480 } else if (strcmp(p, "raw") == 0) {
57ff5a10 4481 filter_db_set(&current_filter, RAW_DB);
aba5acdf 4482 } else if (strcmp(p, "unix") == 0) {
57ff5a10
VK		 4483 filter_db_set(&current_filter, UNIX_ST_DB);
4484 filter_db_set(&current_filter, UNIX_DG_DB);
4485 filter_db_set(&current_filter, UNIX_SQ_DB);
1a5bad5a 4486 } else if (strcasecmp(p, "unix_stream") == 0 ||
aba5acdf 4487 strcmp(p, "u_str") == 0) {
57ff5a10 4488 filter_db_set(&current_filter, UNIX_ST_DB);
1a5bad5a 4489 } else if (strcasecmp(p, "unix_dgram") == 0 ||
aba5acdf 4490 strcmp(p, "u_dgr") == 0) {
57ff5a10 4491 filter_db_set(&current_filter, UNIX_DG_DB);
30b669d7
MY		 4492 } else if (strcasecmp(p, "unix_seqpacket") == 0 ||
4493 strcmp(p, "u_seq") == 0) {
57ff5a10 4494 filter_db_set(&current_filter, UNIX_SQ_DB);
aba5acdf 4495 } else if (strcmp(p, "packet") == 0) {
57ff5a10
VK		 4496 filter_db_set(&current_filter, PACKET_R_DB);
4497 filter_db_set(&current_filter, PACKET_DG_DB);
aba5acdf
SH		 4498 } else if (strcmp(p, "packet_raw") == 0 ||
4499 strcmp(p, "p_raw") == 0) {
57ff5a10 4500 filter_db_set(&current_filter, PACKET_R_DB);
aba5acdf
SH		 4501 } else if (strcmp(p, "packet_dgram") == 0 ||
4502 strcmp(p, "p_dgr") == 0) {
57ff5a10 4503 filter_db_set(&current_filter, PACKET_DG_DB);
aba5acdf 4504 } else if (strcmp(p, "netlink") == 0) {
57ff5a10 4505 filter_db_set(&current_filter, NETLINK_DB);
c759116a
SH		 4506 } else if (strcmp(p, "vsock") == 0) {
4507 filter_db_set(&current_filter, VSOCK_ST_DB);
4508 filter_db_set(&current_filter, VSOCK_DG_DB);
4509 } else if (strcmp(p, "vsock_stream") == 0 ||
4510 strcmp(p, "v_str") == 0) {
4511 filter_db_set(&current_filter, VSOCK_ST_DB);
4512 } else if (strcmp(p, "vsock_dgram") == 0 ||
4513 strcmp(p, "v_dgr") == 0) {
4514 filter_db_set(&current_filter, VSOCK_DG_DB);
aba5acdf
SH		 4515 } else {
4516 fprintf(stderr, "ss: \"%s\" is illegal socket table id\n", p);
4517 usage();
4518 }
4519 p = p1 + 1;
4520 } while (p1);
4521 break;
4522 }
4523 case 's':
4524 do_summary = 1;
4525 break;
4526 case 'D':
4527 dump_tcpdiag = optarg;
4528 break;
4529 case 'F':
4530 if (filter_fp) {
4531 fprintf(stderr, "More than one filter file\n");
4532 exit(-1);
4533 }
4534 if (optarg[0] == '-')
4535 filter_fp = stdin;
4536 else
4537 filter_fp = fopen(optarg, "r");
4538 if (!filter_fp) {
4539 perror("fopen filter file");
4540 exit(-1);
4541 }
4542 break;
4543 case 'v':
4544 case 'V':
4545 printf("ss utility, iproute2-ss%s\n", SNAPSHOT);
4546 exit(0);
116ac927
RH		 4547 case 'z':
4548 show_sock_ctx++;
36df1a6e 4549 /* fall through */
116ac927
RH		 4550 case 'Z':
4551 if (is_selinux_enabled() <= 0) {
4552 fprintf(stderr, "ss: SELinux is not enabled.\n");
4553 exit(1);
4554 }
4555 show_proc_ctx++;
4556 user_ent_hash_build();
4557 break;
95ce04bc
VK		 4558 case 'N':
4559 if (netns_switch(optarg))
4560 exit(1);
4561 break;
fb2594c1
LC		 4562 case 'K':
4563 current_filter.kill = 1;
4564 break;
7a4559f6
DA		 4565 case 'H':
4566 show_header = 0;
4567 break;
aba5acdf 4568 case 'h':
7a96e199 4569 help();
f73105ab 4570 case '?':
aba5acdf
SH		 4571 default:
4572 usage();
4573 }
4574 }
4575
4576 argc -= optind;
4577 argv += optind;
4578
aba5acdf
SH		 4579 if (do_summary) {
4580 print_summary();
4581 if (do_default && argc == 0)
4582 exit(0);
4583 }
4584
aba5acdf
SH		 4585 while (argc > 0) {
4586 if (strcmp(*argv, "state") == 0) {
4587 NEXT_ARG();
4588 if (!saw_states)
9db7bf15
VK		 4589 state_filter = 0;
4590 state_filter |= scan_state(*argv);
aba5acdf
SH		 4591 saw_states = 1;
4592 } else if (strcmp(*argv, "exclude") == 0 ||
4593 strcmp(*argv, "excl") == 0) {
4594 NEXT_ARG();
4595 if (!saw_states)
9db7bf15
VK		 4596 state_filter = SS_ALL;
4597 state_filter &= ~scan_state(*argv);
aba5acdf
SH		 4598 saw_states = 1;
4599 } else {
aba5acdf
SH		 4600 break;
4601 }
4602 argc--; argv++;
4603 }
4604
9db7bf15
VK		 4605 if (do_default) {
4606 state_filter = state_filter ? state_filter : SS_CONN;
4607 filter_default_dbs(&current_filter);
9db7bf15
VK		 4608 }
4609
57ff5a10
VK		 4610 filter_states_set(&current_filter, state_filter);
4611 filter_merge_defaults(&current_filter);
4612
9db7bf15 4613 if (resolve_services && resolve_hosts &&
168d97f9 4614 (current_filter.dbs & (UNIX_DBM|INET_L4_DBM)))
9db7bf15
VK		 4615 init_service_resolver();
4616
9db7bf15
VK		 4617 if (current_filter.dbs == 0) {
4618 fprintf(stderr, "ss: no socket tables to show with such filter.\n");
4619 exit(0);
4620 }
4621 if (current_filter.families == 0) {
4622 fprintf(stderr, "ss: no families to show with such filter.\n");
4623 exit(0);
4624 }
aba5acdf
SH		 4625 if (current_filter.states == 0) {
4626 fprintf(stderr, "ss: no socket states to show with such filter.\n");
4627 exit(0);
4628 }
4629
4630 if (dump_tcpdiag) {
4631 FILE *dump_fp = stdout;
acd1e437 4632
aba5acdf
SH		 4633 if (!(current_filter.dbs & (1<<TCP_DB))) {
4634 fprintf(stderr, "ss: tcpdiag dump requested and no tcp in filter.\n");
4635 exit(0);
4636 }
4637 if (dump_tcpdiag[0] != '-') {
4638 dump_fp = fopen(dump_tcpdiag, "w");
4639 if (!dump_tcpdiag) {
4640 perror("fopen dump file");
4641 exit(-1);
4642 }
4643 }
3fe5b534 4644 inet_show_netlink(&current_filter, dump_fp, IPPROTO_TCP);
aba5acdf
SH		 4645 fflush(dump_fp);
4646 exit(0);
4647 }
4648
1527a17e
VK		 4649 if (ssfilter_parse(&current_filter.f, argc, argv, filter_fp))
4650 usage();
4651
aba5acdf 4652 if (current_filter.dbs&(current_filter.dbs-1))
59f46b7b 4653 columns[COL_NETID].width = 6;
aba5acdf 4654
aba5acdf 4655 if (current_filter.states&(current_filter.states-1))
59f46b7b
SB		 4656 columns[COL_STATE].width = 10;
4657
4658 /* If Netid or State are hidden, no delimiter before next column */
4659 if (!columns[COL_NETID].width)
4660 columns[COL_STATE].width--;
4661 else if (!columns[COL_STATE].width)
4662 columns[COL_RECVQ].width--;
aba5acdf 4663
aba5acdf
SH		 4664 if (isatty(STDOUT_FILENO)) {
4665 struct winsize w;
4666
4667 if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &w) != -1) {
4668 if (w.ws_col > 0)
4669 screen_width = w.ws_col;
4670 }
4671 }
4672
59f46b7b
SB		 4673 addrp_width = screen_width -
4674 columns[COL_NETID].width -
4675 columns[COL_STATE].width -
4676 columns[COL_RECVQ].width -
4677 columns[COL_SENDQ].width;
aba5acdf
SH		 4678
4679 if (addrp_width&1) {
59f46b7b
SB		 4680 if (columns[COL_NETID].width)
4681 columns[COL_NETID].width++;
4682 else if (columns[COL_STATE].width)
4683 columns[COL_STATE].width++;
4357f5c3 4684 else
59f46b7b 4685 columns[COL_SENDQ].width++;
aba5acdf
SH		 4686 }
4687
4688 addrp_width /= 2;
aba5acdf 4689
59f46b7b
SB		 4690 columns[COL_SERV].width = resolve_services ? 8 : 6;
4691 if (addrp_width < 15 + columns[COL_SERV].width)
4692 addrp_width = 15 + columns[COL_SERV].width;
aba5acdf 4693
59f46b7b 4694 columns[COL_ADDR].width = addrp_width - columns[COL_SERV].width;
aba5acdf 4695
d68e00f7 4696 /* Make enough space for the local/remote port field */
59f46b7b
SB		 4697 columns[COL_ADDR].width -= 13;
4698 columns[COL_SERV].width += 13;
2dc85485 4699
59f46b7b
SB		 4700 columns[COL_RADDR].width = columns[COL_ADDR].width;
4701 columns[COL_RSERV].width = columns[COL_SERV].width;
4702
4703 if (show_header)
4704 print_header();
aba5acdf 4705
aba5acdf
SH		 4706 fflush(stdout);
4707
6885e3bf
CG		 4708 if (follow_events)
4709 exit(handle_follow_request(&current_filter));
4710
aba5acdf
SH		 4711 if (current_filter.dbs & (1<<NETLINK_DB))
4712 netlink_show(&current_filter);
4713 if (current_filter.dbs & PACKET_DBM)
4714 packet_show(&current_filter);
4715 if (current_filter.dbs & UNIX_DBM)
4716 unix_show(&current_filter);
4717 if (current_filter.dbs & (1<<RAW_DB))
4718 raw_show(&current_filter);
4719 if (current_filter.dbs & (1<<UDP_DB))
4720 udp_show(&current_filter);
4721 if (current_filter.dbs & (1<<TCP_DB))
6c6bbc30 4722 tcp_show(&current_filter);
351efcde 4723 if (current_filter.dbs & (1<<DCCP_DB))
6c6bbc30 4724 dccp_show(&current_filter);
f89d46ad
PS		 4725 if (current_filter.dbs & (1<<SCTP_DB))
4726 sctp_show(&current_filter);
c759116a
SH		 4727 if (current_filter.dbs & VSOCK_DBM)
4728 vsock_show(&current_filter);
116ac927
RH		 4729
4730 if (show_users || show_proc_ctx || show_sock_ctx)
4731 user_ent_destroy();
4732
59f46b7b
SB		 4733 field_next();
4734
aba5acdf
SH		 4735 return 0;
4736}
Upstream mirror of iproute2