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