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>
117 #include <linux/freezer.h>
119 struct hlist_head unix_socket_table[2 * UNIX_HASH_SIZE];
120 EXPORT_SYMBOL_GPL(unix_socket_table);
121 DEFINE_SPINLOCK(unix_table_lock);
122 EXPORT_SYMBOL_GPL(unix_table_lock);
123 static atomic_long_t unix_nr_socks;
126 static struct hlist_head *unix_sockets_unbound(void *addr)
128 unsigned long hash = (unsigned long)addr;
132 hash %= UNIX_HASH_SIZE;
133 return &unix_socket_table[UNIX_HASH_SIZE + hash];
136 #define UNIX_ABSTRACT(sk) (unix_sk(sk)->addr->hash < UNIX_HASH_SIZE)
138 #ifdef CONFIG_SECURITY_NETWORK
139 static void unix_get_secdata(struct scm_cookie *scm, struct sk_buff *skb)
141 memcpy(UNIXSID(skb), &scm->secid, sizeof(u32));
144 static inline void unix_set_secdata(struct scm_cookie *scm, struct sk_buff *skb)
146 scm->secid = *UNIXSID(skb);
149 static inline void unix_get_secdata(struct scm_cookie *scm, struct sk_buff *skb)
152 static inline void unix_set_secdata(struct scm_cookie *scm, struct sk_buff *skb)
154 #endif /* CONFIG_SECURITY_NETWORK */
157 * SMP locking strategy:
158 * hash table is protected with spinlock unix_table_lock
159 * each socket state is protected by separate spin lock.
162 static inline unsigned int unix_hash_fold(__wsum n)
164 unsigned int hash = (__force unsigned int)n;
168 return hash&(UNIX_HASH_SIZE-1);
171 #define unix_peer(sk) (unix_sk(sk)->peer)
173 static inline int unix_our_peer(struct sock *sk, struct sock *osk)
175 return unix_peer(osk) == sk;
178 static inline int unix_may_send(struct sock *sk, struct sock *osk)
180 return unix_peer(osk) == NULL || unix_our_peer(sk, osk);
183 static inline int unix_recvq_full(struct sock const *sk)
185 return skb_queue_len(&sk->sk_receive_queue) > sk->sk_max_ack_backlog;
188 struct sock *unix_peer_get(struct sock *s)
196 unix_state_unlock(s);
199 EXPORT_SYMBOL_GPL(unix_peer_get);
201 static inline void unix_release_addr(struct unix_address *addr)
203 if (atomic_dec_and_test(&addr->refcnt))
208 * Check unix socket name:
209 * - should be not zero length.
210 * - if started by not zero, should be NULL terminated (FS object)
211 * - if started by zero, it is abstract name.
214 static int unix_mkname(struct sockaddr_un *sunaddr, int len, unsigned int *hashp)
216 if (len <= sizeof(short) || len > sizeof(*sunaddr))
218 if (!sunaddr || sunaddr->sun_family != AF_UNIX)
220 if (sunaddr->sun_path[0]) {
222 * This may look like an off by one error but it is a bit more
223 * subtle. 108 is the longest valid AF_UNIX path for a binding.
224 * sun_path[108] doesn't as such exist. However in kernel space
225 * we are guaranteed that it is a valid memory location in our
226 * kernel address buffer.
228 ((char *)sunaddr)[len] = 0;
229 len = strlen(sunaddr->sun_path)+1+sizeof(short);
233 *hashp = unix_hash_fold(csum_partial(sunaddr, len, 0));
237 static void __unix_remove_socket(struct sock *sk)
239 sk_del_node_init(sk);
242 static void __unix_insert_socket(struct hlist_head *list, struct sock *sk)
244 WARN_ON(!sk_unhashed(sk));
245 sk_add_node(sk, list);
248 static inline void unix_remove_socket(struct sock *sk)
250 spin_lock(&unix_table_lock);
251 __unix_remove_socket(sk);
252 spin_unlock(&unix_table_lock);
255 static inline void unix_insert_socket(struct hlist_head *list, struct sock *sk)
257 spin_lock(&unix_table_lock);
258 __unix_insert_socket(list, sk);
259 spin_unlock(&unix_table_lock);
262 static struct sock *__unix_find_socket_byname(struct net *net,
263 struct sockaddr_un *sunname,
264 int len, int type, unsigned int hash)
268 sk_for_each(s, &unix_socket_table[hash ^ type]) {
269 struct unix_sock *u = unix_sk(s);
271 if (!net_eq(sock_net(s), net))
274 if (u->addr->len == len &&
275 !memcmp(u->addr->name, sunname, len))
283 static inline struct sock *unix_find_socket_byname(struct net *net,
284 struct sockaddr_un *sunname,
290 spin_lock(&unix_table_lock);
291 s = __unix_find_socket_byname(net, sunname, len, type, hash);
294 spin_unlock(&unix_table_lock);
298 static struct sock *unix_find_socket_byinode(struct inode *i)
302 spin_lock(&unix_table_lock);
304 &unix_socket_table[i->i_ino & (UNIX_HASH_SIZE - 1)]) {
305 struct dentry *dentry = unix_sk(s)->path.dentry;
307 if (dentry && dentry->d_inode == i) {
314 spin_unlock(&unix_table_lock);
318 static inline int unix_writable(struct sock *sk)
320 return (atomic_read(&sk->sk_wmem_alloc) << 2) <= sk->sk_sndbuf;
323 static void unix_write_space(struct sock *sk)
325 struct socket_wq *wq;
328 if (unix_writable(sk)) {
329 wq = rcu_dereference(sk->sk_wq);
330 if (wq_has_sleeper(wq))
331 wake_up_interruptible_sync_poll(&wq->wait,
332 POLLOUT | POLLWRNORM | POLLWRBAND);
333 sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
338 /* When dgram socket disconnects (or changes its peer), we clear its receive
339 * queue of packets arrived from previous peer. First, it allows to do
340 * flow control based only on wmem_alloc; second, sk connected to peer
341 * may receive messages only from that peer. */
342 static void unix_dgram_disconnected(struct sock *sk, struct sock *other)
344 if (!skb_queue_empty(&sk->sk_receive_queue)) {
345 skb_queue_purge(&sk->sk_receive_queue);
346 wake_up_interruptible_all(&unix_sk(sk)->peer_wait);
348 /* If one link of bidirectional dgram pipe is disconnected,
349 * we signal error. Messages are lost. Do not make this,
350 * when peer was not connected to us.
352 if (!sock_flag(other, SOCK_DEAD) && unix_peer(other) == sk) {
353 other->sk_err = ECONNRESET;
354 other->sk_error_report(other);
359 static void unix_sock_destructor(struct sock *sk)
361 struct unix_sock *u = unix_sk(sk);
363 skb_queue_purge(&sk->sk_receive_queue);
365 WARN_ON(atomic_read(&sk->sk_wmem_alloc));
366 WARN_ON(!sk_unhashed(sk));
367 WARN_ON(sk->sk_socket);
368 if (!sock_flag(sk, SOCK_DEAD)) {
369 printk(KERN_INFO "Attempt to release alive unix socket: %p\n", sk);
374 unix_release_addr(u->addr);
376 atomic_long_dec(&unix_nr_socks);
378 sock_prot_inuse_add(sock_net(sk), sk->sk_prot, -1);
380 #ifdef UNIX_REFCNT_DEBUG
381 printk(KERN_DEBUG "UNIX %p is destroyed, %ld are still alive.\n", sk,
382 atomic_long_read(&unix_nr_socks));
386 static void unix_release_sock(struct sock *sk, int embrion)
388 struct unix_sock *u = unix_sk(sk);
394 unix_remove_socket(sk);
399 sk->sk_shutdown = SHUTDOWN_MASK;
401 u->path.dentry = NULL;
403 state = sk->sk_state;
404 sk->sk_state = TCP_CLOSE;
405 unix_state_unlock(sk);
407 wake_up_interruptible_all(&u->peer_wait);
409 skpair = unix_peer(sk);
411 if (skpair != NULL) {
412 if (sk->sk_type == SOCK_STREAM || sk->sk_type == SOCK_SEQPACKET) {
413 unix_state_lock(skpair);
415 skpair->sk_shutdown = SHUTDOWN_MASK;
416 if (!skb_queue_empty(&sk->sk_receive_queue) || embrion)
417 skpair->sk_err = ECONNRESET;
418 unix_state_unlock(skpair);
419 skpair->sk_state_change(skpair);
420 sk_wake_async(skpair, SOCK_WAKE_WAITD, POLL_HUP);
422 sock_put(skpair); /* It may now die */
423 unix_peer(sk) = NULL;
426 /* Try to flush out this socket. Throw out buffers at least */
428 while ((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL) {
429 if (state == TCP_LISTEN)
430 unix_release_sock(skb->sk, 1);
431 /* passed fds are erased in the kfree_skb hook */
440 /* ---- Socket is dead now and most probably destroyed ---- */
443 * Fixme: BSD difference: In BSD all sockets connected to us get
444 * ECONNRESET and we die on the spot. In Linux we behave
445 * like files and pipes do and wait for the last
448 * Can't we simply set sock->err?
450 * What the above comment does talk about? --ANK(980817)
453 if (unix_tot_inflight)
454 unix_gc(); /* Garbage collect fds */
457 static void init_peercred(struct sock *sk)
459 put_pid(sk->sk_peer_pid);
460 if (sk->sk_peer_cred)
461 put_cred(sk->sk_peer_cred);
462 sk->sk_peer_pid = get_pid(task_tgid(current));
463 sk->sk_peer_cred = get_current_cred();
466 static void copy_peercred(struct sock *sk, struct sock *peersk)
468 put_pid(sk->sk_peer_pid);
469 if (sk->sk_peer_cred)
470 put_cred(sk->sk_peer_cred);
471 sk->sk_peer_pid = get_pid(peersk->sk_peer_pid);
472 sk->sk_peer_cred = get_cred(peersk->sk_peer_cred);
475 static int unix_listen(struct socket *sock, int backlog)
478 struct sock *sk = sock->sk;
479 struct unix_sock *u = unix_sk(sk);
480 struct pid *old_pid = NULL;
483 if (sock->type != SOCK_STREAM && sock->type != SOCK_SEQPACKET)
484 goto out; /* Only stream/seqpacket sockets accept */
487 goto out; /* No listens on an unbound socket */
489 if (sk->sk_state != TCP_CLOSE && sk->sk_state != TCP_LISTEN)
491 if (backlog > sk->sk_max_ack_backlog)
492 wake_up_interruptible_all(&u->peer_wait);
493 sk->sk_max_ack_backlog = backlog;
494 sk->sk_state = TCP_LISTEN;
495 /* set credentials so connect can copy them */
500 unix_state_unlock(sk);
506 static int unix_release(struct socket *);
507 static int unix_bind(struct socket *, struct sockaddr *, int);
508 static int unix_stream_connect(struct socket *, struct sockaddr *,
509 int addr_len, int flags);
510 static int unix_socketpair(struct socket *, struct socket *);
511 static int unix_accept(struct socket *, struct socket *, int);
512 static int unix_getname(struct socket *, struct sockaddr *, int *, int);
513 static unsigned int unix_poll(struct file *, struct socket *, poll_table *);
514 static unsigned int unix_dgram_poll(struct file *, struct socket *,
516 static int unix_ioctl(struct socket *, unsigned int, unsigned long);
517 static int unix_shutdown(struct socket *, int);
518 static int unix_stream_sendmsg(struct kiocb *, struct socket *,
519 struct msghdr *, size_t);
520 static int unix_stream_recvmsg(struct kiocb *, struct socket *,
521 struct msghdr *, size_t, int);
522 static int unix_dgram_sendmsg(struct kiocb *, struct socket *,
523 struct msghdr *, size_t);
524 static int unix_dgram_recvmsg(struct kiocb *, struct socket *,
525 struct msghdr *, size_t, int);
526 static int unix_dgram_connect(struct socket *, struct sockaddr *,
528 static int unix_seqpacket_sendmsg(struct kiocb *, struct socket *,
529 struct msghdr *, size_t);
530 static int unix_seqpacket_recvmsg(struct kiocb *, struct socket *,
531 struct msghdr *, size_t, int);
533 static void unix_set_peek_off(struct sock *sk, int val)
535 struct unix_sock *u = unix_sk(sk);
537 mutex_lock(&u->readlock);
538 sk->sk_peek_off = val;
539 mutex_unlock(&u->readlock);
543 static const struct proto_ops unix_stream_ops = {
545 .owner = THIS_MODULE,
546 .release = unix_release,
548 .connect = unix_stream_connect,
549 .socketpair = unix_socketpair,
550 .accept = unix_accept,
551 .getname = unix_getname,
554 .listen = unix_listen,
555 .shutdown = unix_shutdown,
556 .setsockopt = sock_no_setsockopt,
557 .getsockopt = sock_no_getsockopt,
558 .sendmsg = unix_stream_sendmsg,
559 .recvmsg = unix_stream_recvmsg,
560 .mmap = sock_no_mmap,
561 .sendpage = sock_no_sendpage,
562 .set_peek_off = unix_set_peek_off,
565 static const struct proto_ops unix_dgram_ops = {
567 .owner = THIS_MODULE,
568 .release = unix_release,
570 .connect = unix_dgram_connect,
571 .socketpair = unix_socketpair,
572 .accept = sock_no_accept,
573 .getname = unix_getname,
574 .poll = unix_dgram_poll,
576 .listen = sock_no_listen,
577 .shutdown = unix_shutdown,
578 .setsockopt = sock_no_setsockopt,
579 .getsockopt = sock_no_getsockopt,
580 .sendmsg = unix_dgram_sendmsg,
581 .recvmsg = unix_dgram_recvmsg,
582 .mmap = sock_no_mmap,
583 .sendpage = sock_no_sendpage,
584 .set_peek_off = unix_set_peek_off,
587 static const struct proto_ops unix_seqpacket_ops = {
589 .owner = THIS_MODULE,
590 .release = unix_release,
592 .connect = unix_stream_connect,
593 .socketpair = unix_socketpair,
594 .accept = unix_accept,
595 .getname = unix_getname,
596 .poll = unix_dgram_poll,
598 .listen = unix_listen,
599 .shutdown = unix_shutdown,
600 .setsockopt = sock_no_setsockopt,
601 .getsockopt = sock_no_getsockopt,
602 .sendmsg = unix_seqpacket_sendmsg,
603 .recvmsg = unix_seqpacket_recvmsg,
604 .mmap = sock_no_mmap,
605 .sendpage = sock_no_sendpage,
606 .set_peek_off = unix_set_peek_off,
609 static struct proto unix_proto = {
611 .owner = THIS_MODULE,
612 .obj_size = sizeof(struct unix_sock),
616 * AF_UNIX sockets do not interact with hardware, hence they
617 * dont trigger interrupts - so it's safe for them to have
618 * bh-unsafe locking for their sk_receive_queue.lock. Split off
619 * this special lock-class by reinitializing the spinlock key:
621 static struct lock_class_key af_unix_sk_receive_queue_lock_key;
623 static struct sock *unix_create1(struct net *net, struct socket *sock)
625 struct sock *sk = NULL;
628 atomic_long_inc(&unix_nr_socks);
629 if (atomic_long_read(&unix_nr_socks) > 2 * get_max_files())
632 sk = sk_alloc(net, PF_UNIX, GFP_KERNEL, &unix_proto);
636 sock_init_data(sock, sk);
637 lockdep_set_class(&sk->sk_receive_queue.lock,
638 &af_unix_sk_receive_queue_lock_key);
640 sk->sk_write_space = unix_write_space;
641 sk->sk_max_ack_backlog = net->unx.sysctl_max_dgram_qlen;
642 sk->sk_destruct = unix_sock_destructor;
644 u->path.dentry = NULL;
646 spin_lock_init(&u->lock);
647 atomic_long_set(&u->inflight, 0);
648 INIT_LIST_HEAD(&u->link);
649 mutex_init(&u->readlock); /* single task reading lock */
650 init_waitqueue_head(&u->peer_wait);
651 unix_insert_socket(unix_sockets_unbound(sk), sk);
654 atomic_long_dec(&unix_nr_socks);
657 sock_prot_inuse_add(sock_net(sk), sk->sk_prot, 1);
663 static int unix_create(struct net *net, struct socket *sock, int protocol,
666 if (protocol && protocol != PF_UNIX)
667 return -EPROTONOSUPPORT;
669 sock->state = SS_UNCONNECTED;
671 switch (sock->type) {
673 sock->ops = &unix_stream_ops;
676 * Believe it or not BSD has AF_UNIX, SOCK_RAW though
680 sock->type = SOCK_DGRAM;
682 sock->ops = &unix_dgram_ops;
685 sock->ops = &unix_seqpacket_ops;
688 return -ESOCKTNOSUPPORT;
691 return unix_create1(net, sock) ? 0 : -ENOMEM;
694 static int unix_release(struct socket *sock)
696 struct sock *sk = sock->sk;
701 unix_release_sock(sk, 0);
707 static int unix_autobind(struct socket *sock)
709 struct sock *sk = sock->sk;
710 struct net *net = sock_net(sk);
711 struct unix_sock *u = unix_sk(sk);
712 static u32 ordernum = 1;
713 struct unix_address *addr;
715 unsigned int retries = 0;
717 mutex_lock(&u->readlock);
724 addr = kzalloc(sizeof(*addr) + sizeof(short) + 16, GFP_KERNEL);
728 addr->name->sun_family = AF_UNIX;
729 atomic_set(&addr->refcnt, 1);
732 addr->len = sprintf(addr->name->sun_path+1, "%05x", ordernum) + 1 + sizeof(short);
733 addr->hash = unix_hash_fold(csum_partial(addr->name, addr->len, 0));
735 spin_lock(&unix_table_lock);
736 ordernum = (ordernum+1)&0xFFFFF;
738 if (__unix_find_socket_byname(net, addr->name, addr->len, sock->type,
740 spin_unlock(&unix_table_lock);
742 * __unix_find_socket_byname() may take long time if many names
743 * are already in use.
746 /* Give up if all names seems to be in use. */
747 if (retries++ == 0xFFFFF) {
754 addr->hash ^= sk->sk_type;
756 __unix_remove_socket(sk);
758 __unix_insert_socket(&unix_socket_table[addr->hash], sk);
759 spin_unlock(&unix_table_lock);
762 out: mutex_unlock(&u->readlock);
766 static struct sock *unix_find_other(struct net *net,
767 struct sockaddr_un *sunname, int len,
768 int type, unsigned int hash, int *error)
774 if (sunname->sun_path[0]) {
776 err = kern_path(sunname->sun_path, LOOKUP_FOLLOW, &path);
779 inode = path.dentry->d_inode;
780 err = inode_permission(inode, MAY_WRITE);
785 if (!S_ISSOCK(inode->i_mode))
787 u = unix_find_socket_byinode(inode);
791 if (u->sk_type == type)
797 if (u->sk_type != type) {
803 u = unix_find_socket_byname(net, sunname, len, type, hash);
805 struct dentry *dentry;
806 dentry = unix_sk(u)->path.dentry;
808 touch_atime(&unix_sk(u)->path);
821 static int unix_mknod(const char *sun_path, umode_t mode, struct path *res)
823 struct dentry *dentry;
827 * Get the parent directory, calculate the hash for last
830 dentry = kern_path_create(AT_FDCWD, sun_path, &path, 0);
831 err = PTR_ERR(dentry);
836 * All right, let's create it.
838 err = security_path_mknod(&path, dentry, mode, 0);
840 err = vfs_mknod(path.dentry->d_inode, dentry, mode, 0);
842 res->mnt = mntget(path.mnt);
843 res->dentry = dget(dentry);
846 done_path_create(&path, dentry);
850 static int unix_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
852 struct sock *sk = sock->sk;
853 struct net *net = sock_net(sk);
854 struct unix_sock *u = unix_sk(sk);
855 struct sockaddr_un *sunaddr = (struct sockaddr_un *)uaddr;
856 char *sun_path = sunaddr->sun_path;
859 struct unix_address *addr;
860 struct hlist_head *list;
863 if (sunaddr->sun_family != AF_UNIX)
866 if (addr_len == sizeof(short)) {
867 err = unix_autobind(sock);
871 err = unix_mkname(sunaddr, addr_len, &hash);
876 mutex_lock(&u->readlock);
883 addr = kmalloc(sizeof(*addr)+addr_len, GFP_KERNEL);
887 memcpy(addr->name, sunaddr, addr_len);
888 addr->len = addr_len;
889 addr->hash = hash ^ sk->sk_type;
890 atomic_set(&addr->refcnt, 1);
894 umode_t mode = S_IFSOCK |
895 (SOCK_INODE(sock)->i_mode & ~current_umask());
896 err = unix_mknod(sun_path, mode, &path);
900 unix_release_addr(addr);
903 addr->hash = UNIX_HASH_SIZE;
904 hash = path.dentry->d_inode->i_ino & (UNIX_HASH_SIZE-1);
905 spin_lock(&unix_table_lock);
907 list = &unix_socket_table[hash];
909 spin_lock(&unix_table_lock);
911 if (__unix_find_socket_byname(net, sunaddr, addr_len,
912 sk->sk_type, hash)) {
913 unix_release_addr(addr);
917 list = &unix_socket_table[addr->hash];
921 __unix_remove_socket(sk);
923 __unix_insert_socket(list, sk);
926 spin_unlock(&unix_table_lock);
928 mutex_unlock(&u->readlock);
933 static void unix_state_double_lock(struct sock *sk1, struct sock *sk2)
935 if (unlikely(sk1 == sk2) || !sk2) {
936 unix_state_lock(sk1);
940 unix_state_lock(sk1);
941 unix_state_lock_nested(sk2);
943 unix_state_lock(sk2);
944 unix_state_lock_nested(sk1);
948 static void unix_state_double_unlock(struct sock *sk1, struct sock *sk2)
950 if (unlikely(sk1 == sk2) || !sk2) {
951 unix_state_unlock(sk1);
954 unix_state_unlock(sk1);
955 unix_state_unlock(sk2);
958 static int unix_dgram_connect(struct socket *sock, struct sockaddr *addr,
961 struct sock *sk = sock->sk;
962 struct net *net = sock_net(sk);
963 struct sockaddr_un *sunaddr = (struct sockaddr_un *)addr;
968 if (addr->sa_family != AF_UNSPEC) {
969 err = unix_mkname(sunaddr, alen, &hash);
974 if (test_bit(SOCK_PASSCRED, &sock->flags) &&
975 !unix_sk(sk)->addr && (err = unix_autobind(sock)) != 0)
979 other = unix_find_other(net, sunaddr, alen, sock->type, hash, &err);
983 unix_state_double_lock(sk, other);
985 /* Apparently VFS overslept socket death. Retry. */
986 if (sock_flag(other, SOCK_DEAD)) {
987 unix_state_double_unlock(sk, other);
993 if (!unix_may_send(sk, other))
996 err = security_unix_may_send(sk->sk_socket, other->sk_socket);
1002 * 1003.1g breaking connected state with AF_UNSPEC
1005 unix_state_double_lock(sk, other);
1009 * If it was connected, reconnect.
1011 if (unix_peer(sk)) {
1012 struct sock *old_peer = unix_peer(sk);
1013 unix_peer(sk) = other;
1014 unix_state_double_unlock(sk, other);
1016 if (other != old_peer)
1017 unix_dgram_disconnected(sk, old_peer);
1020 unix_peer(sk) = other;
1021 unix_state_double_unlock(sk, other);
1026 unix_state_double_unlock(sk, other);
1032 static long unix_wait_for_peer(struct sock *other, long timeo)
1034 struct unix_sock *u = unix_sk(other);
1038 prepare_to_wait_exclusive(&u->peer_wait, &wait, TASK_INTERRUPTIBLE);
1040 sched = !sock_flag(other, SOCK_DEAD) &&
1041 !(other->sk_shutdown & RCV_SHUTDOWN) &&
1042 unix_recvq_full(other);
1044 unix_state_unlock(other);
1047 timeo = schedule_timeout(timeo);
1049 finish_wait(&u->peer_wait, &wait);
1053 static int unix_stream_connect(struct socket *sock, struct sockaddr *uaddr,
1054 int addr_len, int flags)
1056 struct sockaddr_un *sunaddr = (struct sockaddr_un *)uaddr;
1057 struct sock *sk = sock->sk;
1058 struct net *net = sock_net(sk);
1059 struct unix_sock *u = unix_sk(sk), *newu, *otheru;
1060 struct sock *newsk = NULL;
1061 struct sock *other = NULL;
1062 struct sk_buff *skb = NULL;
1068 err = unix_mkname(sunaddr, addr_len, &hash);
1073 if (test_bit(SOCK_PASSCRED, &sock->flags) && !u->addr &&
1074 (err = unix_autobind(sock)) != 0)
1077 timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
1079 /* First of all allocate resources.
1080 If we will make it after state is locked,
1081 we will have to recheck all again in any case.
1086 /* create new sock for complete connection */
1087 newsk = unix_create1(sock_net(sk), NULL);
1091 /* Allocate skb for sending to listening sock */
1092 skb = sock_wmalloc(newsk, 1, 0, GFP_KERNEL);
1097 /* Find listening sock. */
1098 other = unix_find_other(net, sunaddr, addr_len, sk->sk_type, hash, &err);
1102 /* Latch state of peer */
1103 unix_state_lock(other);
1105 /* Apparently VFS overslept socket death. Retry. */
1106 if (sock_flag(other, SOCK_DEAD)) {
1107 unix_state_unlock(other);
1112 err = -ECONNREFUSED;
1113 if (other->sk_state != TCP_LISTEN)
1115 if (other->sk_shutdown & RCV_SHUTDOWN)
1118 if (unix_recvq_full(other)) {
1123 timeo = unix_wait_for_peer(other, timeo);
1125 err = sock_intr_errno(timeo);
1126 if (signal_pending(current))
1134 It is tricky place. We need to grab our state lock and cannot
1135 drop lock on peer. It is dangerous because deadlock is
1136 possible. Connect to self case and simultaneous
1137 attempt to connect are eliminated by checking socket
1138 state. other is TCP_LISTEN, if sk is TCP_LISTEN we
1139 check this before attempt to grab lock.
1141 Well, and we have to recheck the state after socket locked.
1147 /* This is ok... continue with connect */
1149 case TCP_ESTABLISHED:
1150 /* Socket is already connected */
1158 unix_state_lock_nested(sk);
1160 if (sk->sk_state != st) {
1161 unix_state_unlock(sk);
1162 unix_state_unlock(other);
1167 err = security_unix_stream_connect(sk, other, newsk);
1169 unix_state_unlock(sk);
1173 /* The way is open! Fastly set all the necessary fields... */
1176 unix_peer(newsk) = sk;
1177 newsk->sk_state = TCP_ESTABLISHED;
1178 newsk->sk_type = sk->sk_type;
1179 init_peercred(newsk);
1180 newu = unix_sk(newsk);
1181 RCU_INIT_POINTER(newsk->sk_wq, &newu->peer_wq);
1182 otheru = unix_sk(other);
1184 /* copy address information from listening to new sock*/
1186 atomic_inc(&otheru->addr->refcnt);
1187 newu->addr = otheru->addr;
1189 if (otheru->path.dentry) {
1190 path_get(&otheru->path);
1191 newu->path = otheru->path;
1194 /* Set credentials */
1195 copy_peercred(sk, other);
1197 sock->state = SS_CONNECTED;
1198 sk->sk_state = TCP_ESTABLISHED;
1201 smp_mb__after_atomic_inc(); /* sock_hold() does an atomic_inc() */
1202 unix_peer(sk) = newsk;
1204 unix_state_unlock(sk);
1206 /* take ten and and send info to listening sock */
1207 spin_lock(&other->sk_receive_queue.lock);
1208 __skb_queue_tail(&other->sk_receive_queue, skb);
1209 spin_unlock(&other->sk_receive_queue.lock);
1210 unix_state_unlock(other);
1211 other->sk_data_ready(other, 0);
1217 unix_state_unlock(other);
1222 unix_release_sock(newsk, 0);
1228 static int unix_socketpair(struct socket *socka, struct socket *sockb)
1230 struct sock *ska = socka->sk, *skb = sockb->sk;
1232 /* Join our sockets back to back */
1235 unix_peer(ska) = skb;
1236 unix_peer(skb) = ska;
1240 if (ska->sk_type != SOCK_DGRAM) {
1241 ska->sk_state = TCP_ESTABLISHED;
1242 skb->sk_state = TCP_ESTABLISHED;
1243 socka->state = SS_CONNECTED;
1244 sockb->state = SS_CONNECTED;
1249 static int unix_accept(struct socket *sock, struct socket *newsock, int flags)
1251 struct sock *sk = sock->sk;
1253 struct sk_buff *skb;
1257 if (sock->type != SOCK_STREAM && sock->type != SOCK_SEQPACKET)
1261 if (sk->sk_state != TCP_LISTEN)
1264 /* If socket state is TCP_LISTEN it cannot change (for now...),
1265 * so that no locks are necessary.
1268 skb = skb_recv_datagram(sk, 0, flags&O_NONBLOCK, &err);
1270 /* This means receive shutdown. */
1277 skb_free_datagram(sk, skb);
1278 wake_up_interruptible(&unix_sk(sk)->peer_wait);
1280 /* attach accepted sock to socket */
1281 unix_state_lock(tsk);
1282 newsock->state = SS_CONNECTED;
1283 sock_graft(tsk, newsock);
1284 unix_state_unlock(tsk);
1292 static int unix_getname(struct socket *sock, struct sockaddr *uaddr, int *uaddr_len, int peer)
1294 struct sock *sk = sock->sk;
1295 struct unix_sock *u;
1296 DECLARE_SOCKADDR(struct sockaddr_un *, sunaddr, uaddr);
1300 sk = unix_peer_get(sk);
1311 unix_state_lock(sk);
1313 sunaddr->sun_family = AF_UNIX;
1314 sunaddr->sun_path[0] = 0;
1315 *uaddr_len = sizeof(short);
1317 struct unix_address *addr = u->addr;
1319 *uaddr_len = addr->len;
1320 memcpy(sunaddr, addr->name, *uaddr_len);
1322 unix_state_unlock(sk);
1328 static void unix_detach_fds(struct scm_cookie *scm, struct sk_buff *skb)
1332 scm->fp = UNIXCB(skb).fp;
1333 UNIXCB(skb).fp = NULL;
1335 for (i = scm->fp->count-1; i >= 0; i--)
1336 unix_notinflight(scm->fp->fp[i]);
1339 static void unix_destruct_scm(struct sk_buff *skb)
1341 struct scm_cookie scm;
1342 memset(&scm, 0, sizeof(scm));
1343 scm.pid = UNIXCB(skb).pid;
1345 unix_detach_fds(&scm, skb);
1347 /* Alas, it calls VFS */
1348 /* So fscking what? fput() had been SMP-safe since the last Summer */
1353 #define MAX_RECURSION_LEVEL 4
1355 static int unix_attach_fds(struct scm_cookie *scm, struct sk_buff *skb)
1358 unsigned char max_level = 0;
1359 int unix_sock_count = 0;
1361 for (i = scm->fp->count - 1; i >= 0; i--) {
1362 struct sock *sk = unix_get_socket(scm->fp->fp[i]);
1366 max_level = max(max_level,
1367 unix_sk(sk)->recursion_level);
1370 if (unlikely(max_level > MAX_RECURSION_LEVEL))
1371 return -ETOOMANYREFS;
1374 * Need to duplicate file references for the sake of garbage
1375 * collection. Otherwise a socket in the fps might become a
1376 * candidate for GC while the skb is not yet queued.
1378 UNIXCB(skb).fp = scm_fp_dup(scm->fp);
1379 if (!UNIXCB(skb).fp)
1382 if (unix_sock_count) {
1383 for (i = scm->fp->count - 1; i >= 0; i--)
1384 unix_inflight(scm->fp->fp[i]);
1389 static int unix_scm_to_skb(struct scm_cookie *scm, struct sk_buff *skb, bool send_fds)
1393 UNIXCB(skb).pid = get_pid(scm->pid);
1394 UNIXCB(skb).uid = scm->creds.uid;
1395 UNIXCB(skb).gid = scm->creds.gid;
1396 UNIXCB(skb).fp = NULL;
1397 if (scm->fp && send_fds)
1398 err = unix_attach_fds(scm, skb);
1400 skb->destructor = unix_destruct_scm;
1405 * Some apps rely on write() giving SCM_CREDENTIALS
1406 * We include credentials if source or destination socket
1407 * asserted SOCK_PASSCRED.
1409 static void maybe_add_creds(struct sk_buff *skb, const struct socket *sock,
1410 const struct sock *other)
1412 if (UNIXCB(skb).pid)
1414 if (test_bit(SOCK_PASSCRED, &sock->flags) ||
1415 !other->sk_socket ||
1416 test_bit(SOCK_PASSCRED, &other->sk_socket->flags)) {
1417 UNIXCB(skb).pid = get_pid(task_tgid(current));
1418 current_uid_gid(&UNIXCB(skb).uid, &UNIXCB(skb).gid);
1423 * Send AF_UNIX data.
1426 static int unix_dgram_sendmsg(struct kiocb *kiocb, struct socket *sock,
1427 struct msghdr *msg, size_t len)
1429 struct sock_iocb *siocb = kiocb_to_siocb(kiocb);
1430 struct sock *sk = sock->sk;
1431 struct net *net = sock_net(sk);
1432 struct unix_sock *u = unix_sk(sk);
1433 struct sockaddr_un *sunaddr = msg->msg_name;
1434 struct sock *other = NULL;
1435 int namelen = 0; /* fake GCC */
1438 struct sk_buff *skb;
1440 struct scm_cookie tmp_scm;
1444 if (NULL == siocb->scm)
1445 siocb->scm = &tmp_scm;
1447 err = scm_send(sock, msg, siocb->scm, false);
1452 if (msg->msg_flags&MSG_OOB)
1455 if (msg->msg_namelen) {
1456 err = unix_mkname(sunaddr, msg->msg_namelen, &hash);
1463 other = unix_peer_get(sk);
1468 if (test_bit(SOCK_PASSCRED, &sock->flags) && !u->addr
1469 && (err = unix_autobind(sock)) != 0)
1473 if (len > sk->sk_sndbuf - 32)
1476 if (len > SKB_MAX_ALLOC)
1477 data_len = min_t(size_t,
1478 len - SKB_MAX_ALLOC,
1479 MAX_SKB_FRAGS * PAGE_SIZE);
1481 skb = sock_alloc_send_pskb(sk, len - data_len, data_len,
1482 msg->msg_flags & MSG_DONTWAIT, &err);
1486 err = unix_scm_to_skb(siocb->scm, skb, true);
1489 max_level = err + 1;
1490 unix_get_secdata(siocb->scm, skb);
1492 skb_put(skb, len - data_len);
1493 skb->data_len = data_len;
1495 err = skb_copy_datagram_from_iovec(skb, 0, msg->msg_iov, 0, len);
1499 timeo = sock_sndtimeo(sk, msg->msg_flags & MSG_DONTWAIT);
1504 if (sunaddr == NULL)
1507 other = unix_find_other(net, sunaddr, namelen, sk->sk_type,
1513 if (sk_filter(other, skb) < 0) {
1514 /* Toss the packet but do not return any error to the sender */
1519 unix_state_lock(other);
1521 if (!unix_may_send(sk, other))
1524 if (sock_flag(other, SOCK_DEAD)) {
1526 * Check with 1003.1g - what should
1529 unix_state_unlock(other);
1533 unix_state_lock(sk);
1534 if (unix_peer(sk) == other) {
1535 unix_peer(sk) = NULL;
1536 unix_state_unlock(sk);
1538 unix_dgram_disconnected(sk, other);
1540 err = -ECONNREFUSED;
1542 unix_state_unlock(sk);
1552 if (other->sk_shutdown & RCV_SHUTDOWN)
1555 if (sk->sk_type != SOCK_SEQPACKET) {
1556 err = security_unix_may_send(sk->sk_socket, other->sk_socket);
1561 if (unix_peer(other) != sk && unix_recvq_full(other)) {
1567 timeo = unix_wait_for_peer(other, timeo);
1569 err = sock_intr_errno(timeo);
1570 if (signal_pending(current))
1576 if (sock_flag(other, SOCK_RCVTSTAMP))
1577 __net_timestamp(skb);
1578 maybe_add_creds(skb, sock, other);
1579 skb_queue_tail(&other->sk_receive_queue, skb);
1580 if (max_level > unix_sk(other)->recursion_level)
1581 unix_sk(other)->recursion_level = max_level;
1582 unix_state_unlock(other);
1583 other->sk_data_ready(other, len);
1585 scm_destroy(siocb->scm);
1589 unix_state_unlock(other);
1595 scm_destroy(siocb->scm);
1600 static int unix_stream_sendmsg(struct kiocb *kiocb, struct socket *sock,
1601 struct msghdr *msg, size_t len)
1603 struct sock_iocb *siocb = kiocb_to_siocb(kiocb);
1604 struct sock *sk = sock->sk;
1605 struct sock *other = NULL;
1607 struct sk_buff *skb;
1609 struct scm_cookie tmp_scm;
1610 bool fds_sent = false;
1613 if (NULL == siocb->scm)
1614 siocb->scm = &tmp_scm;
1616 err = scm_send(sock, msg, siocb->scm, false);
1621 if (msg->msg_flags&MSG_OOB)
1624 if (msg->msg_namelen) {
1625 err = sk->sk_state == TCP_ESTABLISHED ? -EISCONN : -EOPNOTSUPP;
1629 other = unix_peer(sk);
1634 if (sk->sk_shutdown & SEND_SHUTDOWN)
1637 while (sent < len) {
1639 * Optimisation for the fact that under 0.01% of X
1640 * messages typically need breaking up.
1645 /* Keep two messages in the pipe so it schedules better */
1646 if (size > ((sk->sk_sndbuf >> 1) - 64))
1647 size = (sk->sk_sndbuf >> 1) - 64;
1649 if (size > SKB_MAX_ALLOC)
1650 size = SKB_MAX_ALLOC;
1656 skb = sock_alloc_send_skb(sk, size, msg->msg_flags&MSG_DONTWAIT,
1663 * If you pass two values to the sock_alloc_send_skb
1664 * it tries to grab the large buffer with GFP_NOFS
1665 * (which can fail easily), and if it fails grab the
1666 * fallback size buffer which is under a page and will
1669 size = min_t(int, size, skb_tailroom(skb));
1672 /* Only send the fds in the first buffer */
1673 err = unix_scm_to_skb(siocb->scm, skb, !fds_sent);
1678 max_level = err + 1;
1681 err = memcpy_fromiovec(skb_put(skb, size), msg->msg_iov, size);
1687 unix_state_lock(other);
1689 if (sock_flag(other, SOCK_DEAD) ||
1690 (other->sk_shutdown & RCV_SHUTDOWN))
1693 maybe_add_creds(skb, sock, other);
1694 skb_queue_tail(&other->sk_receive_queue, skb);
1695 if (max_level > unix_sk(other)->recursion_level)
1696 unix_sk(other)->recursion_level = max_level;
1697 unix_state_unlock(other);
1698 other->sk_data_ready(other, size);
1702 scm_destroy(siocb->scm);
1708 unix_state_unlock(other);
1711 if (sent == 0 && !(msg->msg_flags&MSG_NOSIGNAL))
1712 send_sig(SIGPIPE, current, 0);
1715 scm_destroy(siocb->scm);
1717 return sent ? : err;
1720 static int unix_seqpacket_sendmsg(struct kiocb *kiocb, struct socket *sock,
1721 struct msghdr *msg, size_t len)
1724 struct sock *sk = sock->sk;
1726 err = sock_error(sk);
1730 if (sk->sk_state != TCP_ESTABLISHED)
1733 if (msg->msg_namelen)
1734 msg->msg_namelen = 0;
1736 return unix_dgram_sendmsg(kiocb, sock, msg, len);
1739 static int unix_seqpacket_recvmsg(struct kiocb *iocb, struct socket *sock,
1740 struct msghdr *msg, size_t size,
1743 struct sock *sk = sock->sk;
1745 if (sk->sk_state != TCP_ESTABLISHED)
1748 return unix_dgram_recvmsg(iocb, sock, msg, size, flags);
1751 static void unix_copy_addr(struct msghdr *msg, struct sock *sk)
1753 struct unix_sock *u = unix_sk(sk);
1755 msg->msg_namelen = 0;
1757 msg->msg_namelen = u->addr->len;
1758 memcpy(msg->msg_name, u->addr->name, u->addr->len);
1762 static int unix_dgram_recvmsg(struct kiocb *iocb, struct socket *sock,
1763 struct msghdr *msg, size_t size,
1766 struct sock_iocb *siocb = kiocb_to_siocb(iocb);
1767 struct scm_cookie tmp_scm;
1768 struct sock *sk = sock->sk;
1769 struct unix_sock *u = unix_sk(sk);
1770 int noblock = flags & MSG_DONTWAIT;
1771 struct sk_buff *skb;
1779 msg->msg_namelen = 0;
1781 err = mutex_lock_interruptible(&u->readlock);
1783 err = sock_intr_errno(sock_rcvtimeo(sk, noblock));
1787 skip = sk_peek_offset(sk, flags);
1789 skb = __skb_recv_datagram(sk, flags, &peeked, &skip, &err);
1791 unix_state_lock(sk);
1792 /* Signal EOF on disconnected non-blocking SEQPACKET socket. */
1793 if (sk->sk_type == SOCK_SEQPACKET && err == -EAGAIN &&
1794 (sk->sk_shutdown & RCV_SHUTDOWN))
1796 unix_state_unlock(sk);
1800 wake_up_interruptible_sync_poll(&u->peer_wait,
1801 POLLOUT | POLLWRNORM | POLLWRBAND);
1804 unix_copy_addr(msg, skb->sk);
1806 if (size > skb->len - skip)
1807 size = skb->len - skip;
1808 else if (size < skb->len - skip)
1809 msg->msg_flags |= MSG_TRUNC;
1811 err = skb_copy_datagram_iovec(skb, skip, msg->msg_iov, size);
1815 if (sock_flag(sk, SOCK_RCVTSTAMP))
1816 __sock_recv_timestamp(msg, sk, skb);
1819 siocb->scm = &tmp_scm;
1820 memset(&tmp_scm, 0, sizeof(tmp_scm));
1822 scm_set_cred(siocb->scm, UNIXCB(skb).pid, UNIXCB(skb).uid, UNIXCB(skb).gid);
1823 unix_set_secdata(siocb->scm, skb);
1825 if (!(flags & MSG_PEEK)) {
1827 unix_detach_fds(siocb->scm, skb);
1829 sk_peek_offset_bwd(sk, skb->len);
1831 /* It is questionable: on PEEK we could:
1832 - do not return fds - good, but too simple 8)
1833 - return fds, and do not return them on read (old strategy,
1835 - clone fds (I chose it for now, it is the most universal
1838 POSIX 1003.1g does not actually define this clearly
1839 at all. POSIX 1003.1g doesn't define a lot of things
1844 sk_peek_offset_fwd(sk, size);
1847 siocb->scm->fp = scm_fp_dup(UNIXCB(skb).fp);
1849 err = (flags & MSG_TRUNC) ? skb->len - skip : size;
1851 scm_recv(sock, msg, siocb->scm, flags);
1854 skb_free_datagram(sk, skb);
1856 mutex_unlock(&u->readlock);
1862 * Sleep until more data has arrived. But check for races..
1864 static long unix_stream_data_wait(struct sock *sk, long timeo,
1865 struct sk_buff *last)
1869 unix_state_lock(sk);
1872 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
1874 if (skb_peek_tail(&sk->sk_receive_queue) != last ||
1876 (sk->sk_shutdown & RCV_SHUTDOWN) ||
1877 signal_pending(current) ||
1881 set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
1882 unix_state_unlock(sk);
1883 timeo = freezable_schedule_timeout(timeo);
1884 unix_state_lock(sk);
1885 clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
1888 finish_wait(sk_sleep(sk), &wait);
1889 unix_state_unlock(sk);
1893 static int unix_stream_recvmsg(struct kiocb *iocb, struct socket *sock,
1894 struct msghdr *msg, size_t size,
1897 struct sock_iocb *siocb = kiocb_to_siocb(iocb);
1898 struct scm_cookie tmp_scm;
1899 struct sock *sk = sock->sk;
1900 struct unix_sock *u = unix_sk(sk);
1901 struct sockaddr_un *sunaddr = msg->msg_name;
1903 int check_creds = 0;
1910 if (sk->sk_state != TCP_ESTABLISHED)
1917 target = sock_rcvlowat(sk, flags&MSG_WAITALL, size);
1918 timeo = sock_rcvtimeo(sk, flags&MSG_DONTWAIT);
1920 msg->msg_namelen = 0;
1922 /* Lock the socket to prevent queue disordering
1923 * while sleeps in memcpy_tomsg
1927 siocb->scm = &tmp_scm;
1928 memset(&tmp_scm, 0, sizeof(tmp_scm));
1931 err = mutex_lock_interruptible(&u->readlock);
1933 err = sock_intr_errno(timeo);
1939 struct sk_buff *skb, *last;
1941 unix_state_lock(sk);
1942 last = skb = skb_peek(&sk->sk_receive_queue);
1945 unix_sk(sk)->recursion_level = 0;
1946 if (copied >= target)
1950 * POSIX 1003.1g mandates this order.
1953 err = sock_error(sk);
1956 if (sk->sk_shutdown & RCV_SHUTDOWN)
1959 unix_state_unlock(sk);
1963 mutex_unlock(&u->readlock);
1965 timeo = unix_stream_data_wait(sk, timeo, last);
1967 if (signal_pending(current)
1968 || mutex_lock_interruptible(&u->readlock)) {
1969 err = sock_intr_errno(timeo);
1975 unix_state_unlock(sk);
1979 skip = sk_peek_offset(sk, flags);
1980 while (skip >= skb->len) {
1983 skb = skb_peek_next(skb, &sk->sk_receive_queue);
1988 unix_state_unlock(sk);
1991 /* Never glue messages from different writers */
1992 if ((UNIXCB(skb).pid != siocb->scm->pid) ||
1993 !uid_eq(UNIXCB(skb).uid, siocb->scm->creds.uid) ||
1994 !gid_eq(UNIXCB(skb).gid, siocb->scm->creds.gid))
1996 } else if (test_bit(SOCK_PASSCRED, &sock->flags)) {
1997 /* Copy credentials */
1998 scm_set_cred(siocb->scm, UNIXCB(skb).pid, UNIXCB(skb).uid, UNIXCB(skb).gid);
2002 /* Copy address just once */
2004 unix_copy_addr(msg, skb->sk);
2008 chunk = min_t(unsigned int, skb->len - skip, size);
2009 if (memcpy_toiovec(msg->msg_iov, skb->data + skip, chunk)) {
2017 /* Mark read part of skb as used */
2018 if (!(flags & MSG_PEEK)) {
2019 skb_pull(skb, chunk);
2021 sk_peek_offset_bwd(sk, chunk);
2024 unix_detach_fds(siocb->scm, skb);
2029 skb_unlink(skb, &sk->sk_receive_queue);
2035 /* It is questionable, see note in unix_dgram_recvmsg.
2038 siocb->scm->fp = scm_fp_dup(UNIXCB(skb).fp);
2040 sk_peek_offset_fwd(sk, chunk);
2046 mutex_unlock(&u->readlock);
2047 scm_recv(sock, msg, siocb->scm, flags);
2049 return copied ? : err;
2052 static int unix_shutdown(struct socket *sock, int mode)
2054 struct sock *sk = sock->sk;
2057 if (mode < SHUT_RD || mode > SHUT_RDWR)
2060 * SHUT_RD (0) -> RCV_SHUTDOWN (1)
2061 * SHUT_WR (1) -> SEND_SHUTDOWN (2)
2062 * SHUT_RDWR (2) -> SHUTDOWN_MASK (3)
2066 unix_state_lock(sk);
2067 sk->sk_shutdown |= mode;
2068 other = unix_peer(sk);
2071 unix_state_unlock(sk);
2072 sk->sk_state_change(sk);
2075 (sk->sk_type == SOCK_STREAM || sk->sk_type == SOCK_SEQPACKET)) {
2079 if (mode&RCV_SHUTDOWN)
2080 peer_mode |= SEND_SHUTDOWN;
2081 if (mode&SEND_SHUTDOWN)
2082 peer_mode |= RCV_SHUTDOWN;
2083 unix_state_lock(other);
2084 other->sk_shutdown |= peer_mode;
2085 unix_state_unlock(other);
2086 other->sk_state_change(other);
2087 if (peer_mode == SHUTDOWN_MASK)
2088 sk_wake_async(other, SOCK_WAKE_WAITD, POLL_HUP);
2089 else if (peer_mode & RCV_SHUTDOWN)
2090 sk_wake_async(other, SOCK_WAKE_WAITD, POLL_IN);
2098 long unix_inq_len(struct sock *sk)
2100 struct sk_buff *skb;
2103 if (sk->sk_state == TCP_LISTEN)
2106 spin_lock(&sk->sk_receive_queue.lock);
2107 if (sk->sk_type == SOCK_STREAM ||
2108 sk->sk_type == SOCK_SEQPACKET) {
2109 skb_queue_walk(&sk->sk_receive_queue, skb)
2112 skb = skb_peek(&sk->sk_receive_queue);
2116 spin_unlock(&sk->sk_receive_queue.lock);
2120 EXPORT_SYMBOL_GPL(unix_inq_len);
2122 long unix_outq_len(struct sock *sk)
2124 return sk_wmem_alloc_get(sk);
2126 EXPORT_SYMBOL_GPL(unix_outq_len);
2128 static int unix_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
2130 struct sock *sk = sock->sk;
2136 amount = unix_outq_len(sk);
2137 err = put_user(amount, (int __user *)arg);
2140 amount = unix_inq_len(sk);
2144 err = put_user(amount, (int __user *)arg);
2153 static unsigned int unix_poll(struct file *file, struct socket *sock, poll_table *wait)
2155 struct sock *sk = sock->sk;
2158 sock_poll_wait(file, sk_sleep(sk), wait);
2161 /* exceptional events? */
2164 if (sk->sk_shutdown == SHUTDOWN_MASK)
2166 if (sk->sk_shutdown & RCV_SHUTDOWN)
2167 mask |= POLLRDHUP | POLLIN | POLLRDNORM;
2170 if (!skb_queue_empty(&sk->sk_receive_queue))
2171 mask |= POLLIN | POLLRDNORM;
2173 /* Connection-based need to check for termination and startup */
2174 if ((sk->sk_type == SOCK_STREAM || sk->sk_type == SOCK_SEQPACKET) &&
2175 sk->sk_state == TCP_CLOSE)
2179 * we set writable also when the other side has shut down the
2180 * connection. This prevents stuck sockets.
2182 if (unix_writable(sk))
2183 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
2188 static unsigned int unix_dgram_poll(struct file *file, struct socket *sock,
2191 struct sock *sk = sock->sk, *other;
2192 unsigned int mask, writable;
2194 sock_poll_wait(file, sk_sleep(sk), wait);
2197 /* exceptional events? */
2198 if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
2200 (sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? POLLPRI : 0);
2202 if (sk->sk_shutdown & RCV_SHUTDOWN)
2203 mask |= POLLRDHUP | POLLIN | POLLRDNORM;
2204 if (sk->sk_shutdown == SHUTDOWN_MASK)
2208 if (!skb_queue_empty(&sk->sk_receive_queue))
2209 mask |= POLLIN | POLLRDNORM;
2211 /* Connection-based need to check for termination and startup */
2212 if (sk->sk_type == SOCK_SEQPACKET) {
2213 if (sk->sk_state == TCP_CLOSE)
2215 /* connection hasn't started yet? */
2216 if (sk->sk_state == TCP_SYN_SENT)
2220 /* No write status requested, avoid expensive OUT tests. */
2221 if (!(poll_requested_events(wait) & (POLLWRBAND|POLLWRNORM|POLLOUT)))
2224 writable = unix_writable(sk);
2225 other = unix_peer_get(sk);
2227 if (unix_peer(other) != sk) {
2228 sock_poll_wait(file, &unix_sk(other)->peer_wait, wait);
2229 if (unix_recvq_full(other))
2236 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
2238 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
2243 #ifdef CONFIG_PROC_FS
2245 #define BUCKET_SPACE (BITS_PER_LONG - (UNIX_HASH_BITS + 1) - 1)
2247 #define get_bucket(x) ((x) >> BUCKET_SPACE)
2248 #define get_offset(x) ((x) & ((1L << BUCKET_SPACE) - 1))
2249 #define set_bucket_offset(b, o) ((b) << BUCKET_SPACE | (o))
2251 static struct sock *unix_from_bucket(struct seq_file *seq, loff_t *pos)
2253 unsigned long offset = get_offset(*pos);
2254 unsigned long bucket = get_bucket(*pos);
2256 unsigned long count = 0;
2258 for (sk = sk_head(&unix_socket_table[bucket]); sk; sk = sk_next(sk)) {
2259 if (sock_net(sk) != seq_file_net(seq))
2261 if (++count == offset)
2268 static struct sock *unix_next_socket(struct seq_file *seq,
2272 unsigned long bucket;
2274 while (sk > (struct sock *)SEQ_START_TOKEN) {
2278 if (sock_net(sk) == seq_file_net(seq))
2283 sk = unix_from_bucket(seq, pos);
2288 bucket = get_bucket(*pos) + 1;
2289 *pos = set_bucket_offset(bucket, 1);
2290 } while (bucket < ARRAY_SIZE(unix_socket_table));
2295 static void *unix_seq_start(struct seq_file *seq, loff_t *pos)
2296 __acquires(unix_table_lock)
2298 spin_lock(&unix_table_lock);
2301 return SEQ_START_TOKEN;
2303 if (get_bucket(*pos) >= ARRAY_SIZE(unix_socket_table))
2306 return unix_next_socket(seq, NULL, pos);
2309 static void *unix_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2312 return unix_next_socket(seq, v, pos);
2315 static void unix_seq_stop(struct seq_file *seq, void *v)
2316 __releases(unix_table_lock)
2318 spin_unlock(&unix_table_lock);
2321 static int unix_seq_show(struct seq_file *seq, void *v)
2324 if (v == SEQ_START_TOKEN)
2325 seq_puts(seq, "Num RefCount Protocol Flags Type St "
2329 struct unix_sock *u = unix_sk(s);
2332 seq_printf(seq, "%pK: %08X %08X %08X %04X %02X %5lu",
2334 atomic_read(&s->sk_refcnt),
2336 s->sk_state == TCP_LISTEN ? __SO_ACCEPTCON : 0,
2339 (s->sk_state == TCP_ESTABLISHED ? SS_CONNECTED : SS_UNCONNECTED) :
2340 (s->sk_state == TCP_ESTABLISHED ? SS_CONNECTING : SS_DISCONNECTING),
2348 len = u->addr->len - sizeof(short);
2349 if (!UNIX_ABSTRACT(s))
2355 for ( ; i < len; i++)
2356 seq_putc(seq, u->addr->name->sun_path[i]);
2358 unix_state_unlock(s);
2359 seq_putc(seq, '\n');
2365 static const struct seq_operations unix_seq_ops = {
2366 .start = unix_seq_start,
2367 .next = unix_seq_next,
2368 .stop = unix_seq_stop,
2369 .show = unix_seq_show,
2372 static int unix_seq_open(struct inode *inode, struct file *file)
2374 return seq_open_net(inode, file, &unix_seq_ops,
2375 sizeof(struct seq_net_private));
2378 static const struct file_operations unix_seq_fops = {
2379 .owner = THIS_MODULE,
2380 .open = unix_seq_open,
2382 .llseek = seq_lseek,
2383 .release = seq_release_net,
2388 static const struct net_proto_family unix_family_ops = {
2390 .create = unix_create,
2391 .owner = THIS_MODULE,
2395 static int __net_init unix_net_init(struct net *net)
2397 int error = -ENOMEM;
2399 net->unx.sysctl_max_dgram_qlen = 10;
2400 if (unix_sysctl_register(net))
2403 #ifdef CONFIG_PROC_FS
2404 if (!proc_create("unix", 0, net->proc_net, &unix_seq_fops)) {
2405 unix_sysctl_unregister(net);
2414 static void __net_exit unix_net_exit(struct net *net)
2416 unix_sysctl_unregister(net);
2417 remove_proc_entry("unix", net->proc_net);
2420 static struct pernet_operations unix_net_ops = {
2421 .init = unix_net_init,
2422 .exit = unix_net_exit,
2425 static int __init af_unix_init(void)
2429 BUILD_BUG_ON(sizeof(struct unix_skb_parms) > FIELD_SIZEOF(struct sk_buff, cb));
2431 rc = proto_register(&unix_proto, 1);
2433 printk(KERN_CRIT "%s: Cannot create unix_sock SLAB cache!\n",
2438 sock_register(&unix_family_ops);
2439 register_pernet_subsys(&unix_net_ops);
2444 static void __exit af_unix_exit(void)
2446 sock_unregister(PF_UNIX);
2447 proto_unregister(&unix_proto);
2448 unregister_pernet_subsys(&unix_net_ops);
2451 /* Earlier than device_initcall() so that other drivers invoking
2452 request_module() don't end up in a loop when modprobe tries
2453 to use a UNIX socket. But later than subsys_initcall() because
2454 we depend on stuff initialised there */
2455 fs_initcall(af_unix_init);
2456 module_exit(af_unix_exit);
2458 MODULE_LICENSE("GPL");
2459 MODULE_ALIAS_NETPROTO(PF_UNIX);