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