linux/net/unix/diag.c
<<
>>
Prefs
   1#include <linux/types.h>
   2#include <linux/spinlock.h>
   3#include <linux/sock_diag.h>
   4#include <linux/unix_diag.h>
   5#include <linux/skbuff.h>
   6#include <linux/module.h>
   7#include <net/netlink.h>
   8#include <net/af_unix.h>
   9#include <net/tcp_states.h>
  10
  11static int sk_diag_dump_name(struct sock *sk, struct sk_buff *nlskb)
  12{
  13        struct unix_address *addr = unix_sk(sk)->addr;
  14
  15        if (!addr)
  16                return 0;
  17
  18        return nla_put(nlskb, UNIX_DIAG_NAME, addr->len - sizeof(short),
  19                       addr->name->sun_path);
  20}
  21
  22static int sk_diag_dump_vfs(struct sock *sk, struct sk_buff *nlskb)
  23{
  24        struct dentry *dentry = unix_sk(sk)->path.dentry;
  25
  26        if (dentry) {
  27                struct unix_diag_vfs uv = {
  28                        .udiag_vfs_ino = dentry->d_inode->i_ino,
  29                        .udiag_vfs_dev = dentry->d_sb->s_dev,
  30                };
  31
  32                return nla_put(nlskb, UNIX_DIAG_VFS, sizeof(uv), &uv);
  33        }
  34
  35        return 0;
  36}
  37
  38static int sk_diag_dump_peer(struct sock *sk, struct sk_buff *nlskb)
  39{
  40        struct sock *peer;
  41        int ino;
  42
  43        peer = unix_peer_get(sk);
  44        if (peer) {
  45                unix_state_lock(peer);
  46                ino = sock_i_ino(peer);
  47                unix_state_unlock(peer);
  48                sock_put(peer);
  49
  50                return nla_put_u32(nlskb, UNIX_DIAG_PEER, ino);
  51        }
  52
  53        return 0;
  54}
  55
  56static int sk_diag_dump_icons(struct sock *sk, struct sk_buff *nlskb)
  57{
  58        struct sk_buff *skb;
  59        struct nlattr *attr;
  60        u32 *buf;
  61        int i;
  62
  63        if (sk->sk_state == TCP_LISTEN) {
  64                spin_lock(&sk->sk_receive_queue.lock);
  65
  66                attr = nla_reserve(nlskb, UNIX_DIAG_ICONS,
  67                                   sk->sk_receive_queue.qlen * sizeof(u32));
  68                if (!attr)
  69                        goto errout;
  70
  71                buf = nla_data(attr);
  72                i = 0;
  73                skb_queue_walk(&sk->sk_receive_queue, skb) {
  74                        struct sock *req, *peer;
  75
  76                        req = skb->sk;
  77                        /*
  78                         * The state lock is outer for the same sk's
  79                         * queue lock. With the other's queue locked it's
  80                         * OK to lock the state.
  81                         */
  82                        unix_state_lock_nested(req);
  83                        peer = unix_sk(req)->peer;
  84                        buf[i++] = (peer ? sock_i_ino(peer) : 0);
  85                        unix_state_unlock(req);
  86                }
  87                spin_unlock(&sk->sk_receive_queue.lock);
  88        }
  89
  90        return 0;
  91
  92errout:
  93        spin_unlock(&sk->sk_receive_queue.lock);
  94        return -EMSGSIZE;
  95}
  96
  97static int sk_diag_show_rqlen(struct sock *sk, struct sk_buff *nlskb)
  98{
  99        struct unix_diag_rqlen rql;
 100
 101        if (sk->sk_state == TCP_LISTEN) {
 102                rql.udiag_rqueue = sk->sk_receive_queue.qlen;
 103                rql.udiag_wqueue = sk->sk_max_ack_backlog;
 104        } else {
 105                rql.udiag_rqueue = (u32) unix_inq_len(sk);
 106                rql.udiag_wqueue = (u32) unix_outq_len(sk);
 107        }
 108
 109        return nla_put(nlskb, UNIX_DIAG_RQLEN, sizeof(rql), &rql);
 110}
 111
 112static int sk_diag_fill(struct sock *sk, struct sk_buff *skb, struct unix_diag_req *req,
 113                u32 portid, u32 seq, u32 flags, int sk_ino)
 114{
 115        struct nlmsghdr *nlh;
 116        struct unix_diag_msg *rep;
 117
 118        nlh = nlmsg_put(skb, portid, seq, SOCK_DIAG_BY_FAMILY, sizeof(*rep),
 119                        flags);
 120        if (!nlh)
 121                return -EMSGSIZE;
 122
 123        rep = nlmsg_data(nlh);
 124        rep->udiag_family = AF_UNIX;
 125        rep->udiag_type = sk->sk_type;
 126        rep->udiag_state = sk->sk_state;
 127        rep->udiag_ino = sk_ino;
 128        sock_diag_save_cookie(sk, rep->udiag_cookie);
 129
 130        if ((req->udiag_show & UDIAG_SHOW_NAME) &&
 131            sk_diag_dump_name(sk, skb))
 132                goto out_nlmsg_trim;
 133
 134        if ((req->udiag_show & UDIAG_SHOW_VFS) &&
 135            sk_diag_dump_vfs(sk, skb))
 136                goto out_nlmsg_trim;
 137
 138        if ((req->udiag_show & UDIAG_SHOW_PEER) &&
 139            sk_diag_dump_peer(sk, skb))
 140                goto out_nlmsg_trim;
 141
 142        if ((req->udiag_show & UDIAG_SHOW_ICONS) &&
 143            sk_diag_dump_icons(sk, skb))
 144                goto out_nlmsg_trim;
 145
 146        if ((req->udiag_show & UDIAG_SHOW_RQLEN) &&
 147            sk_diag_show_rqlen(sk, skb))
 148                goto out_nlmsg_trim;
 149
 150        if ((req->udiag_show & UDIAG_SHOW_MEMINFO) &&
 151            sock_diag_put_meminfo(sk, skb, UNIX_DIAG_MEMINFO))
 152                goto out_nlmsg_trim;
 153
 154        return nlmsg_end(skb, nlh);
 155
 156out_nlmsg_trim:
 157        nlmsg_cancel(skb, nlh);
 158        return -EMSGSIZE;
 159}
 160
 161static int sk_diag_dump(struct sock *sk, struct sk_buff *skb, struct unix_diag_req *req,
 162                u32 portid, u32 seq, u32 flags)
 163{
 164        int sk_ino;
 165
 166        unix_state_lock(sk);
 167        sk_ino = sock_i_ino(sk);
 168        unix_state_unlock(sk);
 169
 170        if (!sk_ino)
 171                return 0;
 172
 173        return sk_diag_fill(sk, skb, req, portid, seq, flags, sk_ino);
 174}
 175
 176static int unix_diag_dump(struct sk_buff *skb, struct netlink_callback *cb)
 177{
 178        struct unix_diag_req *req;
 179        int num, s_num, slot, s_slot;
 180        struct net *net = sock_net(skb->sk);
 181
 182        req = nlmsg_data(cb->nlh);
 183
 184        s_slot = cb->args[0];
 185        num = s_num = cb->args[1];
 186
 187        spin_lock(&unix_table_lock);
 188        for (slot = s_slot;
 189             slot < ARRAY_SIZE(unix_socket_table);
 190             s_num = 0, slot++) {
 191                struct sock *sk;
 192                struct hlist_node *node;
 193
 194                num = 0;
 195                sk_for_each(sk, node, &unix_socket_table[slot]) {
 196                        if (!net_eq(sock_net(sk), net))
 197                                continue;
 198                        if (num < s_num)
 199                                goto next;
 200                        if (!(req->udiag_states & (1 << sk->sk_state)))
 201                                goto next;
 202                        if (sk_diag_dump(sk, skb, req,
 203                                         NETLINK_CB(cb->skb).portid,
 204                                         cb->nlh->nlmsg_seq,
 205                                         NLM_F_MULTI) < 0)
 206                                goto done;
 207next:
 208                        num++;
 209                }
 210        }
 211done:
 212        spin_unlock(&unix_table_lock);
 213        cb->args[0] = slot;
 214        cb->args[1] = num;
 215
 216        return skb->len;
 217}
 218
 219static struct sock *unix_lookup_by_ino(int ino)
 220{
 221        int i;
 222        struct sock *sk;
 223
 224        spin_lock(&unix_table_lock);
 225        for (i = 0; i < ARRAY_SIZE(unix_socket_table); i++) {
 226                struct hlist_node *node;
 227
 228                sk_for_each(sk, node, &unix_socket_table[i])
 229                        if (ino == sock_i_ino(sk)) {
 230                                sock_hold(sk);
 231                                spin_unlock(&unix_table_lock);
 232
 233                                return sk;
 234                        }
 235        }
 236
 237        spin_unlock(&unix_table_lock);
 238        return NULL;
 239}
 240
 241static int unix_diag_get_exact(struct sk_buff *in_skb,
 242                               const struct nlmsghdr *nlh,
 243                               struct unix_diag_req *req)
 244{
 245        int err = -EINVAL;
 246        struct sock *sk;
 247        struct sk_buff *rep;
 248        unsigned int extra_len;
 249        struct net *net = sock_net(in_skb->sk);
 250
 251        if (req->udiag_ino == 0)
 252                goto out_nosk;
 253
 254        sk = unix_lookup_by_ino(req->udiag_ino);
 255        err = -ENOENT;
 256        if (sk == NULL)
 257                goto out_nosk;
 258
 259        err = sock_diag_check_cookie(sk, req->udiag_cookie);
 260        if (err)
 261                goto out;
 262
 263        extra_len = 256;
 264again:
 265        err = -ENOMEM;
 266        rep = nlmsg_new(sizeof(struct unix_diag_msg) + extra_len, GFP_KERNEL);
 267        if (!rep)
 268                goto out;
 269
 270        err = sk_diag_fill(sk, rep, req, NETLINK_CB(in_skb).portid,
 271                           nlh->nlmsg_seq, 0, req->udiag_ino);
 272        if (err < 0) {
 273                nlmsg_free(rep);
 274                extra_len += 256;
 275                if (extra_len >= PAGE_SIZE)
 276                        goto out;
 277
 278                goto again;
 279        }
 280        err = netlink_unicast(net->diag_nlsk, rep, NETLINK_CB(in_skb).portid,
 281                              MSG_DONTWAIT);
 282        if (err > 0)
 283                err = 0;
 284out:
 285        if (sk)
 286                sock_put(sk);
 287out_nosk:
 288        return err;
 289}
 290
 291static int unix_diag_handler_dump(struct sk_buff *skb, struct nlmsghdr *h)
 292{
 293        int hdrlen = sizeof(struct unix_diag_req);
 294        struct net *net = sock_net(skb->sk);
 295
 296        if (nlmsg_len(h) < hdrlen)
 297                return -EINVAL;
 298
 299        if (h->nlmsg_flags & NLM_F_DUMP) {
 300                struct netlink_dump_control c = {
 301                        .dump = unix_diag_dump,
 302                };
 303                return netlink_dump_start(net->diag_nlsk, skb, h, &c);
 304        } else
 305                return unix_diag_get_exact(skb, h, nlmsg_data(h));
 306}
 307
 308static const struct sock_diag_handler unix_diag_handler = {
 309        .family = AF_UNIX,
 310        .dump = unix_diag_handler_dump,
 311};
 312
 313static int __init unix_diag_init(void)
 314{
 315        return sock_diag_register(&unix_diag_handler);
 316}
 317
 318static void __exit unix_diag_exit(void)
 319{
 320        sock_diag_unregister(&unix_diag_handler);
 321}
 322
 323module_init(unix_diag_init);
 324module_exit(unix_diag_exit);
 325MODULE_LICENSE("GPL");
 326MODULE_ALIAS_NET_PF_PROTO_TYPE(PF_NETLINK, NETLINK_SOCK_DIAG, 1 /* AF_LOCAL */);
 327
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.