blob: a1eb5969712c93805b6aa3cc2245635eff576b60 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * NET4: Implementation of BSD Unix domain sockets.
3 *
Alan Cox113aa832008-10-13 19:01:08 -07004 * Authors: Alan Cox, <alan@lxorguk.ukuu.org.uk>
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070011 * Fixes:
12 * Linus Torvalds : Assorted bug cures.
13 * Niibe Yutaka : async I/O support.
14 * Carsten Paeth : PF_UNIX check, address fixes.
15 * Alan Cox : Limit size of allocated blocks.
16 * Alan Cox : Fixed the stupid socketpair bug.
17 * Alan Cox : BSD compatibility fine tuning.
18 * Alan Cox : Fixed a bug in connect when interrupted.
19 * Alan Cox : Sorted out a proper draft version of
20 * file descriptor passing hacked up from
21 * Mike Shaver's work.
22 * Marty Leisner : Fixes to fd passing
23 * Nick Nevin : recvmsg bugfix.
24 * Alan Cox : Started proper garbage collector
25 * Heiko EiBfeldt : Missing verify_area check
26 * Alan Cox : Started POSIXisms
27 * Andreas Schwab : Replace inode by dentry for proper
28 * reference counting
29 * Kirk Petersen : Made this a module
30 * Christoph Rohland : Elegant non-blocking accept/connect algorithm.
31 * Lots of bug fixes.
32 * Alexey Kuznetosv : Repaired (I hope) bugs introduces
33 * by above two patches.
34 * Andrea Arcangeli : If possible we block in connect(2)
35 * if the max backlog of the listen socket
36 * is been reached. This won't break
37 * old apps and it will avoid huge amount
38 * of socks hashed (this for unix_gc()
39 * performances reasons).
40 * Security fix that limits the max
41 * number of socks to 2*max_files and
42 * the number of skb queueable in the
43 * dgram receiver.
44 * Artur Skawina : Hash function optimizations
45 * Alexey Kuznetsov : Full scale SMP. Lot of bugs are introduced 8)
46 * Malcolm Beattie : Set peercred for socketpair
47 * Michal Ostrowski : Module initialization cleanup.
48 * Arnaldo C. Melo : Remove MOD_{INC,DEC}_USE_COUNT,
49 * the core infrastructure is doing that
50 * for all net proto families now (2.5.69+)
51 *
52 *
53 * Known differences from reference BSD that was tested:
54 *
55 * [TO FIX]
56 * ECONNREFUSED is not returned from one end of a connected() socket to the
57 * other the moment one end closes.
58 * fstat() doesn't return st_dev=0, and give the blksize as high water mark
59 * and a fake inode identifier (nor the BSD first socket fstat twice bug).
60 * [NOT TO FIX]
61 * accept() returns a path name even if the connecting socket has closed
62 * in the meantime (BSD loses the path and gives up).
63 * accept() returns 0 length path for an unbound connector. BSD returns 16
64 * and a null first byte in the path (but not for gethost/peername - BSD bug ??)
65 * socketpair(...SOCK_RAW..) doesn't panic the kernel.
66 * BSD af_unix apparently has connect forgetting to block properly.
67 * (need to check this with the POSIX spec in detail)
68 *
69 * Differences from 2.0.0-11-... (ANK)
70 * Bug fixes and improvements.
71 * - client shutdown killed server socket.
72 * - removed all useless cli/sti pairs.
73 *
74 * Semantic changes/extensions.
75 * - generic control message passing.
76 * - SCM_CREDENTIALS control message.
77 * - "Abstract" (not FS based) socket bindings.
78 * Abstract names are sequences of bytes (not zero terminated)
79 * started by 0, so that this name space does not intersect
80 * with BSD names.
81 */
82
83#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070084#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070085#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>
93#include <linux/un.h>
94#include <linux/fcntl.h>
95#include <linux/termios.h>
96#include <linux/sockios.h>
97#include <linux/net.h>
98#include <linux/in.h>
99#include <linux/fs.h>
100#include <linux/slab.h>
101#include <asm/uaccess.h>
102#include <linux/skbuff.h>
103#include <linux/netdevice.h>
Eric W. Biederman457c4cb2007-09-12 12:01:34 +0200104#include <net/net_namespace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105#include <net/sock.h>
Arnaldo Carvalho de Meloc752f072005-08-09 20:08:28 -0700106#include <net/tcp_states.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107#include <net/af_unix.h>
108#include <linux/proc_fs.h>
109#include <linux/seq_file.h>
110#include <net/scm.h>
111#include <linux/init.h>
112#include <linux/poll.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113#include <linux/rtnetlink.h>
114#include <linux/mount.h>
115#include <net/checksum.h>
116#include <linux/security.h>
117
Adrian Bunk13111692007-07-30 18:05:45 -0700118static struct hlist_head unix_socket_table[UNIX_HASH_SIZE + 1];
119static DEFINE_SPINLOCK(unix_table_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120static atomic_t unix_nr_socks = ATOMIC_INIT(0);
121
122#define unix_sockets_unbound (&unix_socket_table[UNIX_HASH_SIZE])
123
124#define UNIX_ABSTRACT(sk) (unix_sk(sk)->addr->hash != UNIX_HASH_SIZE)
125
Catherine Zhang877ce7c2006-06-29 12:27:47 -0700126#ifdef CONFIG_SECURITY_NETWORK
Catherine Zhangdc49c1f2006-08-02 14:12:06 -0700127static void unix_get_secdata(struct scm_cookie *scm, struct sk_buff *skb)
Catherine Zhang877ce7c2006-06-29 12:27:47 -0700128{
Catherine Zhangdc49c1f2006-08-02 14:12:06 -0700129 memcpy(UNIXSID(skb), &scm->secid, sizeof(u32));
Catherine Zhang877ce7c2006-06-29 12:27:47 -0700130}
131
132static inline void unix_set_secdata(struct scm_cookie *scm, struct sk_buff *skb)
133{
Catherine Zhangdc49c1f2006-08-02 14:12:06 -0700134 scm->secid = *UNIXSID(skb);
Catherine Zhang877ce7c2006-06-29 12:27:47 -0700135}
136#else
Catherine Zhangdc49c1f2006-08-02 14:12:06 -0700137static inline void unix_get_secdata(struct scm_cookie *scm, struct sk_buff *skb)
Catherine Zhang877ce7c2006-06-29 12:27:47 -0700138{ }
139
140static inline void unix_set_secdata(struct scm_cookie *scm, struct sk_buff *skb)
141{ }
142#endif /* CONFIG_SECURITY_NETWORK */
143
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144/*
145 * SMP locking strategy:
David S. Millerfbe9cc42005-12-13 23:26:29 -0800146 * hash table is protected with spinlock unix_table_lock
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147 * each socket state is protected by separate rwlock.
148 */
149
Al Viro44bb9362006-11-14 21:36:14 -0800150static inline unsigned unix_hash_fold(__wsum n)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151{
Al Viro44bb9362006-11-14 21:36:14 -0800152 unsigned hash = (__force unsigned)n;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 hash ^= hash>>16;
154 hash ^= hash>>8;
155 return hash&(UNIX_HASH_SIZE-1);
156}
157
158#define unix_peer(sk) (unix_sk(sk)->peer)
159
160static inline int unix_our_peer(struct sock *sk, struct sock *osk)
161{
162 return unix_peer(osk) == sk;
163}
164
165static inline int unix_may_send(struct sock *sk, struct sock *osk)
166{
Eric Dumazet6eba6a32008-11-16 22:58:44 -0800167 return unix_peer(osk) == NULL || unix_our_peer(sk, osk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168}
169
Rainer Weikusat3c734192008-06-17 22:28:05 -0700170static inline int unix_recvq_full(struct sock const *sk)
171{
172 return skb_queue_len(&sk->sk_receive_queue) > sk->sk_max_ack_backlog;
173}
174
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175static struct sock *unix_peer_get(struct sock *s)
176{
177 struct sock *peer;
178
David S. Miller1c92b4e2007-05-31 13:24:26 -0700179 unix_state_lock(s);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180 peer = unix_peer(s);
181 if (peer)
182 sock_hold(peer);
David S. Miller1c92b4e2007-05-31 13:24:26 -0700183 unix_state_unlock(s);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184 return peer;
185}
186
187static inline void unix_release_addr(struct unix_address *addr)
188{
189 if (atomic_dec_and_test(&addr->refcnt))
190 kfree(addr);
191}
192
193/*
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.
198 */
YOSHIFUJI Hideakiac7bfa62007-02-09 23:25:23 +0900199
Eric Dumazet6eba6a32008-11-16 22:58:44 -0800200static int unix_mkname(struct sockaddr_un *sunaddr, int len, unsigned *hashp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201{
202 if (len <= sizeof(short) || len > sizeof(*sunaddr))
203 return -EINVAL;
204 if (!sunaddr || sunaddr->sun_family != AF_UNIX)
205 return -EINVAL;
206 if (sunaddr->sun_path[0]) {
207 /*
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.
213 */
Jianjun Konge27dfce2008-11-01 21:38:31 -0700214 ((char *)sunaddr)[len] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215 len = strlen(sunaddr->sun_path)+1+sizeof(short);
216 return len;
217 }
218
Eric Dumazet6eba6a32008-11-16 22:58:44 -0800219 *hashp = unix_hash_fold(csum_partial((char *)sunaddr, len, 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220 return len;
221}
222
223static void __unix_remove_socket(struct sock *sk)
224{
225 sk_del_node_init(sk);
226}
227
228static void __unix_insert_socket(struct hlist_head *list, struct sock *sk)
229{
Ilpo Järvinen547b7922008-07-25 21:43:18 -0700230 WARN_ON(!sk_unhashed(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 sk_add_node(sk, list);
232}
233
234static inline void unix_remove_socket(struct sock *sk)
235{
David S. Millerfbe9cc42005-12-13 23:26:29 -0800236 spin_lock(&unix_table_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 __unix_remove_socket(sk);
David S. Millerfbe9cc42005-12-13 23:26:29 -0800238 spin_unlock(&unix_table_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239}
240
241static inline void unix_insert_socket(struct hlist_head *list, struct sock *sk)
242{
David S. Millerfbe9cc42005-12-13 23:26:29 -0800243 spin_lock(&unix_table_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244 __unix_insert_socket(list, sk);
David S. Millerfbe9cc42005-12-13 23:26:29 -0800245 spin_unlock(&unix_table_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246}
247
Denis V. Lunev097e66c2007-11-19 22:29:30 -0800248static struct sock *__unix_find_socket_byname(struct net *net,
249 struct sockaddr_un *sunname,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250 int len, int type, unsigned hash)
251{
252 struct sock *s;
253 struct hlist_node *node;
254
255 sk_for_each(s, node, &unix_socket_table[hash ^ type]) {
256 struct unix_sock *u = unix_sk(s);
257
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +0900258 if (!net_eq(sock_net(s), net))
Denis V. Lunev097e66c2007-11-19 22:29:30 -0800259 continue;
260
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 if (u->addr->len == len &&
262 !memcmp(u->addr->name, sunname, len))
263 goto found;
264 }
265 s = NULL;
266found:
267 return s;
268}
269
Denis V. Lunev097e66c2007-11-19 22:29:30 -0800270static inline struct sock *unix_find_socket_byname(struct net *net,
271 struct sockaddr_un *sunname,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 int len, int type,
273 unsigned hash)
274{
275 struct sock *s;
276
David S. Millerfbe9cc42005-12-13 23:26:29 -0800277 spin_lock(&unix_table_lock);
Denis V. Lunev097e66c2007-11-19 22:29:30 -0800278 s = __unix_find_socket_byname(net, sunname, len, type, hash);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 if (s)
280 sock_hold(s);
David S. Millerfbe9cc42005-12-13 23:26:29 -0800281 spin_unlock(&unix_table_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 return s;
283}
284
Denis V. Lunev097e66c2007-11-19 22:29:30 -0800285static struct sock *unix_find_socket_byinode(struct net *net, struct inode *i)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286{
287 struct sock *s;
288 struct hlist_node *node;
289
David S. Millerfbe9cc42005-12-13 23:26:29 -0800290 spin_lock(&unix_table_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 sk_for_each(s, node,
292 &unix_socket_table[i->i_ino & (UNIX_HASH_SIZE - 1)]) {
293 struct dentry *dentry = unix_sk(s)->dentry;
294
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +0900295 if (!net_eq(sock_net(s), net))
Denis V. Lunev097e66c2007-11-19 22:29:30 -0800296 continue;
297
Eric Dumazet6eba6a32008-11-16 22:58:44 -0800298 if (dentry && dentry->d_inode == i) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299 sock_hold(s);
300 goto found;
301 }
302 }
303 s = NULL;
304found:
David S. Millerfbe9cc42005-12-13 23:26:29 -0800305 spin_unlock(&unix_table_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 return s;
307}
308
309static inline int unix_writable(struct sock *sk)
310{
311 return (atomic_read(&sk->sk_wmem_alloc) << 2) <= sk->sk_sndbuf;
312}
313
314static void unix_write_space(struct sock *sk)
315{
316 read_lock(&sk->sk_callback_lock);
317 if (unix_writable(sk)) {
318 if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
Ingo Molnar71e20f12007-10-15 17:00:19 +0200319 wake_up_interruptible_sync(sk->sk_sleep);
Pavel Emelyanov8d8ad9d2007-11-26 20:10:50 +0800320 sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321 }
322 read_unlock(&sk->sk_callback_lock);
323}
324
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. */
329static void unix_dgram_disconnected(struct sock *sk, struct sock *other)
330{
David S. Millerb03efcf2005-07-08 14:57:23 -0700331 if (!skb_queue_empty(&sk->sk_receive_queue)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 skb_queue_purge(&sk->sk_receive_queue);
333 wake_up_interruptible_all(&unix_sk(sk)->peer_wait);
334
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.
338 */
339 if (!sock_flag(other, SOCK_DEAD) && unix_peer(other) == sk) {
340 other->sk_err = ECONNRESET;
341 other->sk_error_report(other);
342 }
343 }
344}
345
346static void unix_sock_destructor(struct sock *sk)
347{
348 struct unix_sock *u = unix_sk(sk);
349
350 skb_queue_purge(&sk->sk_receive_queue);
351
Ilpo Järvinen547b7922008-07-25 21:43:18 -0700352 WARN_ON(atomic_read(&sk->sk_wmem_alloc));
353 WARN_ON(!sk_unhashed(sk));
354 WARN_ON(sk->sk_socket);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 if (!sock_flag(sk, SOCK_DEAD)) {
Eric Dumazet6eba6a32008-11-16 22:58:44 -0800356 printk(KERN_DEBUG "Attempt to release alive unix socket: %p\n", sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357 return;
358 }
359
360 if (u->addr)
361 unix_release_addr(u->addr);
362
363 atomic_dec(&unix_nr_socks);
364#ifdef UNIX_REFCNT_DEBUG
Eric Dumazet6eba6a32008-11-16 22:58:44 -0800365 printk(KERN_DEBUG "UNIX %p is destroyed, %d are still alive.\n", sk,
366 atomic_read(&unix_nr_socks));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367#endif
368}
369
Eric Dumazet6eba6a32008-11-16 22:58:44 -0800370static int unix_release_sock(struct sock *sk, int embrion)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371{
372 struct unix_sock *u = unix_sk(sk);
373 struct dentry *dentry;
374 struct vfsmount *mnt;
375 struct sock *skpair;
376 struct sk_buff *skb;
377 int state;
378
379 unix_remove_socket(sk);
380
381 /* Clear state */
David S. Miller1c92b4e2007-05-31 13:24:26 -0700382 unix_state_lock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 sock_orphan(sk);
384 sk->sk_shutdown = SHUTDOWN_MASK;
385 dentry = u->dentry;
386 u->dentry = NULL;
387 mnt = u->mnt;
388 u->mnt = NULL;
389 state = sk->sk_state;
390 sk->sk_state = TCP_CLOSE;
David S. Miller1c92b4e2007-05-31 13:24:26 -0700391 unix_state_unlock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392
393 wake_up_interruptible_all(&u->peer_wait);
394
Jianjun Konge27dfce2008-11-01 21:38:31 -0700395 skpair = unix_peer(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396
Jianjun Konge27dfce2008-11-01 21:38:31 -0700397 if (skpair != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398 if (sk->sk_type == SOCK_STREAM || sk->sk_type == SOCK_SEQPACKET) {
David S. Miller1c92b4e2007-05-31 13:24:26 -0700399 unix_state_lock(skpair);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 /* No more writes */
401 skpair->sk_shutdown = SHUTDOWN_MASK;
402 if (!skb_queue_empty(&sk->sk_receive_queue) || embrion)
403 skpair->sk_err = ECONNRESET;
David S. Miller1c92b4e2007-05-31 13:24:26 -0700404 unix_state_unlock(skpair);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405 skpair->sk_state_change(skpair);
406 read_lock(&skpair->sk_callback_lock);
Pavel Emelyanov8d8ad9d2007-11-26 20:10:50 +0800407 sk_wake_async(skpair, SOCK_WAKE_WAITD, POLL_HUP);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408 read_unlock(&skpair->sk_callback_lock);
409 }
410 sock_put(skpair); /* It may now die */
411 unix_peer(sk) = NULL;
412 }
413
414 /* Try to flush out this socket. Throw out buffers at least */
415
416 while ((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL) {
Jianjun Konge27dfce2008-11-01 21:38:31 -0700417 if (state == TCP_LISTEN)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 unix_release_sock(skb->sk, 1);
419 /* passed fds are erased in the kfree_skb hook */
420 kfree_skb(skb);
421 }
422
423 if (dentry) {
424 dput(dentry);
425 mntput(mnt);
426 }
427
428 sock_put(sk);
429
430 /* ---- Socket is dead now and most probably destroyed ---- */
431
432 /*
433 * Fixme: BSD difference: In BSD all sockets connected to use get
434 * ECONNRESET and we die on the spot. In Linux we behave
435 * like files and pipes do and wait for the last
436 * dereference.
437 *
438 * Can't we simply set sock->err?
439 *
440 * What the above comment does talk about? --ANK(980817)
441 */
442
Pavel Emelyanov9305cfa2007-11-10 22:06:01 -0800443 if (unix_tot_inflight)
YOSHIFUJI Hideakiac7bfa62007-02-09 23:25:23 +0900444 unix_gc(); /* Garbage collect fds */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445
446 return 0;
447}
448
449static int unix_listen(struct socket *sock, int backlog)
450{
451 int err;
452 struct sock *sk = sock->sk;
453 struct unix_sock *u = unix_sk(sk);
454
455 err = -EOPNOTSUPP;
Eric Dumazet6eba6a32008-11-16 22:58:44 -0800456 if (sock->type != SOCK_STREAM && sock->type != SOCK_SEQPACKET)
457 goto out; /* Only stream/seqpacket sockets accept */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458 err = -EINVAL;
459 if (!u->addr)
Eric Dumazet6eba6a32008-11-16 22:58:44 -0800460 goto out; /* No listens on an unbound socket */
David S. Miller1c92b4e2007-05-31 13:24:26 -0700461 unix_state_lock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 if (sk->sk_state != TCP_CLOSE && sk->sk_state != TCP_LISTEN)
463 goto out_unlock;
464 if (backlog > sk->sk_max_ack_backlog)
465 wake_up_interruptible_all(&u->peer_wait);
466 sk->sk_max_ack_backlog = backlog;
467 sk->sk_state = TCP_LISTEN;
468 /* set credentials so connect can copy them */
Pavel Emelyanovb4888932007-10-18 23:40:14 -0700469 sk->sk_peercred.pid = task_tgid_vnr(current);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470 sk->sk_peercred.uid = current->euid;
471 sk->sk_peercred.gid = current->egid;
472 err = 0;
473
474out_unlock:
David S. Miller1c92b4e2007-05-31 13:24:26 -0700475 unix_state_unlock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476out:
477 return err;
478}
479
480static int unix_release(struct socket *);
481static int unix_bind(struct socket *, struct sockaddr *, int);
482static int unix_stream_connect(struct socket *, struct sockaddr *,
483 int addr_len, int flags);
484static int unix_socketpair(struct socket *, struct socket *);
485static int unix_accept(struct socket *, struct socket *, int);
486static int unix_getname(struct socket *, struct sockaddr *, int *, int);
487static unsigned int unix_poll(struct file *, struct socket *, poll_table *);
Rainer Weikusatec0d2152008-06-27 19:34:18 -0700488static unsigned int unix_dgram_poll(struct file *, struct socket *,
489 poll_table *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490static int unix_ioctl(struct socket *, unsigned int, unsigned long);
491static int unix_shutdown(struct socket *, int);
492static int unix_stream_sendmsg(struct kiocb *, struct socket *,
493 struct msghdr *, size_t);
494static int unix_stream_recvmsg(struct kiocb *, struct socket *,
495 struct msghdr *, size_t, int);
496static int unix_dgram_sendmsg(struct kiocb *, struct socket *,
497 struct msghdr *, size_t);
498static int unix_dgram_recvmsg(struct kiocb *, struct socket *,
499 struct msghdr *, size_t, int);
500static int unix_dgram_connect(struct socket *, struct sockaddr *,
501 int, int);
502static int unix_seqpacket_sendmsg(struct kiocb *, struct socket *,
503 struct msghdr *, size_t);
504
Eric Dumazet90ddc4f2005-12-22 12:49:22 -0800505static const struct proto_ops unix_stream_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 .family = PF_UNIX,
507 .owner = THIS_MODULE,
508 .release = unix_release,
509 .bind = unix_bind,
510 .connect = unix_stream_connect,
511 .socketpair = unix_socketpair,
512 .accept = unix_accept,
513 .getname = unix_getname,
514 .poll = unix_poll,
515 .ioctl = unix_ioctl,
516 .listen = unix_listen,
517 .shutdown = unix_shutdown,
518 .setsockopt = sock_no_setsockopt,
519 .getsockopt = sock_no_getsockopt,
520 .sendmsg = unix_stream_sendmsg,
521 .recvmsg = unix_stream_recvmsg,
522 .mmap = sock_no_mmap,
523 .sendpage = sock_no_sendpage,
524};
525
Eric Dumazet90ddc4f2005-12-22 12:49:22 -0800526static const struct proto_ops unix_dgram_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527 .family = PF_UNIX,
528 .owner = THIS_MODULE,
529 .release = unix_release,
530 .bind = unix_bind,
531 .connect = unix_dgram_connect,
532 .socketpair = unix_socketpair,
533 .accept = sock_no_accept,
534 .getname = unix_getname,
Rainer Weikusatec0d2152008-06-27 19:34:18 -0700535 .poll = unix_dgram_poll,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 .ioctl = unix_ioctl,
537 .listen = sock_no_listen,
538 .shutdown = unix_shutdown,
539 .setsockopt = sock_no_setsockopt,
540 .getsockopt = sock_no_getsockopt,
541 .sendmsg = unix_dgram_sendmsg,
542 .recvmsg = unix_dgram_recvmsg,
543 .mmap = sock_no_mmap,
544 .sendpage = sock_no_sendpage,
545};
546
Eric Dumazet90ddc4f2005-12-22 12:49:22 -0800547static const struct proto_ops unix_seqpacket_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548 .family = PF_UNIX,
549 .owner = THIS_MODULE,
550 .release = unix_release,
551 .bind = unix_bind,
552 .connect = unix_stream_connect,
553 .socketpair = unix_socketpair,
554 .accept = unix_accept,
555 .getname = unix_getname,
Rainer Weikusatec0d2152008-06-27 19:34:18 -0700556 .poll = unix_dgram_poll,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557 .ioctl = unix_ioctl,
558 .listen = unix_listen,
559 .shutdown = unix_shutdown,
560 .setsockopt = sock_no_setsockopt,
561 .getsockopt = sock_no_getsockopt,
562 .sendmsg = unix_seqpacket_sendmsg,
563 .recvmsg = unix_dgram_recvmsg,
564 .mmap = sock_no_mmap,
565 .sendpage = sock_no_sendpage,
566};
567
568static struct proto unix_proto = {
Eric Dumazet248969a2008-11-17 00:00:30 -0800569 .name = "UNIX",
570 .owner = THIS_MODULE,
571 .sockets_allocated = &unix_nr_socks,
572 .obj_size = sizeof(struct unix_sock),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573};
574
Ingo Molnara09785a2006-07-03 00:25:12 -0700575/*
576 * AF_UNIX sockets do not interact with hardware, hence they
577 * dont trigger interrupts - so it's safe for them to have
578 * bh-unsafe locking for their sk_receive_queue.lock. Split off
579 * this special lock-class by reinitializing the spinlock key:
580 */
581static struct lock_class_key af_unix_sk_receive_queue_lock_key;
582
Eric Dumazet6eba6a32008-11-16 22:58:44 -0800583static struct sock *unix_create1(struct net *net, struct socket *sock)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584{
585 struct sock *sk = NULL;
586 struct unix_sock *u;
587
Pavel Emelyanov284b3272007-11-10 22:08:30 -0800588 atomic_inc(&unix_nr_socks);
589 if (atomic_read(&unix_nr_socks) > 2 * get_max_files())
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 goto out;
591
Pavel Emelyanov6257ff22007-11-01 00:39:31 -0700592 sk = sk_alloc(net, PF_UNIX, GFP_KERNEL, &unix_proto);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 if (!sk)
594 goto out;
595
Eric Dumazet6eba6a32008-11-16 22:58:44 -0800596 sock_init_data(sock, sk);
Ingo Molnara09785a2006-07-03 00:25:12 -0700597 lockdep_set_class(&sk->sk_receive_queue.lock,
598 &af_unix_sk_receive_queue_lock_key);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599
600 sk->sk_write_space = unix_write_space;
Denis V. Luneva0a53c82007-12-11 04:19:17 -0800601 sk->sk_max_ack_backlog = net->unx.sysctl_max_dgram_qlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602 sk->sk_destruct = unix_sock_destructor;
603 u = unix_sk(sk);
604 u->dentry = NULL;
605 u->mnt = NULL;
Benjamin LaHaisefd19f322006-01-03 14:10:46 -0800606 spin_lock_init(&u->lock);
Al Viro516e0cc2008-07-26 00:39:17 -0400607 atomic_long_set(&u->inflight, 0);
Miklos Szeredi1fd05ba2007-07-11 14:22:39 -0700608 INIT_LIST_HEAD(&u->link);
Ingo Molnar57b47a52006-03-20 22:35:41 -0800609 mutex_init(&u->readlock); /* single task reading lock */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610 init_waitqueue_head(&u->peer_wait);
611 unix_insert_socket(unix_sockets_unbound, sk);
612out:
Pavel Emelyanov284b3272007-11-10 22:08:30 -0800613 if (sk == NULL)
614 atomic_dec(&unix_nr_socks);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615 return sk;
616}
617
Eric W. Biederman1b8d7ae2007-10-08 23:24:22 -0700618static int unix_create(struct net *net, struct socket *sock, int protocol)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619{
620 if (protocol && protocol != PF_UNIX)
621 return -EPROTONOSUPPORT;
622
623 sock->state = SS_UNCONNECTED;
624
625 switch (sock->type) {
626 case SOCK_STREAM:
627 sock->ops = &unix_stream_ops;
628 break;
629 /*
630 * Believe it or not BSD has AF_UNIX, SOCK_RAW though
631 * nothing uses it.
632 */
633 case SOCK_RAW:
Jianjun Konge27dfce2008-11-01 21:38:31 -0700634 sock->type = SOCK_DGRAM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635 case SOCK_DGRAM:
636 sock->ops = &unix_dgram_ops;
637 break;
638 case SOCK_SEQPACKET:
639 sock->ops = &unix_seqpacket_ops;
640 break;
641 default:
642 return -ESOCKTNOSUPPORT;
643 }
644
Eric W. Biederman1b8d7ae2007-10-08 23:24:22 -0700645 return unix_create1(net, sock) ? 0 : -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646}
647
648static int unix_release(struct socket *sock)
649{
650 struct sock *sk = sock->sk;
651
652 if (!sk)
653 return 0;
654
655 sock->sk = NULL;
656
Eric Dumazet6eba6a32008-11-16 22:58:44 -0800657 return unix_release_sock(sk, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658}
659
660static int unix_autobind(struct socket *sock)
661{
662 struct sock *sk = sock->sk;
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +0900663 struct net *net = sock_net(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664 struct unix_sock *u = unix_sk(sk);
665 static u32 ordernum = 1;
Eric Dumazet6eba6a32008-11-16 22:58:44 -0800666 struct unix_address *addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667 int err;
668
Ingo Molnar57b47a52006-03-20 22:35:41 -0800669 mutex_lock(&u->readlock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670
671 err = 0;
672 if (u->addr)
673 goto out;
674
675 err = -ENOMEM;
Panagiotis Issaris0da974f2006-07-21 14:51:30 -0700676 addr = kzalloc(sizeof(*addr) + sizeof(short) + 16, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 if (!addr)
678 goto out;
679
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 addr->name->sun_family = AF_UNIX;
681 atomic_set(&addr->refcnt, 1);
682
683retry:
684 addr->len = sprintf(addr->name->sun_path+1, "%05x", ordernum) + 1 + sizeof(short);
Eric Dumazet6eba6a32008-11-16 22:58:44 -0800685 addr->hash = unix_hash_fold(csum_partial((void *)addr->name, addr->len, 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686
David S. Millerfbe9cc42005-12-13 23:26:29 -0800687 spin_lock(&unix_table_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688 ordernum = (ordernum+1)&0xFFFFF;
689
Denis V. Lunev097e66c2007-11-19 22:29:30 -0800690 if (__unix_find_socket_byname(net, addr->name, addr->len, sock->type,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691 addr->hash)) {
David S. Millerfbe9cc42005-12-13 23:26:29 -0800692 spin_unlock(&unix_table_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693 /* Sanity yield. It is unusual case, but yet... */
694 if (!(ordernum&0xFF))
695 yield();
696 goto retry;
697 }
698 addr->hash ^= sk->sk_type;
699
700 __unix_remove_socket(sk);
701 u->addr = addr;
702 __unix_insert_socket(&unix_socket_table[addr->hash], sk);
David S. Millerfbe9cc42005-12-13 23:26:29 -0800703 spin_unlock(&unix_table_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704 err = 0;
705
Ingo Molnar57b47a52006-03-20 22:35:41 -0800706out: mutex_unlock(&u->readlock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707 return err;
708}
709
Denis V. Lunev097e66c2007-11-19 22:29:30 -0800710static struct sock *unix_find_other(struct net *net,
711 struct sockaddr_un *sunname, int len,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712 int type, unsigned hash, int *error)
713{
714 struct sock *u;
Al Viro421748e2008-08-02 01:04:36 -0400715 struct path path;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716 int err = 0;
YOSHIFUJI Hideakiac7bfa62007-02-09 23:25:23 +0900717
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718 if (sunname->sun_path[0]) {
Al Viro421748e2008-08-02 01:04:36 -0400719 struct inode *inode;
720 err = kern_path(sunname->sun_path, LOOKUP_FOLLOW, &path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721 if (err)
722 goto fail;
Al Viro421748e2008-08-02 01:04:36 -0400723 inode = path.dentry->d_inode;
724 err = inode_permission(inode, MAY_WRITE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725 if (err)
726 goto put_fail;
727
728 err = -ECONNREFUSED;
Al Viro421748e2008-08-02 01:04:36 -0400729 if (!S_ISSOCK(inode->i_mode))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730 goto put_fail;
Al Viro421748e2008-08-02 01:04:36 -0400731 u = unix_find_socket_byinode(net, inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 if (!u)
733 goto put_fail;
734
735 if (u->sk_type == type)
Al Viro421748e2008-08-02 01:04:36 -0400736 touch_atime(path.mnt, path.dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737
Al Viro421748e2008-08-02 01:04:36 -0400738 path_put(&path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739
Jianjun Konge27dfce2008-11-01 21:38:31 -0700740 err = -EPROTOTYPE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741 if (u->sk_type != type) {
742 sock_put(u);
743 goto fail;
744 }
745 } else {
746 err = -ECONNREFUSED;
Jianjun Konge27dfce2008-11-01 21:38:31 -0700747 u = unix_find_socket_byname(net, sunname, len, type, hash);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748 if (u) {
749 struct dentry *dentry;
750 dentry = unix_sk(u)->dentry;
751 if (dentry)
752 touch_atime(unix_sk(u)->mnt, dentry);
753 } else
754 goto fail;
755 }
756 return u;
757
758put_fail:
Al Viro421748e2008-08-02 01:04:36 -0400759 path_put(&path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760fail:
Jianjun Konge27dfce2008-11-01 21:38:31 -0700761 *error = err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762 return NULL;
763}
764
765
766static int unix_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
767{
768 struct sock *sk = sock->sk;
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +0900769 struct net *net = sock_net(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 struct unix_sock *u = unix_sk(sk);
Jianjun Konge27dfce2008-11-01 21:38:31 -0700771 struct sockaddr_un *sunaddr = (struct sockaddr_un *)uaddr;
Eric Dumazet6eba6a32008-11-16 22:58:44 -0800772 struct dentry *dentry = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773 struct nameidata nd;
774 int err;
775 unsigned hash;
776 struct unix_address *addr;
777 struct hlist_head *list;
778
779 err = -EINVAL;
780 if (sunaddr->sun_family != AF_UNIX)
781 goto out;
782
Jianjun Konge27dfce2008-11-01 21:38:31 -0700783 if (addr_len == sizeof(short)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784 err = unix_autobind(sock);
785 goto out;
786 }
787
788 err = unix_mkname(sunaddr, addr_len, &hash);
789 if (err < 0)
790 goto out;
791 addr_len = err;
792
Ingo Molnar57b47a52006-03-20 22:35:41 -0800793 mutex_lock(&u->readlock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794
795 err = -EINVAL;
796 if (u->addr)
797 goto out_up;
798
799 err = -ENOMEM;
800 addr = kmalloc(sizeof(*addr)+addr_len, GFP_KERNEL);
801 if (!addr)
802 goto out_up;
803
804 memcpy(addr->name, sunaddr, addr_len);
805 addr->len = addr_len;
806 addr->hash = hash ^ sk->sk_type;
807 atomic_set(&addr->refcnt, 1);
808
809 if (sunaddr->sun_path[0]) {
810 unsigned int mode;
811 err = 0;
812 /*
813 * Get the parent directory, calculate the hash for last
814 * component.
815 */
816 err = path_lookup(sunaddr->sun_path, LOOKUP_PARENT, &nd);
817 if (err)
818 goto out_mknod_parent;
Christoph Hellwigf81a0bf2005-05-19 12:26:43 -0700819
820 dentry = lookup_create(&nd, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821 err = PTR_ERR(dentry);
822 if (IS_ERR(dentry))
823 goto out_mknod_unlock;
Christoph Hellwigf81a0bf2005-05-19 12:26:43 -0700824
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825 /*
826 * All right, let's create it.
827 */
828 mode = S_IFSOCK |
829 (SOCK_INODE(sock)->i_mode & ~current->fs->umask);
Dave Hansen463c3192008-02-15 14:37:57 -0800830 err = mnt_want_write(nd.path.mnt);
831 if (err)
832 goto out_mknod_dput;
Jan Blunck4ac91372008-02-14 19:34:32 -0800833 err = vfs_mknod(nd.path.dentry->d_inode, dentry, mode, 0);
Dave Hansen463c3192008-02-15 14:37:57 -0800834 mnt_drop_write(nd.path.mnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835 if (err)
836 goto out_mknod_dput;
Jan Blunck4ac91372008-02-14 19:34:32 -0800837 mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
838 dput(nd.path.dentry);
839 nd.path.dentry = dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840
841 addr->hash = UNIX_HASH_SIZE;
842 }
843
David S. Millerfbe9cc42005-12-13 23:26:29 -0800844 spin_lock(&unix_table_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845
846 if (!sunaddr->sun_path[0]) {
847 err = -EADDRINUSE;
Denis V. Lunev097e66c2007-11-19 22:29:30 -0800848 if (__unix_find_socket_byname(net, sunaddr, addr_len,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700849 sk->sk_type, hash)) {
850 unix_release_addr(addr);
851 goto out_unlock;
852 }
853
854 list = &unix_socket_table[addr->hash];
855 } else {
856 list = &unix_socket_table[dentry->d_inode->i_ino & (UNIX_HASH_SIZE-1)];
Jan Blunck4ac91372008-02-14 19:34:32 -0800857 u->dentry = nd.path.dentry;
858 u->mnt = nd.path.mnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859 }
860
861 err = 0;
862 __unix_remove_socket(sk);
863 u->addr = addr;
864 __unix_insert_socket(list, sk);
865
866out_unlock:
David S. Millerfbe9cc42005-12-13 23:26:29 -0800867 spin_unlock(&unix_table_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868out_up:
Ingo Molnar57b47a52006-03-20 22:35:41 -0800869 mutex_unlock(&u->readlock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870out:
871 return err;
872
873out_mknod_dput:
874 dput(dentry);
875out_mknod_unlock:
Jan Blunck4ac91372008-02-14 19:34:32 -0800876 mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
Jan Blunck1d957f92008-02-14 19:34:35 -0800877 path_put(&nd.path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878out_mknod_parent:
Jianjun Konge27dfce2008-11-01 21:38:31 -0700879 if (err == -EEXIST)
880 err = -EADDRINUSE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881 unix_release_addr(addr);
882 goto out_up;
883}
884
David S. Miller278a3de2007-05-31 15:19:20 -0700885static void unix_state_double_lock(struct sock *sk1, struct sock *sk2)
886{
887 if (unlikely(sk1 == sk2) || !sk2) {
888 unix_state_lock(sk1);
889 return;
890 }
891 if (sk1 < sk2) {
892 unix_state_lock(sk1);
893 unix_state_lock_nested(sk2);
894 } else {
895 unix_state_lock(sk2);
896 unix_state_lock_nested(sk1);
897 }
898}
899
900static void unix_state_double_unlock(struct sock *sk1, struct sock *sk2)
901{
902 if (unlikely(sk1 == sk2) || !sk2) {
903 unix_state_unlock(sk1);
904 return;
905 }
906 unix_state_unlock(sk1);
907 unix_state_unlock(sk2);
908}
909
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910static int unix_dgram_connect(struct socket *sock, struct sockaddr *addr,
911 int alen, int flags)
912{
913 struct sock *sk = sock->sk;
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +0900914 struct net *net = sock_net(sk);
Jianjun Konge27dfce2008-11-01 21:38:31 -0700915 struct sockaddr_un *sunaddr = (struct sockaddr_un *)addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916 struct sock *other;
917 unsigned hash;
918 int err;
919
920 if (addr->sa_family != AF_UNSPEC) {
921 err = unix_mkname(sunaddr, alen, &hash);
922 if (err < 0)
923 goto out;
924 alen = err;
925
926 if (test_bit(SOCK_PASSCRED, &sock->flags) &&
927 !unix_sk(sk)->addr && (err = unix_autobind(sock)) != 0)
928 goto out;
929
David S. Miller278a3de2007-05-31 15:19:20 -0700930restart:
Jianjun Konge27dfce2008-11-01 21:38:31 -0700931 other = unix_find_other(net, sunaddr, alen, sock->type, hash, &err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932 if (!other)
933 goto out;
934
David S. Miller278a3de2007-05-31 15:19:20 -0700935 unix_state_double_lock(sk, other);
936
937 /* Apparently VFS overslept socket death. Retry. */
938 if (sock_flag(other, SOCK_DEAD)) {
939 unix_state_double_unlock(sk, other);
940 sock_put(other);
941 goto restart;
942 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943
944 err = -EPERM;
945 if (!unix_may_send(sk, other))
946 goto out_unlock;
947
948 err = security_unix_may_send(sk->sk_socket, other->sk_socket);
949 if (err)
950 goto out_unlock;
951
952 } else {
953 /*
954 * 1003.1g breaking connected state with AF_UNSPEC
955 */
956 other = NULL;
David S. Miller278a3de2007-05-31 15:19:20 -0700957 unix_state_double_lock(sk, other);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958 }
959
960 /*
961 * If it was connected, reconnect.
962 */
963 if (unix_peer(sk)) {
964 struct sock *old_peer = unix_peer(sk);
Jianjun Konge27dfce2008-11-01 21:38:31 -0700965 unix_peer(sk) = other;
David S. Miller278a3de2007-05-31 15:19:20 -0700966 unix_state_double_unlock(sk, other);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967
968 if (other != old_peer)
969 unix_dgram_disconnected(sk, old_peer);
970 sock_put(old_peer);
971 } else {
Jianjun Konge27dfce2008-11-01 21:38:31 -0700972 unix_peer(sk) = other;
David S. Miller278a3de2007-05-31 15:19:20 -0700973 unix_state_double_unlock(sk, other);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700974 }
YOSHIFUJI Hideakiac7bfa62007-02-09 23:25:23 +0900975 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976
977out_unlock:
David S. Miller278a3de2007-05-31 15:19:20 -0700978 unix_state_double_unlock(sk, other);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979 sock_put(other);
980out:
981 return err;
982}
983
984static long unix_wait_for_peer(struct sock *other, long timeo)
985{
986 struct unix_sock *u = unix_sk(other);
987 int sched;
988 DEFINE_WAIT(wait);
989
990 prepare_to_wait_exclusive(&u->peer_wait, &wait, TASK_INTERRUPTIBLE);
991
992 sched = !sock_flag(other, SOCK_DEAD) &&
993 !(other->sk_shutdown & RCV_SHUTDOWN) &&
Rainer Weikusat3c734192008-06-17 22:28:05 -0700994 unix_recvq_full(other);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995
David S. Miller1c92b4e2007-05-31 13:24:26 -0700996 unix_state_unlock(other);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700997
998 if (sched)
999 timeo = schedule_timeout(timeo);
1000
1001 finish_wait(&u->peer_wait, &wait);
1002 return timeo;
1003}
1004
1005static int unix_stream_connect(struct socket *sock, struct sockaddr *uaddr,
1006 int addr_len, int flags)
1007{
Jianjun Konge27dfce2008-11-01 21:38:31 -07001008 struct sockaddr_un *sunaddr = (struct sockaddr_un *)uaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009 struct sock *sk = sock->sk;
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001010 struct net *net = sock_net(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011 struct unix_sock *u = unix_sk(sk), *newu, *otheru;
1012 struct sock *newsk = NULL;
1013 struct sock *other = NULL;
1014 struct sk_buff *skb = NULL;
1015 unsigned hash;
1016 int st;
1017 int err;
1018 long timeo;
1019
1020 err = unix_mkname(sunaddr, addr_len, &hash);
1021 if (err < 0)
1022 goto out;
1023 addr_len = err;
1024
1025 if (test_bit(SOCK_PASSCRED, &sock->flags)
1026 && !u->addr && (err = unix_autobind(sock)) != 0)
1027 goto out;
1028
1029 timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
1030
1031 /* First of all allocate resources.
1032 If we will make it after state is locked,
1033 we will have to recheck all again in any case.
1034 */
1035
1036 err = -ENOMEM;
1037
1038 /* create new sock for complete connection */
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001039 newsk = unix_create1(sock_net(sk), NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040 if (newsk == NULL)
1041 goto out;
1042
1043 /* Allocate skb for sending to listening sock */
1044 skb = sock_wmalloc(newsk, 1, 0, GFP_KERNEL);
1045 if (skb == NULL)
1046 goto out;
1047
1048restart:
1049 /* Find listening sock. */
Denis V. Lunev097e66c2007-11-19 22:29:30 -08001050 other = unix_find_other(net, sunaddr, addr_len, sk->sk_type, hash, &err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001051 if (!other)
1052 goto out;
1053
1054 /* Latch state of peer */
David S. Miller1c92b4e2007-05-31 13:24:26 -07001055 unix_state_lock(other);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001056
1057 /* Apparently VFS overslept socket death. Retry. */
1058 if (sock_flag(other, SOCK_DEAD)) {
David S. Miller1c92b4e2007-05-31 13:24:26 -07001059 unix_state_unlock(other);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060 sock_put(other);
1061 goto restart;
1062 }
1063
1064 err = -ECONNREFUSED;
1065 if (other->sk_state != TCP_LISTEN)
1066 goto out_unlock;
1067
Rainer Weikusat3c734192008-06-17 22:28:05 -07001068 if (unix_recvq_full(other)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069 err = -EAGAIN;
1070 if (!timeo)
1071 goto out_unlock;
1072
1073 timeo = unix_wait_for_peer(other, timeo);
1074
1075 err = sock_intr_errno(timeo);
1076 if (signal_pending(current))
1077 goto out;
1078 sock_put(other);
1079 goto restart;
YOSHIFUJI Hideakiac7bfa62007-02-09 23:25:23 +09001080 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001081
1082 /* Latch our state.
1083
1084 It is tricky place. We need to grab write lock and cannot
1085 drop lock on peer. It is dangerous because deadlock is
1086 possible. Connect to self case and simultaneous
1087 attempt to connect are eliminated by checking socket
1088 state. other is TCP_LISTEN, if sk is TCP_LISTEN we
1089 check this before attempt to grab lock.
1090
1091 Well, and we have to recheck the state after socket locked.
1092 */
1093 st = sk->sk_state;
1094
1095 switch (st) {
1096 case TCP_CLOSE:
1097 /* This is ok... continue with connect */
1098 break;
1099 case TCP_ESTABLISHED:
1100 /* Socket is already connected */
1101 err = -EISCONN;
1102 goto out_unlock;
1103 default:
1104 err = -EINVAL;
1105 goto out_unlock;
1106 }
1107
David S. Miller1c92b4e2007-05-31 13:24:26 -07001108 unix_state_lock_nested(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001109
1110 if (sk->sk_state != st) {
David S. Miller1c92b4e2007-05-31 13:24:26 -07001111 unix_state_unlock(sk);
1112 unix_state_unlock(other);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001113 sock_put(other);
1114 goto restart;
1115 }
1116
1117 err = security_unix_stream_connect(sock, other->sk_socket, newsk);
1118 if (err) {
David S. Miller1c92b4e2007-05-31 13:24:26 -07001119 unix_state_unlock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120 goto out_unlock;
1121 }
1122
1123 /* The way is open! Fastly set all the necessary fields... */
1124
1125 sock_hold(sk);
1126 unix_peer(newsk) = sk;
1127 newsk->sk_state = TCP_ESTABLISHED;
1128 newsk->sk_type = sk->sk_type;
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001129 newsk->sk_peercred.pid = task_tgid_vnr(current);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130 newsk->sk_peercred.uid = current->euid;
1131 newsk->sk_peercred.gid = current->egid;
1132 newu = unix_sk(newsk);
1133 newsk->sk_sleep = &newu->peer_wait;
1134 otheru = unix_sk(other);
1135
1136 /* copy address information from listening to new sock*/
1137 if (otheru->addr) {
1138 atomic_inc(&otheru->addr->refcnt);
1139 newu->addr = otheru->addr;
1140 }
1141 if (otheru->dentry) {
1142 newu->dentry = dget(otheru->dentry);
1143 newu->mnt = mntget(otheru->mnt);
1144 }
1145
1146 /* Set credentials */
1147 sk->sk_peercred = other->sk_peercred;
1148
Linus Torvalds1da177e2005-04-16 15:20:36 -07001149 sock->state = SS_CONNECTED;
1150 sk->sk_state = TCP_ESTABLISHED;
Benjamin LaHaise830a1e52005-12-13 23:22:32 -08001151 sock_hold(newsk);
1152
1153 smp_mb__after_atomic_inc(); /* sock_hold() does an atomic_inc() */
1154 unix_peer(sk) = newsk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001155
David S. Miller1c92b4e2007-05-31 13:24:26 -07001156 unix_state_unlock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001157
1158 /* take ten and and send info to listening sock */
1159 spin_lock(&other->sk_receive_queue.lock);
1160 __skb_queue_tail(&other->sk_receive_queue, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161 spin_unlock(&other->sk_receive_queue.lock);
David S. Miller1c92b4e2007-05-31 13:24:26 -07001162 unix_state_unlock(other);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001163 other->sk_data_ready(other, 0);
1164 sock_put(other);
1165 return 0;
1166
1167out_unlock:
1168 if (other)
David S. Miller1c92b4e2007-05-31 13:24:26 -07001169 unix_state_unlock(other);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001170
1171out:
1172 if (skb)
1173 kfree_skb(skb);
1174 if (newsk)
1175 unix_release_sock(newsk, 0);
1176 if (other)
1177 sock_put(other);
1178 return err;
1179}
1180
1181static int unix_socketpair(struct socket *socka, struct socket *sockb)
1182{
Jianjun Konge27dfce2008-11-01 21:38:31 -07001183 struct sock *ska = socka->sk, *skb = sockb->sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001184
1185 /* Join our sockets back to back */
1186 sock_hold(ska);
1187 sock_hold(skb);
Jianjun Konge27dfce2008-11-01 21:38:31 -07001188 unix_peer(ska) = skb;
1189 unix_peer(skb) = ska;
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001190 ska->sk_peercred.pid = skb->sk_peercred.pid = task_tgid_vnr(current);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001191 ska->sk_peercred.uid = skb->sk_peercred.uid = current->euid;
1192 ska->sk_peercred.gid = skb->sk_peercred.gid = current->egid;
1193
1194 if (ska->sk_type != SOCK_DGRAM) {
1195 ska->sk_state = TCP_ESTABLISHED;
1196 skb->sk_state = TCP_ESTABLISHED;
1197 socka->state = SS_CONNECTED;
1198 sockb->state = SS_CONNECTED;
1199 }
1200 return 0;
1201}
1202
1203static int unix_accept(struct socket *sock, struct socket *newsock, int flags)
1204{
1205 struct sock *sk = sock->sk;
1206 struct sock *tsk;
1207 struct sk_buff *skb;
1208 int err;
1209
1210 err = -EOPNOTSUPP;
Eric Dumazet6eba6a32008-11-16 22:58:44 -08001211 if (sock->type != SOCK_STREAM && sock->type != SOCK_SEQPACKET)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001212 goto out;
1213
1214 err = -EINVAL;
1215 if (sk->sk_state != TCP_LISTEN)
1216 goto out;
1217
1218 /* If socket state is TCP_LISTEN it cannot change (for now...),
1219 * so that no locks are necessary.
1220 */
1221
1222 skb = skb_recv_datagram(sk, 0, flags&O_NONBLOCK, &err);
1223 if (!skb) {
1224 /* This means receive shutdown. */
1225 if (err == 0)
1226 err = -EINVAL;
1227 goto out;
1228 }
1229
1230 tsk = skb->sk;
1231 skb_free_datagram(sk, skb);
1232 wake_up_interruptible(&unix_sk(sk)->peer_wait);
1233
1234 /* attach accepted sock to socket */
David S. Miller1c92b4e2007-05-31 13:24:26 -07001235 unix_state_lock(tsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001236 newsock->state = SS_CONNECTED;
1237 sock_graft(tsk, newsock);
David S. Miller1c92b4e2007-05-31 13:24:26 -07001238 unix_state_unlock(tsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001239 return 0;
1240
1241out:
1242 return err;
1243}
1244
1245
1246static int unix_getname(struct socket *sock, struct sockaddr *uaddr, int *uaddr_len, int peer)
1247{
1248 struct sock *sk = sock->sk;
1249 struct unix_sock *u;
Jianjun Konge27dfce2008-11-01 21:38:31 -07001250 struct sockaddr_un *sunaddr = (struct sockaddr_un *)uaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001251 int err = 0;
1252
1253 if (peer) {
1254 sk = unix_peer_get(sk);
1255
1256 err = -ENOTCONN;
1257 if (!sk)
1258 goto out;
1259 err = 0;
1260 } else {
1261 sock_hold(sk);
1262 }
1263
1264 u = unix_sk(sk);
David S. Miller1c92b4e2007-05-31 13:24:26 -07001265 unix_state_lock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001266 if (!u->addr) {
1267 sunaddr->sun_family = AF_UNIX;
1268 sunaddr->sun_path[0] = 0;
1269 *uaddr_len = sizeof(short);
1270 } else {
1271 struct unix_address *addr = u->addr;
1272
1273 *uaddr_len = addr->len;
1274 memcpy(sunaddr, addr->name, *uaddr_len);
1275 }
David S. Miller1c92b4e2007-05-31 13:24:26 -07001276 unix_state_unlock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001277 sock_put(sk);
1278out:
1279 return err;
1280}
1281
1282static void unix_detach_fds(struct scm_cookie *scm, struct sk_buff *skb)
1283{
1284 int i;
1285
1286 scm->fp = UNIXCB(skb).fp;
1287 skb->destructor = sock_wfree;
1288 UNIXCB(skb).fp = NULL;
1289
Eric Dumazet6eba6a32008-11-16 22:58:44 -08001290 for (i = scm->fp->count-1; i >= 0; i--)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001291 unix_notinflight(scm->fp->fp[i]);
1292}
1293
1294static void unix_destruct_fds(struct sk_buff *skb)
1295{
1296 struct scm_cookie scm;
1297 memset(&scm, 0, sizeof(scm));
1298 unix_detach_fds(&scm, skb);
1299
1300 /* Alas, it calls VFS */
1301 /* So fscking what? fput() had been SMP-safe since the last Summer */
1302 scm_destroy(&scm);
1303 sock_wfree(skb);
1304}
1305
Miklos Szeredi62093442008-11-09 15:23:57 +01001306static int unix_attach_fds(struct scm_cookie *scm, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001307{
1308 int i;
Miklos Szeredi62093442008-11-09 15:23:57 +01001309
1310 /*
1311 * Need to duplicate file references for the sake of garbage
1312 * collection. Otherwise a socket in the fps might become a
1313 * candidate for GC while the skb is not yet queued.
1314 */
1315 UNIXCB(skb).fp = scm_fp_dup(scm->fp);
1316 if (!UNIXCB(skb).fp)
1317 return -ENOMEM;
1318
Eric Dumazet6eba6a32008-11-16 22:58:44 -08001319 for (i = scm->fp->count-1; i >= 0; i--)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001320 unix_inflight(scm->fp->fp[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321 skb->destructor = unix_destruct_fds;
Miklos Szeredi62093442008-11-09 15:23:57 +01001322 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001323}
1324
1325/*
1326 * Send AF_UNIX data.
1327 */
1328
1329static int unix_dgram_sendmsg(struct kiocb *kiocb, struct socket *sock,
1330 struct msghdr *msg, size_t len)
1331{
1332 struct sock_iocb *siocb = kiocb_to_siocb(kiocb);
1333 struct sock *sk = sock->sk;
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001334 struct net *net = sock_net(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001335 struct unix_sock *u = unix_sk(sk);
Jianjun Konge27dfce2008-11-01 21:38:31 -07001336 struct sockaddr_un *sunaddr = msg->msg_name;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001337 struct sock *other = NULL;
1338 int namelen = 0; /* fake GCC */
1339 int err;
1340 unsigned hash;
1341 struct sk_buff *skb;
1342 long timeo;
1343 struct scm_cookie tmp_scm;
1344
1345 if (NULL == siocb->scm)
1346 siocb->scm = &tmp_scm;
1347 err = scm_send(sock, msg, siocb->scm);
1348 if (err < 0)
1349 return err;
1350
1351 err = -EOPNOTSUPP;
1352 if (msg->msg_flags&MSG_OOB)
1353 goto out;
1354
1355 if (msg->msg_namelen) {
1356 err = unix_mkname(sunaddr, msg->msg_namelen, &hash);
1357 if (err < 0)
1358 goto out;
1359 namelen = err;
1360 } else {
1361 sunaddr = NULL;
1362 err = -ENOTCONN;
1363 other = unix_peer_get(sk);
1364 if (!other)
1365 goto out;
1366 }
1367
1368 if (test_bit(SOCK_PASSCRED, &sock->flags)
1369 && !u->addr && (err = unix_autobind(sock)) != 0)
1370 goto out;
1371
1372 err = -EMSGSIZE;
1373 if (len > sk->sk_sndbuf - 32)
1374 goto out;
1375
1376 skb = sock_alloc_send_skb(sk, len, msg->msg_flags&MSG_DONTWAIT, &err);
Jianjun Konge27dfce2008-11-01 21:38:31 -07001377 if (skb == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001378 goto out;
1379
1380 memcpy(UNIXCREDS(skb), &siocb->scm->creds, sizeof(struct ucred));
Miklos Szeredi62093442008-11-09 15:23:57 +01001381 if (siocb->scm->fp) {
1382 err = unix_attach_fds(siocb->scm, skb);
1383 if (err)
1384 goto out_free;
1385 }
Catherine Zhangdc49c1f2006-08-02 14:12:06 -07001386 unix_get_secdata(siocb->scm, skb);
Catherine Zhang877ce7c2006-06-29 12:27:47 -07001387
Arnaldo Carvalho de Melobadff6d2007-03-13 13:06:52 -03001388 skb_reset_transport_header(skb);
Eric Dumazet6eba6a32008-11-16 22:58:44 -08001389 err = memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001390 if (err)
1391 goto out_free;
1392
1393 timeo = sock_sndtimeo(sk, msg->msg_flags & MSG_DONTWAIT);
1394
1395restart:
1396 if (!other) {
1397 err = -ECONNRESET;
1398 if (sunaddr == NULL)
1399 goto out_free;
1400
Denis V. Lunev097e66c2007-11-19 22:29:30 -08001401 other = unix_find_other(net, sunaddr, namelen, sk->sk_type,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001402 hash, &err);
Jianjun Konge27dfce2008-11-01 21:38:31 -07001403 if (other == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001404 goto out_free;
1405 }
1406
David S. Miller1c92b4e2007-05-31 13:24:26 -07001407 unix_state_lock(other);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001408 err = -EPERM;
1409 if (!unix_may_send(sk, other))
1410 goto out_unlock;
1411
1412 if (sock_flag(other, SOCK_DEAD)) {
1413 /*
1414 * Check with 1003.1g - what should
1415 * datagram error
1416 */
David S. Miller1c92b4e2007-05-31 13:24:26 -07001417 unix_state_unlock(other);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001418 sock_put(other);
1419
1420 err = 0;
David S. Miller1c92b4e2007-05-31 13:24:26 -07001421 unix_state_lock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001422 if (unix_peer(sk) == other) {
Jianjun Konge27dfce2008-11-01 21:38:31 -07001423 unix_peer(sk) = NULL;
David S. Miller1c92b4e2007-05-31 13:24:26 -07001424 unix_state_unlock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001425
1426 unix_dgram_disconnected(sk, other);
1427 sock_put(other);
1428 err = -ECONNREFUSED;
1429 } else {
David S. Miller1c92b4e2007-05-31 13:24:26 -07001430 unix_state_unlock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001431 }
1432
1433 other = NULL;
1434 if (err)
1435 goto out_free;
1436 goto restart;
1437 }
1438
1439 err = -EPIPE;
1440 if (other->sk_shutdown & RCV_SHUTDOWN)
1441 goto out_unlock;
1442
1443 if (sk->sk_type != SOCK_SEQPACKET) {
1444 err = security_unix_may_send(sk->sk_socket, other->sk_socket);
1445 if (err)
1446 goto out_unlock;
1447 }
1448
Rainer Weikusat3c734192008-06-17 22:28:05 -07001449 if (unix_peer(other) != sk && unix_recvq_full(other)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001450 if (!timeo) {
1451 err = -EAGAIN;
1452 goto out_unlock;
1453 }
1454
1455 timeo = unix_wait_for_peer(other, timeo);
1456
1457 err = sock_intr_errno(timeo);
1458 if (signal_pending(current))
1459 goto out_free;
1460
1461 goto restart;
1462 }
1463
1464 skb_queue_tail(&other->sk_receive_queue, skb);
David S. Miller1c92b4e2007-05-31 13:24:26 -07001465 unix_state_unlock(other);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001466 other->sk_data_ready(other, len);
1467 sock_put(other);
1468 scm_destroy(siocb->scm);
1469 return len;
1470
1471out_unlock:
David S. Miller1c92b4e2007-05-31 13:24:26 -07001472 unix_state_unlock(other);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001473out_free:
1474 kfree_skb(skb);
1475out:
1476 if (other)
1477 sock_put(other);
1478 scm_destroy(siocb->scm);
1479 return err;
1480}
1481
YOSHIFUJI Hideakiac7bfa62007-02-09 23:25:23 +09001482
Linus Torvalds1da177e2005-04-16 15:20:36 -07001483static int unix_stream_sendmsg(struct kiocb *kiocb, struct socket *sock,
1484 struct msghdr *msg, size_t len)
1485{
1486 struct sock_iocb *siocb = kiocb_to_siocb(kiocb);
1487 struct sock *sk = sock->sk;
1488 struct sock *other = NULL;
Jianjun Konge27dfce2008-11-01 21:38:31 -07001489 struct sockaddr_un *sunaddr = msg->msg_name;
Eric Dumazet6eba6a32008-11-16 22:58:44 -08001490 int err, size;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001491 struct sk_buff *skb;
Jianjun Konge27dfce2008-11-01 21:38:31 -07001492 int sent = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001493 struct scm_cookie tmp_scm;
1494
1495 if (NULL == siocb->scm)
1496 siocb->scm = &tmp_scm;
1497 err = scm_send(sock, msg, siocb->scm);
1498 if (err < 0)
1499 return err;
1500
1501 err = -EOPNOTSUPP;
1502 if (msg->msg_flags&MSG_OOB)
1503 goto out_err;
1504
1505 if (msg->msg_namelen) {
1506 err = sk->sk_state == TCP_ESTABLISHED ? -EISCONN : -EOPNOTSUPP;
1507 goto out_err;
1508 } else {
1509 sunaddr = NULL;
1510 err = -ENOTCONN;
Benjamin LaHaise830a1e52005-12-13 23:22:32 -08001511 other = unix_peer(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001512 if (!other)
1513 goto out_err;
1514 }
1515
1516 if (sk->sk_shutdown & SEND_SHUTDOWN)
1517 goto pipe_err;
1518
Eric Dumazet6eba6a32008-11-16 22:58:44 -08001519 while (sent < len) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001520 /*
Benjamin LaHaisee9df7d7f2006-03-20 21:29:05 -08001521 * Optimisation for the fact that under 0.01% of X
1522 * messages typically need breaking up.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001523 */
1524
Benjamin LaHaisee9df7d7f2006-03-20 21:29:05 -08001525 size = len-sent;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001526
1527 /* Keep two messages in the pipe so it schedules better */
Benjamin LaHaisee9df7d7f2006-03-20 21:29:05 -08001528 if (size > ((sk->sk_sndbuf >> 1) - 64))
1529 size = (sk->sk_sndbuf >> 1) - 64;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001530
1531 if (size > SKB_MAX_ALLOC)
1532 size = SKB_MAX_ALLOC;
YOSHIFUJI Hideakiac7bfa62007-02-09 23:25:23 +09001533
Linus Torvalds1da177e2005-04-16 15:20:36 -07001534 /*
1535 * Grab a buffer
1536 */
YOSHIFUJI Hideakiac7bfa62007-02-09 23:25:23 +09001537
Eric Dumazet6eba6a32008-11-16 22:58:44 -08001538 skb = sock_alloc_send_skb(sk, size, msg->msg_flags&MSG_DONTWAIT,
1539 &err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001540
Jianjun Konge27dfce2008-11-01 21:38:31 -07001541 if (skb == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001542 goto out_err;
1543
1544 /*
1545 * If you pass two values to the sock_alloc_send_skb
1546 * it tries to grab the large buffer with GFP_NOFS
1547 * (which can fail easily), and if it fails grab the
1548 * fallback size buffer which is under a page and will
1549 * succeed. [Alan]
1550 */
1551 size = min_t(int, size, skb_tailroom(skb));
1552
1553 memcpy(UNIXCREDS(skb), &siocb->scm->creds, sizeof(struct ucred));
Miklos Szeredi62093442008-11-09 15:23:57 +01001554 if (siocb->scm->fp) {
1555 err = unix_attach_fds(siocb->scm, skb);
1556 if (err) {
1557 kfree_skb(skb);
1558 goto out_err;
1559 }
1560 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561
Eric Dumazet6eba6a32008-11-16 22:58:44 -08001562 err = memcpy_fromiovec(skb_put(skb, size), msg->msg_iov, size);
1563 if (err) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001564 kfree_skb(skb);
1565 goto out_err;
1566 }
1567
David S. Miller1c92b4e2007-05-31 13:24:26 -07001568 unix_state_lock(other);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001569
1570 if (sock_flag(other, SOCK_DEAD) ||
1571 (other->sk_shutdown & RCV_SHUTDOWN))
1572 goto pipe_err_free;
1573
1574 skb_queue_tail(&other->sk_receive_queue, skb);
David S. Miller1c92b4e2007-05-31 13:24:26 -07001575 unix_state_unlock(other);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001576 other->sk_data_ready(other, size);
Jianjun Konge27dfce2008-11-01 21:38:31 -07001577 sent += size;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001578 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001579
1580 scm_destroy(siocb->scm);
1581 siocb->scm = NULL;
1582
1583 return sent;
1584
1585pipe_err_free:
David S. Miller1c92b4e2007-05-31 13:24:26 -07001586 unix_state_unlock(other);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001587 kfree_skb(skb);
1588pipe_err:
Eric Dumazet6eba6a32008-11-16 22:58:44 -08001589 if (sent == 0 && !(msg->msg_flags&MSG_NOSIGNAL))
1590 send_sig(SIGPIPE, current, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591 err = -EPIPE;
1592out_err:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001593 scm_destroy(siocb->scm);
1594 siocb->scm = NULL;
1595 return sent ? : err;
1596}
1597
1598static int unix_seqpacket_sendmsg(struct kiocb *kiocb, struct socket *sock,
1599 struct msghdr *msg, size_t len)
1600{
1601 int err;
1602 struct sock *sk = sock->sk;
YOSHIFUJI Hideakiac7bfa62007-02-09 23:25:23 +09001603
Linus Torvalds1da177e2005-04-16 15:20:36 -07001604 err = sock_error(sk);
1605 if (err)
1606 return err;
1607
1608 if (sk->sk_state != TCP_ESTABLISHED)
1609 return -ENOTCONN;
1610
1611 if (msg->msg_namelen)
1612 msg->msg_namelen = 0;
1613
1614 return unix_dgram_sendmsg(kiocb, sock, msg, len);
1615}
YOSHIFUJI Hideakiac7bfa62007-02-09 23:25:23 +09001616
Linus Torvalds1da177e2005-04-16 15:20:36 -07001617static void unix_copy_addr(struct msghdr *msg, struct sock *sk)
1618{
1619 struct unix_sock *u = unix_sk(sk);
1620
1621 msg->msg_namelen = 0;
1622 if (u->addr) {
1623 msg->msg_namelen = u->addr->len;
1624 memcpy(msg->msg_name, u->addr->name, u->addr->len);
1625 }
1626}
1627
1628static int unix_dgram_recvmsg(struct kiocb *iocb, struct socket *sock,
1629 struct msghdr *msg, size_t size,
1630 int flags)
1631{
1632 struct sock_iocb *siocb = kiocb_to_siocb(iocb);
1633 struct scm_cookie tmp_scm;
1634 struct sock *sk = sock->sk;
1635 struct unix_sock *u = unix_sk(sk);
1636 int noblock = flags & MSG_DONTWAIT;
1637 struct sk_buff *skb;
1638 int err;
1639
1640 err = -EOPNOTSUPP;
1641 if (flags&MSG_OOB)
1642 goto out;
1643
1644 msg->msg_namelen = 0;
1645
Ingo Molnar57b47a52006-03-20 22:35:41 -08001646 mutex_lock(&u->readlock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001647
1648 skb = skb_recv_datagram(sk, flags, noblock, &err);
Florian Zumbiehl0a112252007-11-29 23:19:23 +11001649 if (!skb) {
1650 unix_state_lock(sk);
1651 /* Signal EOF on disconnected non-blocking SEQPACKET socket. */
1652 if (sk->sk_type == SOCK_SEQPACKET && err == -EAGAIN &&
1653 (sk->sk_shutdown & RCV_SHUTDOWN))
1654 err = 0;
1655 unix_state_unlock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001656 goto out_unlock;
Florian Zumbiehl0a112252007-11-29 23:19:23 +11001657 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001658
Ingo Molnar71e20f12007-10-15 17:00:19 +02001659 wake_up_interruptible_sync(&u->peer_wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001660
1661 if (msg->msg_name)
1662 unix_copy_addr(msg, skb->sk);
1663
1664 if (size > skb->len)
1665 size = skb->len;
1666 else if (size < skb->len)
1667 msg->msg_flags |= MSG_TRUNC;
1668
1669 err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, size);
1670 if (err)
1671 goto out_free;
1672
1673 if (!siocb->scm) {
1674 siocb->scm = &tmp_scm;
1675 memset(&tmp_scm, 0, sizeof(tmp_scm));
1676 }
1677 siocb->scm->creds = *UNIXCREDS(skb);
Catherine Zhang877ce7c2006-06-29 12:27:47 -07001678 unix_set_secdata(siocb->scm, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001679
Eric Dumazet6eba6a32008-11-16 22:58:44 -08001680 if (!(flags & MSG_PEEK)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001681 if (UNIXCB(skb).fp)
1682 unix_detach_fds(siocb->scm, skb);
Eric Dumazet6eba6a32008-11-16 22:58:44 -08001683 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001684 /* It is questionable: on PEEK we could:
1685 - do not return fds - good, but too simple 8)
1686 - return fds, and do not return them on read (old strategy,
1687 apparently wrong)
1688 - clone fds (I chose it for now, it is the most universal
1689 solution)
YOSHIFUJI Hideakiac7bfa62007-02-09 23:25:23 +09001690
1691 POSIX 1003.1g does not actually define this clearly
1692 at all. POSIX 1003.1g doesn't define a lot of things
1693 clearly however!
1694
Linus Torvalds1da177e2005-04-16 15:20:36 -07001695 */
1696 if (UNIXCB(skb).fp)
1697 siocb->scm->fp = scm_fp_dup(UNIXCB(skb).fp);
1698 }
1699 err = size;
1700
1701 scm_recv(sock, msg, siocb->scm, flags);
1702
1703out_free:
Eric Dumazet6eba6a32008-11-16 22:58:44 -08001704 skb_free_datagram(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001705out_unlock:
Ingo Molnar57b47a52006-03-20 22:35:41 -08001706 mutex_unlock(&u->readlock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001707out:
1708 return err;
1709}
1710
1711/*
1712 * Sleep until data has arrive. But check for races..
1713 */
YOSHIFUJI Hideakiac7bfa62007-02-09 23:25:23 +09001714
Eric Dumazet6eba6a32008-11-16 22:58:44 -08001715static long unix_stream_data_wait(struct sock *sk, long timeo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001716{
1717 DEFINE_WAIT(wait);
1718
David S. Miller1c92b4e2007-05-31 13:24:26 -07001719 unix_state_lock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001720
1721 for (;;) {
1722 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
1723
David S. Millerb03efcf2005-07-08 14:57:23 -07001724 if (!skb_queue_empty(&sk->sk_receive_queue) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -07001725 sk->sk_err ||
1726 (sk->sk_shutdown & RCV_SHUTDOWN) ||
1727 signal_pending(current) ||
1728 !timeo)
1729 break;
1730
1731 set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
David S. Miller1c92b4e2007-05-31 13:24:26 -07001732 unix_state_unlock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001733 timeo = schedule_timeout(timeo);
David S. Miller1c92b4e2007-05-31 13:24:26 -07001734 unix_state_lock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001735 clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
1736 }
1737
1738 finish_wait(sk->sk_sleep, &wait);
David S. Miller1c92b4e2007-05-31 13:24:26 -07001739 unix_state_unlock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001740 return timeo;
1741}
1742
1743
1744
1745static int unix_stream_recvmsg(struct kiocb *iocb, struct socket *sock,
1746 struct msghdr *msg, size_t size,
1747 int flags)
1748{
1749 struct sock_iocb *siocb = kiocb_to_siocb(iocb);
1750 struct scm_cookie tmp_scm;
1751 struct sock *sk = sock->sk;
1752 struct unix_sock *u = unix_sk(sk);
Jianjun Konge27dfce2008-11-01 21:38:31 -07001753 struct sockaddr_un *sunaddr = msg->msg_name;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001754 int copied = 0;
1755 int check_creds = 0;
1756 int target;
1757 int err = 0;
1758 long timeo;
1759
1760 err = -EINVAL;
1761 if (sk->sk_state != TCP_ESTABLISHED)
1762 goto out;
1763
1764 err = -EOPNOTSUPP;
1765 if (flags&MSG_OOB)
1766 goto out;
1767
1768 target = sock_rcvlowat(sk, flags&MSG_WAITALL, size);
1769 timeo = sock_rcvtimeo(sk, flags&MSG_DONTWAIT);
1770
1771 msg->msg_namelen = 0;
1772
1773 /* Lock the socket to prevent queue disordering
1774 * while sleeps in memcpy_tomsg
1775 */
1776
1777 if (!siocb->scm) {
1778 siocb->scm = &tmp_scm;
1779 memset(&tmp_scm, 0, sizeof(tmp_scm));
1780 }
1781
Ingo Molnar57b47a52006-03-20 22:35:41 -08001782 mutex_lock(&u->readlock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001783
Eric Dumazet6eba6a32008-11-16 22:58:44 -08001784 do {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001785 int chunk;
1786 struct sk_buff *skb;
1787
Miklos Szeredi3c0d2f32007-06-05 13:10:29 -07001788 unix_state_lock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001789 skb = skb_dequeue(&sk->sk_receive_queue);
Eric Dumazet6eba6a32008-11-16 22:58:44 -08001790 if (skb == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001791 if (copied >= target)
Miklos Szeredi3c0d2f32007-06-05 13:10:29 -07001792 goto unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001793
1794 /*
1795 * POSIX 1003.1g mandates this order.
1796 */
YOSHIFUJI Hideakiac7bfa62007-02-09 23:25:23 +09001797
Eric Dumazet6eba6a32008-11-16 22:58:44 -08001798 err = sock_error(sk);
1799 if (err)
Miklos Szeredi3c0d2f32007-06-05 13:10:29 -07001800 goto unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001801 if (sk->sk_shutdown & RCV_SHUTDOWN)
Miklos Szeredi3c0d2f32007-06-05 13:10:29 -07001802 goto unlock;
1803
1804 unix_state_unlock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001805 err = -EAGAIN;
1806 if (!timeo)
1807 break;
Ingo Molnar57b47a52006-03-20 22:35:41 -08001808 mutex_unlock(&u->readlock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001809
1810 timeo = unix_stream_data_wait(sk, timeo);
1811
1812 if (signal_pending(current)) {
1813 err = sock_intr_errno(timeo);
1814 goto out;
1815 }
Ingo Molnar57b47a52006-03-20 22:35:41 -08001816 mutex_lock(&u->readlock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001817 continue;
Miklos Szeredi3c0d2f32007-06-05 13:10:29 -07001818 unlock:
1819 unix_state_unlock(sk);
1820 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001821 }
Miklos Szeredi3c0d2f32007-06-05 13:10:29 -07001822 unix_state_unlock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001823
1824 if (check_creds) {
1825 /* Never glue messages from different writers */
Eric Dumazet6eba6a32008-11-16 22:58:44 -08001826 if (memcmp(UNIXCREDS(skb), &siocb->scm->creds,
1827 sizeof(siocb->scm->creds)) != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001828 skb_queue_head(&sk->sk_receive_queue, skb);
1829 break;
1830 }
1831 } else {
1832 /* Copy credentials */
1833 siocb->scm->creds = *UNIXCREDS(skb);
1834 check_creds = 1;
1835 }
1836
1837 /* Copy address just once */
Eric Dumazet6eba6a32008-11-16 22:58:44 -08001838 if (sunaddr) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001839 unix_copy_addr(msg, skb->sk);
1840 sunaddr = NULL;
1841 }
1842
1843 chunk = min_t(unsigned int, skb->len, size);
1844 if (memcpy_toiovec(msg->msg_iov, skb->data, chunk)) {
1845 skb_queue_head(&sk->sk_receive_queue, skb);
1846 if (copied == 0)
1847 copied = -EFAULT;
1848 break;
1849 }
1850 copied += chunk;
1851 size -= chunk;
1852
1853 /* Mark read part of skb as used */
Eric Dumazet6eba6a32008-11-16 22:58:44 -08001854 if (!(flags & MSG_PEEK)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001855 skb_pull(skb, chunk);
1856
1857 if (UNIXCB(skb).fp)
1858 unix_detach_fds(siocb->scm, skb);
1859
1860 /* put the skb back if we didn't use it up.. */
Eric Dumazet6eba6a32008-11-16 22:58:44 -08001861 if (skb->len) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001862 skb_queue_head(&sk->sk_receive_queue, skb);
1863 break;
1864 }
1865
1866 kfree_skb(skb);
1867
1868 if (siocb->scm->fp)
1869 break;
Eric Dumazet6eba6a32008-11-16 22:58:44 -08001870 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001871 /* It is questionable, see note in unix_dgram_recvmsg.
1872 */
1873 if (UNIXCB(skb).fp)
1874 siocb->scm->fp = scm_fp_dup(UNIXCB(skb).fp);
1875
1876 /* put message back and return */
1877 skb_queue_head(&sk->sk_receive_queue, skb);
1878 break;
1879 }
1880 } while (size);
1881
Ingo Molnar57b47a52006-03-20 22:35:41 -08001882 mutex_unlock(&u->readlock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001883 scm_recv(sock, msg, siocb->scm, flags);
1884out:
1885 return copied ? : err;
1886}
1887
1888static int unix_shutdown(struct socket *sock, int mode)
1889{
1890 struct sock *sk = sock->sk;
1891 struct sock *other;
1892
1893 mode = (mode+1)&(RCV_SHUTDOWN|SEND_SHUTDOWN);
1894
1895 if (mode) {
David S. Miller1c92b4e2007-05-31 13:24:26 -07001896 unix_state_lock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001897 sk->sk_shutdown |= mode;
Jianjun Konge27dfce2008-11-01 21:38:31 -07001898 other = unix_peer(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001899 if (other)
1900 sock_hold(other);
David S. Miller1c92b4e2007-05-31 13:24:26 -07001901 unix_state_unlock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001902 sk->sk_state_change(sk);
1903
1904 if (other &&
1905 (sk->sk_type == SOCK_STREAM || sk->sk_type == SOCK_SEQPACKET)) {
1906
1907 int peer_mode = 0;
1908
1909 if (mode&RCV_SHUTDOWN)
1910 peer_mode |= SEND_SHUTDOWN;
1911 if (mode&SEND_SHUTDOWN)
1912 peer_mode |= RCV_SHUTDOWN;
David S. Miller1c92b4e2007-05-31 13:24:26 -07001913 unix_state_lock(other);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001914 other->sk_shutdown |= peer_mode;
David S. Miller1c92b4e2007-05-31 13:24:26 -07001915 unix_state_unlock(other);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001916 other->sk_state_change(other);
1917 read_lock(&other->sk_callback_lock);
1918 if (peer_mode == SHUTDOWN_MASK)
Pavel Emelyanov8d8ad9d2007-11-26 20:10:50 +08001919 sk_wake_async(other, SOCK_WAKE_WAITD, POLL_HUP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001920 else if (peer_mode & RCV_SHUTDOWN)
Pavel Emelyanov8d8ad9d2007-11-26 20:10:50 +08001921 sk_wake_async(other, SOCK_WAKE_WAITD, POLL_IN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001922 read_unlock(&other->sk_callback_lock);
1923 }
1924 if (other)
1925 sock_put(other);
1926 }
1927 return 0;
1928}
1929
1930static int unix_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1931{
1932 struct sock *sk = sock->sk;
Jianjun Konge27dfce2008-11-01 21:38:31 -07001933 long amount = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001934 int err;
1935
Eric Dumazet6eba6a32008-11-16 22:58:44 -08001936 switch (cmd) {
1937 case SIOCOUTQ:
1938 amount = atomic_read(&sk->sk_wmem_alloc);
1939 err = put_user(amount, (int __user *)arg);
1940 break;
1941 case SIOCINQ:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001942 {
1943 struct sk_buff *skb;
1944
1945 if (sk->sk_state == TCP_LISTEN) {
1946 err = -EINVAL;
1947 break;
1948 }
1949
1950 spin_lock(&sk->sk_receive_queue.lock);
1951 if (sk->sk_type == SOCK_STREAM ||
1952 sk->sk_type == SOCK_SEQPACKET) {
1953 skb_queue_walk(&sk->sk_receive_queue, skb)
1954 amount += skb->len;
1955 } else {
1956 skb = skb_peek(&sk->sk_receive_queue);
1957 if (skb)
Jianjun Konge27dfce2008-11-01 21:38:31 -07001958 amount = skb->len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001959 }
1960 spin_unlock(&sk->sk_receive_queue.lock);
1961 err = put_user(amount, (int __user *)arg);
1962 break;
1963 }
1964
Eric Dumazet6eba6a32008-11-16 22:58:44 -08001965 default:
1966 err = -ENOIOCTLCMD;
1967 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001968 }
1969 return err;
1970}
1971
Eric Dumazet6eba6a32008-11-16 22:58:44 -08001972static unsigned int unix_poll(struct file *file, struct socket *sock, poll_table *wait)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001973{
1974 struct sock *sk = sock->sk;
1975 unsigned int mask;
1976
1977 poll_wait(file, sk->sk_sleep, wait);
1978 mask = 0;
1979
1980 /* exceptional events? */
1981 if (sk->sk_err)
1982 mask |= POLLERR;
1983 if (sk->sk_shutdown == SHUTDOWN_MASK)
1984 mask |= POLLHUP;
Davide Libenzif348d702006-03-25 03:07:39 -08001985 if (sk->sk_shutdown & RCV_SHUTDOWN)
1986 mask |= POLLRDHUP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001987
1988 /* readable? */
1989 if (!skb_queue_empty(&sk->sk_receive_queue) ||
1990 (sk->sk_shutdown & RCV_SHUTDOWN))
1991 mask |= POLLIN | POLLRDNORM;
1992
1993 /* Connection-based need to check for termination and startup */
Eric Dumazet6eba6a32008-11-16 22:58:44 -08001994 if ((sk->sk_type == SOCK_STREAM || sk->sk_type == SOCK_SEQPACKET) &&
1995 sk->sk_state == TCP_CLOSE)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001996 mask |= POLLHUP;
1997
1998 /*
1999 * we set writable also when the other side has shut down the
2000 * connection. This prevents stuck sockets.
2001 */
2002 if (unix_writable(sk))
2003 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
2004
2005 return mask;
2006}
2007
Rainer Weikusatec0d2152008-06-27 19:34:18 -07002008static unsigned int unix_dgram_poll(struct file *file, struct socket *sock,
2009 poll_table *wait)
Rainer Weikusat3c734192008-06-17 22:28:05 -07002010{
Rainer Weikusatec0d2152008-06-27 19:34:18 -07002011 struct sock *sk = sock->sk, *other;
2012 unsigned int mask, writable;
Rainer Weikusat3c734192008-06-17 22:28:05 -07002013
2014 poll_wait(file, sk->sk_sleep, wait);
Rainer Weikusat3c734192008-06-17 22:28:05 -07002015 mask = 0;
2016
2017 /* exceptional events? */
2018 if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
2019 mask |= POLLERR;
2020 if (sk->sk_shutdown & RCV_SHUTDOWN)
2021 mask |= POLLRDHUP;
2022 if (sk->sk_shutdown == SHUTDOWN_MASK)
2023 mask |= POLLHUP;
2024
2025 /* readable? */
2026 if (!skb_queue_empty(&sk->sk_receive_queue) ||
2027 (sk->sk_shutdown & RCV_SHUTDOWN))
2028 mask |= POLLIN | POLLRDNORM;
2029
2030 /* Connection-based need to check for termination and startup */
2031 if (sk->sk_type == SOCK_SEQPACKET) {
2032 if (sk->sk_state == TCP_CLOSE)
2033 mask |= POLLHUP;
2034 /* connection hasn't started yet? */
2035 if (sk->sk_state == TCP_SYN_SENT)
2036 return mask;
2037 }
2038
2039 /* writable? */
Rainer Weikusatec0d2152008-06-27 19:34:18 -07002040 writable = unix_writable(sk);
2041 if (writable) {
2042 other = unix_peer_get(sk);
2043 if (other) {
2044 if (unix_peer(other) != sk) {
2045 poll_wait(file, &unix_sk(other)->peer_wait,
2046 wait);
2047 if (unix_recvq_full(other))
2048 writable = 0;
2049 }
2050
2051 sock_put(other);
2052 }
2053 }
2054
2055 if (writable)
Rainer Weikusat3c734192008-06-17 22:28:05 -07002056 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
2057 else
2058 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
2059
Rainer Weikusat3c734192008-06-17 22:28:05 -07002060 return mask;
2061}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002062
2063#ifdef CONFIG_PROC_FS
Pavel Emelyanova53eb3f2007-11-23 20:30:01 +08002064static struct sock *first_unix_socket(int *i)
2065{
2066 for (*i = 0; *i <= UNIX_HASH_SIZE; (*i)++) {
2067 if (!hlist_empty(&unix_socket_table[*i]))
2068 return __sk_head(&unix_socket_table[*i]);
2069 }
2070 return NULL;
2071}
2072
2073static struct sock *next_unix_socket(int *i, struct sock *s)
2074{
2075 struct sock *next = sk_next(s);
2076 /* More in this chain? */
2077 if (next)
2078 return next;
2079 /* Look for next non-empty chain. */
2080 for ((*i)++; *i <= UNIX_HASH_SIZE; (*i)++) {
2081 if (!hlist_empty(&unix_socket_table[*i]))
2082 return __sk_head(&unix_socket_table[*i]);
2083 }
2084 return NULL;
2085}
2086
Denis V. Lunev097e66c2007-11-19 22:29:30 -08002087struct unix_iter_state {
Denis V. Luneve372c412007-11-19 22:31:54 -08002088 struct seq_net_private p;
Denis V. Lunev097e66c2007-11-19 22:29:30 -08002089 int i;
2090};
Jianjun Konge27dfce2008-11-01 21:38:31 -07002091
YOSHIFUJI Hideaki12188542008-03-26 02:36:06 +09002092static struct sock *unix_seq_idx(struct seq_file *seq, loff_t pos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002093{
YOSHIFUJI Hideaki12188542008-03-26 02:36:06 +09002094 struct unix_iter_state *iter = seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002095 loff_t off = 0;
2096 struct sock *s;
2097
Denis V. Lunev097e66c2007-11-19 22:29:30 -08002098 for (s = first_unix_socket(&iter->i); s; s = next_unix_socket(&iter->i, s)) {
YOSHIFUJI Hideaki12188542008-03-26 02:36:06 +09002099 if (sock_net(s) != seq_file_net(seq))
Denis V. Lunev097e66c2007-11-19 22:29:30 -08002100 continue;
YOSHIFUJI Hideakiac7bfa62007-02-09 23:25:23 +09002101 if (off == pos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002102 return s;
2103 ++off;
2104 }
2105 return NULL;
2106}
2107
Linus Torvalds1da177e2005-04-16 15:20:36 -07002108static void *unix_seq_start(struct seq_file *seq, loff_t *pos)
Eric Dumazet9a429c42008-01-01 21:58:02 -08002109 __acquires(unix_table_lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002110{
David S. Millerfbe9cc42005-12-13 23:26:29 -08002111 spin_lock(&unix_table_lock);
Joe Perchesb9f31242008-04-12 19:04:38 -07002112 return *pos ? unix_seq_idx(seq, *pos - 1) : SEQ_START_TOKEN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002113}
2114
2115static void *unix_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2116{
Denis V. Lunev097e66c2007-11-19 22:29:30 -08002117 struct unix_iter_state *iter = seq->private;
2118 struct sock *sk = v;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002119 ++*pos;
2120
Joe Perchesb9f31242008-04-12 19:04:38 -07002121 if (v == SEQ_START_TOKEN)
Denis V. Lunev097e66c2007-11-19 22:29:30 -08002122 sk = first_unix_socket(&iter->i);
2123 else
2124 sk = next_unix_socket(&iter->i, sk);
YOSHIFUJI Hideaki12188542008-03-26 02:36:06 +09002125 while (sk && (sock_net(sk) != seq_file_net(seq)))
Denis V. Lunev097e66c2007-11-19 22:29:30 -08002126 sk = next_unix_socket(&iter->i, sk);
2127 return sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002128}
2129
2130static void unix_seq_stop(struct seq_file *seq, void *v)
Eric Dumazet9a429c42008-01-01 21:58:02 -08002131 __releases(unix_table_lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002132{
David S. Millerfbe9cc42005-12-13 23:26:29 -08002133 spin_unlock(&unix_table_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002134}
2135
2136static int unix_seq_show(struct seq_file *seq, void *v)
2137{
YOSHIFUJI Hideakiac7bfa62007-02-09 23:25:23 +09002138
Joe Perchesb9f31242008-04-12 19:04:38 -07002139 if (v == SEQ_START_TOKEN)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002140 seq_puts(seq, "Num RefCount Protocol Flags Type St "
2141 "Inode Path\n");
2142 else {
2143 struct sock *s = v;
2144 struct unix_sock *u = unix_sk(s);
David S. Miller1c92b4e2007-05-31 13:24:26 -07002145 unix_state_lock(s);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002146
2147 seq_printf(seq, "%p: %08X %08X %08X %04X %02X %5lu",
2148 s,
2149 atomic_read(&s->sk_refcnt),
2150 0,
2151 s->sk_state == TCP_LISTEN ? __SO_ACCEPTCON : 0,
2152 s->sk_type,
2153 s->sk_socket ?
2154 (s->sk_state == TCP_ESTABLISHED ? SS_CONNECTED : SS_UNCONNECTED) :
2155 (s->sk_state == TCP_ESTABLISHED ? SS_CONNECTING : SS_DISCONNECTING),
2156 sock_i_ino(s));
2157
2158 if (u->addr) {
2159 int i, len;
2160 seq_putc(seq, ' ');
2161
2162 i = 0;
2163 len = u->addr->len - sizeof(short);
2164 if (!UNIX_ABSTRACT(s))
2165 len--;
2166 else {
2167 seq_putc(seq, '@');
2168 i++;
2169 }
2170 for ( ; i < len; i++)
2171 seq_putc(seq, u->addr->name->sun_path[i]);
2172 }
David S. Miller1c92b4e2007-05-31 13:24:26 -07002173 unix_state_unlock(s);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002174 seq_putc(seq, '\n');
2175 }
2176
2177 return 0;
2178}
2179
Philippe De Muyter56b3d972007-07-10 23:07:31 -07002180static const struct seq_operations unix_seq_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002181 .start = unix_seq_start,
2182 .next = unix_seq_next,
2183 .stop = unix_seq_stop,
2184 .show = unix_seq_show,
2185};
2186
Linus Torvalds1da177e2005-04-16 15:20:36 -07002187static int unix_seq_open(struct inode *inode, struct file *file)
2188{
Denis V. Luneve372c412007-11-19 22:31:54 -08002189 return seq_open_net(inode, file, &unix_seq_ops,
2190 sizeof(struct unix_iter_state));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002191}
2192
Arjan van de Venda7071d2007-02-12 00:55:36 -08002193static const struct file_operations unix_seq_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002194 .owner = THIS_MODULE,
2195 .open = unix_seq_open,
2196 .read = seq_read,
2197 .llseek = seq_lseek,
Denis V. Luneve372c412007-11-19 22:31:54 -08002198 .release = seq_release_net,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002199};
2200
2201#endif
2202
2203static struct net_proto_family unix_family_ops = {
2204 .family = PF_UNIX,
2205 .create = unix_create,
2206 .owner = THIS_MODULE,
2207};
2208
Denis V. Lunev097e66c2007-11-19 22:29:30 -08002209
2210static int unix_net_init(struct net *net)
2211{
2212 int error = -ENOMEM;
2213
Denis V. Luneva0a53c82007-12-11 04:19:17 -08002214 net->unx.sysctl_max_dgram_qlen = 10;
Pavel Emelyanov1597fbc2007-12-01 23:51:01 +11002215 if (unix_sysctl_register(net))
2216 goto out;
Pavel Emelyanovd392e492007-12-01 23:44:15 +11002217
Denis V. Lunev097e66c2007-11-19 22:29:30 -08002218#ifdef CONFIG_PROC_FS
Pavel Emelyanov1597fbc2007-12-01 23:51:01 +11002219 if (!proc_net_fops_create(net, "unix", 0, &unix_seq_fops)) {
2220 unix_sysctl_unregister(net);
Denis V. Lunev097e66c2007-11-19 22:29:30 -08002221 goto out;
Pavel Emelyanov1597fbc2007-12-01 23:51:01 +11002222 }
Denis V. Lunev097e66c2007-11-19 22:29:30 -08002223#endif
2224 error = 0;
2225out:
Jianjun Kong48dcc33e2008-11-01 21:37:27 -07002226 return error;
Denis V. Lunev097e66c2007-11-19 22:29:30 -08002227}
2228
2229static void unix_net_exit(struct net *net)
2230{
Pavel Emelyanov1597fbc2007-12-01 23:51:01 +11002231 unix_sysctl_unregister(net);
Denis V. Lunev097e66c2007-11-19 22:29:30 -08002232 proc_net_remove(net, "unix");
2233}
2234
2235static struct pernet_operations unix_net_ops = {
2236 .init = unix_net_init,
2237 .exit = unix_net_exit,
2238};
2239
Linus Torvalds1da177e2005-04-16 15:20:36 -07002240static int __init af_unix_init(void)
2241{
2242 int rc = -1;
2243 struct sk_buff *dummy_skb;
2244
YOSHIFUJI Hideakief047f52006-09-01 00:29:06 -07002245 BUILD_BUG_ON(sizeof(struct unix_skb_parms) > sizeof(dummy_skb->cb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002246
2247 rc = proto_register(&unix_proto, 1);
YOSHIFUJI Hideakiac7bfa62007-02-09 23:25:23 +09002248 if (rc != 0) {
2249 printk(KERN_CRIT "%s: Cannot create unix_sock SLAB cache!\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -08002250 __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002251 goto out;
2252 }
2253
2254 sock_register(&unix_family_ops);
Denis V. Lunev097e66c2007-11-19 22:29:30 -08002255 register_pernet_subsys(&unix_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002256out:
2257 return rc;
2258}
2259
2260static void __exit af_unix_exit(void)
2261{
2262 sock_unregister(PF_UNIX);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002263 proto_unregister(&unix_proto);
Denis V. Lunev097e66c2007-11-19 22:29:30 -08002264 unregister_pernet_subsys(&unix_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002265}
2266
David Woodhouse3d366962008-04-24 00:59:25 -07002267/* Earlier than device_initcall() so that other drivers invoking
2268 request_module() don't end up in a loop when modprobe tries
2269 to use a UNIX socket. But later than subsys_initcall() because
2270 we depend on stuff initialised there */
2271fs_initcall(af_unix_init);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002272module_exit(af_unix_exit);
2273
2274MODULE_LICENSE("GPL");
2275MODULE_ALIAS_NETPROTO(PF_UNIX);