/*

 * ss.c		"sockstat", socket statistics

 *

 *		This program is free software; you can redistribute it and/or

 *		modify it under the terms of the GNU General Public License

 *		as published by the Free Software Foundation; either version

 *		2 of the License, or (at your option) any later version.

 *

 * Authors:	Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>

 */

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <fcntl.h>

#include <sys/ioctl.h>

#include <sys/socket.h>

#include <sys/uio.h>

#include <sys/sysmacros.h>

#include <netinet/in.h>

#include <string.h>

#include <errno.h>

#include <netdb.h>

#include <arpa/inet.h>

#include <dirent.h>

#include <fnmatch.h>

#include <getopt.h>

#include <stdbool.h>

#include <limits.h>

#include <stdarg.h>

#include "ss_util.h"

#include "utils.h"

#include "rt_names.h"

#include "ll_map.h"

#include "libnetlink.h"

#include "namespace.h"

#include "version.h"

#include "rt_names.h"

#include "cg_map.h"

#include <linux/tcp.h>

#include <linux/unix_diag.h>

#include <linux/netdevice.h>	/* for MAX_ADDR_LEN */

#include <linux/filter.h>

#include <linux/xdp_diag.h>

#include <linux/packet_diag.h>

#include <linux/netlink_diag.h>

#include <linux/sctp.h>

#include <linux/vm_sockets_diag.h>

#include <linux/net.h>

#include <linux/tipc.h>

#include <linux/tipc_netlink.h>

#include <linux/tipc_sockets_diag.h>

#include <linux/tls.h>

#include <linux/mptcp.h>

/* AF_VSOCK/PF_VSOCK is only provided since glibc 2.18 */

#ifndef PF_VSOCK

#define PF_VSOCK 40

#endif

#ifndef AF_VSOCK

#define AF_VSOCK PF_VSOCK

#endif

#ifndef IPPROTO_MPTCP

#define IPPROTO_MPTCP 262

#endif

#define BUF_CHUNK (1024 * 1024)	/* Buffer chunk allocation size */

#define BUF_CHUNKS_MAX 5	/* Maximum number of allocated buffer chunks */

#define LEN_ALIGN(x) (((x) + 1) & ~1)

#if HAVE_SELINUX

#include <selinux/selinux.h>

#else

/* Stubs for SELinux functions */

static int is_selinux_enabled(void)

{

	return -1;

}

static int getpidcon(pid_t pid, char **context)

{

	*context = NULL;

	return -1;

}

static int getfilecon(char *path, char **context)

{

	*context = NULL;

	return -1;

}

static int security_get_initial_context(char *name,  char **context)

{

	*context = NULL;

	return -1;

}

#endif

int preferred_family = AF_UNSPEC;

static int show_options;

int show_details;

static int show_users;

static int show_mem;

static int show_tcpinfo;

static int show_bpf;

static int show_proc_ctx;

static int show_sock_ctx;

static int show_header = 1;

static int follow_events;

static int sctp_ino;

static int show_tipcinfo;

static int show_tos;

static int show_cgroup;

int oneline;

enum col_id {

	COL_NETID,

	COL_STATE,

	COL_RECVQ,

	COL_SENDQ,

	COL_ADDR,

	COL_SERV,

	COL_RADDR,

	COL_RSERV,

	COL_EXT,

	COL_PROC,

	COL_MAX

};

enum col_align {

	ALIGN_LEFT,

	ALIGN_CENTER,

	ALIGN_RIGHT

};

struct column {

	const enum col_align align;

	const char *header;

	const char *ldelim;

	int disabled;

	int width;	/* Calculated, including additional layout spacing */

	int max_len;	/* Measured maximum field length in this column */

};

static struct column columns[] = {

	{ ALIGN_LEFT,	"Netid",		"",	0, 0, 0 },

	{ ALIGN_LEFT,	"State",		" ",	0, 0, 0 },

	{ ALIGN_LEFT,	"Recv-Q",		" ",	0, 0, 0 },

	{ ALIGN_LEFT,	"Send-Q",		" ",	0, 0, 0 },

	{ ALIGN_RIGHT,	"Local Address:",	" ",	0, 0, 0 },

	{ ALIGN_LEFT,	"Port",			"",	0, 0, 0 },

	{ ALIGN_RIGHT,	"Peer Address:",	" ",	0, 0, 0 },

	{ ALIGN_LEFT,	"Port",			"",	0, 0, 0 },

	{ ALIGN_LEFT,	"Process",		"",	0, 0, 0 },

	{ ALIGN_LEFT,	"",			"",	0, 0, 0 },

};

static struct column *current_field = columns;

/* Output buffer: chained chunks of BUF_CHUNK bytes. Each field is written to

 * the buffer as a variable size token. A token consists of a 16 bits length

 * field, followed by a string which is not NULL-terminated.

 *

 * A new chunk is allocated and linked when the current chunk doesn't have

 * enough room to store the current token as a whole.

 */

struct buf_chunk {

	struct buf_chunk *next;	/* Next chained chunk */

	char *end;		/* Current end of content */

	char data[0];

};

struct buf_token {

	uint16_t len;		/* Data length, excluding length descriptor */

	char data[0];

};

static struct {

	struct buf_token *cur;	/* Position of current token in chunk */

	struct buf_chunk *head;	/* First chunk */

	struct buf_chunk *tail;	/* Current chunk */

	int chunks;		/* Number of allocated chunks */

} buffer;

static const char *TCP_PROTO = "tcp";

static const char *SCTP_PROTO = "sctp";

static const char *UDP_PROTO = "udp";

static const char *RAW_PROTO = "raw";

static const char *dg_proto;

enum {

	TCP_DB,

	MPTCP_DB,

	DCCP_DB,

	UDP_DB,

	RAW_DB,

	UNIX_DG_DB,

	UNIX_ST_DB,

	UNIX_SQ_DB,

	PACKET_DG_DB,

	PACKET_R_DB,

	NETLINK_DB,

	SCTP_DB,

	VSOCK_ST_DB,

	VSOCK_DG_DB,

	TIPC_DB,

	XDP_DB,

	MAX_DB

};

#define PACKET_DBM ((1<

#define UNIX_DBM ((1<

#define ALL_DB ((1<

#define INET_L4_DBM ((1<

#define INET_DBM (INET_L4_DBM | (1<

#define VSOCK_DBM ((1<

enum {

	SS_UNKNOWN,

	SS_ESTABLISHED,

	SS_SYN_SENT,

	SS_SYN_RECV,

	SS_FIN_WAIT1,

	SS_FIN_WAIT2,

	SS_TIME_WAIT,

	SS_CLOSE,

	SS_CLOSE_WAIT,

	SS_LAST_ACK,

	SS_LISTEN,

	SS_CLOSING,

	SS_MAX

};

enum {

	SCTP_STATE_CLOSED		= 0,

	SCTP_STATE_COOKIE_WAIT		= 1,

	SCTP_STATE_COOKIE_ECHOED	= 2,

	SCTP_STATE_ESTABLISHED		= 3,

	SCTP_STATE_SHUTDOWN_PENDING	= 4,

	SCTP_STATE_SHUTDOWN_SENT	= 5,

	SCTP_STATE_SHUTDOWN_RECEIVED	= 6,

	SCTP_STATE_SHUTDOWN_ACK_SENT	= 7,

};

#define SS_ALL ((1 << SS_MAX) - 1)

#define SS_CONN (SS_ALL & ~((1<

#define TIPC_SS_CONN ((1<

#include "ssfilter.h"

struct filter {

	int dbs;

	int states;

	uint64_t families;

	struct ssfilter *f;

	bool kill;

	struct rtnl_handle *rth_for_killing;

};

#define FAMILY_MASK(family) ((uint64_t)1 << (family))

static const struct filter default_dbs[MAX_DB] = {

	[TCP_DB] = {

		.states   = SS_CONN,

		.families = FAMILY_MASK(AF_INET) | FAMILY_MASK(AF_INET6),

	},

	[MPTCP_DB] = {

		.states   = SS_CONN,

		.families = FAMILY_MASK(AF_INET) | FAMILY_MASK(AF_INET6),

	},

	[DCCP_DB] = {

		.states   = SS_CONN,

		.families = FAMILY_MASK(AF_INET) | FAMILY_MASK(AF_INET6),

	},

	[UDP_DB] = {

		.states   = (1 << SS_ESTABLISHED),

		.families = FAMILY_MASK(AF_INET) | FAMILY_MASK(AF_INET6),

	},

	[RAW_DB] = {

		.states   = (1 << SS_ESTABLISHED),

		.families = FAMILY_MASK(AF_INET) | FAMILY_MASK(AF_INET6),

	},

	[UNIX_DG_DB] = {

		.states   = (1 << SS_CLOSE),

		.families = FAMILY_MASK(AF_UNIX),

	},

	[UNIX_ST_DB] = {

		.states   = SS_CONN,

		.families = FAMILY_MASK(AF_UNIX),

	},

	[UNIX_SQ_DB] = {

		.states   = SS_CONN,

		.families = FAMILY_MASK(AF_UNIX),

	},

	[PACKET_DG_DB] = {

		.states   = (1 << SS_CLOSE),

		.families = FAMILY_MASK(AF_PACKET),

	},

	[PACKET_R_DB] = {

		.states   = (1 << SS_CLOSE),

		.families = FAMILY_MASK(AF_PACKET),

	},

	[NETLINK_DB] = {

		.states   = (1 << SS_CLOSE),

		.families = FAMILY_MASK(AF_NETLINK),

	},

	[SCTP_DB] = {

		.states   = SS_CONN,

		.families = FAMILY_MASK(AF_INET) | FAMILY_MASK(AF_INET6),

	},

	[VSOCK_ST_DB] = {

		.states   = SS_CONN,

		.families = FAMILY_MASK(AF_VSOCK),

	},

	[VSOCK_DG_DB] = {

		.states   = SS_CONN,

		.families = FAMILY_MASK(AF_VSOCK),

	},

	[TIPC_DB] = {

		.states   = TIPC_SS_CONN,

		.families = FAMILY_MASK(AF_TIPC),

	},

	[XDP_DB] = {

		.states   = (1 << SS_CLOSE),

		.families = FAMILY_MASK(AF_XDP),

	},

};

static const struct filter default_afs[AF_MAX] = {

	[AF_INET] = {

		.dbs    = INET_DBM,

		.states = SS_CONN,

	},

	[AF_INET6] = {

		.dbs    = INET_DBM,

		.states = SS_CONN,

	},

	[AF_UNIX] = {

		.dbs    = UNIX_DBM,

		.states = SS_CONN,

	},

	[AF_PACKET] = {

		.dbs    = PACKET_DBM,

		.states = (1 << SS_CLOSE),

	},

	[AF_NETLINK] = {

		.dbs    = (1 << NETLINK_DB),

		.states = (1 << SS_CLOSE),

	},

	[AF_VSOCK] = {

		.dbs    = VSOCK_DBM,

		.states = SS_CONN,

	},

	[AF_TIPC] = {

		.dbs    = (1 << TIPC_DB),

		.states = TIPC_SS_CONN,

	},

	[AF_XDP] = {

		.dbs    = (1 << XDP_DB),

		.states = (1 << SS_CLOSE),

	},

};

static int do_default = 1;

static struct filter current_filter;

static void filter_db_set(struct filter *f, int db, bool enable)

{

	if (enable) {

		f->states   |= default_dbs[db].states;

		f->dbs	    |= 1 << db;

	} else {

		f->dbs &= ~(1 << db);

	}

	do_default   = 0;

}

static int filter_db_parse(struct filter *f, const char *s)

{

	const struct {

		const char *name;

		int dbs[MAX_DB + 1];

	} db_name_tbl[] = {

#define ENTRY(name, ...) { #name, { __VA_ARGS__, MAX_DB } }

		ENTRY(all, UDP_DB, DCCP_DB, TCP_DB, MPTCP_DB, RAW_DB,

			   UNIX_ST_DB, UNIX_DG_DB, UNIX_SQ_DB,

			   PACKET_R_DB, PACKET_DG_DB, NETLINK_DB,

			   SCTP_DB, VSOCK_ST_DB, VSOCK_DG_DB, XDP_DB),

		ENTRY(inet, UDP_DB, DCCP_DB, TCP_DB, MPTCP_DB, SCTP_DB, RAW_DB),

		ENTRY(udp, UDP_DB),

		ENTRY(dccp, DCCP_DB),

		ENTRY(tcp, TCP_DB),

		ENTRY(mptcp, MPTCP_DB),

		ENTRY(sctp, SCTP_DB),

		ENTRY(raw, RAW_DB),

		ENTRY(unix, UNIX_ST_DB, UNIX_DG_DB, UNIX_SQ_DB),

		ENTRY(unix_stream, UNIX_ST_DB),

		ENTRY(u_str, UNIX_ST_DB),	/* alias for unix_stream */

		ENTRY(unix_dgram, UNIX_DG_DB),

		ENTRY(u_dgr, UNIX_DG_DB),	/* alias for unix_dgram */

		ENTRY(unix_seqpacket, UNIX_SQ_DB),

		ENTRY(u_seq, UNIX_SQ_DB),	/* alias for unix_seqpacket */

		ENTRY(packet, PACKET_R_DB, PACKET_DG_DB),

		ENTRY(packet_raw, PACKET_R_DB),

		ENTRY(p_raw, PACKET_R_DB),	/* alias for packet_raw */

		ENTRY(packet_dgram, PACKET_DG_DB),

		ENTRY(p_dgr, PACKET_DG_DB),	/* alias for packet_dgram */

		ENTRY(netlink, NETLINK_DB),

		ENTRY(vsock, VSOCK_ST_DB, VSOCK_DG_DB),

		ENTRY(vsock_stream, VSOCK_ST_DB),

		ENTRY(v_str, VSOCK_ST_DB),	/* alias for vsock_stream */

		ENTRY(vsock_dgram, VSOCK_DG_DB),

		ENTRY(v_dgr, VSOCK_DG_DB),	/* alias for vsock_dgram */

		ENTRY(xdp, XDP_DB),

#undef ENTRY

	};

	bool enable = true;

	unsigned int i;

	const int *dbp;

	if (s[0] == '!') {

		enable = false;

		s++;

	}

	for (i = 0; i < ARRAY_SIZE(db_name_tbl); i++) {

		if (strcmp(s, db_name_tbl[i].name))

			continue;

		for (dbp = db_name_tbl[i].dbs; *dbp != MAX_DB; dbp++)

			filter_db_set(f, *dbp, enable);

		return 0;

	}

	return -1;

}

static void filter_af_set(struct filter *f, int af)

{

	f->states	   |= default_afs[af].states;

	f->families	   |= FAMILY_MASK(af);

	do_default	    = 0;

	preferred_family    = af;

}

static int filter_af_get(struct filter *f, int af)

{

	return !!(f->families & FAMILY_MASK(af));

}

static void filter_states_set(struct filter *f, int states)

{

	if (states)

		f->states = states;

}

static void filter_merge_defaults(struct filter *f)

{

	int db;

	int af;

	for (db = 0; db < MAX_DB; db++) {

		if (!(f->dbs & (1 << db)))

			continue;

		if (!(default_dbs[db].families & f->families))

			f->families |= default_dbs[db].families;

	}

	for (af = 0; af < AF_MAX; af++) {

		if (!(f->families & FAMILY_MASK(af)))

			continue;

		if (!(default_afs[af].dbs & f->dbs))

			f->dbs |= default_afs[af].dbs;

	}

}

static FILE *generic_proc_open(const char *env, const char *name)

{

	const char *p = getenv(env);

	char store[128];

	if (!p) {

		p = getenv("PROC_ROOT") ? : "/proc";

		snprintf(store, sizeof(store)-1, "%s/%s", p, name);

		p = store;

	}

	return fopen(p, "r");

}

#define net_tcp_open()		generic_proc_open("PROC_NET_TCP", "net/tcp")

#define net_tcp6_open()		generic_proc_open("PROC_NET_TCP6", "net/tcp6")

#define net_udp_open()		generic_proc_open("PROC_NET_UDP", "net/udp")

#define net_udp6_open()		generic_proc_open("PROC_NET_UDP6", "net/udp6")

#define net_raw_open()		generic_proc_open("PROC_NET_RAW", "net/raw")

#define net_raw6_open()		generic_proc_open("PROC_NET_RAW6", "net/raw6")

#define net_unix_open()		generic_proc_open("PROC_NET_UNIX", "net/unix")

#define net_packet_open()	generic_proc_open("PROC_NET_PACKET", \

							"net/packet")

#define net_netlink_open()	generic_proc_open("PROC_NET_NETLINK", \

							"net/netlink")

#define net_sockstat_open()	generic_proc_open("PROC_NET_SOCKSTAT", \

							"net/sockstat")

#define net_sockstat6_open()	generic_proc_open("PROC_NET_SOCKSTAT6", \

							"net/sockstat6")

#define net_snmp_open()		generic_proc_open("PROC_NET_SNMP", "net/snmp")

#define ephemeral_ports_open()	generic_proc_open("PROC_IP_LOCAL_PORT_RANGE", \

					"sys/net/ipv4/ip_local_port_range")

struct user_ent {

	struct user_ent	*next;

	unsigned int	ino;

	int		pid;

	int		fd;

	char		*process;

	char		*process_ctx;

	char		*socket_ctx;

};

#define USER_ENT_HASH_SIZE	256

static struct user_ent *user_ent_hash[USER_ENT_HASH_SIZE];

static int user_ent_hashfn(unsigned int ino)

{

	int val = (ino >> 24) ^ (ino >> 16) ^ (ino >> 8) ^ ino;

	return val & (USER_ENT_HASH_SIZE - 1);

}

static void user_ent_add(unsigned int ino, char *process,

					int pid, int fd,

					char *proc_ctx,

					char *sock_ctx)

{

	struct user_ent *p, **pp;

	p = malloc(sizeof(struct user_ent));

	if (!p) {

		fprintf(stderr, "ss: failed to malloc buffer\n");

		abort();

	}

	p->next = NULL;

	p->ino = ino;

	p->pid = pid;

	p->fd = fd;

	p->process = strdup(process);

	p->process_ctx = strdup(proc_ctx);

	p->socket_ctx = strdup(sock_ctx);

	pp = &user_ent_hash[user_ent_hashfn(ino)];

	p->next = *pp;

	*pp = p;

}

static void user_ent_destroy(void)

{

	struct user_ent *p, *p_next;

	int cnt = 0;

	while (cnt != USER_ENT_HASH_SIZE) {

		p = user_ent_hash[cnt];

		while (p) {

			free(p->process);

			free(p->process_ctx);

			free(p->socket_ctx);

			p_next = p->next;

			free(p);

			p = p_next;

		}

		cnt++;

	}

}

static void user_ent_hash_build(void)

{

	const char *root = getenv("PROC_ROOT") ? : "/proc/";

	struct dirent *d;

	char name[1024];

	int nameoff;

	DIR *dir;

	char *pid_context;

	char *sock_context;

	const char *no_ctx = "unavailable";

	static int user_ent_hash_build_init;

	/* If show_users & show_proc_ctx set only do this once */

	if (user_ent_hash_build_init != 0)

		return;

	user_ent_hash_build_init = 1;

	strlcpy(name, root, sizeof(name));

	if (strlen(name) == 0 || name[strlen(name)-1] != '/')

		strcat(name, "/");

	nameoff = strlen(name);

	dir = opendir(name);

	if (!dir)

		return;

	while ((d = readdir(dir)) != NULL) {

		struct dirent *d1;

		char process[16];

		char *p;

		int pid, pos;

		DIR *dir1;

		char crap;

		if (sscanf(d->d_name, "%d%c", &pid, &crap) != 1)

			continue;

		if (getpidcon(pid, &pid_context) != 0)

			pid_context = strdup(no_ctx);

		snprintf(name + nameoff, sizeof(name) - nameoff, "%d/fd/", pid);

		pos = strlen(name);

		if ((dir1 = opendir(name)) == NULL) {

			free(pid_context);

			continue;

		}

		process[0] = '\0';

		p = process;

		while ((d1 = readdir(dir1)) != NULL) {

			const char *pattern = "socket:[";

			unsigned int ino;

			char lnk[64];

			int fd;

			ssize_t link_len;

			char tmp[1024];

			if (sscanf(d1->d_name, "%d%c", &fd, &crap) != 1)

				continue;

			snprintf(name+pos, sizeof(name) - pos, "%d", fd);

			link_len = readlink(name, lnk, sizeof(lnk)-1);

			if (link_len == -1)

				continue;

			lnk[link_len] = '\0';

			if (strncmp(lnk, pattern, strlen(pattern)))

				continue;

			sscanf(lnk, "socket:[%u]", &ino);

			snprintf(tmp, sizeof(tmp), "%s/%d/fd/%s",

					root, pid, d1->d_name);

			if (getfilecon(tmp, &sock_context) <= 0)

				sock_context = strdup(no_ctx);

			if (*p == '\0') {

				FILE *fp;

				snprintf(tmp, sizeof(tmp), "%s/%d/stat",

					root, pid);

				if ((fp = fopen(tmp, "r")) != NULL) {

					if (fscanf(fp, "%*d (%[^)])", p) < 1)

						; /* ignore */

					fclose(fp);

				}

			}

			user_ent_add(ino, p, pid, fd,

					pid_context, sock_context);

			free(sock_context);

		}

		free(pid_context);

		closedir(dir1);

	}

	closedir(dir);

}

enum entry_types {

	USERS,

	PROC_CTX,

	PROC_SOCK_CTX

};

#define ENTRY_BUF_SIZE 512

static int find_entry(unsigned int ino, char **buf, int type)

{

	struct user_ent *p;

	int cnt = 0;

	char *ptr;

	char *new_buf;

	int len, new_buf_len;

	int buf_used = 0;

	int buf_len = 0;

	if (!ino)

		return 0;

	p = user_ent_hash[user_ent_hashfn(ino)];

	ptr = *buf = NULL;

	while (p) {

		if (p->ino != ino)

			goto next;

		while (1) {

			ptr = *buf + buf_used;

			switch (type) {

			case USERS:

				len = snprintf(ptr, buf_len - buf_used,

					"(\"%s\",pid=%d,fd=%d),",

					p->process, p->pid, p->fd);

				break;

			case PROC_CTX:

				len = snprintf(ptr, buf_len - buf_used,

					"(\"%s\",pid=%d,proc_ctx=%s,fd=%d),",

					p->process, p->pid,

					p->process_ctx, p->fd);

				break;

			case PROC_SOCK_CTX:

				len = snprintf(ptr, buf_len - buf_used,

					"(\"%s\",pid=%d,proc_ctx=%s,fd=%d,sock_ctx=%s),",

					p->process, p->pid,

					p->process_ctx, p->fd,

					p->socket_ctx);

				break;

			default:

				fprintf(stderr, "ss: invalid type: %d\n", type);

				abort();

			}

			if (len < 0 || len >= buf_len - buf_used) {

				new_buf_len = buf_len + ENTRY_BUF_SIZE;

				new_buf = realloc(*buf, new_buf_len);

				if (!new_buf) {

					fprintf(stderr, "ss: failed to malloc buffer\n");

					abort();

				}

				*buf = new_buf;

				buf_len = new_buf_len;

				continue;

			} else {

				buf_used += len;

				break;

			}

		}

		cnt++;

next:

		p = p->next;

	}

	if (buf_used) {

		ptr = *buf + buf_used;

		ptr[-1] = '\0';

	}

	return cnt;

}

static unsigned long long cookie_sk_get(const uint32_t *cookie)

{

	return (((unsigned long long)cookie[1] << 31) << 1) | cookie[0];

}

static const char *sctp_sstate_name[] = {

	[SCTP_STATE_CLOSED] = "CLOSED",

	[SCTP_STATE_COOKIE_WAIT] = "COOKIE_WAIT",

	[SCTP_STATE_COOKIE_ECHOED] = "COOKIE_ECHOED",

	[SCTP_STATE_ESTABLISHED] = "ESTAB",

	[SCTP_STATE_SHUTDOWN_PENDING] = "SHUTDOWN_PENDING",

	[SCTP_STATE_SHUTDOWN_SENT] = "SHUTDOWN_SENT",

	[SCTP_STATE_SHUTDOWN_RECEIVED] = "SHUTDOWN_RECEIVED",

	[SCTP_STATE_SHUTDOWN_ACK_SENT] = "ACK_SENT",

};

static const char * const stype_nameg[] = {

	"UNKNOWN",

	[SOCK_STREAM] = "STREAM",

	[SOCK_DGRAM] = "DGRAM",

	[SOCK_RDM] = "RDM",

	[SOCK_SEQPACKET] = "SEQPACKET",

};

struct sockstat {

	struct sockstat	   *next;

	unsigned int	    type;

	uint16_t	    prot;

	uint16_t	    raw_prot;

	inet_prefix	    local;

	inet_prefix	    remote;

	int		    lport;

	int		    rport;

	int		    state;

	int		    rq, wq;

	unsigned int ino;

	unsigned int uid;

	int		    refcnt;

	unsigned int	    iface;

	unsigned long long  sk;

	char *name;

	char *peer_name;

	__u32		    mark;

	__u64		    cgroup_id;

};

struct dctcpstat {

	unsigned int	ce_state;

	unsigned int	alpha;

	unsigned int	ab_ecn;

	unsigned int	ab_tot;

	bool		enabled;

};

struct tcpstat {

	struct sockstat	    ss;

	unsigned int	    timer;

	unsigned int	    timeout;

	int		    probes;

	char		    cong_alg[16];

	double		    rto, ato, rtt, rttvar;

	int		    qack, ssthresh, backoff;

	double		    send_bps;

	int		    snd_wscale;

	int		    rcv_wscale;

	int		    mss;

	int		    rcv_mss;

	int		    advmss;

	unsigned int	    pmtu;

	unsigned int	    cwnd;

	unsigned int	    lastsnd;

	unsigned int	    lastrcv;

	unsigned int	    lastack;

	double		    pacing_rate;

	double		    pacing_rate_max;

	double		    delivery_rate;

	unsigned long long  bytes_acked;

	unsigned long long  bytes_received;

	unsigned int	    segs_out;

	unsigned int	    segs_in;

	unsigned int	    data_segs_out;

	unsigned int	    data_segs_in;

	unsigned int	    unacked;

	unsigned int	    retrans;

	unsigned int	    retrans_total;

	unsigned int	    lost;

	unsigned int	    sacked;

	unsigned int	    fackets;

	unsigned int	    reordering;

	unsigned int	    not_sent;

	unsigned int	    delivered;

	unsigned int	    delivered_ce;

	unsigned int	    dsack_dups;

	unsigned int	    reord_seen;

	double		    rcv_rtt;

	double		    min_rtt;

	int		    rcv_space;

	unsigned int        rcv_ssthresh;

	unsigned long long  busy_time;

	unsigned long long  rwnd_limited;

	unsigned long long  sndbuf_limited;

	unsigned long long  bytes_sent;

	unsigned long long  bytes_retrans;

	bool		    has_ts_opt;

	bool		    has_sack_opt;

	bool		    has_ecn_opt;

	bool		    has_ecnseen_opt;

	bool		    has_fastopen_opt;

	bool		    has_wscale_opt;

	bool		    app_limited;

	struct dctcpstat    *dctcp;

	struct tcp_bbr_info *bbr_info;

};

/* SCTP assocs share the same inode number with their parent endpoint. So if we

 * have seen the inode number before, it must be an assoc instead of the next

 * endpoint. */

static bool is_sctp_assoc(struct sockstat *s, const char *sock_name)

{

	if (strcmp(sock_name, "sctp"))

		return false;

	if (!sctp_ino || sctp_ino != s->ino)

		return false;

	return true;

}