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