net/ipv4/inet_diag.c

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