net/core/sock_diag.c

   1 #include <linux/mutex.h>
   2 #include <linux/socket.h>
   3 #include <linux/skbuff.h>
   4 #include <net/netlink.h>
   5 #include <net/net_namespace.h>
   6 #include <linux/module.h>
   7 #include <net/sock.h>
   8
   9 #include <linux/inet_diag.h>
  10 #include <linux/sock_diag.h>
  11
  12 static const struct sock_diag_handler *sock_diag_handlers[AF_MAX];
  13 static int (*inet_rcv_compat)(struct sk_buff *skb, struct nlmsghdr *nlh);
  14 static DEFINE_MUTEX(sock_diag_table_mutex);
  15
  16 static u64 sock_gen_cookie(struct sock *sk)
  17 {
  18         while (1) {
  19                 u64 res = atomic64_read(&sk->sk_cookie);
  20
  21                 if (res)
  22                         return res;
  23                 res = atomic64_inc_return(&sock_net(sk)->cookie_gen);
  24                 atomic64_cmpxchg(&sk->sk_cookie, 0, res);
  25         }
  26 }
  27
  28 int sock_diag_check_cookie(struct sock *sk, const __u32 *cookie)
  29 {
  30         u64 res;
  31
  32         if (cookie[0] == INET_DIAG_NOCOOKIE && cookie[1] == INET_DIAG_NOCOOKIE)
  33                 return 0;
  34
  35         res = sock_gen_cookie(sk);
  36         if ((u32)res != cookie[0] || (u32)(res >> 32) != cookie[1])
  37                 return -ESTALE;
  38
  39         return 0;
  40 }
  41 EXPORT_SYMBOL_GPL(sock_diag_check_cookie);
  42
  43 void sock_diag_save_cookie(struct sock *sk, __u32 *cookie)
  44 {
  45         u64 res = sock_gen_cookie(sk);
  46
  47         cookie[0] = (u32)res;
  48         cookie[1] = (u32)(res >> 32);
  49 }
  50 EXPORT_SYMBOL_GPL(sock_diag_save_cookie);
  51
  52 int sock_diag_put_meminfo(struct sock *sk, struct sk_buff *skb, int attrtype)
  53 {
  54         u32 mem[SK_MEMINFO_VARS];
  55
  56         mem[SK_MEMINFO_RMEM_ALLOC] = sk_rmem_alloc_get(sk);
  57         mem[SK_MEMINFO_RCVBUF] = sk->sk_rcvbuf;
  58         mem[SK_MEMINFO_WMEM_ALLOC] = sk_wmem_alloc_get(sk);
  59         mem[SK_MEMINFO_SNDBUF] = sk->sk_sndbuf;
  60         mem[SK_MEMINFO_FWD_ALLOC] = sk->sk_forward_alloc;
  61         mem[SK_MEMINFO_WMEM_QUEUED] = sk->sk_wmem_queued;
  62         mem[SK_MEMINFO_OPTMEM] = atomic_read(&sk->sk_omem_alloc);
  63         mem[SK_MEMINFO_BACKLOG] = sk->sk_backlog.len;
  64
  65         return nla_put(skb, attrtype, sizeof(mem), &mem);
  66 }
  67 EXPORT_SYMBOL_GPL(sock_diag_put_meminfo);
  68
  69 int sock_diag_put_filterinfo(bool may_report_filterinfo, struct sock *sk,
  70                              struct sk_buff *skb, int attrtype)
  71 {
  72         struct sock_fprog_kern *fprog;
  73         struct sk_filter *filter;
  74         struct nlattr *attr;
  75         unsigned int flen;
  76         int err = 0;
  77
  78         if (!may_report_filterinfo) {
  79                 nla_reserve(skb, attrtype, 0);
  80                 return 0;
  81         }
  82
  83         rcu_read_lock();
  84         filter = rcu_dereference(sk->sk_filter);
  85         if (!filter)
  86                 goto out;
  87
  88         fprog = filter->prog->orig_prog;
  89         if (!fprog)
  90                 goto out;
  91
  92         flen = bpf_classic_proglen(fprog);
  93
  94         attr = nla_reserve(skb, attrtype, flen);
  95         if (attr == NULL) {
  96                 err = -EMSGSIZE;
  97                 goto out;
  98         }
  99
 100         memcpy(nla_data(attr), fprog->filter, flen);
 101 out:
 102         rcu_read_unlock();
 103         return err;
 104 }
 105 EXPORT_SYMBOL(sock_diag_put_filterinfo);
 106
 107 void sock_diag_register_inet_compat(int (*fn)(struct sk_buff *skb, struct nlmsghdr *nlh))
 108 {
 109         mutex_lock(&sock_diag_table_mutex);
 110         inet_rcv_compat = fn;
 111         mutex_unlock(&sock_diag_table_mutex);
 112 }
 113 EXPORT_SYMBOL_GPL(sock_diag_register_inet_compat);
 114
 115 void sock_diag_unregister_inet_compat(int (*fn)(struct sk_buff *skb, struct nlmsghdr *nlh))
 116 {
 117         mutex_lock(&sock_diag_table_mutex);
 118         inet_rcv_compat = NULL;
 119         mutex_unlock(&sock_diag_table_mutex);
 120 }
 121 EXPORT_SYMBOL_GPL(sock_diag_unregister_inet_compat);
 122
 123 int sock_diag_register(const struct sock_diag_handler *hndl)
 124 {
 125         int err = 0;
 126
 127         if (hndl->family >= AF_MAX)
 128                 return -EINVAL;
 129
 130         mutex_lock(&sock_diag_table_mutex);
 131         if (sock_diag_handlers[hndl->family])
 132                 err = -EBUSY;
 133         else
 134                 sock_diag_handlers[hndl->family] = hndl;
 135         mutex_unlock(&sock_diag_table_mutex);
 136
 137         return err;
 138 }
 139 EXPORT_SYMBOL_GPL(sock_diag_register);
 140
 141 void sock_diag_unregister(const struct sock_diag_handler *hnld)
 142 {
 143         int family = hnld->family;
 144
 145         if (family >= AF_MAX)
 146                 return;
 147
 148         mutex_lock(&sock_diag_table_mutex);
 149         BUG_ON(sock_diag_handlers[family] != hnld);
 150         sock_diag_handlers[family] = NULL;
 151         mutex_unlock(&sock_diag_table_mutex);
 152 }
 153 EXPORT_SYMBOL_GPL(sock_diag_unregister);
 154
 155 static int __sock_diag_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh)
 156 {
 157         int err;
 158         struct sock_diag_req *req = nlmsg_data(nlh);
 159         const struct sock_diag_handler *hndl;
 160
 161         if (nlmsg_len(nlh) < sizeof(*req))
 162                 return -EINVAL;
 163
 164         if (req->sdiag_family >= AF_MAX)
 165                 return -EINVAL;
 166
 167         if (sock_diag_handlers[req->sdiag_family] == NULL)
 168                 request_module("net-pf-%d-proto-%d-type-%d", PF_NETLINK,
 169                                 NETLINK_SOCK_DIAG, req->sdiag_family);
 170
 171         mutex_lock(&sock_diag_table_mutex);
 172         hndl = sock_diag_handlers[req->sdiag_family];
 173         if (hndl == NULL)
 174                 err = -ENOENT;
 175         else
 176                 err = hndl->dump(skb, nlh);
 177         mutex_unlock(&sock_diag_table_mutex);
 178
 179         return err;
 180 }
 181
 182 static int sock_diag_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh)
 183 {
 184         int ret;
 185
 186         switch (nlh->nlmsg_type) {
 187         case TCPDIAG_GETSOCK:
 188         case DCCPDIAG_GETSOCK:
 189                 if (inet_rcv_compat == NULL)
 190                         request_module("net-pf-%d-proto-%d-type-%d", PF_NETLINK,
 191                                         NETLINK_SOCK_DIAG, AF_INET);
 192
 193                 mutex_lock(&sock_diag_table_mutex);
 194                 if (inet_rcv_compat != NULL)
 195                         ret = inet_rcv_compat(skb, nlh);
 196                 else
 197                         ret = -EOPNOTSUPP;
 198                 mutex_unlock(&sock_diag_table_mutex);
 199
 200                 return ret;
 201         case SOCK_DIAG_BY_FAMILY:
 202                 return __sock_diag_rcv_msg(skb, nlh);
 203         default:
 204                 return -EINVAL;
 205         }
 206 }
 207
 208 static DEFINE_MUTEX(sock_diag_mutex);
 209
 210 static void sock_diag_rcv(struct sk_buff *skb)
 211 {
 212         mutex_lock(&sock_diag_mutex);
 213         netlink_rcv_skb(skb, &sock_diag_rcv_msg);
 214         mutex_unlock(&sock_diag_mutex);
 215 }
 216
 217 static int __net_init diag_net_init(struct net *net)
 218 {
 219         struct netlink_kernel_cfg cfg = {
 220                 .input  = sock_diag_rcv,
 221         };
 222
 223         net->diag_nlsk = netlink_kernel_create(net, NETLINK_SOCK_DIAG, &cfg);
 224         return net->diag_nlsk == NULL ? -ENOMEM : 0;
 225 }
 226
 227 static void __net_exit diag_net_exit(struct net *net)
 228 {
 229         netlink_kernel_release(net->diag_nlsk);
 230         net->diag_nlsk = NULL;
 231 }
 232
 233 static struct pernet_operations diag_net_ops = {
 234         .init = diag_net_init,
 235         .exit = diag_net_exit,
 236 };
 237
 238 static int __init sock_diag_init(void)
 239 {
 240         return register_pernet_subsys(&diag_net_ops);
 241 }
 242
 243 static void __exit sock_diag_exit(void)
 244 {
 245         unregister_pernet_subsys(&diag_net_ops);
 246 }
 247
 248 module_init(sock_diag_init);
 249 module_exit(sock_diag_exit);
 250 MODULE_LICENSE("GPL");
 251 MODULE_ALIAS_NET_PF_PROTO(PF_NETLINK, NETLINK_SOCK_DIAG);