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