SAFE public projects git trees. - safe/jmp/linux-2.6/blob - net/unix/af_unix.c

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