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