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