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