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