2 * NET4: Implementation of BSD Unix domain sockets.
4 * Authors: Alan Cox, <alan@lxorguk.ukuu.org.uk>
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.
12 * Linus Torvalds : Assorted bug cures.
13 * Niibe Yutaka : async I/O support.
14 * Carsten Paeth : PF_UNIX check, address fixes.
15 * Alan Cox : Limit size of allocated blocks.
16 * Alan Cox : Fixed the stupid socketpair bug.
17 * Alan Cox : BSD compatibility fine tuning.
18 * Alan Cox : Fixed a bug in connect when interrupted.
19 * Alan Cox : Sorted out a proper draft version of
20 * file descriptor passing hacked up from
22 * Marty Leisner : Fixes to fd passing
23 * Nick Nevin : recvmsg bugfix.
24 * Alan Cox : Started proper garbage collector
25 * Heiko EiBfeldt : Missing verify_area check
26 * Alan Cox : Started POSIXisms
27 * Andreas Schwab : Replace inode by dentry for proper
29 * Kirk Petersen : Made this a module
30 * Christoph Rohland : Elegant non-blocking accept/connect algorithm.
32 * Alexey Kuznetosv : Repaired (I hope) bugs introduces
33 * by above two patches.
34 * Andrea Arcangeli : If possible we block in connect(2)
35 * if the max backlog of the listen socket
36 * is been reached. This won't break
37 * old apps and it will avoid huge amount
38 * of socks hashed (this for unix_gc()
39 * performances reasons).
40 * Security fix that limits the max
41 * number of socks to 2*max_files and
42 * the number of skb queueable in the
44 * Artur Skawina : Hash function optimizations
45 * Alexey Kuznetsov : Full scale SMP. Lot of bugs are introduced 8)
46 * Malcolm Beattie : Set peercred for socketpair
47 * Michal Ostrowski : Module initialization cleanup.
48 * Arnaldo C. Melo : Remove MOD_{INC,DEC}_USE_COUNT,
49 * the core infrastructure is doing that
50 * for all net proto families now (2.5.69+)
53 * Known differences from reference BSD that was tested:
56 * ECONNREFUSED is not returned from one end of a connected() socket to the
57 * other the moment one end closes.
58 * fstat() doesn't return st_dev=0, and give the blksize as high water mark
59 * and a fake inode identifier (nor the BSD first socket fstat twice bug).
61 * accept() returns a path name even if the connecting socket has closed
62 * in the meantime (BSD loses the path and gives up).
63 * accept() returns 0 length path for an unbound connector. BSD returns 16
64 * and a null first byte in the path (but not for gethost/peername - BSD bug ??)
65 * socketpair(...SOCK_RAW..) doesn't panic the kernel.
66 * BSD af_unix apparently has connect forgetting to block properly.
67 * (need to check this with the POSIX spec in detail)
69 * Differences from 2.0.0-11-... (ANK)
70 * Bug fixes and improvements.
71 * - client shutdown killed server socket.
72 * - removed all useless cli/sti pairs.
74 * Semantic changes/extensions.
75 * - generic control message passing.
76 * - SCM_CREDENTIALS control message.
77 * - "Abstract" (not FS based) socket bindings.
78 * Abstract names are sequences of bytes (not zero terminated)
79 * started by 0, so that this name space does not intersect
83 #include <linux/module.h>
84 #include <linux/kernel.h>
85 #include <linux/signal.h>
86 #include <linux/sched.h>
87 #include <linux/errno.h>
88 #include <linux/string.h>
89 #include <linux/stat.h>
90 #include <linux/dcache.h>
91 #include <linux/namei.h>
92 #include <linux/socket.h>
94 #include <linux/fcntl.h>
95 #include <linux/termios.h>
96 #include <linux/sockios.h>
97 #include <linux/net.h>
100 #include <linux/slab.h>
101 #include <asm/uaccess.h>
102 #include <linux/skbuff.h>
103 #include <linux/netdevice.h>
104 #include <net/net_namespace.h>
105 #include <net/sock.h>
106 #include <net/tcp_states.h>
107 #include <net/af_unix.h>
108 #include <linux/proc_fs.h>
109 #include <linux/seq_file.h>
111 #include <linux/init.h>
112 #include <linux/poll.h>
113 #include <linux/rtnetlink.h>
114 #include <linux/mount.h>
115 #include <net/checksum.h>
116 #include <linux/security.h>
118 static struct hlist_head unix_socket_table
[UNIX_HASH_SIZE
+ 1];
119 static DEFINE_SPINLOCK(unix_table_lock
);
120 static atomic_t unix_nr_socks
= ATOMIC_INIT(0);
122 #define unix_sockets_unbound (&unix_socket_table[UNIX_HASH_SIZE])
124 #define UNIX_ABSTRACT(sk) (unix_sk(sk)->addr->hash != UNIX_HASH_SIZE)
126 #ifdef CONFIG_SECURITY_NETWORK
127 static void unix_get_secdata(struct scm_cookie
*scm
, struct sk_buff
*skb
)
129 memcpy(UNIXSID(skb
), &scm
->secid
, sizeof(u32
));
132 static inline void unix_set_secdata(struct scm_cookie
*scm
, struct sk_buff
*skb
)
134 scm
->secid
= *UNIXSID(skb
);
137 static inline void unix_get_secdata(struct scm_cookie
*scm
, struct sk_buff
*skb
)
140 static inline void unix_set_secdata(struct scm_cookie
*scm
, struct sk_buff
*skb
)
142 #endif /* CONFIG_SECURITY_NETWORK */
145 * SMP locking strategy:
146 * hash table is protected with spinlock unix_table_lock
147 * each socket state is protected by separate rwlock.
150 static inline unsigned unix_hash_fold(__wsum n
)
152 unsigned hash
= (__force
unsigned)n
;
155 return hash
&(UNIX_HASH_SIZE
-1);
158 #define unix_peer(sk) (unix_sk(sk)->peer)
160 static inline int unix_our_peer(struct sock
*sk
, struct sock
*osk
)
162 return unix_peer(osk
) == sk
;
165 static inline int unix_may_send(struct sock
*sk
, struct sock
*osk
)
167 return unix_peer(osk
) == NULL
|| unix_our_peer(sk
, osk
);
170 static inline int unix_recvq_full(struct sock
const *sk
)
172 return skb_queue_len(&sk
->sk_receive_queue
) > sk
->sk_max_ack_backlog
;
175 static struct sock
*unix_peer_get(struct sock
*s
)
183 unix_state_unlock(s
);
187 static inline void unix_release_addr(struct unix_address
*addr
)
189 if (atomic_dec_and_test(&addr
->refcnt
))
194 * Check unix socket name:
195 * - should be not zero length.
196 * - if started by not zero, should be NULL terminated (FS object)
197 * - if started by zero, it is abstract name.
200 static int unix_mkname(struct sockaddr_un
*sunaddr
, int len
, unsigned *hashp
)
202 if (len
<= sizeof(short) || len
> sizeof(*sunaddr
))
204 if (!sunaddr
|| sunaddr
->sun_family
!= AF_UNIX
)
206 if (sunaddr
->sun_path
[0]) {
208 * This may look like an off by one error but it is a bit more
209 * subtle. 108 is the longest valid AF_UNIX path for a binding.
210 * sun_path[108] doesnt as such exist. However in kernel space
211 * we are guaranteed that it is a valid memory location in our
212 * kernel address buffer.
214 ((char *)sunaddr
)[len
] = 0;
215 len
= strlen(sunaddr
->sun_path
)+1+sizeof(short);
219 *hashp
= unix_hash_fold(csum_partial(sunaddr
, len
, 0));
223 static void __unix_remove_socket(struct sock
*sk
)
225 sk_del_node_init(sk
);
228 static void __unix_insert_socket(struct hlist_head
*list
, struct sock
*sk
)
230 WARN_ON(!sk_unhashed(sk
));
231 sk_add_node(sk
, list
);
234 static inline void unix_remove_socket(struct sock
*sk
)
236 spin_lock(&unix_table_lock
);
237 __unix_remove_socket(sk
);
238 spin_unlock(&unix_table_lock
);
241 static inline void unix_insert_socket(struct hlist_head
*list
, struct sock
*sk
)
243 spin_lock(&unix_table_lock
);
244 __unix_insert_socket(list
, sk
);
245 spin_unlock(&unix_table_lock
);
248 static struct sock
*__unix_find_socket_byname(struct net
*net
,
249 struct sockaddr_un
*sunname
,
250 int len
, int type
, unsigned hash
)
253 struct hlist_node
*node
;
255 sk_for_each(s
, node
, &unix_socket_table
[hash
^ type
]) {
256 struct unix_sock
*u
= unix_sk(s
);
258 if (!net_eq(sock_net(s
), net
))
261 if (u
->addr
->len
== len
&&
262 !memcmp(u
->addr
->name
, sunname
, len
))
270 static inline struct sock
*unix_find_socket_byname(struct net
*net
,
271 struct sockaddr_un
*sunname
,
277 spin_lock(&unix_table_lock
);
278 s
= __unix_find_socket_byname(net
, sunname
, len
, type
, hash
);
281 spin_unlock(&unix_table_lock
);
285 static struct sock
*unix_find_socket_byinode(struct net
*net
, struct inode
*i
)
288 struct hlist_node
*node
;
290 spin_lock(&unix_table_lock
);
292 &unix_socket_table
[i
->i_ino
& (UNIX_HASH_SIZE
- 1)]) {
293 struct dentry
*dentry
= unix_sk(s
)->dentry
;
295 if (!net_eq(sock_net(s
), net
))
298 if (dentry
&& dentry
->d_inode
== i
) {
305 spin_unlock(&unix_table_lock
);
309 static inline int unix_writable(struct sock
*sk
)
311 return (atomic_read(&sk
->sk_wmem_alloc
) << 2) <= sk
->sk_sndbuf
;
314 static void unix_write_space(struct sock
*sk
)
316 read_lock(&sk
->sk_callback_lock
);
317 if (unix_writable(sk
)) {
318 if (sk
->sk_sleep
&& waitqueue_active(sk
->sk_sleep
))
319 wake_up_interruptible_sync(sk
->sk_sleep
);
320 sk_wake_async(sk
, SOCK_WAKE_SPACE
, POLL_OUT
);
322 read_unlock(&sk
->sk_callback_lock
);
325 /* When dgram socket disconnects (or changes its peer), we clear its receive
326 * queue of packets arrived from previous peer. First, it allows to do
327 * flow control based only on wmem_alloc; second, sk connected to peer
328 * may receive messages only from that peer. */
329 static void unix_dgram_disconnected(struct sock
*sk
, struct sock
*other
)
331 if (!skb_queue_empty(&sk
->sk_receive_queue
)) {
332 skb_queue_purge(&sk
->sk_receive_queue
);
333 wake_up_interruptible_all(&unix_sk(sk
)->peer_wait
);
335 /* If one link of bidirectional dgram pipe is disconnected,
336 * we signal error. Messages are lost. Do not make this,
337 * when peer was not connected to us.
339 if (!sock_flag(other
, SOCK_DEAD
) && unix_peer(other
) == sk
) {
340 other
->sk_err
= ECONNRESET
;
341 other
->sk_error_report(other
);
346 static void unix_sock_destructor(struct sock
*sk
)
348 struct unix_sock
*u
= unix_sk(sk
);
350 skb_queue_purge(&sk
->sk_receive_queue
);
352 WARN_ON(atomic_read(&sk
->sk_wmem_alloc
));
353 WARN_ON(!sk_unhashed(sk
));
354 WARN_ON(sk
->sk_socket
);
355 if (!sock_flag(sk
, SOCK_DEAD
)) {
356 printk(KERN_INFO
"Attempt to release alive unix socket: %p\n", sk
);
361 unix_release_addr(u
->addr
);
363 atomic_dec(&unix_nr_socks
);
365 sock_prot_inuse_add(sock_net(sk
), sk
->sk_prot
, -1);
367 #ifdef UNIX_REFCNT_DEBUG
368 printk(KERN_DEBUG
"UNIX %p is destroyed, %d are still alive.\n", sk
,
369 atomic_read(&unix_nr_socks
));
373 static int unix_release_sock(struct sock
*sk
, int embrion
)
375 struct unix_sock
*u
= unix_sk(sk
);
376 struct dentry
*dentry
;
377 struct vfsmount
*mnt
;
382 unix_remove_socket(sk
);
387 sk
->sk_shutdown
= SHUTDOWN_MASK
;
392 state
= sk
->sk_state
;
393 sk
->sk_state
= TCP_CLOSE
;
394 unix_state_unlock(sk
);
396 wake_up_interruptible_all(&u
->peer_wait
);
398 skpair
= unix_peer(sk
);
400 if (skpair
!= NULL
) {
401 if (sk
->sk_type
== SOCK_STREAM
|| sk
->sk_type
== SOCK_SEQPACKET
) {
402 unix_state_lock(skpair
);
404 skpair
->sk_shutdown
= SHUTDOWN_MASK
;
405 if (!skb_queue_empty(&sk
->sk_receive_queue
) || embrion
)
406 skpair
->sk_err
= ECONNRESET
;
407 unix_state_unlock(skpair
);
408 skpair
->sk_state_change(skpair
);
409 read_lock(&skpair
->sk_callback_lock
);
410 sk_wake_async(skpair
, SOCK_WAKE_WAITD
, POLL_HUP
);
411 read_unlock(&skpair
->sk_callback_lock
);
413 sock_put(skpair
); /* It may now die */
414 unix_peer(sk
) = NULL
;
417 /* Try to flush out this socket. Throw out buffers at least */
419 while ((skb
= skb_dequeue(&sk
->sk_receive_queue
)) != NULL
) {
420 if (state
== TCP_LISTEN
)
421 unix_release_sock(skb
->sk
, 1);
422 /* passed fds are erased in the kfree_skb hook */
433 /* ---- Socket is dead now and most probably destroyed ---- */
436 * Fixme: BSD difference: In BSD all sockets connected to use get
437 * ECONNRESET and we die on the spot. In Linux we behave
438 * like files and pipes do and wait for the last
441 * Can't we simply set sock->err?
443 * What the above comment does talk about? --ANK(980817)
446 if (unix_tot_inflight
)
447 unix_gc(); /* Garbage collect fds */
452 static int unix_listen(struct socket
*sock
, int backlog
)
455 struct sock
*sk
= sock
->sk
;
456 struct unix_sock
*u
= unix_sk(sk
);
459 if (sock
->type
!= SOCK_STREAM
&& sock
->type
!= SOCK_SEQPACKET
)
460 goto out
; /* Only stream/seqpacket sockets accept */
463 goto out
; /* No listens on an unbound socket */
465 if (sk
->sk_state
!= TCP_CLOSE
&& sk
->sk_state
!= TCP_LISTEN
)
467 if (backlog
> sk
->sk_max_ack_backlog
)
468 wake_up_interruptible_all(&u
->peer_wait
);
469 sk
->sk_max_ack_backlog
= backlog
;
470 sk
->sk_state
= TCP_LISTEN
;
471 /* set credentials so connect can copy them */
472 sk
->sk_peercred
.pid
= task_tgid_vnr(current
);
473 sk
->sk_peercred
.uid
= current
->euid
;
474 sk
->sk_peercred
.gid
= current
->egid
;
478 unix_state_unlock(sk
);
483 static int unix_release(struct socket
*);
484 static int unix_bind(struct socket
*, struct sockaddr
*, int);
485 static int unix_stream_connect(struct socket
*, struct sockaddr
*,
486 int addr_len
, int flags
);
487 static int unix_socketpair(struct socket
*, struct socket
*);
488 static int unix_accept(struct socket
*, struct socket
*, int);
489 static int unix_getname(struct socket
*, struct sockaddr
*, int *, int);
490 static unsigned int unix_poll(struct file
*, struct socket
*, poll_table
*);
491 static unsigned int unix_dgram_poll(struct file
*, struct socket
*,
493 static int unix_ioctl(struct socket
*, unsigned int, unsigned long);
494 static int unix_shutdown(struct socket
*, int);
495 static int unix_stream_sendmsg(struct kiocb
*, struct socket
*,
496 struct msghdr
*, size_t);
497 static int unix_stream_recvmsg(struct kiocb
*, struct socket
*,
498 struct msghdr
*, size_t, int);
499 static int unix_dgram_sendmsg(struct kiocb
*, struct socket
*,
500 struct msghdr
*, size_t);
501 static int unix_dgram_recvmsg(struct kiocb
*, struct socket
*,
502 struct msghdr
*, size_t, int);
503 static int unix_dgram_connect(struct socket
*, struct sockaddr
*,
505 static int unix_seqpacket_sendmsg(struct kiocb
*, struct socket
*,
506 struct msghdr
*, size_t);
508 static const struct proto_ops unix_stream_ops
= {
510 .owner
= THIS_MODULE
,
511 .release
= unix_release
,
513 .connect
= unix_stream_connect
,
514 .socketpair
= unix_socketpair
,
515 .accept
= unix_accept
,
516 .getname
= unix_getname
,
519 .listen
= unix_listen
,
520 .shutdown
= unix_shutdown
,
521 .setsockopt
= sock_no_setsockopt
,
522 .getsockopt
= sock_no_getsockopt
,
523 .sendmsg
= unix_stream_sendmsg
,
524 .recvmsg
= unix_stream_recvmsg
,
525 .mmap
= sock_no_mmap
,
526 .sendpage
= sock_no_sendpage
,
529 static const struct proto_ops unix_dgram_ops
= {
531 .owner
= THIS_MODULE
,
532 .release
= unix_release
,
534 .connect
= unix_dgram_connect
,
535 .socketpair
= unix_socketpair
,
536 .accept
= sock_no_accept
,
537 .getname
= unix_getname
,
538 .poll
= unix_dgram_poll
,
540 .listen
= sock_no_listen
,
541 .shutdown
= unix_shutdown
,
542 .setsockopt
= sock_no_setsockopt
,
543 .getsockopt
= sock_no_getsockopt
,
544 .sendmsg
= unix_dgram_sendmsg
,
545 .recvmsg
= unix_dgram_recvmsg
,
546 .mmap
= sock_no_mmap
,
547 .sendpage
= sock_no_sendpage
,
550 static const struct proto_ops unix_seqpacket_ops
= {
552 .owner
= THIS_MODULE
,
553 .release
= unix_release
,
555 .connect
= unix_stream_connect
,
556 .socketpair
= unix_socketpair
,
557 .accept
= unix_accept
,
558 .getname
= unix_getname
,
559 .poll
= unix_dgram_poll
,
561 .listen
= unix_listen
,
562 .shutdown
= unix_shutdown
,
563 .setsockopt
= sock_no_setsockopt
,
564 .getsockopt
= sock_no_getsockopt
,
565 .sendmsg
= unix_seqpacket_sendmsg
,
566 .recvmsg
= unix_dgram_recvmsg
,
567 .mmap
= sock_no_mmap
,
568 .sendpage
= sock_no_sendpage
,
571 static struct proto unix_proto
= {
573 .owner
= THIS_MODULE
,
574 .sockets_allocated
= &unix_nr_socks
,
575 .obj_size
= sizeof(struct unix_sock
),
579 * AF_UNIX sockets do not interact with hardware, hence they
580 * dont trigger interrupts - so it's safe for them to have
581 * bh-unsafe locking for their sk_receive_queue.lock. Split off
582 * this special lock-class by reinitializing the spinlock key:
584 static struct lock_class_key af_unix_sk_receive_queue_lock_key
;
586 static struct sock
*unix_create1(struct net
*net
, struct socket
*sock
)
588 struct sock
*sk
= NULL
;
591 atomic_inc(&unix_nr_socks
);
592 if (atomic_read(&unix_nr_socks
) > 2 * get_max_files())
595 sk
= sk_alloc(net
, PF_UNIX
, GFP_KERNEL
, &unix_proto
);
599 sock_init_data(sock
, sk
);
600 lockdep_set_class(&sk
->sk_receive_queue
.lock
,
601 &af_unix_sk_receive_queue_lock_key
);
603 sk
->sk_write_space
= unix_write_space
;
604 sk
->sk_max_ack_backlog
= net
->unx
.sysctl_max_dgram_qlen
;
605 sk
->sk_destruct
= unix_sock_destructor
;
609 spin_lock_init(&u
->lock
);
610 atomic_long_set(&u
->inflight
, 0);
611 INIT_LIST_HEAD(&u
->link
);
612 mutex_init(&u
->readlock
); /* single task reading lock */
613 init_waitqueue_head(&u
->peer_wait
);
614 unix_insert_socket(unix_sockets_unbound
, sk
);
617 atomic_dec(&unix_nr_socks
);
619 sock_prot_inuse_add(sock_net(sk
), sk
->sk_prot
, 1);
624 static int unix_create(struct net
*net
, struct socket
*sock
, int protocol
)
626 if (protocol
&& protocol
!= PF_UNIX
)
627 return -EPROTONOSUPPORT
;
629 sock
->state
= SS_UNCONNECTED
;
631 switch (sock
->type
) {
633 sock
->ops
= &unix_stream_ops
;
636 * Believe it or not BSD has AF_UNIX, SOCK_RAW though
640 sock
->type
= SOCK_DGRAM
;
642 sock
->ops
= &unix_dgram_ops
;
645 sock
->ops
= &unix_seqpacket_ops
;
648 return -ESOCKTNOSUPPORT
;
651 return unix_create1(net
, sock
) ? 0 : -ENOMEM
;
654 static int unix_release(struct socket
*sock
)
656 struct sock
*sk
= sock
->sk
;
663 return unix_release_sock(sk
, 0);
666 static int unix_autobind(struct socket
*sock
)
668 struct sock
*sk
= sock
->sk
;
669 struct net
*net
= sock_net(sk
);
670 struct unix_sock
*u
= unix_sk(sk
);
671 static u32 ordernum
= 1;
672 struct unix_address
*addr
;
675 mutex_lock(&u
->readlock
);
682 addr
= kzalloc(sizeof(*addr
) + sizeof(short) + 16, GFP_KERNEL
);
686 addr
->name
->sun_family
= AF_UNIX
;
687 atomic_set(&addr
->refcnt
, 1);
690 addr
->len
= sprintf(addr
->name
->sun_path
+1, "%05x", ordernum
) + 1 + sizeof(short);
691 addr
->hash
= unix_hash_fold(csum_partial(addr
->name
, addr
->len
, 0));
693 spin_lock(&unix_table_lock
);
694 ordernum
= (ordernum
+1)&0xFFFFF;
696 if (__unix_find_socket_byname(net
, addr
->name
, addr
->len
, sock
->type
,
698 spin_unlock(&unix_table_lock
);
699 /* Sanity yield. It is unusual case, but yet... */
700 if (!(ordernum
&0xFF))
704 addr
->hash
^= sk
->sk_type
;
706 __unix_remove_socket(sk
);
708 __unix_insert_socket(&unix_socket_table
[addr
->hash
], sk
);
709 spin_unlock(&unix_table_lock
);
712 out
: mutex_unlock(&u
->readlock
);
716 static struct sock
*unix_find_other(struct net
*net
,
717 struct sockaddr_un
*sunname
, int len
,
718 int type
, unsigned hash
, int *error
)
724 if (sunname
->sun_path
[0]) {
726 err
= kern_path(sunname
->sun_path
, LOOKUP_FOLLOW
, &path
);
729 inode
= path
.dentry
->d_inode
;
730 err
= inode_permission(inode
, MAY_WRITE
);
735 if (!S_ISSOCK(inode
->i_mode
))
737 u
= unix_find_socket_byinode(net
, inode
);
741 if (u
->sk_type
== type
)
742 touch_atime(path
.mnt
, path
.dentry
);
747 if (u
->sk_type
!= type
) {
753 u
= unix_find_socket_byname(net
, sunname
, len
, type
, hash
);
755 struct dentry
*dentry
;
756 dentry
= unix_sk(u
)->dentry
;
758 touch_atime(unix_sk(u
)->mnt
, dentry
);
772 static int unix_bind(struct socket
*sock
, struct sockaddr
*uaddr
, int addr_len
)
774 struct sock
*sk
= sock
->sk
;
775 struct net
*net
= sock_net(sk
);
776 struct unix_sock
*u
= unix_sk(sk
);
777 struct sockaddr_un
*sunaddr
= (struct sockaddr_un
*)uaddr
;
778 struct dentry
*dentry
= NULL
;
782 struct unix_address
*addr
;
783 struct hlist_head
*list
;
786 if (sunaddr
->sun_family
!= AF_UNIX
)
789 if (addr_len
== sizeof(short)) {
790 err
= unix_autobind(sock
);
794 err
= unix_mkname(sunaddr
, addr_len
, &hash
);
799 mutex_lock(&u
->readlock
);
806 addr
= kmalloc(sizeof(*addr
)+addr_len
, GFP_KERNEL
);
810 memcpy(addr
->name
, sunaddr
, addr_len
);
811 addr
->len
= addr_len
;
812 addr
->hash
= hash
^ sk
->sk_type
;
813 atomic_set(&addr
->refcnt
, 1);
815 if (sunaddr
->sun_path
[0]) {
819 * Get the parent directory, calculate the hash for last
822 err
= path_lookup(sunaddr
->sun_path
, LOOKUP_PARENT
, &nd
);
824 goto out_mknod_parent
;
826 dentry
= lookup_create(&nd
, 0);
827 err
= PTR_ERR(dentry
);
829 goto out_mknod_unlock
;
832 * All right, let's create it.
835 (SOCK_INODE(sock
)->i_mode
& ~current
->fs
->umask
);
836 err
= mnt_want_write(nd
.path
.mnt
);
839 err
= vfs_mknod(nd
.path
.dentry
->d_inode
, dentry
, mode
, 0);
840 mnt_drop_write(nd
.path
.mnt
);
843 mutex_unlock(&nd
.path
.dentry
->d_inode
->i_mutex
);
844 dput(nd
.path
.dentry
);
845 nd
.path
.dentry
= dentry
;
847 addr
->hash
= UNIX_HASH_SIZE
;
850 spin_lock(&unix_table_lock
);
852 if (!sunaddr
->sun_path
[0]) {
854 if (__unix_find_socket_byname(net
, sunaddr
, addr_len
,
855 sk
->sk_type
, hash
)) {
856 unix_release_addr(addr
);
860 list
= &unix_socket_table
[addr
->hash
];
862 list
= &unix_socket_table
[dentry
->d_inode
->i_ino
& (UNIX_HASH_SIZE
-1)];
863 u
->dentry
= nd
.path
.dentry
;
864 u
->mnt
= nd
.path
.mnt
;
868 __unix_remove_socket(sk
);
870 __unix_insert_socket(list
, sk
);
873 spin_unlock(&unix_table_lock
);
875 mutex_unlock(&u
->readlock
);
882 mutex_unlock(&nd
.path
.dentry
->d_inode
->i_mutex
);
887 unix_release_addr(addr
);
891 static void unix_state_double_lock(struct sock
*sk1
, struct sock
*sk2
)
893 if (unlikely(sk1
== sk2
) || !sk2
) {
894 unix_state_lock(sk1
);
898 unix_state_lock(sk1
);
899 unix_state_lock_nested(sk2
);
901 unix_state_lock(sk2
);
902 unix_state_lock_nested(sk1
);
906 static void unix_state_double_unlock(struct sock
*sk1
, struct sock
*sk2
)
908 if (unlikely(sk1
== sk2
) || !sk2
) {
909 unix_state_unlock(sk1
);
912 unix_state_unlock(sk1
);
913 unix_state_unlock(sk2
);
916 static int unix_dgram_connect(struct socket
*sock
, struct sockaddr
*addr
,
919 struct sock
*sk
= sock
->sk
;
920 struct net
*net
= sock_net(sk
);
921 struct sockaddr_un
*sunaddr
= (struct sockaddr_un
*)addr
;
926 if (addr
->sa_family
!= AF_UNSPEC
) {
927 err
= unix_mkname(sunaddr
, alen
, &hash
);
932 if (test_bit(SOCK_PASSCRED
, &sock
->flags
) &&
933 !unix_sk(sk
)->addr
&& (err
= unix_autobind(sock
)) != 0)
937 other
= unix_find_other(net
, sunaddr
, alen
, sock
->type
, hash
, &err
);
941 unix_state_double_lock(sk
, other
);
943 /* Apparently VFS overslept socket death. Retry. */
944 if (sock_flag(other
, SOCK_DEAD
)) {
945 unix_state_double_unlock(sk
, other
);
951 if (!unix_may_send(sk
, other
))
954 err
= security_unix_may_send(sk
->sk_socket
, other
->sk_socket
);
960 * 1003.1g breaking connected state with AF_UNSPEC
963 unix_state_double_lock(sk
, other
);
967 * If it was connected, reconnect.
970 struct sock
*old_peer
= unix_peer(sk
);
971 unix_peer(sk
) = other
;
972 unix_state_double_unlock(sk
, other
);
974 if (other
!= old_peer
)
975 unix_dgram_disconnected(sk
, old_peer
);
978 unix_peer(sk
) = other
;
979 unix_state_double_unlock(sk
, other
);
984 unix_state_double_unlock(sk
, other
);
990 static long unix_wait_for_peer(struct sock
*other
, long timeo
)
992 struct unix_sock
*u
= unix_sk(other
);
996 prepare_to_wait_exclusive(&u
->peer_wait
, &wait
, TASK_INTERRUPTIBLE
);
998 sched
= !sock_flag(other
, SOCK_DEAD
) &&
999 !(other
->sk_shutdown
& RCV_SHUTDOWN
) &&
1000 unix_recvq_full(other
);
1002 unix_state_unlock(other
);
1005 timeo
= schedule_timeout(timeo
);
1007 finish_wait(&u
->peer_wait
, &wait
);
1011 static int unix_stream_connect(struct socket
*sock
, struct sockaddr
*uaddr
,
1012 int addr_len
, int flags
)
1014 struct sockaddr_un
*sunaddr
= (struct sockaddr_un
*)uaddr
;
1015 struct sock
*sk
= sock
->sk
;
1016 struct net
*net
= sock_net(sk
);
1017 struct unix_sock
*u
= unix_sk(sk
), *newu
, *otheru
;
1018 struct sock
*newsk
= NULL
;
1019 struct sock
*other
= NULL
;
1020 struct sk_buff
*skb
= NULL
;
1026 err
= unix_mkname(sunaddr
, addr_len
, &hash
);
1031 if (test_bit(SOCK_PASSCRED
, &sock
->flags
)
1032 && !u
->addr
&& (err
= unix_autobind(sock
)) != 0)
1035 timeo
= sock_sndtimeo(sk
, flags
& O_NONBLOCK
);
1037 /* First of all allocate resources.
1038 If we will make it after state is locked,
1039 we will have to recheck all again in any case.
1044 /* create new sock for complete connection */
1045 newsk
= unix_create1(sock_net(sk
), NULL
);
1049 /* Allocate skb for sending to listening sock */
1050 skb
= sock_wmalloc(newsk
, 1, 0, GFP_KERNEL
);
1055 /* Find listening sock. */
1056 other
= unix_find_other(net
, sunaddr
, addr_len
, sk
->sk_type
, hash
, &err
);
1060 /* Latch state of peer */
1061 unix_state_lock(other
);
1063 /* Apparently VFS overslept socket death. Retry. */
1064 if (sock_flag(other
, SOCK_DEAD
)) {
1065 unix_state_unlock(other
);
1070 err
= -ECONNREFUSED
;
1071 if (other
->sk_state
!= TCP_LISTEN
)
1074 if (unix_recvq_full(other
)) {
1079 timeo
= unix_wait_for_peer(other
, timeo
);
1081 err
= sock_intr_errno(timeo
);
1082 if (signal_pending(current
))
1090 It is tricky place. We need to grab write lock and cannot
1091 drop lock on peer. It is dangerous because deadlock is
1092 possible. Connect to self case and simultaneous
1093 attempt to connect are eliminated by checking socket
1094 state. other is TCP_LISTEN, if sk is TCP_LISTEN we
1095 check this before attempt to grab lock.
1097 Well, and we have to recheck the state after socket locked.
1103 /* This is ok... continue with connect */
1105 case TCP_ESTABLISHED
:
1106 /* Socket is already connected */
1114 unix_state_lock_nested(sk
);
1116 if (sk
->sk_state
!= st
) {
1117 unix_state_unlock(sk
);
1118 unix_state_unlock(other
);
1123 err
= security_unix_stream_connect(sock
, other
->sk_socket
, newsk
);
1125 unix_state_unlock(sk
);
1129 /* The way is open! Fastly set all the necessary fields... */
1132 unix_peer(newsk
) = sk
;
1133 newsk
->sk_state
= TCP_ESTABLISHED
;
1134 newsk
->sk_type
= sk
->sk_type
;
1135 newsk
->sk_peercred
.pid
= task_tgid_vnr(current
);
1136 newsk
->sk_peercred
.uid
= current
->euid
;
1137 newsk
->sk_peercred
.gid
= current
->egid
;
1138 newu
= unix_sk(newsk
);
1139 newsk
->sk_sleep
= &newu
->peer_wait
;
1140 otheru
= unix_sk(other
);
1142 /* copy address information from listening to new sock*/
1144 atomic_inc(&otheru
->addr
->refcnt
);
1145 newu
->addr
= otheru
->addr
;
1147 if (otheru
->dentry
) {
1148 newu
->dentry
= dget(otheru
->dentry
);
1149 newu
->mnt
= mntget(otheru
->mnt
);
1152 /* Set credentials */
1153 sk
->sk_peercred
= other
->sk_peercred
;
1155 sock
->state
= SS_CONNECTED
;
1156 sk
->sk_state
= TCP_ESTABLISHED
;
1159 smp_mb__after_atomic_inc(); /* sock_hold() does an atomic_inc() */
1160 unix_peer(sk
) = newsk
;
1162 unix_state_unlock(sk
);
1164 /* take ten and and send info to listening sock */
1165 spin_lock(&other
->sk_receive_queue
.lock
);
1166 __skb_queue_tail(&other
->sk_receive_queue
, skb
);
1167 spin_unlock(&other
->sk_receive_queue
.lock
);
1168 unix_state_unlock(other
);
1169 other
->sk_data_ready(other
, 0);
1175 unix_state_unlock(other
);
1181 unix_release_sock(newsk
, 0);
1187 static int unix_socketpair(struct socket
*socka
, struct socket
*sockb
)
1189 struct sock
*ska
= socka
->sk
, *skb
= sockb
->sk
;
1191 /* Join our sockets back to back */
1194 unix_peer(ska
) = skb
;
1195 unix_peer(skb
) = ska
;
1196 ska
->sk_peercred
.pid
= skb
->sk_peercred
.pid
= task_tgid_vnr(current
);
1197 ska
->sk_peercred
.uid
= skb
->sk_peercred
.uid
= current
->euid
;
1198 ska
->sk_peercred
.gid
= skb
->sk_peercred
.gid
= current
->egid
;
1200 if (ska
->sk_type
!= SOCK_DGRAM
) {
1201 ska
->sk_state
= TCP_ESTABLISHED
;
1202 skb
->sk_state
= TCP_ESTABLISHED
;
1203 socka
->state
= SS_CONNECTED
;
1204 sockb
->state
= SS_CONNECTED
;
1209 static int unix_accept(struct socket
*sock
, struct socket
*newsock
, int flags
)
1211 struct sock
*sk
= sock
->sk
;
1213 struct sk_buff
*skb
;
1217 if (sock
->type
!= SOCK_STREAM
&& sock
->type
!= SOCK_SEQPACKET
)
1221 if (sk
->sk_state
!= TCP_LISTEN
)
1224 /* If socket state is TCP_LISTEN it cannot change (for now...),
1225 * so that no locks are necessary.
1228 skb
= skb_recv_datagram(sk
, 0, flags
&O_NONBLOCK
, &err
);
1230 /* This means receive shutdown. */
1237 skb_free_datagram(sk
, skb
);
1238 wake_up_interruptible(&unix_sk(sk
)->peer_wait
);
1240 /* attach accepted sock to socket */
1241 unix_state_lock(tsk
);
1242 newsock
->state
= SS_CONNECTED
;
1243 sock_graft(tsk
, newsock
);
1244 unix_state_unlock(tsk
);
1252 static int unix_getname(struct socket
*sock
, struct sockaddr
*uaddr
, int *uaddr_len
, int peer
)
1254 struct sock
*sk
= sock
->sk
;
1255 struct unix_sock
*u
;
1256 struct sockaddr_un
*sunaddr
= (struct sockaddr_un
*)uaddr
;
1260 sk
= unix_peer_get(sk
);
1271 unix_state_lock(sk
);
1273 sunaddr
->sun_family
= AF_UNIX
;
1274 sunaddr
->sun_path
[0] = 0;
1275 *uaddr_len
= sizeof(short);
1277 struct unix_address
*addr
= u
->addr
;
1279 *uaddr_len
= addr
->len
;
1280 memcpy(sunaddr
, addr
->name
, *uaddr_len
);
1282 unix_state_unlock(sk
);
1288 static void unix_detach_fds(struct scm_cookie
*scm
, struct sk_buff
*skb
)
1292 scm
->fp
= UNIXCB(skb
).fp
;
1293 skb
->destructor
= sock_wfree
;
1294 UNIXCB(skb
).fp
= NULL
;
1296 for (i
= scm
->fp
->count
-1; i
>= 0; i
--)
1297 unix_notinflight(scm
->fp
->fp
[i
]);
1300 static void unix_destruct_fds(struct sk_buff
*skb
)
1302 struct scm_cookie scm
;
1303 memset(&scm
, 0, sizeof(scm
));
1304 unix_detach_fds(&scm
, skb
);
1306 /* Alas, it calls VFS */
1307 /* So fscking what? fput() had been SMP-safe since the last Summer */
1312 static int unix_attach_fds(struct scm_cookie
*scm
, struct sk_buff
*skb
)
1317 * Need to duplicate file references for the sake of garbage
1318 * collection. Otherwise a socket in the fps might become a
1319 * candidate for GC while the skb is not yet queued.
1321 UNIXCB(skb
).fp
= scm_fp_dup(scm
->fp
);
1322 if (!UNIXCB(skb
).fp
)
1325 for (i
= scm
->fp
->count
-1; i
>= 0; i
--)
1326 unix_inflight(scm
->fp
->fp
[i
]);
1327 skb
->destructor
= unix_destruct_fds
;
1332 * Send AF_UNIX data.
1335 static int unix_dgram_sendmsg(struct kiocb
*kiocb
, struct socket
*sock
,
1336 struct msghdr
*msg
, size_t len
)
1338 struct sock_iocb
*siocb
= kiocb_to_siocb(kiocb
);
1339 struct sock
*sk
= sock
->sk
;
1340 struct net
*net
= sock_net(sk
);
1341 struct unix_sock
*u
= unix_sk(sk
);
1342 struct sockaddr_un
*sunaddr
= msg
->msg_name
;
1343 struct sock
*other
= NULL
;
1344 int namelen
= 0; /* fake GCC */
1347 struct sk_buff
*skb
;
1349 struct scm_cookie tmp_scm
;
1351 if (NULL
== siocb
->scm
)
1352 siocb
->scm
= &tmp_scm
;
1353 err
= scm_send(sock
, msg
, siocb
->scm
);
1358 if (msg
->msg_flags
&MSG_OOB
)
1361 if (msg
->msg_namelen
) {
1362 err
= unix_mkname(sunaddr
, msg
->msg_namelen
, &hash
);
1369 other
= unix_peer_get(sk
);
1374 if (test_bit(SOCK_PASSCRED
, &sock
->flags
)
1375 && !u
->addr
&& (err
= unix_autobind(sock
)) != 0)
1379 if (len
> sk
->sk_sndbuf
- 32)
1382 skb
= sock_alloc_send_skb(sk
, len
, msg
->msg_flags
&MSG_DONTWAIT
, &err
);
1386 memcpy(UNIXCREDS(skb
), &siocb
->scm
->creds
, sizeof(struct ucred
));
1387 if (siocb
->scm
->fp
) {
1388 err
= unix_attach_fds(siocb
->scm
, skb
);
1392 unix_get_secdata(siocb
->scm
, skb
);
1394 skb_reset_transport_header(skb
);
1395 err
= memcpy_fromiovec(skb_put(skb
, len
), msg
->msg_iov
, len
);
1399 timeo
= sock_sndtimeo(sk
, msg
->msg_flags
& MSG_DONTWAIT
);
1404 if (sunaddr
== NULL
)
1407 other
= unix_find_other(net
, sunaddr
, namelen
, sk
->sk_type
,
1413 unix_state_lock(other
);
1415 if (!unix_may_send(sk
, other
))
1418 if (sock_flag(other
, SOCK_DEAD
)) {
1420 * Check with 1003.1g - what should
1423 unix_state_unlock(other
);
1427 unix_state_lock(sk
);
1428 if (unix_peer(sk
) == other
) {
1429 unix_peer(sk
) = NULL
;
1430 unix_state_unlock(sk
);
1432 unix_dgram_disconnected(sk
, other
);
1434 err
= -ECONNREFUSED
;
1436 unix_state_unlock(sk
);
1446 if (other
->sk_shutdown
& RCV_SHUTDOWN
)
1449 if (sk
->sk_type
!= SOCK_SEQPACKET
) {
1450 err
= security_unix_may_send(sk
->sk_socket
, other
->sk_socket
);
1455 if (unix_peer(other
) != sk
&& unix_recvq_full(other
)) {
1461 timeo
= unix_wait_for_peer(other
, timeo
);
1463 err
= sock_intr_errno(timeo
);
1464 if (signal_pending(current
))
1470 skb_queue_tail(&other
->sk_receive_queue
, skb
);
1471 unix_state_unlock(other
);
1472 other
->sk_data_ready(other
, len
);
1474 scm_destroy(siocb
->scm
);
1478 unix_state_unlock(other
);
1484 scm_destroy(siocb
->scm
);
1489 static int unix_stream_sendmsg(struct kiocb
*kiocb
, struct socket
*sock
,
1490 struct msghdr
*msg
, size_t len
)
1492 struct sock_iocb
*siocb
= kiocb_to_siocb(kiocb
);
1493 struct sock
*sk
= sock
->sk
;
1494 struct sock
*other
= NULL
;
1495 struct sockaddr_un
*sunaddr
= msg
->msg_name
;
1497 struct sk_buff
*skb
;
1499 struct scm_cookie tmp_scm
;
1501 if (NULL
== siocb
->scm
)
1502 siocb
->scm
= &tmp_scm
;
1503 err
= scm_send(sock
, msg
, siocb
->scm
);
1508 if (msg
->msg_flags
&MSG_OOB
)
1511 if (msg
->msg_namelen
) {
1512 err
= sk
->sk_state
== TCP_ESTABLISHED
? -EISCONN
: -EOPNOTSUPP
;
1517 other
= unix_peer(sk
);
1522 if (sk
->sk_shutdown
& SEND_SHUTDOWN
)
1525 while (sent
< len
) {
1527 * Optimisation for the fact that under 0.01% of X
1528 * messages typically need breaking up.
1533 /* Keep two messages in the pipe so it schedules better */
1534 if (size
> ((sk
->sk_sndbuf
>> 1) - 64))
1535 size
= (sk
->sk_sndbuf
>> 1) - 64;
1537 if (size
> SKB_MAX_ALLOC
)
1538 size
= SKB_MAX_ALLOC
;
1544 skb
= sock_alloc_send_skb(sk
, size
, msg
->msg_flags
&MSG_DONTWAIT
,
1551 * If you pass two values to the sock_alloc_send_skb
1552 * it tries to grab the large buffer with GFP_NOFS
1553 * (which can fail easily), and if it fails grab the
1554 * fallback size buffer which is under a page and will
1557 size
= min_t(int, size
, skb_tailroom(skb
));
1559 memcpy(UNIXCREDS(skb
), &siocb
->scm
->creds
, sizeof(struct ucred
));
1560 if (siocb
->scm
->fp
) {
1561 err
= unix_attach_fds(siocb
->scm
, skb
);
1568 err
= memcpy_fromiovec(skb_put(skb
, size
), msg
->msg_iov
, size
);
1574 unix_state_lock(other
);
1576 if (sock_flag(other
, SOCK_DEAD
) ||
1577 (other
->sk_shutdown
& RCV_SHUTDOWN
))
1580 skb_queue_tail(&other
->sk_receive_queue
, skb
);
1581 unix_state_unlock(other
);
1582 other
->sk_data_ready(other
, size
);
1586 scm_destroy(siocb
->scm
);
1592 unix_state_unlock(other
);
1595 if (sent
== 0 && !(msg
->msg_flags
&MSG_NOSIGNAL
))
1596 send_sig(SIGPIPE
, current
, 0);
1599 scm_destroy(siocb
->scm
);
1601 return sent
? : err
;
1604 static int unix_seqpacket_sendmsg(struct kiocb
*kiocb
, struct socket
*sock
,
1605 struct msghdr
*msg
, size_t len
)
1608 struct sock
*sk
= sock
->sk
;
1610 err
= sock_error(sk
);
1614 if (sk
->sk_state
!= TCP_ESTABLISHED
)
1617 if (msg
->msg_namelen
)
1618 msg
->msg_namelen
= 0;
1620 return unix_dgram_sendmsg(kiocb
, sock
, msg
, len
);
1623 static void unix_copy_addr(struct msghdr
*msg
, struct sock
*sk
)
1625 struct unix_sock
*u
= unix_sk(sk
);
1627 msg
->msg_namelen
= 0;
1629 msg
->msg_namelen
= u
->addr
->len
;
1630 memcpy(msg
->msg_name
, u
->addr
->name
, u
->addr
->len
);
1634 static int unix_dgram_recvmsg(struct kiocb
*iocb
, struct socket
*sock
,
1635 struct msghdr
*msg
, size_t size
,
1638 struct sock_iocb
*siocb
= kiocb_to_siocb(iocb
);
1639 struct scm_cookie tmp_scm
;
1640 struct sock
*sk
= sock
->sk
;
1641 struct unix_sock
*u
= unix_sk(sk
);
1642 int noblock
= flags
& MSG_DONTWAIT
;
1643 struct sk_buff
*skb
;
1650 msg
->msg_namelen
= 0;
1652 mutex_lock(&u
->readlock
);
1654 skb
= skb_recv_datagram(sk
, flags
, noblock
, &err
);
1656 unix_state_lock(sk
);
1657 /* Signal EOF on disconnected non-blocking SEQPACKET socket. */
1658 if (sk
->sk_type
== SOCK_SEQPACKET
&& err
== -EAGAIN
&&
1659 (sk
->sk_shutdown
& RCV_SHUTDOWN
))
1661 unix_state_unlock(sk
);
1665 wake_up_interruptible_sync(&u
->peer_wait
);
1668 unix_copy_addr(msg
, skb
->sk
);
1670 if (size
> skb
->len
)
1672 else if (size
< skb
->len
)
1673 msg
->msg_flags
|= MSG_TRUNC
;
1675 err
= skb_copy_datagram_iovec(skb
, 0, msg
->msg_iov
, size
);
1680 siocb
->scm
= &tmp_scm
;
1681 memset(&tmp_scm
, 0, sizeof(tmp_scm
));
1683 siocb
->scm
->creds
= *UNIXCREDS(skb
);
1684 unix_set_secdata(siocb
->scm
, skb
);
1686 if (!(flags
& MSG_PEEK
)) {
1688 unix_detach_fds(siocb
->scm
, skb
);
1690 /* It is questionable: on PEEK we could:
1691 - do not return fds - good, but too simple 8)
1692 - return fds, and do not return them on read (old strategy,
1694 - clone fds (I chose it for now, it is the most universal
1697 POSIX 1003.1g does not actually define this clearly
1698 at all. POSIX 1003.1g doesn't define a lot of things
1703 siocb
->scm
->fp
= scm_fp_dup(UNIXCB(skb
).fp
);
1707 scm_recv(sock
, msg
, siocb
->scm
, flags
);
1710 skb_free_datagram(sk
, skb
);
1712 mutex_unlock(&u
->readlock
);
1718 * Sleep until data has arrive. But check for races..
1721 static long unix_stream_data_wait(struct sock
*sk
, long timeo
)
1725 unix_state_lock(sk
);
1728 prepare_to_wait(sk
->sk_sleep
, &wait
, TASK_INTERRUPTIBLE
);
1730 if (!skb_queue_empty(&sk
->sk_receive_queue
) ||
1732 (sk
->sk_shutdown
& RCV_SHUTDOWN
) ||
1733 signal_pending(current
) ||
1737 set_bit(SOCK_ASYNC_WAITDATA
, &sk
->sk_socket
->flags
);
1738 unix_state_unlock(sk
);
1739 timeo
= schedule_timeout(timeo
);
1740 unix_state_lock(sk
);
1741 clear_bit(SOCK_ASYNC_WAITDATA
, &sk
->sk_socket
->flags
);
1744 finish_wait(sk
->sk_sleep
, &wait
);
1745 unix_state_unlock(sk
);
1751 static int unix_stream_recvmsg(struct kiocb
*iocb
, struct socket
*sock
,
1752 struct msghdr
*msg
, size_t size
,
1755 struct sock_iocb
*siocb
= kiocb_to_siocb(iocb
);
1756 struct scm_cookie tmp_scm
;
1757 struct sock
*sk
= sock
->sk
;
1758 struct unix_sock
*u
= unix_sk(sk
);
1759 struct sockaddr_un
*sunaddr
= msg
->msg_name
;
1761 int check_creds
= 0;
1767 if (sk
->sk_state
!= TCP_ESTABLISHED
)
1774 target
= sock_rcvlowat(sk
, flags
&MSG_WAITALL
, size
);
1775 timeo
= sock_rcvtimeo(sk
, flags
&MSG_DONTWAIT
);
1777 msg
->msg_namelen
= 0;
1779 /* Lock the socket to prevent queue disordering
1780 * while sleeps in memcpy_tomsg
1784 siocb
->scm
= &tmp_scm
;
1785 memset(&tmp_scm
, 0, sizeof(tmp_scm
));
1788 mutex_lock(&u
->readlock
);
1792 struct sk_buff
*skb
;
1794 unix_state_lock(sk
);
1795 skb
= skb_dequeue(&sk
->sk_receive_queue
);
1797 if (copied
>= target
)
1801 * POSIX 1003.1g mandates this order.
1804 err
= sock_error(sk
);
1807 if (sk
->sk_shutdown
& RCV_SHUTDOWN
)
1810 unix_state_unlock(sk
);
1814 mutex_unlock(&u
->readlock
);
1816 timeo
= unix_stream_data_wait(sk
, timeo
);
1818 if (signal_pending(current
)) {
1819 err
= sock_intr_errno(timeo
);
1822 mutex_lock(&u
->readlock
);
1825 unix_state_unlock(sk
);
1828 unix_state_unlock(sk
);
1831 /* Never glue messages from different writers */
1832 if (memcmp(UNIXCREDS(skb
), &siocb
->scm
->creds
,
1833 sizeof(siocb
->scm
->creds
)) != 0) {
1834 skb_queue_head(&sk
->sk_receive_queue
, skb
);
1838 /* Copy credentials */
1839 siocb
->scm
->creds
= *UNIXCREDS(skb
);
1843 /* Copy address just once */
1845 unix_copy_addr(msg
, skb
->sk
);
1849 chunk
= min_t(unsigned int, skb
->len
, size
);
1850 if (memcpy_toiovec(msg
->msg_iov
, skb
->data
, chunk
)) {
1851 skb_queue_head(&sk
->sk_receive_queue
, skb
);
1859 /* Mark read part of skb as used */
1860 if (!(flags
& MSG_PEEK
)) {
1861 skb_pull(skb
, chunk
);
1864 unix_detach_fds(siocb
->scm
, skb
);
1866 /* put the skb back if we didn't use it up.. */
1868 skb_queue_head(&sk
->sk_receive_queue
, skb
);
1877 /* It is questionable, see note in unix_dgram_recvmsg.
1880 siocb
->scm
->fp
= scm_fp_dup(UNIXCB(skb
).fp
);
1882 /* put message back and return */
1883 skb_queue_head(&sk
->sk_receive_queue
, skb
);
1888 mutex_unlock(&u
->readlock
);
1889 scm_recv(sock
, msg
, siocb
->scm
, flags
);
1891 return copied
? : err
;
1894 static int unix_shutdown(struct socket
*sock
, int mode
)
1896 struct sock
*sk
= sock
->sk
;
1899 mode
= (mode
+1)&(RCV_SHUTDOWN
|SEND_SHUTDOWN
);
1902 unix_state_lock(sk
);
1903 sk
->sk_shutdown
|= mode
;
1904 other
= unix_peer(sk
);
1907 unix_state_unlock(sk
);
1908 sk
->sk_state_change(sk
);
1911 (sk
->sk_type
== SOCK_STREAM
|| sk
->sk_type
== SOCK_SEQPACKET
)) {
1915 if (mode
&RCV_SHUTDOWN
)
1916 peer_mode
|= SEND_SHUTDOWN
;
1917 if (mode
&SEND_SHUTDOWN
)
1918 peer_mode
|= RCV_SHUTDOWN
;
1919 unix_state_lock(other
);
1920 other
->sk_shutdown
|= peer_mode
;
1921 unix_state_unlock(other
);
1922 other
->sk_state_change(other
);
1923 read_lock(&other
->sk_callback_lock
);
1924 if (peer_mode
== SHUTDOWN_MASK
)
1925 sk_wake_async(other
, SOCK_WAKE_WAITD
, POLL_HUP
);
1926 else if (peer_mode
& RCV_SHUTDOWN
)
1927 sk_wake_async(other
, SOCK_WAKE_WAITD
, POLL_IN
);
1928 read_unlock(&other
->sk_callback_lock
);
1936 static int unix_ioctl(struct socket
*sock
, unsigned int cmd
, unsigned long arg
)
1938 struct sock
*sk
= sock
->sk
;
1944 amount
= atomic_read(&sk
->sk_wmem_alloc
);
1945 err
= put_user(amount
, (int __user
*)arg
);
1949 struct sk_buff
*skb
;
1951 if (sk
->sk_state
== TCP_LISTEN
) {
1956 spin_lock(&sk
->sk_receive_queue
.lock
);
1957 if (sk
->sk_type
== SOCK_STREAM
||
1958 sk
->sk_type
== SOCK_SEQPACKET
) {
1959 skb_queue_walk(&sk
->sk_receive_queue
, skb
)
1962 skb
= skb_peek(&sk
->sk_receive_queue
);
1966 spin_unlock(&sk
->sk_receive_queue
.lock
);
1967 err
= put_user(amount
, (int __user
*)arg
);
1978 static unsigned int unix_poll(struct file
*file
, struct socket
*sock
, poll_table
*wait
)
1980 struct sock
*sk
= sock
->sk
;
1983 poll_wait(file
, sk
->sk_sleep
, wait
);
1986 /* exceptional events? */
1989 if (sk
->sk_shutdown
== SHUTDOWN_MASK
)
1991 if (sk
->sk_shutdown
& RCV_SHUTDOWN
)
1995 if (!skb_queue_empty(&sk
->sk_receive_queue
) ||
1996 (sk
->sk_shutdown
& RCV_SHUTDOWN
))
1997 mask
|= POLLIN
| POLLRDNORM
;
1999 /* Connection-based need to check for termination and startup */
2000 if ((sk
->sk_type
== SOCK_STREAM
|| sk
->sk_type
== SOCK_SEQPACKET
) &&
2001 sk
->sk_state
== TCP_CLOSE
)
2005 * we set writable also when the other side has shut down the
2006 * connection. This prevents stuck sockets.
2008 if (unix_writable(sk
))
2009 mask
|= POLLOUT
| POLLWRNORM
| POLLWRBAND
;
2014 static unsigned int unix_dgram_poll(struct file
*file
, struct socket
*sock
,
2017 struct sock
*sk
= sock
->sk
, *other
;
2018 unsigned int mask
, writable
;
2020 poll_wait(file
, sk
->sk_sleep
, wait
);
2023 /* exceptional events? */
2024 if (sk
->sk_err
|| !skb_queue_empty(&sk
->sk_error_queue
))
2026 if (sk
->sk_shutdown
& RCV_SHUTDOWN
)
2028 if (sk
->sk_shutdown
== SHUTDOWN_MASK
)
2032 if (!skb_queue_empty(&sk
->sk_receive_queue
) ||
2033 (sk
->sk_shutdown
& RCV_SHUTDOWN
))
2034 mask
|= POLLIN
| POLLRDNORM
;
2036 /* Connection-based need to check for termination and startup */
2037 if (sk
->sk_type
== SOCK_SEQPACKET
) {
2038 if (sk
->sk_state
== TCP_CLOSE
)
2040 /* connection hasn't started yet? */
2041 if (sk
->sk_state
== TCP_SYN_SENT
)
2046 writable
= unix_writable(sk
);
2048 other
= unix_peer_get(sk
);
2050 if (unix_peer(other
) != sk
) {
2051 poll_wait(file
, &unix_sk(other
)->peer_wait
,
2053 if (unix_recvq_full(other
))
2062 mask
|= POLLOUT
| POLLWRNORM
| POLLWRBAND
;
2064 set_bit(SOCK_ASYNC_NOSPACE
, &sk
->sk_socket
->flags
);
2069 #ifdef CONFIG_PROC_FS
2070 static struct sock
*first_unix_socket(int *i
)
2072 for (*i
= 0; *i
<= UNIX_HASH_SIZE
; (*i
)++) {
2073 if (!hlist_empty(&unix_socket_table
[*i
]))
2074 return __sk_head(&unix_socket_table
[*i
]);
2079 static struct sock
*next_unix_socket(int *i
, struct sock
*s
)
2081 struct sock
*next
= sk_next(s
);
2082 /* More in this chain? */
2085 /* Look for next non-empty chain. */
2086 for ((*i
)++; *i
<= UNIX_HASH_SIZE
; (*i
)++) {
2087 if (!hlist_empty(&unix_socket_table
[*i
]))
2088 return __sk_head(&unix_socket_table
[*i
]);
2093 struct unix_iter_state
{
2094 struct seq_net_private p
;
2098 static struct sock
*unix_seq_idx(struct seq_file
*seq
, loff_t pos
)
2100 struct unix_iter_state
*iter
= seq
->private;
2104 for (s
= first_unix_socket(&iter
->i
); s
; s
= next_unix_socket(&iter
->i
, s
)) {
2105 if (sock_net(s
) != seq_file_net(seq
))
2114 static void *unix_seq_start(struct seq_file
*seq
, loff_t
*pos
)
2115 __acquires(unix_table_lock
)
2117 spin_lock(&unix_table_lock
);
2118 return *pos
? unix_seq_idx(seq
, *pos
- 1) : SEQ_START_TOKEN
;
2121 static void *unix_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
2123 struct unix_iter_state
*iter
= seq
->private;
2124 struct sock
*sk
= v
;
2127 if (v
== SEQ_START_TOKEN
)
2128 sk
= first_unix_socket(&iter
->i
);
2130 sk
= next_unix_socket(&iter
->i
, sk
);
2131 while (sk
&& (sock_net(sk
) != seq_file_net(seq
)))
2132 sk
= next_unix_socket(&iter
->i
, sk
);
2136 static void unix_seq_stop(struct seq_file
*seq
, void *v
)
2137 __releases(unix_table_lock
)
2139 spin_unlock(&unix_table_lock
);
2142 static int unix_seq_show(struct seq_file
*seq
, void *v
)
2145 if (v
== SEQ_START_TOKEN
)
2146 seq_puts(seq
, "Num RefCount Protocol Flags Type St "
2150 struct unix_sock
*u
= unix_sk(s
);
2153 seq_printf(seq
, "%p: %08X %08X %08X %04X %02X %5lu",
2155 atomic_read(&s
->sk_refcnt
),
2157 s
->sk_state
== TCP_LISTEN
? __SO_ACCEPTCON
: 0,
2160 (s
->sk_state
== TCP_ESTABLISHED
? SS_CONNECTED
: SS_UNCONNECTED
) :
2161 (s
->sk_state
== TCP_ESTABLISHED
? SS_CONNECTING
: SS_DISCONNECTING
),
2169 len
= u
->addr
->len
- sizeof(short);
2170 if (!UNIX_ABSTRACT(s
))
2176 for ( ; i
< len
; i
++)
2177 seq_putc(seq
, u
->addr
->name
->sun_path
[i
]);
2179 unix_state_unlock(s
);
2180 seq_putc(seq
, '\n');
2186 static const struct seq_operations unix_seq_ops
= {
2187 .start
= unix_seq_start
,
2188 .next
= unix_seq_next
,
2189 .stop
= unix_seq_stop
,
2190 .show
= unix_seq_show
,
2193 static int unix_seq_open(struct inode
*inode
, struct file
*file
)
2195 return seq_open_net(inode
, file
, &unix_seq_ops
,
2196 sizeof(struct unix_iter_state
));
2199 static const struct file_operations unix_seq_fops
= {
2200 .owner
= THIS_MODULE
,
2201 .open
= unix_seq_open
,
2203 .llseek
= seq_lseek
,
2204 .release
= seq_release_net
,
2209 static struct net_proto_family unix_family_ops
= {
2211 .create
= unix_create
,
2212 .owner
= THIS_MODULE
,
2216 static int unix_net_init(struct net
*net
)
2218 int error
= -ENOMEM
;
2220 net
->unx
.sysctl_max_dgram_qlen
= 10;
2221 if (unix_sysctl_register(net
))
2224 #ifdef CONFIG_PROC_FS
2225 if (!proc_net_fops_create(net
, "unix", 0, &unix_seq_fops
)) {
2226 unix_sysctl_unregister(net
);
2235 static void unix_net_exit(struct net
*net
)
2237 unix_sysctl_unregister(net
);
2238 proc_net_remove(net
, "unix");
2241 static struct pernet_operations unix_net_ops
= {
2242 .init
= unix_net_init
,
2243 .exit
= unix_net_exit
,
2246 static int __init
af_unix_init(void)
2249 struct sk_buff
*dummy_skb
;
2251 BUILD_BUG_ON(sizeof(struct unix_skb_parms
) > sizeof(dummy_skb
->cb
));
2253 rc
= proto_register(&unix_proto
, 1);
2255 printk(KERN_CRIT
"%s: Cannot create unix_sock SLAB cache!\n",
2260 sock_register(&unix_family_ops
);
2261 register_pernet_subsys(&unix_net_ops
);
2266 static void __exit
af_unix_exit(void)
2268 sock_unregister(PF_UNIX
);
2269 proto_unregister(&unix_proto
);
2270 unregister_pernet_subsys(&unix_net_ops
);
2273 /* Earlier than device_initcall() so that other drivers invoking
2274 request_module() don't end up in a loop when modprobe tries
2275 to use a UNIX socket. But later than subsys_initcall() because
2276 we depend on stuff initialised there */
2277 fs_initcall(af_unix_init
);
2278 module_exit(af_unix_exit
);
2280 MODULE_LICENSE("GPL");
2281 MODULE_ALIAS_NETPROTO(PF_UNIX
);