?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[NETFILTER]: ipt_TCPMSS: reformat
[hh.org.git] / net / unix / af_unix.c
blobb43a27828df5d4486d2f397baac2792eb23d4215
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/smp_lock.h>
115 #include <linux/rtnetlink.h>
116 #include <linux/mount.h>
117 #include <net/checksum.h>
118 #include <linux/security.h>
119
120 int sysctl_unix_max_dgram_qlen __read_mostly = 10;
121
122 struct hlist_head unix_socket_table[UNIX_HASH_SIZE + 1];
123 DEFINE_SPINLOCK(unix_table_lock);
124 static atomic_t unix_nr_socks = ATOMIC_INIT(0);
125
126 #define unix_sockets_unbound (&unix_socket_table[UNIX_HASH_SIZE])
127
128 #define UNIX_ABSTRACT(sk) (unix_sk(sk)->addr->hash != UNIX_HASH_SIZE)
129
130 #ifdef CONFIG_SECURITY_NETWORK
131 static void unix_get_secdata(struct scm_cookie *scm, struct sk_buff *skb)
132 {
133 memcpy(UNIXSID(skb), &scm->secid, sizeof(u32));
134 }
135
136 static inline void unix_set_secdata(struct scm_cookie *scm, struct sk_buff *skb)
137 {
138 scm->secid = *UNIXSID(skb);
139 }
140 #else
141 static inline void unix_get_secdata(struct scm_cookie *scm, struct sk_buff *skb)
142 { }
143
144 static inline void unix_set_secdata(struct scm_cookie *scm, struct sk_buff *skb)
145 { }
146 #endif /* CONFIG_SECURITY_NETWORK */
147
148 /*
149 * SMP locking strategy:
150 * hash table is protected with spinlock unix_table_lock
151 * each socket state is protected by separate rwlock.
152 */
153
154 static inline unsigned unix_hash_fold(unsigned hash)
155 {
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_rlock(s);
178 peer = unix_peer(s);
179 if (peer)
180 sock_hold(peer);
181 unix_state_runlock(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_wlock(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_wunlock(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_wlock(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_wunlock(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_wlock(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_wunlock(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, sock ? 0 : -1);
596 mutex_init(&u->readlock); /* single task reading lock */
597 init_waitqueue_head(&u->peer_wait);
598 unix_insert_socket(unix_sockets_unbound, sk);
599 out:
600 return sk;
601 }
602
603 static int unix_create(struct socket *sock, int protocol)
604 {
605 if (protocol && protocol != PF_UNIX)
606 return -EPROTONOSUPPORT;
607
608 sock->state = SS_UNCONNECTED;
609
610 switch (sock->type) {
611 case SOCK_STREAM:
612 sock->ops = &unix_stream_ops;
613 break;
614 /*
615 * Believe it or not BSD has AF_UNIX, SOCK_RAW though
616 * nothing uses it.
617 */
618 case SOCK_RAW:
619 sock->type=SOCK_DGRAM;
620 case SOCK_DGRAM:
621 sock->ops = &unix_dgram_ops;
622 break;
623 case SOCK_SEQPACKET:
624 sock->ops = &unix_seqpacket_ops;
625 break;
626 default:
627 return -ESOCKTNOSUPPORT;
628 }
629
630 return unix_create1(sock) ? 0 : -ENOMEM;
631 }
632
633 static int unix_release(struct socket *sock)
634 {
635 struct sock *sk = sock->sk;
636
637 if (!sk)
638 return 0;
639
640 sock->sk = NULL;
641
642 return unix_release_sock (sk, 0);
643 }
644
645 static int unix_autobind(struct socket *sock)
646 {
647 struct sock *sk = sock->sk;
648 struct unix_sock *u = unix_sk(sk);
649 static u32 ordernum = 1;
650 struct unix_address * addr;
651 int err;
652
653 mutex_lock(&u->readlock);
654
655 err = 0;
656 if (u->addr)
657 goto out;
658
659 err = -ENOMEM;
660 addr = kzalloc(sizeof(*addr) + sizeof(short) + 16, GFP_KERNEL);
661 if (!addr)
662 goto out;
663
664 addr->name->sun_family = AF_UNIX;
665 atomic_set(&addr->refcnt, 1);
666
667 retry:
668 addr->len = sprintf(addr->name->sun_path+1, "%05x", ordernum) + 1 + sizeof(short);
669 addr->hash = unix_hash_fold(csum_partial((void*)addr->name, addr->len, 0));
670
671 spin_lock(&unix_table_lock);
672 ordernum = (ordernum+1)&0xFFFFF;
673
674 if (__unix_find_socket_byname(addr->name, addr->len, sock->type,
675 addr->hash)) {
676 spin_unlock(&unix_table_lock);
677 /* Sanity yield. It is unusual case, but yet... */
678 if (!(ordernum&0xFF))
679 yield();
680 goto retry;
681 }
682 addr->hash ^= sk->sk_type;
683
684 __unix_remove_socket(sk);
685 u->addr = addr;
686 __unix_insert_socket(&unix_socket_table[addr->hash], sk);
687 spin_unlock(&unix_table_lock);
688 err = 0;
689
690 out: mutex_unlock(&u->readlock);
691 return err;
692 }
693
694 static struct sock *unix_find_other(struct sockaddr_un *sunname, int len,
695 int type, unsigned hash, int *error)
696 {
697 struct sock *u;
698 struct nameidata nd;
699 int err = 0;
700
701 if (sunname->sun_path[0]) {
702 err = path_lookup(sunname->sun_path, LOOKUP_FOLLOW, &nd);
703 if (err)
704 goto fail;
705 err = vfs_permission(&nd, MAY_WRITE);
706 if (err)
707 goto put_fail;
708
709 err = -ECONNREFUSED;
710 if (!S_ISSOCK(nd.dentry->d_inode->i_mode))
711 goto put_fail;
712 u=unix_find_socket_byinode(nd.dentry->d_inode);
713 if (!u)
714 goto put_fail;
715
716 if (u->sk_type == type)
717 touch_atime(nd.mnt, nd.dentry);
718
719 path_release(&nd);
720
721 err=-EPROTOTYPE;
722 if (u->sk_type != type) {
723 sock_put(u);
724 goto fail;
725 }
726 } else {
727 err = -ECONNREFUSED;
728 u=unix_find_socket_byname(sunname, len, type, hash);
729 if (u) {
730 struct dentry *dentry;
731 dentry = unix_sk(u)->dentry;
732 if (dentry)
733 touch_atime(unix_sk(u)->mnt, dentry);
734 } else
735 goto fail;
736 }
737 return u;
738
739 put_fail:
740 path_release(&nd);
741 fail:
742 *error=err;
743 return NULL;
744 }
745
746
747 static int unix_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
748 {
749 struct sock *sk = sock->sk;
750 struct unix_sock *u = unix_sk(sk);
751 struct sockaddr_un *sunaddr=(struct sockaddr_un *)uaddr;
752 struct dentry * dentry = NULL;
753 struct nameidata nd;
754 int err;
755 unsigned hash;
756 struct unix_address *addr;
757 struct hlist_head *list;
758
759 err = -EINVAL;
760 if (sunaddr->sun_family != AF_UNIX)
761 goto out;
762
763 if (addr_len==sizeof(short)) {
764 err = unix_autobind(sock);
765 goto out;
766 }
767
768 err = unix_mkname(sunaddr, addr_len, &hash);
769 if (err < 0)
770 goto out;
771 addr_len = err;
772
773 mutex_lock(&u->readlock);
774
775 err = -EINVAL;
776 if (u->addr)
777 goto out_up;
778
779 err = -ENOMEM;
780 addr = kmalloc(sizeof(*addr)+addr_len, GFP_KERNEL);
781 if (!addr)
782 goto out_up;
783
784 memcpy(addr->name, sunaddr, addr_len);
785 addr->len = addr_len;
786 addr->hash = hash ^ sk->sk_type;
787 atomic_set(&addr->refcnt, 1);
788
789 if (sunaddr->sun_path[0]) {
790 unsigned int mode;
791 err = 0;
792 /*
793 * Get the parent directory, calculate the hash for last
794 * component.
795 */
796 err = path_lookup(sunaddr->sun_path, LOOKUP_PARENT, &nd);
797 if (err)
798 goto out_mknod_parent;
799
800 dentry = lookup_create(&nd, 0);
801 err = PTR_ERR(dentry);
802 if (IS_ERR(dentry))
803 goto out_mknod_unlock;
804
805 /*
806 * All right, let's create it.
807 */
808 mode = S_IFSOCK |
809 (SOCK_INODE(sock)->i_mode & ~current->fs->umask);
810 err = vfs_mknod(nd.dentry->d_inode, dentry, mode, 0);
811 if (err)
812 goto out_mknod_dput;
813 mutex_unlock(&nd.dentry->d_inode->i_mutex);
814 dput(nd.dentry);
815 nd.dentry = dentry;
816
817 addr->hash = UNIX_HASH_SIZE;
818 }
819
820 spin_lock(&unix_table_lock);
821
822 if (!sunaddr->sun_path[0]) {
823 err = -EADDRINUSE;
824 if (__unix_find_socket_byname(sunaddr, addr_len,
825 sk->sk_type, hash)) {
826 unix_release_addr(addr);
827 goto out_unlock;
828 }
829
830 list = &unix_socket_table[addr->hash];
831 } else {
832 list = &unix_socket_table[dentry->d_inode->i_ino & (UNIX_HASH_SIZE-1)];
833 u->dentry = nd.dentry;
834 u->mnt = nd.mnt;
835 }
836
837 err = 0;
838 __unix_remove_socket(sk);
839 u->addr = addr;
840 __unix_insert_socket(list, sk);
841
842 out_unlock:
843 spin_unlock(&unix_table_lock);
844 out_up:
845 mutex_unlock(&u->readlock);
846 out:
847 return err;
848
849 out_mknod_dput:
850 dput(dentry);
851 out_mknod_unlock:
852 mutex_unlock(&nd.dentry->d_inode->i_mutex);
853 path_release(&nd);
854 out_mknod_parent:
855 if (err==-EEXIST)
856 err=-EADDRINUSE;
857 unix_release_addr(addr);
858 goto out_up;
859 }
860
861 static int unix_dgram_connect(struct socket *sock, struct sockaddr *addr,
862 int alen, int flags)
863 {
864 struct sock *sk = sock->sk;
865 struct sockaddr_un *sunaddr=(struct sockaddr_un*)addr;
866 struct sock *other;
867 unsigned hash;
868 int err;
869
870 if (addr->sa_family != AF_UNSPEC) {
871 err = unix_mkname(sunaddr, alen, &hash);
872 if (err < 0)
873 goto out;
874 alen = err;
875
876 if (test_bit(SOCK_PASSCRED, &sock->flags) &&
877 !unix_sk(sk)->addr && (err = unix_autobind(sock)) != 0)
878 goto out;
879
880 other=unix_find_other(sunaddr, alen, sock->type, hash, &err);
881 if (!other)
882 goto out;
883
884 unix_state_wlock(sk);
885
886 err = -EPERM;
887 if (!unix_may_send(sk, other))
888 goto out_unlock;
889
890 err = security_unix_may_send(sk->sk_socket, other->sk_socket);
891 if (err)
892 goto out_unlock;
893
894 } else {
895 /*
896 * 1003.1g breaking connected state with AF_UNSPEC
897 */
898 other = NULL;
899 unix_state_wlock(sk);
900 }
901
902 /*
903 * If it was connected, reconnect.
904 */
905 if (unix_peer(sk)) {
906 struct sock *old_peer = unix_peer(sk);
907 unix_peer(sk)=other;
908 unix_state_wunlock(sk);
909
910 if (other != old_peer)
911 unix_dgram_disconnected(sk, old_peer);
912 sock_put(old_peer);
913 } else {
914 unix_peer(sk)=other;
915 unix_state_wunlock(sk);
916 }
917 return 0;
918
919 out_unlock:
920 unix_state_wunlock(sk);
921 sock_put(other);
922 out:
923 return err;
924 }
925
926 static long unix_wait_for_peer(struct sock *other, long timeo)
927 {
928 struct unix_sock *u = unix_sk(other);
929 int sched;
930 DEFINE_WAIT(wait);
931
932 prepare_to_wait_exclusive(&u->peer_wait, &wait, TASK_INTERRUPTIBLE);
933
934 sched = !sock_flag(other, SOCK_DEAD) &&
935 !(other->sk_shutdown & RCV_SHUTDOWN) &&
936 (skb_queue_len(&other->sk_receive_queue) >
937 other->sk_max_ack_backlog);
938
939 unix_state_runlock(other);
940
941 if (sched)
942 timeo = schedule_timeout(timeo);
943
944 finish_wait(&u->peer_wait, &wait);
945 return timeo;
946 }
947
948 static int unix_stream_connect(struct socket *sock, struct sockaddr *uaddr,
949 int addr_len, int flags)
950 {
951 struct sockaddr_un *sunaddr=(struct sockaddr_un *)uaddr;
952 struct sock *sk = sock->sk;
953 struct unix_sock *u = unix_sk(sk), *newu, *otheru;
954 struct sock *newsk = NULL;
955 struct sock *other = NULL;
956 struct sk_buff *skb = NULL;
957 unsigned hash;
958 int st;
959 int err;
960 long timeo;
961
962 err = unix_mkname(sunaddr, addr_len, &hash);
963 if (err < 0)
964 goto out;
965 addr_len = err;
966
967 if (test_bit(SOCK_PASSCRED, &sock->flags)
968 && !u->addr && (err = unix_autobind(sock)) != 0)
969 goto out;
970
971 timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
972
973 /* First of all allocate resources.
974 If we will make it after state is locked,
975 we will have to recheck all again in any case.
976 */
977
978 err = -ENOMEM;
979
980 /* create new sock for complete connection */
981 newsk = unix_create1(NULL);
982 if (newsk == NULL)
983 goto out;
984
985 /* Allocate skb for sending to listening sock */
986 skb = sock_wmalloc(newsk, 1, 0, GFP_KERNEL);
987 if (skb == NULL)
988 goto out;
989
990 restart:
991 /* Find listening sock. */
992 other = unix_find_other(sunaddr, addr_len, sk->sk_type, hash, &err);
993 if (!other)
994 goto out;
995
996 /* Latch state of peer */
997 unix_state_rlock(other);
998
999 /* Apparently VFS overslept socket death. Retry. */
1000 if (sock_flag(other, SOCK_DEAD)) {
1001 unix_state_runlock(other);
1002 sock_put(other);
1003 goto restart;
1004 }
1005
1006 err = -ECONNREFUSED;
1007 if (other->sk_state != TCP_LISTEN)
1008 goto out_unlock;
1009
1010 if (skb_queue_len(&other->sk_receive_queue) >
1011 other->sk_max_ack_backlog) {
1012 err = -EAGAIN;
1013 if (!timeo)
1014 goto out_unlock;
1015
1016 timeo = unix_wait_for_peer(other, timeo);
1017
1018 err = sock_intr_errno(timeo);
1019 if (signal_pending(current))
1020 goto out;
1021 sock_put(other);
1022 goto restart;
1023 }
1024
1025 /* Latch our state.
1026
1027 It is tricky place. We need to grab write lock and cannot
1028 drop lock on peer. It is dangerous because deadlock is
1029 possible. Connect to self case and simultaneous
1030 attempt to connect are eliminated by checking socket
1031 state. other is TCP_LISTEN, if sk is TCP_LISTEN we
1032 check this before attempt to grab lock.
1033
1034 Well, and we have to recheck the state after socket locked.
1035 */
1036 st = sk->sk_state;
1037
1038 switch (st) {
1039 case TCP_CLOSE:
1040 /* This is ok... continue with connect */
1041 break;
1042 case TCP_ESTABLISHED:
1043 /* Socket is already connected */
1044 err = -EISCONN;
1045 goto out_unlock;
1046 default:
1047 err = -EINVAL;
1048 goto out_unlock;
1049 }
1050
1051 unix_state_wlock_nested(sk);
1052
1053 if (sk->sk_state != st) {
1054 unix_state_wunlock(sk);
1055 unix_state_runlock(other);
1056 sock_put(other);
1057 goto restart;
1058 }
1059
1060 err = security_unix_stream_connect(sock, other->sk_socket, newsk);
1061 if (err) {
1062 unix_state_wunlock(sk);
1063 goto out_unlock;
1064 }
1065
1066 /* The way is open! Fastly set all the necessary fields... */
1067
1068 sock_hold(sk);
1069 unix_peer(newsk) = sk;
1070 newsk->sk_state = TCP_ESTABLISHED;
1071 newsk->sk_type = sk->sk_type;
1072 newsk->sk_peercred.pid = current->tgid;
1073 newsk->sk_peercred.uid = current->euid;
1074 newsk->sk_peercred.gid = current->egid;
1075 newu = unix_sk(newsk);
1076 newsk->sk_sleep = &newu->peer_wait;
1077 otheru = unix_sk(other);
1078
1079 /* copy address information from listening to new sock*/
1080 if (otheru->addr) {
1081 atomic_inc(&otheru->addr->refcnt);
1082 newu->addr = otheru->addr;
1083 }
1084 if (otheru->dentry) {
1085 newu->dentry = dget(otheru->dentry);
1086 newu->mnt = mntget(otheru->mnt);
1087 }
1088
1089 /* Set credentials */
1090 sk->sk_peercred = other->sk_peercred;
1091
1092 sock->state = SS_CONNECTED;
1093 sk->sk_state = TCP_ESTABLISHED;
1094 sock_hold(newsk);
1095
1096 smp_mb__after_atomic_inc(); /* sock_hold() does an atomic_inc() */
1097 unix_peer(sk) = newsk;
1098
1099 unix_state_wunlock(sk);
1100
1101 /* take ten and and send info to listening sock */
1102 spin_lock(&other->sk_receive_queue.lock);
1103 __skb_queue_tail(&other->sk_receive_queue, skb);
1104 /* Undo artificially decreased inflight after embrion
1105 * is installed to listening socket. */
1106 atomic_inc(&newu->inflight);
1107 spin_unlock(&other->sk_receive_queue.lock);
1108 unix_state_runlock(other);
1109 other->sk_data_ready(other, 0);
1110 sock_put(other);
1111 return 0;
1112
1113 out_unlock:
1114 if (other)
1115 unix_state_runlock(other);
1116
1117 out:
1118 if (skb)
1119 kfree_skb(skb);
1120 if (newsk)
1121 unix_release_sock(newsk, 0);
1122 if (other)
1123 sock_put(other);
1124 return err;
1125 }
1126
1127 static int unix_socketpair(struct socket *socka, struct socket *sockb)
1128 {
1129 struct sock *ska=socka->sk, *skb = sockb->sk;
1130
1131 /* Join our sockets back to back */
1132 sock_hold(ska);
1133 sock_hold(skb);
1134 unix_peer(ska)=skb;
1135 unix_peer(skb)=ska;
1136 ska->sk_peercred.pid = skb->sk_peercred.pid = current->tgid;
1137 ska->sk_peercred.uid = skb->sk_peercred.uid = current->euid;
1138 ska->sk_peercred.gid = skb->sk_peercred.gid = current->egid;
1139
1140 if (ska->sk_type != SOCK_DGRAM) {
1141 ska->sk_state = TCP_ESTABLISHED;
1142 skb->sk_state = TCP_ESTABLISHED;
1143 socka->state = SS_CONNECTED;
1144 sockb->state = SS_CONNECTED;
1145 }
1146 return 0;
1147 }
1148
1149 static int unix_accept(struct socket *sock, struct socket *newsock, int flags)
1150 {
1151 struct sock *sk = sock->sk;
1152 struct sock *tsk;
1153 struct sk_buff *skb;
1154 int err;
1155
1156 err = -EOPNOTSUPP;
1157 if (sock->type!=SOCK_STREAM && sock->type!=SOCK_SEQPACKET)
1158 goto out;
1159
1160 err = -EINVAL;
1161 if (sk->sk_state != TCP_LISTEN)
1162 goto out;
1163
1164 /* If socket state is TCP_LISTEN it cannot change (for now...),
1165 * so that no locks are necessary.
1166 */
1167
1168 skb = skb_recv_datagram(sk, 0, flags&O_NONBLOCK, &err);
1169 if (!skb) {
1170 /* This means receive shutdown. */
1171 if (err == 0)
1172 err = -EINVAL;
1173 goto out;
1174 }
1175
1176 tsk = skb->sk;
1177 skb_free_datagram(sk, skb);
1178 wake_up_interruptible(&unix_sk(sk)->peer_wait);
1179
1180 /* attach accepted sock to socket */
1181 unix_state_wlock(tsk);
1182 newsock->state = SS_CONNECTED;
1183 sock_graft(tsk, newsock);
1184 unix_state_wunlock(tsk);
1185 return 0;
1186
1187 out:
1188 return err;
1189 }
1190
1191
1192 static int unix_getname(struct socket *sock, struct sockaddr *uaddr, int *uaddr_len, int peer)
1193 {
1194 struct sock *sk = sock->sk;
1195 struct unix_sock *u;
1196 struct sockaddr_un *sunaddr=(struct sockaddr_un *)uaddr;
1197 int err = 0;
1198
1199 if (peer) {
1200 sk = unix_peer_get(sk);
1201
1202 err = -ENOTCONN;
1203 if (!sk)
1204 goto out;
1205 err = 0;
1206 } else {
1207 sock_hold(sk);
1208 }
1209
1210 u = unix_sk(sk);
1211 unix_state_rlock(sk);
1212 if (!u->addr) {
1213 sunaddr->sun_family = AF_UNIX;
1214 sunaddr->sun_path[0] = 0;
1215 *uaddr_len = sizeof(short);
1216 } else {
1217 struct unix_address *addr = u->addr;
1218
1219 *uaddr_len = addr->len;
1220 memcpy(sunaddr, addr->name, *uaddr_len);
1221 }
1222 unix_state_runlock(sk);
1223 sock_put(sk);
1224 out:
1225 return err;
1226 }
1227
1228 static void unix_detach_fds(struct scm_cookie *scm, struct sk_buff *skb)
1229 {
1230 int i;
1231
1232 scm->fp = UNIXCB(skb).fp;
1233 skb->destructor = sock_wfree;
1234 UNIXCB(skb).fp = NULL;
1235
1236 for (i=scm->fp->count-1; i>=0; i--)
1237 unix_notinflight(scm->fp->fp[i]);
1238 }
1239
1240 static void unix_destruct_fds(struct sk_buff *skb)
1241 {
1242 struct scm_cookie scm;
1243 memset(&scm, 0, sizeof(scm));
1244 unix_detach_fds(&scm, skb);
1245
1246 /* Alas, it calls VFS */
1247 /* So fscking what? fput() had been SMP-safe since the last Summer */
1248 scm_destroy(&scm);
1249 sock_wfree(skb);
1250 }
1251
1252 static void unix_attach_fds(struct scm_cookie *scm, struct sk_buff *skb)
1253 {
1254 int i;
1255 for (i=scm->fp->count-1; i>=0; i--)
1256 unix_inflight(scm->fp->fp[i]);
1257 UNIXCB(skb).fp = scm->fp;
1258 skb->destructor = unix_destruct_fds;
1259 scm->fp = NULL;
1260 }
1261
1262 /*
1263 * Send AF_UNIX data.
1264 */
1265
1266 static int unix_dgram_sendmsg(struct kiocb *kiocb, struct socket *sock,
1267 struct msghdr *msg, size_t len)
1268 {
1269 struct sock_iocb *siocb = kiocb_to_siocb(kiocb);
1270 struct sock *sk = sock->sk;
1271 struct unix_sock *u = unix_sk(sk);
1272 struct sockaddr_un *sunaddr=msg->msg_name;
1273 struct sock *other = NULL;
1274 int namelen = 0; /* fake GCC */
1275 int err;
1276 unsigned hash;
1277 struct sk_buff *skb;
1278 long timeo;
1279 struct scm_cookie tmp_scm;
1280
1281 if (NULL == siocb->scm)
1282 siocb->scm = &tmp_scm;
1283 err = scm_send(sock, msg, siocb->scm);
1284 if (err < 0)
1285 return err;
1286
1287 err = -EOPNOTSUPP;
1288 if (msg->msg_flags&MSG_OOB)
1289 goto out;
1290
1291 if (msg->msg_namelen) {
1292 err = unix_mkname(sunaddr, msg->msg_namelen, &hash);
1293 if (err < 0)
1294 goto out;
1295 namelen = err;
1296 } else {
1297 sunaddr = NULL;
1298 err = -ENOTCONN;
1299 other = unix_peer_get(sk);
1300 if (!other)
1301 goto out;
1302 }
1303
1304 if (test_bit(SOCK_PASSCRED, &sock->flags)
1305 && !u->addr && (err = unix_autobind(sock)) != 0)
1306 goto out;
1307
1308 err = -EMSGSIZE;
1309 if (len > sk->sk_sndbuf - 32)
1310 goto out;
1311
1312 skb = sock_alloc_send_skb(sk, len, msg->msg_flags&MSG_DONTWAIT, &err);
1313 if (skb==NULL)
1314 goto out;
1315
1316 memcpy(UNIXCREDS(skb), &siocb->scm->creds, sizeof(struct ucred));
1317 if (siocb->scm->fp)
1318 unix_attach_fds(siocb->scm, skb);
1319 unix_get_secdata(siocb->scm, skb);
1320
1321 skb->h.raw = skb->data;
1322 err = memcpy_fromiovec(skb_put(skb,len), msg->msg_iov, len);
1323 if (err)
1324 goto out_free;
1325
1326 timeo = sock_sndtimeo(sk, msg->msg_flags & MSG_DONTWAIT);
1327
1328 restart:
1329 if (!other) {
1330 err = -ECONNRESET;
1331 if (sunaddr == NULL)
1332 goto out_free;
1333
1334 other = unix_find_other(sunaddr, namelen, sk->sk_type,
1335 hash, &err);
1336 if (other==NULL)
1337 goto out_free;
1338 }
1339
1340 unix_state_rlock(other);
1341 err = -EPERM;
1342 if (!unix_may_send(sk, other))
1343 goto out_unlock;
1344
1345 if (sock_flag(other, SOCK_DEAD)) {
1346 /*
1347 * Check with 1003.1g - what should
1348 * datagram error
1349 */
1350 unix_state_runlock(other);
1351 sock_put(other);
1352
1353 err = 0;
1354 unix_state_wlock(sk);
1355 if (unix_peer(sk) == other) {
1356 unix_peer(sk)=NULL;
1357 unix_state_wunlock(sk);
1358
1359 unix_dgram_disconnected(sk, other);
1360 sock_put(other);
1361 err = -ECONNREFUSED;
1362 } else {
1363 unix_state_wunlock(sk);
1364 }
1365
1366 other = NULL;
1367 if (err)
1368 goto out_free;
1369 goto restart;
1370 }
1371
1372 err = -EPIPE;
1373 if (other->sk_shutdown & RCV_SHUTDOWN)
1374 goto out_unlock;
1375
1376 if (sk->sk_type != SOCK_SEQPACKET) {
1377 err = security_unix_may_send(sk->sk_socket, other->sk_socket);
1378 if (err)
1379 goto out_unlock;
1380 }
1381
1382 if (unix_peer(other) != sk &&
1383 (skb_queue_len(&other->sk_receive_queue) >
1384 other->sk_max_ack_backlog)) {
1385 if (!timeo) {
1386 err = -EAGAIN;
1387 goto out_unlock;
1388 }
1389
1390 timeo = unix_wait_for_peer(other, timeo);
1391
1392 err = sock_intr_errno(timeo);
1393 if (signal_pending(current))
1394 goto out_free;
1395
1396 goto restart;
1397 }
1398
1399 skb_queue_tail(&other->sk_receive_queue, skb);
1400 unix_state_runlock(other);
1401 other->sk_data_ready(other, len);
1402 sock_put(other);
1403 scm_destroy(siocb->scm);
1404 return len;
1405
1406 out_unlock:
1407 unix_state_runlock(other);
1408 out_free:
1409 kfree_skb(skb);
1410 out:
1411 if (other)
1412 sock_put(other);
1413 scm_destroy(siocb->scm);
1414 return err;
1415 }
1416
1417
1418 static int unix_stream_sendmsg(struct kiocb *kiocb, struct socket *sock,
1419 struct msghdr *msg, size_t len)
1420 {
1421 struct sock_iocb *siocb = kiocb_to_siocb(kiocb);
1422 struct sock *sk = sock->sk;
1423 struct sock *other = NULL;
1424 struct sockaddr_un *sunaddr=msg->msg_name;
1425 int err,size;
1426 struct sk_buff *skb;
1427 int sent=0;
1428 struct scm_cookie tmp_scm;
1429
1430 if (NULL == siocb->scm)
1431 siocb->scm = &tmp_scm;
1432 err = scm_send(sock, msg, siocb->scm);
1433 if (err < 0)
1434 return err;
1435
1436 err = -EOPNOTSUPP;
1437 if (msg->msg_flags&MSG_OOB)
1438 goto out_err;
1439
1440 if (msg->msg_namelen) {
1441 err = sk->sk_state == TCP_ESTABLISHED ? -EISCONN : -EOPNOTSUPP;
1442 goto out_err;
1443 } else {
1444 sunaddr = NULL;
1445 err = -ENOTCONN;
1446 other = unix_peer(sk);
1447 if (!other)
1448 goto out_err;
1449 }
1450
1451 if (sk->sk_shutdown & SEND_SHUTDOWN)
1452 goto pipe_err;
1453
1454 while(sent < len)
1455 {
1456 /*
1457 * Optimisation for the fact that under 0.01% of X
1458 * messages typically need breaking up.
1459 */
1460
1461 size = len-sent;
1462
1463 /* Keep two messages in the pipe so it schedules better */
1464 if (size > ((sk->sk_sndbuf >> 1) - 64))
1465 size = (sk->sk_sndbuf >> 1) - 64;
1466
1467 if (size > SKB_MAX_ALLOC)
1468 size = SKB_MAX_ALLOC;
1469
1470 /*
1471 * Grab a buffer
1472 */
1473
1474 skb=sock_alloc_send_skb(sk,size,msg->msg_flags&MSG_DONTWAIT, &err);
1475
1476 if (skb==NULL)
1477 goto out_err;
1478
1479 /*
1480 * If you pass two values to the sock_alloc_send_skb
1481 * it tries to grab the large buffer with GFP_NOFS
1482 * (which can fail easily), and if it fails grab the
1483 * fallback size buffer which is under a page and will
1484 * succeed. [Alan]
1485 */
1486 size = min_t(int, size, skb_tailroom(skb));
1487
1488 memcpy(UNIXCREDS(skb), &siocb->scm->creds, sizeof(struct ucred));
1489 if (siocb->scm->fp)
1490 unix_attach_fds(siocb->scm, skb);
1491
1492 if ((err = memcpy_fromiovec(skb_put(skb,size), msg->msg_iov, size)) != 0) {
1493 kfree_skb(skb);
1494 goto out_err;
1495 }
1496
1497 unix_state_rlock(other);
1498
1499 if (sock_flag(other, SOCK_DEAD) ||
1500 (other->sk_shutdown & RCV_SHUTDOWN))
1501 goto pipe_err_free;
1502
1503 skb_queue_tail(&other->sk_receive_queue, skb);
1504 unix_state_runlock(other);
1505 other->sk_data_ready(other, size);
1506 sent+=size;
1507 }
1508
1509 scm_destroy(siocb->scm);
1510 siocb->scm = NULL;
1511
1512 return sent;
1513
1514 pipe_err_free:
1515 unix_state_runlock(other);
1516 kfree_skb(skb);
1517 pipe_err:
1518 if (sent==0 && !(msg->msg_flags&MSG_NOSIGNAL))
1519 send_sig(SIGPIPE,current,0);
1520 err = -EPIPE;
1521 out_err:
1522 scm_destroy(siocb->scm);
1523 siocb->scm = NULL;
1524 return sent ? : err;
1525 }
1526
1527 static int unix_seqpacket_sendmsg(struct kiocb *kiocb, struct socket *sock,
1528 struct msghdr *msg, size_t len)
1529 {
1530 int err;
1531 struct sock *sk = sock->sk;
1532
1533 err = sock_error(sk);
1534 if (err)
1535 return err;
1536
1537 if (sk->sk_state != TCP_ESTABLISHED)
1538 return -ENOTCONN;
1539
1540 if (msg->msg_namelen)
1541 msg->msg_namelen = 0;
1542
1543 return unix_dgram_sendmsg(kiocb, sock, msg, len);
1544 }
1545
1546 static void unix_copy_addr(struct msghdr *msg, struct sock *sk)
1547 {
1548 struct unix_sock *u = unix_sk(sk);
1549
1550 msg->msg_namelen = 0;
1551 if (u->addr) {
1552 msg->msg_namelen = u->addr->len;
1553 memcpy(msg->msg_name, u->addr->name, u->addr->len);
1554 }
1555 }
1556
1557 static int unix_dgram_recvmsg(struct kiocb *iocb, struct socket *sock,
1558 struct msghdr *msg, size_t size,
1559 int flags)
1560 {
1561 struct sock_iocb *siocb = kiocb_to_siocb(iocb);
1562 struct scm_cookie tmp_scm;
1563 struct sock *sk = sock->sk;
1564 struct unix_sock *u = unix_sk(sk);
1565 int noblock = flags & MSG_DONTWAIT;
1566 struct sk_buff *skb;
1567 int err;
1568
1569 err = -EOPNOTSUPP;
1570 if (flags&MSG_OOB)
1571 goto out;
1572
1573 msg->msg_namelen = 0;
1574
1575 mutex_lock(&u->readlock);
1576
1577 skb = skb_recv_datagram(sk, flags, noblock, &err);
1578 if (!skb)
1579 goto out_unlock;
1580
1581 wake_up_interruptible(&u->peer_wait);
1582
1583 if (msg->msg_name)
1584 unix_copy_addr(msg, skb->sk);
1585
1586 if (size > skb->len)
1587 size = skb->len;
1588 else if (size < skb->len)
1589 msg->msg_flags |= MSG_TRUNC;
1590
1591 err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, size);
1592 if (err)
1593 goto out_free;
1594
1595 if (!siocb->scm) {
1596 siocb->scm = &tmp_scm;
1597 memset(&tmp_scm, 0, sizeof(tmp_scm));
1598 }
1599 siocb->scm->creds = *UNIXCREDS(skb);
1600 unix_set_secdata(siocb->scm, skb);
1601
1602 if (!(flags & MSG_PEEK))
1603 {
1604 if (UNIXCB(skb).fp)
1605 unix_detach_fds(siocb->scm, skb);
1606 }
1607 else
1608 {
1609 /* It is questionable: on PEEK we could:
1610 - do not return fds - good, but too simple 8)
1611 - return fds, and do not return them on read (old strategy,
1612 apparently wrong)
1613 - clone fds (I chose it for now, it is the most universal
1614 solution)
1615
1616 POSIX 1003.1g does not actually define this clearly
1617 at all. POSIX 1003.1g doesn't define a lot of things
1618 clearly however!
1619
1620 */
1621 if (UNIXCB(skb).fp)
1622 siocb->scm->fp = scm_fp_dup(UNIXCB(skb).fp);
1623 }
1624 err = size;
1625
1626 scm_recv(sock, msg, siocb->scm, flags);
1627
1628 out_free:
1629 skb_free_datagram(sk,skb);
1630 out_unlock:
1631 mutex_unlock(&u->readlock);
1632 out:
1633 return err;
1634 }
1635
1636 /*
1637 * Sleep until data has arrive. But check for races..
1638 */
1639
1640 static long unix_stream_data_wait(struct sock * sk, long timeo)
1641 {
1642 DEFINE_WAIT(wait);
1643
1644 unix_state_rlock(sk);
1645
1646 for (;;) {
1647 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
1648
1649 if (!skb_queue_empty(&sk->sk_receive_queue) ||
1650 sk->sk_err ||
1651 (sk->sk_shutdown & RCV_SHUTDOWN) ||
1652 signal_pending(current) ||
1653 !timeo)
1654 break;
1655
1656 set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
1657 unix_state_runlock(sk);
1658 timeo = schedule_timeout(timeo);
1659 unix_state_rlock(sk);
1660 clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
1661 }
1662
1663 finish_wait(sk->sk_sleep, &wait);
1664 unix_state_runlock(sk);
1665 return timeo;
1666 }
1667
1668
1669
1670 static int unix_stream_recvmsg(struct kiocb *iocb, struct socket *sock,
1671 struct msghdr *msg, size_t size,
1672 int flags)
1673 {
1674 struct sock_iocb *siocb = kiocb_to_siocb(iocb);
1675 struct scm_cookie tmp_scm;
1676 struct sock *sk = sock->sk;
1677 struct unix_sock *u = unix_sk(sk);
1678 struct sockaddr_un *sunaddr=msg->msg_name;
1679 int copied = 0;
1680 int check_creds = 0;
1681 int target;
1682 int err = 0;
1683 long timeo;
1684
1685 err = -EINVAL;
1686 if (sk->sk_state != TCP_ESTABLISHED)
1687 goto out;
1688
1689 err = -EOPNOTSUPP;
1690 if (flags&MSG_OOB)
1691 goto out;
1692
1693 target = sock_rcvlowat(sk, flags&MSG_WAITALL, size);
1694 timeo = sock_rcvtimeo(sk, flags&MSG_DONTWAIT);
1695
1696 msg->msg_namelen = 0;
1697
1698 /* Lock the socket to prevent queue disordering
1699 * while sleeps in memcpy_tomsg
1700 */
1701
1702 if (!siocb->scm) {
1703 siocb->scm = &tmp_scm;
1704 memset(&tmp_scm, 0, sizeof(tmp_scm));
1705 }
1706
1707 mutex_lock(&u->readlock);
1708
1709 do
1710 {
1711 int chunk;
1712 struct sk_buff *skb;
1713
1714 skb = skb_dequeue(&sk->sk_receive_queue);
1715 if (skb==NULL)
1716 {
1717 if (copied >= target)
1718 break;
1719
1720 /*
1721 * POSIX 1003.1g mandates this order.
1722 */
1723
1724 if ((err = sock_error(sk)) != 0)
1725 break;
1726 if (sk->sk_shutdown & RCV_SHUTDOWN)
1727 break;
1728 err = -EAGAIN;
1729 if (!timeo)
1730 break;
1731 mutex_unlock(&u->readlock);
1732
1733 timeo = unix_stream_data_wait(sk, timeo);
1734
1735 if (signal_pending(current)) {
1736 err = sock_intr_errno(timeo);
1737 goto out;
1738 }
1739 mutex_lock(&u->readlock);
1740 continue;
1741 }
1742
1743 if (check_creds) {
1744 /* Never glue messages from different writers */
1745 if (memcmp(UNIXCREDS(skb), &siocb->scm->creds, sizeof(siocb->scm->creds)) != 0) {
1746 skb_queue_head(&sk->sk_receive_queue, skb);
1747 break;
1748 }
1749 } else {
1750 /* Copy credentials */
1751 siocb->scm->creds = *UNIXCREDS(skb);
1752 check_creds = 1;
1753 }
1754
1755 /* Copy address just once */
1756 if (sunaddr)
1757 {
1758 unix_copy_addr(msg, skb->sk);
1759 sunaddr = NULL;
1760 }
1761
1762 chunk = min_t(unsigned int, skb->len, size);
1763 if (memcpy_toiovec(msg->msg_iov, skb->data, chunk)) {
1764 skb_queue_head(&sk->sk_receive_queue, skb);
1765 if (copied == 0)
1766 copied = -EFAULT;
1767 break;
1768 }
1769 copied += chunk;
1770 size -= chunk;
1771
1772 /* Mark read part of skb as used */
1773 if (!(flags & MSG_PEEK))
1774 {
1775 skb_pull(skb, chunk);
1776
1777 if (UNIXCB(skb).fp)
1778 unix_detach_fds(siocb->scm, skb);
1779
1780 /* put the skb back if we didn't use it up.. */
1781 if (skb->len)
1782 {
1783 skb_queue_head(&sk->sk_receive_queue, skb);
1784 break;
1785 }
1786
1787 kfree_skb(skb);
1788
1789 if (siocb->scm->fp)
1790 break;
1791 }
1792 else
1793 {
1794 /* It is questionable, see note in unix_dgram_recvmsg.
1795 */
1796 if (UNIXCB(skb).fp)
1797 siocb->scm->fp = scm_fp_dup(UNIXCB(skb).fp);
1798
1799 /* put message back and return */
1800 skb_queue_head(&sk->sk_receive_queue, skb);
1801 break;
1802 }
1803 } while (size);
1804
1805 mutex_unlock(&u->readlock);
1806 scm_recv(sock, msg, siocb->scm, flags);
1807 out:
1808 return copied ? : err;
1809 }
1810
1811 static int unix_shutdown(struct socket *sock, int mode)
1812 {
1813 struct sock *sk = sock->sk;
1814 struct sock *other;
1815
1816 mode = (mode+1)&(RCV_SHUTDOWN|SEND_SHUTDOWN);
1817
1818 if (mode) {
1819 unix_state_wlock(sk);
1820 sk->sk_shutdown |= mode;
1821 other=unix_peer(sk);
1822 if (other)
1823 sock_hold(other);
1824 unix_state_wunlock(sk);
1825 sk->sk_state_change(sk);
1826
1827 if (other &&
1828 (sk->sk_type == SOCK_STREAM || sk->sk_type == SOCK_SEQPACKET)) {
1829
1830 int peer_mode = 0;
1831
1832 if (mode&RCV_SHUTDOWN)
1833 peer_mode |= SEND_SHUTDOWN;
1834 if (mode&SEND_SHUTDOWN)
1835 peer_mode |= RCV_SHUTDOWN;
1836 unix_state_wlock(other);
1837 other->sk_shutdown |= peer_mode;
1838 unix_state_wunlock(other);
1839 other->sk_state_change(other);
1840 read_lock(&other->sk_callback_lock);
1841 if (peer_mode == SHUTDOWN_MASK)
1842 sk_wake_async(other,1,POLL_HUP);
1843 else if (peer_mode & RCV_SHUTDOWN)
1844 sk_wake_async(other,1,POLL_IN);
1845 read_unlock(&other->sk_callback_lock);
1846 }
1847 if (other)
1848 sock_put(other);
1849 }
1850 return 0;
1851 }
1852
1853 static int unix_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1854 {
1855 struct sock *sk = sock->sk;
1856 long amount=0;
1857 int err;
1858
1859 switch(cmd)
1860 {
1861 case SIOCOUTQ:
1862 amount = atomic_read(&sk->sk_wmem_alloc);
1863 err = put_user(amount, (int __user *)arg);
1864 break;
1865 case SIOCINQ:
1866 {
1867 struct sk_buff *skb;
1868
1869 if (sk->sk_state == TCP_LISTEN) {
1870 err = -EINVAL;
1871 break;
1872 }
1873
1874 spin_lock(&sk->sk_receive_queue.lock);
1875 if (sk->sk_type == SOCK_STREAM ||
1876 sk->sk_type == SOCK_SEQPACKET) {
1877 skb_queue_walk(&sk->sk_receive_queue, skb)
1878 amount += skb->len;
1879 } else {
1880 skb = skb_peek(&sk->sk_receive_queue);
1881 if (skb)
1882 amount=skb->len;
1883 }
1884 spin_unlock(&sk->sk_receive_queue.lock);
1885 err = put_user(amount, (int __user *)arg);
1886 break;
1887 }
1888
1889 default:
1890 err = -ENOIOCTLCMD;
1891 break;
1892 }
1893 return err;
1894 }
1895
1896 static unsigned int unix_poll(struct file * file, struct socket *sock, poll_table *wait)
1897 {
1898 struct sock *sk = sock->sk;
1899 unsigned int mask;
1900
1901 poll_wait(file, sk->sk_sleep, wait);
1902 mask = 0;
1903
1904 /* exceptional events? */
1905 if (sk->sk_err)
1906 mask |= POLLERR;
1907 if (sk->sk_shutdown == SHUTDOWN_MASK)
1908 mask |= POLLHUP;
1909 if (sk->sk_shutdown & RCV_SHUTDOWN)
1910 mask |= POLLRDHUP;
1911
1912 /* readable? */
1913 if (!skb_queue_empty(&sk->sk_receive_queue) ||
1914 (sk->sk_shutdown & RCV_SHUTDOWN))
1915 mask |= POLLIN | POLLRDNORM;
1916
1917 /* Connection-based need to check for termination and startup */
1918 if ((sk->sk_type == SOCK_STREAM || sk->sk_type == SOCK_SEQPACKET) && sk->sk_state == TCP_CLOSE)
1919 mask |= POLLHUP;
1920
1921 /*
1922 * we set writable also when the other side has shut down the
1923 * connection. This prevents stuck sockets.
1924 */
1925 if (unix_writable(sk))
1926 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
1927
1928 return mask;
1929 }
1930
1931
1932 #ifdef CONFIG_PROC_FS
1933 static struct sock *unix_seq_idx(int *iter, loff_t pos)
1934 {
1935 loff_t off = 0;
1936 struct sock *s;
1937
1938 for (s = first_unix_socket(iter); s; s = next_unix_socket(iter, s)) {
1939 if (off == pos)
1940 return s;
1941 ++off;
1942 }
1943 return NULL;
1944 }
1945
1946
1947 static void *unix_seq_start(struct seq_file *seq, loff_t *pos)
1948 {
1949 spin_lock(&unix_table_lock);
1950 return *pos ? unix_seq_idx(seq->private, *pos - 1) : ((void *) 1);
1951 }
1952
1953 static void *unix_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1954 {
1955 ++*pos;
1956
1957 if (v == (void *)1)
1958 return first_unix_socket(seq->private);
1959 return next_unix_socket(seq->private, v);
1960 }
1961
1962 static void unix_seq_stop(struct seq_file *seq, void *v)
1963 {
1964 spin_unlock(&unix_table_lock);
1965 }
1966
1967 static int unix_seq_show(struct seq_file *seq, void *v)
1968 {
1969
1970 if (v == (void *)1)
1971 seq_puts(seq, "Num RefCount Protocol Flags Type St "
1972 "Inode Path\n");
1973 else {
1974 struct sock *s = v;
1975 struct unix_sock *u = unix_sk(s);
1976 unix_state_rlock(s);
1977
1978 seq_printf(seq, "%p: %08X %08X %08X %04X %02X %5lu",
1979 s,
1980 atomic_read(&s->sk_refcnt),
1981 0,
1982 s->sk_state == TCP_LISTEN ? __SO_ACCEPTCON : 0,
1983 s->sk_type,
1984 s->sk_socket ?
1985 (s->sk_state == TCP_ESTABLISHED ? SS_CONNECTED : SS_UNCONNECTED) :
1986 (s->sk_state == TCP_ESTABLISHED ? SS_CONNECTING : SS_DISCONNECTING),
1987 sock_i_ino(s));
1988
1989 if (u->addr) {
1990 int i, len;
1991 seq_putc(seq, ' ');
1992
1993 i = 0;
1994 len = u->addr->len - sizeof(short);
1995 if (!UNIX_ABSTRACT(s))
1996 len--;
1997 else {
1998 seq_putc(seq, '@');
1999 i++;
2000 }
2001 for ( ; i < len; i++)
2002 seq_putc(seq, u->addr->name->sun_path[i]);
2003 }
2004 unix_state_runlock(s);
2005 seq_putc(seq, '\n');
2006 }
2007
2008 return 0;
2009 }
2010
2011 static struct seq_operations unix_seq_ops = {
2012 .start = unix_seq_start,
2013 .next = unix_seq_next,
2014 .stop = unix_seq_stop,
2015 .show = unix_seq_show,
2016 };
2017
2018
2019 static int unix_seq_open(struct inode *inode, struct file *file)
2020 {
2021 struct seq_file *seq;
2022 int rc = -ENOMEM;
2023 int *iter = kmalloc(sizeof(int), GFP_KERNEL);
2024
2025 if (!iter)
2026 goto out;
2027
2028 rc = seq_open(file, &unix_seq_ops);
2029 if (rc)
2030 goto out_kfree;
2031
2032 seq = file->private_data;
2033 seq->private = iter;
2034 *iter = 0;
2035 out:
2036 return rc;
2037 out_kfree:
2038 kfree(iter);
2039 goto out;
2040 }
2041
2042 static struct file_operations unix_seq_fops = {
2043 .owner = THIS_MODULE,
2044 .open = unix_seq_open,
2045 .read = seq_read,
2046 .llseek = seq_lseek,
2047 .release = seq_release_private,
2048 };
2049
2050 #endif
2051
2052 static struct net_proto_family unix_family_ops = {
2053 .family = PF_UNIX,
2054 .create = unix_create,
2055 .owner = THIS_MODULE,
2056 };
2057
2058 static int __init af_unix_init(void)
2059 {
2060 int rc = -1;
2061 struct sk_buff *dummy_skb;
2062
2063 BUILD_BUG_ON(sizeof(struct unix_skb_parms) > sizeof(dummy_skb->cb));
2064
2065 rc = proto_register(&unix_proto, 1);
2066 if (rc != 0) {
2067 printk(KERN_CRIT "%s: Cannot create unix_sock SLAB cache!\n",
2068 __FUNCTION__);
2069 goto out;
2070 }
2071
2072 sock_register(&unix_family_ops);
2073 #ifdef CONFIG_PROC_FS
2074 proc_net_fops_create("unix", 0, &unix_seq_fops);
2075 #endif
2076 unix_sysctl_register();
2077 out:
2078 return rc;
2079 }
2080
2081 static void __exit af_unix_exit(void)
2082 {
2083 sock_unregister(PF_UNIX);
2084 unix_sysctl_unregister();
2085 proc_net_remove("unix");
2086 proto_unregister(&unix_proto);
2087 }
2088
2089 module_init(af_unix_init);
2090 module_exit(af_unix_exit);
2091
2092 MODULE_LICENSE("GPL");
2093 MODULE_ALIAS_NETPROTO(PF_UNIX);
hh.org GIT migration