xref: /openbmc/linux/net/ipv4/inet_diag.c (revision a44e4f3a) 
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/inet_hashtables.h>
24 #include <net/inet_timewait_sock.h>
25 #include <net/inet6_hashtables.h>
26 #include <net/netlink.h>
27 
28 #include <linux/inet.h>
29 #include <linux/stddef.h>
30 
31 #include <linux/inet_diag.h>
32 #include <linux/sock_diag.h>
33 
34 static const struct inet_diag_handler **inet_diag_table;
35 
36 struct inet_diag_entry {
37 	const __be32 *saddr;
38 	const __be32 *daddr;
39 	u16 sport;
40 	u16 dport;
41 	u16 family;
42 	u16 userlocks;
43 	u32 ifindex;
44 	u32 mark;
45 };
46 
47 static DEFINE_MUTEX(inet_diag_table_mutex);
48 
49 static const struct inet_diag_handler *inet_diag_lock_handler(int proto)
50 {
51 	if (!inet_diag_table[proto])
52 		sock_load_diag_module(AF_INET, proto);
53 
54 	mutex_lock(&inet_diag_table_mutex);
55 	if (!inet_diag_table[proto])
56 		return ERR_PTR(-ENOENT);
57 
58 	return inet_diag_table[proto];
59 }
60 
61 static void inet_diag_unlock_handler(const struct inet_diag_handler *handler)
62 {
63 	mutex_unlock(&inet_diag_table_mutex);
64 }
65 
66 void inet_diag_msg_common_fill(struct inet_diag_msg *r, struct sock *sk)
67 {
68 	r->idiag_family = sk->sk_family;
69 
70 	r->id.idiag_sport = htons(sk->sk_num);
71 	r->id.idiag_dport = sk->sk_dport;
72 	r->id.idiag_if = sk->sk_bound_dev_if;
73 	sock_diag_save_cookie(sk, r->id.idiag_cookie);
74 
75 #if IS_ENABLED(CONFIG_IPV6)
76 	if (sk->sk_family == AF_INET6) {
77 		*(struct in6_addr *)r->id.idiag_src = sk->sk_v6_rcv_saddr;
78 		*(struct in6_addr *)r->id.idiag_dst = sk->sk_v6_daddr;
79 	} else
80 #endif
81 	{
82 	memset(&r->id.idiag_src, 0, sizeof(r->id.idiag_src));
83 	memset(&r->id.idiag_dst, 0, sizeof(r->id.idiag_dst));
84 
85 	r->id.idiag_src[0] = sk->sk_rcv_saddr;
86 	r->id.idiag_dst[0] = sk->sk_daddr;
87 	}
88 }
89 EXPORT_SYMBOL_GPL(inet_diag_msg_common_fill);
90 
91 static size_t inet_sk_attr_size(struct sock *sk,
92 				const struct inet_diag_req_v2 *req,
93 				bool net_admin)
94 {
95 	const struct inet_diag_handler *handler;
96 	size_t aux = 0;
97 
98 	handler = inet_diag_table[req->sdiag_protocol];
99 	if (handler && handler->idiag_get_aux_size)
100 		aux = handler->idiag_get_aux_size(sk, net_admin);
101 
102 	return	  nla_total_size(sizeof(struct tcp_info))
103 		+ nla_total_size(1) /* INET_DIAG_SHUTDOWN */
104 		+ nla_total_size(1) /* INET_DIAG_TOS */
105 		+ nla_total_size(1) /* INET_DIAG_TCLASS */
106 		+ nla_total_size(4) /* INET_DIAG_MARK */
107 		+ nla_total_size(4) /* INET_DIAG_CLASS_ID */
108 		+ nla_total_size(sizeof(struct inet_diag_meminfo))
109 		+ nla_total_size(sizeof(struct inet_diag_msg))
110 		+ nla_total_size(SK_MEMINFO_VARS * sizeof(u32))
111 		+ nla_total_size(TCP_CA_NAME_MAX)
112 		+ nla_total_size(sizeof(struct tcpvegas_info))
113 		+ aux
114 		+ 64;
115 }
116 
117 int inet_diag_msg_attrs_fill(struct sock *sk, struct sk_buff *skb,
118 			     struct inet_diag_msg *r, int ext,
119 			     struct user_namespace *user_ns,
120 			     bool net_admin)
121 {
122 	const struct inet_sock *inet = inet_sk(sk);
123 
124 	if (nla_put_u8(skb, INET_DIAG_SHUTDOWN, sk->sk_shutdown))
125 		goto errout;
126 
127 	/* IPv6 dual-stack sockets use inet->tos for IPv4 connections,
128 	 * hence this needs to be included regardless of socket family.
129 	 */
130 	if (ext & (1 << (INET_DIAG_TOS - 1)))
131 		if (nla_put_u8(skb, INET_DIAG_TOS, inet->tos) < 0)
132 			goto errout;
133 
134 #if IS_ENABLED(CONFIG_IPV6)
135 	if (r->idiag_family == AF_INET6) {
136 		if (ext & (1 << (INET_DIAG_TCLASS - 1)))
137 			if (nla_put_u8(skb, INET_DIAG_TCLASS,
138 				       inet6_sk(sk)->tclass) < 0)
139 				goto errout;
140 
141 		if (((1 << sk->sk_state) & (TCPF_LISTEN | TCPF_CLOSE)) &&
142 		    nla_put_u8(skb, INET_DIAG_SKV6ONLY, ipv6_only_sock(sk)))
143 			goto errout;
144 	}
145 #endif
146 
147 	if (net_admin && nla_put_u32(skb, INET_DIAG_MARK, sk->sk_mark))
148 		goto errout;
149 
150 	r->idiag_uid = from_kuid_munged(user_ns, sock_i_uid(sk));
151 	r->idiag_inode = sock_i_ino(sk);
152 
153 	return 0;
154 errout:
155 	return 1;
156 }
157 EXPORT_SYMBOL_GPL(inet_diag_msg_attrs_fill);
158 
159 int inet_sk_diag_fill(struct sock *sk, struct inet_connection_sock *icsk,
160 		      struct sk_buff *skb, const struct inet_diag_req_v2 *req,
161 		      struct user_namespace *user_ns,
162 		      u32 portid, u32 seq, u16 nlmsg_flags,
163 		      const struct nlmsghdr *unlh,
164 		      bool net_admin)
165 {
166 	const struct tcp_congestion_ops *ca_ops;
167 	const struct inet_diag_handler *handler;
168 	int ext = req->idiag_ext;
169 	struct inet_diag_msg *r;
170 	struct nlmsghdr  *nlh;
171 	struct nlattr *attr;
172 	void *info = NULL;
173 
174 	handler = inet_diag_table[req->sdiag_protocol];
175 	BUG_ON(!handler);
176 
177 	nlh = nlmsg_put(skb, portid, seq, unlh->nlmsg_type, sizeof(*r),
178 			nlmsg_flags);
179 	if (!nlh)
180 		return -EMSGSIZE;
181 
182 	r = nlmsg_data(nlh);
183 	BUG_ON(!sk_fullsock(sk));
184 
185 	inet_diag_msg_common_fill(r, sk);
186 	r->idiag_state = sk->sk_state;
187 	r->idiag_timer = 0;
188 	r->idiag_retrans = 0;
189 
190 	if (inet_diag_msg_attrs_fill(sk, skb, r, ext, user_ns, net_admin))
191 		goto errout;
192 
193 	if (ext & (1 << (INET_DIAG_MEMINFO - 1))) {
194 		struct inet_diag_meminfo minfo = {
195 			.idiag_rmem = sk_rmem_alloc_get(sk),
196 			.idiag_wmem = READ_ONCE(sk->sk_wmem_queued),
197 			.idiag_fmem = sk->sk_forward_alloc,
198 			.idiag_tmem = sk_wmem_alloc_get(sk),
199 		};
200 
201 		if (nla_put(skb, INET_DIAG_MEMINFO, sizeof(minfo), &minfo) < 0)
202 			goto errout;
203 	}
204 
205 	if (ext & (1 << (INET_DIAG_SKMEMINFO - 1)))
206 		if (sock_diag_put_meminfo(sk, skb, INET_DIAG_SKMEMINFO))
207 			goto errout;
208 
209 	/*
210 	 * RAW sockets might have user-defined protocols assigned,
211 	 * so report the one supplied on socket creation.
212 	 */
213 	if (sk->sk_type == SOCK_RAW) {
214 		if (nla_put_u8(skb, INET_DIAG_PROTOCOL, sk->sk_protocol))
215 			goto errout;
216 	}
217 
218 	if (!icsk) {
219 		handler->idiag_get_info(sk, r, NULL);
220 		goto out;
221 	}
222 
223 	if (icsk->icsk_pending == ICSK_TIME_RETRANS ||
224 	    icsk->icsk_pending == ICSK_TIME_REO_TIMEOUT ||
225 	    icsk->icsk_pending == ICSK_TIME_LOSS_PROBE) {
226 		r->idiag_timer = 1;
227 		r->idiag_retrans = icsk->icsk_retransmits;
228 		r->idiag_expires =
229 			jiffies_to_msecs(icsk->icsk_timeout - jiffies);
230 	} else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
231 		r->idiag_timer = 4;
232 		r->idiag_retrans = icsk->icsk_probes_out;
233 		r->idiag_expires =
234 			jiffies_to_msecs(icsk->icsk_timeout - jiffies);
235 	} else if (timer_pending(&sk->sk_timer)) {
236 		r->idiag_timer = 2;
237 		r->idiag_retrans = icsk->icsk_probes_out;
238 		r->idiag_expires =
239 			jiffies_to_msecs(sk->sk_timer.expires - jiffies);
240 	} else {
241 		r->idiag_timer = 0;
242 		r->idiag_expires = 0;
243 	}
244 
245 	if ((ext & (1 << (INET_DIAG_INFO - 1))) && handler->idiag_info_size) {
246 		attr = nla_reserve_64bit(skb, INET_DIAG_INFO,
247 					 handler->idiag_info_size,
248 					 INET_DIAG_PAD);
249 		if (!attr)
250 			goto errout;
251 
252 		info = nla_data(attr);
253 	}
254 
255 	if (ext & (1 << (INET_DIAG_CONG - 1))) {
256 		int err = 0;
257 
258 		rcu_read_lock();
259 		ca_ops = READ_ONCE(icsk->icsk_ca_ops);
260 		if (ca_ops)
261 			err = nla_put_string(skb, INET_DIAG_CONG, ca_ops->name);
262 		rcu_read_unlock();
263 		if (err < 0)
264 			goto errout;
265 	}
266 
267 	handler->idiag_get_info(sk, r, info);
268 
269 	if (ext & (1 << (INET_DIAG_INFO - 1)) && handler->idiag_get_aux)
270 		if (handler->idiag_get_aux(sk, net_admin, skb) < 0)
271 			goto errout;
272 
273 	if (sk->sk_state < TCP_TIME_WAIT) {
274 		union tcp_cc_info info;
275 		size_t sz = 0;
276 		int attr;
277 
278 		rcu_read_lock();
279 		ca_ops = READ_ONCE(icsk->icsk_ca_ops);
280 		if (ca_ops && ca_ops->get_info)
281 			sz = ca_ops->get_info(sk, ext, &attr, &info);
282 		rcu_read_unlock();
283 		if (sz && nla_put(skb, attr, sz, &info) < 0)
284 			goto errout;
285 	}
286 
287 	if (ext & (1 << (INET_DIAG_CLASS_ID - 1)) ||
288 	    ext & (1 << (INET_DIAG_TCLASS - 1))) {
289 		u32 classid = 0;
290 
291 #ifdef CONFIG_SOCK_CGROUP_DATA
292 		classid = sock_cgroup_classid(&sk->sk_cgrp_data);
293 #endif
294 		/* Fallback to socket priority if class id isn't set.
295 		 * Classful qdiscs use it as direct reference to class.
296 		 * For cgroup2 classid is always zero.
297 		 */
298 		if (!classid)
299 			classid = sk->sk_priority;
300 
301 		if (nla_put_u32(skb, INET_DIAG_CLASS_ID, classid))
302 			goto errout;
303 	}
304 
305 out:
306 	nlmsg_end(skb, nlh);
307 	return 0;
308 
309 errout:
310 	nlmsg_cancel(skb, nlh);
311 	return -EMSGSIZE;
312 }
313 EXPORT_SYMBOL_GPL(inet_sk_diag_fill);
314 
315 static int inet_csk_diag_fill(struct sock *sk,
316 			      struct sk_buff *skb,
317 			      const struct inet_diag_req_v2 *req,
318 			      struct user_namespace *user_ns,
319 			      u32 portid, u32 seq, u16 nlmsg_flags,
320 			      const struct nlmsghdr *unlh,
321 			      bool net_admin)
322 {
323 	return inet_sk_diag_fill(sk, inet_csk(sk), skb, req, user_ns,
324 				 portid, seq, nlmsg_flags, unlh, net_admin);
325 }
326 
327 static int inet_twsk_diag_fill(struct sock *sk,
328 			       struct sk_buff *skb,
329 			       u32 portid, u32 seq, u16 nlmsg_flags,
330 			       const struct nlmsghdr *unlh)
331 {
332 	struct inet_timewait_sock *tw = inet_twsk(sk);
333 	struct inet_diag_msg *r;
334 	struct nlmsghdr *nlh;
335 	long tmo;
336 
337 	nlh = nlmsg_put(skb, portid, seq, unlh->nlmsg_type, sizeof(*r),
338 			nlmsg_flags);
339 	if (!nlh)
340 		return -EMSGSIZE;
341 
342 	r = nlmsg_data(nlh);
343 	BUG_ON(tw->tw_state != TCP_TIME_WAIT);
344 
345 	tmo = tw->tw_timer.expires - jiffies;
346 	if (tmo < 0)
347 		tmo = 0;
348 
349 	inet_diag_msg_common_fill(r, sk);
350 	r->idiag_retrans      = 0;
351 
352 	r->idiag_state	      = tw->tw_substate;
353 	r->idiag_timer	      = 3;
354 	r->idiag_expires      = jiffies_to_msecs(tmo);
355 	r->idiag_rqueue	      = 0;
356 	r->idiag_wqueue	      = 0;
357 	r->idiag_uid	      = 0;
358 	r->idiag_inode	      = 0;
359 
360 	nlmsg_end(skb, nlh);
361 	return 0;
362 }
363 
364 static int inet_req_diag_fill(struct sock *sk, struct sk_buff *skb,
365 			      u32 portid, u32 seq, u16 nlmsg_flags,
366 			      const struct nlmsghdr *unlh, bool net_admin)
367 {
368 	struct request_sock *reqsk = inet_reqsk(sk);
369 	struct inet_diag_msg *r;
370 	struct nlmsghdr *nlh;
371 	long tmo;
372 
373 	nlh = nlmsg_put(skb, portid, seq, unlh->nlmsg_type, sizeof(*r),
374 			nlmsg_flags);
375 	if (!nlh)
376 		return -EMSGSIZE;
377 
378 	r = nlmsg_data(nlh);
379 	inet_diag_msg_common_fill(r, sk);
380 	r->idiag_state = TCP_SYN_RECV;
381 	r->idiag_timer = 1;
382 	r->idiag_retrans = reqsk->num_retrans;
383 
384 	BUILD_BUG_ON(offsetof(struct inet_request_sock, ir_cookie) !=
385 		     offsetof(struct sock, sk_cookie));
386 
387 	tmo = inet_reqsk(sk)->rsk_timer.expires - jiffies;
388 	r->idiag_expires = (tmo >= 0) ? jiffies_to_msecs(tmo) : 0;
389 	r->idiag_rqueue	= 0;
390 	r->idiag_wqueue	= 0;
391 	r->idiag_uid	= 0;
392 	r->idiag_inode	= 0;
393 
394 	if (net_admin && nla_put_u32(skb, INET_DIAG_MARK,
395 				     inet_rsk(reqsk)->ir_mark))
396 		return -EMSGSIZE;
397 
398 	nlmsg_end(skb, nlh);
399 	return 0;
400 }
401 
402 static int sk_diag_fill(struct sock *sk, struct sk_buff *skb,
403 			const struct inet_diag_req_v2 *r,
404 			struct user_namespace *user_ns,
405 			u32 portid, u32 seq, u16 nlmsg_flags,
406 			const struct nlmsghdr *unlh, bool net_admin)
407 {
408 	if (sk->sk_state == TCP_TIME_WAIT)
409 		return inet_twsk_diag_fill(sk, skb, portid, seq,
410 					   nlmsg_flags, unlh);
411 
412 	if (sk->sk_state == TCP_NEW_SYN_RECV)
413 		return inet_req_diag_fill(sk, skb, portid, seq,
414 					  nlmsg_flags, unlh, net_admin);
415 
416 	return inet_csk_diag_fill(sk, skb, r, user_ns, portid, seq,
417 				  nlmsg_flags, unlh, net_admin);
418 }
419 
420 struct sock *inet_diag_find_one_icsk(struct net *net,
421 				     struct inet_hashinfo *hashinfo,
422 				     const struct inet_diag_req_v2 *req)
423 {
424 	struct sock *sk;
425 
426 	rcu_read_lock();
427 	if (req->sdiag_family == AF_INET)
428 		sk = inet_lookup(net, hashinfo, NULL, 0, req->id.idiag_dst[0],
429 				 req->id.idiag_dport, req->id.idiag_src[0],
430 				 req->id.idiag_sport, req->id.idiag_if);
431 #if IS_ENABLED(CONFIG_IPV6)
432 	else if (req->sdiag_family == AF_INET6) {
433 		if (ipv6_addr_v4mapped((struct in6_addr *)req->id.idiag_dst) &&
434 		    ipv6_addr_v4mapped((struct in6_addr *)req->id.idiag_src))
435 			sk = inet_lookup(net, hashinfo, NULL, 0, req->id.idiag_dst[3],
436 					 req->id.idiag_dport, req->id.idiag_src[3],
437 					 req->id.idiag_sport, req->id.idiag_if);
438 		else
439 			sk = inet6_lookup(net, hashinfo, NULL, 0,
440 					  (struct in6_addr *)req->id.idiag_dst,
441 					  req->id.idiag_dport,
442 					  (struct in6_addr *)req->id.idiag_src,
443 					  req->id.idiag_sport,
444 					  req->id.idiag_if);
445 	}
446 #endif
447 	else {
448 		rcu_read_unlock();
449 		return ERR_PTR(-EINVAL);
450 	}
451 	rcu_read_unlock();
452 	if (!sk)
453 		return ERR_PTR(-ENOENT);
454 
455 	if (sock_diag_check_cookie(sk, req->id.idiag_cookie)) {
456 		sock_gen_put(sk);
457 		return ERR_PTR(-ENOENT);
458 	}
459 
460 	return sk;
461 }
462 EXPORT_SYMBOL_GPL(inet_diag_find_one_icsk);
463 
464 int inet_diag_dump_one_icsk(struct inet_hashinfo *hashinfo,
465 			    struct sk_buff *in_skb,
466 			    const struct nlmsghdr *nlh,
467 			    const struct inet_diag_req_v2 *req)
468 {
469 	bool net_admin = netlink_net_capable(in_skb, CAP_NET_ADMIN);
470 	struct net *net = sock_net(in_skb->sk);
471 	struct sk_buff *rep;
472 	struct sock *sk;
473 	int err;
474 
475 	sk = inet_diag_find_one_icsk(net, hashinfo, req);
476 	if (IS_ERR(sk))
477 		return PTR_ERR(sk);
478 
479 	rep = nlmsg_new(inet_sk_attr_size(sk, req, net_admin), GFP_KERNEL);
480 	if (!rep) {
481 		err = -ENOMEM;
482 		goto out;
483 	}
484 
485 	err = sk_diag_fill(sk, rep, req,
486 			   sk_user_ns(NETLINK_CB(in_skb).sk),
487 			   NETLINK_CB(in_skb).portid,
488 			   nlh->nlmsg_seq, 0, nlh, net_admin);
489 	if (err < 0) {
490 		WARN_ON(err == -EMSGSIZE);
491 		nlmsg_free(rep);
492 		goto out;
493 	}
494 	err = netlink_unicast(net->diag_nlsk, rep, NETLINK_CB(in_skb).portid,
495 			      MSG_DONTWAIT);
496 	if (err > 0)
497 		err = 0;
498 
499 out:
500 	if (sk)
501 		sock_gen_put(sk);
502 
503 	return err;
504 }
505 EXPORT_SYMBOL_GPL(inet_diag_dump_one_icsk);
506 
507 static int inet_diag_cmd_exact(int cmd, struct sk_buff *in_skb,
508 			       const struct nlmsghdr *nlh,
509 			       const struct inet_diag_req_v2 *req)
510 {
511 	const struct inet_diag_handler *handler;
512 	int err;
513 
514 	handler = inet_diag_lock_handler(req->sdiag_protocol);
515 	if (IS_ERR(handler))
516 		err = PTR_ERR(handler);
517 	else if (cmd == SOCK_DIAG_BY_FAMILY)
518 		err = handler->dump_one(in_skb, nlh, req);
519 	else if (cmd == SOCK_DESTROY && handler->destroy)
520 		err = handler->destroy(in_skb, req);
521 	else
522 		err = -EOPNOTSUPP;
523 	inet_diag_unlock_handler(handler);
524 
525 	return err;
526 }
527 
528 static int bitstring_match(const __be32 *a1, const __be32 *a2, int bits)
529 {
530 	int words = bits >> 5;
531 
532 	bits &= 0x1f;
533 
534 	if (words) {
535 		if (memcmp(a1, a2, words << 2))
536 			return 0;
537 	}
538 	if (bits) {
539 		__be32 w1, w2;
540 		__be32 mask;
541 
542 		w1 = a1[words];
543 		w2 = a2[words];
544 
545 		mask = htonl((0xffffffff) << (32 - bits));
546 
547 		if ((w1 ^ w2) & mask)
548 			return 0;
549 	}
550 
551 	return 1;
552 }
553 
554 static int inet_diag_bc_run(const struct nlattr *_bc,
555 			    const struct inet_diag_entry *entry)
556 {
557 	const void *bc = nla_data(_bc);
558 	int len = nla_len(_bc);
559 
560 	while (len > 0) {
561 		int yes = 1;
562 		const struct inet_diag_bc_op *op = bc;
563 
564 		switch (op->code) {
565 		case INET_DIAG_BC_NOP:
566 			break;
567 		case INET_DIAG_BC_JMP:
568 			yes = 0;
569 			break;
570 		case INET_DIAG_BC_S_EQ:
571 			yes = entry->sport == op[1].no;
572 			break;
573 		case INET_DIAG_BC_S_GE:
574 			yes = entry->sport >= op[1].no;
575 			break;
576 		case INET_DIAG_BC_S_LE:
577 			yes = entry->sport <= op[1].no;
578 			break;
579 		case INET_DIAG_BC_D_EQ:
580 			yes = entry->dport == op[1].no;
581 			break;
582 		case INET_DIAG_BC_D_GE:
583 			yes = entry->dport >= op[1].no;
584 			break;
585 		case INET_DIAG_BC_D_LE:
586 			yes = entry->dport <= op[1].no;
587 			break;
588 		case INET_DIAG_BC_AUTO:
589 			yes = !(entry->userlocks & SOCK_BINDPORT_LOCK);
590 			break;
591 		case INET_DIAG_BC_S_COND:
592 		case INET_DIAG_BC_D_COND: {
593 			const struct inet_diag_hostcond *cond;
594 			const __be32 *addr;
595 
596 			cond = (const struct inet_diag_hostcond *)(op + 1);
597 			if (cond->port != -1 &&
598 			    cond->port != (op->code == INET_DIAG_BC_S_COND ?
599 					     entry->sport : entry->dport)) {
600 				yes = 0;
601 				break;
602 			}
603 
604 			if (op->code == INET_DIAG_BC_S_COND)
605 				addr = entry->saddr;
606 			else
607 				addr = entry->daddr;
608 
609 			if (cond->family != AF_UNSPEC &&
610 			    cond->family != entry->family) {
611 				if (entry->family == AF_INET6 &&
612 				    cond->family == AF_INET) {
613 					if (addr[0] == 0 && addr[1] == 0 &&
614 					    addr[2] == htonl(0xffff) &&
615 					    bitstring_match(addr + 3,
616 							    cond->addr,
617 							    cond->prefix_len))
618 						break;
619 				}
620 				yes = 0;
621 				break;
622 			}
623 
624 			if (cond->prefix_len == 0)
625 				break;
626 			if (bitstring_match(addr, cond->addr,
627 					    cond->prefix_len))
628 				break;
629 			yes = 0;
630 			break;
631 		}
632 		case INET_DIAG_BC_DEV_COND: {
633 			u32 ifindex;
634 
635 			ifindex = *((const u32 *)(op + 1));
636 			if (ifindex != entry->ifindex)
637 				yes = 0;
638 			break;
639 		}
640 		case INET_DIAG_BC_MARK_COND: {
641 			struct inet_diag_markcond *cond;
642 
643 			cond = (struct inet_diag_markcond *)(op + 1);
644 			if ((entry->mark & cond->mask) != cond->mark)
645 				yes = 0;
646 			break;
647 		}
648 		}
649 
650 		if (yes) {
651 			len -= op->yes;
652 			bc += op->yes;
653 		} else {
654 			len -= op->no;
655 			bc += op->no;
656 		}
657 	}
658 	return len == 0;
659 }
660 
661 /* This helper is available for all sockets (ESTABLISH, TIMEWAIT, SYN_RECV)
662  */
663 static void entry_fill_addrs(struct inet_diag_entry *entry,
664 			     const struct sock *sk)
665 {
666 #if IS_ENABLED(CONFIG_IPV6)
667 	if (sk->sk_family == AF_INET6) {
668 		entry->saddr = sk->sk_v6_rcv_saddr.s6_addr32;
669 		entry->daddr = sk->sk_v6_daddr.s6_addr32;
670 	} else
671 #endif
672 	{
673 		entry->saddr = &sk->sk_rcv_saddr;
674 		entry->daddr = &sk->sk_daddr;
675 	}
676 }
677 
678 int inet_diag_bc_sk(const struct nlattr *bc, struct sock *sk)
679 {
680 	struct inet_sock *inet = inet_sk(sk);
681 	struct inet_diag_entry entry;
682 
683 	if (!bc)
684 		return 1;
685 
686 	entry.family = sk->sk_family;
687 	entry_fill_addrs(&entry, sk);
688 	entry.sport = inet->inet_num;
689 	entry.dport = ntohs(inet->inet_dport);
690 	entry.ifindex = sk->sk_bound_dev_if;
691 	entry.userlocks = sk_fullsock(sk) ? sk->sk_userlocks : 0;
692 	if (sk_fullsock(sk))
693 		entry.mark = sk->sk_mark;
694 	else if (sk->sk_state == TCP_NEW_SYN_RECV)
695 		entry.mark = inet_rsk(inet_reqsk(sk))->ir_mark;
696 	else
697 		entry.mark = 0;
698 
699 	return inet_diag_bc_run(bc, &entry);
700 }
701 EXPORT_SYMBOL_GPL(inet_diag_bc_sk);
702 
703 static int valid_cc(const void *bc, int len, int cc)
704 {
705 	while (len >= 0) {
706 		const struct inet_diag_bc_op *op = bc;
707 
708 		if (cc > len)
709 			return 0;
710 		if (cc == len)
711 			return 1;
712 		if (op->yes < 4 || op->yes & 3)
713 			return 0;
714 		len -= op->yes;
715 		bc  += op->yes;
716 	}
717 	return 0;
718 }
719 
720 /* data is u32 ifindex */
721 static bool valid_devcond(const struct inet_diag_bc_op *op, int len,
722 			  int *min_len)
723 {
724 	/* Check ifindex space. */
725 	*min_len += sizeof(u32);
726 	if (len < *min_len)
727 		return false;
728 
729 	return true;
730 }
731 /* Validate an inet_diag_hostcond. */
732 static bool valid_hostcond(const struct inet_diag_bc_op *op, int len,
733 			   int *min_len)
734 {
735 	struct inet_diag_hostcond *cond;
736 	int addr_len;
737 
738 	/* Check hostcond space. */
739 	*min_len += sizeof(struct inet_diag_hostcond);
740 	if (len < *min_len)
741 		return false;
742 	cond = (struct inet_diag_hostcond *)(op + 1);
743 
744 	/* Check address family and address length. */
745 	switch (cond->family) {
746 	case AF_UNSPEC:
747 		addr_len = 0;
748 		break;
749 	case AF_INET:
750 		addr_len = sizeof(struct in_addr);
751 		break;
752 	case AF_INET6:
753 		addr_len = sizeof(struct in6_addr);
754 		break;
755 	default:
756 		return false;
757 	}
758 	*min_len += addr_len;
759 	if (len < *min_len)
760 		return false;
761 
762 	/* Check prefix length (in bits) vs address length (in bytes). */
763 	if (cond->prefix_len > 8 * addr_len)
764 		return false;
765 
766 	return true;
767 }
768 
769 /* Validate a port comparison operator. */
770 static bool valid_port_comparison(const struct inet_diag_bc_op *op,
771 				  int len, int *min_len)
772 {
773 	/* Port comparisons put the port in a follow-on inet_diag_bc_op. */
774 	*min_len += sizeof(struct inet_diag_bc_op);
775 	if (len < *min_len)
776 		return false;
777 	return true;
778 }
779 
780 static bool valid_markcond(const struct inet_diag_bc_op *op, int len,
781 			   int *min_len)
782 {
783 	*min_len += sizeof(struct inet_diag_markcond);
784 	return len >= *min_len;
785 }
786 
787 static int inet_diag_bc_audit(const struct nlattr *attr,
788 			      const struct sk_buff *skb)
789 {
790 	bool net_admin = netlink_net_capable(skb, CAP_NET_ADMIN);
791 	const void *bytecode, *bc;
792 	int bytecode_len, len;
793 
794 	if (!attr || nla_len(attr) < sizeof(struct inet_diag_bc_op))
795 		return -EINVAL;
796 
797 	bytecode = bc = nla_data(attr);
798 	len = bytecode_len = nla_len(attr);
799 
800 	while (len > 0) {
801 		int min_len = sizeof(struct inet_diag_bc_op);
802 		const struct inet_diag_bc_op *op = bc;
803 
804 		switch (op->code) {
805 		case INET_DIAG_BC_S_COND:
806 		case INET_DIAG_BC_D_COND:
807 			if (!valid_hostcond(bc, len, &min_len))
808 				return -EINVAL;
809 			break;
810 		case INET_DIAG_BC_DEV_COND:
811 			if (!valid_devcond(bc, len, &min_len))
812 				return -EINVAL;
813 			break;
814 		case INET_DIAG_BC_S_EQ:
815 		case INET_DIAG_BC_S_GE:
816 		case INET_DIAG_BC_S_LE:
817 		case INET_DIAG_BC_D_EQ:
818 		case INET_DIAG_BC_D_GE:
819 		case INET_DIAG_BC_D_LE:
820 			if (!valid_port_comparison(bc, len, &min_len))
821 				return -EINVAL;
822 			break;
823 		case INET_DIAG_BC_MARK_COND:
824 			if (!net_admin)
825 				return -EPERM;
826 			if (!valid_markcond(bc, len, &min_len))
827 				return -EINVAL;
828 			break;
829 		case INET_DIAG_BC_AUTO:
830 		case INET_DIAG_BC_JMP:
831 		case INET_DIAG_BC_NOP:
832 			break;
833 		default:
834 			return -EINVAL;
835 		}
836 
837 		if (op->code != INET_DIAG_BC_NOP) {
838 			if (op->no < min_len || op->no > len + 4 || op->no & 3)
839 				return -EINVAL;
840 			if (op->no < len &&
841 			    !valid_cc(bytecode, bytecode_len, len - op->no))
842 				return -EINVAL;
843 		}
844 
845 		if (op->yes < min_len || op->yes > len + 4 || op->yes & 3)
846 			return -EINVAL;
847 		bc  += op->yes;
848 		len -= op->yes;
849 	}
850 	return len == 0 ? 0 : -EINVAL;
851 }
852 
853 static int inet_csk_diag_dump(struct sock *sk,
854 			      struct sk_buff *skb,
855 			      struct netlink_callback *cb,
856 			      const struct inet_diag_req_v2 *r,
857 			      const struct nlattr *bc,
858 			      bool net_admin)
859 {
860 	if (!inet_diag_bc_sk(bc, sk))
861 		return 0;
862 
863 	return inet_csk_diag_fill(sk, skb, r,
864 				  sk_user_ns(NETLINK_CB(cb->skb).sk),
865 				  NETLINK_CB(cb->skb).portid,
866 				  cb->nlh->nlmsg_seq, NLM_F_MULTI, cb->nlh,
867 				  net_admin);
868 }
869 
870 static void twsk_build_assert(void)
871 {
872 	BUILD_BUG_ON(offsetof(struct inet_timewait_sock, tw_family) !=
873 		     offsetof(struct sock, sk_family));
874 
875 	BUILD_BUG_ON(offsetof(struct inet_timewait_sock, tw_num) !=
876 		     offsetof(struct inet_sock, inet_num));
877 
878 	BUILD_BUG_ON(offsetof(struct inet_timewait_sock, tw_dport) !=
879 		     offsetof(struct inet_sock, inet_dport));
880 
881 	BUILD_BUG_ON(offsetof(struct inet_timewait_sock, tw_rcv_saddr) !=
882 		     offsetof(struct inet_sock, inet_rcv_saddr));
883 
884 	BUILD_BUG_ON(offsetof(struct inet_timewait_sock, tw_daddr) !=
885 		     offsetof(struct inet_sock, inet_daddr));
886 
887 #if IS_ENABLED(CONFIG_IPV6)
888 	BUILD_BUG_ON(offsetof(struct inet_timewait_sock, tw_v6_rcv_saddr) !=
889 		     offsetof(struct sock, sk_v6_rcv_saddr));
890 
891 	BUILD_BUG_ON(offsetof(struct inet_timewait_sock, tw_v6_daddr) !=
892 		     offsetof(struct sock, sk_v6_daddr));
893 #endif
894 }
895 
896 void inet_diag_dump_icsk(struct inet_hashinfo *hashinfo, struct sk_buff *skb,
897 			 struct netlink_callback *cb,
898 			 const struct inet_diag_req_v2 *r, struct nlattr *bc)
899 {
900 	bool net_admin = netlink_net_capable(cb->skb, CAP_NET_ADMIN);
901 	struct net *net = sock_net(skb->sk);
902 	u32 idiag_states = r->idiag_states;
903 	int i, num, s_i, s_num;
904 	struct sock *sk;
905 
906 	if (idiag_states & TCPF_SYN_RECV)
907 		idiag_states |= TCPF_NEW_SYN_RECV;
908 	s_i = cb->args[1];
909 	s_num = num = cb->args[2];
910 
911 	if (cb->args[0] == 0) {
912 		if (!(idiag_states & TCPF_LISTEN) || r->id.idiag_dport)
913 			goto skip_listen_ht;
914 
915 		for (i = s_i; i < INET_LHTABLE_SIZE; i++) {
916 			struct inet_listen_hashbucket *ilb;
917 
918 			num = 0;
919 			ilb = &hashinfo->listening_hash[i];
920 			spin_lock(&ilb->lock);
921 			sk_for_each(sk, &ilb->head) {
922 				struct inet_sock *inet = inet_sk(sk);
923 
924 				if (!net_eq(sock_net(sk), net))
925 					continue;
926 
927 				if (num < s_num) {
928 					num++;
929 					continue;
930 				}
931 
932 				if (r->sdiag_family != AF_UNSPEC &&
933 				    sk->sk_family != r->sdiag_family)
934 					goto next_listen;
935 
936 				if (r->id.idiag_sport != inet->inet_sport &&
937 				    r->id.idiag_sport)
938 					goto next_listen;
939 
940 				if (inet_csk_diag_dump(sk, skb, cb, r,
941 						       bc, net_admin) < 0) {
942 					spin_unlock(&ilb->lock);
943 					goto done;
944 				}
945 
946 next_listen:
947 				++num;
948 			}
949 			spin_unlock(&ilb->lock);
950 
951 			s_num = 0;
952 		}
953 skip_listen_ht:
954 		cb->args[0] = 1;
955 		s_i = num = s_num = 0;
956 	}
957 
958 	if (!(idiag_states & ~TCPF_LISTEN))
959 		goto out;
960 
961 #define SKARR_SZ 16
962 	for (i = s_i; i <= hashinfo->ehash_mask; i++) {
963 		struct inet_ehash_bucket *head = &hashinfo->ehash[i];
964 		spinlock_t *lock = inet_ehash_lockp(hashinfo, i);
965 		struct hlist_nulls_node *node;
966 		struct sock *sk_arr[SKARR_SZ];
967 		int num_arr[SKARR_SZ];
968 		int idx, accum, res;
969 
970 		if (hlist_nulls_empty(&head->chain))
971 			continue;
972 
973 		if (i > s_i)
974 			s_num = 0;
975 
976 next_chunk:
977 		num = 0;
978 		accum = 0;
979 		spin_lock_bh(lock);
980 		sk_nulls_for_each(sk, node, &head->chain) {
981 			int state;
982 
983 			if (!net_eq(sock_net(sk), net))
984 				continue;
985 			if (num < s_num)
986 				goto next_normal;
987 			state = (sk->sk_state == TCP_TIME_WAIT) ?
988 				inet_twsk(sk)->tw_substate : sk->sk_state;
989 			if (!(idiag_states & (1 << state)))
990 				goto next_normal;
991 			if (r->sdiag_family != AF_UNSPEC &&
992 			    sk->sk_family != r->sdiag_family)
993 				goto next_normal;
994 			if (r->id.idiag_sport != htons(sk->sk_num) &&
995 			    r->id.idiag_sport)
996 				goto next_normal;
997 			if (r->id.idiag_dport != sk->sk_dport &&
998 			    r->id.idiag_dport)
999 				goto next_normal;
1000 			twsk_build_assert();
1001 
1002 			if (!inet_diag_bc_sk(bc, sk))
1003 				goto next_normal;
1004 
1005 			if (!refcount_inc_not_zero(&sk->sk_refcnt))
1006 				goto next_normal;
1007 
1008 			num_arr[accum] = num;
1009 			sk_arr[accum] = sk;
1010 			if (++accum == SKARR_SZ)
1011 				break;
1012 next_normal:
1013 			++num;
1014 		}
1015 		spin_unlock_bh(lock);
1016 		res = 0;
1017 		for (idx = 0; idx < accum; idx++) {
1018 			if (res >= 0) {
1019 				res = sk_diag_fill(sk_arr[idx], skb, r,
1020 					   sk_user_ns(NETLINK_CB(cb->skb).sk),
1021 					   NETLINK_CB(cb->skb).portid,
1022 					   cb->nlh->nlmsg_seq, NLM_F_MULTI,
1023 					   cb->nlh, net_admin);
1024 				if (res < 0)
1025 					num = num_arr[idx];
1026 			}
1027 			sock_gen_put(sk_arr[idx]);
1028 		}
1029 		if (res < 0)
1030 			break;
1031 		cond_resched();
1032 		if (accum == SKARR_SZ) {
1033 			s_num = num + 1;
1034 			goto next_chunk;
1035 		}
1036 	}
1037 
1038 done:
1039 	cb->args[1] = i;
1040 	cb->args[2] = num;
1041 out:
1042 	;
1043 }
1044 EXPORT_SYMBOL_GPL(inet_diag_dump_icsk);
1045 
1046 static int __inet_diag_dump(struct sk_buff *skb, struct netlink_callback *cb,
1047 			    const struct inet_diag_req_v2 *r,
1048 			    struct nlattr *bc)
1049 {
1050 	const struct inet_diag_handler *handler;
1051 	int err = 0;
1052 
1053 	handler = inet_diag_lock_handler(r->sdiag_protocol);
1054 	if (!IS_ERR(handler))
1055 		handler->dump(skb, cb, r, bc);
1056 	else
1057 		err = PTR_ERR(handler);
1058 	inet_diag_unlock_handler(handler);
1059 
1060 	return err ? : skb->len;
1061 }
1062 
1063 static int inet_diag_dump(struct sk_buff *skb, struct netlink_callback *cb)
1064 {
1065 	int hdrlen = sizeof(struct inet_diag_req_v2);
1066 	struct nlattr *bc = NULL;
1067 
1068 	if (nlmsg_attrlen(cb->nlh, hdrlen))
1069 		bc = nlmsg_find_attr(cb->nlh, hdrlen, INET_DIAG_REQ_BYTECODE);
1070 
1071 	return __inet_diag_dump(skb, cb, nlmsg_data(cb->nlh), bc);
1072 }
1073 
1074 static int inet_diag_type2proto(int type)
1075 {
1076 	switch (type) {
1077 	case TCPDIAG_GETSOCK:
1078 		return IPPROTO_TCP;
1079 	case DCCPDIAG_GETSOCK:
1080 		return IPPROTO_DCCP;
1081 	default:
1082 		return 0;
1083 	}
1084 }
1085 
1086 static int inet_diag_dump_compat(struct sk_buff *skb,
1087 				 struct netlink_callback *cb)
1088 {
1089 	struct inet_diag_req *rc = nlmsg_data(cb->nlh);
1090 	int hdrlen = sizeof(struct inet_diag_req);
1091 	struct inet_diag_req_v2 req;
1092 	struct nlattr *bc = NULL;
1093 
1094 	req.sdiag_family = AF_UNSPEC; /* compatibility */
1095 	req.sdiag_protocol = inet_diag_type2proto(cb->nlh->nlmsg_type);
1096 	req.idiag_ext = rc->idiag_ext;
1097 	req.idiag_states = rc->idiag_states;
1098 	req.id = rc->id;
1099 
1100 	if (nlmsg_attrlen(cb->nlh, hdrlen))
1101 		bc = nlmsg_find_attr(cb->nlh, hdrlen, INET_DIAG_REQ_BYTECODE);
1102 
1103 	return __inet_diag_dump(skb, cb, &req, bc);
1104 }
1105 
1106 static int inet_diag_get_exact_compat(struct sk_buff *in_skb,
1107 				      const struct nlmsghdr *nlh)
1108 {
1109 	struct inet_diag_req *rc = nlmsg_data(nlh);
1110 	struct inet_diag_req_v2 req;
1111 
1112 	req.sdiag_family = rc->idiag_family;
1113 	req.sdiag_protocol = inet_diag_type2proto(nlh->nlmsg_type);
1114 	req.idiag_ext = rc->idiag_ext;
1115 	req.idiag_states = rc->idiag_states;
1116 	req.id = rc->id;
1117 
1118 	return inet_diag_cmd_exact(SOCK_DIAG_BY_FAMILY, in_skb, nlh, &req);
1119 }
1120 
1121 static int inet_diag_rcv_msg_compat(struct sk_buff *skb, struct nlmsghdr *nlh)
1122 {
1123 	int hdrlen = sizeof(struct inet_diag_req);
1124 	struct net *net = sock_net(skb->sk);
1125 
1126 	if (nlh->nlmsg_type >= INET_DIAG_GETSOCK_MAX ||
1127 	    nlmsg_len(nlh) < hdrlen)
1128 		return -EINVAL;
1129 
1130 	if (nlh->nlmsg_flags & NLM_F_DUMP) {
1131 		if (nlmsg_attrlen(nlh, hdrlen)) {
1132 			struct nlattr *attr;
1133 			int err;
1134 
1135 			attr = nlmsg_find_attr(nlh, hdrlen,
1136 					       INET_DIAG_REQ_BYTECODE);
1137 			err = inet_diag_bc_audit(attr, skb);
1138 			if (err)
1139 				return err;
1140 		}
1141 		{
1142 			struct netlink_dump_control c = {
1143 				.dump = inet_diag_dump_compat,
1144 			};
1145 			return netlink_dump_start(net->diag_nlsk, skb, nlh, &c);
1146 		}
1147 	}
1148 
1149 	return inet_diag_get_exact_compat(skb, nlh);
1150 }
1151 
1152 static int inet_diag_handler_cmd(struct sk_buff *skb, struct nlmsghdr *h)
1153 {
1154 	int hdrlen = sizeof(struct inet_diag_req_v2);
1155 	struct net *net = sock_net(skb->sk);
1156 
1157 	if (nlmsg_len(h) < hdrlen)
1158 		return -EINVAL;
1159 
1160 	if (h->nlmsg_type == SOCK_DIAG_BY_FAMILY &&
1161 	    h->nlmsg_flags & NLM_F_DUMP) {
1162 		if (nlmsg_attrlen(h, hdrlen)) {
1163 			struct nlattr *attr;
1164 			int err;
1165 
1166 			attr = nlmsg_find_attr(h, hdrlen,
1167 					       INET_DIAG_REQ_BYTECODE);
1168 			err = inet_diag_bc_audit(attr, skb);
1169 			if (err)
1170 				return err;
1171 		}
1172 		{
1173 			struct netlink_dump_control c = {
1174 				.dump = inet_diag_dump,
1175 			};
1176 			return netlink_dump_start(net->diag_nlsk, skb, h, &c);
1177 		}
1178 	}
1179 
1180 	return inet_diag_cmd_exact(h->nlmsg_type, skb, h, nlmsg_data(h));
1181 }
1182 
1183 static
1184 int inet_diag_handler_get_info(struct sk_buff *skb, struct sock *sk)
1185 {
1186 	const struct inet_diag_handler *handler;
1187 	struct nlmsghdr *nlh;
1188 	struct nlattr *attr;
1189 	struct inet_diag_msg *r;
1190 	void *info = NULL;
1191 	int err = 0;
1192 
1193 	nlh = nlmsg_put(skb, 0, 0, SOCK_DIAG_BY_FAMILY, sizeof(*r), 0);
1194 	if (!nlh)
1195 		return -ENOMEM;
1196 
1197 	r = nlmsg_data(nlh);
1198 	memset(r, 0, sizeof(*r));
1199 	inet_diag_msg_common_fill(r, sk);
1200 	if (sk->sk_type == SOCK_DGRAM || sk->sk_type == SOCK_STREAM)
1201 		r->id.idiag_sport = inet_sk(sk)->inet_sport;
1202 	r->idiag_state = sk->sk_state;
1203 
1204 	if ((err = nla_put_u8(skb, INET_DIAG_PROTOCOL, sk->sk_protocol))) {
1205 		nlmsg_cancel(skb, nlh);
1206 		return err;
1207 	}
1208 
1209 	handler = inet_diag_lock_handler(sk->sk_protocol);
1210 	if (IS_ERR(handler)) {
1211 		inet_diag_unlock_handler(handler);
1212 		nlmsg_cancel(skb, nlh);
1213 		return PTR_ERR(handler);
1214 	}
1215 
1216 	attr = handler->idiag_info_size
1217 		? nla_reserve_64bit(skb, INET_DIAG_INFO,
1218 				    handler->idiag_info_size,
1219 				    INET_DIAG_PAD)
1220 		: NULL;
1221 	if (attr)
1222 		info = nla_data(attr);
1223 
1224 	handler->idiag_get_info(sk, r, info);
1225 	inet_diag_unlock_handler(handler);
1226 
1227 	nlmsg_end(skb, nlh);
1228 	return 0;
1229 }
1230 
1231 static const struct sock_diag_handler inet_diag_handler = {
1232 	.family = AF_INET,
1233 	.dump = inet_diag_handler_cmd,
1234 	.get_info = inet_diag_handler_get_info,
1235 	.destroy = inet_diag_handler_cmd,
1236 };
1237 
1238 static const struct sock_diag_handler inet6_diag_handler = {
1239 	.family = AF_INET6,
1240 	.dump = inet_diag_handler_cmd,
1241 	.get_info = inet_diag_handler_get_info,
1242 	.destroy = inet_diag_handler_cmd,
1243 };
1244 
1245 int inet_diag_register(const struct inet_diag_handler *h)
1246 {
1247 	const __u16 type = h->idiag_type;
1248 	int err = -EINVAL;
1249 
1250 	if (type >= IPPROTO_MAX)
1251 		goto out;
1252 
1253 	mutex_lock(&inet_diag_table_mutex);
1254 	err = -EEXIST;
1255 	if (!inet_diag_table[type]) {
1256 		inet_diag_table[type] = h;
1257 		err = 0;
1258 	}
1259 	mutex_unlock(&inet_diag_table_mutex);
1260 out:
1261 	return err;
1262 }
1263 EXPORT_SYMBOL_GPL(inet_diag_register);
1264 
1265 void inet_diag_unregister(const struct inet_diag_handler *h)
1266 {
1267 	const __u16 type = h->idiag_type;
1268 
1269 	if (type >= IPPROTO_MAX)
1270 		return;
1271 
1272 	mutex_lock(&inet_diag_table_mutex);
1273 	inet_diag_table[type] = NULL;
1274 	mutex_unlock(&inet_diag_table_mutex);
1275 }
1276 EXPORT_SYMBOL_GPL(inet_diag_unregister);
1277 
1278 static int __init inet_diag_init(void)
1279 {
1280 	const int inet_diag_table_size = (IPPROTO_MAX *
1281 					  sizeof(struct inet_diag_handler *));
1282 	int err = -ENOMEM;
1283 
1284 	inet_diag_table = kzalloc(inet_diag_table_size, GFP_KERNEL);
1285 	if (!inet_diag_table)
1286 		goto out;
1287 
1288 	err = sock_diag_register(&inet_diag_handler);
1289 	if (err)
1290 		goto out_free_nl;
1291 
1292 	err = sock_diag_register(&inet6_diag_handler);
1293 	if (err)
1294 		goto out_free_inet;
1295 
1296 	sock_diag_register_inet_compat(inet_diag_rcv_msg_compat);
1297 out:
1298 	return err;
1299 
1300 out_free_inet:
1301 	sock_diag_unregister(&inet_diag_handler);
1302 out_free_nl:
1303 	kfree(inet_diag_table);
1304 	goto out;
1305 }
1306 
1307 static void __exit inet_diag_exit(void)
1308 {
1309 	sock_diag_unregister(&inet6_diag_handler);
1310 	sock_diag_unregister(&inet_diag_handler);
1311 	sock_diag_unregister_inet_compat(inet_diag_rcv_msg_compat);
1312 	kfree(inet_diag_table);
1313 }
1314 
1315 module_init(inet_diag_init);
1316 module_exit(inet_diag_exit);
1317 MODULE_LICENSE("GPL");
1318 MODULE_ALIAS_NET_PF_PROTO_TYPE(PF_NETLINK, NETLINK_SOCK_DIAG, 2 /* AF_INET */);
1319 MODULE_ALIAS_NET_PF_PROTO_TYPE(PF_NETLINK, NETLINK_SOCK_DIAG, 10 /* AF_INET6 */);
1320