![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to socket.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Early Linux] / linux / net|
Return to socket.c CVS log | Up to [Early Linux] / linux / net |
1.1 ! root 1: #include <signal.h> ! 2: #include <errno.h> ! 3: #include <linux/sched.h> ! 4: #include <linux/kernel.h> ! 5: #include <asm/system.h> ! 6: #include <asm/segment.h> ! 7: #include <sys/socket.h> ! 8: #include <sys/stat.h> ! 9: #include <fcntl.h> ! 10: #include <termios.h> ! 11: #include "kern_sock.h" ! 12: #include "socketcall.h" ! 13: ! 14: extern int sys_close(int fd); ! 15: ! 16: extern struct proto_ops unix_proto_ops; ! 17: ! 18: static struct { ! 19: short family; ! 20: char *name; ! 21: struct proto_ops *ops; ! 22: } proto_table[] = { ! 23: AF_UNIX, "AF_UNIX", &unix_proto_ops ! 24: }; ! 25: #define NPROTO (sizeof(proto_table) / sizeof(proto_table[0])) ! 26: ! 27: static char * ! 28: family_name(int family) ! 29: { ! 30: int i; ! 31: ! 32: for (i = 0; i < NPROTO; ++i) ! 33: if (proto_table[i].family == family) ! 34: return proto_table[i].name; ! 35: return "UNKNOWN"; ! 36: } ! 37: ! 38: static int sock_lseek(struct inode *inode, struct file *file, off_t offset, ! 39: int whence); ! 40: static int sock_read(struct inode *inode, struct file *file, char *buf, ! 41: int size); ! 42: static int sock_write(struct inode *inode, struct file *file, char *buf, ! 43: int size); ! 44: static int sock_readdir(struct inode *inode, struct file *file, ! 45: struct dirent *dirent, int count); ! 46: static void sock_close(struct inode *inode, struct file *file); ! 47: /*static*/ int sock_select(struct inode *inode, struct file *file, int which, ! 48: select_table *seltable); ! 49: static int sock_ioctl(struct inode *inode, struct file *file, ! 50: unsigned int cmd, unsigned int arg); ! 51: ! 52: static struct file_operations socket_file_ops = { ! 53: sock_lseek, ! 54: sock_read, ! 55: sock_write, ! 56: sock_readdir, ! 57: sock_select, /* not in vfs yet */ ! 58: sock_ioctl, ! 59: NULL, /* no special open code... */ ! 60: sock_close ! 61: }; ! 62: ! 63: #define SOCK_INODE(S) ((struct inode *)(S)->dummy) ! 64: ! 65: static struct socket sockets[NSOCKETS]; ! 66: #define last_socket (sockets + NSOCKETS - 1) ! 67: static struct task_struct *socket_wait_free = NULL; ! 68: ! 69: /* ! 70: * obtains the first available file descriptor and sets it up for use ! 71: */ ! 72: static int ! 73: get_fd(struct inode *inode) ! 74: { ! 75: int fd, i; ! 76: struct file *file; ! 77: ! 78: /* ! 79: * find a file descriptor suitable for return to the user. ! 80: */ ! 81: for (fd = 0; fd < NR_OPEN; ++fd) ! 82: if (!current->filp[fd]) ! 83: break; ! 84: if (fd == NR_OPEN) ! 85: return -1; ! 86: current->close_on_exec &= ~(1 << fd); ! 87: for (file = file_table, i = 0; i < NR_FILE; ++i, ++file) ! 88: if (!file->f_count) ! 89: break; ! 90: if (i == NR_FILE) ! 91: return -1; ! 92: current->filp[fd] = file; ! 93: file->f_op = &socket_file_ops; ! 94: file->f_mode = 3; ! 95: file->f_flags = 0; ! 96: file->f_count = 1; ! 97: file->f_inode = inode; ! 98: file->f_pos = 0; ! 99: return fd; ! 100: } ! 101: ! 102: /* ! 103: * reverses the action of get_fd() by releasing the file. it closes the ! 104: * descriptor, but makes sure it does nothing more. called when an incomplete ! 105: * socket must be closed, along with sock_release(). ! 106: */ ! 107: static inline void ! 108: toss_fd(int fd) ! 109: { ! 110: current->filp[fd]->f_inode = NULL; /* safe from iput */ ! 111: sys_close(fd); ! 112: } ! 113: ! 114: static inline struct socket * ! 115: socki_lookup(struct inode *inode) ! 116: { ! 117: struct socket *sock; ! 118: ! 119: for (sock = sockets; sock <= last_socket; ++sock) ! 120: if (sock->state != SS_FREE && SOCK_INODE(sock) == inode) ! 121: return sock; ! 122: return NULL; ! 123: } ! 124: ! 125: static inline struct socket * ! 126: sockfd_lookup(int fd, struct file **pfile) ! 127: { ! 128: struct file *file; ! 129: ! 130: if (fd < 0 || fd >= NR_OPEN || !(file = current->filp[fd])) ! 131: return NULL; ! 132: if (pfile) ! 133: *pfile = file; ! 134: return socki_lookup(file->f_inode); ! 135: } ! 136: ! 137: static struct socket * ! 138: sock_alloc(int wait) ! 139: { ! 140: struct socket *sock; ! 141: ! 142: while (1) { ! 143: cli(); ! 144: for (sock = sockets; sock <= last_socket; ++sock) ! 145: if (sock->state == SS_FREE) { ! 146: sock->state = SS_UNCONNECTED; ! 147: sti(); ! 148: sock->flags = 0; ! 149: sock->ops = NULL; ! 150: sock->data = NULL; ! 151: sock->conn = NULL; ! 152: sock->iconn = NULL; ! 153: /* ! 154: * this really shouldn't be necessary, but ! 155: * everything else depends on inodes, so we ! 156: * grab it. ! 157: * sleeps are also done on the i_wait member ! 158: * of this inode. ! 159: * the close system call will iput this inode ! 160: * for us. ! 161: */ ! 162: if (!(SOCK_INODE(sock) = get_empty_inode())) { ! 163: printk("sock_alloc: no more inodes\n"); ! 164: sock->state = SS_FREE; ! 165: return NULL; ! 166: } ! 167: SOCK_INODE(sock)->i_mode = S_IFSOCK; ! 168: sock->wait = &SOCK_INODE(sock)->i_wait; ! 169: PRINTK("sock_alloc: socket 0x%x, inode 0x%x\n", ! 170: sock, SOCK_INODE(sock)); ! 171: return sock; ! 172: } ! 173: sti(); ! 174: if (!wait) ! 175: return NULL; ! 176: PRINTK("sock_alloc: no free sockets, sleeping...\n"); ! 177: interruptible_sleep_on(&socket_wait_free); ! 178: if (current->signal & ~current->blocked) { ! 179: PRINTK("sock_alloc: sleep was interrupted\n"); ! 180: return NULL; ! 181: } ! 182: PRINTK("sock_alloc: wakeup... trying again...\n"); ! 183: } ! 184: } ! 185: ! 186: static inline void ! 187: sock_release_peer(struct socket *peer) ! 188: { ! 189: peer->state = SS_DISCONNECTING; ! 190: wake_up(peer->wait); ! 191: } ! 192: ! 193: static void ! 194: sock_release(struct socket *sock) ! 195: { ! 196: int oldstate; ! 197: struct socket *peersock, *nextsock; ! 198: ! 199: PRINTK("sock_release: socket 0x%x, inode 0x%x\n", sock, ! 200: SOCK_INODE(sock)); ! 201: if ((oldstate = sock->state) != SS_UNCONNECTED) ! 202: sock->state = SS_DISCONNECTING; ! 203: /* ! 204: * wake up anyone waiting for connections ! 205: */ ! 206: for (peersock = sock->iconn; peersock; peersock = nextsock) { ! 207: nextsock = peersock->next; ! 208: sock_release_peer(peersock); ! 209: } ! 210: /* ! 211: * wake up anyone we're connected to. first, we release the ! 212: * protocol, to give it a chance to flush data, etc. ! 213: */ ! 214: peersock = (oldstate == SS_CONNECTED) ? sock->conn : NULL; ! 215: if (sock->ops) ! 216: sock->ops->release(sock, peersock); ! 217: if (peersock) ! 218: sock_release_peer(peersock); ! 219: sock->state = SS_FREE; /* this really releases us */ ! 220: wake_up(&socket_wait_free); ! 221: } ! 222: ! 223: static int ! 224: sock_lseek(struct inode *inode, struct file *file, off_t offset, int whence) ! 225: { ! 226: PRINTK("sock_lseek: huh?\n"); ! 227: return -EBADF; ! 228: } ! 229: ! 230: static int ! 231: sock_read(struct inode *inode, struct file *file, char *ubuf, int size) ! 232: { ! 233: struct socket *sock; ! 234: ! 235: PRINTK("sock_read: buf=0x%x, size=%d\n", ubuf, size); ! 236: if (!(sock = socki_lookup(inode))) { ! 237: printk("sock_read: can't find socket for inode!\n"); ! 238: return -EBADF; ! 239: } ! 240: if (sock->flags & SO_ACCEPTCON) ! 241: return -EINVAL; ! 242: return sock->ops->read(sock, ubuf, size, (file->f_flags & O_NONBLOCK)); ! 243: } ! 244: ! 245: static int ! 246: sock_write(struct inode *inode, struct file *file, char *ubuf, int size) ! 247: { ! 248: struct socket *sock; ! 249: ! 250: PRINTK("sock_write: buf=0x%x, size=%d\n", ubuf, size); ! 251: if (!(sock = socki_lookup(inode))) { ! 252: printk("sock_write: can't find socket for inode!\n"); ! 253: return -EBADF; ! 254: } ! 255: if (sock->flags & SO_ACCEPTCON) ! 256: return -EINVAL; ! 257: return sock->ops->write(sock, ubuf, size,(file->f_flags & O_NONBLOCK)); ! 258: } ! 259: ! 260: static int ! 261: sock_readdir(struct inode *inode, struct file *file, struct dirent *dirent, ! 262: int count) ! 263: { ! 264: PRINTK("sock_readdir: huh?\n"); ! 265: return -EBADF; ! 266: } ! 267: ! 268: int ! 269: sock_ioctl(struct inode *inode, struct file *file, unsigned int cmd, ! 270: unsigned int arg) ! 271: { ! 272: struct socket *sock; ! 273: ! 274: PRINTK("sock_ioctl: inode=0x%x cmd=0x%x arg=%d\n", inode, cmd, arg); ! 275: if (!(sock = socki_lookup(inode))) { ! 276: printk("sock_ioctl: can't find socket for inode!\n"); ! 277: return -EBADF; ! 278: } ! 279: switch (cmd) { ! 280: case TIOCINQ: ! 281: case TIOCOUTQ: ! 282: if (sock->flags & SO_ACCEPTCON) ! 283: return -EINVAL; ! 284: break; ! 285: ! 286: default: ! 287: return -EINVAL; ! 288: } ! 289: return sock->ops->ioctl(sock, cmd, arg); ! 290: } ! 291: ! 292: /*static*/ int ! 293: sock_select(struct inode *inode, struct file *file, int which, ! 294: select_table *seltable) ! 295: { ! 296: struct socket *sock; ! 297: ! 298: PRINTK("sock_select: inode = 0x%x, kind = %s\n", inode, ! 299: (which == SEL_IN) ? "in" : ! 300: (which == SEL_OUT) ? "out" : "ex"); ! 301: if (!(sock = socki_lookup(inode))) { ! 302: printk("sock_write: can't find socket for inode!\n"); ! 303: return -EBADF; ! 304: } ! 305: ! 306: /* ! 307: * handle server sockets specially ! 308: */ ! 309: if (sock->flags & SO_ACCEPTCON) { ! 310: if (which == SEL_IN) { ! 311: PRINTK("sock_select: %sconnections pending\n", ! 312: sock->iconn ? "" : "no "); ! 313: return sock->iconn ? 1 : 0; ! 314: } ! 315: PRINTK("sock_select: nothing else for server socket\n"); ! 316: return 0; ! 317: } ! 318: ! 319: /* ! 320: * we can't return errors to select, so its either yes or no. ! 321: */ ! 322: return sock->ops->select(sock, which) ? 1 : 0; ! 323: } ! 324: ! 325: void ! 326: sock_close(struct inode *inode, struct file *file) ! 327: { ! 328: struct socket *sock; ! 329: ! 330: PRINTK("sock_close: inode=0x%x (cnt=%d)\n", inode, inode->i_count); ! 331: /* ! 332: * it's possible the inode is NULL if we're closing an unfinished ! 333: * socket. ! 334: */ ! 335: if (!inode) ! 336: return; ! 337: if (!(sock = socki_lookup(inode))) { ! 338: printk("sock_close: can't find socket for inode!\n"); ! 339: return; ! 340: } ! 341: sock_release(sock); ! 342: } ! 343: ! 344: int ! 345: sock_awaitconn(struct socket *mysock, struct socket *servsock) ! 346: { ! 347: struct socket *last; ! 348: ! 349: PRINTK("sock_awaitconn: trying to connect socket 0x%x to 0x%x\n", ! 350: mysock, servsock); ! 351: if (!(servsock->flags & SO_ACCEPTCON)) { ! 352: PRINTK("sock_awaitconn: server not accepting connections\n"); ! 353: return -EINVAL; ! 354: } ! 355: ! 356: /* ! 357: * put ourselves on the server's incomplete connection queue. ! 358: */ ! 359: mysock->next = NULL; ! 360: cli(); ! 361: if (!(last = servsock->iconn)) ! 362: servsock->iconn = mysock; ! 363: else { ! 364: while (last->next) ! 365: last = last->next; ! 366: last->next = mysock; ! 367: } ! 368: mysock->state = SS_CONNECTING; ! 369: mysock->conn = servsock; ! 370: sti(); ! 371: ! 372: /* ! 373: * wake up server, then await connection. server will set state to ! 374: * SS_CONNECTED if we're connected. ! 375: */ ! 376: wake_up(servsock->wait); ! 377: if (mysock->state != SS_CONNECTED) { ! 378: interruptible_sleep_on(mysock->wait); ! 379: if (mysock->state != SS_CONNECTED) { ! 380: /* ! 381: * if we're not connected we could have been ! 382: * 1) interrupted, so we need to remove ourselves ! 383: * from the server list ! 384: * 2) rejected (mysock->conn == NULL), and have ! 385: * already been removed from the list ! 386: */ ! 387: if (mysock->conn == servsock) { ! 388: cli(); ! 389: if ((last = servsock->iconn) == mysock) ! 390: servsock->iconn = mysock->next; ! 391: else { ! 392: while (last->next != mysock) ! 393: last = last->next; ! 394: last->next = mysock->next; ! 395: } ! 396: sti(); ! 397: } ! 398: return mysock->conn ? -EINTR : -EACCES; ! 399: } ! 400: } ! 401: return 0; ! 402: } ! 403: ! 404: /* ! 405: * perform the socket system call. we locate the appropriate family, then ! 406: * create a fresh socket. ! 407: */ ! 408: static int ! 409: sock_socket(int family, int type, int protocol) ! 410: { ! 411: int i, fd; ! 412: struct socket *sock; ! 413: struct proto_ops *ops; ! 414: ! 415: PRINTK("sys_socket: family = %d (%s), type = %d, protocol = %d\n", ! 416: family, family_name(family), type, protocol); ! 417: ! 418: /* ! 419: * locate the correct protocol family ! 420: */ ! 421: for (i = 0; i < NPROTO; ++i) ! 422: if (proto_table[i].family == family) ! 423: break; ! 424: if (i == NPROTO) { ! 425: PRINTK("sys_socket: family not found\n"); ! 426: return -EINVAL; ! 427: } ! 428: ops = proto_table[i].ops; ! 429: ! 430: /* ! 431: * check that this is a type that we know how to manipulate and ! 432: * the protocol makes sense here. the family can still reject the ! 433: * protocol later. ! 434: */ ! 435: if ((type != SOCK_STREAM && ! 436: type != SOCK_DGRAM && ! 437: type != SOCK_SEQPACKET && ! 438: type != SOCK_RAW) || ! 439: protocol < 0) ! 440: return -EINVAL; ! 441: ! 442: /* ! 443: * allocate the socket and allow the family to set things up. if ! 444: * the protocol is 0, the family is instructed to select an appropriate ! 445: * default. ! 446: */ ! 447: if (!(sock = sock_alloc(1))) { ! 448: printk("sys_socket: no more sockets\n"); ! 449: return -EAGAIN; ! 450: } ! 451: sock->type = type; ! 452: sock->ops = ops; ! 453: if ((i = sock->ops->create(sock, protocol)) < 0) { ! 454: sock_release(sock); ! 455: return i; ! 456: } ! 457: ! 458: if ((fd = get_fd(SOCK_INODE(sock))) < 0) { ! 459: sock_release(sock); ! 460: return -EINVAL; ! 461: } ! 462: ! 463: return fd; ! 464: } ! 465: ! 466: static int ! 467: sock_socketpair(int family, int type, int protocol, int usockvec[2]) ! 468: { ! 469: int fd1, fd2, i; ! 470: struct socket *sock1, *sock2; ! 471: ! 472: PRINTK("sys_socketpair: family = %d, type = %d, protocol = %d\n", ! 473: family, type, protocol); ! 474: ! 475: /* ! 476: * obtain the first socket and check if the underlying protocol ! 477: * supports the socketpair call ! 478: */ ! 479: if ((fd1 = sock_socket(family, type, protocol)) < 0) ! 480: return fd1; ! 481: sock1 = sockfd_lookup(fd1, NULL); ! 482: if (!sock1->ops->socketpair) { ! 483: sys_close(fd1); ! 484: return -EINVAL; ! 485: } ! 486: ! 487: /* ! 488: * now grab another socket and try to connect the two together ! 489: */ ! 490: if ((fd2 = sock_socket(family, type, protocol)) < 0) { ! 491: sys_close(fd1); ! 492: return -EINVAL; ! 493: } ! 494: sock2 = sockfd_lookup(fd2, NULL); ! 495: if ((i = sock1->ops->socketpair(sock1, sock2)) < 0) { ! 496: sys_close(fd1); ! 497: sys_close(fd2); ! 498: return i; ! 499: } ! 500: sock1->conn = sock2; ! 501: sock2->conn = sock1; ! 502: sock1->state = SS_CONNECTED; ! 503: sock2->state = SS_CONNECTED; ! 504: ! 505: verify_area(usockvec, 2 * sizeof(int)); ! 506: put_fs_long(fd1, &usockvec[0]); ! 507: put_fs_long(fd2, &usockvec[1]); ! 508: ! 509: return 0; ! 510: } ! 511: ! 512: /* ! 513: * binds a name to a socket. nothing much to do here since its the ! 514: * protocol's responsibility to handle the local address ! 515: */ ! 516: static int ! 517: sock_bind(int fd, struct sockaddr *umyaddr, int addrlen) ! 518: { ! 519: struct socket *sock; ! 520: int i; ! 521: ! 522: PRINTK("sys_bind: fd = %d\n", fd); ! 523: if (!(sock = sockfd_lookup(fd, NULL))) ! 524: return -EBADF; ! 525: if ((i = sock->ops->bind(sock, umyaddr, addrlen)) < 0) { ! 526: PRINTK("sys_bind: bind failed\n"); ! 527: return i; ! 528: } ! 529: return 0; ! 530: } ! 531: ! 532: /* ! 533: * perform a listen. basically, we allow the protocol to do anything ! 534: * necessary for a listen, and if that works, we mark the socket as ! 535: * ready for listening. ! 536: */ ! 537: static int ! 538: sock_listen(int fd, int backlog) ! 539: { ! 540: struct socket *sock; ! 541: ! 542: PRINTK("sys_listen: fd = %d\n", fd); ! 543: if (!(sock = sockfd_lookup(fd, NULL))) ! 544: return -EBADF; ! 545: if (sock->state != SS_UNCONNECTED) { ! 546: PRINTK("sys_listen: socket isn't unconnected\n"); ! 547: return -EINVAL; ! 548: } ! 549: if (sock->flags & SO_ACCEPTCON) { ! 550: PRINTK("sys_listen: socket already accepting connections!\n"); ! 551: return -EINVAL; ! 552: } ! 553: sock->flags |= SO_ACCEPTCON; ! 554: return 0; ! 555: } ! 556: ! 557: /* ! 558: * for accept, we attempt to create a new socket, set up the link with the ! 559: * client, wake up the client, then return the new connected fd. ! 560: */ ! 561: static int ! 562: sock_accept(int fd, struct sockaddr *upeer_sockaddr, int *upeer_addrlen) ! 563: { ! 564: struct file *file; ! 565: struct socket *sock, *clientsock, *newsock; ! 566: int i; ! 567: ! 568: PRINTK("sys_accept: fd = %d\n", fd); ! 569: if (!(sock = sockfd_lookup(fd, &file))) ! 570: return -EBADF; ! 571: if (sock->state != SS_UNCONNECTED) { ! 572: PRINTK("sys_accept: socket isn't unconnected\n"); ! 573: return -EINVAL; ! 574: } ! 575: if (!(sock->flags & SO_ACCEPTCON)) { ! 576: PRINTK("sys_accept: socket not accepting connections!\n"); ! 577: return -EINVAL; ! 578: } ! 579: ! 580: /* ! 581: * if there aren't any sockets awaiting connection, then wait for ! 582: * one, unless nonblocking ! 583: */ ! 584: while (!(clientsock = sock->iconn)) { ! 585: if (file->f_flags & O_NONBLOCK) ! 586: return -EAGAIN; ! 587: interruptible_sleep_on(sock->wait); ! 588: if (current->signal & ~current->blocked) { ! 589: PRINTK("sys_accept: sleep was interrupted\n"); ! 590: return -EINTR; ! 591: } ! 592: } ! 593: ! 594: if (!(newsock = sock_alloc(0))) { ! 595: printk("sys_accept: no more sockets\n"); ! 596: return -EINVAL; ! 597: } ! 598: newsock->type = sock->type; ! 599: newsock->ops = sock->ops; ! 600: if ((i = sock->ops->dup(newsock, sock)) < 0) { ! 601: sock_release(newsock); ! 602: return i; ! 603: } ! 604: ! 605: if ((fd = get_fd(SOCK_INODE(newsock))) < 0) { ! 606: sock_release(newsock); ! 607: return -EINVAL; ! 608: } ! 609: ! 610: /* ! 611: * great. finish the connection relative to server and client, ! 612: * wake up the client and return the new fd to the server ! 613: */ ! 614: sock->iconn = clientsock->next; ! 615: clientsock->next = NULL; ! 616: newsock->conn = clientsock; ! 617: clientsock->conn = newsock; ! 618: clientsock->state = SS_CONNECTED; ! 619: newsock->state = SS_CONNECTED; ! 620: newsock->ops->accept(sock, newsock); ! 621: PRINTK("sys_accept: connected socket 0x%x via 0x%x to 0x%x\n", ! 622: sock, newsock, clientsock); ! 623: if (upeer_sockaddr) ! 624: newsock->ops->getname(newsock, upeer_sockaddr, ! 625: upeer_addrlen, 1); ! 626: wake_up(clientsock->wait); ! 627: ! 628: return fd; ! 629: } ! 630: ! 631: /* ! 632: * attempt to connect to a socket with the server address. ! 633: */ ! 634: static int ! 635: sock_connect(int fd, struct sockaddr *uservaddr, int addrlen) ! 636: { ! 637: struct socket *sock; ! 638: int i; ! 639: ! 640: PRINTK("sys_connect: fd = %d\n", fd); ! 641: if (!(sock = sockfd_lookup(fd, NULL))) ! 642: return -EBADF; ! 643: if (sock->state != SS_UNCONNECTED) { ! 644: PRINTK("sys_connect: socket not unconnected\n"); ! 645: return -EINVAL; ! 646: } ! 647: if ((i = sock->ops->connect(sock, uservaddr, addrlen)) < 0) { ! 648: PRINTK("sys_connect: connect failed\n"); ! 649: return i; ! 650: } ! 651: return 0; ! 652: } ! 653: ! 654: static int ! 655: sock_getsockname(int fd, struct sockaddr *usockaddr, int *usockaddr_len) ! 656: { ! 657: struct socket *sock; ! 658: ! 659: PRINTK("sys_getsockname: fd = %d\n", fd); ! 660: if (!(sock = sockfd_lookup(fd, NULL))) ! 661: return -EBADF; ! 662: return sock->ops->getname(sock, usockaddr, usockaddr_len, 0); ! 663: } ! 664: ! 665: static int ! 666: sock_getpeername(int fd, struct sockaddr *usockaddr, int *usockaddr_len) ! 667: { ! 668: struct socket *sock; ! 669: ! 670: PRINTK("sys_getpeername: fd = %d\n", fd); ! 671: if (!(sock = sockfd_lookup(fd, NULL))) ! 672: return -EBADF; ! 673: return sock->ops->getname(sock, usockaddr, usockaddr_len, 1); ! 674: } ! 675: ! 676: /* ! 677: * system call vectors. since i want to rewrite sockets as streams, we have ! 678: * this level of indirection. not a lot of overhead, since more of the work is ! 679: * done via read/write/select directly ! 680: */ ! 681: int ! 682: sys_socketcall(int call, unsigned long *args) ! 683: { ! 684: switch (call) { ! 685: case SYS_SOCKET: ! 686: verify_area(args, 3 * sizeof(long)); ! 687: return sock_socket(get_fs_long(args+0), ! 688: get_fs_long(args+1), ! 689: get_fs_long(args+2)); ! 690: ! 691: case SYS_BIND: ! 692: verify_area(args, 3 * sizeof(long)); ! 693: return sock_bind(get_fs_long(args+0), ! 694: (struct sockaddr *)get_fs_long(args+1), ! 695: get_fs_long(args+2)); ! 696: ! 697: case SYS_CONNECT: ! 698: verify_area(args, 3 * sizeof(long)); ! 699: return sock_connect(get_fs_long(args+0), ! 700: (struct sockaddr *)get_fs_long(args+1), ! 701: get_fs_long(args+2)); ! 702: ! 703: case SYS_LISTEN: ! 704: verify_area(args, 2 * sizeof(long)); ! 705: return sock_listen(get_fs_long(args+0), ! 706: get_fs_long(args+1)); ! 707: ! 708: case SYS_ACCEPT: ! 709: verify_area(args, 3 * sizeof(long)); ! 710: return sock_accept(get_fs_long(args+0), ! 711: (struct sockaddr *)get_fs_long(args+1), ! 712: (int *)get_fs_long(args+2)); ! 713: ! 714: case SYS_GETSOCKNAME: ! 715: verify_area(args, 3 * sizeof(long)); ! 716: return sock_getsockname(get_fs_long(args+0), ! 717: (struct sockaddr *)get_fs_long(args+1), ! 718: (int *)get_fs_long(args+2)); ! 719: ! 720: case SYS_GETPEERNAME: ! 721: verify_area(args, 3 * sizeof(long)); ! 722: return sock_getpeername(get_fs_long(args+0), ! 723: (struct sockaddr *)get_fs_long(args+1), ! 724: (int *)get_fs_long(args+2)); ! 725: ! 726: case SYS_SOCKETPAIR: ! 727: verify_area(args, 4 * sizeof(long)); ! 728: return sock_socketpair(get_fs_long(args+0), ! 729: get_fs_long(args+1), ! 730: get_fs_long(args+2), ! 731: (int *)get_fs_long(args+3)); ! 732: ! 733: default: ! 734: return -EINVAL; ! 735: } ! 736: } ! 737: ! 738: void ! 739: sock_init(void) ! 740: { ! 741: struct socket *sock; ! 742: int i, ok; ! 743: ! 744: for (sock = sockets; sock <= last_socket; ++sock) ! 745: sock->state = SS_FREE; ! 746: for (i = ok = 0; i < NPROTO; ++i) { ! 747: printk("sock_init: initializing family %d (%s)\n", ! 748: proto_table[i].family, proto_table[i].name); ! 749: if ((*proto_table[i].ops->init)() < 0) { ! 750: printk("sock_init: init failed.\n", ! 751: proto_table[i].family); ! 752: proto_table[i].family = -1; ! 753: } ! 754: else ! 755: ++ok; ! 756: } ! 757: if (!ok) ! 758: printk("sock_init: warning: no protocols initialized\n"); ! 759: return; ! 760: } ! 761:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.