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
inet_diag_lock_handler(int proto)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
inet_diag_unlock_handler(const struct inet_diag_handler * handler)61 static void inet_diag_unlock_handler(const struct inet_diag_handler *handler)
62 {
63 mutex_unlock(&inet_diag_table_mutex);
64 }
65
inet_diag_msg_common_fill(struct inet_diag_msg * r,struct sock * sk)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
inet_sk_attr_size(struct sock * sk,const struct inet_diag_req_v2 * req,bool net_admin)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
inet_diag_msg_attrs_fill(struct sock * sk,struct sk_buff * skb,struct inet_diag_msg * r,int ext,struct user_namespace * user_ns,bool net_admin)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
inet_sk_diag_fill(struct sock * sk,struct inet_connection_sock * icsk,struct sk_buff * skb,const struct inet_diag_req_v2 * req,struct user_namespace * user_ns,u32 portid,u32 seq,u16 nlmsg_flags,const struct nlmsghdr * unlh,bool net_admin)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
inet_csk_diag_fill(struct sock * sk,struct sk_buff * skb,const struct inet_diag_req_v2 * req,struct user_namespace * user_ns,u32 portid,u32 seq,u16 nlmsg_flags,const struct nlmsghdr * unlh,bool net_admin)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
inet_twsk_diag_fill(struct sock * sk,struct sk_buff * skb,u32 portid,u32 seq,u16 nlmsg_flags,const struct nlmsghdr * unlh)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
inet_req_diag_fill(struct sock * sk,struct sk_buff * skb,u32 portid,u32 seq,u16 nlmsg_flags,const struct nlmsghdr * unlh,bool net_admin)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
sk_diag_fill(struct sock * sk,struct sk_buff * skb,const struct inet_diag_req_v2 * r,struct user_namespace * user_ns,u32 portid,u32 seq,u16 nlmsg_flags,const struct nlmsghdr * unlh,bool net_admin)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
inet_diag_find_one_icsk(struct net * net,struct inet_hashinfo * hashinfo,const struct inet_diag_req_v2 * req)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
inet_diag_dump_one_icsk(struct inet_hashinfo * hashinfo,struct sk_buff * in_skb,const struct nlmsghdr * nlh,const struct inet_diag_req_v2 * req)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
inet_diag_cmd_exact(int cmd,struct sk_buff * in_skb,const struct nlmsghdr * nlh,const struct inet_diag_req_v2 * req)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
bitstring_match(const __be32 * a1,const __be32 * a2,int bits)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
inet_diag_bc_run(const struct nlattr * _bc,const struct inet_diag_entry * entry)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 */
entry_fill_addrs(struct inet_diag_entry * entry,const struct sock * sk)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
inet_diag_bc_sk(const struct nlattr * bc,struct sock * sk)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
valid_cc(const void * bc,int len,int cc)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 */
valid_devcond(const struct inet_diag_bc_op * op,int len,int * min_len)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. */
valid_hostcond(const struct inet_diag_bc_op * op,int len,int * min_len)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. */
valid_port_comparison(const struct inet_diag_bc_op * op,int len,int * min_len)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
valid_markcond(const struct inet_diag_bc_op * op,int len,int * min_len)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
inet_diag_bc_audit(const struct nlattr * attr,const struct sk_buff * skb)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
inet_csk_diag_dump(struct sock * sk,struct sk_buff * skb,struct netlink_callback * cb,const struct inet_diag_req_v2 * r,const struct nlattr * bc,bool net_admin)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
twsk_build_assert(void)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
inet_diag_dump_icsk(struct inet_hashinfo * hashinfo,struct sk_buff * skb,struct netlink_callback * cb,const struct inet_diag_req_v2 * r,struct nlattr * bc)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 struct hlist_nulls_node *node;
918
919 num = 0;
920 ilb = &hashinfo->listening_hash[i];
921 spin_lock(&ilb->lock);
922 sk_nulls_for_each(sk, node, &ilb->nulls_head) {
923 struct inet_sock *inet = inet_sk(sk);
924
925 if (!net_eq(sock_net(sk), net))
926 continue;
927
928 if (num < s_num) {
929 num++;
930 continue;
931 }
932
933 if (r->sdiag_family != AF_UNSPEC &&
934 sk->sk_family != r->sdiag_family)
935 goto next_listen;
936
937 if (r->id.idiag_sport != inet->inet_sport &&
938 r->id.idiag_sport)
939 goto next_listen;
940
941 if (inet_csk_diag_dump(sk, skb, cb, r,
942 bc, net_admin) < 0) {
943 spin_unlock(&ilb->lock);
944 goto done;
945 }
946
947 next_listen:
948 ++num;
949 }
950 spin_unlock(&ilb->lock);
951
952 s_num = 0;
953 }
954 skip_listen_ht:
955 cb->args[0] = 1;
956 s_i = num = s_num = 0;
957 }
958
959 if (!(idiag_states & ~TCPF_LISTEN))
960 goto out;
961
962 #define SKARR_SZ 16
963 for (i = s_i; i <= hashinfo->ehash_mask; i++) {
964 struct inet_ehash_bucket *head = &hashinfo->ehash[i];
965 spinlock_t *lock = inet_ehash_lockp(hashinfo, i);
966 struct hlist_nulls_node *node;
967 struct sock *sk_arr[SKARR_SZ];
968 int num_arr[SKARR_SZ];
969 int idx, accum, res;
970
971 if (hlist_nulls_empty(&head->chain))
972 continue;
973
974 if (i > s_i)
975 s_num = 0;
976
977 next_chunk:
978 num = 0;
979 accum = 0;
980 spin_lock_bh(lock);
981 sk_nulls_for_each(sk, node, &head->chain) {
982 int state;
983
984 if (!net_eq(sock_net(sk), net))
985 continue;
986 if (num < s_num)
987 goto next_normal;
988 state = (sk->sk_state == TCP_TIME_WAIT) ?
989 inet_twsk(sk)->tw_substate : sk->sk_state;
990 if (!(idiag_states & (1 << state)))
991 goto next_normal;
992 if (r->sdiag_family != AF_UNSPEC &&
993 sk->sk_family != r->sdiag_family)
994 goto next_normal;
995 if (r->id.idiag_sport != htons(sk->sk_num) &&
996 r->id.idiag_sport)
997 goto next_normal;
998 if (r->id.idiag_dport != sk->sk_dport &&
999 r->id.idiag_dport)
1000 goto next_normal;
1001 twsk_build_assert();
1002
1003 if (!inet_diag_bc_sk(bc, sk))
1004 goto next_normal;
1005
1006 if (!refcount_inc_not_zero(&sk->sk_refcnt))
1007 goto next_normal;
1008
1009 num_arr[accum] = num;
1010 sk_arr[accum] = sk;
1011 if (++accum == SKARR_SZ)
1012 break;
1013 next_normal:
1014 ++num;
1015 }
1016 spin_unlock_bh(lock);
1017 res = 0;
1018 for (idx = 0; idx < accum; idx++) {
1019 if (res >= 0) {
1020 res = sk_diag_fill(sk_arr[idx], skb, r,
1021 sk_user_ns(NETLINK_CB(cb->skb).sk),
1022 NETLINK_CB(cb->skb).portid,
1023 cb->nlh->nlmsg_seq, NLM_F_MULTI,
1024 cb->nlh, net_admin);
1025 if (res < 0)
1026 num = num_arr[idx];
1027 }
1028 sock_gen_put(sk_arr[idx]);
1029 }
1030 if (res < 0)
1031 break;
1032 cond_resched();
1033 if (accum == SKARR_SZ) {
1034 s_num = num + 1;
1035 goto next_chunk;
1036 }
1037 }
1038
1039 done:
1040 cb->args[1] = i;
1041 cb->args[2] = num;
1042 out:
1043 ;
1044 }
1045 EXPORT_SYMBOL_GPL(inet_diag_dump_icsk);
1046
__inet_diag_dump(struct sk_buff * skb,struct netlink_callback * cb,const struct inet_diag_req_v2 * r,struct nlattr * bc)1047 static int __inet_diag_dump(struct sk_buff *skb, struct netlink_callback *cb,
1048 const struct inet_diag_req_v2 *r,
1049 struct nlattr *bc)
1050 {
1051 const struct inet_diag_handler *handler;
1052 int err = 0;
1053
1054 handler = inet_diag_lock_handler(r->sdiag_protocol);
1055 if (!IS_ERR(handler))
1056 handler->dump(skb, cb, r, bc);
1057 else
1058 err = PTR_ERR(handler);
1059 inet_diag_unlock_handler(handler);
1060
1061 return err ? : skb->len;
1062 }
1063
inet_diag_dump(struct sk_buff * skb,struct netlink_callback * cb)1064 static int inet_diag_dump(struct sk_buff *skb, struct netlink_callback *cb)
1065 {
1066 int hdrlen = sizeof(struct inet_diag_req_v2);
1067 struct nlattr *bc = NULL;
1068
1069 if (nlmsg_attrlen(cb->nlh, hdrlen))
1070 bc = nlmsg_find_attr(cb->nlh, hdrlen, INET_DIAG_REQ_BYTECODE);
1071
1072 return __inet_diag_dump(skb, cb, nlmsg_data(cb->nlh), bc);
1073 }
1074
inet_diag_type2proto(int type)1075 static int inet_diag_type2proto(int type)
1076 {
1077 switch (type) {
1078 case TCPDIAG_GETSOCK:
1079 return IPPROTO_TCP;
1080 case DCCPDIAG_GETSOCK:
1081 return IPPROTO_DCCP;
1082 default:
1083 return 0;
1084 }
1085 }
1086
inet_diag_dump_compat(struct sk_buff * skb,struct netlink_callback * cb)1087 static int inet_diag_dump_compat(struct sk_buff *skb,
1088 struct netlink_callback *cb)
1089 {
1090 struct inet_diag_req *rc = nlmsg_data(cb->nlh);
1091 int hdrlen = sizeof(struct inet_diag_req);
1092 struct inet_diag_req_v2 req;
1093 struct nlattr *bc = NULL;
1094
1095 req.sdiag_family = AF_UNSPEC; /* compatibility */
1096 req.sdiag_protocol = inet_diag_type2proto(cb->nlh->nlmsg_type);
1097 req.idiag_ext = rc->idiag_ext;
1098 req.idiag_states = rc->idiag_states;
1099 req.id = rc->id;
1100
1101 if (nlmsg_attrlen(cb->nlh, hdrlen))
1102 bc = nlmsg_find_attr(cb->nlh, hdrlen, INET_DIAG_REQ_BYTECODE);
1103
1104 return __inet_diag_dump(skb, cb, &req, bc);
1105 }
1106
inet_diag_get_exact_compat(struct sk_buff * in_skb,const struct nlmsghdr * nlh)1107 static int inet_diag_get_exact_compat(struct sk_buff *in_skb,
1108 const struct nlmsghdr *nlh)
1109 {
1110 struct inet_diag_req *rc = nlmsg_data(nlh);
1111 struct inet_diag_req_v2 req;
1112
1113 req.sdiag_family = rc->idiag_family;
1114 req.sdiag_protocol = inet_diag_type2proto(nlh->nlmsg_type);
1115 req.idiag_ext = rc->idiag_ext;
1116 req.idiag_states = rc->idiag_states;
1117 req.id = rc->id;
1118
1119 return inet_diag_cmd_exact(SOCK_DIAG_BY_FAMILY, in_skb, nlh, &req);
1120 }
1121
inet_diag_rcv_msg_compat(struct sk_buff * skb,struct nlmsghdr * nlh)1122 static int inet_diag_rcv_msg_compat(struct sk_buff *skb, struct nlmsghdr *nlh)
1123 {
1124 int hdrlen = sizeof(struct inet_diag_req);
1125 struct net *net = sock_net(skb->sk);
1126
1127 if (nlh->nlmsg_type >= INET_DIAG_GETSOCK_MAX ||
1128 nlmsg_len(nlh) < hdrlen)
1129 return -EINVAL;
1130
1131 if (nlh->nlmsg_flags & NLM_F_DUMP) {
1132 if (nlmsg_attrlen(nlh, hdrlen)) {
1133 struct nlattr *attr;
1134 int err;
1135
1136 attr = nlmsg_find_attr(nlh, hdrlen,
1137 INET_DIAG_REQ_BYTECODE);
1138 err = inet_diag_bc_audit(attr, skb);
1139 if (err)
1140 return err;
1141 }
1142 {
1143 struct netlink_dump_control c = {
1144 .dump = inet_diag_dump_compat,
1145 };
1146 return netlink_dump_start(net->diag_nlsk, skb, nlh, &c);
1147 }
1148 }
1149
1150 return inet_diag_get_exact_compat(skb, nlh);
1151 }
1152
inet_diag_handler_cmd(struct sk_buff * skb,struct nlmsghdr * h)1153 static int inet_diag_handler_cmd(struct sk_buff *skb, struct nlmsghdr *h)
1154 {
1155 int hdrlen = sizeof(struct inet_diag_req_v2);
1156 struct net *net = sock_net(skb->sk);
1157
1158 if (nlmsg_len(h) < hdrlen)
1159 return -EINVAL;
1160
1161 if (h->nlmsg_type == SOCK_DIAG_BY_FAMILY &&
1162 h->nlmsg_flags & NLM_F_DUMP) {
1163 if (nlmsg_attrlen(h, hdrlen)) {
1164 struct nlattr *attr;
1165 int err;
1166
1167 attr = nlmsg_find_attr(h, hdrlen,
1168 INET_DIAG_REQ_BYTECODE);
1169 err = inet_diag_bc_audit(attr, skb);
1170 if (err)
1171 return err;
1172 }
1173 {
1174 struct netlink_dump_control c = {
1175 .dump = inet_diag_dump,
1176 };
1177 return netlink_dump_start(net->diag_nlsk, skb, h, &c);
1178 }
1179 }
1180
1181 return inet_diag_cmd_exact(h->nlmsg_type, skb, h, nlmsg_data(h));
1182 }
1183
1184 static
inet_diag_handler_get_info(struct sk_buff * skb,struct sock * sk)1185 int inet_diag_handler_get_info(struct sk_buff *skb, struct sock *sk)
1186 {
1187 const struct inet_diag_handler *handler;
1188 struct nlmsghdr *nlh;
1189 struct nlattr *attr;
1190 struct inet_diag_msg *r;
1191 void *info = NULL;
1192 int err = 0;
1193
1194 nlh = nlmsg_put(skb, 0, 0, SOCK_DIAG_BY_FAMILY, sizeof(*r), 0);
1195 if (!nlh)
1196 return -ENOMEM;
1197
1198 r = nlmsg_data(nlh);
1199 memset(r, 0, sizeof(*r));
1200 inet_diag_msg_common_fill(r, sk);
1201 if (sk->sk_type == SOCK_DGRAM || sk->sk_type == SOCK_STREAM)
1202 r->id.idiag_sport = inet_sk(sk)->inet_sport;
1203 r->idiag_state = sk->sk_state;
1204
1205 if ((err = nla_put_u8(skb, INET_DIAG_PROTOCOL, sk->sk_protocol))) {
1206 nlmsg_cancel(skb, nlh);
1207 return err;
1208 }
1209
1210 handler = inet_diag_lock_handler(sk->sk_protocol);
1211 if (IS_ERR(handler)) {
1212 inet_diag_unlock_handler(handler);
1213 nlmsg_cancel(skb, nlh);
1214 return PTR_ERR(handler);
1215 }
1216
1217 attr = handler->idiag_info_size
1218 ? nla_reserve_64bit(skb, INET_DIAG_INFO,
1219 handler->idiag_info_size,
1220 INET_DIAG_PAD)
1221 : NULL;
1222 if (attr)
1223 info = nla_data(attr);
1224
1225 handler->idiag_get_info(sk, r, info);
1226 inet_diag_unlock_handler(handler);
1227
1228 nlmsg_end(skb, nlh);
1229 return 0;
1230 }
1231
1232 static const struct sock_diag_handler inet_diag_handler = {
1233 .family = AF_INET,
1234 .dump = inet_diag_handler_cmd,
1235 .get_info = inet_diag_handler_get_info,
1236 .destroy = inet_diag_handler_cmd,
1237 };
1238
1239 static const struct sock_diag_handler inet6_diag_handler = {
1240 .family = AF_INET6,
1241 .dump = inet_diag_handler_cmd,
1242 .get_info = inet_diag_handler_get_info,
1243 .destroy = inet_diag_handler_cmd,
1244 };
1245
inet_diag_register(const struct inet_diag_handler * h)1246 int inet_diag_register(const struct inet_diag_handler *h)
1247 {
1248 const __u16 type = h->idiag_type;
1249 int err = -EINVAL;
1250
1251 if (type >= IPPROTO_MAX)
1252 goto out;
1253
1254 mutex_lock(&inet_diag_table_mutex);
1255 err = -EEXIST;
1256 if (!inet_diag_table[type]) {
1257 inet_diag_table[type] = h;
1258 err = 0;
1259 }
1260 mutex_unlock(&inet_diag_table_mutex);
1261 out:
1262 return err;
1263 }
1264 EXPORT_SYMBOL_GPL(inet_diag_register);
1265
inet_diag_unregister(const struct inet_diag_handler * h)1266 void inet_diag_unregister(const struct inet_diag_handler *h)
1267 {
1268 const __u16 type = h->idiag_type;
1269
1270 if (type >= IPPROTO_MAX)
1271 return;
1272
1273 mutex_lock(&inet_diag_table_mutex);
1274 inet_diag_table[type] = NULL;
1275 mutex_unlock(&inet_diag_table_mutex);
1276 }
1277 EXPORT_SYMBOL_GPL(inet_diag_unregister);
1278
inet_diag_init(void)1279 static int __init inet_diag_init(void)
1280 {
1281 const int inet_diag_table_size = (IPPROTO_MAX *
1282 sizeof(struct inet_diag_handler *));
1283 int err = -ENOMEM;
1284
1285 inet_diag_table = kzalloc(inet_diag_table_size, GFP_KERNEL);
1286 if (!inet_diag_table)
1287 goto out;
1288
1289 err = sock_diag_register(&inet_diag_handler);
1290 if (err)
1291 goto out_free_nl;
1292
1293 err = sock_diag_register(&inet6_diag_handler);
1294 if (err)
1295 goto out_free_inet;
1296
1297 sock_diag_register_inet_compat(inet_diag_rcv_msg_compat);
1298 out:
1299 return err;
1300
1301 out_free_inet:
1302 sock_diag_unregister(&inet_diag_handler);
1303 out_free_nl:
1304 kfree(inet_diag_table);
1305 goto out;
1306 }
1307
inet_diag_exit(void)1308 static void __exit inet_diag_exit(void)
1309 {
1310 sock_diag_unregister(&inet6_diag_handler);
1311 sock_diag_unregister(&inet_diag_handler);
1312 sock_diag_unregister_inet_compat(inet_diag_rcv_msg_compat);
1313 kfree(inet_diag_table);
1314 }
1315
1316 module_init(inet_diag_init);
1317 module_exit(inet_diag_exit);
1318 MODULE_LICENSE("GPL");
1319 MODULE_ALIAS_NET_PF_PROTO_TYPE(PF_NETLINK, NETLINK_SOCK_DIAG, 2 /* AF_INET */);
1320 MODULE_ALIAS_NET_PF_PROTO_TYPE(PF_NETLINK, NETLINK_SOCK_DIAG, 10 /* AF_INET6 */);
1321