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 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  84
  85 #include <linux/module.h>
  86 #include <linux/kernel.h>
  87 #include <linux/signal.h>
  88 #include <linux/sched/signal.h>
  89 #include <linux/errno.h>
  90 #include <linux/string.h>
  91 #include <linux/stat.h>
  92 #include <linux/dcache.h>
  93 #include <linux/namei.h>
  94 #include <linux/socket.h>
  95 #include <linux/un.h>
  96 #include <linux/fcntl.h>
  97 #include <linux/termios.h>
  98 #include <linux/sockios.h>
  99 #include <linux/net.h>
 100 #include <linux/in.h>
 101 #include <linux/fs.h>
 102 #include <linux/slab.h>
 103 #include <linux/uaccess.h>
 104 #include <linux/skbuff.h>
 105 #include <linux/netdevice.h>
 106 #include <net/net_namespace.h>
 107 #include <net/sock.h>
 108 #include <net/tcp_states.h>
 109 #include <net/af_unix.h>
 110 #include <linux/proc_fs.h>
 111 #include <linux/seq_file.h>
 112 #include <net/scm.h>
 113 #include <linux/init.h>
 114 #include <linux/poll.h>
 115 #include <linux/rtnetlink.h>
 116 #include <linux/mount.h>
 117 #include <net/checksum.h>
 118 #include <linux/security.h>
 119 #include <linux/freezer.h>
 120 #include <linux/file.h>
 121
 122 #include "scm.h"
 123
 124 struct hlist_head unix_socket_table[2 * UNIX_HASH_SIZE];
 125 EXPORT_SYMBOL_GPL(unix_socket_table);
 126 DEFINE_SPINLOCK(unix_table_lock);
 127 EXPORT_SYMBOL_GPL(unix_table_lock);
 128 static atomic_long_t unix_nr_socks;
 129
 130
 131 static struct hlist_head *unix_sockets_unbound(void *addr)
 132 {
 133         unsigned long hash = (unsigned long)addr;
 134
 135         hash ^= hash >> 16;
 136         hash ^= hash >> 8;
 137         hash %= UNIX_HASH_SIZE;
 138         return &unix_socket_table[UNIX_HASH_SIZE + hash];
 139 }
 140
 141 #define UNIX_ABSTRACT(sk)       (unix_sk(sk)->addr->hash < UNIX_HASH_SIZE)
 142
 143 #ifdef CONFIG_SECURITY_NETWORK
 144 static void unix_get_secdata(struct scm_cookie *scm, struct sk_buff *skb)
 145 {
 146         UNIXCB(skb).secid = scm->secid;
 147 }
 148
 149 static inline void unix_set_secdata(struct scm_cookie *scm, struct sk_buff *skb)
 150 {
 151         scm->secid = UNIXCB(skb).secid;
 152 }
 153
 154 static inline bool unix_secdata_eq(struct scm_cookie *scm, struct sk_buff *skb)
 155 {
 156         return (scm->secid == UNIXCB(skb).secid);
 157 }
 158 #else
 159 static inline void unix_get_secdata(struct scm_cookie *scm, struct sk_buff *skb)
 160 { }
 161
 162 static inline void unix_set_secdata(struct scm_cookie *scm, struct sk_buff *skb)
 163 { }
 164
 165 static inline bool unix_secdata_eq(struct scm_cookie *scm, struct sk_buff *skb)
 166 {
 167         return true;
 168 }
 169 #endif /* CONFIG_SECURITY_NETWORK */
 170
 171 /*
 172  *  SMP locking strategy:
 173  *    hash table is protected with spinlock unix_table_lock
 174  *    each socket state is protected by separate spin lock.
 175  */
 176
 177 static inline unsigned int unix_hash_fold(__wsum n)
 178 {
 179         unsigned int hash = (__force unsigned int)csum_fold(n);
 180
 181         hash ^= hash>>8;
 182         return hash&(UNIX_HASH_SIZE-1);
 183 }
 184
 185 #define unix_peer(sk) (unix_sk(sk)->peer)
 186
 187 static inline int unix_our_peer(struct sock *sk, struct sock *osk)
 188 {
 189         return unix_peer(osk) == sk;
 190 }
 191
 192 static inline int unix_may_send(struct sock *sk, struct sock *osk)
 193 {
 194         return unix_peer(osk) == NULL || unix_our_peer(sk, osk);
 195 }
 196
 197 static inline int unix_recvq_full(const struct sock *sk)
 198 {
 199         return skb_queue_len(&sk->sk_receive_queue) > sk->sk_max_ack_backlog;
 200 }
 201
 202 static inline int unix_recvq_full_lockless(const struct sock *sk)
 203 {
 204         return skb_queue_len_lockless(&sk->sk_receive_queue) >
 205                 READ_ONCE(sk->sk_max_ack_backlog);
 206 }
 207
 208 struct sock *unix_peer_get(struct sock *s)
 209 {
 210         struct sock *peer;
 211
 212         unix_state_lock(s);
 213         peer = unix_peer(s);
 214         if (peer)
 215                 sock_hold(peer);
 216         unix_state_unlock(s);
 217         return peer;
 218 }
 219 EXPORT_SYMBOL_GPL(unix_peer_get);
 220
 221 static inline void unix_release_addr(struct unix_address *addr)
 222 {
 223         if (refcount_dec_and_test(&addr->refcnt))
 224                 kfree(addr);
 225 }
 226
 227 /*
 228  *      Check unix socket name:
 229  *              - should be not zero length.
 230  *              - if started by not zero, should be NULL terminated (FS object)
 231  *              - if started by zero, it is abstract name.
 232  */
 233
 234 static int unix_mkname(struct sockaddr_un *sunaddr, int len, unsigned int *hashp)
 235 {
 236         *hashp = 0;
 237
 238         if (len <= sizeof(short) || len > sizeof(*sunaddr))
 239                 return -EINVAL;
 240         if (!sunaddr || sunaddr->sun_family != AF_UNIX)
 241                 return -EINVAL;
 242         if (sunaddr->sun_path[0]) {
 243                 /*
 244                  * This may look like an off by one error but it is a bit more
 245                  * subtle. 108 is the longest valid AF_UNIX path for a binding.
 246                  * sun_path[108] doesn't as such exist.  However in kernel space
 247                  * we are guaranteed that it is a valid memory location in our
 248                  * kernel address buffer.
 249                  */
 250                 ((char *)sunaddr)[len] = 0;
 251                 len = strlen(sunaddr->sun_path)+1+sizeof(short);
 252                 return len;
 253         }
 254
 255         *hashp = unix_hash_fold(csum_partial(sunaddr, len, 0));
 256         return len;
 257 }
 258
 259 static void __unix_remove_socket(struct sock *sk)
 260 {
 261         sk_del_node_init(sk);
 262 }
 263
 264 static void __unix_insert_socket(struct hlist_head *list, struct sock *sk)
 265 {
 266         WARN_ON(!sk_unhashed(sk));
 267         sk_add_node(sk, list);
 268 }
 269
 270 static inline void unix_remove_socket(struct sock *sk)
 271 {
 272         spin_lock(&unix_table_lock);
 273         __unix_remove_socket(sk);
 274         spin_unlock(&unix_table_lock);
 275 }
 276
 277 static inline void unix_insert_socket(struct hlist_head *list, struct sock *sk)
 278 {
 279         spin_lock(&unix_table_lock);
 280         __unix_insert_socket(list, sk);
 281         spin_unlock(&unix_table_lock);
 282 }
 283
 284 static struct sock *__unix_find_socket_byname(struct net *net,
 285                                               struct sockaddr_un *sunname,
 286                                               int len, int type, unsigned int hash)
 287 {
 288         struct sock *s;
 289
 290         sk_for_each(s, &unix_socket_table[hash ^ type]) {
 291                 struct unix_sock *u = unix_sk(s);
 292
 293                 if (!net_eq(sock_net(s), net))
 294                         continue;
 295
 296                 if (u->addr->len == len &&
 297                     !memcmp(u->addr->name, sunname, len))
 298                         goto found;
 299         }
 300         s = NULL;
 301 found:
 302         return s;
 303 }
 304
 305 static inline struct sock *unix_find_socket_byname(struct net *net,
 306                                                    struct sockaddr_un *sunname,
 307                                                    int len, int type,
 308                                                    unsigned int hash)
 309 {
 310         struct sock *s;
 311
 312         spin_lock(&unix_table_lock);
 313         s = __unix_find_socket_byname(net, sunname, len, type, hash);
 314         if (s)
 315                 sock_hold(s);
 316         spin_unlock(&unix_table_lock);
 317         return s;
 318 }
 319
 320 static struct sock *unix_find_socket_byinode(struct inode *i)
 321 {
 322         struct sock *s;
 323
 324         spin_lock(&unix_table_lock);
 325         sk_for_each(s,
 326                     &unix_socket_table[i->i_ino & (UNIX_HASH_SIZE - 1)]) {
 327                 struct dentry *dentry = unix_sk(s)->path.dentry;
 328
 329                 if (dentry && d_backing_inode(dentry) == i) {
 330                         sock_hold(s);
 331                         goto found;
 332                 }
 333         }
 334         s = NULL;
 335 found:
 336         spin_unlock(&unix_table_lock);
 337         return s;
 338 }
 339
 340 /* Support code for asymmetrically connected dgram sockets
 341  *
 342  * If a datagram socket is connected to a socket not itself connected
 343  * to the first socket (eg, /dev/log), clients may only enqueue more
 344  * messages if the present receive queue of the server socket is not
 345  * "too large". This means there's a second writeability condition
 346  * poll and sendmsg need to test. The dgram recv code will do a wake
 347  * up on the peer_wait wait queue of a socket upon reception of a
 348  * datagram which needs to be propagated to sleeping would-be writers
 349  * since these might not have sent anything so far. This can't be
 350  * accomplished via poll_wait because the lifetime of the server
 351  * socket might be less than that of its clients if these break their
 352  * association with it or if the server socket is closed while clients
 353  * are still connected to it and there's no way to inform "a polling
 354  * implementation" that it should let go of a certain wait queue
 355  *
 356  * In order to propagate a wake up, a wait_queue_entry_t of the client
 357  * socket is enqueued on the peer_wait queue of the server socket
 358  * whose wake function does a wake_up on the ordinary client socket
 359  * wait queue. This connection is established whenever a write (or
 360  * poll for write) hit the flow control condition and broken when the
 361  * association to the server socket is dissolved or after a wake up
 362  * was relayed.
 363  */
 364
 365 static int unix_dgram_peer_wake_relay(wait_queue_entry_t *q, unsigned mode, int flags,
 366                                       void *key)
 367 {
 368         struct unix_sock *u;
 369         wait_queue_head_t *u_sleep;
 370
 371         u = container_of(q, struct unix_sock, peer_wake);
 372
 373         __remove_wait_queue(&unix_sk(u->peer_wake.private)->peer_wait,
 374                             q);
 375         u->peer_wake.private = NULL;
 376
 377         /* relaying can only happen while the wq still exists */
 378         u_sleep = sk_sleep(&u->sk);
 379         if (u_sleep)
 380                 wake_up_interruptible_poll(u_sleep, key);
 381
 382         return 0;
 383 }
 384
 385 static int unix_dgram_peer_wake_connect(struct sock *sk, struct sock *other)
 386 {
 387         struct unix_sock *u, *u_other;
 388         int rc;
 389
 390         u = unix_sk(sk);
 391         u_other = unix_sk(other);
 392         rc = 0;
 393         spin_lock(&u_other->peer_wait.lock);
 394
 395         if (!u->peer_wake.private) {
 396                 u->peer_wake.private = other;
 397                 __add_wait_queue(&u_other->peer_wait, &u->peer_wake);
 398
 399                 rc = 1;
 400         }
 401
 402         spin_unlock(&u_other->peer_wait.lock);
 403         return rc;
 404 }
 405
 406 static void unix_dgram_peer_wake_disconnect(struct sock *sk,
 407                                             struct sock *other)
 408 {
 409         struct unix_sock *u, *u_other;
 410
 411         u = unix_sk(sk);
 412         u_other = unix_sk(other);
 413         spin_lock(&u_other->peer_wait.lock);
 414
 415         if (u->peer_wake.private == other) {
 416                 __remove_wait_queue(&u_other->peer_wait, &u->peer_wake);
 417                 u->peer_wake.private = NULL;
 418         }
 419
 420         spin_unlock(&u_other->peer_wait.lock);
 421 }
 422
 423 static void unix_dgram_peer_wake_disconnect_wakeup(struct sock *sk,
 424                                                    struct sock *other)
 425 {
 426         unix_dgram_peer_wake_disconnect(sk, other);
 427         wake_up_interruptible_poll(sk_sleep(sk),
 428                                    POLLOUT |
 429                                    POLLWRNORM |
 430                                    POLLWRBAND);
 431 }
 432
 433 /* preconditions:
 434  *      - unix_peer(sk) == other
 435  *      - association is stable
 436  */
 437 static int unix_dgram_peer_wake_me(struct sock *sk, struct sock *other)
 438 {
 439         int connected;
 440
 441         connected = unix_dgram_peer_wake_connect(sk, other);
 442
 443         if (unix_recvq_full(other))
 444                 return 1;
 445
 446         if (connected)
 447                 unix_dgram_peer_wake_disconnect(sk, other);
 448
 449         return 0;
 450 }
 451
 452 static int unix_writable(const struct sock *sk)
 453 {
 454         return sk->sk_state != TCP_LISTEN &&
 455                (refcount_read(&sk->sk_wmem_alloc) << 2) <= sk->sk_sndbuf;
 456 }
 457
 458 static void unix_write_space(struct sock *sk)
 459 {
 460         struct socket_wq *wq;
 461
 462         rcu_read_lock();
 463         if (unix_writable(sk)) {
 464                 wq = rcu_dereference(sk->sk_wq);
 465                 if (skwq_has_sleeper(wq))
 466                         wake_up_interruptible_sync_poll(&wq->wait,
 467                                 POLLOUT | POLLWRNORM | POLLWRBAND);
 468                 sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
 469         }
 470         rcu_read_unlock();
 471 }
 472
 473 /* When dgram socket disconnects (or changes its peer), we clear its receive
 474  * queue of packets arrived from previous peer. First, it allows to do
 475  * flow control based only on wmem_alloc; second, sk connected to peer
 476  * may receive messages only from that peer. */
 477 static void unix_dgram_disconnected(struct sock *sk, struct sock *other)
 478 {
 479         if (!skb_queue_empty(&sk->sk_receive_queue)) {
 480                 skb_queue_purge(&sk->sk_receive_queue);
 481                 wake_up_interruptible_all(&unix_sk(sk)->peer_wait);
 482
 483                 /* If one link of bidirectional dgram pipe is disconnected,
 484                  * we signal error. Messages are lost. Do not make this,
 485                  * when peer was not connected to us.
 486                  */
 487                 if (!sock_flag(other, SOCK_DEAD) && unix_peer(other) == sk) {
 488                         other->sk_err = ECONNRESET;
 489                         other->sk_error_report(other);
 490                 }
 491         }
 492 }
 493
 494 static void unix_sock_destructor(struct sock *sk)
 495 {
 496         struct unix_sock *u = unix_sk(sk);
 497
 498         skb_queue_purge(&sk->sk_receive_queue);
 499
 500         WARN_ON(refcount_read(&sk->sk_wmem_alloc));
 501         WARN_ON(!sk_unhashed(sk));
 502         WARN_ON(sk->sk_socket);
 503         if (!sock_flag(sk, SOCK_DEAD)) {
 504                 pr_info("Attempt to release alive unix socket: %p\n", sk);
 505                 return;
 506         }
 507
 508         if (u->addr)
 509                 unix_release_addr(u->addr);
 510
 511         atomic_long_dec(&unix_nr_socks);
 512         local_bh_disable();
 513         sock_prot_inuse_add(sock_net(sk), sk->sk_prot, -1);
 514         local_bh_enable();
 515 #ifdef UNIX_REFCNT_DEBUG
 516         pr_debug("UNIX %p is destroyed, %ld are still alive.\n", sk,
 517                 atomic_long_read(&unix_nr_socks));
 518 #endif
 519 }
 520
 521 static void unix_release_sock(struct sock *sk, int embrion)
 522 {
 523         struct unix_sock *u = unix_sk(sk);
 524         struct path path;
 525         struct sock *skpair;
 526         struct sk_buff *skb;
 527         int state;
 528
 529         unix_remove_socket(sk);
 530
 531         /* Clear state */
 532         unix_state_lock(sk);
 533         sock_orphan(sk);
 534         sk->sk_shutdown = SHUTDOWN_MASK;
 535         path         = u->path;
 536         u->path.dentry = NULL;
 537         u->path.mnt = NULL;
 538         state = sk->sk_state;
 539         sk->sk_state = TCP_CLOSE;
 540
 541         skpair = unix_peer(sk);
 542         unix_peer(sk) = NULL;
 543
 544         unix_state_unlock(sk);
 545
 546         wake_up_interruptible_all(&u->peer_wait);
 547
 548         if (skpair != NULL) {
 549                 if (sk->sk_type == SOCK_STREAM || sk->sk_type == SOCK_SEQPACKET) {
 550                         unix_state_lock(skpair);
 551                         /* No more writes */
 552                         skpair->sk_shutdown = SHUTDOWN_MASK;
 553                         if (!skb_queue_empty(&sk->sk_receive_queue) || embrion)
 554                                 skpair->sk_err = ECONNRESET;
 555                         unix_state_unlock(skpair);
 556                         skpair->sk_state_change(skpair);
 557                         sk_wake_async(skpair, SOCK_WAKE_WAITD, POLL_HUP);
 558                 }
 559
 560                 unix_dgram_peer_wake_disconnect(sk, skpair);
 561                 sock_put(skpair); /* It may now die */
 562         }
 563
 564         /* Try to flush out this socket. Throw out buffers at least */
 565
 566         while ((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL) {
 567                 if (state == TCP_LISTEN)
 568                         unix_release_sock(skb->sk, 1);
 569                 /* passed fds are erased in the kfree_skb hook        */
 570                 UNIXCB(skb).consumed = skb->len;
 571                 kfree_skb(skb);
 572         }
 573
 574         if (path.dentry)
 575                 path_put(&path);
 576
 577         sock_put(sk);
 578
 579         /* ---- Socket is dead now and most probably destroyed ---- */
 580
 581         /*
 582          * Fixme: BSD difference: In BSD all sockets connected to us get
 583          *        ECONNRESET and we die on the spot. In Linux we behave
 584          *        like files and pipes do and wait for the last
 585          *        dereference.
 586          *
 587          * Can't we simply set sock->err?
 588          *
 589          *        What the above comment does talk about? --ANK(980817)
 590          */
 591
 592         if (unix_tot_inflight)
 593                 unix_gc();              /* Garbage collect fds */
 594 }
 595
 596 static void init_peercred(struct sock *sk)
 597 {
 598         const struct cred *old_cred;
 599         struct pid *old_pid;
 600
 601         spin_lock(&sk->sk_peer_lock);
 602         old_pid = sk->sk_peer_pid;
 603         old_cred = sk->sk_peer_cred;
 604         sk->sk_peer_pid  = get_pid(task_tgid(current));
 605         sk->sk_peer_cred = get_current_cred();
 606         spin_unlock(&sk->sk_peer_lock);
 607
 608         put_pid(old_pid);
 609         put_cred(old_cred);
 610 }
 611
 612 static void copy_peercred(struct sock *sk, struct sock *peersk)
 613 {
 614         const struct cred *old_cred;
 615         struct pid *old_pid;
 616
 617         if (sk < peersk) {
 618                 spin_lock(&sk->sk_peer_lock);
 619                 spin_lock_nested(&peersk->sk_peer_lock, SINGLE_DEPTH_NESTING);
 620         } else {
 621                 spin_lock(&peersk->sk_peer_lock);
 622                 spin_lock_nested(&sk->sk_peer_lock, SINGLE_DEPTH_NESTING);
 623         }
 624         old_pid = sk->sk_peer_pid;
 625         old_cred = sk->sk_peer_cred;
 626         sk->sk_peer_pid  = get_pid(peersk->sk_peer_pid);
 627         sk->sk_peer_cred = get_cred(peersk->sk_peer_cred);
 628
 629         spin_unlock(&sk->sk_peer_lock);
 630         spin_unlock(&peersk->sk_peer_lock);
 631
 632         put_pid(old_pid);
 633         put_cred(old_cred);
 634 }
 635
 636 static int unix_listen(struct socket *sock, int backlog)
 637 {
 638         int err;
 639         struct sock *sk = sock->sk;
 640         struct unix_sock *u = unix_sk(sk);
 641         struct pid *old_pid = NULL;
 642
 643         err = -EOPNOTSUPP;
 644         if (sock->type != SOCK_STREAM && sock->type != SOCK_SEQPACKET)
 645                 goto out;       /* Only stream/seqpacket sockets accept */
 646         err = -EINVAL;
 647         if (!u->addr)
 648                 goto out;       /* No listens on an unbound socket */
 649         unix_state_lock(sk);
 650         if (sk->sk_state != TCP_CLOSE && sk->sk_state != TCP_LISTEN)
 651                 goto out_unlock;
 652         if (backlog > sk->sk_max_ack_backlog)
 653                 wake_up_interruptible_all(&u->peer_wait);
 654         sk->sk_max_ack_backlog  = backlog;
 655         sk->sk_state            = TCP_LISTEN;
 656         /* set credentials so connect can copy them */
 657         init_peercred(sk);
 658         err = 0;
 659
 660 out_unlock:
 661         unix_state_unlock(sk);
 662         put_pid(old_pid);
 663 out:
 664         return err;
 665 }
 666
 667 static int unix_release(struct socket *);
 668 static int unix_bind(struct socket *, struct sockaddr *, int);
 669 static int unix_stream_connect(struct socket *, struct sockaddr *,
 670                                int addr_len, int flags);
 671 static int unix_socketpair(struct socket *, struct socket *);
 672 static int unix_accept(struct socket *, struct socket *, int, bool);
 673 static int unix_getname(struct socket *, struct sockaddr *, int *, int);
 674 static unsigned int unix_poll(struct file *, struct socket *, poll_table *);
 675 static unsigned int unix_dgram_poll(struct file *, struct socket *,
 676                                     poll_table *);
 677 static int unix_ioctl(struct socket *, unsigned int, unsigned long);
 678 #ifdef CONFIG_COMPAT
 679 static int unix_compat_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg);
 680 #endif
 681 static int unix_shutdown(struct socket *, int);
 682 static int unix_stream_sendmsg(struct socket *, struct msghdr *, size_t);
 683 static int unix_stream_recvmsg(struct socket *, struct msghdr *, size_t, int);
 684 static ssize_t unix_stream_sendpage(struct socket *, struct page *, int offset,
 685                                     size_t size, int flags);
 686 static ssize_t unix_stream_splice_read(struct socket *,  loff_t *ppos,
 687                                        struct pipe_inode_info *, size_t size,
 688                                        unsigned int flags);
 689 static int unix_dgram_sendmsg(struct socket *, struct msghdr *, size_t);
 690 static int unix_dgram_recvmsg(struct socket *, struct msghdr *, size_t, int);
 691 static int unix_dgram_connect(struct socket *, struct sockaddr *,
 692                               int, int);
 693 static int unix_seqpacket_sendmsg(struct socket *, struct msghdr *, size_t);
 694 static int unix_seqpacket_recvmsg(struct socket *, struct msghdr *, size_t,
 695                                   int);
 696
 697 static int unix_set_peek_off(struct sock *sk, int val)
 698 {
 699         struct unix_sock *u = unix_sk(sk);
 700
 701         if (mutex_lock_interruptible(&u->iolock))
 702                 return -EINTR;
 703
 704         sk->sk_peek_off = val;
 705         mutex_unlock(&u->iolock);
 706
 707         return 0;
 708 }
 709
 710
 711 static const struct proto_ops unix_stream_ops = {
 712         .family =       PF_UNIX,
 713         .owner =        THIS_MODULE,
 714         .release =      unix_release,
 715         .bind =         unix_bind,
 716         .connect =      unix_stream_connect,
 717         .socketpair =   unix_socketpair,
 718         .accept =       unix_accept,
 719         .getname =      unix_getname,
 720         .poll =         unix_poll,
 721         .ioctl =        unix_ioctl,
 722 #ifdef CONFIG_COMPAT
 723         .compat_ioctl = unix_compat_ioctl,
 724 #endif
 725         .listen =       unix_listen,
 726         .shutdown =     unix_shutdown,
 727         .setsockopt =   sock_no_setsockopt,
 728         .getsockopt =   sock_no_getsockopt,
 729         .sendmsg =      unix_stream_sendmsg,
 730         .recvmsg =      unix_stream_recvmsg,
 731         .mmap =         sock_no_mmap,
 732         .sendpage =     unix_stream_sendpage,
 733         .splice_read =  unix_stream_splice_read,
 734         .set_peek_off = unix_set_peek_off,
 735 };
 736
 737 static const struct proto_ops unix_dgram_ops = {
 738         .family =       PF_UNIX,
 739         .owner =        THIS_MODULE,
 740         .release =      unix_release,
 741         .bind =         unix_bind,
 742         .connect =      unix_dgram_connect,
 743         .socketpair =   unix_socketpair,
 744         .accept =       sock_no_accept,
 745         .getname =      unix_getname,
 746         .poll =         unix_dgram_poll,
 747         .ioctl =        unix_ioctl,
 748 #ifdef CONFIG_COMPAT
 749         .compat_ioctl = unix_compat_ioctl,
 750 #endif
 751         .listen =       sock_no_listen,
 752         .shutdown =     unix_shutdown,
 753         .setsockopt =   sock_no_setsockopt,
 754         .getsockopt =   sock_no_getsockopt,
 755         .sendmsg =      unix_dgram_sendmsg,
 756         .recvmsg =      unix_dgram_recvmsg,
 757         .mmap =         sock_no_mmap,
 758         .sendpage =     sock_no_sendpage,
 759         .set_peek_off = unix_set_peek_off,
 760 };
 761
 762 static const struct proto_ops unix_seqpacket_ops = {
 763         .family =       PF_UNIX,
 764         .owner =        THIS_MODULE,
 765         .release =      unix_release,
 766         .bind =         unix_bind,
 767         .connect =      unix_stream_connect,
 768         .socketpair =   unix_socketpair,
 769         .accept =       unix_accept,
 770         .getname =      unix_getname,
 771         .poll =         unix_dgram_poll,
 772         .ioctl =        unix_ioctl,
 773 #ifdef CONFIG_COMPAT
 774         .compat_ioctl = unix_compat_ioctl,
 775 #endif
 776         .listen =       unix_listen,
 777         .shutdown =     unix_shutdown,
 778         .setsockopt =   sock_no_setsockopt,
 779         .getsockopt =   sock_no_getsockopt,
 780         .sendmsg =      unix_seqpacket_sendmsg,
 781         .recvmsg =      unix_seqpacket_recvmsg,
 782         .mmap =         sock_no_mmap,
 783         .sendpage =     sock_no_sendpage,
 784         .set_peek_off = unix_set_peek_off,
 785 };
 786
 787 static struct proto unix_proto = {
 788         .name                   = "UNIX",
 789         .owner                  = THIS_MODULE,
 790         .obj_size               = sizeof(struct unix_sock),
 791 };
 792
 793 /*
 794  * AF_UNIX sockets do not interact with hardware, hence they
 795  * dont trigger interrupts - so it's safe for them to have
 796  * bh-unsafe locking for their sk_receive_queue.lock. Split off
 797  * this special lock-class by reinitializing the spinlock key:
 798  */
 799 static struct lock_class_key af_unix_sk_receive_queue_lock_key;
 800
 801 static struct sock *unix_create1(struct net *net, struct socket *sock, int kern)
 802 {
 803         struct sock *sk = NULL;
 804         struct unix_sock *u;
 805
 806         atomic_long_inc(&unix_nr_socks);
 807         if (atomic_long_read(&unix_nr_socks) > 2 * get_max_files())
 808                 goto out;
 809
 810         sk = sk_alloc(net, PF_UNIX, GFP_KERNEL, &unix_proto, kern);
 811         if (!sk)
 812                 goto out;
 813
 814         sock_init_data(sock, sk);
 815         lockdep_set_class(&sk->sk_receive_queue.lock,
 816                                 &af_unix_sk_receive_queue_lock_key);
 817
 818         sk->sk_allocation       = GFP_KERNEL_ACCOUNT;
 819         sk->sk_write_space      = unix_write_space;
 820         sk->sk_max_ack_backlog  = net->unx.sysctl_max_dgram_qlen;
 821         sk->sk_destruct         = unix_sock_destructor;
 822         u         = unix_sk(sk);
 823         u->path.dentry = NULL;
 824         u->path.mnt = NULL;
 825         spin_lock_init(&u->lock);
 826         atomic_long_set(&u->inflight, 0);
 827         INIT_LIST_HEAD(&u->link);
 828         mutex_init(&u->iolock); /* single task reading lock */
 829         mutex_init(&u->bindlock); /* single task binding lock */
 830         init_waitqueue_head(&u->peer_wait);
 831         init_waitqueue_func_entry(&u->peer_wake, unix_dgram_peer_wake_relay);
 832         unix_insert_socket(unix_sockets_unbound(sk), sk);
 833 out:
 834         if (sk == NULL)
 835                 atomic_long_dec(&unix_nr_socks);
 836         else {
 837                 local_bh_disable();
 838                 sock_prot_inuse_add(sock_net(sk), sk->sk_prot, 1);
 839                 local_bh_enable();
 840         }
 841         return sk;
 842 }
 843
 844 static int unix_create(struct net *net, struct socket *sock, int protocol,
 845                        int kern)
 846 {
 847         if (protocol && protocol != PF_UNIX)
 848                 return -EPROTONOSUPPORT;
 849
 850         sock->state = SS_UNCONNECTED;
 851
 852         switch (sock->type) {
 853         case SOCK_STREAM:
 854                 sock->ops = &unix_stream_ops;
 855                 break;
 856                 /*
 857                  *      Believe it or not BSD has AF_UNIX, SOCK_RAW though
 858                  *      nothing uses it.
 859                  */
 860         case SOCK_RAW:
 861                 sock->type = SOCK_DGRAM;
 862         case SOCK_DGRAM:
 863                 sock->ops = &unix_dgram_ops;
 864                 break;
 865         case SOCK_SEQPACKET:
 866                 sock->ops = &unix_seqpacket_ops;
 867                 break;
 868         default:
 869                 return -ESOCKTNOSUPPORT;
 870         }
 871
 872         return unix_create1(net, sock, kern) ? 0 : -ENOMEM;
 873 }
 874
 875 static int unix_release(struct socket *sock)
 876 {
 877         struct sock *sk = sock->sk;
 878
 879         if (!sk)
 880                 return 0;
 881
 882         unix_release_sock(sk, 0);
 883         sock->sk = NULL;
 884
 885         return 0;
 886 }
 887
 888 static int unix_autobind(struct socket *sock)
 889 {
 890         struct sock *sk = sock->sk;
 891         struct net *net = sock_net(sk);
 892         struct unix_sock *u = unix_sk(sk);
 893         static u32 ordernum = 1;
 894         struct unix_address *addr;
 895         int err;
 896         unsigned int retries = 0;
 897
 898         err = mutex_lock_interruptible(&u->bindlock);
 899         if (err)
 900                 return err;
 901
 902         err = 0;
 903         if (u->addr)
 904                 goto out;
 905
 906         err = -ENOMEM;
 907         addr = kzalloc(sizeof(*addr) + sizeof(short) + 16, GFP_KERNEL);
 908         if (!addr)
 909                 goto out;
 910
 911         addr->name->sun_family = AF_UNIX;
 912         refcount_set(&addr->refcnt, 1);
 913
 914 retry:
 915         addr->len = sprintf(addr->name->sun_path+1, "%05x", ordernum) + 1 + sizeof(short);
 916         addr->hash = unix_hash_fold(csum_partial(addr->name, addr->len, 0));
 917
 918         spin_lock(&unix_table_lock);
 919         ordernum = (ordernum+1)&0xFFFFF;
 920
 921         if (__unix_find_socket_byname(net, addr->name, addr->len, sock->type,
 922                                       addr->hash)) {
 923                 spin_unlock(&unix_table_lock);
 924                 /*
 925                  * __unix_find_socket_byname() may take long time if many names
 926                  * are already in use.
 927                  */
 928                 cond_resched();
 929                 /* Give up if all names seems to be in use. */
 930                 if (retries++ == 0xFFFFF) {
 931                         err = -ENOSPC;
 932                         kfree(addr);
 933                         goto out;
 934                 }
 935                 goto retry;
 936         }
 937         addr->hash ^= sk->sk_type;
 938
 939         __unix_remove_socket(sk);
 940         smp_store_release(&u->addr, addr);
 941         __unix_insert_socket(&unix_socket_table[addr->hash], sk);
 942         spin_unlock(&unix_table_lock);
 943         err = 0;
 944
 945 out:    mutex_unlock(&u->bindlock);
 946         return err;
 947 }
 948
 949 static struct sock *unix_find_other(struct net *net,
 950                                     struct sockaddr_un *sunname, int len,
 951                                     int type, unsigned int hash, int *error)
 952 {
 953         struct sock *u;
 954         struct path path;
 955         int err = 0;
 956
 957         if (sunname->sun_path[0]) {
 958                 struct inode *inode;
 959                 err = kern_path(sunname->sun_path, LOOKUP_FOLLOW, &path);
 960                 if (err)
 961                         goto fail;
 962                 inode = d_backing_inode(path.dentry);
 963                 err = inode_permission(inode, MAY_WRITE);
 964                 if (err)
 965                         goto put_fail;
 966
 967                 err = -ECONNREFUSED;
 968                 if (!S_ISSOCK(inode->i_mode))
 969                         goto put_fail;
 970                 u = unix_find_socket_byinode(inode);
 971                 if (!u)
 972                         goto put_fail;
 973
 974                 if (u->sk_type == type)
 975                         touch_atime(&path);
 976
 977                 path_put(&path);
 978
 979                 err = -EPROTOTYPE;
 980                 if (u->sk_type != type) {
 981                         sock_put(u);
 982                         goto fail;
 983                 }
 984         } else {
 985                 err = -ECONNREFUSED;
 986                 u = unix_find_socket_byname(net, sunname, len, type, hash);
 987                 if (u) {
 988                         struct dentry *dentry;
 989                         dentry = unix_sk(u)->path.dentry;
 990                         if (dentry)
 991                                 touch_atime(&unix_sk(u)->path);
 992                 } else
 993                         goto fail;
 994         }
 995         return u;
 996
 997 put_fail:
 998         path_put(&path);
 999 fail:
1000         *error = err;
1001         return NULL;
1002 }
1003
1004 static int unix_mknod(const char *sun_path, umode_t mode, struct path *res)
1005 {
1006         struct dentry *dentry;
1007         struct path path;
1008         int err = 0;
1009         /*
1010          * Get the parent directory, calculate the hash for last
1011          * component.
1012          */
1013         dentry = kern_path_create(AT_FDCWD, sun_path, &path, 0);
1014         err = PTR_ERR(dentry);
1015         if (IS_ERR(dentry))
1016                 return err;
1017
1018         /*
1019          * All right, let's create it.
1020          */
1021         err = security_path_mknod(&path, dentry, mode, 0);
1022         if (!err) {
1023                 err = vfs_mknod(d_inode(path.dentry), dentry, mode, 0);
1024                 if (!err) {
1025                         res->mnt = mntget(path.mnt);
1026                         res->dentry = dget(dentry);
1027                 }
1028         }
1029         done_path_create(&path, dentry);
1030         return err;
1031 }
1032
1033 static int unix_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
1034 {
1035         struct sock *sk = sock->sk;
1036         struct net *net = sock_net(sk);
1037         struct unix_sock *u = unix_sk(sk);
1038         struct sockaddr_un *sunaddr = (struct sockaddr_un *)uaddr;
1039         char *sun_path = sunaddr->sun_path;
1040         int err;
1041         unsigned int hash;
1042         struct unix_address *addr;
1043         struct hlist_head *list;
1044         struct path path = { };
1045
1046         err = -EINVAL;
1047         if (addr_len < offsetofend(struct sockaddr_un, sun_family) ||
1048             sunaddr->sun_family != AF_UNIX)
1049                 goto out;
1050
1051         if (addr_len == sizeof(short)) {
1052                 err = unix_autobind(sock);
1053                 goto out;
1054         }
1055
1056         err = unix_mkname(sunaddr, addr_len, &hash);
1057         if (err < 0)
1058                 goto out;
1059         addr_len = err;
1060
1061         if (sun_path[0]) {
1062                 umode_t mode = S_IFSOCK |
1063                        (SOCK_INODE(sock)->i_mode & ~current_umask());
1064                 err = unix_mknod(sun_path, mode, &path);
1065                 if (err) {
1066                         if (err == -EEXIST)
1067                                 err = -EADDRINUSE;
1068                         goto out;
1069                 }
1070         }
1071
1072         err = mutex_lock_interruptible(&u->bindlock);
1073         if (err)
1074                 goto out_put;
1075
1076         err = -EINVAL;
1077         if (u->addr)
1078                 goto out_up;
1079
1080         err = -ENOMEM;
1081         addr = kmalloc(sizeof(*addr)+addr_len, GFP_KERNEL);
1082         if (!addr)
1083                 goto out_up;
1084
1085         memcpy(addr->name, sunaddr, addr_len);
1086         addr->len = addr_len;
1087         addr->hash = hash ^ sk->sk_type;
1088         refcount_set(&addr->refcnt, 1);
1089
1090         if (sun_path[0]) {
1091                 addr->hash = UNIX_HASH_SIZE;
1092                 hash = d_backing_inode(path.dentry)->i_ino & (UNIX_HASH_SIZE - 1);
1093                 spin_lock(&unix_table_lock);
1094                 u->path = path;
1095                 list = &unix_socket_table[hash];
1096         } else {
1097                 spin_lock(&unix_table_lock);
1098                 err = -EADDRINUSE;
1099                 if (__unix_find_socket_byname(net, sunaddr, addr_len,
1100                                               sk->sk_type, hash)) {
1101                         unix_release_addr(addr);
1102                         goto out_unlock;
1103                 }
1104
1105                 list = &unix_socket_table[addr->hash];
1106         }
1107
1108         err = 0;
1109         __unix_remove_socket(sk);
1110         smp_store_release(&u->addr, addr);
1111         __unix_insert_socket(list, sk);
1112
1113 out_unlock:
1114         spin_unlock(&unix_table_lock);
1115 out_up:
1116         mutex_unlock(&u->bindlock);
1117 out_put:
1118         if (err)
1119                 path_put(&path);
1120 out:
1121         return err;
1122 }
1123
1124 static void unix_state_double_lock(struct sock *sk1, struct sock *sk2)
1125 {
1126         if (unlikely(sk1 == sk2) || !sk2) {
1127                 unix_state_lock(sk1);
1128                 return;
1129         }
1130         if (sk1 < sk2) {
1131                 unix_state_lock(sk1);
1132                 unix_state_lock_nested(sk2);
1133         } else {
1134                 unix_state_lock(sk2);
1135                 unix_state_lock_nested(sk1);
1136         }
1137 }
1138
1139 static void unix_state_double_unlock(struct sock *sk1, struct sock *sk2)
1140 {
1141         if (unlikely(sk1 == sk2) || !sk2) {
1142                 unix_state_unlock(sk1);
1143                 return;
1144         }
1145         unix_state_unlock(sk1);
1146         unix_state_unlock(sk2);
1147 }
1148
1149 static int unix_dgram_connect(struct socket *sock, struct sockaddr *addr,
1150                               int alen, int flags)
1151 {
1152         struct sock *sk = sock->sk;
1153         struct net *net = sock_net(sk);
1154         struct sockaddr_un *sunaddr = (struct sockaddr_un *)addr;
1155         struct sock *other;
1156         unsigned int hash;
1157         int err;
1158
1159         err = -EINVAL;
1160         if (alen < offsetofend(struct sockaddr, sa_family))
1161                 goto out;
1162
1163         if (addr->sa_family != AF_UNSPEC) {
1164                 err = unix_mkname(sunaddr, alen, &hash);
1165                 if (err < 0)
1166                         goto out;
1167                 alen = err;
1168
1169                 if (test_bit(SOCK_PASSCRED, &sock->flags) &&
1170                     !unix_sk(sk)->addr && (err = unix_autobind(sock)) != 0)
1171                         goto out;
1172
1173 restart:
1174                 other = unix_find_other(net, sunaddr, alen, sock->type, hash, &err);
1175                 if (!other)
1176                         goto out;
1177
1178                 unix_state_double_lock(sk, other);
1179
1180                 /* Apparently VFS overslept socket death. Retry. */
1181                 if (sock_flag(other, SOCK_DEAD)) {
1182                         unix_state_double_unlock(sk, other);
1183                         sock_put(other);
1184                         goto restart;
1185                 }
1186
1187                 err = -EPERM;
1188                 if (!unix_may_send(sk, other))
1189                         goto out_unlock;
1190
1191                 err = security_unix_may_send(sk->sk_socket, other->sk_socket);
1192                 if (err)
1193                         goto out_unlock;
1194
1195         } else {
1196                 /*
1197                  *      1003.1g breaking connected state with AF_UNSPEC
1198                  */
1199                 other = NULL;
1200                 unix_state_double_lock(sk, other);
1201         }
1202
1203         /*
1204          * If it was connected, reconnect.
1205          */
1206         if (unix_peer(sk)) {
1207                 struct sock *old_peer = unix_peer(sk);
1208                 unix_peer(sk) = other;
1209                 unix_dgram_peer_wake_disconnect_wakeup(sk, old_peer);
1210
1211                 unix_state_double_unlock(sk, other);
1212
1213                 if (other != old_peer)
1214                         unix_dgram_disconnected(sk, old_peer);
1215                 sock_put(old_peer);
1216         } else {
1217                 unix_peer(sk) = other;
1218                 unix_state_double_unlock(sk, other);
1219         }
1220         return 0;
1221
1222 out_unlock:
1223         unix_state_double_unlock(sk, other);
1224         sock_put(other);
1225 out:
1226         return err;
1227 }
1228
1229 static long unix_wait_for_peer(struct sock *other, long timeo)
1230 {
1231         struct unix_sock *u = unix_sk(other);
1232         int sched;
1233         DEFINE_WAIT(wait);
1234
1235         prepare_to_wait_exclusive(&u->peer_wait, &wait, TASK_INTERRUPTIBLE);
1236
1237         sched = !sock_flag(other, SOCK_DEAD) &&
1238                 !(other->sk_shutdown & RCV_SHUTDOWN) &&
1239                 unix_recvq_full(other);
1240
1241         unix_state_unlock(other);
1242
1243         if (sched)
1244                 timeo = schedule_timeout(timeo);
1245
1246         finish_wait(&u->peer_wait, &wait);
1247         return timeo;
1248 }
1249
1250 static int unix_stream_connect(struct socket *sock, struct sockaddr *uaddr,
1251                                int addr_len, int flags)
1252 {
1253         struct sockaddr_un *sunaddr = (struct sockaddr_un *)uaddr;
1254         struct sock *sk = sock->sk;
1255         struct net *net = sock_net(sk);
1256         struct unix_sock *u = unix_sk(sk), *newu, *otheru;
1257         struct sock *newsk = NULL;
1258         struct sock *other = NULL;
1259         struct sk_buff *skb = NULL;
1260         unsigned int hash;
1261         int st;
1262         int err;
1263         long timeo;
1264
1265         err = unix_mkname(sunaddr, addr_len, &hash);
1266         if (err < 0)
1267                 goto out;
1268         addr_len = err;
1269
1270         if (test_bit(SOCK_PASSCRED, &sock->flags) && !u->addr &&
1271             (err = unix_autobind(sock)) != 0)
1272                 goto out;
1273
1274         timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
1275
1276         /* First of all allocate resources.
1277            If we will make it after state is locked,
1278            we will have to recheck all again in any case.
1279          */
1280
1281         err = -ENOMEM;
1282
1283         /* create new sock for complete connection */
1284         newsk = unix_create1(sock_net(sk), NULL, 0);
1285         if (newsk == NULL)
1286                 goto out;
1287
1288         /* Allocate skb for sending to listening sock */
1289         skb = sock_wmalloc(newsk, 1, 0, GFP_KERNEL);
1290         if (skb == NULL)
1291                 goto out;
1292
1293 restart:
1294         /*  Find listening sock. */
1295         other = unix_find_other(net, sunaddr, addr_len, sk->sk_type, hash, &err);
1296         if (!other)
1297                 goto out;
1298
1299         /* Latch state of peer */
1300         unix_state_lock(other);
1301
1302         /* Apparently VFS overslept socket death. Retry. */
1303         if (sock_flag(other, SOCK_DEAD)) {
1304                 unix_state_unlock(other);
1305                 sock_put(other);
1306                 goto restart;
1307         }
1308
1309         err = -ECONNREFUSED;
1310         if (other->sk_state != TCP_LISTEN)
1311                 goto out_unlock;
1312         if (other->sk_shutdown & RCV_SHUTDOWN)
1313                 goto out_unlock;
1314
1315         if (unix_recvq_full(other)) {
1316                 err = -EAGAIN;
1317                 if (!timeo)
1318                         goto out_unlock;
1319
1320                 timeo = unix_wait_for_peer(other, timeo);
1321
1322                 err = sock_intr_errno(timeo);
1323                 if (signal_pending(current))
1324                         goto out;
1325                 sock_put(other);
1326                 goto restart;
1327         }
1328
1329         /* Latch our state.
1330
1331            It is tricky place. We need to grab our state lock and cannot
1332            drop lock on peer. It is dangerous because deadlock is
1333            possible. Connect to self case and simultaneous
1334            attempt to connect are eliminated by checking socket
1335            state. other is TCP_LISTEN, if sk is TCP_LISTEN we
1336            check this before attempt to grab lock.
1337
1338            Well, and we have to recheck the state after socket locked.
1339          */
1340         st = sk->sk_state;
1341
1342         switch (st) {
1343         case TCP_CLOSE:
1344                 /* This is ok... continue with connect */
1345                 break;
1346         case TCP_ESTABLISHED:
1347                 /* Socket is already connected */
1348                 err = -EISCONN;
1349                 goto out_unlock;
1350         default:
1351                 err = -EINVAL;
1352                 goto out_unlock;
1353         }
1354
1355         unix_state_lock_nested(sk);
1356
1357         if (sk->sk_state != st) {
1358                 unix_state_unlock(sk);
1359                 unix_state_unlock(other);
1360                 sock_put(other);
1361                 goto restart;
1362         }
1363
1364         err = security_unix_stream_connect(sk, other, newsk);
1365         if (err) {
1366                 unix_state_unlock(sk);
1367                 goto out_unlock;
1368         }
1369
1370         /* The way is open! Fastly set all the necessary fields... */
1371
1372         sock_hold(sk);
1373         unix_peer(newsk)        = sk;
1374         newsk->sk_state         = TCP_ESTABLISHED;
1375         newsk->sk_type          = sk->sk_type;
1376         init_peercred(newsk);
1377         newu = unix_sk(newsk);
1378         RCU_INIT_POINTER(newsk->sk_wq, &newu->peer_wq);
1379         otheru = unix_sk(other);
1380
1381         /* copy address information from listening to new sock
1382          *
1383          * The contents of *(otheru->addr) and otheru->path
1384          * are seen fully set up here, since we have found
1385          * otheru in hash under unix_table_lock.  Insertion
1386          * into the hash chain we'd found it in had been done
1387          * in an earlier critical area protected by unix_table_lock,
1388          * the same one where we'd set *(otheru->addr) contents,
1389          * as well as otheru->path and otheru->addr itself.
1390          *
1391          * Using smp_store_release() here to set newu->addr
1392          * is enough to make those stores, as well as stores
1393          * to newu->path visible to anyone who gets newu->addr
1394          * by smp_load_acquire().  IOW, the same warranties
1395          * as for unix_sock instances bound in unix_bind() or
1396          * in unix_autobind().
1397          */
1398         if (otheru->path.dentry) {
1399                 path_get(&otheru->path);
1400                 newu->path = otheru->path;
1401         }
1402         refcount_inc(&otheru->addr->refcnt);
1403         smp_store_release(&newu->addr, otheru->addr);
1404
1405         /* Set credentials */
1406         copy_peercred(sk, other);
1407
1408         sock->state     = SS_CONNECTED;
1409         sk->sk_state    = TCP_ESTABLISHED;
1410         sock_hold(newsk);
1411
1412         smp_mb__after_atomic(); /* sock_hold() does an atomic_inc() */
1413         unix_peer(sk)   = newsk;
1414
1415         unix_state_unlock(sk);
1416
1417         /* take ten and and send info to listening sock */
1418         spin_lock(&other->sk_receive_queue.lock);
1419         __skb_queue_tail(&other->sk_receive_queue, skb);
1420         spin_unlock(&other->sk_receive_queue.lock);
1421         unix_state_unlock(other);
1422         other->sk_data_ready(other);
1423         sock_put(other);
1424         return 0;
1425
1426 out_unlock:
1427         if (other)
1428                 unix_state_unlock(other);
1429
1430 out:
1431         kfree_skb(skb);
1432         if (newsk)
1433                 unix_release_sock(newsk, 0);
1434         if (other)
1435                 sock_put(other);
1436         return err;
1437 }
1438
1439 static int unix_socketpair(struct socket *socka, struct socket *sockb)
1440 {
1441         struct sock *ska = socka->sk, *skb = sockb->sk;
1442
1443         /* Join our sockets back to back */
1444         sock_hold(ska);
1445         sock_hold(skb);
1446         unix_peer(ska) = skb;
1447         unix_peer(skb) = ska;
1448         init_peercred(ska);
1449         init_peercred(skb);
1450
1451         if (ska->sk_type != SOCK_DGRAM) {
1452                 ska->sk_state = TCP_ESTABLISHED;
1453                 skb->sk_state = TCP_ESTABLISHED;
1454                 socka->state  = SS_CONNECTED;
1455                 sockb->state  = SS_CONNECTED;
1456         }
1457         return 0;
1458 }
1459
1460 static void unix_sock_inherit_flags(const struct socket *old,
1461                                     struct socket *new)
1462 {
1463         if (test_bit(SOCK_PASSCRED, &old->flags))
1464                 set_bit(SOCK_PASSCRED, &new->flags);
1465         if (test_bit(SOCK_PASSSEC, &old->flags))
1466                 set_bit(SOCK_PASSSEC, &new->flags);
1467 }
1468
1469 static int unix_accept(struct socket *sock, struct socket *newsock, int flags,
1470                        bool kern)
1471 {
1472         struct sock *sk = sock->sk;
1473         struct sock *tsk;
1474         struct sk_buff *skb;
1475         int err;
1476
1477         err = -EOPNOTSUPP;
1478         if (sock->type != SOCK_STREAM && sock->type != SOCK_SEQPACKET)
1479                 goto out;
1480
1481         err = -EINVAL;
1482         if (sk->sk_state != TCP_LISTEN)
1483                 goto out;
1484
1485         /* If socket state is TCP_LISTEN it cannot change (for now...),
1486          * so that no locks are necessary.
1487          */
1488
1489         skb = skb_recv_datagram(sk, 0, flags&O_NONBLOCK, &err);
1490         if (!skb) {
1491                 /* This means receive shutdown. */
1492                 if (err == 0)
1493                         err = -EINVAL;
1494                 goto out;
1495         }
1496
1497         tsk = skb->sk;
1498         skb_free_datagram(sk, skb);
1499         wake_up_interruptible(&unix_sk(sk)->peer_wait);
1500
1501         /* attach accepted sock to socket */
1502         unix_state_lock(tsk);
1503         newsock->state = SS_CONNECTED;
1504         unix_sock_inherit_flags(sock, newsock);
1505         sock_graft(tsk, newsock);
1506         unix_state_unlock(tsk);
1507         return 0;
1508
1509 out:
1510         return err;
1511 }
1512
1513
1514 static int unix_getname(struct socket *sock, struct sockaddr *uaddr, int *uaddr_len, int peer)
1515 {
1516         struct sock *sk = sock->sk;
1517         struct unix_address *addr;
1518         DECLARE_SOCKADDR(struct sockaddr_un *, sunaddr, uaddr);
1519         int err = 0;
1520
1521         if (peer) {
1522                 sk = unix_peer_get(sk);
1523
1524                 err = -ENOTCONN;
1525                 if (!sk)
1526                         goto out;
1527                 err = 0;
1528         } else {
1529                 sock_hold(sk);
1530         }
1531
1532         addr = smp_load_acquire(&unix_sk(sk)->addr);
1533         if (!addr) {
1534                 sunaddr->sun_family = AF_UNIX;
1535                 sunaddr->sun_path[0] = 0;
1536                 *uaddr_len = sizeof(short);
1537         } else {
1538                 *uaddr_len = addr->len;
1539                 memcpy(sunaddr, addr->name, *uaddr_len);
1540         }
1541         sock_put(sk);
1542 out:
1543         return err;
1544 }
1545
1546 static void unix_peek_fds(struct scm_cookie *scm, struct sk_buff *skb)
1547 {
1548         scm->fp = scm_fp_dup(UNIXCB(skb).fp);
1549
1550         /*
1551          * Garbage collection of unix sockets starts by selecting a set of
1552          * candidate sockets which have reference only from being in flight
1553          * (total_refs == inflight_refs).  This condition is checked once during
1554          * the candidate collection phase, and candidates are marked as such, so
1555          * that non-candidates can later be ignored.  While inflight_refs is
1556          * protected by unix_gc_lock, total_refs (file count) is not, hence this
1557          * is an instantaneous decision.
1558          *
1559          * Once a candidate, however, the socket must not be reinstalled into a
1560          * file descriptor while the garbage collection is in progress.
1561          *
1562          * If the above conditions are met, then the directed graph of
1563          * candidates (*) does not change while unix_gc_lock is held.
1564          *
1565          * Any operations that changes the file count through file descriptors
1566          * (dup, close, sendmsg) does not change the graph since candidates are
1567          * not installed in fds.
1568          *
1569          * Dequeing a candidate via recvmsg would install it into an fd, but
1570          * that takes unix_gc_lock to decrement the inflight count, so it's
1571          * serialized with garbage collection.
1572          *
1573          * MSG_PEEK is special in that it does not change the inflight count,
1574          * yet does install the socket into an fd.  The following lock/unlock
1575          * pair is to ensure serialization with garbage collection.  It must be
1576          * done between incrementing the file count and installing the file into
1577          * an fd.
1578          *
1579          * If garbage collection starts after the barrier provided by the
1580          * lock/unlock, then it will see the elevated refcount and not mark this
1581          * as a candidate.  If a garbage collection is already in progress
1582          * before the file count was incremented, then the lock/unlock pair will
1583          * ensure that garbage collection is finished before progressing to
1584          * installing the fd.
1585          *
1586          * (*) A -> B where B is on the queue of A or B is on the queue of C
1587          * which is on the queue of listening socket A.
1588          */
1589         spin_lock(&unix_gc_lock);
1590         spin_unlock(&unix_gc_lock);
1591 }
1592
1593 static int unix_scm_to_skb(struct scm_cookie *scm, struct sk_buff *skb, bool send_fds)
1594 {
1595         int err = 0;
1596
1597         UNIXCB(skb).pid  = get_pid(scm->pid);
1598         UNIXCB(skb).uid = scm->creds.uid;
1599         UNIXCB(skb).gid = scm->creds.gid;
1600         UNIXCB(skb).fp = NULL;
1601         unix_get_secdata(scm, skb);
1602         if (scm->fp && send_fds)
1603                 err = unix_attach_fds(scm, skb);
1604
1605         skb->destructor = unix_destruct_scm;
1606         return err;
1607 }
1608
1609 static bool unix_passcred_enabled(const struct socket *sock,
1610                                   const struct sock *other)
1611 {
1612         return test_bit(SOCK_PASSCRED, &sock->flags) ||
1613                !other->sk_socket ||
1614                test_bit(SOCK_PASSCRED, &other->sk_socket->flags);
1615 }
1616
1617 /*
1618  * Some apps rely on write() giving SCM_CREDENTIALS
1619  * We include credentials if source or destination socket
1620  * asserted SOCK_PASSCRED.
1621  */
1622 static void maybe_add_creds(struct sk_buff *skb, const struct socket *sock,
1623                             const struct sock *other)
1624 {
1625         if (UNIXCB(skb).pid)
1626                 return;
1627         if (unix_passcred_enabled(sock, other)) {
1628                 UNIXCB(skb).pid  = get_pid(task_tgid(current));
1629                 current_uid_gid(&UNIXCB(skb).uid, &UNIXCB(skb).gid);
1630         }
1631 }
1632
1633 static int maybe_init_creds(struct scm_cookie *scm,
1634                             struct socket *socket,
1635                             const struct sock *other)
1636 {
1637         int err;
1638         struct msghdr msg = { .msg_controllen = 0 };
1639
1640         err = scm_send(socket, &msg, scm, false);
1641         if (err)
1642                 return err;
1643
1644         if (unix_passcred_enabled(socket, other)) {
1645                 scm->pid = get_pid(task_tgid(current));
1646                 current_uid_gid(&scm->creds.uid, &scm->creds.gid);
1647         }
1648         return err;
1649 }
1650
1651 static bool unix_skb_scm_eq(struct sk_buff *skb,
1652                             struct scm_cookie *scm)
1653 {
1654         const struct unix_skb_parms *u = &UNIXCB(skb);
1655
1656         return u->pid == scm->pid &&
1657                uid_eq(u->uid, scm->creds.uid) &&
1658                gid_eq(u->gid, scm->creds.gid) &&
1659                unix_secdata_eq(scm, skb);
1660 }
1661
1662 /*
1663  *      Send AF_UNIX data.
1664  */
1665
1666 static int unix_dgram_sendmsg(struct socket *sock, struct msghdr *msg,
1667                               size_t len)
1668 {
1669         struct sock *sk = sock->sk;
1670         struct net *net = sock_net(sk);
1671         struct unix_sock *u = unix_sk(sk);
1672         DECLARE_SOCKADDR(struct sockaddr_un *, sunaddr, msg->msg_name);
1673         struct sock *other = NULL;
1674         int namelen = 0; /* fake GCC */
1675         int err;
1676         unsigned int hash;
1677         struct sk_buff *skb;
1678         long timeo;
1679         struct scm_cookie scm;
1680         int data_len = 0;
1681         int sk_locked;
1682
1683         wait_for_unix_gc();
1684         err = scm_send(sock, msg, &scm, false);
1685         if (err < 0)
1686                 return err;
1687
1688         err = -EOPNOTSUPP;
1689         if (msg->msg_flags&MSG_OOB)
1690                 goto out;
1691
1692         if (msg->msg_namelen) {
1693                 err = unix_mkname(sunaddr, msg->msg_namelen, &hash);
1694                 if (err < 0)
1695                         goto out;
1696                 namelen = err;
1697         } else {
1698                 sunaddr = NULL;
1699                 err = -ENOTCONN;
1700                 other = unix_peer_get(sk);
1701                 if (!other)
1702                         goto out;
1703         }
1704
1705         if (test_bit(SOCK_PASSCRED, &sock->flags) && !u->addr
1706             && (err = unix_autobind(sock)) != 0)
1707                 goto out;
1708
1709         err = -EMSGSIZE;
1710         if (len > sk->sk_sndbuf - 32)
1711                 goto out;
1712
1713         if (len > SKB_MAX_ALLOC) {
1714                 data_len = min_t(size_t,
1715                                  len - SKB_MAX_ALLOC,
1716                                  MAX_SKB_FRAGS * PAGE_SIZE);
1717                 data_len = PAGE_ALIGN(data_len);
1718
1719                 BUILD_BUG_ON(SKB_MAX_ALLOC < PAGE_SIZE);
1720         }
1721
1722         skb = sock_alloc_send_pskb(sk, len - data_len, data_len,
1723                                    msg->msg_flags & MSG_DONTWAIT, &err,
1724                                    PAGE_ALLOC_COSTLY_ORDER);
1725         if (skb == NULL)
1726                 goto out;
1727
1728         err = unix_scm_to_skb(&scm, skb, true);
1729         if (err < 0)
1730                 goto out_free;
1731
1732         skb_put(skb, len - data_len);
1733         skb->data_len = data_len;
1734         skb->len = len;
1735         err = skb_copy_datagram_from_iter(skb, 0, &msg->msg_iter, len);
1736         if (err)
1737                 goto out_free;
1738
1739         timeo = sock_sndtimeo(sk, msg->msg_flags & MSG_DONTWAIT);
1740
1741 restart:
1742         if (!other) {
1743                 err = -ECONNRESET;
1744                 if (sunaddr == NULL)
1745                         goto out_free;
1746
1747                 other = unix_find_other(net, sunaddr, namelen, sk->sk_type,
1748                                         hash, &err);
1749                 if (other == NULL)
1750                         goto out_free;
1751         }
1752
1753         if (sk_filter(other, skb) < 0) {
1754                 /* Toss the packet but do not return any error to the sender */
1755                 err = len;
1756                 goto out_free;
1757         }
1758
1759         sk_locked = 0;
1760         unix_state_lock(other);
1761 restart_locked:
1762         err = -EPERM;
1763         if (!unix_may_send(sk, other))
1764                 goto out_unlock;
1765
1766         if (unlikely(sock_flag(other, SOCK_DEAD))) {
1767                 /*
1768                  *      Check with 1003.1g - what should
1769                  *      datagram error
1770                  */
1771                 unix_state_unlock(other);
1772                 sock_put(other);
1773
1774                 if (!sk_locked)
1775                         unix_state_lock(sk);
1776
1777                 err = 0;
1778                 if (unix_peer(sk) == other) {
1779                         unix_peer(sk) = NULL;
1780                         unix_dgram_peer_wake_disconnect_wakeup(sk, other);
1781
1782                         unix_state_unlock(sk);
1783
1784                         unix_dgram_disconnected(sk, other);
1785                         sock_put(other);
1786                         err = -ECONNREFUSED;
1787                 } else {
1788                         unix_state_unlock(sk);
1789                 }
1790
1791                 other = NULL;
1792                 if (err)
1793                         goto out_free;
1794                 goto restart;
1795         }
1796
1797         err = -EPIPE;
1798         if (other->sk_shutdown & RCV_SHUTDOWN)
1799                 goto out_unlock;
1800
1801         if (sk->sk_type != SOCK_SEQPACKET) {
1802                 err = security_unix_may_send(sk->sk_socket, other->sk_socket);
1803                 if (err)
1804                         goto out_unlock;
1805         }
1806
1807         /* other == sk && unix_peer(other) != sk if
1808          * - unix_peer(sk) == NULL, destination address bound to sk
1809          * - unix_peer(sk) == sk by time of get but disconnected before lock
1810          */
1811         if (other != sk &&
1812             unlikely(unix_peer(other) != sk &&
1813             unix_recvq_full_lockless(other))) {
1814                 if (timeo) {
1815                         timeo = unix_wait_for_peer(other, timeo);
1816
1817                         err = sock_intr_errno(timeo);
1818                         if (signal_pending(current))
1819                                 goto out_free;
1820
1821                         goto restart;
1822                 }
1823
1824                 if (!sk_locked) {
1825                         unix_state_unlock(other);
1826                         unix_state_double_lock(sk, other);
1827                 }
1828
1829                 if (unix_peer(sk) != other ||
1830                     unix_dgram_peer_wake_me(sk, other)) {
1831                         err = -EAGAIN;
1832                         sk_locked = 1;
1833                         goto out_unlock;
1834                 }
1835
1836                 if (!sk_locked) {
1837                         sk_locked = 1;
1838                         goto restart_locked;
1839                 }
1840         }
1841
1842         if (unlikely(sk_locked))
1843                 unix_state_unlock(sk);
1844
1845         if (sock_flag(other, SOCK_RCVTSTAMP))
1846                 __net_timestamp(skb);
1847         maybe_add_creds(skb, sock, other);
1848         skb_queue_tail(&other->sk_receive_queue, skb);
1849         unix_state_unlock(other);
1850         other->sk_data_ready(other);
1851         sock_put(other);
1852         scm_destroy(&scm);
1853         return len;
1854
1855 out_unlock:
1856         if (sk_locked)
1857                 unix_state_unlock(sk);
1858         unix_state_unlock(other);
1859 out_free:
1860         kfree_skb(skb);
1861 out:
1862         if (other)
1863                 sock_put(other);
1864         scm_destroy(&scm);
1865         return err;
1866 }
1867
1868 /* We use paged skbs for stream sockets, and limit occupancy to 32768
1869  * bytes, and a minimun of a full page.
1870  */
1871 #define UNIX_SKB_FRAGS_SZ (PAGE_SIZE << get_order(32768))
1872
1873 static int unix_stream_sendmsg(struct socket *sock, struct msghdr *msg,
1874                                size_t len)
1875 {
1876         struct sock *sk = sock->sk;
1877         struct sock *other = NULL;
1878         int err, size;
1879         struct sk_buff *skb;
1880         int sent = 0;
1881         struct scm_cookie scm;
1882         bool fds_sent = false;
1883         int data_len;
1884
1885         wait_for_unix_gc();
1886         err = scm_send(sock, msg, &scm, false);
1887         if (err < 0)
1888                 return err;
1889
1890         err = -EOPNOTSUPP;
1891         if (msg->msg_flags&MSG_OOB)
1892                 goto out_err;
1893
1894         if (msg->msg_namelen) {
1895                 err = sk->sk_state == TCP_ESTABLISHED ? -EISCONN : -EOPNOTSUPP;
1896                 goto out_err;
1897         } else {
1898                 err = -ENOTCONN;
1899                 other = unix_peer(sk);
1900                 if (!other)
1901                         goto out_err;
1902         }
1903
1904         if (sk->sk_shutdown & SEND_SHUTDOWN)
1905                 goto pipe_err;
1906
1907         while (sent < len) {
1908                 size = len - sent;
1909
1910                 /* Keep two messages in the pipe so it schedules better */
1911                 size = min_t(int, size, (sk->sk_sndbuf >> 1) - 64);
1912
1913                 /* allow fallback to order-0 allocations */
1914                 size = min_t(int, size, SKB_MAX_HEAD(0) + UNIX_SKB_FRAGS_SZ);
1915
1916                 data_len = max_t(int, 0, size - SKB_MAX_HEAD(0));
1917
1918                 data_len = min_t(size_t, size, PAGE_ALIGN(data_len));
1919
1920                 skb = sock_alloc_send_pskb(sk, size - data_len, data_len,
1921                                            msg->msg_flags & MSG_DONTWAIT, &err,
1922                                            get_order(UNIX_SKB_FRAGS_SZ));
1923                 if (!skb)
1924                         goto out_err;
1925
1926                 /* Only send the fds in the first buffer */
1927                 err = unix_scm_to_skb(&scm, skb, !fds_sent);
1928                 if (err < 0) {
1929                         kfree_skb(skb);
1930                         goto out_err;
1931                 }
1932                 fds_sent = true;
1933
1934                 skb_put(skb, size - data_len);
1935                 skb->data_len = data_len;
1936                 skb->len = size;
1937                 err = skb_copy_datagram_from_iter(skb, 0, &msg->msg_iter, size);
1938                 if (err) {
1939                         kfree_skb(skb);
1940                         goto out_err;
1941                 }
1942
1943                 unix_state_lock(other);
1944
1945                 if (sock_flag(other, SOCK_DEAD) ||
1946                     (other->sk_shutdown & RCV_SHUTDOWN))
1947                         goto pipe_err_free;
1948
1949                 maybe_add_creds(skb, sock, other);
1950                 skb_queue_tail(&other->sk_receive_queue, skb);
1951                 unix_state_unlock(other);
1952                 other->sk_data_ready(other);
1953                 sent += size;
1954         }
1955
1956         scm_destroy(&scm);
1957
1958         return sent;
1959
1960 pipe_err_free:
1961         unix_state_unlock(other);
1962         kfree_skb(skb);
1963 pipe_err:
1964         if (sent == 0 && !(msg->msg_flags&MSG_NOSIGNAL))
1965                 send_sig(SIGPIPE, current, 0);
1966         err = -EPIPE;
1967 out_err:
1968         scm_destroy(&scm);
1969         return sent ? : err;
1970 }
1971
1972 static ssize_t unix_stream_sendpage(struct socket *socket, struct page *page,
1973                                     int offset, size_t size, int flags)
1974 {
1975         int err;
1976         bool send_sigpipe = false;
1977         bool init_scm = true;
1978         struct scm_cookie scm;
1979         struct sock *other, *sk = socket->sk;
1980         struct sk_buff *skb, *newskb = NULL, *tail = NULL;
1981
1982         if (flags & MSG_OOB)
1983                 return -EOPNOTSUPP;
1984
1985         other = unix_peer(sk);
1986         if (!other || sk->sk_state != TCP_ESTABLISHED)
1987                 return -ENOTCONN;
1988
1989         if (false) {
1990 alloc_skb:
1991                 unix_state_unlock(other);
1992                 mutex_unlock(&unix_sk(other)->iolock);
1993                 newskb = sock_alloc_send_pskb(sk, 0, 0, flags & MSG_DONTWAIT,
1994                                               &err, 0);
1995                 if (!newskb)
1996                         goto err;
1997         }
1998
1999         /* we must acquire iolock as we modify already present
2000          * skbs in the sk_receive_queue and mess with skb->len
2001          */
2002         err = mutex_lock_interruptible(&unix_sk(other)->iolock);
2003         if (err) {
2004                 err = flags & MSG_DONTWAIT ? -EAGAIN : -ERESTARTSYS;
2005                 goto err;
2006         }
2007
2008         if (sk->sk_shutdown & SEND_SHUTDOWN) {
2009                 err = -EPIPE;
2010                 send_sigpipe = true;
2011                 goto err_unlock;
2012         }
2013
2014         unix_state_lock(other);
2015
2016         if (sock_flag(other, SOCK_DEAD) ||
2017             other->sk_shutdown & RCV_SHUTDOWN) {
2018                 err = -EPIPE;
2019                 send_sigpipe = true;
2020                 goto err_state_unlock;
2021         }
2022
2023         if (init_scm) {
2024                 err = maybe_init_creds(&scm, socket, other);
2025                 if (err)
2026                         goto err_state_unlock;
2027                 init_scm = false;
2028         }
2029
2030         skb = skb_peek_tail(&other->sk_receive_queue);
2031         if (tail && tail == skb) {
2032                 skb = newskb;
2033         } else if (!skb || !unix_skb_scm_eq(skb, &scm)) {
2034                 if (newskb) {
2035                         skb = newskb;
2036                 } else {
2037                         tail = skb;
2038                         goto alloc_skb;
2039                 }
2040         } else if (newskb) {
2041                 /* this is fast path, we don't necessarily need to
2042                  * call to kfree_skb even though with newskb == NULL
2043                  * this - does no harm
2044                  */
2045                 consume_skb(newskb);
2046                 newskb = NULL;
2047         }
2048
2049         if (skb_append_pagefrags(skb, page, offset, size)) {
2050                 tail = skb;
2051                 goto alloc_skb;
2052         }
2053
2054         skb->len += size;
2055         skb->data_len += size;
2056         skb->truesize += size;
2057         refcount_add(size, &sk->sk_wmem_alloc);
2058
2059         if (newskb) {
2060                 err = unix_scm_to_skb(&scm, skb, false);
2061                 if (err)
2062                         goto err_state_unlock;
2063                 spin_lock(&other->sk_receive_queue.lock);
2064                 __skb_queue_tail(&other->sk_receive_queue, newskb);
2065                 spin_unlock(&other->sk_receive_queue.lock);
2066         }
2067
2068         unix_state_unlock(other);
2069         mutex_unlock(&unix_sk(other)->iolock);
2070
2071         other->sk_data_ready(other);
2072         scm_destroy(&scm);
2073         return size;
2074
2075 err_state_unlock:
2076         unix_state_unlock(other);
2077 err_unlock:
2078         mutex_unlock(&unix_sk(other)->iolock);
2079 err:
2080         kfree_skb(newskb);
2081         if (send_sigpipe && !(flags & MSG_NOSIGNAL))
2082                 send_sig(SIGPIPE, current, 0);
2083         if (!init_scm)
2084                 scm_destroy(&scm);
2085         return err;
2086 }
2087
2088 static int unix_seqpacket_sendmsg(struct socket *sock, struct msghdr *msg,
2089                                   size_t len)
2090 {
2091         int err;
2092         struct sock *sk = sock->sk;
2093
2094         err = sock_error(sk);
2095         if (err)
2096                 return err;
2097
2098         if (sk->sk_state != TCP_ESTABLISHED)
2099                 return -ENOTCONN;
2100
2101         if (msg->msg_namelen)
2102                 msg->msg_namelen = 0;
2103
2104         return unix_dgram_sendmsg(sock, msg, len);
2105 }
2106
2107 static int unix_seqpacket_recvmsg(struct socket *sock, struct msghdr *msg,
2108                                   size_t size, int flags)
2109 {
2110         struct sock *sk = sock->sk;
2111
2112         if (sk->sk_state != TCP_ESTABLISHED)
2113                 return -ENOTCONN;
2114
2115         return unix_dgram_recvmsg(sock, msg, size, flags);
2116 }
2117
2118 static void unix_copy_addr(struct msghdr *msg, struct sock *sk)
2119 {
2120         struct unix_address *addr = smp_load_acquire(&unix_sk(sk)->addr);
2121
2122         if (addr) {
2123                 msg->msg_namelen = addr->len;
2124                 memcpy(msg->msg_name, addr->name, addr->len);
2125         }
2126 }
2127
2128 static int unix_dgram_recvmsg(struct socket *sock, struct msghdr *msg,
2129                               size_t size, int flags)
2130 {
2131         struct scm_cookie scm;
2132         struct sock *sk = sock->sk;
2133         struct unix_sock *u = unix_sk(sk);
2134         struct sk_buff *skb, *last;
2135         long timeo;
2136         int err;
2137         int peeked, skip;
2138
2139         err = -EOPNOTSUPP;
2140         if (flags&MSG_OOB)
2141                 goto out;
2142
2143         timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
2144
2145         do {
2146                 mutex_lock(&u->iolock);
2147
2148                 skip = sk_peek_offset(sk, flags);
2149                 skb = __skb_try_recv_datagram(sk, flags, NULL, &peeked, &skip,
2150                                               &err, &last);
2151                 if (skb)
2152                         break;
2153
2154                 mutex_unlock(&u->iolock);
2155
2156                 if (err != -EAGAIN)
2157                         break;
2158         } while (timeo &&
2159                  !__skb_wait_for_more_packets(sk, &err, &timeo, last));
2160
2161         if (!skb) { /* implies iolock unlocked */
2162                 unix_state_lock(sk);
2163                 /* Signal EOF on disconnected non-blocking SEQPACKET socket. */
2164                 if (sk->sk_type == SOCK_SEQPACKET && err == -EAGAIN &&
2165                     (sk->sk_shutdown & RCV_SHUTDOWN))
2166                         err = 0;
2167                 unix_state_unlock(sk);
2168                 goto out;
2169         }
2170
2171         if (wq_has_sleeper(&u->peer_wait))
2172                 wake_up_interruptible_sync_poll(&u->peer_wait,
2173                                                 POLLOUT | POLLWRNORM |
2174                                                 POLLWRBAND);
2175
2176         if (msg->msg_name)
2177                 unix_copy_addr(msg, skb->sk);
2178
2179         if (size > skb->len - skip)
2180                 size = skb->len - skip;
2181         else if (size < skb->len - skip)
2182                 msg->msg_flags |= MSG_TRUNC;
2183
2184         err = skb_copy_datagram_msg(skb, skip, msg, size);
2185         if (err)
2186                 goto out_free;
2187
2188         if (sock_flag(sk, SOCK_RCVTSTAMP))
2189                 __sock_recv_timestamp(msg, sk, skb);
2190
2191         memset(&scm, 0, sizeof(scm));
2192
2193         scm_set_cred(&scm, UNIXCB(skb).pid, UNIXCB(skb).uid, UNIXCB(skb).gid);
2194         unix_set_secdata(&scm, skb);
2195
2196         if (!(flags & MSG_PEEK)) {
2197                 if (UNIXCB(skb).fp)
2198                         unix_detach_fds(&scm, skb);
2199
2200                 sk_peek_offset_bwd(sk, skb->len);
2201         } else {
2202                 /* It is questionable: on PEEK we could:
2203                    - do not return fds - good, but too simple 8)
2204                    - return fds, and do not return them on read (old strategy,
2205                      apparently wrong)
2206                    - clone fds (I chose it for now, it is the most universal
2207                      solution)
2208
2209                    POSIX 1003.1g does not actually define this clearly
2210                    at all. POSIX 1003.1g doesn't define a lot of things
2211                    clearly however!
2212
2213                 */
2214
2215                 sk_peek_offset_fwd(sk, size);
2216
2217                 if (UNIXCB(skb).fp)
2218                         unix_peek_fds(&scm, skb);
2219         }
2220         err = (flags & MSG_TRUNC) ? skb->len - skip : size;
2221
2222         scm_recv(sock, msg, &scm, flags);
2223
2224 out_free:
2225         skb_free_datagram(sk, skb);
2226         mutex_unlock(&u->iolock);
2227 out:
2228         return err;
2229 }
2230
2231 /*
2232  *      Sleep until more data has arrived. But check for races..
2233  */
2234 static long unix_stream_data_wait(struct sock *sk, long timeo,
2235                                   struct sk_buff *last, unsigned int last_len,
2236                                   bool freezable)
2237 {
2238         struct sk_buff *tail;
2239         DEFINE_WAIT(wait);
2240
2241         unix_state_lock(sk);
2242
2243         for (;;) {
2244                 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
2245
2246                 tail = skb_peek_tail(&sk->sk_receive_queue);
2247                 if (tail != last ||
2248                     (tail && tail->len != last_len) ||
2249                     sk->sk_err ||
2250                     (sk->sk_shutdown & RCV_SHUTDOWN) ||
2251                     signal_pending(current) ||
2252                     !timeo)
2253                         break;
2254
2255                 sk_set_bit(SOCKWQ_ASYNC_WAITDATA, sk);
2256                 unix_state_unlock(sk);
2257                 if (freezable)
2258                         timeo = freezable_schedule_timeout(timeo);
2259                 else
2260                         timeo = schedule_timeout(timeo);
2261                 unix_state_lock(sk);
2262
2263                 if (sock_flag(sk, SOCK_DEAD))
2264                         break;
2265
2266                 sk_clear_bit(SOCKWQ_ASYNC_WAITDATA, sk);
2267         }
2268
2269         finish_wait(sk_sleep(sk), &wait);
2270         unix_state_unlock(sk);
2271         return timeo;
2272 }
2273
2274 static unsigned int unix_skb_len(const struct sk_buff *skb)
2275 {
2276         return skb->len - UNIXCB(skb).consumed;
2277 }
2278
2279 struct unix_stream_read_state {
2280         int (*recv_actor)(struct sk_buff *, int, int,
2281                           struct unix_stream_read_state *);
2282         struct socket *socket;
2283         struct msghdr *msg;
2284         struct pipe_inode_info *pipe;
2285         size_t size;
2286         int flags;
2287         unsigned int splice_flags;
2288 };
2289
2290 static int unix_stream_read_generic(struct unix_stream_read_state *state,
2291                                     bool freezable)
2292 {
2293         struct scm_cookie scm;
2294         struct socket *sock = state->socket;
2295         struct sock *sk = sock->sk;
2296         struct unix_sock *u = unix_sk(sk);
2297         int copied = 0;
2298         int flags = state->flags;
2299         int noblock = flags & MSG_DONTWAIT;
2300         bool check_creds = false;
2301         int target;
2302         int err = 0;
2303         long timeo;
2304         int skip;
2305         size_t size = state->size;
2306         unsigned int last_len;
2307
2308         if (unlikely(sk->sk_state != TCP_ESTABLISHED)) {
2309                 err = -EINVAL;
2310                 goto out;
2311         }
2312
2313         if (unlikely(flags & MSG_OOB)) {
2314                 err = -EOPNOTSUPP;
2315                 goto out;
2316         }
2317
2318         target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
2319         timeo = sock_rcvtimeo(sk, noblock);
2320
2321         memset(&scm, 0, sizeof(scm));
2322
2323         /* Lock the socket to prevent queue disordering
2324          * while sleeps in memcpy_tomsg
2325          */
2326         mutex_lock(&u->iolock);
2327
2328         skip = max(sk_peek_offset(sk, flags), 0);
2329
2330         do {
2331                 int chunk;
2332                 bool drop_skb;
2333                 struct sk_buff *skb, *last;
2334
2335 redo:
2336                 unix_state_lock(sk);
2337                 if (sock_flag(sk, SOCK_DEAD)) {
2338                         err = -ECONNRESET;
2339                         goto unlock;
2340                 }
2341                 last = skb = skb_peek(&sk->sk_receive_queue);
2342                 last_len = last ? last->len : 0;
2343 again:
2344                 if (skb == NULL) {
2345                         if (copied >= target)
2346                                 goto unlock;
2347
2348                         /*
2349                          *      POSIX 1003.1g mandates this order.
2350                          */
2351
2352                         err = sock_error(sk);
2353                         if (err)
2354                                 goto unlock;
2355                         if (sk->sk_shutdown & RCV_SHUTDOWN)
2356                                 goto unlock;
2357
2358                         unix_state_unlock(sk);
2359                         if (!timeo) {
2360                                 err = -EAGAIN;
2361                                 break;
2362                         }
2363
2364                         mutex_unlock(&u->iolock);
2365
2366                         timeo = unix_stream_data_wait(sk, timeo, last,
2367                                                       last_len, freezable);
2368
2369                         if (signal_pending(current)) {
2370                                 err = sock_intr_errno(timeo);
2371                                 scm_destroy(&scm);
2372                                 goto out;
2373                         }
2374
2375                         mutex_lock(&u->iolock);
2376                         goto redo;
2377 unlock:
2378                         unix_state_unlock(sk);
2379                         break;
2380                 }
2381
2382                 while (skip >= unix_skb_len(skb)) {
2383                         skip -= unix_skb_len(skb);
2384                         last = skb;
2385                         last_len = skb->len;
2386                         skb = skb_peek_next(skb, &sk->sk_receive_queue);
2387                         if (!skb)
2388                                 goto again;
2389                 }
2390
2391                 unix_state_unlock(sk);
2392
2393                 if (check_creds) {
2394                         /* Never glue messages from different writers */
2395                         if (!unix_skb_scm_eq(skb, &scm))
2396                                 break;
2397                 } else if (test_bit(SOCK_PASSCRED, &sock->flags)) {
2398                         /* Copy credentials */
2399                         scm_set_cred(&scm, UNIXCB(skb).pid, UNIXCB(skb).uid, UNIXCB(skb).gid);
2400                         unix_set_secdata(&scm, skb);
2401                         check_creds = true;
2402                 }
2403
2404                 /* Copy address just once */
2405                 if (state->msg && state->msg->msg_name) {
2406                         DECLARE_SOCKADDR(struct sockaddr_un *, sunaddr,
2407                                          state->msg->msg_name);
2408                         unix_copy_addr(state->msg, skb->sk);
2409                         sunaddr = NULL;
2410                 }
2411
2412                 chunk = min_t(unsigned int, unix_skb_len(skb) - skip, size);
2413                 skb_get(skb);
2414                 chunk = state->recv_actor(skb, skip, chunk, state);
2415                 drop_skb = !unix_skb_len(skb);
2416                 /* skb is only safe to use if !drop_skb */
2417                 consume_skb(skb);
2418                 if (chunk < 0) {
2419                         if (copied == 0)
2420                                 copied = -EFAULT;
2421                         break;
2422                 }
2423                 copied += chunk;
2424                 size -= chunk;
2425
2426                 if (drop_skb) {
2427                         /* the skb was touched by a concurrent reader;
2428                          * we should not expect anything from this skb
2429                          * anymore and assume it invalid - we can be
2430                          * sure it was dropped from the socket queue
2431                          *
2432                          * let's report a short read
2433                          */
2434                         err = 0;
2435                         break;
2436                 }
2437
2438                 /* Mark read part of skb as used */
2439                 if (!(flags & MSG_PEEK)) {
2440                         UNIXCB(skb).consumed += chunk;
2441
2442                         sk_peek_offset_bwd(sk, chunk);
2443
2444                         if (UNIXCB(skb).fp)
2445                                 unix_detach_fds(&scm, skb);
2446
2447                         if (unix_skb_len(skb))
2448                                 break;
2449
2450                         skb_unlink(skb, &sk->sk_receive_queue);
2451                         consume_skb(skb);
2452
2453                         if (scm.fp)
2454                                 break;
2455                 } else {
2456                         /* It is questionable, see note in unix_dgram_recvmsg.
2457                          */
2458                         if (UNIXCB(skb).fp)
2459                                 unix_peek_fds(&scm, skb);
2460
2461                         sk_peek_offset_fwd(sk, chunk);
2462
2463                         if (UNIXCB(skb).fp)
2464                                 break;
2465
2466                         skip = 0;
2467                         last = skb;
2468                         last_len = skb->len;
2469                         unix_state_lock(sk);
2470                         skb = skb_peek_next(skb, &sk->sk_receive_queue);
2471                         if (skb)
2472                                 goto again;
2473                         unix_state_unlock(sk);
2474                         break;
2475                 }
2476         } while (size);
2477
2478         mutex_unlock(&u->iolock);
2479         if (state->msg)
2480                 scm_recv(sock, state->msg, &scm, flags);
2481         else
2482                 scm_destroy(&scm);
2483 out:
2484         return copied ? : err;
2485 }
2486
2487 static int unix_stream_read_actor(struct sk_buff *skb,
2488                                   int skip, int chunk,
2489                                   struct unix_stream_read_state *state)
2490 {
2491         int ret;
2492
2493         ret = skb_copy_datagram_msg(skb, UNIXCB(skb).consumed + skip,
2494                                     state->msg, chunk);
2495         return ret ?: chunk;
2496 }
2497
2498 static int unix_stream_recvmsg(struct socket *sock, struct msghdr *msg,
2499                                size_t size, int flags)
2500 {
2501         struct unix_stream_read_state state = {
2502                 .recv_actor = unix_stream_read_actor,
2503                 .socket = sock,
2504                 .msg = msg,
2505                 .size = size,
2506                 .flags = flags
2507         };
2508
2509         return unix_stream_read_generic(&state, true);
2510 }
2511
2512 static int unix_stream_splice_actor(struct sk_buff *skb,
2513                                     int skip, int chunk,
2514                                     struct unix_stream_read_state *state)
2515 {
2516         return skb_splice_bits(skb, state->socket->sk,
2517                                UNIXCB(skb).consumed + skip,
2518                                state->pipe, chunk, state->splice_flags);
2519 }
2520
2521 static ssize_t unix_stream_splice_read(struct socket *sock,  loff_t *ppos,
2522                                        struct pipe_inode_info *pipe,
2523                                        size_t size, unsigned int flags)
2524 {
2525         struct unix_stream_read_state state = {
2526                 .recv_actor = unix_stream_splice_actor,
2527                 .socket = sock,
2528                 .pipe = pipe,
2529                 .size = size,
2530                 .splice_flags = flags,
2531         };
2532
2533         if (unlikely(*ppos))
2534                 return -ESPIPE;
2535
2536         if (sock->file->f_flags & O_NONBLOCK ||
2537             flags & SPLICE_F_NONBLOCK)
2538                 state.flags = MSG_DONTWAIT;
2539
2540         return unix_stream_read_generic(&state, false);
2541 }
2542
2543 static int unix_shutdown(struct socket *sock, int mode)
2544 {
2545         struct sock *sk = sock->sk;
2546         struct sock *other;
2547
2548         if (mode < SHUT_RD || mode > SHUT_RDWR)
2549                 return -EINVAL;
2550         /* This maps:
2551          * SHUT_RD   (0) -> RCV_SHUTDOWN  (1)
2552          * SHUT_WR   (1) -> SEND_SHUTDOWN (2)
2553          * SHUT_RDWR (2) -> SHUTDOWN_MASK (3)
2554          */
2555         ++mode;
2556
2557         unix_state_lock(sk);
2558         sk->sk_shutdown |= mode;
2559         other = unix_peer(sk);
2560         if (other)
2561                 sock_hold(other);
2562         unix_state_unlock(sk);
2563         sk->sk_state_change(sk);
2564
2565         if (other &&
2566                 (sk->sk_type == SOCK_STREAM || sk->sk_type == SOCK_SEQPACKET)) {
2567
2568                 int peer_mode = 0;
2569
2570                 if (mode&RCV_SHUTDOWN)
2571                         peer_mode |= SEND_SHUTDOWN;
2572                 if (mode&SEND_SHUTDOWN)
2573                         peer_mode |= RCV_SHUTDOWN;
2574                 unix_state_lock(other);
2575                 other->sk_shutdown |= peer_mode;
2576                 unix_state_unlock(other);
2577                 other->sk_state_change(other);
2578                 if (peer_mode == SHUTDOWN_MASK)
2579                         sk_wake_async(other, SOCK_WAKE_WAITD, POLL_HUP);
2580                 else if (peer_mode & RCV_SHUTDOWN)
2581                         sk_wake_async(other, SOCK_WAKE_WAITD, POLL_IN);
2582         }
2583         if (other)
2584                 sock_put(other);
2585
2586         return 0;
2587 }
2588
2589 long unix_inq_len(struct sock *sk)
2590 {
2591         struct sk_buff *skb;
2592         long amount = 0;
2593
2594         if (sk->sk_state == TCP_LISTEN)
2595                 return -EINVAL;
2596
2597         spin_lock(&sk->sk_receive_queue.lock);
2598         if (sk->sk_type == SOCK_STREAM ||
2599             sk->sk_type == SOCK_SEQPACKET) {
2600                 skb_queue_walk(&sk->sk_receive_queue, skb)
2601                         amount += unix_skb_len(skb);
2602         } else {
2603                 skb = skb_peek(&sk->sk_receive_queue);
2604                 if (skb)
2605                         amount = skb->len;
2606         }
2607         spin_unlock(&sk->sk_receive_queue.lock);
2608
2609         return amount;
2610 }
2611 EXPORT_SYMBOL_GPL(unix_inq_len);
2612
2613 long unix_outq_len(struct sock *sk)
2614 {
2615         return sk_wmem_alloc_get(sk);
2616 }
2617 EXPORT_SYMBOL_GPL(unix_outq_len);
2618
2619 static int unix_open_file(struct sock *sk)
2620 {
2621         struct path path;
2622         struct file *f;
2623         int fd;
2624
2625         if (!ns_capable(sock_net(sk)->user_ns, CAP_NET_ADMIN))
2626                 return -EPERM;
2627
2628         if (!smp_load_acquire(&unix_sk(sk)->addr))
2629                 return -ENOENT;
2630
2631         path = unix_sk(sk)->path;
2632         if (!path.dentry)
2633                 return -ENOENT;
2634
2635         path_get(&path);
2636
2637         fd = get_unused_fd_flags(O_CLOEXEC);
2638         if (fd < 0)
2639                 goto out;
2640
2641         f = dentry_open(&path, O_PATH, current_cred());
2642         if (IS_ERR(f)) {
2643                 put_unused_fd(fd);
2644                 fd = PTR_ERR(f);
2645                 goto out;
2646         }
2647
2648         fd_install(fd, f);
2649 out:
2650         path_put(&path);
2651
2652         return fd;
2653 }
2654
2655 static int unix_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
2656 {
2657         struct sock *sk = sock->sk;
2658         long amount = 0;
2659         int err;
2660
2661         switch (cmd) {
2662         case SIOCOUTQ:
2663                 amount = unix_outq_len(sk);
2664                 err = put_user(amount, (int __user *)arg);
2665                 break;
2666         case SIOCINQ:
2667                 amount = unix_inq_len(sk);
2668                 if (amount < 0)
2669                         err = amount;
2670                 else
2671                         err = put_user(amount, (int __user *)arg);
2672                 break;
2673         case SIOCUNIXFILE:
2674                 err = unix_open_file(sk);
2675                 break;
2676         default:
2677                 err = -ENOIOCTLCMD;
2678                 break;
2679         }
2680         return err;
2681 }
2682
2683 #ifdef CONFIG_COMPAT
2684 static int unix_compat_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
2685 {
2686         return unix_ioctl(sock, cmd, (unsigned long)compat_ptr(arg));
2687 }
2688 #endif
2689
2690 static unsigned int unix_poll(struct file *file, struct socket *sock, poll_table *wait)
2691 {
2692         struct sock *sk = sock->sk;
2693         unsigned int mask;
2694
2695         sock_poll_wait(file, sk_sleep(sk), wait);
2696         mask = 0;
2697
2698         /* exceptional events? */
2699         if (sk->sk_err)
2700                 mask |= POLLERR;
2701         if (sk->sk_shutdown == SHUTDOWN_MASK)
2702                 mask |= POLLHUP;
2703         if (sk->sk_shutdown & RCV_SHUTDOWN)
2704                 mask |= POLLRDHUP | POLLIN | POLLRDNORM;
2705
2706         /* readable? */
2707         if (!skb_queue_empty_lockless(&sk->sk_receive_queue))
2708                 mask |= POLLIN | POLLRDNORM;
2709
2710         /* Connection-based need to check for termination and startup */
2711         if ((sk->sk_type == SOCK_STREAM || sk->sk_type == SOCK_SEQPACKET) &&
2712             sk->sk_state == TCP_CLOSE)
2713                 mask |= POLLHUP;
2714
2715         /*
2716          * we set writable also when the other side has shut down the
2717          * connection. This prevents stuck sockets.
2718          */
2719         if (unix_writable(sk))
2720                 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
2721
2722         return mask;
2723 }
2724
2725 static unsigned int unix_dgram_poll(struct file *file, struct socket *sock,
2726                                     poll_table *wait)
2727 {
2728         struct sock *sk = sock->sk, *other;
2729         unsigned int mask, writable;
2730
2731         sock_poll_wait(file, sk_sleep(sk), wait);
2732         mask = 0;
2733
2734         /* exceptional events? */
2735         if (sk->sk_err || !skb_queue_empty_lockless(&sk->sk_error_queue))
2736                 mask |= POLLERR |
2737                         (sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? POLLPRI : 0);
2738
2739         if (sk->sk_shutdown & RCV_SHUTDOWN)
2740                 mask |= POLLRDHUP | POLLIN | POLLRDNORM;
2741         if (sk->sk_shutdown == SHUTDOWN_MASK)
2742                 mask |= POLLHUP;
2743
2744         /* readable? */
2745         if (!skb_queue_empty_lockless(&sk->sk_receive_queue))
2746                 mask |= POLLIN | POLLRDNORM;
2747
2748         /* Connection-based need to check for termination and startup */
2749         if (sk->sk_type == SOCK_SEQPACKET) {
2750                 if (sk->sk_state == TCP_CLOSE)
2751                         mask |= POLLHUP;
2752                 /* connection hasn't started yet? */
2753                 if (sk->sk_state == TCP_SYN_SENT)
2754                         return mask;
2755         }
2756
2757         /* No write status requested, avoid expensive OUT tests. */
2758         if (!(poll_requested_events(wait) & (POLLWRBAND|POLLWRNORM|POLLOUT)))
2759                 return mask;
2760
2761         writable = unix_writable(sk);
2762         if (writable) {
2763                 unix_state_lock(sk);
2764
2765                 other = unix_peer(sk);
2766                 if (other && unix_peer(other) != sk &&
2767                     unix_recvq_full_lockless(other) &&
2768                     unix_dgram_peer_wake_me(sk, other))
2769                         writable = 0;
2770
2771                 unix_state_unlock(sk);
2772         }
2773
2774         if (writable)
2775                 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
2776         else
2777                 sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);
2778
2779         return mask;
2780 }
2781
2782 #ifdef CONFIG_PROC_FS
2783
2784 #define BUCKET_SPACE (BITS_PER_LONG - (UNIX_HASH_BITS + 1) - 1)
2785
2786 #define get_bucket(x) ((x) >> BUCKET_SPACE)
2787 #define get_offset(x) ((x) & ((1L << BUCKET_SPACE) - 1))
2788 #define set_bucket_offset(b, o) ((b) << BUCKET_SPACE | (o))
2789
2790 static struct sock *unix_from_bucket(struct seq_file *seq, loff_t *pos)
2791 {
2792         unsigned long offset = get_offset(*pos);
2793         unsigned long bucket = get_bucket(*pos);
2794         struct sock *sk;
2795         unsigned long count = 0;
2796
2797         for (sk = sk_head(&unix_socket_table[bucket]); sk; sk = sk_next(sk)) {
2798                 if (sock_net(sk) != seq_file_net(seq))
2799                         continue;
2800                 if (++count == offset)
2801                         break;
2802         }
2803
2804         return sk;
2805 }
2806
2807 static struct sock *unix_next_socket(struct seq_file *seq,
2808                                      struct sock *sk,
2809                                      loff_t *pos)
2810 {
2811         unsigned long bucket;
2812
2813         while (sk > (struct sock *)SEQ_START_TOKEN) {
2814                 sk = sk_next(sk);
2815                 if (!sk)
2816                         goto next_bucket;
2817                 if (sock_net(sk) == seq_file_net(seq))
2818                         return sk;
2819         }
2820
2821         do {
2822                 sk = unix_from_bucket(seq, pos);
2823                 if (sk)
2824                         return sk;
2825
2826 next_bucket:
2827                 bucket = get_bucket(*pos) + 1;
2828                 *pos = set_bucket_offset(bucket, 1);
2829         } while (bucket < ARRAY_SIZE(unix_socket_table));
2830
2831         return NULL;
2832 }
2833
2834 static void *unix_seq_start(struct seq_file *seq, loff_t *pos)
2835         __acquires(unix_table_lock)
2836 {
2837         spin_lock(&unix_table_lock);
2838
2839         if (!*pos)
2840                 return SEQ_START_TOKEN;
2841
2842         if (get_bucket(*pos) >= ARRAY_SIZE(unix_socket_table))
2843                 return NULL;
2844
2845         return unix_next_socket(seq, NULL, pos);
2846 }
2847
2848 static void *unix_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2849 {
2850         ++*pos;
2851         return unix_next_socket(seq, v, pos);
2852 }
2853
2854 static void unix_seq_stop(struct seq_file *seq, void *v)
2855         __releases(unix_table_lock)
2856 {
2857         spin_unlock(&unix_table_lock);
2858 }
2859
2860 static int unix_seq_show(struct seq_file *seq, void *v)
2861 {
2862
2863         if (v == SEQ_START_TOKEN)
2864                 seq_puts(seq, "Num       RefCount Protocol Flags    Type St "
2865                          "Inode Path\n");
2866         else {
2867                 struct sock *s = v;
2868                 struct unix_sock *u = unix_sk(s);
2869                 unix_state_lock(s);
2870
2871                 seq_printf(seq, "%pK: %08X %08X %08X %04X %02X %5lu",
2872                         s,
2873                         refcount_read(&s->sk_refcnt),
2874                         0,
2875                         s->sk_state == TCP_LISTEN ? __SO_ACCEPTCON : 0,
2876                         s->sk_type,
2877                         s->sk_socket ?
2878                         (s->sk_state == TCP_ESTABLISHED ? SS_CONNECTED : SS_UNCONNECTED) :
2879                         (s->sk_state == TCP_ESTABLISHED ? SS_CONNECTING : SS_DISCONNECTING),
2880                         sock_i_ino(s));
2881
2882                 if (u->addr) {  // under unix_table_lock here
2883                         int i, len;
2884                         seq_putc(seq, ' ');
2885
2886                         i = 0;
2887                         len = u->addr->len - sizeof(short);
2888                         if (!UNIX_ABSTRACT(s))
2889                                 len--;
2890                         else {
2891                                 seq_putc(seq, '@');
2892                                 i++;
2893                         }
2894                         for ( ; i < len; i++)
2895                                 seq_putc(seq, u->addr->name->sun_path[i] ?:
2896                                          '@');
2897                 }
2898                 unix_state_unlock(s);
2899                 seq_putc(seq, '\n');
2900         }
2901
2902         return 0;
2903 }
2904
2905 static const struct seq_operations unix_seq_ops = {
2906         .start  = unix_seq_start,
2907         .next   = unix_seq_next,
2908         .stop   = unix_seq_stop,
2909         .show   = unix_seq_show,
2910 };
2911
2912 static int unix_seq_open(struct inode *inode, struct file *file)
2913 {
2914         return seq_open_net(inode, file, &unix_seq_ops,
2915                             sizeof(struct seq_net_private));
2916 }
2917
2918 static const struct file_operations unix_seq_fops = {
2919         .owner          = THIS_MODULE,
2920         .open           = unix_seq_open,
2921         .read           = seq_read,
2922         .llseek         = seq_lseek,
2923         .release        = seq_release_net,
2924 };
2925
2926 #endif
2927
2928 static const struct net_proto_family unix_family_ops = {
2929         .family = PF_UNIX,
2930         .create = unix_create,
2931         .owner  = THIS_MODULE,
2932 };
2933
2934
2935 static int __net_init unix_net_init(struct net *net)
2936 {
2937         int error = -ENOMEM;
2938
2939         net->unx.sysctl_max_dgram_qlen = 10;
2940         if (unix_sysctl_register(net))
2941                 goto out;
2942
2943 #ifdef CONFIG_PROC_FS
2944         if (!proc_create("unix", 0, net->proc_net, &unix_seq_fops)) {
2945                 unix_sysctl_unregister(net);
2946                 goto out;
2947         }
2948 #endif
2949         error = 0;
2950 out:
2951         return error;
2952 }
2953
2954 static void __net_exit unix_net_exit(struct net *net)
2955 {
2956         unix_sysctl_unregister(net);
2957         remove_proc_entry("unix", net->proc_net);
2958 }
2959
2960 static struct pernet_operations unix_net_ops = {
2961         .init = unix_net_init,
2962         .exit = unix_net_exit,
2963 };
2964
2965 static int __init af_unix_init(void)
2966 {
2967         int rc = -1;
2968
2969         BUILD_BUG_ON(sizeof(struct unix_skb_parms) > FIELD_SIZEOF(struct sk_buff, cb));
2970
2971         rc = proto_register(&unix_proto, 1);
2972         if (rc != 0) {
2973                 pr_crit("%s: Cannot create unix_sock SLAB cache!\n", __func__);
2974                 goto out;
2975         }
2976
2977         sock_register(&unix_family_ops);
2978         register_pernet_subsys(&unix_net_ops);
2979 out:
2980         return rc;
2981 }
2982
2983 static void __exit af_unix_exit(void)
2984 {
2985         sock_unregister(PF_UNIX);
2986         proto_unregister(&unix_proto);
2987         unregister_pernet_subsys(&unix_net_ops);
2988 }
2989
2990 /* Earlier than device_initcall() so that other drivers invoking
2991    request_module() don't end up in a loop when modprobe tries
2992    to use a UNIX socket. But later than subsys_initcall() because
2993    we depend on stuff initialised there */
2994 fs_initcall(af_unix_init);
2995 module_exit(af_unix_exit);
2996
2997 MODULE_LICENSE("GPL");
2998 MODULE_ALIAS_NETPROTO(PF_UNIX);