inet_diag.c

   1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 * inet_diag.c	Module for monitoring INET transport protocols sockets.
   4 *
   5 * Authors:	Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
   6 */
   7
   8#include <linux/kernel.h>
   9#include <linux/module.h>
  10#include <linux/types.h>
  11#include <linux/fcntl.h>
  12#include <linux/random.h>
  13#include <linux/slab.h>
  14#include <linux/cache.h>
  15#include <linux/init.h>
  16#include <linux/time.h>
  17
  18#include <net/icmp.h>
  19#include <net/tcp.h>
  20#include <net/ipv6.h>
  21#include <net/inet_common.h>
  22#include <net/inet_connection_sock.h>
  23#include <net/bpf_sk_storage.h>
  24#include <net/netlink.h>
  25
  26#include <linux/inet.h>
  27#include <linux/stddef.h>
  28
  29#include <linux/inet_diag.h>
  30#include <linux/sock_diag.h>
  31
  32static const struct inet_diag_handler __rcu **inet_diag_table;
  33
  34struct inet_diag_entry {
  35	const __be32 *saddr;
  36	const __be32 *daddr;
  37	u16 sport;
  38	u16 dport;
  39	u16 family;
  40	u16 userlocks;
  41	u32 ifindex;
  42	u32 mark;
  43#ifdef CONFIG_SOCK_CGROUP_DATA
  44	u64 cgroup_id;
  45#endif
  46};
  47
  48static const struct inet_diag_handler *inet_diag_lock_handler(int proto)
  49{
  50	const struct inet_diag_handler *handler;
  51
  52	if (proto < 0 || proto >= IPPROTO_MAX)
  53		return NULL;
  54
  55	if (!READ_ONCE(inet_diag_table[proto]))
  56		sock_load_diag_module(AF_INET, proto);
  57
  58	rcu_read_lock();
  59	handler = rcu_dereference(inet_diag_table[proto]);
  60	if (handler && !try_module_get(handler->owner))
  61		handler = NULL;
  62	rcu_read_unlock();
  63
  64	return handler;
  65}
  66
  67static void inet_diag_unlock_handler(const struct inet_diag_handler *handler)
  68{
  69	module_put(handler->owner);
  70}
  71
  72void inet_diag_msg_common_fill(struct inet_diag_msg *r, struct sock *sk)
  73{
  74	r->idiag_family = READ_ONCE(sk->sk_family);
  75
  76	r->id.idiag_sport = htons(READ_ONCE(sk->sk_num));
  77	r->id.idiag_dport = READ_ONCE(sk->sk_dport);
  78	r->id.idiag_if = READ_ONCE(sk->sk_bound_dev_if);
  79	sock_diag_save_cookie(sk, r->id.idiag_cookie);
  80
  81#if IS_ENABLED(CONFIG_IPV6)
  82	if (r->idiag_family == AF_INET6) {
  83		data_race(*(struct in6_addr *)r->id.idiag_src = sk->sk_v6_rcv_saddr);
  84		data_race(*(struct in6_addr *)r->id.idiag_dst = sk->sk_v6_daddr);
  85	} else
  86#endif
  87	{
  88	memset(&r->id.idiag_src, 0, sizeof(r->id.idiag_src));
  89	memset(&r->id.idiag_dst, 0, sizeof(r->id.idiag_dst));
  90
  91	r->id.idiag_src[0] = READ_ONCE(sk->sk_rcv_saddr);
  92	r->id.idiag_dst[0] = READ_ONCE(sk->sk_daddr);
  93	}
  94}
  95EXPORT_SYMBOL_GPL(inet_diag_msg_common_fill);
  96
  97int inet_diag_msg_attrs_fill(struct sock *sk, struct sk_buff *skb,
  98			     struct inet_diag_msg *r, int ext,
  99			     struct user_namespace *user_ns,
 100			     bool net_admin)
 101{
 102	const struct inet_sock *inet = inet_sk(sk);
 103	struct inet_diag_sockopt inet_sockopt;
 104
 105	if (nla_put_u8(skb, INET_DIAG_SHUTDOWN, sk->sk_shutdown))
 106		goto errout;
 107
 108	/* IPv6 dual-stack sockets use inet->tos for IPv4 connections,
 109	 * hence this needs to be included regardless of socket family.
 110	 */
 111	if (ext & (1 << (INET_DIAG_TOS - 1)))
 112		if (nla_put_u8(skb, INET_DIAG_TOS, READ_ONCE(inet->tos)) < 0)
 113			goto errout;
 114
 115#if IS_ENABLED(CONFIG_IPV6)
 116	if (r->idiag_family == AF_INET6) {
 117		if (ext & (1 << (INET_DIAG_TCLASS - 1)))
 118			if (nla_put_u8(skb, INET_DIAG_TCLASS,
 119				       inet6_sk(sk)->tclass) < 0)
 120				goto errout;
 121
 122		if (((1 << sk->sk_state) & (TCPF_LISTEN | TCPF_CLOSE)) &&
 123		    nla_put_u8(skb, INET_DIAG_SKV6ONLY, ipv6_only_sock(sk)))
 124			goto errout;
 125	}
 126#endif
 127
 128	if (net_admin && nla_put_u32(skb, INET_DIAG_MARK, READ_ONCE(sk->sk_mark)))
 129		goto errout;
 130
 131	if (ext & (1 << (INET_DIAG_CLASS_ID - 1)) ||
 132	    ext & (1 << (INET_DIAG_TCLASS - 1))) {
 133		u32 classid = 0;
 134
 135#ifdef CONFIG_CGROUP_NET_CLASSID
 136		classid = sock_cgroup_classid(&sk->sk_cgrp_data);
 137#endif
 138		/* Fallback to socket priority if class id isn't set.
 139		 * Classful qdiscs use it as direct reference to class.
 140		 * For cgroup2 classid is always zero.
 141		 */
 142		if (!classid)
 143			classid = READ_ONCE(sk->sk_priority);
 144
 145		if (nla_put_u32(skb, INET_DIAG_CLASS_ID, classid))
 146			goto errout;
 147	}
 148
 149#ifdef CONFIG_SOCK_CGROUP_DATA
 150	if (nla_put_u64_64bit(skb, INET_DIAG_CGROUP_ID,
 151			      cgroup_id(sock_cgroup_ptr(&sk->sk_cgrp_data)),
 152			      INET_DIAG_PAD))
 153		goto errout;
 154#endif
 155
 156	r->idiag_uid = from_kuid_munged(user_ns, sk_uid(sk));
 157	r->idiag_inode = sock_i_ino(sk);
 158
 159	memset(&inet_sockopt, 0, sizeof(inet_sockopt));
 160	inet_sockopt.recverr	= inet_test_bit(RECVERR, sk);
 161	inet_sockopt.is_icsk	= inet_test_bit(IS_ICSK, sk);
 162	inet_sockopt.freebind	= inet_test_bit(FREEBIND, sk);
 163	inet_sockopt.hdrincl	= inet_test_bit(HDRINCL, sk);
 164	inet_sockopt.mc_loop	= inet_test_bit(MC_LOOP, sk);
 165	inet_sockopt.transparent = inet_test_bit(TRANSPARENT, sk);
 166	inet_sockopt.mc_all	= inet_test_bit(MC_ALL, sk);
 167	inet_sockopt.nodefrag	= inet_test_bit(NODEFRAG, sk);
 168	inet_sockopt.bind_address_no_port = inet_test_bit(BIND_ADDRESS_NO_PORT, sk);
 169	inet_sockopt.recverr_rfc4884 = inet_test_bit(RECVERR_RFC4884, sk);
 170	inet_sockopt.defer_connect = inet_test_bit(DEFER_CONNECT, sk);
 171	if (nla_put(skb, INET_DIAG_SOCKOPT, sizeof(inet_sockopt),
 172		    &inet_sockopt))
 173		goto errout;
 174
 175	return 0;
 176errout:
 177	return 1;
 178}
 179EXPORT_SYMBOL_GPL(inet_diag_msg_attrs_fill);
 180
 181static int inet_diag_parse_attrs(const struct nlmsghdr *nlh, int hdrlen,
 182				 struct nlattr **req_nlas)
 183{
 184	struct nlattr *nla;
 185	int remaining;
 186
 187	nlmsg_for_each_attr(nla, nlh, hdrlen, remaining) {
 188		int type = nla_type(nla);
 189
 190		if (type == INET_DIAG_REQ_PROTOCOL && nla_len(nla) != sizeof(u32))
 191			return -EINVAL;
 192
 193		if (type < __INET_DIAG_REQ_MAX)
 194			req_nlas[type] = nla;
 195	}
 196	return 0;
 197}
 198
 199static int inet_diag_get_protocol(const struct inet_diag_req_v2 *req,
 200				  const struct inet_diag_dump_data *data)
 201{
 202	if (data->req_nlas[INET_DIAG_REQ_PROTOCOL])
 203		return nla_get_u32(data->req_nlas[INET_DIAG_REQ_PROTOCOL]);
 204	return req->sdiag_protocol;
 205}
 206
 207#define MAX_DUMP_ALLOC_SIZE (KMALLOC_MAX_SIZE - SKB_DATA_ALIGN(sizeof(struct skb_shared_info)))
 208
 209int inet_sk_diag_fill(struct sock *sk, struct inet_connection_sock *icsk,
 210		      struct sk_buff *skb, struct netlink_callback *cb,
 211		      const struct inet_diag_req_v2 *req,
 212		      u16 nlmsg_flags, bool net_admin)
 213{
 214	const struct tcp_congestion_ops *ca_ops;
 215	const struct inet_diag_handler *handler;
 216	struct inet_diag_dump_data *cb_data;
 217	int ext = req->idiag_ext;
 218	struct inet_diag_msg *r;
 219	struct nlmsghdr  *nlh;
 220	struct nlattr *attr;
 221	void *info = NULL;
 222	u8 icsk_pending;
 223	int protocol;
 224
 225	cb_data = cb->data;
 226	protocol = inet_diag_get_protocol(req, cb_data);
 227
 228	/* inet_diag_lock_handler() made sure inet_diag_table[] is stable. */
 229	handler = rcu_dereference_protected(inet_diag_table[protocol], 1);
 230	DEBUG_NET_WARN_ON_ONCE(!handler);
 231	if (!handler)
 232		return -ENXIO;
 233
 234	nlh = nlmsg_put(skb, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq,
 235			cb->nlh->nlmsg_type, sizeof(*r), nlmsg_flags);
 236	if (!nlh)
 237		return -EMSGSIZE;
 238
 239	r = nlmsg_data(nlh);
 240	BUG_ON(!sk_fullsock(sk));
 241
 242	inet_diag_msg_common_fill(r, sk);
 243	r->idiag_state = sk->sk_state;
 244	r->idiag_timer = 0;
 245	r->idiag_retrans = 0;
 246	r->idiag_expires = 0;
 247
 248	if (inet_diag_msg_attrs_fill(sk, skb, r, ext,
 249				     sk_user_ns(NETLINK_CB(cb->skb).sk),
 250				     net_admin))
 251		goto errout;
 252
 253	if (ext & (1 << (INET_DIAG_MEMINFO - 1))) {
 254		struct inet_diag_meminfo minfo = {
 255			.idiag_rmem = sk_rmem_alloc_get(sk),
 256			.idiag_wmem = READ_ONCE(sk->sk_wmem_queued),
 257			.idiag_fmem = READ_ONCE(sk->sk_forward_alloc),
 258			.idiag_tmem = sk_wmem_alloc_get(sk),
 259		};
 260
 261		if (nla_put(skb, INET_DIAG_MEMINFO, sizeof(minfo), &minfo) < 0)
 262			goto errout;
 263	}
 264
 265	if (ext & (1 << (INET_DIAG_SKMEMINFO - 1)))
 266		if (sock_diag_put_meminfo(sk, skb, INET_DIAG_SKMEMINFO))
 267			goto errout;
 268
 269	/*
 270	 * RAW sockets might have user-defined protocols assigned,
 271	 * so report the one supplied on socket creation.
 272	 */
 273	if (sk->sk_type == SOCK_RAW) {
 274		if (nla_put_u8(skb, INET_DIAG_PROTOCOL, sk->sk_protocol))
 275			goto errout;
 276	}
 277
 278	if (!icsk) {
 279		handler->idiag_get_info(sk, r, NULL);
 280		goto out;
 281	}
 282
 283	icsk_pending = smp_load_acquire(&icsk->icsk_pending);
 284	if (icsk_pending == ICSK_TIME_RETRANS ||
 285	    icsk_pending == ICSK_TIME_REO_TIMEOUT ||
 286	    icsk_pending == ICSK_TIME_LOSS_PROBE) {
 287		r->idiag_timer = 1;
 288		r->idiag_retrans = READ_ONCE(icsk->icsk_retransmits);
 289		r->idiag_expires =
 290			jiffies_delta_to_msecs(tcp_timeout_expires(sk) - jiffies);
 291	} else if (icsk_pending == ICSK_TIME_PROBE0) {
 292		r->idiag_timer = 4;
 293		r->idiag_retrans = READ_ONCE(icsk->icsk_probes_out);
 294		r->idiag_expires =
 295			jiffies_delta_to_msecs(tcp_timeout_expires(sk) - jiffies);
 296	} else if (timer_pending(&icsk->icsk_keepalive_timer)) {
 297		r->idiag_timer = 2;
 298		r->idiag_retrans = READ_ONCE(icsk->icsk_probes_out);
 299		r->idiag_expires =
 300			jiffies_delta_to_msecs(icsk->icsk_keepalive_timer.expires - jiffies);
 301	}
 302
 303	if ((ext & (1 << (INET_DIAG_INFO - 1))) && handler->idiag_info_size) {
 304		attr = nla_reserve_64bit(skb, INET_DIAG_INFO,
 305					 handler->idiag_info_size,
 306					 INET_DIAG_PAD);
 307		if (!attr)
 308			goto errout;
 309
 310		info = nla_data(attr);
 311	}
 312
 313	if (ext & (1 << (INET_DIAG_CONG - 1))) {
 314		int err = 0;
 315
 316		rcu_read_lock();
 317		ca_ops = READ_ONCE(icsk->icsk_ca_ops);
 318		if (ca_ops)
 319			err = nla_put_string(skb, INET_DIAG_CONG, ca_ops->name);
 320		rcu_read_unlock();
 321		if (err < 0)
 322			goto errout;
 323	}
 324
 325	handler->idiag_get_info(sk, r, info);
 326
 327	if (ext & (1 << (INET_DIAG_INFO - 1)) && handler->idiag_get_aux)
 328		if (handler->idiag_get_aux(sk, net_admin, skb) < 0)
 329			goto errout;
 330
 331	if (sk->sk_state < TCP_TIME_WAIT) {
 332		union tcp_cc_info info;
 333		size_t sz = 0;
 334		int attr;
 335
 336		rcu_read_lock();
 337		ca_ops = READ_ONCE(icsk->icsk_ca_ops);
 338		if (ca_ops && ca_ops->get_info)
 339			sz = ca_ops->get_info(sk, ext, &attr, &info);
 340		rcu_read_unlock();
 341		if (sz && nla_put(skb, attr, sz, &info) < 0)
 342			goto errout;
 343	}
 344
 345	/* Keep it at the end for potential retry with a larger skb,
 346	 * or else do best-effort fitting, which is only done for the
 347	 * first_nlmsg.
 348	 */
 349	if (cb_data->bpf_stg_diag) {
 350		bool first_nlmsg = ((unsigned char *)nlh == skb->data);
 351		unsigned int prev_min_dump_alloc;
 352		unsigned int total_nla_size = 0;
 353		unsigned int msg_len;
 354		int err;
 355
 356		msg_len = skb_tail_pointer(skb) - (unsigned char *)nlh;
 357		err = bpf_sk_storage_diag_put(cb_data->bpf_stg_diag, sk, skb,
 358					      INET_DIAG_SK_BPF_STORAGES,
 359					      &total_nla_size);
 360
 361		if (!err)
 362			goto out;
 363
 364		total_nla_size += msg_len;
 365		prev_min_dump_alloc = cb->min_dump_alloc;
 366		if (total_nla_size > prev_min_dump_alloc)
 367			cb->min_dump_alloc = min_t(u32, total_nla_size,
 368						   MAX_DUMP_ALLOC_SIZE);
 369
 370		if (!first_nlmsg)
 371			goto errout;
 372
 373		if (cb->min_dump_alloc > prev_min_dump_alloc)
 374			/* Retry with pskb_expand_head() with
 375			 * __GFP_DIRECT_RECLAIM
 376			 */
 377			goto errout;
 378
 379		WARN_ON_ONCE(total_nla_size <= prev_min_dump_alloc);
 380
 381		/* Send what we have for this sk
 382		 * and move on to the next sk in the following
 383		 * dump()
 384		 */
 385	}
 386
 387out:
 388	nlmsg_end(skb, nlh);
 389	return 0;
 390
 391errout:
 392	nlmsg_cancel(skb, nlh);
 393	return -EMSGSIZE;
 394}
 395EXPORT_SYMBOL_GPL(inet_sk_diag_fill);
 396
 397static int inet_diag_cmd_exact(int cmd, struct sk_buff *in_skb,
 398			       const struct nlmsghdr *nlh,
 399			       int hdrlen,
 400			       const struct inet_diag_req_v2 *req)
 401{
 402	const struct inet_diag_handler *handler;
 403	struct inet_diag_dump_data dump_data;
 404	int err, protocol;
 405
 406	memset(&dump_data, 0, sizeof(dump_data));
 407	err = inet_diag_parse_attrs(nlh, hdrlen, dump_data.req_nlas);
 408	if (err)
 409		return err;
 410
 411	protocol = inet_diag_get_protocol(req, &dump_data);
 412
 413	handler = inet_diag_lock_handler(protocol);
 414	if (!handler)
 415		return -ENOENT;
 416
 417	if (cmd == SOCK_DIAG_BY_FAMILY) {
 418		struct netlink_callback cb = {
 419			.nlh = nlh,
 420			.skb = in_skb,
 421			.data = &dump_data,
 422		};
 423		err = handler->dump_one(&cb, req);
 424	} else if (cmd == SOCK_DESTROY && handler->destroy) {
 425		err = handler->destroy(in_skb, req);
 426	} else {
 427		err = -EOPNOTSUPP;
 428	}
 429	inet_diag_unlock_handler(handler);
 430
 431	return err;
 432}
 433
 434static int bitstring_match(const __be32 *a1, const __be32 *a2, int bits)
 435{
 436	int words = bits >> 5;
 437
 438	bits &= 0x1f;
 439
 440	if (words) {
 441		if (memcmp(a1, a2, words << 2))
 442			return 0;
 443	}
 444	if (bits) {
 445		__be32 w1, w2;
 446		__be32 mask;
 447
 448		w1 = a1[words];
 449		w2 = a2[words];
 450
 451		mask = htonl((0xffffffff) << (32 - bits));
 452
 453		if ((w1 ^ w2) & mask)
 454			return 0;
 455	}
 456
 457	return 1;
 458}
 459
 460static int inet_diag_bc_run(const struct nlattr *_bc,
 461			    const struct inet_diag_entry *entry)
 462{
 463	const void *bc = nla_data(_bc);
 464	int len = nla_len(_bc);
 465
 466	while (len > 0) {
 467		int yes = 1;
 468		const struct inet_diag_bc_op *op = bc;
 469
 470		switch (op->code) {
 471		case INET_DIAG_BC_NOP:
 472			break;
 473		case INET_DIAG_BC_JMP:
 474			yes = 0;
 475			break;
 476		case INET_DIAG_BC_S_EQ:
 477			yes = entry->sport == op[1].no;
 478			break;
 479		case INET_DIAG_BC_S_GE:
 480			yes = entry->sport >= op[1].no;
 481			break;
 482		case INET_DIAG_BC_S_LE:
 483			yes = entry->sport <= op[1].no;
 484			break;
 485		case INET_DIAG_BC_D_EQ:
 486			yes = entry->dport == op[1].no;
 487			break;
 488		case INET_DIAG_BC_D_GE:
 489			yes = entry->dport >= op[1].no;
 490			break;
 491		case INET_DIAG_BC_D_LE:
 492			yes = entry->dport <= op[1].no;
 493			break;
 494		case INET_DIAG_BC_AUTO:
 495			yes = !(entry->userlocks & SOCK_BINDPORT_LOCK);
 496			break;
 497		case INET_DIAG_BC_S_COND:
 498		case INET_DIAG_BC_D_COND: {
 499			const struct inet_diag_hostcond *cond;
 500			const __be32 *addr;
 501
 502			cond = (const struct inet_diag_hostcond *)(op + 1);
 503			if (cond->port != -1 &&
 504			    cond->port != (op->code == INET_DIAG_BC_S_COND ?
 505					     entry->sport : entry->dport)) {
 506				yes = 0;
 507				break;
 508			}
 509
 510			if (op->code == INET_DIAG_BC_S_COND)
 511				addr = entry->saddr;
 512			else
 513				addr = entry->daddr;
 514
 515			if (cond->family != AF_UNSPEC &&
 516			    cond->family != entry->family) {
 517				if (entry->family == AF_INET6 &&
 518				    cond->family == AF_INET) {
 519					if (addr[0] == 0 && addr[1] == 0 &&
 520					    addr[2] == htonl(0xffff) &&
 521					    bitstring_match(addr + 3,
 522							    cond->addr,
 523							    cond->prefix_len))
 524						break;
 525				}
 526				yes = 0;
 527				break;
 528			}
 529
 530			if (cond->prefix_len == 0)
 531				break;
 532			if (bitstring_match(addr, cond->addr,
 533					    cond->prefix_len))
 534				break;
 535			yes = 0;
 536			break;
 537		}
 538		case INET_DIAG_BC_DEV_COND: {
 539			u32 ifindex;
 540
 541			ifindex = *((const u32 *)(op + 1));
 542			if (ifindex != entry->ifindex)
 543				yes = 0;
 544			break;
 545		}
 546		case INET_DIAG_BC_MARK_COND: {
 547			struct inet_diag_markcond *cond;
 548
 549			cond = (struct inet_diag_markcond *)(op + 1);
 550			if ((entry->mark & cond->mask) != cond->mark)
 551				yes = 0;
 552			break;
 553		}
 554#ifdef CONFIG_SOCK_CGROUP_DATA
 555		case INET_DIAG_BC_CGROUP_COND: {
 556			u64 cgroup_id;
 557
 558			cgroup_id = get_unaligned((const u64 *)(op + 1));
 559			if (cgroup_id != entry->cgroup_id)
 560				yes = 0;
 561			break;
 562		}
 563#endif
 564		}
 565
 566		if (yes) {
 567			len -= op->yes;
 568			bc += op->yes;
 569		} else {
 570			len -= op->no;
 571			bc += op->no;
 572		}
 573	}
 574	return len == 0;
 575}
 576
 577/* This helper is available for all sockets (ESTABLISH, TIMEWAIT, SYN_RECV)
 578 */
 579static void entry_fill_addrs(struct inet_diag_entry *entry,
 580			     const struct sock *sk)
 581{
 582#if IS_ENABLED(CONFIG_IPV6)
 583	if (entry->family == AF_INET6) {
 584		entry->saddr = sk->sk_v6_rcv_saddr.s6_addr32;
 585		entry->daddr = sk->sk_v6_daddr.s6_addr32;
 586	} else
 587#endif
 588	{
 589		entry->saddr = &sk->sk_rcv_saddr;
 590		entry->daddr = &sk->sk_daddr;
 591	}
 592}
 593
 594int inet_diag_bc_sk(const struct inet_diag_dump_data *cb_data, struct sock *sk)
 595{
 596	const struct nlattr *bc = cb_data->inet_diag_nla_bc;
 597	const struct inet_sock *inet = inet_sk(sk);
 598	struct inet_diag_entry entry;
 599
 600	if (!bc)
 601		return 1;
 602
 603	entry.family = READ_ONCE(sk->sk_family);
 604	entry_fill_addrs(&entry, sk);
 605	entry.sport = READ_ONCE(inet->inet_num);
 606	entry.dport = ntohs(READ_ONCE(inet->inet_dport));
 607	entry.ifindex = READ_ONCE(sk->sk_bound_dev_if);
 608	if (cb_data->userlocks_needed)
 609		entry.userlocks = sk_fullsock(sk) ? READ_ONCE(sk->sk_userlocks) : 0;
 610	if (cb_data->mark_needed) {
 611		if (sk_fullsock(sk))
 612			entry.mark = READ_ONCE(sk->sk_mark);
 613		else if (sk->sk_state == TCP_NEW_SYN_RECV)
 614			entry.mark = inet_rsk(inet_reqsk(sk))->ir_mark;
 615		else if (sk->sk_state == TCP_TIME_WAIT)
 616			entry.mark = inet_twsk(sk)->tw_mark;
 617		else
 618			entry.mark = 0;
 619	}
 620#ifdef CONFIG_SOCK_CGROUP_DATA
 621	if (cb_data->cgroup_needed)
 622		entry.cgroup_id = sk_fullsock(sk) ?
 623			cgroup_id(sock_cgroup_ptr(&sk->sk_cgrp_data)) : 0;
 624#endif
 625
 626	return inet_diag_bc_run(bc, &entry);
 627}
 628EXPORT_SYMBOL_GPL(inet_diag_bc_sk);
 629
 630static int valid_cc(const void *bc, int len, int cc)
 631{
 632	while (len >= 0) {
 633		const struct inet_diag_bc_op *op = bc;
 634
 635		if (cc > len)
 636			return 0;
 637		if (cc == len)
 638			return 1;
 639		if (op->yes < 4 || op->yes & 3)
 640			return 0;
 641		len -= op->yes;
 642		bc  += op->yes;
 643	}
 644	return 0;
 645}
 646
 647/* data is u32 ifindex */
 648static bool valid_devcond(const struct inet_diag_bc_op *op, int len,
 649			  int *min_len)
 650{
 651	/* Check ifindex space. */
 652	*min_len += sizeof(u32);
 653	if (len < *min_len)
 654		return false;
 655
 656	return true;
 657}
 658/* Validate an inet_diag_hostcond. */
 659static bool valid_hostcond(const struct inet_diag_bc_op *op, int len,
 660			   int *min_len)
 661{
 662	struct inet_diag_hostcond *cond;
 663	int addr_len;
 664
 665	/* Check hostcond space. */
 666	*min_len += sizeof(struct inet_diag_hostcond);
 667	if (len < *min_len)
 668		return false;
 669	cond = (struct inet_diag_hostcond *)(op + 1);
 670
 671	/* Check address family and address length. */
 672	switch (cond->family) {
 673	case AF_UNSPEC:
 674		addr_len = 0;
 675		break;
 676	case AF_INET:
 677		addr_len = sizeof(struct in_addr);
 678		break;
 679	case AF_INET6:
 680		addr_len = sizeof(struct in6_addr);
 681		break;
 682	default:
 683		return false;
 684	}
 685	*min_len += addr_len;
 686	if (len < *min_len)
 687		return false;
 688
 689	/* Check prefix length (in bits) vs address length (in bytes). */
 690	if (cond->prefix_len > 8 * addr_len)
 691		return false;
 692
 693	return true;
 694}
 695
 696/* Validate a port comparison operator. */
 697static bool valid_port_comparison(const struct inet_diag_bc_op *op,
 698				  int len, int *min_len)
 699{
 700	/* Port comparisons put the port in a follow-on inet_diag_bc_op. */
 701	*min_len += sizeof(struct inet_diag_bc_op);
 702	if (len < *min_len)
 703		return false;
 704	return true;
 705}
 706
 707static bool valid_markcond(const struct inet_diag_bc_op *op, int len,
 708			   int *min_len)
 709{
 710	*min_len += sizeof(struct inet_diag_markcond);
 711	return len >= *min_len;
 712}
 713
 714#ifdef CONFIG_SOCK_CGROUP_DATA
 715static bool valid_cgroupcond(const struct inet_diag_bc_op *op, int len,
 716			     int *min_len)
 717{
 718	*min_len += sizeof(u64);
 719	return len >= *min_len;
 720}
 721#endif
 722
 723static int inet_diag_bc_audit(struct inet_diag_dump_data *cb_data,
 724			      const struct sk_buff *skb)
 725{
 726	const struct nlattr *attr = cb_data->inet_diag_nla_bc;
 727	const void *bytecode, *bc;
 728	int bytecode_len, len;
 729	bool net_admin;
 730
 731	if (!attr)
 732		return 0;
 733
 734	if (nla_len(attr) < sizeof(struct inet_diag_bc_op))
 735		return -EINVAL;
 736
 737	net_admin = netlink_net_capable(skb, CAP_NET_ADMIN);
 738	bytecode = bc = nla_data(attr);
 739	len = bytecode_len = nla_len(attr);
 740
 741	while (len > 0) {
 742		int min_len = sizeof(struct inet_diag_bc_op);
 743		const struct inet_diag_bc_op *op = bc;
 744
 745		switch (op->code) {
 746		case INET_DIAG_BC_S_COND:
 747		case INET_DIAG_BC_D_COND:
 748			if (!valid_hostcond(bc, len, &min_len))
 749				return -EINVAL;
 750			break;
 751		case INET_DIAG_BC_DEV_COND:
 752			if (!valid_devcond(bc, len, &min_len))
 753				return -EINVAL;
 754			break;
 755		case INET_DIAG_BC_S_EQ:
 756		case INET_DIAG_BC_S_GE:
 757		case INET_DIAG_BC_S_LE:
 758		case INET_DIAG_BC_D_EQ:
 759		case INET_DIAG_BC_D_GE:
 760		case INET_DIAG_BC_D_LE:
 761			if (!valid_port_comparison(bc, len, &min_len))
 762				return -EINVAL;
 763			break;
 764		case INET_DIAG_BC_MARK_COND:
 765			if (!net_admin)
 766				return -EPERM;
 767			if (!valid_markcond(bc, len, &min_len))
 768				return -EINVAL;
 769			cb_data->mark_needed = true;
 770			break;
 771#ifdef CONFIG_SOCK_CGROUP_DATA
 772		case INET_DIAG_BC_CGROUP_COND:
 773			if (!valid_cgroupcond(bc, len, &min_len))
 774				return -EINVAL;
 775			cb_data->cgroup_needed = true;
 776			break;
 777#endif
 778		case INET_DIAG_BC_AUTO:
 779			cb_data->userlocks_needed = true;
 780			fallthrough;
 781		case INET_DIAG_BC_JMP:
 782		case INET_DIAG_BC_NOP:
 783			break;
 784		default:
 785			return -EINVAL;
 786		}
 787
 788		if (op->code != INET_DIAG_BC_NOP) {
 789			if (op->no < min_len || op->no > len + 4 || op->no & 3)
 790				return -EINVAL;
 791			if (op->no < len &&
 792			    !valid_cc(bytecode, bytecode_len, len - op->no))
 793				return -EINVAL;
 794		}
 795
 796		if (op->yes < min_len || op->yes > len + 4 || op->yes & 3)
 797			return -EINVAL;
 798		bc  += op->yes;
 799		len -= op->yes;
 800	}
 801	return len == 0 ? 0 : -EINVAL;
 802}
 803
 804static int __inet_diag_dump(struct sk_buff *skb, struct netlink_callback *cb,
 805			    const struct inet_diag_req_v2 *r)
 806{
 807	struct inet_diag_dump_data *cb_data = cb->data;
 808	const struct inet_diag_handler *handler;
 809	u32 prev_min_dump_alloc;
 810	int protocol, err = 0;
 811
 812	protocol = inet_diag_get_protocol(r, cb_data);
 813
 814again:
 815	prev_min_dump_alloc = cb->min_dump_alloc;
 816	handler = inet_diag_lock_handler(protocol);
 817	if (handler) {
 818		handler->dump(skb, cb, r);
 819		inet_diag_unlock_handler(handler);
 820	} else {
 821		err = -ENOENT;
 822	}
 823	/* The skb is not large enough to fit one sk info and
 824	 * inet_sk_diag_fill() has requested for a larger skb.
 825	 */
 826	if (!skb->len && cb->min_dump_alloc > prev_min_dump_alloc) {
 827		err = pskb_expand_head(skb, 0, cb->min_dump_alloc, GFP_KERNEL);
 828		if (!err)
 829			goto again;
 830	}
 831
 832	return err ? : skb->len;
 833}
 834
 835static int inet_diag_dump(struct sk_buff *skb, struct netlink_callback *cb)
 836{
 837	return __inet_diag_dump(skb, cb, nlmsg_data(cb->nlh));
 838}
 839
 840static int __inet_diag_dump_start(struct netlink_callback *cb, int hdrlen)
 841{
 842	const struct nlmsghdr *nlh = cb->nlh;
 843	struct inet_diag_dump_data *cb_data;
 844	struct sk_buff *skb = cb->skb;
 845	struct nlattr *nla;
 846	int err;
 847
 848	cb_data = kzalloc(sizeof(*cb_data), GFP_KERNEL);
 849	if (!cb_data)
 850		return -ENOMEM;
 851
 852	err = inet_diag_parse_attrs(nlh, hdrlen, cb_data->req_nlas);
 853	if (err) {
 854		kfree(cb_data);
 855		return err;
 856	}
 857	err = inet_diag_bc_audit(cb_data, skb);
 858	if (err) {
 859		kfree(cb_data);
 860		return err;
 861	}
 862
 863	nla = cb_data->inet_diag_nla_bpf_stgs;
 864	if (nla) {
 865		struct bpf_sk_storage_diag *bpf_stg_diag;
 866
 867		bpf_stg_diag = bpf_sk_storage_diag_alloc(nla);
 868		if (IS_ERR(bpf_stg_diag)) {
 869			kfree(cb_data);
 870			return PTR_ERR(bpf_stg_diag);
 871		}
 872		cb_data->bpf_stg_diag = bpf_stg_diag;
 873	}
 874
 875	cb->data = cb_data;
 876	return 0;
 877}
 878
 879static int inet_diag_dump_start(struct netlink_callback *cb)
 880{
 881	return __inet_diag_dump_start(cb, sizeof(struct inet_diag_req_v2));
 882}
 883
 884static int inet_diag_dump_start_compat(struct netlink_callback *cb)
 885{
 886	return __inet_diag_dump_start(cb, sizeof(struct inet_diag_req));
 887}
 888
 889static int inet_diag_dump_done(struct netlink_callback *cb)
 890{
 891	struct inet_diag_dump_data *cb_data = cb->data;
 892
 893	bpf_sk_storage_diag_free(cb_data->bpf_stg_diag);
 894	kfree(cb->data);
 895
 896	return 0;
 897}
 898
 899static int inet_diag_type2proto(int type)
 900{
 901	switch (type) {
 902	case TCPDIAG_GETSOCK:
 903		return IPPROTO_TCP;
 904	default:
 905		return 0;
 906	}
 907}
 908
 909static int inet_diag_dump_compat(struct sk_buff *skb,
 910				 struct netlink_callback *cb)
 911{
 912	struct inet_diag_req *rc = nlmsg_data(cb->nlh);
 913	struct inet_diag_req_v2 req;
 914
 915	req.sdiag_family = AF_UNSPEC; /* compatibility */
 916	req.sdiag_protocol = inet_diag_type2proto(cb->nlh->nlmsg_type);
 917	req.idiag_ext = rc->idiag_ext;
 918	req.pad = 0;
 919	req.idiag_states = rc->idiag_states;
 920	req.id = rc->id;
 921
 922	return __inet_diag_dump(skb, cb, &req);
 923}
 924
 925static int inet_diag_get_exact_compat(struct sk_buff *in_skb,
 926				      const struct nlmsghdr *nlh)
 927{
 928	struct inet_diag_req *rc = nlmsg_data(nlh);
 929	struct inet_diag_req_v2 req;
 930
 931	req.sdiag_family = rc->idiag_family;
 932	req.sdiag_protocol = inet_diag_type2proto(nlh->nlmsg_type);
 933	req.idiag_ext = rc->idiag_ext;
 934	req.pad = 0;
 935	req.idiag_states = rc->idiag_states;
 936	req.id = rc->id;
 937
 938	return inet_diag_cmd_exact(SOCK_DIAG_BY_FAMILY, in_skb, nlh,
 939				   sizeof(struct inet_diag_req), &req);
 940}
 941
 942static int inet_diag_rcv_msg_compat(struct sk_buff *skb, struct nlmsghdr *nlh)
 943{
 944	int hdrlen = sizeof(struct inet_diag_req);
 945	struct net *net = sock_net(skb->sk);
 946
 947	if (nlh->nlmsg_type >= INET_DIAG_GETSOCK_MAX ||
 948	    nlmsg_len(nlh) < hdrlen)
 949		return -EINVAL;
 950
 951	if (nlh->nlmsg_flags & NLM_F_DUMP) {
 952		struct netlink_dump_control c = {
 953			.start = inet_diag_dump_start_compat,
 954			.done = inet_diag_dump_done,
 955			.dump = inet_diag_dump_compat,
 956		};
 957		return netlink_dump_start(net->diag_nlsk, skb, nlh, &c);
 958	}
 959
 960	return inet_diag_get_exact_compat(skb, nlh);
 961}
 962
 963static int inet_diag_handler_cmd(struct sk_buff *skb, struct nlmsghdr *h)
 964{
 965	int hdrlen = sizeof(struct inet_diag_req_v2);
 966	struct net *net = sock_net(skb->sk);
 967
 968	if (nlmsg_len(h) < hdrlen)
 969		return -EINVAL;
 970
 971	if (h->nlmsg_type == SOCK_DIAG_BY_FAMILY &&
 972	    h->nlmsg_flags & NLM_F_DUMP) {
 973		struct netlink_dump_control c = {
 974			.start = inet_diag_dump_start,
 975			.done = inet_diag_dump_done,
 976			.dump = inet_diag_dump,
 977		};
 978		return netlink_dump_start(net->diag_nlsk, skb, h, &c);
 979	}
 980
 981	return inet_diag_cmd_exact(h->nlmsg_type, skb, h, hdrlen,
 982				   nlmsg_data(h));
 983}
 984
 985static
 986int inet_diag_handler_get_info(struct sk_buff *skb, struct sock *sk)
 987{
 988	const struct inet_diag_handler *handler;
 989	struct nlmsghdr *nlh;
 990	struct nlattr *attr;
 991	struct inet_diag_msg *r;
 992	void *info = NULL;
 993	int err = 0;
 994
 995	nlh = nlmsg_put(skb, 0, 0, SOCK_DIAG_BY_FAMILY, sizeof(*r), 0);
 996	if (!nlh)
 997		return -ENOMEM;
 998
 999	r = nlmsg_data(nlh);
1000	memset(r, 0, sizeof(*r));
1001	inet_diag_msg_common_fill(r, sk);
1002	if (sk->sk_type == SOCK_DGRAM || sk->sk_type == SOCK_STREAM)
1003		r->id.idiag_sport = inet_sk(sk)->inet_sport;
1004	r->idiag_state = sk->sk_state;
1005
1006	if ((err = nla_put_u8(skb, INET_DIAG_PROTOCOL, sk->sk_protocol))) {
1007		nlmsg_cancel(skb, nlh);
1008		return err;
1009	}
1010
1011	handler = inet_diag_lock_handler(sk->sk_protocol);
1012	if (!handler) {
1013		nlmsg_cancel(skb, nlh);
1014		return -ENOENT;
1015	}
1016
1017	attr = handler->idiag_info_size
1018		? nla_reserve_64bit(skb, INET_DIAG_INFO,
1019				    handler->idiag_info_size,
1020				    INET_DIAG_PAD)
1021		: NULL;
1022	if (attr)
1023		info = nla_data(attr);
1024
1025	handler->idiag_get_info(sk, r, info);
1026	inet_diag_unlock_handler(handler);
1027
1028	nlmsg_end(skb, nlh);
1029	return 0;
1030}
1031
1032static const struct sock_diag_handler inet_diag_handler = {
1033	.owner = THIS_MODULE,
1034	.family = AF_INET,
1035	.dump = inet_diag_handler_cmd,
1036	.get_info = inet_diag_handler_get_info,
1037	.destroy = inet_diag_handler_cmd,
1038};
1039
1040static const struct sock_diag_handler inet6_diag_handler = {
1041	.owner = THIS_MODULE,
1042	.family = AF_INET6,
1043	.dump = inet_diag_handler_cmd,
1044	.get_info = inet_diag_handler_get_info,
1045	.destroy = inet_diag_handler_cmd,
1046};
1047
1048int inet_diag_register(const struct inet_diag_handler *h)
1049{
1050	const __u16 type = h->idiag_type;
1051
1052	if (type >= IPPROTO_MAX)
1053		return -EINVAL;
1054
1055	return !cmpxchg((const struct inet_diag_handler **)&inet_diag_table[type],
1056			NULL, h) ? 0 : -EEXIST;
1057}
1058EXPORT_SYMBOL_GPL(inet_diag_register);
1059
1060void inet_diag_unregister(const struct inet_diag_handler *h)
1061{
1062	const __u16 type = h->idiag_type;
1063
1064	if (type >= IPPROTO_MAX)
1065		return;
1066
1067	xchg((const struct inet_diag_handler **)&inet_diag_table[type],
1068	     NULL);
1069}
1070EXPORT_SYMBOL_GPL(inet_diag_unregister);
1071
1072static const struct sock_diag_inet_compat inet_diag_compat = {
1073	.owner	= THIS_MODULE,
1074	.fn	= inet_diag_rcv_msg_compat,
1075};
1076
1077static int __init inet_diag_init(void)
1078{
1079	const int inet_diag_table_size = (IPPROTO_MAX *
1080					  sizeof(struct inet_diag_handler *));
1081	int err = -ENOMEM;
1082
1083	inet_diag_table = kzalloc(inet_diag_table_size, GFP_KERNEL);
1084	if (!inet_diag_table)
1085		goto out;
1086
1087	err = sock_diag_register(&inet_diag_handler);
1088	if (err)
1089		goto out_free_nl;
1090
1091	err = sock_diag_register(&inet6_diag_handler);
1092	if (err)
1093		goto out_free_inet;
1094
1095	sock_diag_register_inet_compat(&inet_diag_compat);
1096out:
1097	return err;
1098
1099out_free_inet:
1100	sock_diag_unregister(&inet_diag_handler);
1101out_free_nl:
1102	kfree(inet_diag_table);
1103	goto out;
1104}
1105
1106static void __exit inet_diag_exit(void)
1107{
1108	sock_diag_unregister(&inet6_diag_handler);
1109	sock_diag_unregister(&inet_diag_handler);
1110	sock_diag_unregister_inet_compat(&inet_diag_compat);
1111	kfree(inet_diag_table);
1112}
1113
1114module_init(inet_diag_init);
1115module_exit(inet_diag_exit);
1116MODULE_LICENSE("GPL");
1117MODULE_DESCRIPTION("INET/INET6: socket monitoring via SOCK_DIAG");
1118MODULE_ALIAS_NET_PF_PROTO_TYPE(PF_NETLINK, NETLINK_SOCK_DIAG, 2 /* AF_INET */);
1119MODULE_ALIAS_NET_PF_PROTO_TYPE(PF_NETLINK, NETLINK_SOCK_DIAG, 10 /* AF_INET6 */);