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