net/unix/af_unix.c

Name: Public Git Hosting - davej-history.git/blob - net/unix/af_unix.c
Rating: 4.4 (7325 reviews)
 1 /*
 2  * NET3: 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.69 1998/08/28 01:15:41 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  *
 37  * Known differences from reference BSD that was tested:
 38  *
 39  * [TO FIX]
 40  * ECONNREFUSED is not returned from one end of a connected() socket to the
 41  * other the moment one end closes.
 42  * fstat() doesn't return st_dev=NODEV, and give the blksize as high water mark
 43  * and a fake inode identifier (nor the BSD first socket fstat twice bug).
 44  * [NOT TO FIX]
 45  * accept() returns a path name even if the connecting socket has closed
 46  * in the meantime (BSD loses the path and gives up).
 47  * accept() returns 0 length path for an unbound connector. BSD returns 16
 48  * and a null first byte in the path (but not for gethost/peername - BSD bug ??)
 49  * socketpair(...SOCK_RAW..) doesn't panic the kernel.
 50  * BSD af_unix apparently has connect forgetting to block properly.
 51  * (need to check this with the POSIX spec in detail)
 52  *
 53  * Differences from 2.0.0-11-... (ANK)
 54  * Bug fixes and improvements.
 55  * - client shutdown killed server socket.
 56  * - removed all useless cli/sti pairs.
 57  *
 58  * Semantic changes/extensions.
 59  * - generic control message passing.
 60  * - SCM_CREDENTIALS control message.
 61  * - "Abstract" (not FS based) socket bindings.
 62  * Abstract names are sequences of bytes (not zero terminated)
 63  * started by 0, so that this name space does not intersect
 64  * with BSD names.
 65  */
 66
 67 #include <linux/module.h>
 68 #include <linux/config.h>
 69 #include <linux/kernel.h>
 70 #include <linux/major.h>
 71 #include <linux/signal.h>
 72 #include <linux/sched.h>
 73 #include <linux/errno.h>
 74 #include <linux/string.h>
 75 #include <linux/stat.h>
 76 #include <linux/socket.h>
 77 #include <linux/un.h>
 78 #include <linux/fcntl.h>
 79 #include <linux/termios.h>
 80 #include <linux/socket.h>
 81 #include <linux/sockios.h>
 82 #include <linux/net.h>
 83 #include <linux/in.h>
 84 #include <linux/fs.h>
 85 #include <linux/malloc.h>
 86 #include <asm/uaccess.h>
 87 #include <linux/skbuff.h>
 88 #include <linux/netdevice.h>
 89 #include <net/sock.h>
 90 #include <net/tcp.h>
 91 #include <net/af_unix.h>
 92 #include <linux/proc_fs.h>
 93 #include <net/scm.h>
 94 #include <linux/init.h>
 95 #include <linux/poll.h>
 96
 97 #include <asm/checksum.h>
 98
 99 #define min(a,b) (((a)<(b))?(a):(b))
 100
 101 int sysctl_unix_delete_delay = HZ;
 102 int sysctl_unix_destroy_delay =10*HZ;
 103
 104 unix_socket *unix_socket_table[UNIX_HASH_SIZE+1];
 105
 106 #define unix_sockets_unbound (unix_socket_table[UNIX_HASH_SIZE])
 107
 108 #define UNIX_ABSTRACT(sk) ((sk)->protinfo.af_unix.addr->hash!=UNIX_HASH_SIZE)
 109
 110 static voidunix_destroy_socket(unix_socket *sk);
 111 static voidunix_stream_write_space(struct sock *sk);
 112
 113 extern __inline__ unsignedunix_hash_fold(unsigned hash)
 114 {
 115  hash ^= hash>>16;
 116  hash ^= hash>>8;
 117  hash ^= hash>>4;
 118 return hash;
 119 }
 120
 121 #define unix_peer(sk) ((sk)->pair)
 122
 123 extern __inline__ intunix_our_peer(unix_socket *sk, unix_socket *osk)
 124 {
 125 returnunix_peer(osk) == sk;
 126 }
 127
 128 extern __inline__ intunix_may_send(unix_socket *sk, unix_socket *osk)
 129 {
 130 return(unix_peer(osk) == NULL ||unix_our_peer(sk, osk));
 131 }
 132
 133 extern __inline__ voidunix_lock(unix_socket *sk)
 134 {
 135 atomic_inc(&sk->sock_readers);
 136 }
 137
 138 extern __inline__ voidunix_unlock(unix_socket *sk)
 139 {
 140 atomic_dec(&sk->sock_readers);
 141 }
 142
 143 extern __inline__ intunix_locked(unix_socket *sk)
 144 {
 145 returnatomic_read(&sk->sock_readers);
 146 }
 147
 148 extern __inline__ voidunix_release_addr(struct unix_address *addr)
 149 {
 150 if(addr)
 151 {
 152 if(atomic_dec_and_test(&addr->refcnt))
 153 kfree(addr);
 154 }
 155 }
 156
 157 static voidunix_destruct_addr(struct sock *sk)
 158 {
 159 struct unix_address *addr = sk->protinfo.af_unix.addr;
 160
 161 unix_release_addr(addr);
 162 }
 163
 164 /*
 165  * Check unix socket name:
 166  * - should be not zero length.
 167  * - if started by not zero, should be NULL terminated (FS object)
 168  * - if started by zero, it is abstract name.
 169  */
 170
 171 static intunix_mkname(struct sockaddr_un * sunaddr,int len,unsigned*hashp)
 172 {
 173 if(len <=sizeof(short) || len >sizeof(*sunaddr))
 174 return-EINVAL;
 175 if(!sunaddr || sunaddr->sun_family != AF_UNIX)
 176 return-EINVAL;
 177 if(sunaddr->sun_path[0])
 178 {
 179 /*
 180  * This may look like an off by one error but it is
 181  * a bit more subtle. 108 is the longest valid AF_UNIX
 182  * path for a binding. sun_path[108] doesnt as such
 183  * exist. However in kernel space we are guaranteed that
 184  * it is a valid memory location in our kernel
 185  * address buffer.
 186  */
 187 if(len >sizeof(*sunaddr))
 188  len =sizeof(*sunaddr);
 189 ((char*)sunaddr)[len]=0;
 190  len =strlen(sunaddr->sun_path)+1+sizeof(short);
 191 return len;
 192 }
 193
 194 *hashp =unix_hash_fold(csum_partial((char*)sunaddr, len,0));
 195 return len;
 196 }
 197
 198 static voidunix_remove_socket(unix_socket *sk)
 199 {
 200  unix_socket **list = sk->protinfo.af_unix.list;
 201 if(sk->next)
 202  sk->next->prev = sk->prev;
 203 if(sk->prev)
 204  sk->prev->next = sk->next;
 205 if(*list == sk)
 206 *list = sk->next;
 207  sk->protinfo.af_unix.list = NULL;
 208  sk->prev = NULL;
 209  sk->next = NULL;
 210 }
 211
 212 static voidunix_insert_socket(unix_socket *sk)
 213 {
 214  unix_socket **list = sk->protinfo.af_unix.list;
 215  sk->prev = NULL;
 216  sk->next = *list;
 217 if(*list)
 218 (*list)->prev = sk;
 219 *list=sk;
 220 }
 221
 222 static unix_socket *unix_find_socket_byname(struct sockaddr_un *sunname,
 223 int len,int type,unsigned hash)
 224 {
 225  unix_socket *s;
 226
 227 for(s=unix_socket_table[(hash^type)&0xF]; s; s=s->next)
 228 {
 229 if(s->protinfo.af_unix.addr->len==len &&
 230 memcmp(s->protinfo.af_unix.addr->name, sunname, len) ==0&&
 231  s->type == type)
 232 {
 233 unix_lock(s);
 234 return(s);
 235 }
 236 }
 237 return(NULL);
 238 }
 239
 240 static unix_socket *unix_find_socket_byinode(struct inode *i)
 241 {
 242  unix_socket *s;
 243
 244 for(s=unix_socket_table[i->i_ino &0xF]; s; s=s->next)
 245 {
 246 struct dentry *dentry = s->protinfo.af_unix.dentry;
 247
 248 if(dentry && dentry->d_inode == i)
 249 {
 250 unix_lock(s);
 251 return(s);
 252 }
 253 }
 254 return(NULL);
 255 }
 256
 257 /*
 258  * Delete a unix socket. We have to allow for deferring this on a timer.
 259  */
 260
 261 static voidunix_destroy_timer(unsigned long data)
 262 {
 263  unix_socket *sk=(unix_socket *)data;
 264 if(!unix_locked(sk) &&atomic_read(&sk->wmem_alloc) ==0)
 265 {
 266 sk_free(sk);
 267
 268 /* socket destroyed, decrement count */
 269  MOD_DEC_USE_COUNT;
 270 return;
 271 }
 272
 273 /*
 274  * Retry;
 275  */
 276
 277  sk->timer.expires=jiffies+sysctl_unix_destroy_delay;/* No real hurry try it every 10 seconds or so */
 278 add_timer(&sk->timer);
 279 }
 280
 281
 282 static voidunix_delayed_delete(unix_socket *sk)
 283 {
 284  sk->timer.data=(unsigned long)sk;
 285  sk->timer.expires=jiffies+sysctl_unix_delete_delay;/* Normally 1 second after will clean up. After that we try every 10 */
 286  sk->timer.function=unix_destroy_timer;
 287 add_timer(&sk->timer);
 288 }
 289
 290 static intunix_release_sock(unix_socket *sk)
 291 {
 292  unix_socket *skpair;
 293
 294  sk->state_change(sk);
 295  sk->dead=1;
 296  sk->socket = NULL;
 297
 298  skpair=unix_peer(sk);
 299
 300 if(skpair!=NULL)
 301 {
 302 if(sk->type==SOCK_STREAM &&unix_our_peer(sk, skpair))
 303 {
 304  skpair->state_change(skpair);
 305  skpair->shutdown=SHUTDOWN_MASK;/* No more writes*/
 306 }
 307 unix_unlock(skpair);/* It may now die */
 308 }
 309
 310 /* Try to flush out this socket. Throw out buffers at least */
 311 unix_destroy_socket(sk);
 312
 313 /*
 314  * Fixme: BSD difference: In BSD all sockets connected to use get
 315  * ECONNRESET and we die on the spot. In Linux we behave
 316  * like files and pipes do and wait for the last
 317  * dereference.
 318  *
 319  * Can't we simply set sock->err?
 320  *
 321  * What the above comment does talk about? --ANK(980817)
 322  */
 323
 324 unix_gc();/* Garbage collect fds */
 325 return0;
 326 }
 327
 328 static voidunix_destroy_socket(unix_socket *sk)
 329 {
 330 struct sk_buff *skb;
 331
 332 unix_remove_socket(sk);
 333
 334 while((skb=skb_dequeue(&sk->receive_queue))!=NULL)
 335 {
 336 if(sk->state==TCP_LISTEN)
 337 unix_release_sock(skb->sk);
 338 /* passed fds are erased in the kfree_skb hook */
 339 kfree_skb(skb);
 340 }
 341
 342 if(sk->protinfo.af_unix.dentry!=NULL)
 343 {
 344 dput(sk->protinfo.af_unix.dentry);
 345  sk->protinfo.af_unix.dentry=NULL;
 346 }
 347
 348 if(!unix_locked(sk) &&atomic_read(&sk->wmem_alloc) ==0)
 349 {
 350 sk_free(sk);
 351
 352 /* socket destroyed, decrement count */
 353  MOD_DEC_USE_COUNT;
 354 }
 355 else
 356 {
 357  sk->state=TCP_CLOSE;
 358  sk->dead=1;
 359 unix_delayed_delete(sk);/* Try every so often until buffers are all freed */
 360 }
 361
 362 }
 363
 364 static intunix_listen(struct socket *sock,int backlog)
 365 {
 366 struct sock *sk = sock->sk;
 367
 368 if(sock->state != SS_UNCONNECTED)
 369 return(-EINVAL);
 370 if(sock->type!=SOCK_STREAM)
 371 return-EOPNOTSUPP;/* Only stream sockets accept */
 372 if(!sk->protinfo.af_unix.addr)
 373 return-EINVAL;/* No listens on an unbound socket */
 374  sk->max_ack_backlog=backlog;
 375  sk->state=TCP_LISTEN;
 376  sock->flags |= SO_ACCEPTCON;
 377 /* set credentials so connect can copy them */
 378  sk->peercred.pid = current->pid;
 379  sk->peercred.uid = current->euid;
 380  sk->peercred.gid = current->egid;
 381 return0;
 382 }
 383
 384 externstruct proto_ops unix_stream_ops;
 385 externstruct proto_ops unix_dgram_ops;
 386
 387 static struct sock *unix_create1(struct socket *sock,int stream)
 388 {
 389 struct sock *sk;
 390
 391  MOD_INC_USE_COUNT;
 392  sk =sk_alloc(PF_UNIX, GFP_KERNEL,1);
 393 if(!sk) {
 394  MOD_DEC_USE_COUNT;
 395 return NULL;
 396 }
 397
 398 sock_init_data(sock,sk);
 399
 400 if(stream)
 401  sk->write_space = unix_stream_write_space;
 402
 403  sk->destruct = unix_destruct_addr;
 404  sk->protinfo.af_unix.family=PF_UNIX;
 405  sk->protinfo.af_unix.dentry=NULL;
 406  sk->protinfo.af_unix.readsem=MUTEX;/* single task reading lock */
 407  sk->protinfo.af_unix.list=&unix_sockets_unbound;
 408 unix_insert_socket(sk);
 409
 410 return sk;
 411 }
 412
 413 static intunix_create(struct socket *sock,int protocol)
 414 {
 415 int stream =0;
 416
 417 if(protocol && protocol != PF_UNIX)
 418 return-EPROTONOSUPPORT;
 419
 420  sock->state = SS_UNCONNECTED;
 421
 422 switch(sock->type) {
 423 case SOCK_STREAM:
 424  sock->ops = &unix_stream_ops;
 425  stream =1;
 426 break;
 427 /*
 428  * Believe it or not BSD has AF_UNIX, SOCK_RAW though
 429  * nothing uses it.
 430  */
 431 case SOCK_RAW:
 432  sock->type=SOCK_DGRAM;
 433 case SOCK_DGRAM:
 434  sock->ops = &unix_dgram_ops;
 435 break;
 436 default:
 437 return-ESOCKTNOSUPPORT;
 438 }
 439
 440 returnunix_create1(sock, stream) ?0: -ENOMEM;
 441 }
 442
 443 static intunix_release(struct socket *sock,struct socket *peer)
 444 {
 445  unix_socket *sk = sock->sk;
 446
 447 if(!sk)
 448 return0;
 449
 450  sock->sk = NULL;
 451 if(sock->state != SS_UNCONNECTED)
 452  sock->state = SS_DISCONNECTING;
 453
 454 returnunix_release_sock(sk);
 455 }
 456
 457 static intunix_autobind(struct socket *sock)
 458 {
 459 struct sock *sk = sock->sk;
 460 static u32 ordernum =1;
 461 struct unix_address * addr;
 462  unix_socket *osk;
 463
 464  addr =kmalloc(sizeof(*addr) +sizeof(short) +16, GFP_KERNEL);
 465 if(!addr)
 466 return-ENOBUFS;
 467 if(sk->protinfo.af_unix.addr || sk->protinfo.af_unix.dentry)
 468 {
 469 kfree(addr);
 470 return-EINVAL;
 471 }
 472 memset(addr,0,sizeof(*addr) +sizeof(short) +16);
 473  addr->name->sun_family = AF_UNIX;
 474 atomic_set(&addr->refcnt,1);
 475
 476 retry:
 477  addr->len =sprintf(addr->name->sun_path+1,"%08x", ordernum) +1+sizeof(short);
 478  addr->hash =unix_hash_fold(csum_partial((void*)addr->name, addr->len,0));
 479  ordernum++;
 480
 481 if((osk=unix_find_socket_byname(addr->name, addr->len, sock->type,
 482  addr->hash)) != NULL)
 483 {
 484 unix_unlock(osk);
 485 goto retry;
 486 }
 487
 488  sk->protinfo.af_unix.addr = addr;
 489 unix_remove_socket(sk);
 490  sk->protinfo.af_unix.list = &unix_socket_table[(addr->hash ^ sk->type)&0xF];
 491 unix_insert_socket(sk);
 492 return0;
 493 }
 494
 495 static unix_socket *unix_find_other(struct sockaddr_un *sunname,int len,
 496 int type,unsigned hash,int*error)
 497 {
 498  unix_socket *u;
 499
 500 if(sunname->sun_path[0])
 501 {
 502 struct dentry *dentry;
 503  dentry =open_namei(sunname->sun_path,2, S_IFSOCK);
 504 if(IS_ERR(dentry)) {
 505 *error =PTR_ERR(dentry);
 506 return NULL;
 507 }
 508  u=unix_find_socket_byinode(dentry->d_inode);
 509 dput(dentry);
 510 if(u && u->type != type)
 511 {
 512 *error=-EPROTOTYPE;
 513 unix_unlock(u);
 514 return NULL;
 515 }
 516 }
 517 else
 518  u=unix_find_socket_byname(sunname, len, type, hash);
 519
 520 if(u==NULL)
 521 {
 522 *error=-ECONNREFUSED;
 523 return NULL;
 524 }
 525 return u;
 526 }
 527
 528
 529 static intunix_bind(struct socket *sock,struct sockaddr *uaddr,int addr_len)
 530 {
 531 struct sock *sk = sock->sk;
 532 struct sockaddr_un *sunaddr=(struct sockaddr_un *)uaddr;
 533 struct dentry * dentry;
 534 int err;
 535 unsigned hash;
 536 struct unix_address *addr;
 537
 538 if(sk->protinfo.af_unix.addr || sk->protinfo.af_unix.dentry ||
 539  sunaddr->sun_family != AF_UNIX)
 540 return-EINVAL;
 541
 542 if(addr_len==sizeof(short))
 543 returnunix_autobind(sock);
 544
 545  addr_len =unix_mkname(sunaddr, addr_len, &hash);
 546 if(addr_len <0)
 547 return addr_len;
 548
 549  addr =kmalloc(sizeof(*addr)+addr_len, GFP_KERNEL);
 550 if(!addr)
 551 return-ENOBUFS;
 552
 553 /* We slept; recheck ... */
 554
 555 if(sk->protinfo.af_unix.addr || sk->protinfo.af_unix.dentry)
 556 {
 557 kfree(addr);
 558 return-EINVAL;/* Already bound */
 559 }
 560
 561 memcpy(addr->name, sunaddr, addr_len);
 562  addr->len = addr_len;
 563  addr->hash = hash;
 564 atomic_set(&addr->refcnt,1);
 565
 566 if(!sunaddr->sun_path[0])
 567 {
 568  unix_socket *osk =unix_find_socket_byname(sunaddr, addr_len,
 569  sk->type, hash);
 570 if(osk)
 571 {
 572 unix_unlock(osk);
 573 kfree(addr);
 574 return-EADDRINUSE;
 575 }
 576 unix_remove_socket(sk);
 577  sk->protinfo.af_unix.addr = addr;
 578  sk->protinfo.af_unix.list = &unix_socket_table[(hash^sk->type)&0xF];
 579 unix_insert_socket(sk);
 580 return0;
 581 }
 582
 583  addr->hash = UNIX_HASH_SIZE;
 584  sk->protinfo.af_unix.addr = addr;
 585
 586
 587  dentry =do_mknod(sunaddr->sun_path, S_IFSOCK|S_IRWXUGO,0);
 588 if(IS_ERR(dentry))
 589 {
 590  err =PTR_ERR(dentry);
 591 unix_release_addr(addr);
 592  sk->protinfo.af_unix.addr = NULL;
 593 if(err==-EEXIST)
 594 return-EADDRINUSE;
 595 else
 596 return err;
 597 }
 598 unix_remove_socket(sk);
 599  sk->protinfo.af_unix.list = &unix_socket_table[dentry->d_inode->i_ino &0xF];
 600  sk->protinfo.af_unix.dentry = dentry;
 601 unix_insert_socket(sk);
 602
 603 return0;
 604 }
 605
 606 static intunix_dgram_connect(struct socket *sock,struct sockaddr *addr,
 607 int alen,int flags)
 608 {
 609 struct sock *sk = sock->sk;
 610 struct sockaddr_un *sunaddr=(struct sockaddr_un*)addr;
 611 struct sock *other;
 612 unsigned hash;
 613 int err;
 614
 615 /*
 616  * 1003.1g breaking connected state with AF_UNSPEC
 617  */
 618
 619 if(addr->sa_family==AF_UNSPEC)
 620 {
 621 if(unix_peer(sk))
 622 {
 623 unix_unlock(unix_peer(sk));
 624 unix_peer(sk) = NULL;
 625  sock->state=SS_UNCONNECTED;
 626 }
 627 return0;
 628 }
 629
 630  alen =unix_mkname(sunaddr, alen, &hash);
 631 if(alen <0)
 632 return alen;
 633
 634  other=unix_find_other(sunaddr, alen, sock->type, hash, &err);
 635 if(!other)
 636 return err;
 637 if(!unix_may_send(sk, other))
 638 {
 639 unix_unlock(other);
 640 return-EINVAL;
 641 }
 642
 643 /*
 644  * If it was connected, reconnect.
 645  */
 646 if(unix_peer(sk))
 647 {
 648 unix_unlock(unix_peer(sk));
 649 unix_peer(sk)=NULL;
 650 }
 651 unix_peer(sk)=other;
 652 if(sock->passcred && !sk->protinfo.af_unix.addr)
 653 unix_autobind(sock);
 654 return0;
 655 }
 656
 657 static intunix_stream_connect(struct socket *sock,struct sockaddr *uaddr,
 658 int addr_len,int flags)
 659 {
 660 struct sockaddr_un *sunaddr=(struct sockaddr_un *)uaddr;
 661 struct sock *sk = sock->sk, *newsk;
 662  unix_socket *other;
 663 struct sk_buff *skb;
 664 int err;
 665 unsigned hash;
 666
 667  addr_len =unix_mkname(sunaddr, addr_len, &hash);
 668 if(addr_len <0)
 669 return addr_len;
 670
 671 /* First of all allocate resources.
 672  If we will make it after state checks,
 673  we will have to recheck all again in any case.
 674  */
 675
 676 /* Find listening sock */
 677  other=unix_find_other(sunaddr, addr_len, sk->type, hash, &err);
 678
 679 /* create new sock for complete connection */
 680  newsk =unix_create1(NULL,1);
 681
 682 /* Allocate skb for sending to listening sock */
 683  skb = NULL;
 684 if(newsk)
 685  skb =sock_wmalloc(newsk,1,0, GFP_KERNEL);
 686
 687 switch(sock->state)
 688 {
 689 case SS_UNCONNECTED:
 690 /* This is ok... continue with connect */
 691 break;
 692 case SS_CONNECTED:
 693 /* Socket is already connected */
 694  err = -EISCONN;
 695 goto out;
 696 default:
 697  err = -EINVAL;
 698 goto out;
 699 }
 700
 701  err = -EINVAL;
 702 if(sk->state != TCP_CLOSE)
 703 goto out;
 704
 705 /* Check that listener is in valid state. */
 706  err = -ECONNREFUSED;
 707 if(other == NULL || other->dead || other->state != TCP_LISTEN)
 708 goto out;
 709
 710  err = -ENOMEM;
 711 if(newsk == NULL || skb == NULL)
 712 goto out;
 713
 714 UNIXCB(skb).attr = MSG_SYN;
 715
 716 /* set up connecting socket */
 717  sock->state=SS_CONNECTED;
 718 if(!sk->protinfo.af_unix.addr)
 719 unix_autobind(sock);
 720 unix_peer(sk)=newsk;
 721 unix_lock(sk);
 722  sk->state=TCP_ESTABLISHED;
 723 /* Set credentials */
 724  sk->peercred = other->peercred;
 725
 726 /* set up newly created sock */
 727 unix_peer(newsk)=sk;
 728 unix_lock(newsk);
 729  newsk->state=TCP_ESTABLISHED;
 730  newsk->type=SOCK_STREAM;
 731  newsk->peercred.pid = current->pid;
 732  newsk->peercred.uid = current->euid;
 733  newsk->peercred.gid = current->egid;
 734
 735 /* copy address information from listening to new sock*/
 736 if(other->protinfo.af_unix.addr)
 737 {
 738 atomic_inc(&other->protinfo.af_unix.addr->refcnt);
 739  newsk->protinfo.af_unix.addr=other->protinfo.af_unix.addr;
 740 }
 741 if(other->protinfo.af_unix.dentry)
 742  newsk->protinfo.af_unix.dentry=dget(other->protinfo.af_unix.dentry);
 743
 744 /* send info to listening sock */
 745  other->ack_backlog++;
 746 skb_queue_tail(&other->receive_queue,skb);
 747  other->data_ready(other,0);/* Wake up ! */
 748 unix_unlock(other);
 749 return0;
 750
 751 out:
 752 if(skb)
 753 kfree_skb(skb);
 754 if(newsk)
 755 unix_destroy_socket(newsk);
 756 if(other)
 757 unix_unlock(other);
 758 return err;
 759 }
 760
 761 static intunix_socketpair(struct socket *socka,struct socket *sockb)
 762 {
 763 struct sock *ska=socka->sk, *skb = sockb->sk;
 764
 765 /* Join our sockets back to back */
 766 unix_lock(ska);
 767 unix_lock(skb);
 768 unix_peer(ska)=skb;
 769 unix_peer(skb)=ska;
 770
 771 if(ska->type != SOCK_DGRAM)
 772 {
 773  ska->state=TCP_ESTABLISHED;
 774  skb->state=TCP_ESTABLISHED;
 775  socka->state=SS_CONNECTED;
 776  sockb->state=SS_CONNECTED;
 777 }
 778 return0;
 779 }
 780
 781 static intunix_accept(struct socket *sock,struct socket *newsock,int flags)
 782 {
 783  unix_socket *sk = sock->sk;
 784  unix_socket *newsk = newsock->sk;
 785  unix_socket *tsk;
 786 struct sk_buff *skb;
 787
 788 if(sock->state != SS_UNCONNECTED)
 789 return(-EINVAL);
 790 if(!(sock->flags & SO_ACCEPTCON))
 791 return(-EINVAL);
 792
 793 if(sock->type!=SOCK_STREAM)
 794 return-EOPNOTSUPP;
 795 if(sk->state!=TCP_LISTEN)
 796 return-EINVAL;
 797
 798 for(;;)
 799 {
 800  skb=skb_dequeue(&sk->receive_queue);
 801 if(skb==NULL)
 802 {
 803 if(flags&O_NONBLOCK)
 804 return-EAGAIN;
 805 interruptible_sleep_on(sk->sleep);
 806 if(signal_pending(current))
 807 return-ERESTARTSYS;
 808 continue;
 809 }
 810 if(!(UNIXCB(skb).attr & MSG_SYN))
 811 {
 812  tsk=skb->sk;
 813  tsk->state_change(tsk);
 814 kfree_skb(skb);
 815 continue;
 816 }
 817  tsk = skb->sk;
 818  sk->ack_backlog--;
 819 kfree_skb(skb);
 820 if(!tsk->dead)
 821 break;
 822 unix_release_sock(tsk);
 823 }
 824
 825
 826 /* attach accepted sock to socket */
 827  newsock->state=SS_CONNECTED;
 828  newsock->sk=tsk;
 829  tsk->sleep=newsk->sleep;
 830  tsk->socket=newsock;
 831
 832 /* destroy handed sock */
 833  newsk->socket = NULL;
 834 unix_destroy_socket(newsk);
 835
 836 return0;
 837 }
 838
 839
 840 static intunix_getname(struct socket *sock,struct sockaddr *uaddr,int*uaddr_len,int peer)
 841 {
 842 struct sock *sk = sock->sk;
 843 struct sockaddr_un *sunaddr=(struct sockaddr_un *)uaddr;
 844
 845 if(peer)
 846 {
 847 if(!unix_peer(sk))
 848 return-ENOTCONN;
 849  sk=unix_peer(sk);
 850 }
 851 if(!sk->protinfo.af_unix.addr)
 852 {
 853  sunaddr->sun_family = AF_UNIX;
 854  sunaddr->sun_path[0] =0;
 855 *uaddr_len =sizeof(short);
 856 return0;/* Not bound */
 857 }
 858 *uaddr_len = sk->protinfo.af_unix.addr->len;
 859 memcpy(sunaddr, sk->protinfo.af_unix.addr->name, *uaddr_len);
 860 return0;
 861 }
 862
 863 static voidunix_detach_fds(struct scm_cookie *scm,struct sk_buff *skb)
 864 {
 865 int i;
 866
 867  scm->fp =UNIXCB(skb).fp;
 868  skb->destructor = sock_wfree;
 869 UNIXCB(skb).fp = NULL;
 870
 871 for(i=scm->fp->count-1; i>=0; i--)
 872 unix_notinflight(scm->fp->fp[i]);
 873 }
 874
 875 static voidunix_destruct_fds(struct sk_buff *skb)
 876 {
 877 struct scm_cookie scm;
 878 memset(&scm,0,sizeof(scm));
 879 unix_detach_fds(&scm, skb);
 880 scm_destroy(&scm);
 881 sock_wfree(skb);
 882 }
 883
 884 static voidunix_attach_fds(struct scm_cookie *scm,struct sk_buff *skb)
 885 {
 886 int i;
 887 for(i=scm->fp->count-1; i>=0; i--)
 888 unix_inflight(scm->fp->fp[i]);
 889 UNIXCB(skb).fp = scm->fp;
 890  skb->destructor = unix_destruct_fds;
 891  scm->fp = NULL;
 892 }
 893
 894
 895 /*
 896  * Send AF_UNIX data.
 897  */
 898
 899 static intunix_dgram_sendmsg(struct socket *sock,struct msghdr *msg,int len,
 900 struct scm_cookie *scm)
 901 {
 902 struct sock *sk = sock->sk;
 903 struct sockaddr_un *sunaddr=msg->msg_name;
 904  unix_socket *other;
 905 int namelen =0;/* fake GCC */
 906 int err;
 907 unsigned hash;
 908 struct sk_buff *skb;
 909
 910 if(msg->msg_flags&MSG_OOB)
 911 return-EOPNOTSUPP;
 912
 913 if(msg->msg_flags&~(MSG_DONTWAIT|MSG_NOSIGNAL))
 914 return-EINVAL;
 915
 916 if(msg->msg_namelen) {
 917  namelen =unix_mkname(sunaddr, msg->msg_namelen, &hash);
 918 if(namelen <0)
 919 return namelen;
 920 }else{
 921  sunaddr = NULL;
 922 if(!unix_peer(sk))
 923 return-ENOTCONN;
 924 }
 925
 926 if(sock->passcred && !sk->protinfo.af_unix.addr)
 927 unix_autobind(sock);
 928
 929  skb =sock_alloc_send_skb(sk, len,0, msg->msg_flags&MSG_DONTWAIT, &err);
 930 if(skb==NULL)
 931 goto out;
 932
 933 memcpy(UNIXCREDS(skb), &scm->creds,sizeof(struct ucred));
 934 UNIXCB(skb).attr = msg->msg_flags;
 935 if(scm->fp)
 936 unix_attach_fds(scm, skb);
 937
 938  skb->h.raw = skb->data;
 939  err =memcpy_fromiovec(skb_put(skb,len), msg->msg_iov, len);
 940 if(err)
 941 goto out_free;
 942
 943  other =unix_peer(sk);
 944 if(other && other->dead)
 945 {
 946 /*
 947  * Check with 1003.1g - what should
 948  * datagram error
 949  */
 950 unix_unlock(other);
 951 unix_peer(sk)=NULL;
 952  other = NULL;
 953  err = -ECONNRESET;
 954 if(sunaddr == NULL)
 955 goto out_free;
 956 }
 957 if(!other)
 958 {
 959  other =unix_find_other(sunaddr, namelen, sk->type, hash, &err);
 960 if(other==NULL)
 961 goto out_free;
 962  err = -EINVAL;
 963 if(!unix_may_send(sk, other))
 964 goto out_unlock;
 965 }
 966
 967 skb_queue_tail(&other->receive_queue, skb);
 968  other->data_ready(other,len);
 969
 970 if(!unix_peer(sk))
 971 unix_unlock(other);
 972 return len;
 973
 974 out_unlock:
 975 unix_unlock(other);
 976 out_free:
 977 kfree_skb(skb);
 978 out:
 979 return err;
 980 }
 981
 982
 983 static intunix_stream_sendmsg(struct socket *sock,struct msghdr *msg,int len,
 984 struct scm_cookie *scm)
 985 {
 986 struct sock *sk = sock->sk;
 987  unix_socket *other;
 988 struct sockaddr_un *sunaddr=msg->msg_name;
 989 int err,size;
 990 struct sk_buff *skb;
 991 int limit=0;
 992 int sent=0;
 993
 994 if(sock->flags & SO_ACCEPTCON)
 995 return(-EINVAL);
 996
 997 if(msg->msg_flags&MSG_OOB)
 998 return-EOPNOTSUPP;
 999
1000 if(msg->msg_flags&~(MSG_DONTWAIT|MSG_NOSIGNAL))
1001 return-EINVAL;
1002
1003 if(msg->msg_namelen) {
1004 if(sk->state==TCP_ESTABLISHED)
1005 return-EISCONN;
1006 else
1007 return-EOPNOTSUPP;
1008 }else{
1009  sunaddr = NULL;
1010 if(!unix_peer(sk))
1011 return-ENOTCONN;
1012 }
1013
1014 if(sk->shutdown&SEND_SHUTDOWN) {
1015 if(!(msg->msg_flags&MSG_NOSIGNAL))
1016 send_sig(SIGPIPE,current,0);
1017 return-EPIPE;
1018 }
1019
1020 while(sent < len)
1021 {
1022 /*
1023  * Optimisation for the fact that under 0.01% of X messages typically
1024  * need breaking up.
1025  */
1026
1027  size=len-sent;
1028
1029 /* Keep two messages in the pipe so it schedules better */
1030 if(size > sk->sndbuf/2-16)
1031  size = sk->sndbuf/2-16;
1032
1033 /*
1034  * Keep to page sized kmalloc()'s as various people
1035  * have suggested. Big mallocs stress the vm too
1036  * much.
1037  */
1038
1039 if(size >4096-16)
1040  limit =4096-16;/* Fall back to a page if we can't grab a big buffer this instant */
1041 else
1042  limit =0;/* Otherwise just grab and wait */
1043
1044 /*
1045  * Grab a buffer
1046  */
1047
1048  skb=sock_alloc_send_skb(sk,size,limit,msg->msg_flags&MSG_DONTWAIT, &err);
1049
1050 if(skb==NULL)
1051 {
1052 if(sent)
1053 goto out;
1054 return err;
1055 }
1056
1057 /*
1058  * If you pass two values to the sock_alloc_send_skb
1059  * it tries to grab the large buffer with GFP_BUFFER
1060  * (which can fail easily), and if it fails grab the
1061  * fallback size buffer which is under a page and will
1062  * succeed. [Alan]
1063  */
1064  size =min(size,skb_tailroom(skb));
1065
1066 memcpy(UNIXCREDS(skb), &scm->creds,sizeof(struct ucred));
1067 UNIXCB(skb).attr = msg->msg_flags;
1068 if(scm->fp)
1069 unix_attach_fds(scm, skb);
1070
1071 if(memcpy_fromiovec(skb_put(skb,size), msg->msg_iov, size)) {
1072 kfree_skb(skb);
1073 if(sent)
1074 goto out;
1075 return-EFAULT;
1076 }
1077
1078  other=unix_peer(sk);
1079
1080 if(other->dead || (sk->shutdown & SEND_SHUTDOWN))
1081 {
1082 kfree_skb(skb);
1083 if(sent)
1084 goto out;
1085 if(!(msg->msg_flags&MSG_NOSIGNAL))
1086 send_sig(SIGPIPE,current,0);
1087 return-EPIPE;
1088 }
1089
1090 skb_queue_tail(&other->receive_queue, skb);
1091  other->data_ready(other,size);
1092  sent+=size;
1093 }
1094 out:
1095 return sent;
1096 }
1097
1098 /*
1099  * Sleep until data has arrive. But check for races..
1100  */
1101
1102 static voidunix_data_wait(unix_socket * sk)
1103 {
1104 if(!skb_peek(&sk->receive_queue))
1105 {
1106  sk->socket->flags |= SO_WAITDATA;
1107 interruptible_sleep_on(sk->sleep);
1108  sk->socket->flags &= ~SO_WAITDATA;
1109 }
1110 }
1111
1112 static intunix_dgram_recvmsg(struct socket *sock,struct msghdr *msg,int size,
1113 int flags,struct scm_cookie *scm)
1114 {
1115 struct sock *sk = sock->sk;
1116 int noblock = flags & MSG_DONTWAIT;
1117 struct sk_buff *skb;
1118 int err;
1119
1120 if(flags&MSG_OOB)
1121 return-EOPNOTSUPP;
1122
1123  msg->msg_namelen =0;
1124
1125  skb =skb_recv_datagram(sk, flags, noblock, &err);
1126 if(!skb)
1127 goto out;
1128
1129 if(msg->msg_name)
1130 {
1131  msg->msg_namelen =sizeof(short);
1132 if(skb->sk->protinfo.af_unix.addr)
1133 {
1134  msg->msg_namelen=skb->sk->protinfo.af_unix.addr->len;
1135 memcpy(msg->msg_name,
1136  skb->sk->protinfo.af_unix.addr->name,
1137  skb->sk->protinfo.af_unix.addr->len);
1138 }
1139 }
1140
1141 if(size > skb->len)
1142  size = skb->len;
1143 else if(size < skb->len)
1144  msg->msg_flags |= MSG_TRUNC;
1145
1146  err =skb_copy_datagram_iovec(skb,0, msg->msg_iov, size);
1147 if(err)
1148 goto out_free;
1149
1150  scm->creds = *UNIXCREDS(skb);
1151
1152 if(!(flags & MSG_PEEK))
1153 {
1154 if(UNIXCB(skb).fp)
1155 unix_detach_fds(scm, skb);
1156 }
1157 else
1158 {
1159 /* It is questionable: on PEEK we could:
1160  - do not return fds - good, but too simple 8)
1161  - return fds, and do not return them on read (old strategy,
1162  apparently wrong)
1163  - clone fds (I choosed it for now, it is the most universal
1164  solution)
1165
1166  POSIX 1003.1g does not actually define this clearly
1167  at all. POSIX 1003.1g doesn't define a lot of things
1168  clearly however!
1169
1170  */
1171 if(UNIXCB(skb).fp)
1172  scm->fp =scm_fp_dup(UNIXCB(skb).fp);
1173 }
1174  err = size;
1175
1176 out_free:
1177 skb_free_datagram(sk,skb);
1178 out:
1179 return err;
1180 }
1181
1182
1183 static intunix_stream_recvmsg(struct socket *sock,struct msghdr *msg,int size,
1184 int flags,struct scm_cookie *scm)
1185 {
1186 struct sock *sk = sock->sk;
1187 int noblock = flags & MSG_DONTWAIT;
1188 struct sockaddr_un *sunaddr=msg->msg_name;
1189 int copied =0;
1190 int check_creds =0;
1191 int target =1;
1192
1193 if(sock->flags & SO_ACCEPTCON)
1194 return(-EINVAL);
1195
1196 if(flags&MSG_OOB)
1197 return-EOPNOTSUPP;
1198 if(flags&MSG_WAITALL)
1199  target = size;
1200
1201
1202  msg->msg_namelen =0;
1203
1204 /* Lock the socket to prevent queue disordering
1205  * while sleeps in memcpy_tomsg
1206  */
1207
1208 down(&sk->protinfo.af_unix.readsem);
1209
1210 do
1211 {
1212 int chunk;
1213 struct sk_buff *skb;
1214
1215  skb=skb_dequeue(&sk->receive_queue);
1216 if(skb==NULL)
1217 {
1218 if(copied >= target)
1219 break;
1220
1221 /*
1222  * POSIX 1003.1g mandates this order.
1223  */
1224
1225 if(sk->err)
1226 {
1227 up(&sk->protinfo.af_unix.readsem);
1228 returnsock_error(sk);
1229 }
1230
1231 if(sk->shutdown & RCV_SHUTDOWN)
1232 break;
1233 up(&sk->protinfo.af_unix.readsem);
1234 if(noblock)
1235 return-EAGAIN;
1236 unix_data_wait(sk);
1237 if(signal_pending(current))
1238 return-ERESTARTSYS;
1239 down(&sk->protinfo.af_unix.readsem);
1240 continue;
1241 }
1242
1243 /* Never glue messages from different writers */
1244 if(check_creds &&
1245 memcmp(UNIXCREDS(skb), &scm->creds,sizeof(scm->creds)) !=0)
1246 {
1247 skb_queue_head(&sk->receive_queue, skb);
1248 break;
1249 }
1250
1251 /* Copy address just once */
1252 if(sunaddr)
1253 {
1254  msg->msg_namelen =sizeof(short);
1255 if(skb->sk->protinfo.af_unix.addr)
1256 {
1257  msg->msg_namelen=skb->sk->protinfo.af_unix.addr->len;
1258 memcpy(sunaddr,
1259  skb->sk->protinfo.af_unix.addr->name,
1260  skb->sk->protinfo.af_unix.addr->len);
1261 }
1262  sunaddr = NULL;
1263 }
1264
1265  chunk =min(skb->len, size);
1266 if(memcpy_toiovec(msg->msg_iov, skb->data, chunk)) {
1267 skb_queue_head(&sk->receive_queue, skb);
1268 if(copied ==0)
1269  copied = -EFAULT;
1270 break;
1271 }
1272  copied += chunk;
1273  size -= chunk;
1274
1275 /* Copy credentials */
1276  scm->creds = *UNIXCREDS(skb);
1277  check_creds =1;
1278
1279 /* Mark read part of skb as used */
1280 if(!(flags & MSG_PEEK))
1281 {
1282 skb_pull(skb, chunk);
1283
1284 if(UNIXCB(skb).fp)
1285 unix_detach_fds(scm, skb);
1286
1287 /* put the skb back if we didn't use it up.. */
1288 if(skb->len)
1289 {
1290 skb_queue_head(&sk->receive_queue, skb);
1291 break;
1292 }
1293
1294 kfree_skb(skb);
1295
1296 if(scm->fp)
1297 break;
1298 }
1299 else
1300 {
1301 /* It is questionable, see note in unix_dgram_recvmsg.
1302
1303  */
1304 if(UNIXCB(skb).fp)
1305  scm->fp =scm_fp_dup(UNIXCB(skb).fp);
1306
1307 /* put message back and return */
1308 skb_queue_head(&sk->receive_queue, skb);
1309 break;
1310 }
1311 }while(size);
1312
1313 up(&sk->protinfo.af_unix.readsem);
1314 return copied;
1315 }
1316
1317 static intunix_shutdown(struct socket *sock,int mode)
1318 {
1319 struct sock *sk = sock->sk;
1320  unix_socket *other=unix_peer(sk);
1321
1322  mode = (mode+1)&(RCV_SHUTDOWN|SEND_SHUTDOWN);
1323
1324 if(mode) {
1325  sk->shutdown |= mode;
1326  sk->state_change(sk);
1327 if(other && sk->type == SOCK_STREAM &&
1328 unix_our_peer(sk, other)) {
1329 int peer_mode =0;
1330
1331 if(mode&RCV_SHUTDOWN)
1332  peer_mode |= SEND_SHUTDOWN;
1333 if(mode&SEND_SHUTDOWN)
1334  peer_mode |= RCV_SHUTDOWN;
1335  other->shutdown |= mode;
1336  other->state_change(other);
1337 }
1338 }
1339 return0;
1340 }
1341
1342
1343 static intunix_ioctl(struct socket *sock,unsigned int cmd,unsigned long arg)
1344 {
1345 struct sock *sk = sock->sk;
1346 long amount=0;
1347
1348 switch(cmd)
1349 {
1350
1351 case TIOCOUTQ:
1352  amount = sk->sndbuf -atomic_read(&sk->wmem_alloc);
1353 if(amount<0)
1354  amount=0;
1355 returnput_user(amount, (int*)arg);
1356 case TIOCINQ:
1357 {
1358 struct sk_buff *skb;
1359 if(sk->state==TCP_LISTEN)
1360 return-EINVAL;
1361 /*
1362  * These two are safe on current systems as
1363  * only user tasks fiddle here
1364  */
1365 if((skb=skb_peek(&sk->receive_queue))!=NULL)
1366  amount=skb->len;
1367 returnput_user(amount, (int*)arg);
1368 }
1369
1370 default:
1371 return-EINVAL;
1372 }
1373 /*NOTREACHED*/
1374 return(0);
1375 }
1376
1377 static unsigned intunix_poll(struct file * file,struct socket *sock, poll_table *wait)
1378 {
1379 struct sock *sk = sock->sk;
1380 unsigned int mask;
1381
1382 poll_wait(file, sk->sleep, wait);
1383  mask =0;
1384
1385 /* exceptional events? */
1386 if(sk->err)
1387  mask |= POLLERR;
1388 if(sk->shutdown & RCV_SHUTDOWN)
1389  mask |= POLLHUP;
1390
1391 /* readable? */
1392 if(!skb_queue_empty(&sk->receive_queue))
1393  mask |= POLLIN | POLLRDNORM;
1394
1395 /* Connection-based need to check for termination and startup */
1396 if(sk->type == SOCK_STREAM && sk->state==TCP_CLOSE)
1397  mask |= POLLHUP;
1398
1399 /*
1400  * we set writable also when the other side has shut down the
1401  * connection. This prevents stuck sockets.
1402  */
1403 if(sk->sndbuf - (int)atomic_read(&sk->wmem_alloc) >= MIN_WRITE_SPACE)
1404  mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
1405
1406 return mask;
1407 }
1408
1409 static voidunix_stream_write_space(struct sock *sk)
1410 {
1411 if(sk->dead)
1412 return;
1413 wake_up_interruptible(sk->sleep);
1414 if(sk->sndbuf - (int)atomic_read(&sk->wmem_alloc) >= MIN_WRITE_SPACE)
1415 sock_wake_async(sk->socket,2);
1416 }
1417
1418 #ifdef CONFIG_PROC_FS
1419 static intunix_read_proc(char*buffer,char**start, off_t offset,
1420 int length,int*eof,void*data)
1421 {
1422  off_t pos=0;
1423  off_t begin=0;
1424 int len=0;
1425 int i;
1426  unix_socket *s;
1427
1428  len+=sprintf(buffer,"Num RefCount Protocol Flags Type St "
1429 "Inode Path\n");
1430
1431 forall_unix_sockets(i,s)
1432 {
1433  len+=sprintf(buffer+len,"%p: %08X %08X %08lX %04X %02X %5ld",
1434  s,
1435 atomic_read(&s->sock_readers),
1436 0,
1437  s->socket ? s->socket->flags :0,
1438  s->type,
1439  s->socket ? s->socket->state :
1440 (s->state == TCP_ESTABLISHED ?
1441  SS_CONNECTING : SS_DISCONNECTING),
1442  s->socket ? s->socket->inode->i_ino :0);
1443
1444 if(s->protinfo.af_unix.addr)
1445 {
1446  buffer[len++] =' ';
1447 memcpy(buffer+len, s->protinfo.af_unix.addr->name->sun_path,
1448  s->protinfo.af_unix.addr->len-sizeof(short));
1449 if(!UNIX_ABSTRACT(s))
1450  len--;
1451 else
1452  buffer[len] ='@';
1453  len += s->protinfo.af_unix.addr->len -sizeof(short);
1454 }
1455  buffer[len++]='\n';
1456
1457  pos = begin + len;
1458 if(pos<offset)
1459 {
1460  len=0;
1461  begin=pos;
1462 }
1463 if(pos>offset+length)
1464 goto done;
1465 }
1466 *eof =1;
1467 done:
1468 *start=buffer+(offset-begin);
1469  len-=(offset-begin);
1470 if(len>length)
1471  len=length;
1472 if(len <0)
1473  len =0;
1474 return len;
1475 }
1476 #endif
1477
1478 struct proto_ops unix_stream_ops = {
1479  PF_UNIX,
1480
1481  sock_no_dup,
1482  unix_release,
1483  unix_bind,
1484  unix_stream_connect,
1485  unix_socketpair,
1486  unix_accept,
1487  unix_getname,
1488  unix_poll,
1489  unix_ioctl,
1490  unix_listen,
1491  unix_shutdown,
1492  sock_no_setsockopt,
1493  sock_no_getsockopt,
1494  sock_no_fcntl,
1495  unix_stream_sendmsg,
1496  unix_stream_recvmsg
1497 };
1498
1499 struct proto_ops unix_dgram_ops = {
1500  PF_UNIX,
1501
1502  sock_no_dup,
1503  unix_release,
1504  unix_bind,
1505  unix_dgram_connect,
1506  unix_socketpair,
1507  sock_no_accept,
1508  unix_getname,
1509  datagram_poll,
1510  unix_ioctl,
1511  sock_no_listen,
1512  unix_shutdown,
1513  sock_no_setsockopt,
1514  sock_no_getsockopt,
1515  sock_no_fcntl,
1516  unix_dgram_sendmsg,
1517  unix_dgram_recvmsg
1518 };
1519
1520 struct net_proto_family unix_family_ops = {
1521  PF_UNIX,
1522  unix_create
1523 };
1524
1525 #ifdef MODULE
1526 #ifdef CONFIG_SYSCTL
1527 externvoidunix_sysctl_register(void);
1528 externvoidunix_sysctl_unregister(void);
1529 #endif
1530
1531 intinit_module(void)
1532 #else
1533 __initfunc(voidunix_proto_init(struct net_proto *pro))
1534 #endif
1535 {
1536 struct sk_buff *dummy_skb;
1537 struct proc_dir_entry *ent;
1538
1539 printk(KERN_INFO "NET3: Unix domain sockets 0.16 for Linux NET3.038.\n");
1540 if(sizeof(struct unix_skb_parms) >sizeof(dummy_skb->cb))
1541 {
1542 printk(KERN_CRIT "unix_proto_init: panic\n");
1543 #ifdef MODULE
1544 return-1;
1545 #else
1546 return;
1547 #endif
1548 }
1549 sock_register(&unix_family_ops);
1550 #ifdef CONFIG_PROC_FS
1551  ent =create_proc_entry("net/unix",0,0);
1552  ent->read_proc = unix_read_proc;
1553 #endif
1554
1555 #ifdef MODULE
1556 #ifdef CONFIG_SYSCTL
1557 unix_sysctl_register();
1558 #endif
1559
1560 return0;
1561 #endif
1562 }
1563
1564 #ifdef MODULE
1565 voidcleanup_module(void)
1566 {
1567 sock_unregister(PF_UNIX);
1568 #ifdef CONFIG_SYSCTL
1569 unix_sysctl_unregister();
1570 #endif
1571 #ifdef CONFIG_PROC_FS
1572 remove_proc_entry("net/unix",0);
1573 #endif
1574 }
1575 #endif
1576
1577 /*
1578  * Local variables:
1579  * compile-command: "gcc -g -D__KERNEL__ -Wall -O6 -I/usr/src/linux/include -c af_unix.c"
1580  * End:
1581  */