net/netlink/diag.c

   1 #include <linux/module.h>
   2
   3 #include <net/sock.h>
   4 #include <linux/netlink.h>
   5 #include <linux/sock_diag.h>
   6 #include <linux/netlink_diag.h>
   7 #include <linux/rhashtable.h>
   8
   9 #include "af_netlink.h"
  10
  11 static int sk_diag_dump_groups(struct sock *sk, struct sk_buff *nlskb)
  12 {
  13         struct netlink_sock *nlk = nlk_sk(sk);
  14
  15         if (nlk->groups == NULL)
  16                 return 0;
  17
  18         return nla_put(nlskb, NETLINK_DIAG_GROUPS, NLGRPSZ(nlk->ngroups),
  19                        nlk->groups);
  20 }
  21
  22 static int sk_diag_fill(struct sock *sk, struct sk_buff *skb,
  23                         struct netlink_diag_req *req,
  24                         u32 portid, u32 seq, u32 flags, int sk_ino)
  25 {
  26         struct nlmsghdr *nlh;
  27         struct netlink_diag_msg *rep;
  28         struct netlink_sock *nlk = nlk_sk(sk);
  29
  30         nlh = nlmsg_put(skb, portid, seq, SOCK_DIAG_BY_FAMILY, sizeof(*rep),
  31                         flags);
  32         if (!nlh)
  33                 return -EMSGSIZE;
  34
  35         rep = nlmsg_data(nlh);
  36         rep->ndiag_family       = AF_NETLINK;
  37         rep->ndiag_type         = sk->sk_type;
  38         rep->ndiag_protocol     = sk->sk_protocol;
  39         rep->ndiag_state        = sk->sk_state;
  40
  41         rep->ndiag_ino          = sk_ino;
  42         rep->ndiag_portid       = nlk->portid;
  43         rep->ndiag_dst_portid   = nlk->dst_portid;
  44         rep->ndiag_dst_group    = nlk->dst_group;
  45         sock_diag_save_cookie(sk, rep->ndiag_cookie);
  46
  47         if ((req->ndiag_show & NDIAG_SHOW_GROUPS) &&
  48             sk_diag_dump_groups(sk, skb))
  49                 goto out_nlmsg_trim;
  50
  51         if ((req->ndiag_show & NDIAG_SHOW_MEMINFO) &&
  52             sock_diag_put_meminfo(sk, skb, NETLINK_DIAG_MEMINFO))
  53                 goto out_nlmsg_trim;
  54
  55         nlmsg_end(skb, nlh);
  56         return 0;
  57
  58 out_nlmsg_trim:
  59         nlmsg_cancel(skb, nlh);
  60         return -EMSGSIZE;
  61 }
  62
  63 static int __netlink_diag_dump(struct sk_buff *skb, struct netlink_callback *cb,
  64                                 int protocol, int s_num)
  65 {
  66         struct rhashtable_iter *hti = (void *)cb->args[2];
  67         struct netlink_table *tbl = &nl_table[protocol];
  68         struct net *net = sock_net(skb->sk);
  69         struct netlink_diag_req *req;
  70         struct netlink_sock *nlsk;
  71         struct sock *sk;
  72         int num = 2;
  73         int ret = 0;
  74
  75         req = nlmsg_data(cb->nlh);
  76
  77         if (s_num > 1)
  78                 goto mc_list;
  79
  80         num--;
  81
  82         if (!hti) {
  83                 hti = kmalloc(sizeof(*hti), GFP_KERNEL);
  84                 if (!hti)
  85                         return -ENOMEM;
  86
  87                 cb->args[2] = (long)hti;
  88         }
  89
  90         if (!s_num)
  91                 rhashtable_walk_enter(&tbl->hash, hti);
  92
  93         ret = rhashtable_walk_start(hti);
  94         if (ret == -EAGAIN)
  95                 ret = 0;
  96         if (ret)
  97                 goto stop;
  98
  99         while ((nlsk = rhashtable_walk_next(hti))) {
 100                 if (IS_ERR(nlsk)) {
 101                         ret = PTR_ERR(nlsk);
 102                         if (ret == -EAGAIN) {
 103                                 ret = 0;
 104                                 continue;
 105                         }
 106                         break;
 107                 }
 108
 109                 sk = (struct sock *)nlsk;
 110
 111                 if (!net_eq(sock_net(sk), net))
 112                         continue;
 113
 114                 if (sk_diag_fill(sk, skb, req,
 115                                  NETLINK_CB(cb->skb).portid,
 116                                  cb->nlh->nlmsg_seq,
 117                                  NLM_F_MULTI,
 118                                  sock_i_ino(sk)) < 0) {
 119                         ret = 1;
 120                         break;
 121                 }
 122         }
 123
 124 stop:
 125         rhashtable_walk_stop(hti);
 126         if (ret)
 127                 goto done;
 128
 129         rhashtable_walk_exit(hti);
 130         cb->args[2] = 0;
 131         num++;
 132
 133 mc_list:
 134         read_lock(&nl_table_lock);
 135         sk_for_each_bound(sk, &tbl->mc_list) {
 136                 if (sk_hashed(sk))
 137                         continue;
 138                 if (!net_eq(sock_net(sk), net))
 139                         continue;
 140                 if (num < s_num) {
 141                         num++;
 142                         continue;
 143                 }
 144
 145                 if (sk_diag_fill(sk, skb, req,
 146                                  NETLINK_CB(cb->skb).portid,
 147                                  cb->nlh->nlmsg_seq,
 148                                  NLM_F_MULTI,
 149                                  sock_i_ino(sk)) < 0) {
 150                         ret = 1;
 151                         break;
 152                 }
 153                 num++;
 154         }
 155         read_unlock(&nl_table_lock);
 156
 157 done:
 158         cb->args[0] = num;
 159
 160         return ret;
 161 }
 162
 163 static int netlink_diag_dump(struct sk_buff *skb, struct netlink_callback *cb)
 164 {
 165         struct netlink_diag_req *req;
 166         int s_num = cb->args[0];
 167         int err = 0;
 168
 169         req = nlmsg_data(cb->nlh);
 170
 171         if (req->sdiag_protocol == NDIAG_PROTO_ALL) {
 172                 int i;
 173
 174                 for (i = cb->args[1]; i < MAX_LINKS; i++) {
 175                         err = __netlink_diag_dump(skb, cb, i, s_num);
 176                         if (err)
 177                                 break;
 178                         s_num = 0;
 179                 }
 180                 cb->args[1] = i;
 181         } else {
 182                 if (req->sdiag_protocol >= MAX_LINKS) {
 183                         read_unlock(&nl_table_lock);
 184                         rcu_read_unlock();
 185                         return -ENOENT;
 186                 }
 187
 188                 err = __netlink_diag_dump(skb, cb, req->sdiag_protocol, s_num);
 189         }
 190
 191         return err < 0 ? err : skb->len;
 192 }
 193
 194 static int netlink_diag_dump_done(struct netlink_callback *cb)
 195 {
 196         struct rhashtable_iter *hti = (void *)cb->args[2];
 197
 198         if (cb->args[0] == 1)
 199                 rhashtable_walk_exit(hti);
 200
 201         kfree(hti);
 202
 203         return 0;
 204 }
 205
 206 static int netlink_diag_handler_dump(struct sk_buff *skb, struct nlmsghdr *h)
 207 {
 208         int hdrlen = sizeof(struct netlink_diag_req);
 209         struct net *net = sock_net(skb->sk);
 210
 211         if (nlmsg_len(h) < hdrlen)
 212                 return -EINVAL;
 213
 214         if (h->nlmsg_flags & NLM_F_DUMP) {
 215                 struct netlink_dump_control c = {
 216                         .dump = netlink_diag_dump,
 217                         .done = netlink_diag_dump_done,
 218                 };
 219                 return netlink_dump_start(net->diag_nlsk, skb, h, &c);
 220         } else
 221                 return -EOPNOTSUPP;
 222 }
 223
 224 static const struct sock_diag_handler netlink_diag_handler = {
 225         .family = AF_NETLINK,
 226         .dump = netlink_diag_handler_dump,
 227 };
 228
 229 static int __init netlink_diag_init(void)
 230 {
 231         return sock_diag_register(&netlink_diag_handler);
 232 }
 233
 234 static void __exit netlink_diag_exit(void)
 235 {
 236         sock_diag_unregister(&netlink_diag_handler);
 237 }
 238
 239 module_init(netlink_diag_init);
 240 module_exit(netlink_diag_exit);
 241 MODULE_LICENSE("GPL");
 242 MODULE_ALIAS_NET_PF_PROTO_TYPE(PF_NETLINK, NETLINK_SOCK_DIAG, 16 /* AF_NETLINK */);