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