net/unix/af_unix.c

   1 /*
   2  * NET4:        Implementation of BSD Unix domain sockets.
   3  *
   4  * Authors:     Alan Cox, <alan@lxorguk.ukuu.org.uk>
   5  *
   6  *              This program is free software; you can redistribute it and/or
   7  *              modify it under the terms of the GNU General Public License
   8  *              as published by the Free Software Foundation; either version
   9  *              2 of the License, or (at your option) any later version.
  10  *
  11  * Fixes:
  12  *              Linus Torvalds  :       Assorted bug cures.
  13  *              Niibe Yutaka    :       async I/O support.
  14  *              Carsten Paeth   :       PF_UNIX check, address fixes.
  15  *              Alan Cox        :       Limit size of allocated blocks.
  16  *              Alan Cox        :       Fixed the stupid socketpair bug.
  17  *              Alan Cox        :       BSD compatibility fine tuning.
  18  *              Alan Cox        :       Fixed a bug in connect when interrupted.
  19  *              Alan Cox        :       Sorted out a proper draft version of
  20  *                                      file descriptor passing hacked up from
  21  *                                      Mike Shaver's work.
  22  *              Marty Leisner   :       Fixes to fd passing
  23  *              Nick Nevin      :       recvmsg bugfix.
  24  *              Alan Cox        :       Started proper garbage collector
  25  *              Heiko EiBfeldt  :       Missing verify_area check
  26  *              Alan Cox        :       Started POSIXisms
  27  *              Andreas Schwab  :       Replace inode by dentry for proper
  28  *                                      reference counting
  29  *              Kirk Petersen   :       Made this a module
  30  *          Christoph Rohland   :       Elegant non-blocking accept/connect algorithm.
  31  *                                      Lots of bug fixes.
  32  *           Alexey Kuznetosv   :       Repaired (I hope) bugs introduces
  33  *                                      by above two patches.
  34  *           Andrea Arcangeli   :       If possible we block in connect(2)
  35  *                                      if the max backlog of the listen socket
  36  *                                      is been reached. This won't break
  37  *                                      old apps and it will avoid huge amount
  38  *                                      of socks hashed (this for unix_gc()
  39  *                                      performances reasons).
  40  *                                      Security fix that limits the max
  41  *                                      number of socks to 2*max_files and
  42  *                                      the number of skb queueable in the
  43  *                                      dgram receiver.
  44  *              Artur Skawina   :       Hash function optimizations
  45  *           Alexey Kuznetsov   :       Full scale SMP. Lot of bugs are introduced 8)
  46  *            Malcolm Beattie   :       Set peercred for socketpair
  47  *           Michal Ostrowski   :       Module initialization cleanup.
  48  *           Arnaldo C. Melo    :       Remove MOD_{INC,DEC}_USE_COUNT,
  49  *                                      the core infrastructure is doing that
  50  *                                      for all net proto families now (2.5.69+)
  51  *
  52  *
  53  * Known differences from reference BSD that was tested:
  54  *
  55  *      [TO FIX]
  56  *      ECONNREFUSED is not returned from one end of a connected() socket to the
  57  *              other the moment one end closes.
  58  *      fstat() doesn't return st_dev=0, and give the blksize as high water mark
  59  *              and a fake inode identifier (nor the BSD first socket fstat twice bug).
  60  *      [NOT TO FIX]
  61  *      accept() returns a path name even if the connecting socket has closed
  62  *              in the meantime (BSD loses the path and gives up).
  63  *      accept() returns 0 length path for an unbound connector. BSD returns 16
  64  *              and a null first byte in the path (but not for gethost/peername - BSD bug ??)
  65  *      socketpair(...SOCK_RAW..) doesn't panic the kernel.
  66  *      BSD af_unix apparently has connect forgetting to block properly.
  67  *              (need to check this with the POSIX spec in detail)
  68  *
  69  * Differences from 2.0.0-11-... (ANK)
  70  *      Bug fixes and improvements.
  71  *              - client shutdown killed server socket.
  72  *              - removed all useless cli/sti pairs.
  73  *
  74  *      Semantic changes/extensions.
  75  *              - generic control message passing.
  76  *              - SCM_CREDENTIALS control message.
  77  *              - "Abstract" (not FS based) socket bindings.
  78  *                Abstract names are sequences of bytes (not zero terminated)
  79  *                started by 0, so that this name space does not intersect
  80  *                with BSD names.
  81  */
  82
  83 #include <linux/module.h>
  84 #include <linux/kernel.h>
  85 #include <linux/signal.h>
  86 #include <linux/sched.h>
  87 #include <linux/errno.h>
  88 #include <linux/string.h>
  89 #include <linux/stat.h>
  90 #include <linux/dcache.h>
  91 #include <linux/namei.h>
  92 #include <linux/socket.h>
  93 #include <linux/un.h>
  94 #include <linux/fcntl.h>
  95 #include <linux/termios.h>
  96 #include <linux/sockios.h>
  97 #include <linux/net.h>
  98 #include <linux/in.h>
  99 #include <linux/fs.h>
 100 #include <linux/slab.h>
 101 #include <asm/uaccess.h>
 102 #include <linux/skbuff.h>
 103 #include <linux/netdevice.h>
 104 #include <net/net_namespace.h>
 105 #include <net/sock.h>
 106 #include <net/tcp_states.h>
 107 #include <net/af_unix.h>
 108 #include <linux/proc_fs.h>
 109 #include <linux/seq_file.h>
 110 #include <net/scm.h>
 111 #include <linux/init.h>
 112 #include <linux/poll.h>
 113 #include <linux/rtnetlink.h>
 114 #include <linux/mount.h>
 115 #include <net/checksum.h>
 116 #include <linux/security.h>
 117
 118 struct hlist_head unix_socket_table[2 * UNIX_HASH_SIZE];
 119 EXPORT_SYMBOL_GPL(unix_socket_table);
 120 DEFINE_SPINLOCK(unix_table_lock);
 121 EXPORT_SYMBOL_GPL(unix_table_lock);
 122 static atomic_long_t unix_nr_socks;
 123
 124
 125 static struct hlist_head *unix_sockets_unbound(void *addr)
 126 {
 127         unsigned long hash = (unsigned long)addr;
 128
 129         hash ^= hash >> 16;
 130         hash ^= hash >> 8;
 131         hash %= UNIX_HASH_SIZE;
 132         return &unix_socket_table[UNIX_HASH_SIZE + hash];
 133 }
 134
 135 #define UNIX_ABSTRACT(sk)       (unix_sk(sk)->addr->hash < UNIX_HASH_SIZE)
 136
 137 #ifdef CONFIG_SECURITY_NETWORK
 138 static void unix_get_secdata(struct scm_cookie *scm, struct sk_buff *skb)
 139 {
 140         memcpy(UNIXSID(skb), &scm->secid, sizeof(u32));
 141 }
 142
 143 static inline void unix_set_secdata(struct scm_cookie *scm, struct sk_buff *skb)
 144 {
 145         scm->secid = *UNIXSID(skb);
 146 }
 147 #else
 148 static inline void unix_get_secdata(struct scm_cookie *scm, struct sk_buff *skb)
 149 { }
 150
 151 static inline void unix_set_secdata(struct scm_cookie *scm, struct sk_buff *skb)
 152 { }
 153 #endif /* CONFIG_SECURITY_NETWORK */
 154
 155 /*
 156  *  SMP locking strategy:
 157  *    hash table is protected with spinlock unix_table_lock
 158  *    each socket state is protected by separate spin lock.
 159  */
 160
 161 static inline unsigned int unix_hash_fold(__wsum n)
 162 {
 163         unsigned int hash = (__force unsigned int)n;
 164
 165         hash ^= hash>>16;
 166         hash ^= hash>>8;
 167         return hash&(UNIX_HASH_SIZE-1);
 168 }
 169
 170 #define unix_peer(sk) (unix_sk(sk)->peer)
 171
 172 static inline int unix_our_peer(struct sock *sk, struct sock *osk)
 173 {
 174         return unix_peer(osk) == sk;
 175 }
 176
 177 static inline int unix_may_send(struct sock *sk, struct sock *osk)
 178 {
 179         return unix_peer(osk) == NULL || unix_our_peer(sk, osk);
 180 }
 181
 182 static inline int unix_recvq_full(struct sock const *sk)
 183 {
 184         return skb_queue_len(&sk->sk_receive_queue) > sk->sk_max_ack_backlog;
 185 }
 186
 187 struct sock *unix_peer_get(struct sock *s)
 188 {
 189         struct sock *peer;
 190
 191         unix_state_lock(s);
 192         peer = unix_peer(s);
 193         if (peer)
 194                 sock_hold(peer);
 195         unix_state_unlock(s);
 196         return peer;
 197 }
 198 EXPORT_SYMBOL_GPL(unix_peer_get);
 199
 200 static inline void unix_release_addr(struct unix_address *addr)
 201 {
 202         if (atomic_dec_and_test(&addr->refcnt))
 203                 kfree(addr);
 204 }
 205
 206 /*
 207  *      Check unix socket name:
 208  *              - should be not zero length.
 209  *              - if started by not zero, should be NULL terminated (FS object)
 210  *              - if started by zero, it is abstract name.
 211  */
 212
 213 static int unix_mkname(struct sockaddr_un *sunaddr, int len, unsigned int *hashp)
 214 {
 215         if (len <= sizeof(short) || len > sizeof(*sunaddr))
 216                 return -EINVAL;
 217         if (!sunaddr || sunaddr->sun_family != AF_UNIX)
 218                 return -EINVAL;
 219         if (sunaddr->sun_path[0]) {
 220                 /*
 221                  * This may look like an off by one error but it is a bit more
 222                  * subtle. 108 is the longest valid AF_UNIX path for a binding.
 223                  * sun_path[108] doesn't as such exist.  However in kernel space
 224                  * we are guaranteed that it is a valid memory location in our
 225                  * kernel address buffer.
 226                  */
 227                 ((char *)sunaddr)[len] = 0;
 228                 len = strlen(sunaddr->sun_path)+1+sizeof(short);
 229                 return len;
 230         }
 231
 232         *hashp = unix_hash_fold(csum_partial(sunaddr, len, 0));
 233         return len;
 234 }
 235
 236 static void __unix_remove_socket(struct sock *sk)
 237 {
 238         sk_del_node_init(sk);
 239 }
 240
 241 static void __unix_insert_socket(struct hlist_head *list, struct sock *sk)
 242 {
 243         WARN_ON(!sk_unhashed(sk));
 244         sk_add_node(sk, list);
 245 }
 246
 247 static inline void unix_remove_socket(struct sock *sk)
 248 {
 249         spin_lock(&unix_table_lock);
 250         __unix_remove_socket(sk);
 251         spin_unlock(&unix_table_lock);
 252 }
 253
 254 static inline void unix_insert_socket(struct hlist_head *list, struct sock *sk)
 255 {
 256         spin_lock(&unix_table_lock);
 257         __unix_insert_socket(list, sk);
 258         spin_unlock(&unix_table_lock);
 259 }
 260
 261 static struct sock *__unix_find_socket_byname(struct net *net,
 262                                               struct sockaddr_un *sunname,
 263                                               int len, int type, unsigned int hash)
 264 {
 265         struct sock *s;
 266         struct hlist_node *node;
 267
 268         sk_for_each(s, node, &unix_socket_table[hash ^ type]) {
 269                 struct unix_sock *u = unix_sk(s);
 270
 271                 if (!net_eq(sock_net(s), net))
 272                         continue;
 273
 274                 if (u->addr->len == len &&
 275                     !memcmp(u->addr->name, sunname, len))
 276                         goto found;
 277         }
 278         s = NULL;
 279 found:
 280         return s;
 281 }
 282
 283 static inline struct sock *unix_find_socket_byname(struct net *net,
 284                                                    struct sockaddr_un *sunname,
 285                                                    int len, int type,
 286                                                    unsigned int hash)
 287 {
 288         struct sock *s;
 289
 290         spin_lock(&unix_table_lock);
 291         s = __unix_find_socket_byname(net, sunname, len, type, hash);
 292         if (s)
 293                 sock_hold(s);
 294         spin_unlock(&unix_table_lock);
 295         return s;
 296 }
 297
 298 static struct sock *unix_find_socket_byinode(struct inode *i)
 299 {
 300         struct sock *s;
 301         struct hlist_node *node;
 302
 303         spin_lock(&unix_table_lock);
 304         sk_for_each(s, node,
 305                     &unix_socket_table[i->i_ino & (UNIX_HASH_SIZE - 1)]) {
 306                 struct dentry *dentry = unix_sk(s)->path.dentry;
 307
 308                 if (dentry && dentry->d_inode == i) {
 309                         sock_hold(s);
 310                         goto found;
 311                 }
 312         }
 313         s = NULL;
 314 found:
 315         spin_unlock(&unix_table_lock);
 316         return s;
 317 }
 318
 319 static inline int unix_writable(struct sock *sk)
 320 {
 321         return (atomic_read(&sk->sk_wmem_alloc) << 2) <= sk->sk_sndbuf;
 322 }
 323
 324 static void unix_write_space(struct sock *sk)
 325 {
 326         struct socket_wq *wq;
 327
 328         rcu_read_lock();
 329         if (unix_writable(sk)) {
 330                 wq = rcu_dereference(sk->sk_wq);
 331                 if (wq_has_sleeper(wq))
 332                         wake_up_interruptible_sync_poll(&wq->wait,
 333                                 POLLOUT | POLLWRNORM | POLLWRBAND);
 334                 sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
 335         }
 336         rcu_read_unlock();
 337 }
 338
 339 /* When dgram socket disconnects (or changes its peer), we clear its receive
 340  * queue of packets arrived from previous peer. First, it allows to do
 341  * flow control based only on wmem_alloc; second, sk connected to peer
 342  * may receive messages only from that peer. */
 343 static void unix_dgram_disconnected(struct sock *sk, struct sock *other)
 344 {
 345         if (!skb_queue_empty(&sk->sk_receive_queue)) {
 346                 skb_queue_purge(&sk->sk_receive_queue);
 347                 wake_up_interruptible_all(&unix_sk(sk)->peer_wait);
 348
 349                 /* If one link of bidirectional dgram pipe is disconnected,
 350                  * we signal error. Messages are lost. Do not make this,
 351                  * when peer was not connected to us.
 352                  */
 353                 if (!sock_flag(other, SOCK_DEAD) && unix_peer(other) == sk) {
 354                         other->sk_err = ECONNRESET;
 355                         other->sk_error_report(other);
 356                 }
 357         }
 358 }
 359
 360 static void unix_sock_destructor(struct sock *sk)
 361 {
 362         struct unix_sock *u = unix_sk(sk);
 363
 364         skb_queue_purge(&sk->sk_receive_queue);
 365
 366         WARN_ON(atomic_read(&sk->sk_wmem_alloc));
 367         WARN_ON(!sk_unhashed(sk));
 368         WARN_ON(sk->sk_socket);
 369         if (!sock_flag(sk, SOCK_DEAD)) {
 370                 printk(KERN_INFO "Attempt to release alive unix socket: %p\n", sk);
 371                 return;
 372         }
 373
 374         if (u->addr)
 375                 unix_release_addr(u->addr);
 376
 377         atomic_long_dec(&unix_nr_socks);
 378         local_bh_disable();
 379         sock_prot_inuse_add(sock_net(sk), sk->sk_prot, -1);
 380         local_bh_enable();
 381 #ifdef UNIX_REFCNT_DEBUG
 382         printk(KERN_DEBUG "UNIX %p is destroyed, %ld are still alive.\n", sk,
 383                 atomic_long_read(&unix_nr_socks));
 384 #endif
 385 }
 386
 387 static int unix_release_sock(struct sock *sk, int embrion)
 388 {
 389         struct unix_sock *u = unix_sk(sk);
 390         struct path path;
 391         struct sock *skpair;
 392         struct sk_buff *skb;
 393         int state;
 394
 395         unix_remove_socket(sk);
 396
 397         /* Clear state */
 398         unix_state_lock(sk);
 399         sock_orphan(sk);
 400         sk->sk_shutdown = SHUTDOWN_MASK;
 401         path         = u->path;
 402         u->path.dentry = NULL;
 403         u->path.mnt = NULL;
 404         state = sk->sk_state;
 405         sk->sk_state = TCP_CLOSE;
 406         unix_state_unlock(sk);
 407
 408         wake_up_interruptible_all(&u->peer_wait);
 409
 410         skpair = unix_peer(sk);
 411
 412         if (skpair != NULL) {
 413                 if (sk->sk_type == SOCK_STREAM || sk->sk_type == SOCK_SEQPACKET) {
 414                         unix_state_lock(skpair);
 415                         /* No more writes */
 416                         skpair->sk_shutdown = SHUTDOWN_MASK;
 417                         if (!skb_queue_empty(&sk->sk_receive_queue) || embrion)
 418                                 skpair->sk_err = ECONNRESET;
 419                         unix_state_unlock(skpair);
 420                         skpair->sk_state_change(skpair);
 421                         sk_wake_async(skpair, SOCK_WAKE_WAITD, POLL_HUP);
 422                 }
 423                 sock_put(skpair); /* It may now die */
 424                 unix_peer(sk) = NULL;
 425         }
 426
 427         /* Try to flush out this socket. Throw out buffers at least */
 428
 429         while ((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL) {
 430                 if (state == TCP_LISTEN)
 431                         unix_release_sock(skb->sk, 1);
 432                 /* passed fds are erased in the kfree_skb hook        */
 433                 kfree_skb(skb);
 434         }
 435
 436         if (path.dentry)
 437                 path_put(&path);
 438
 439         sock_put(sk);
 440
 441         /* ---- Socket is dead now and most probably destroyed ---- */
 442
 443         /*
 444          * Fixme: BSD difference: In BSD all sockets connected to use get
 445          *        ECONNRESET and we die on the spot. In Linux we behave
 446          *        like files and pipes do and wait for the last
 447          *        dereference.
 448          *
 449          * Can't we simply set sock->err?
 450          *
 451          *        What the above comment does talk about? --ANK(980817)
 452          */
 453
 454         if (unix_tot_inflight)
 455                 unix_gc();              /* Garbage collect fds */
 456
 457         return 0;
 458 }
 459
 460 static void init_peercred(struct sock *sk)
 461 {
 462         put_pid(sk->sk_peer_pid);
 463         if (sk->sk_peer_cred)
 464                 put_cred(sk->sk_peer_cred);
 465         sk->sk_peer_pid  = get_pid(task_tgid(current));
 466         sk->sk_peer_cred = get_current_cred();
 467 }
 468
 469 static void copy_peercred(struct sock *sk, struct sock *peersk)
 470 {
 471         put_pid(sk->sk_peer_pid);
 472         if (sk->sk_peer_cred)
 473                 put_cred(sk->sk_peer_cred);
 474         sk->sk_peer_pid  = get_pid(peersk->sk_peer_pid);
 475         sk->sk_peer_cred = get_cred(peersk->sk_peer_cred);
 476 }
 477
 478 static int unix_listen(struct socket *sock, int backlog)
 479 {
 480         int err;
 481         struct sock *sk = sock->sk;
 482         struct unix_sock *u = unix_sk(sk);
 483         struct pid *old_pid = NULL;
 484         const struct cred *old_cred = NULL;
 485
 486         err = -EOPNOTSUPP;
 487         if (sock->type != SOCK_STREAM && sock->type != SOCK_SEQPACKET)
 488                 goto out;       /* Only stream/seqpacket sockets accept */
 489         err = -EINVAL;
 490         if (!u->addr)
 491                 goto out;       /* No listens on an unbound socket */
 492         unix_state_lock(sk);
 493         if (sk->sk_state != TCP_CLOSE && sk->sk_state != TCP_LISTEN)
 494                 goto out_unlock;
 495         if (backlog > sk->sk_max_ack_backlog)
 496                 wake_up_interruptible_all(&u->peer_wait);
 497         sk->sk_max_ack_backlog  = backlog;
 498         sk->sk_state            = TCP_LISTEN;
 499         /* set credentials so connect can copy them */
 500         init_peercred(sk);
 501         err = 0;
 502
 503 out_unlock:
 504         unix_state_unlock(sk);
 505         put_pid(old_pid);
 506         if (old_cred)
 507                 put_cred(old_cred);
 508 out:
 509         return err;
 510 }
 511
 512 static int unix_release(struct socket *);
 513 static int unix_bind(struct socket *, struct sockaddr *, int);
 514 static int unix_stream_connect(struct socket *, struct sockaddr *,
 515                                int addr_len, int flags);
 516 static int unix_socketpair(struct socket *, struct socket *);
 517 static int unix_accept(struct socket *, struct socket *, int);
 518 static int unix_getname(struct socket *, struct sockaddr *, int *, int);
 519 static unsigned int unix_poll(struct file *, struct socket *, poll_table *);
 520 static unsigned int unix_dgram_poll(struct file *, struct socket *,
 521                                     poll_table *);
 522 static int unix_ioctl(struct socket *, unsigned int, unsigned long);
 523 static int unix_shutdown(struct socket *, int);
 524 static int unix_stream_sendmsg(struct kiocb *, struct socket *,
 525                                struct msghdr *, size_t);
 526 static int unix_stream_recvmsg(struct kiocb *, struct socket *,
 527                                struct msghdr *, size_t, int);
 528 static int unix_dgram_sendmsg(struct kiocb *, struct socket *,
 529                               struct msghdr *, size_t);
 530 static int unix_dgram_recvmsg(struct kiocb *, struct socket *,
 531                               struct msghdr *, size_t, int);
 532 static int unix_dgram_connect(struct socket *, struct sockaddr *,
 533                               int, int);
 534 static int unix_seqpacket_sendmsg(struct kiocb *, struct socket *,
 535                                   struct msghdr *, size_t);
 536 static int unix_seqpacket_recvmsg(struct kiocb *, struct socket *,
 537                                   struct msghdr *, size_t, int);
 538
 539 static void unix_set_peek_off(struct sock *sk, int val)
 540 {
 541         struct unix_sock *u = unix_sk(sk);
 542
 543         mutex_lock(&u->readlock);
 544         sk->sk_peek_off = val;
 545         mutex_unlock(&u->readlock);
 546 }
 547
 548
 549 static const struct proto_ops unix_stream_ops = {
 550         .family =       PF_UNIX,
 551         .owner =        THIS_MODULE,
 552         .release =      unix_release,
 553         .bind =         unix_bind,
 554         .connect =      unix_stream_connect,
 555         .socketpair =   unix_socketpair,
 556         .accept =       unix_accept,
 557         .getname =      unix_getname,
 558         .poll =         unix_poll,
 559         .ioctl =        unix_ioctl,
 560         .listen =       unix_listen,
 561         .shutdown =     unix_shutdown,
 562         .setsockopt =   sock_no_setsockopt,
 563         .getsockopt =   sock_no_getsockopt,
 564         .sendmsg =      unix_stream_sendmsg,
 565         .recvmsg =      unix_stream_recvmsg,
 566         .mmap =         sock_no_mmap,
 567         .sendpage =     sock_no_sendpage,
 568         .set_peek_off = unix_set_peek_off,
 569 };
 570
 571 static const struct proto_ops unix_dgram_ops = {
 572         .family =       PF_UNIX,
 573         .owner =        THIS_MODULE,
 574         .release =      unix_release,
 575         .bind =         unix_bind,
 576         .connect =      unix_dgram_connect,
 577         .socketpair =   unix_socketpair,
 578         .accept =       sock_no_accept,
 579         .getname =      unix_getname,
 580         .poll =         unix_dgram_poll,
 581         .ioctl =        unix_ioctl,
 582         .listen =       sock_no_listen,
 583         .shutdown =     unix_shutdown,
 584         .setsockopt =   sock_no_setsockopt,
 585         .getsockopt =   sock_no_getsockopt,
 586         .sendmsg =      unix_dgram_sendmsg,
 587         .recvmsg =      unix_dgram_recvmsg,
 588         .mmap =         sock_no_mmap,
 589         .sendpage =     sock_no_sendpage,
 590         .set_peek_off = unix_set_peek_off,
 591 };
 592
 593 static const struct proto_ops unix_seqpacket_ops = {
 594         .family =       PF_UNIX,
 595         .owner =        THIS_MODULE,
 596         .release =      unix_release,
 597         .bind =         unix_bind,
 598         .connect =      unix_stream_connect,
 599         .socketpair =   unix_socketpair,
 600         .accept =       unix_accept,
 601         .getname =      unix_getname,
 602         .poll =         unix_dgram_poll,
 603         .ioctl =        unix_ioctl,
 604         .listen =       unix_listen,
 605         .shutdown =     unix_shutdown,
 606         .setsockopt =   sock_no_setsockopt,
 607         .getsockopt =   sock_no_getsockopt,
 608         .sendmsg =      unix_seqpacket_sendmsg,
 609         .recvmsg =      unix_seqpacket_recvmsg,
 610         .mmap =         sock_no_mmap,
 611         .sendpage =     sock_no_sendpage,
 612         .set_peek_off = unix_set_peek_off,
 613 };
 614
 615 static struct proto unix_proto = {
 616         .name                   = "UNIX",
 617         .owner                  = THIS_MODULE,
 618         .obj_size               = sizeof(struct unix_sock),
 619 };
 620
 621 /*
 622  * AF_UNIX sockets do not interact with hardware, hence they
 623  * dont trigger interrupts - so it's safe for them to have
 624  * bh-unsafe locking for their sk_receive_queue.lock. Split off
 625  * this special lock-class by reinitializing the spinlock key:
 626  */
 627 static struct lock_class_key af_unix_sk_receive_queue_lock_key;
 628
 629 static struct sock *unix_create1(struct net *net, struct socket *sock)
 630 {
 631         struct sock *sk = NULL;
 632         struct unix_sock *u;
 633
 634         atomic_long_inc(&unix_nr_socks);
 635         if (atomic_long_read(&unix_nr_socks) > 2 * get_max_files())
 636                 goto out;
 637
 638         sk = sk_alloc(net, PF_UNIX, GFP_KERNEL, &unix_proto);
 639         if (!sk)
 640                 goto out;
 641
 642         sock_init_data(sock, sk);
 643         lockdep_set_class(&sk->sk_receive_queue.lock,
 644                                 &af_unix_sk_receive_queue_lock_key);
 645
 646         sk->sk_write_space      = unix_write_space;
 647         sk->sk_max_ack_backlog  = net->unx.sysctl_max_dgram_qlen;
 648         sk->sk_destruct         = unix_sock_destructor;
 649         u         = unix_sk(sk);
 650         u->path.dentry = NULL;
 651         u->path.mnt = NULL;
 652         spin_lock_init(&u->lock);
 653         atomic_long_set(&u->inflight, 0);
 654         INIT_LIST_HEAD(&u->link);
 655         mutex_init(&u->readlock); /* single task reading lock */
 656         init_waitqueue_head(&u->peer_wait);
 657         unix_insert_socket(unix_sockets_unbound(sk), sk);
 658 out:
 659         if (sk == NULL)
 660                 atomic_long_dec(&unix_nr_socks);
 661         else {
 662                 local_bh_disable();
 663                 sock_prot_inuse_add(sock_net(sk), sk->sk_prot, 1);
 664                 local_bh_enable();
 665         }
 666         return sk;
 667 }
 668
 669 static int unix_create(struct net *net, struct socket *sock, int protocol,
 670                        int kern)
 671 {
 672         if (protocol && protocol != PF_UNIX)
 673                 return -EPROTONOSUPPORT;
 674
 675         sock->state = SS_UNCONNECTED;
 676
 677         switch (sock->type) {
 678         case SOCK_STREAM:
 679                 sock->ops = &unix_stream_ops;
 680                 break;
 681                 /*
 682                  *      Believe it or not BSD has AF_UNIX, SOCK_RAW though
 683                  *      nothing uses it.
 684                  */
 685         case SOCK_RAW:
 686                 sock->type = SOCK_DGRAM;
 687         case SOCK_DGRAM:
 688                 sock->ops = &unix_dgram_ops;
 689                 break;
 690         case SOCK_SEQPACKET:
 691                 sock->ops = &unix_seqpacket_ops;
 692                 break;
 693         default:
 694                 return -ESOCKTNOSUPPORT;
 695         }
 696
 697         return unix_create1(net, sock) ? 0 : -ENOMEM;
 698 }
 699
 700 static int unix_release(struct socket *sock)
 701 {
 702         struct sock *sk = sock->sk;
 703
 704         if (!sk)
 705                 return 0;
 706
 707         sock->sk = NULL;
 708
 709         return unix_release_sock(sk, 0);
 710 }
 711
 712 static int unix_autobind(struct socket *sock)
 713 {
 714         struct sock *sk = sock->sk;
 715         struct net *net = sock_net(sk);
 716         struct unix_sock *u = unix_sk(sk);
 717         static u32 ordernum = 1;
 718         struct unix_address *addr;
 719         int err;
 720         unsigned int retries = 0;
 721
 722         mutex_lock(&u->readlock);
 723
 724         err = 0;
 725         if (u->addr)
 726                 goto out;
 727
 728         err = -ENOMEM;
 729         addr = kzalloc(sizeof(*addr) + sizeof(short) + 16, GFP_KERNEL);
 730         if (!addr)
 731                 goto out;
 732
 733         addr->name->sun_family = AF_UNIX;
 734         atomic_set(&addr->refcnt, 1);
 735
 736 retry:
 737         addr->len = sprintf(addr->name->sun_path+1, "%05x", ordernum) + 1 + sizeof(short);
 738         addr->hash = unix_hash_fold(csum_partial(addr->name, addr->len, 0));
 739
 740         spin_lock(&unix_table_lock);
 741         ordernum = (ordernum+1)&0xFFFFF;
 742
 743         if (__unix_find_socket_byname(net, addr->name, addr->len, sock->type,
 744                                       addr->hash)) {
 745                 spin_unlock(&unix_table_lock);
 746                 /*
 747                  * __unix_find_socket_byname() may take long time if many names
 748                  * are already in use.
 749                  */
 750                 cond_resched();
 751                 /* Give up if all names seems to be in use. */
 752                 if (retries++ == 0xFFFFF) {
 753                         err = -ENOSPC;
 754                         kfree(addr);
 755                         goto out;
 756                 }
 757                 goto retry;
 758         }
 759         addr->hash ^= sk->sk_type;
 760
 761         __unix_remove_socket(sk);
 762         u->addr = addr;
 763         __unix_insert_socket(&unix_socket_table[addr->hash], sk);
 764         spin_unlock(&unix_table_lock);
 765         err = 0;
 766
 767 out:    mutex_unlock(&u->readlock);
 768         return err;
 769 }
 770
 771 static struct sock *unix_find_other(struct net *net,
 772                                     struct sockaddr_un *sunname, int len,
 773                                     int type, unsigned int hash, int *error)
 774 {
 775         struct sock *u;
 776         struct path path;
 777         int err = 0;
 778
 779         if (sunname->sun_path[0]) {
 780                 struct inode *inode;
 781                 err = kern_path(sunname->sun_path, LOOKUP_FOLLOW, &path);
 782                 if (err)
 783                         goto fail;
 784                 inode = path.dentry->d_inode;
 785                 err = inode_permission(inode, MAY_WRITE);
 786                 if (err)
 787                         goto put_fail;
 788
 789                 err = -ECONNREFUSED;
 790                 if (!S_ISSOCK(inode->i_mode))
 791                         goto put_fail;
 792                 u = unix_find_socket_byinode(inode);
 793                 if (!u)
 794                         goto put_fail;
 795
 796                 if (u->sk_type == type)
 797                         touch_atime(&path);
 798
 799                 path_put(&path);
 800
 801                 err = -EPROTOTYPE;
 802                 if (u->sk_type != type) {
 803                         sock_put(u);
 804                         goto fail;
 805                 }
 806         } else {
 807                 err = -ECONNREFUSED;
 808                 u = unix_find_socket_byname(net, sunname, len, type, hash);
 809                 if (u) {
 810                         struct dentry *dentry;
 811                         dentry = unix_sk(u)->path.dentry;
 812                         if (dentry)
 813                                 touch_atime(&unix_sk(u)->path);
 814                 } else
 815                         goto fail;
 816         }
 817         return u;
 818
 819 put_fail:
 820         path_put(&path);
 821 fail:
 822         *error = err;
 823         return NULL;
 824 }
 825
 826
 827 static int unix_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
 828 {
 829         struct sock *sk = sock->sk;
 830         struct net *net = sock_net(sk);
 831         struct unix_sock *u = unix_sk(sk);
 832         struct sockaddr_un *sunaddr = (struct sockaddr_un *)uaddr;
 833         char *sun_path = sunaddr->sun_path;
 834         struct dentry *dentry = NULL;
 835         struct path path;
 836         int err;
 837         unsigned int hash;
 838         struct unix_address *addr;
 839         struct hlist_head *list;
 840
 841         err = -EINVAL;
 842         if (sunaddr->sun_family != AF_UNIX)
 843                 goto out;
 844
 845         if (addr_len == sizeof(short)) {
 846                 err = unix_autobind(sock);
 847                 goto out;
 848         }
 849
 850         err = unix_mkname(sunaddr, addr_len, &hash);
 851         if (err < 0)
 852                 goto out;
 853         addr_len = err;
 854
 855         mutex_lock(&u->readlock);
 856
 857         err = -EINVAL;
 858         if (u->addr)
 859                 goto out_up;
 860
 861         err = -ENOMEM;
 862         addr = kmalloc(sizeof(*addr)+addr_len, GFP_KERNEL);
 863         if (!addr)
 864                 goto out_up;
 865
 866         memcpy(addr->name, sunaddr, addr_len);
 867         addr->len = addr_len;
 868         addr->hash = hash ^ sk->sk_type;
 869         atomic_set(&addr->refcnt, 1);
 870
 871         if (sun_path[0]) {
 872                 umode_t mode;
 873                 err = 0;
 874                 /*
 875                  * Get the parent directory, calculate the hash for last
 876                  * component.
 877                  */
 878                 dentry = kern_path_create(AT_FDCWD, sun_path, &path, 0);
 879                 err = PTR_ERR(dentry);
 880                 if (IS_ERR(dentry))
 881                         goto out_mknod_parent;
 882
 883                 /*
 884                  * All right, let's create it.
 885                  */
 886                 mode = S_IFSOCK |
 887                        (SOCK_INODE(sock)->i_mode & ~current_umask());
 888                 err = mnt_want_write(path.mnt);
 889                 if (err)
 890                         goto out_mknod_dput;
 891                 err = security_path_mknod(&path, dentry, mode, 0);
 892                 if (err)
 893                         goto out_mknod_drop_write;
 894                 err = vfs_mknod(path.dentry->d_inode, dentry, mode, 0);
 895 out_mknod_drop_write:
 896                 mnt_drop_write(path.mnt);
 897                 if (err)
 898                         goto out_mknod_dput;
 899                 mutex_unlock(&path.dentry->d_inode->i_mutex);
 900                 dput(path.dentry);
 901                 path.dentry = dentry;
 902
 903                 addr->hash = UNIX_HASH_SIZE;
 904         }
 905
 906         spin_lock(&unix_table_lock);
 907
 908         if (!sun_path[0]) {
 909                 err = -EADDRINUSE;
 910                 if (__unix_find_socket_byname(net, sunaddr, addr_len,
 911                                               sk->sk_type, hash)) {
 912                         unix_release_addr(addr);
 913                         goto out_unlock;
 914                 }
 915
 916                 list = &unix_socket_table[addr->hash];
 917         } else {
 918                 list = &unix_socket_table[dentry->d_inode->i_ino & (UNIX_HASH_SIZE-1)];
 919                 u->path = path;
 920         }
 921
 922         err = 0;
 923         __unix_remove_socket(sk);
 924         u->addr = addr;
 925         __unix_insert_socket(list, sk);
 926
 927 out_unlock:
 928         spin_unlock(&unix_table_lock);
 929 out_up:
 930         mutex_unlock(&u->readlock);
 931 out:
 932         return err;
 933
 934 out_mknod_dput:
 935         dput(dentry);
 936         mutex_unlock(&path.dentry->d_inode->i_mutex);
 937         path_put(&path);
 938 out_mknod_parent:
 939         if (err == -EEXIST)
 940                 err = -EADDRINUSE;
 941         unix_release_addr(addr);
 942         goto out_up;
 943 }
 944
 945 static void unix_state_double_lock(struct sock *sk1, struct sock *sk2)
 946 {
 947         if (unlikely(sk1 == sk2) || !sk2) {
 948                 unix_state_lock(sk1);
 949                 return;
 950         }
 951         if (sk1 < sk2) {
 952                 unix_state_lock(sk1);
 953                 unix_state_lock_nested(sk2);
 954         } else {
 955                 unix_state_lock(sk2);
 956                 unix_state_lock_nested(sk1);
 957         }
 958 }
 959
 960 static void unix_state_double_unlock(struct sock *sk1, struct sock *sk2)
 961 {
 962         if (unlikely(sk1 == sk2) || !sk2) {
 963                 unix_state_unlock(sk1);
 964                 return;
 965         }
 966         unix_state_unlock(sk1);
 967         unix_state_unlock(sk2);
 968 }
 969
 970 static int unix_dgram_connect(struct socket *sock, struct sockaddr *addr,
 971                               int alen, int flags)
 972 {
 973         struct sock *sk = sock->sk;
 974         struct net *net = sock_net(sk);
 975         struct sockaddr_un *sunaddr = (struct sockaddr_un *)addr;
 976         struct sock *other;
 977         unsigned int hash;
 978         int err;
 979
 980         if (addr->sa_family != AF_UNSPEC) {
 981                 err = unix_mkname(sunaddr, alen, &hash);
 982                 if (err < 0)
 983                         goto out;
 984                 alen = err;
 985
 986                 if (test_bit(SOCK_PASSCRED, &sock->flags) &&
 987                     !unix_sk(sk)->addr && (err = unix_autobind(sock)) != 0)
 988                         goto out;
 989
 990 restart:
 991                 other = unix_find_other(net, sunaddr, alen, sock->type, hash, &err);
 992                 if (!other)
 993                         goto out;
 994
 995                 unix_state_double_lock(sk, other);
 996
 997                 /* Apparently VFS overslept socket death. Retry. */
 998                 if (sock_flag(other, SOCK_DEAD)) {
 999                         unix_state_double_unlock(sk, other);
1000                         sock_put(other);
1001                         goto restart;
1002                 }
1003
1004                 err = -EPERM;
1005                 if (!unix_may_send(sk, other))
1006                         goto out_unlock;
1007
1008                 err = security_unix_may_send(sk->sk_socket, other->sk_socket);
1009                 if (err)
1010                         goto out_unlock;
1011
1012         } else {
1013                 /*
1014                  *      1003.1g breaking connected state with AF_UNSPEC
1015                  */
1016                 other = NULL;
1017                 unix_state_double_lock(sk, other);
1018         }
1019
1020         /*
1021          * If it was connected, reconnect.
1022          */
1023         if (unix_peer(sk)) {
1024                 struct sock *old_peer = unix_peer(sk);
1025                 unix_peer(sk) = other;
1026                 unix_state_double_unlock(sk, other);
1027
1028                 if (other != old_peer)
1029                         unix_dgram_disconnected(sk, old_peer);
1030                 sock_put(old_peer);
1031         } else {
1032                 unix_peer(sk) = other;
1033                 unix_state_double_unlock(sk, other);
1034         }
1035         return 0;
1036
1037 out_unlock:
1038         unix_state_double_unlock(sk, other);
1039         sock_put(other);
1040 out:
1041         return err;
1042 }
1043
1044 static long unix_wait_for_peer(struct sock *other, long timeo)
1045 {
1046         struct unix_sock *u = unix_sk(other);
1047         int sched;
1048         DEFINE_WAIT(wait);
1049
1050         prepare_to_wait_exclusive(&u->peer_wait, &wait, TASK_INTERRUPTIBLE);
1051
1052         sched = !sock_flag(other, SOCK_DEAD) &&
1053                 !(other->sk_shutdown & RCV_SHUTDOWN) &&
1054                 unix_recvq_full(other);
1055
1056         unix_state_unlock(other);
1057
1058         if (sched)
1059                 timeo = schedule_timeout(timeo);
1060
1061         finish_wait(&u->peer_wait, &wait);
1062         return timeo;
1063 }
1064
1065 static int unix_stream_connect(struct socket *sock, struct sockaddr *uaddr,
1066                                int addr_len, int flags)
1067 {
1068         struct sockaddr_un *sunaddr = (struct sockaddr_un *)uaddr;
1069         struct sock *sk = sock->sk;
1070         struct net *net = sock_net(sk);
1071         struct unix_sock *u = unix_sk(sk), *newu, *otheru;
1072         struct sock *newsk = NULL;
1073         struct sock *other = NULL;
1074         struct sk_buff *skb = NULL;
1075         unsigned int hash;
1076         int st;
1077         int err;
1078         long timeo;
1079
1080         err = unix_mkname(sunaddr, addr_len, &hash);
1081         if (err < 0)
1082                 goto out;
1083         addr_len = err;
1084
1085         if (test_bit(SOCK_PASSCRED, &sock->flags) && !u->addr &&
1086             (err = unix_autobind(sock)) != 0)
1087                 goto out;
1088
1089         timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
1090
1091         /* First of all allocate resources.
1092            If we will make it after state is locked,
1093            we will have to recheck all again in any case.
1094          */
1095
1096         err = -ENOMEM;
1097
1098         /* create new sock for complete connection */
1099         newsk = unix_create1(sock_net(sk), NULL);
1100         if (newsk == NULL)
1101                 goto out;
1102
1103         /* Allocate skb for sending to listening sock */
1104         skb = sock_wmalloc(newsk, 1, 0, GFP_KERNEL);
1105         if (skb == NULL)
1106                 goto out;
1107
1108 restart:
1109         /*  Find listening sock. */
1110         other = unix_find_other(net, sunaddr, addr_len, sk->sk_type, hash, &err);
1111         if (!other)
1112                 goto out;
1113
1114         /* Latch state of peer */
1115         unix_state_lock(other);
1116
1117         /* Apparently VFS overslept socket death. Retry. */
1118         if (sock_flag(other, SOCK_DEAD)) {
1119                 unix_state_unlock(other);
1120                 sock_put(other);
1121                 goto restart;
1122         }
1123
1124         err = -ECONNREFUSED;
1125         if (other->sk_state != TCP_LISTEN)
1126                 goto out_unlock;
1127         if (other->sk_shutdown & RCV_SHUTDOWN)
1128                 goto out_unlock;
1129
1130         if (unix_recvq_full(other)) {
1131                 err = -EAGAIN;
1132                 if (!timeo)
1133                         goto out_unlock;
1134
1135                 timeo = unix_wait_for_peer(other, timeo);
1136
1137                 err = sock_intr_errno(timeo);
1138                 if (signal_pending(current))
1139                         goto out;
1140                 sock_put(other);
1141                 goto restart;
1142         }
1143
1144         /* Latch our state.
1145
1146            It is tricky place. We need to grab our state lock and cannot
1147            drop lock on peer. It is dangerous because deadlock is
1148            possible. Connect to self case and simultaneous
1149            attempt to connect are eliminated by checking socket
1150            state. other is TCP_LISTEN, if sk is TCP_LISTEN we
1151            check this before attempt to grab lock.
1152
1153            Well, and we have to recheck the state after socket locked.
1154          */
1155         st = sk->sk_state;
1156
1157         switch (st) {
1158         case TCP_CLOSE:
1159                 /* This is ok... continue with connect */
1160                 break;
1161         case TCP_ESTABLISHED:
1162                 /* Socket is already connected */
1163                 err = -EISCONN;
1164                 goto out_unlock;
1165         default:
1166                 err = -EINVAL;
1167                 goto out_unlock;
1168         }
1169
1170         unix_state_lock_nested(sk);
1171
1172         if (sk->sk_state != st) {
1173                 unix_state_unlock(sk);
1174                 unix_state_unlock(other);
1175                 sock_put(other);
1176                 goto restart;
1177         }
1178
1179         err = security_unix_stream_connect(sk, other, newsk);
1180         if (err) {
1181                 unix_state_unlock(sk);
1182                 goto out_unlock;
1183         }
1184
1185         /* The way is open! Fastly set all the necessary fields... */
1186
1187         sock_hold(sk);
1188         unix_peer(newsk)        = sk;
1189         newsk->sk_state         = TCP_ESTABLISHED;
1190         newsk->sk_type          = sk->sk_type;
1191         init_peercred(newsk);
1192         newu = unix_sk(newsk);
1193         RCU_INIT_POINTER(newsk->sk_wq, &newu->peer_wq);
1194         otheru = unix_sk(other);
1195
1196         /* copy address information from listening to new sock*/
1197         if (otheru->addr) {
1198                 atomic_inc(&otheru->addr->refcnt);
1199                 newu->addr = otheru->addr;
1200         }
1201         if (otheru->path.dentry) {
1202                 path_get(&otheru->path);
1203                 newu->path = otheru->path;
1204         }
1205
1206         /* Set credentials */
1207         copy_peercred(sk, other);
1208
1209         sock->state     = SS_CONNECTED;
1210         sk->sk_state    = TCP_ESTABLISHED;
1211         sock_hold(newsk);
1212
1213         smp_mb__after_atomic_inc();     /* sock_hold() does an atomic_inc() */
1214         unix_peer(sk)   = newsk;
1215
1216         unix_state_unlock(sk);
1217
1218         /* take ten and and send info to listening sock */
1219         spin_lock(&other->sk_receive_queue.lock);
1220         __skb_queue_tail(&other->sk_receive_queue, skb);
1221         spin_unlock(&other->sk_receive_queue.lock);
1222         unix_state_unlock(other);
1223         other->sk_data_ready(other, 0);
1224         sock_put(other);
1225         return 0;
1226
1227 out_unlock:
1228         if (other)
1229                 unix_state_unlock(other);
1230
1231 out:
1232         kfree_skb(skb);
1233         if (newsk)
1234                 unix_release_sock(newsk, 0);
1235         if (other)
1236                 sock_put(other);
1237         return err;
1238 }
1239
1240 static int unix_socketpair(struct socket *socka, struct socket *sockb)
1241 {
1242         struct sock *ska = socka->sk, *skb = sockb->sk;
1243
1244         /* Join our sockets back to back */
1245         sock_hold(ska);
1246         sock_hold(skb);
1247         unix_peer(ska) = skb;
1248         unix_peer(skb) = ska;
1249         init_peercred(ska);
1250         init_peercred(skb);
1251
1252         if (ska->sk_type != SOCK_DGRAM) {
1253                 ska->sk_state = TCP_ESTABLISHED;
1254                 skb->sk_state = TCP_ESTABLISHED;
1255                 socka->state  = SS_CONNECTED;
1256                 sockb->state  = SS_CONNECTED;
1257         }
1258         return 0;
1259 }
1260
1261 static int unix_accept(struct socket *sock, struct socket *newsock, int flags)
1262 {
1263         struct sock *sk = sock->sk;
1264         struct sock *tsk;
1265         struct sk_buff *skb;
1266         int err;
1267
1268         err = -EOPNOTSUPP;
1269         if (sock->type != SOCK_STREAM && sock->type != SOCK_SEQPACKET)
1270                 goto out;
1271
1272         err = -EINVAL;
1273         if (sk->sk_state != TCP_LISTEN)
1274                 goto out;
1275
1276         /* If socket state is TCP_LISTEN it cannot change (for now...),
1277          * so that no locks are necessary.
1278          */
1279
1280         skb = skb_recv_datagram(sk, 0, flags&O_NONBLOCK, &err);
1281         if (!skb) {
1282                 /* This means receive shutdown. */
1283                 if (err == 0)
1284                         err = -EINVAL;
1285                 goto out;
1286         }
1287
1288         tsk = skb->sk;
1289         skb_free_datagram(sk, skb);
1290         wake_up_interruptible(&unix_sk(sk)->peer_wait);
1291
1292         /* attach accepted sock to socket */
1293         unix_state_lock(tsk);
1294         newsock->state = SS_CONNECTED;
1295         sock_graft(tsk, newsock);
1296         unix_state_unlock(tsk);
1297         return 0;
1298
1299 out:
1300         return err;
1301 }
1302
1303
1304 static int unix_getname(struct socket *sock, struct sockaddr *uaddr, int *uaddr_len, int peer)
1305 {
1306         struct sock *sk = sock->sk;
1307         struct unix_sock *u;
1308         DECLARE_SOCKADDR(struct sockaddr_un *, sunaddr, uaddr);
1309         int err = 0;
1310
1311         if (peer) {
1312                 sk = unix_peer_get(sk);
1313
1314                 err = -ENOTCONN;
1315                 if (!sk)
1316                         goto out;
1317                 err = 0;
1318         } else {
1319                 sock_hold(sk);
1320         }
1321
1322         u = unix_sk(sk);
1323         unix_state_lock(sk);
1324         if (!u->addr) {
1325                 sunaddr->sun_family = AF_UNIX;
1326                 sunaddr->sun_path[0] = 0;
1327                 *uaddr_len = sizeof(short);
1328         } else {
1329                 struct unix_address *addr = u->addr;
1330
1331                 *uaddr_len = addr->len;
1332                 memcpy(sunaddr, addr->name, *uaddr_len);
1333         }
1334         unix_state_unlock(sk);
1335         sock_put(sk);
1336 out:
1337         return err;
1338 }
1339
1340 static void unix_detach_fds(struct scm_cookie *scm, struct sk_buff *skb)
1341 {
1342         int i;
1343
1344         scm->fp = UNIXCB(skb).fp;
1345         UNIXCB(skb).fp = NULL;
1346
1347         for (i = scm->fp->count-1; i >= 0; i--)
1348                 unix_notinflight(scm->fp->fp[i]);
1349 }
1350
1351 static void unix_destruct_scm(struct sk_buff *skb)
1352 {
1353         struct scm_cookie scm;
1354         memset(&scm, 0, sizeof(scm));
1355         scm.pid  = UNIXCB(skb).pid;
1356         scm.cred = UNIXCB(skb).cred;
1357         if (UNIXCB(skb).fp)
1358                 unix_detach_fds(&scm, skb);
1359
1360         /* Alas, it calls VFS */
1361         /* So fscking what? fput() had been SMP-safe since the last Summer */
1362         scm_destroy(&scm);
1363         sock_wfree(skb);
1364 }
1365
1366 #define MAX_RECURSION_LEVEL 4
1367
1368 static int unix_attach_fds(struct scm_cookie *scm, struct sk_buff *skb)
1369 {
1370         int i;
1371         unsigned char max_level = 0;
1372         int unix_sock_count = 0;
1373
1374         for (i = scm->fp->count - 1; i >= 0; i--) {
1375                 struct sock *sk = unix_get_socket(scm->fp->fp[i]);
1376
1377                 if (sk) {
1378                         unix_sock_count++;
1379                         max_level = max(max_level,
1380                                         unix_sk(sk)->recursion_level);
1381                 }
1382         }
1383         if (unlikely(max_level > MAX_RECURSION_LEVEL))
1384                 return -ETOOMANYREFS;
1385
1386         /*
1387          * Need to duplicate file references for the sake of garbage
1388          * collection.  Otherwise a socket in the fps might become a
1389          * candidate for GC while the skb is not yet queued.
1390          */
1391         UNIXCB(skb).fp = scm_fp_dup(scm->fp);
1392         if (!UNIXCB(skb).fp)
1393                 return -ENOMEM;
1394
1395         if (unix_sock_count) {
1396                 for (i = scm->fp->count - 1; i >= 0; i--)
1397                         unix_inflight(scm->fp->fp[i]);
1398         }
1399         return max_level;
1400 }
1401
1402 static int unix_scm_to_skb(struct scm_cookie *scm, struct sk_buff *skb, bool send_fds)
1403 {
1404         int err = 0;
1405
1406         UNIXCB(skb).pid  = get_pid(scm->pid);
1407         if (scm->cred)
1408                 UNIXCB(skb).cred = get_cred(scm->cred);
1409         UNIXCB(skb).fp = NULL;
1410         if (scm->fp && send_fds)
1411                 err = unix_attach_fds(scm, skb);
1412
1413         skb->destructor = unix_destruct_scm;
1414         return err;
1415 }
1416
1417 /*
1418  * Some apps rely on write() giving SCM_CREDENTIALS
1419  * We include credentials if source or destination socket
1420  * asserted SOCK_PASSCRED.
1421  */
1422 static void maybe_add_creds(struct sk_buff *skb, const struct socket *sock,
1423                             const struct sock *other)
1424 {
1425         if (UNIXCB(skb).cred)
1426                 return;
1427         if (test_bit(SOCK_PASSCRED, &sock->flags) ||
1428             !other->sk_socket ||
1429             test_bit(SOCK_PASSCRED, &other->sk_socket->flags)) {
1430                 UNIXCB(skb).pid  = get_pid(task_tgid(current));
1431                 UNIXCB(skb).cred = get_current_cred();
1432         }
1433 }
1434
1435 /*
1436  *      Send AF_UNIX data.
1437  */
1438
1439 static int unix_dgram_sendmsg(struct kiocb *kiocb, struct socket *sock,
1440                               struct msghdr *msg, size_t len)
1441 {
1442         struct sock_iocb *siocb = kiocb_to_siocb(kiocb);
1443         struct sock *sk = sock->sk;
1444         struct net *net = sock_net(sk);
1445         struct unix_sock *u = unix_sk(sk);
1446         struct sockaddr_un *sunaddr = msg->msg_name;
1447         struct sock *other = NULL;
1448         int namelen = 0; /* fake GCC */
1449         int err;
1450         unsigned int hash;
1451         struct sk_buff *skb;
1452         long timeo;
1453         struct scm_cookie tmp_scm;
1454         int max_level;
1455         int data_len = 0;
1456
1457         if (NULL == siocb->scm)
1458                 siocb->scm = &tmp_scm;
1459         wait_for_unix_gc();
1460         err = scm_send(sock, msg, siocb->scm);
1461         if (err < 0)
1462                 return err;
1463
1464         err = -EOPNOTSUPP;
1465         if (msg->msg_flags&MSG_OOB)
1466                 goto out;
1467
1468         if (msg->msg_namelen) {
1469                 err = unix_mkname(sunaddr, msg->msg_namelen, &hash);
1470                 if (err < 0)
1471                         goto out;
1472                 namelen = err;
1473         } else {
1474                 sunaddr = NULL;
1475                 err = -ENOTCONN;
1476                 other = unix_peer_get(sk);
1477                 if (!other)
1478                         goto out;
1479         }
1480
1481         if (test_bit(SOCK_PASSCRED, &sock->flags) && !u->addr
1482             && (err = unix_autobind(sock)) != 0)
1483                 goto out;
1484
1485         err = -EMSGSIZE;
1486         if (len > sk->sk_sndbuf - 32)
1487                 goto out;
1488
1489         if (len > SKB_MAX_ALLOC)
1490                 data_len = min_t(size_t,
1491                                  len - SKB_MAX_ALLOC,
1492                                  MAX_SKB_FRAGS * PAGE_SIZE);
1493
1494         skb = sock_alloc_send_pskb(sk, len - data_len, data_len,
1495                                    msg->msg_flags & MSG_DONTWAIT, &err);
1496         if (skb == NULL)
1497                 goto out;
1498
1499         err = unix_scm_to_skb(siocb->scm, skb, true);
1500         if (err < 0)
1501                 goto out_free;
1502         max_level = err + 1;
1503         unix_get_secdata(siocb->scm, skb);
1504
1505         skb_put(skb, len - data_len);
1506         skb->data_len = data_len;
1507         skb->len = len;
1508         err = skb_copy_datagram_from_iovec(skb, 0, msg->msg_iov, 0, len);
1509         if (err)
1510                 goto out_free;
1511
1512         timeo = sock_sndtimeo(sk, msg->msg_flags & MSG_DONTWAIT);
1513
1514 restart:
1515         if (!other) {
1516                 err = -ECONNRESET;
1517                 if (sunaddr == NULL)
1518                         goto out_free;
1519
1520                 other = unix_find_other(net, sunaddr, namelen, sk->sk_type,
1521                                         hash, &err);
1522                 if (other == NULL)
1523                         goto out_free;
1524         }
1525
1526         if (sk_filter(other, skb) < 0) {
1527                 /* Toss the packet but do not return any error to the sender */
1528                 err = len;
1529                 goto out_free;
1530         }
1531
1532         unix_state_lock(other);
1533         err = -EPERM;
1534         if (!unix_may_send(sk, other))
1535                 goto out_unlock;
1536
1537         if (sock_flag(other, SOCK_DEAD)) {
1538                 /*
1539                  *      Check with 1003.1g - what should
1540                  *      datagram error
1541                  */
1542                 unix_state_unlock(other);
1543                 sock_put(other);
1544
1545                 err = 0;
1546                 unix_state_lock(sk);
1547                 if (unix_peer(sk) == other) {
1548                         unix_peer(sk) = NULL;
1549                         unix_state_unlock(sk);
1550
1551                         unix_dgram_disconnected(sk, other);
1552                         sock_put(other);
1553                         err = -ECONNREFUSED;
1554                 } else {
1555                         unix_state_unlock(sk);
1556                 }
1557
1558                 other = NULL;
1559                 if (err)
1560                         goto out_free;
1561                 goto restart;
1562         }
1563
1564         err = -EPIPE;
1565         if (other->sk_shutdown & RCV_SHUTDOWN)
1566                 goto out_unlock;
1567
1568         if (sk->sk_type != SOCK_SEQPACKET) {
1569                 err = security_unix_may_send(sk->sk_socket, other->sk_socket);
1570                 if (err)
1571                         goto out_unlock;
1572         }
1573
1574         if (unix_peer(other) != sk && unix_recvq_full(other)) {
1575                 if (!timeo) {
1576                         err = -EAGAIN;
1577                         goto out_unlock;
1578                 }
1579
1580                 timeo = unix_wait_for_peer(other, timeo);
1581
1582                 err = sock_intr_errno(timeo);
1583                 if (signal_pending(current))
1584                         goto out_free;
1585
1586                 goto restart;
1587         }
1588
1589         if (sock_flag(other, SOCK_RCVTSTAMP))
1590                 __net_timestamp(skb);
1591         maybe_add_creds(skb, sock, other);
1592         skb_queue_tail(&other->sk_receive_queue, skb);
1593         if (max_level > unix_sk(other)->recursion_level)
1594                 unix_sk(other)->recursion_level = max_level;
1595         unix_state_unlock(other);
1596         other->sk_data_ready(other, len);
1597         sock_put(other);
1598         scm_destroy(siocb->scm);
1599         return len;
1600
1601 out_unlock:
1602         unix_state_unlock(other);
1603 out_free:
1604         kfree_skb(skb);
1605 out:
1606         if (other)
1607                 sock_put(other);
1608         scm_destroy(siocb->scm);
1609         return err;
1610 }
1611
1612
1613 static int unix_stream_sendmsg(struct kiocb *kiocb, struct socket *sock,
1614                                struct msghdr *msg, size_t len)
1615 {
1616         struct sock_iocb *siocb = kiocb_to_siocb(kiocb);
1617         struct sock *sk = sock->sk;
1618         struct sock *other = NULL;
1619         int err, size;
1620         struct sk_buff *skb;
1621         int sent = 0;
1622         struct scm_cookie tmp_scm;
1623         bool fds_sent = false;
1624         int max_level;
1625
1626         if (NULL == siocb->scm)
1627                 siocb->scm = &tmp_scm;
1628         wait_for_unix_gc();
1629         err = scm_send(sock, msg, siocb->scm);
1630         if (err < 0)
1631                 return err;
1632
1633         err = -EOPNOTSUPP;
1634         if (msg->msg_flags&MSG_OOB)
1635                 goto out_err;
1636
1637         if (msg->msg_namelen) {
1638                 err = sk->sk_state == TCP_ESTABLISHED ? -EISCONN : -EOPNOTSUPP;
1639                 goto out_err;
1640         } else {
1641                 err = -ENOTCONN;
1642                 other = unix_peer(sk);
1643                 if (!other)
1644                         goto out_err;
1645         }
1646
1647         if (sk->sk_shutdown & SEND_SHUTDOWN)
1648                 goto pipe_err;
1649
1650         while (sent < len) {
1651                 /*
1652                  *      Optimisation for the fact that under 0.01% of X
1653                  *      messages typically need breaking up.
1654                  */
1655
1656                 size = len-sent;
1657
1658                 /* Keep two messages in the pipe so it schedules better */
1659                 if (size > ((sk->sk_sndbuf >> 1) - 64))
1660                         size = (sk->sk_sndbuf >> 1) - 64;
1661
1662                 if (size > SKB_MAX_ALLOC)
1663                         size = SKB_MAX_ALLOC;
1664
1665                 /*
1666                  *      Grab a buffer
1667                  */
1668
1669                 skb = sock_alloc_send_skb(sk, size, msg->msg_flags&MSG_DONTWAIT,
1670                                           &err);
1671
1672                 if (skb == NULL)
1673                         goto out_err;
1674
1675                 /*
1676                  *      If you pass two values to the sock_alloc_send_skb
1677                  *      it tries to grab the large buffer with GFP_NOFS
1678                  *      (which can fail easily), and if it fails grab the
1679                  *      fallback size buffer which is under a page and will
1680                  *      succeed. [Alan]
1681                  */
1682                 size = min_t(int, size, skb_tailroom(skb));
1683
1684
1685                 /* Only send the fds in the first buffer */
1686                 err = unix_scm_to_skb(siocb->scm, skb, !fds_sent);
1687                 if (err < 0) {
1688                         kfree_skb(skb);
1689                         goto out_err;
1690                 }
1691                 max_level = err + 1;
1692                 fds_sent = true;
1693
1694                 err = memcpy_fromiovec(skb_put(skb, size), msg->msg_iov, size);
1695                 if (err) {
1696                         kfree_skb(skb);
1697                         goto out_err;
1698                 }
1699
1700                 unix_state_lock(other);
1701
1702                 if (sock_flag(other, SOCK_DEAD) ||
1703                     (other->sk_shutdown & RCV_SHUTDOWN))
1704                         goto pipe_err_free;
1705
1706                 maybe_add_creds(skb, sock, other);
1707                 skb_queue_tail(&other->sk_receive_queue, skb);
1708                 if (max_level > unix_sk(other)->recursion_level)
1709                         unix_sk(other)->recursion_level = max_level;
1710                 unix_state_unlock(other);
1711                 other->sk_data_ready(other, size);
1712                 sent += size;
1713         }
1714
1715         scm_destroy(siocb->scm);
1716         siocb->scm = NULL;
1717
1718         return sent;
1719
1720 pipe_err_free:
1721         unix_state_unlock(other);
1722         kfree_skb(skb);
1723 pipe_err:
1724         if (sent == 0 && !(msg->msg_flags&MSG_NOSIGNAL))
1725                 send_sig(SIGPIPE, current, 0);
1726         err = -EPIPE;
1727 out_err:
1728         scm_destroy(siocb->scm);
1729         siocb->scm = NULL;
1730         return sent ? : err;
1731 }
1732
1733 static int unix_seqpacket_sendmsg(struct kiocb *kiocb, struct socket *sock,
1734                                   struct msghdr *msg, size_t len)
1735 {
1736         int err;
1737         struct sock *sk = sock->sk;
1738
1739         err = sock_error(sk);
1740         if (err)
1741                 return err;
1742
1743         if (sk->sk_state != TCP_ESTABLISHED)
1744                 return -ENOTCONN;
1745
1746         if (msg->msg_namelen)
1747                 msg->msg_namelen = 0;
1748
1749         return unix_dgram_sendmsg(kiocb, sock, msg, len);
1750 }
1751
1752 static int unix_seqpacket_recvmsg(struct kiocb *iocb, struct socket *sock,
1753                               struct msghdr *msg, size_t size,
1754                               int flags)
1755 {
1756         struct sock *sk = sock->sk;
1757
1758         if (sk->sk_state != TCP_ESTABLISHED)
1759                 return -ENOTCONN;
1760
1761         return unix_dgram_recvmsg(iocb, sock, msg, size, flags);
1762 }
1763
1764 static void unix_copy_addr(struct msghdr *msg, struct sock *sk)
1765 {
1766         struct unix_sock *u = unix_sk(sk);
1767
1768         msg->msg_namelen = 0;
1769         if (u->addr) {
1770                 msg->msg_namelen = u->addr->len;
1771                 memcpy(msg->msg_name, u->addr->name, u->addr->len);
1772         }
1773 }
1774
1775 static int unix_dgram_recvmsg(struct kiocb *iocb, struct socket *sock,
1776                               struct msghdr *msg, size_t size,
1777                               int flags)
1778 {
1779         struct sock_iocb *siocb = kiocb_to_siocb(iocb);
1780         struct scm_cookie tmp_scm;
1781         struct sock *sk = sock->sk;
1782         struct unix_sock *u = unix_sk(sk);
1783         int noblock = flags & MSG_DONTWAIT;
1784         struct sk_buff *skb;
1785         int err;
1786         int peeked, skip;
1787
1788         err = -EOPNOTSUPP;
1789         if (flags&MSG_OOB)
1790                 goto out;
1791
1792         msg->msg_namelen = 0;
1793
1794         err = mutex_lock_interruptible(&u->readlock);
1795         if (err) {
1796                 err = sock_intr_errno(sock_rcvtimeo(sk, noblock));
1797                 goto out;
1798         }
1799
1800         skip = sk_peek_offset(sk, flags);
1801
1802         skb = __skb_recv_datagram(sk, flags, &peeked, &skip, &err);
1803         if (!skb) {
1804                 unix_state_lock(sk);
1805                 /* Signal EOF on disconnected non-blocking SEQPACKET socket. */
1806                 if (sk->sk_type == SOCK_SEQPACKET && err == -EAGAIN &&
1807                     (sk->sk_shutdown & RCV_SHUTDOWN))
1808                         err = 0;
1809                 unix_state_unlock(sk);
1810                 goto out_unlock;
1811         }
1812
1813         wake_up_interruptible_sync_poll(&u->peer_wait,
1814                                         POLLOUT | POLLWRNORM | POLLWRBAND);
1815
1816         if (msg->msg_name)
1817                 unix_copy_addr(msg, skb->sk);
1818
1819         if (size > skb->len - skip)
1820                 size = skb->len - skip;
1821         else if (size < skb->len - skip)
1822                 msg->msg_flags |= MSG_TRUNC;
1823
1824         err = skb_copy_datagram_iovec(skb, skip, msg->msg_iov, size);
1825         if (err)
1826                 goto out_free;
1827
1828         if (sock_flag(sk, SOCK_RCVTSTAMP))
1829                 __sock_recv_timestamp(msg, sk, skb);
1830
1831         if (!siocb->scm) {
1832                 siocb->scm = &tmp_scm;
1833                 memset(&tmp_scm, 0, sizeof(tmp_scm));
1834         }
1835         scm_set_cred(siocb->scm, UNIXCB(skb).pid, UNIXCB(skb).cred);
1836         unix_set_secdata(siocb->scm, skb);
1837
1838         if (!(flags & MSG_PEEK)) {
1839                 if (UNIXCB(skb).fp)
1840                         unix_detach_fds(siocb->scm, skb);
1841
1842                 sk_peek_offset_bwd(sk, skb->len);
1843         } else {
1844                 /* It is questionable: on PEEK we could:
1845                    - do not return fds - good, but too simple 8)
1846                    - return fds, and do not return them on read (old strategy,
1847                      apparently wrong)
1848                    - clone fds (I chose it for now, it is the most universal
1849                      solution)
1850
1851                    POSIX 1003.1g does not actually define this clearly
1852                    at all. POSIX 1003.1g doesn't define a lot of things
1853                    clearly however!
1854
1855                 */
1856
1857                 sk_peek_offset_fwd(sk, size);
1858
1859                 if (UNIXCB(skb).fp)
1860                         siocb->scm->fp = scm_fp_dup(UNIXCB(skb).fp);
1861         }
1862         err = (flags & MSG_TRUNC) ? skb->len - skip : size;
1863
1864         scm_recv(sock, msg, siocb->scm, flags);
1865
1866 out_free:
1867         skb_free_datagram(sk, skb);
1868 out_unlock:
1869         mutex_unlock(&u->readlock);
1870 out:
1871         return err;
1872 }
1873
1874 /*
1875  *      Sleep until data has arrive. But check for races..
1876  */
1877
1878 static long unix_stream_data_wait(struct sock *sk, long timeo)
1879 {
1880         DEFINE_WAIT(wait);
1881
1882         unix_state_lock(sk);
1883
1884         for (;;) {
1885                 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
1886
1887                 if (!skb_queue_empty(&sk->sk_receive_queue) ||
1888                     sk->sk_err ||
1889                     (sk->sk_shutdown & RCV_SHUTDOWN) ||
1890                     signal_pending(current) ||
1891                     !timeo)
1892                         break;
1893
1894                 set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
1895                 unix_state_unlock(sk);
1896                 timeo = schedule_timeout(timeo);
1897                 unix_state_lock(sk);
1898                 clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
1899         }
1900
1901         finish_wait(sk_sleep(sk), &wait);
1902         unix_state_unlock(sk);
1903         return timeo;
1904 }
1905
1906
1907
1908 static int unix_stream_recvmsg(struct kiocb *iocb, struct socket *sock,
1909                                struct msghdr *msg, size_t size,
1910                                int flags)
1911 {
1912         struct sock_iocb *siocb = kiocb_to_siocb(iocb);
1913         struct scm_cookie tmp_scm;
1914         struct sock *sk = sock->sk;
1915         struct unix_sock *u = unix_sk(sk);
1916         struct sockaddr_un *sunaddr = msg->msg_name;
1917         int copied = 0;
1918         int check_creds = 0;
1919         int target;
1920         int err = 0;
1921         long timeo;
1922         int skip;
1923
1924         err = -EINVAL;
1925         if (sk->sk_state != TCP_ESTABLISHED)
1926                 goto out;
1927
1928         err = -EOPNOTSUPP;
1929         if (flags&MSG_OOB)
1930                 goto out;
1931
1932         target = sock_rcvlowat(sk, flags&MSG_WAITALL, size);
1933         timeo = sock_rcvtimeo(sk, flags&MSG_DONTWAIT);
1934
1935         msg->msg_namelen = 0;
1936
1937         /* Lock the socket to prevent queue disordering
1938          * while sleeps in memcpy_tomsg
1939          */
1940
1941         if (!siocb->scm) {
1942                 siocb->scm = &tmp_scm;
1943                 memset(&tmp_scm, 0, sizeof(tmp_scm));
1944         }
1945
1946         err = mutex_lock_interruptible(&u->readlock);
1947         if (err) {
1948                 err = sock_intr_errno(timeo);
1949                 goto out;
1950         }
1951
1952         skip = sk_peek_offset(sk, flags);
1953
1954         do {
1955                 int chunk;
1956                 struct sk_buff *skb;
1957
1958                 unix_state_lock(sk);
1959                 skb = skb_peek(&sk->sk_receive_queue);
1960 again:
1961                 if (skb == NULL) {
1962                         unix_sk(sk)->recursion_level = 0;
1963                         if (copied >= target)
1964                                 goto unlock;
1965
1966                         /*
1967                          *      POSIX 1003.1g mandates this order.
1968                          */
1969
1970                         err = sock_error(sk);
1971                         if (err)
1972                                 goto unlock;
1973                         if (sk->sk_shutdown & RCV_SHUTDOWN)
1974                                 goto unlock;
1975
1976                         unix_state_unlock(sk);
1977                         err = -EAGAIN;
1978                         if (!timeo)
1979                                 break;
1980                         mutex_unlock(&u->readlock);
1981
1982                         timeo = unix_stream_data_wait(sk, timeo);
1983
1984                         if (signal_pending(current)
1985                             ||  mutex_lock_interruptible(&u->readlock)) {
1986                                 err = sock_intr_errno(timeo);
1987                                 goto out;
1988                         }
1989
1990                         continue;
1991  unlock:
1992                         unix_state_unlock(sk);
1993                         break;
1994                 }
1995
1996                 if (skip >= skb->len) {
1997                         skip -= skb->len;
1998                         skb = skb_peek_next(skb, &sk->sk_receive_queue);
1999                         goto again;
2000                 }
2001
2002                 unix_state_unlock(sk);
2003
2004                 if (check_creds) {
2005                         /* Never glue messages from different writers */
2006                         if ((UNIXCB(skb).pid  != siocb->scm->pid) ||
2007                             (UNIXCB(skb).cred != siocb->scm->cred))
2008                                 break;
2009                 } else {
2010                         /* Copy credentials */
2011                         scm_set_cred(siocb->scm, UNIXCB(skb).pid, UNIXCB(skb).cred);
2012                         check_creds = 1;
2013                 }
2014
2015                 /* Copy address just once */
2016                 if (sunaddr) {
2017                         unix_copy_addr(msg, skb->sk);
2018                         sunaddr = NULL;
2019                 }
2020
2021                 chunk = min_t(unsigned int, skb->len - skip, size);
2022                 if (memcpy_toiovec(msg->msg_iov, skb->data + skip, chunk)) {
2023                         if (copied == 0)
2024                                 copied = -EFAULT;
2025                         break;
2026                 }
2027                 copied += chunk;
2028                 size -= chunk;
2029
2030                 /* Mark read part of skb as used */
2031                 if (!(flags & MSG_PEEK)) {
2032                         skb_pull(skb, chunk);
2033
2034                         sk_peek_offset_bwd(sk, chunk);
2035
2036                         if (UNIXCB(skb).fp)
2037                                 unix_detach_fds(siocb->scm, skb);
2038
2039                         if (skb->len)
2040                                 break;
2041
2042                         skb_unlink(skb, &sk->sk_receive_queue);
2043                         consume_skb(skb);
2044
2045                         if (siocb->scm->fp)
2046                                 break;
2047                 } else {
2048                         /* It is questionable, see note in unix_dgram_recvmsg.
2049                          */
2050                         if (UNIXCB(skb).fp)
2051                                 siocb->scm->fp = scm_fp_dup(UNIXCB(skb).fp);
2052
2053                         sk_peek_offset_fwd(sk, chunk);
2054
2055                         break;
2056                 }
2057         } while (size);
2058
2059         mutex_unlock(&u->readlock);
2060         scm_recv(sock, msg, siocb->scm, flags);
2061 out:
2062         return copied ? : err;
2063 }
2064
2065 static int unix_shutdown(struct socket *sock, int mode)
2066 {
2067         struct sock *sk = sock->sk;
2068         struct sock *other;
2069
2070         mode = (mode+1)&(RCV_SHUTDOWN|SEND_SHUTDOWN);
2071
2072         if (!mode)
2073                 return 0;
2074
2075         unix_state_lock(sk);
2076         sk->sk_shutdown |= mode;
2077         other = unix_peer(sk);
2078         if (other)
2079                 sock_hold(other);
2080         unix_state_unlock(sk);
2081         sk->sk_state_change(sk);
2082
2083         if (other &&
2084                 (sk->sk_type == SOCK_STREAM || sk->sk_type == SOCK_SEQPACKET)) {
2085
2086                 int peer_mode = 0;
2087
2088                 if (mode&RCV_SHUTDOWN)
2089                         peer_mode |= SEND_SHUTDOWN;
2090                 if (mode&SEND_SHUTDOWN)
2091                         peer_mode |= RCV_SHUTDOWN;
2092                 unix_state_lock(other);
2093                 other->sk_shutdown |= peer_mode;
2094                 unix_state_unlock(other);
2095                 other->sk_state_change(other);
2096                 if (peer_mode == SHUTDOWN_MASK)
2097                         sk_wake_async(other, SOCK_WAKE_WAITD, POLL_HUP);
2098                 else if (peer_mode & RCV_SHUTDOWN)
2099                         sk_wake_async(other, SOCK_WAKE_WAITD, POLL_IN);
2100         }
2101         if (other)
2102                 sock_put(other);
2103
2104         return 0;
2105 }
2106
2107 long unix_inq_len(struct sock *sk)
2108 {
2109         struct sk_buff *skb;
2110         long amount = 0;
2111
2112         if (sk->sk_state == TCP_LISTEN)
2113                 return -EINVAL;
2114
2115         spin_lock(&sk->sk_receive_queue.lock);
2116         if (sk->sk_type == SOCK_STREAM ||
2117             sk->sk_type == SOCK_SEQPACKET) {
2118                 skb_queue_walk(&sk->sk_receive_queue, skb)
2119                         amount += skb->len;
2120         } else {
2121                 skb = skb_peek(&sk->sk_receive_queue);
2122                 if (skb)
2123                         amount = skb->len;
2124         }
2125         spin_unlock(&sk->sk_receive_queue.lock);
2126
2127         return amount;
2128 }
2129 EXPORT_SYMBOL_GPL(unix_inq_len);
2130
2131 long unix_outq_len(struct sock *sk)
2132 {
2133         return sk_wmem_alloc_get(sk);
2134 }
2135 EXPORT_SYMBOL_GPL(unix_outq_len);
2136
2137 static int unix_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
2138 {
2139         struct sock *sk = sock->sk;
2140         long amount = 0;
2141         int err;
2142
2143         switch (cmd) {
2144         case SIOCOUTQ:
2145                 amount = unix_outq_len(sk);
2146                 err = put_user(amount, (int __user *)arg);
2147                 break;
2148         case SIOCINQ:
2149                 amount = unix_inq_len(sk);
2150                 if (amount < 0)
2151                         err = amount;
2152                 else
2153                         err = put_user(amount, (int __user *)arg);
2154                 break;
2155         default:
2156                 err = -ENOIOCTLCMD;
2157                 break;
2158         }
2159         return err;
2160 }
2161
2162 static unsigned int unix_poll(struct file *file, struct socket *sock, poll_table *wait)
2163 {
2164         struct sock *sk = sock->sk;
2165         unsigned int mask;
2166
2167         sock_poll_wait(file, sk_sleep(sk), wait);
2168         mask = 0;
2169
2170         /* exceptional events? */
2171         if (sk->sk_err)
2172                 mask |= POLLERR;
2173         if (sk->sk_shutdown == SHUTDOWN_MASK)
2174                 mask |= POLLHUP;
2175         if (sk->sk_shutdown & RCV_SHUTDOWN)
2176                 mask |= POLLRDHUP | POLLIN | POLLRDNORM;
2177
2178         /* readable? */
2179         if (!skb_queue_empty(&sk->sk_receive_queue))
2180                 mask |= POLLIN | POLLRDNORM;
2181
2182         /* Connection-based need to check for termination and startup */
2183         if ((sk->sk_type == SOCK_STREAM || sk->sk_type == SOCK_SEQPACKET) &&
2184             sk->sk_state == TCP_CLOSE)
2185                 mask |= POLLHUP;
2186
2187         /*
2188          * we set writable also when the other side has shut down the
2189          * connection. This prevents stuck sockets.
2190          */
2191         if (unix_writable(sk))
2192                 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
2193
2194         return mask;
2195 }
2196
2197 static unsigned int unix_dgram_poll(struct file *file, struct socket *sock,
2198                                     poll_table *wait)
2199 {
2200         struct sock *sk = sock->sk, *other;
2201         unsigned int mask, writable;
2202
2203         sock_poll_wait(file, sk_sleep(sk), wait);
2204         mask = 0;
2205
2206         /* exceptional events? */
2207         if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
2208                 mask |= POLLERR;
2209         if (sk->sk_shutdown & RCV_SHUTDOWN)
2210                 mask |= POLLRDHUP | POLLIN | POLLRDNORM;
2211         if (sk->sk_shutdown == SHUTDOWN_MASK)
2212                 mask |= POLLHUP;
2213
2214         /* readable? */
2215         if (!skb_queue_empty(&sk->sk_receive_queue))
2216                 mask |= POLLIN | POLLRDNORM;
2217
2218         /* Connection-based need to check for termination and startup */
2219         if (sk->sk_type == SOCK_SEQPACKET) {
2220                 if (sk->sk_state == TCP_CLOSE)
2221                         mask |= POLLHUP;
2222                 /* connection hasn't started yet? */
2223                 if (sk->sk_state == TCP_SYN_SENT)
2224                         return mask;
2225         }
2226
2227         /* No write status requested, avoid expensive OUT tests. */
2228         if (!(poll_requested_events(wait) & (POLLWRBAND|POLLWRNORM|POLLOUT)))
2229                 return mask;
2230
2231         writable = unix_writable(sk);
2232         other = unix_peer_get(sk);
2233         if (other) {
2234                 if (unix_peer(other) != sk) {
2235                         sock_poll_wait(file, &unix_sk(other)->peer_wait, wait);
2236                         if (unix_recvq_full(other))
2237                                 writable = 0;
2238                 }
2239                 sock_put(other);
2240         }
2241
2242         if (writable)
2243                 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
2244         else
2245                 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
2246
2247         return mask;
2248 }
2249
2250 #ifdef CONFIG_PROC_FS
2251
2252 #define BUCKET_SPACE (BITS_PER_LONG - (UNIX_HASH_BITS + 1) - 1)
2253
2254 #define get_bucket(x) ((x) >> BUCKET_SPACE)
2255 #define get_offset(x) ((x) & ((1L << BUCKET_SPACE) - 1))
2256 #define set_bucket_offset(b, o) ((b) << BUCKET_SPACE | (o))
2257
2258 static struct sock *unix_from_bucket(struct seq_file *seq, loff_t *pos)
2259 {
2260         unsigned long offset = get_offset(*pos);
2261         unsigned long bucket = get_bucket(*pos);
2262         struct sock *sk;
2263         unsigned long count = 0;
2264
2265         for (sk = sk_head(&unix_socket_table[bucket]); sk; sk = sk_next(sk)) {
2266                 if (sock_net(sk) != seq_file_net(seq))
2267                         continue;
2268                 if (++count == offset)
2269                         break;
2270         }
2271
2272         return sk;
2273 }
2274
2275 static struct sock *unix_next_socket(struct seq_file *seq,
2276                                      struct sock *sk,
2277                                      loff_t *pos)
2278 {
2279         unsigned long bucket;
2280
2281         while (sk > (struct sock *)SEQ_START_TOKEN) {
2282                 sk = sk_next(sk);
2283                 if (!sk)
2284                         goto next_bucket;
2285                 if (sock_net(sk) == seq_file_net(seq))
2286                         return sk;
2287         }
2288
2289         do {
2290                 sk = unix_from_bucket(seq, pos);
2291                 if (sk)
2292                         return sk;
2293
2294 next_bucket:
2295                 bucket = get_bucket(*pos) + 1;
2296                 *pos = set_bucket_offset(bucket, 1);
2297         } while (bucket < ARRAY_SIZE(unix_socket_table));
2298
2299         return NULL;
2300 }
2301
2302 static void *unix_seq_start(struct seq_file *seq, loff_t *pos)
2303         __acquires(unix_table_lock)
2304 {
2305         spin_lock(&unix_table_lock);
2306
2307         if (!*pos)
2308                 return SEQ_START_TOKEN;
2309
2310         if (get_bucket(*pos) >= ARRAY_SIZE(unix_socket_table))
2311                 return NULL;
2312
2313         return unix_next_socket(seq, NULL, pos);
2314 }
2315
2316 static void *unix_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2317 {
2318         ++*pos;
2319         return unix_next_socket(seq, v, pos);
2320 }
2321
2322 static void unix_seq_stop(struct seq_file *seq, void *v)
2323         __releases(unix_table_lock)
2324 {
2325         spin_unlock(&unix_table_lock);
2326 }
2327
2328 static int unix_seq_show(struct seq_file *seq, void *v)
2329 {
2330
2331         if (v == SEQ_START_TOKEN)
2332                 seq_puts(seq, "Num       RefCount Protocol Flags    Type St "
2333                          "Inode Path\n");
2334         else {
2335                 struct sock *s = v;
2336                 struct unix_sock *u = unix_sk(s);
2337                 unix_state_lock(s);
2338
2339                 seq_printf(seq, "%pK: %08X %08X %08X %04X %02X %5lu",
2340                         s,
2341                         atomic_read(&s->sk_refcnt),
2342                         0,
2343                         s->sk_state == TCP_LISTEN ? __SO_ACCEPTCON : 0,
2344                         s->sk_type,
2345                         s->sk_socket ?
2346                         (s->sk_state == TCP_ESTABLISHED ? SS_CONNECTED : SS_UNCONNECTED) :
2347                         (s->sk_state == TCP_ESTABLISHED ? SS_CONNECTING : SS_DISCONNECTING),
2348                         sock_i_ino(s));
2349
2350                 if (u->addr) {
2351                         int i, len;
2352                         seq_putc(seq, ' ');
2353
2354                         i = 0;
2355                         len = u->addr->len - sizeof(short);
2356                         if (!UNIX_ABSTRACT(s))
2357                                 len--;
2358                         else {
2359                                 seq_putc(seq, '@');
2360                                 i++;
2361                         }
2362                         for ( ; i < len; i++)
2363                                 seq_putc(seq, u->addr->name->sun_path[i]);
2364                 }
2365                 unix_state_unlock(s);
2366                 seq_putc(seq, '\n');
2367         }
2368
2369         return 0;
2370 }
2371
2372 static const struct seq_operations unix_seq_ops = {
2373         .start  = unix_seq_start,
2374         .next   = unix_seq_next,
2375         .stop   = unix_seq_stop,
2376         .show   = unix_seq_show,
2377 };
2378
2379 static int unix_seq_open(struct inode *inode, struct file *file)
2380 {
2381         return seq_open_net(inode, file, &unix_seq_ops,
2382                             sizeof(struct seq_net_private));
2383 }
2384
2385 static const struct file_operations unix_seq_fops = {
2386         .owner          = THIS_MODULE,
2387         .open           = unix_seq_open,
2388         .read           = seq_read,
2389         .llseek         = seq_lseek,
2390         .release        = seq_release_net,
2391 };
2392
2393 #endif
2394
2395 static const struct net_proto_family unix_family_ops = {
2396         .family = PF_UNIX,
2397         .create = unix_create,
2398         .owner  = THIS_MODULE,
2399 };
2400
2401
2402 static int __net_init unix_net_init(struct net *net)
2403 {
2404         int error = -ENOMEM;
2405
2406         net->unx.sysctl_max_dgram_qlen = 10;
2407         if (unix_sysctl_register(net))
2408                 goto out;
2409
2410 #ifdef CONFIG_PROC_FS
2411         if (!proc_net_fops_create(net, "unix", 0, &unix_seq_fops)) {
2412                 unix_sysctl_unregister(net);
2413                 goto out;
2414         }
2415 #endif
2416         error = 0;
2417 out:
2418         return error;
2419 }
2420
2421 static void __net_exit unix_net_exit(struct net *net)
2422 {
2423         unix_sysctl_unregister(net);
2424         proc_net_remove(net, "unix");
2425 }
2426
2427 static struct pernet_operations unix_net_ops = {
2428         .init = unix_net_init,
2429         .exit = unix_net_exit,
2430 };
2431
2432 static int __init af_unix_init(void)
2433 {
2434         int rc = -1;
2435         struct sk_buff *dummy_skb;
2436
2437         BUILD_BUG_ON(sizeof(struct unix_skb_parms) > sizeof(dummy_skb->cb));
2438
2439         rc = proto_register(&unix_proto, 1);
2440         if (rc != 0) {
2441                 printk(KERN_CRIT "%s: Cannot create unix_sock SLAB cache!\n",
2442                        __func__);
2443                 goto out;
2444         }
2445
2446         sock_register(&unix_family_ops);
2447         register_pernet_subsys(&unix_net_ops);
2448 out:
2449         return rc;
2450 }
2451
2452 static void __exit af_unix_exit(void)
2453 {
2454         sock_unregister(PF_UNIX);
2455         proto_unregister(&unix_proto);
2456         unregister_pernet_subsys(&unix_net_ops);
2457 }
2458
2459 /* Earlier than device_initcall() so that other drivers invoking
2460    request_module() don't end up in a loop when modprobe tries
2461    to use a UNIX socket. But later than subsys_initcall() because
2462    we depend on stuff initialised there */
2463 fs_initcall(af_unix_init);
2464 module_exit(af_unix_exit);
2465
2466 MODULE_LICENSE("GPL");
2467 MODULE_ALIAS_NETPROTO(PF_UNIX);