home *** CD-ROM | disk | FTP | other *** search
/ Il CD di internet / CD.iso / SOURCE / KERNEL-S / V1.0 / LINUX-1.0 / LINUX-1 / linux / net / socket.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-01-31  |  27.8 KB  |  1,095 lines
  1. /*
  2.  * NET        An implementation of the SOCKET network access protocol.
  3.  *
  4.  * Version:    @(#)socket.c    1.0.5    05/25/93
  5.  *
  6.  * Authors:    Orest Zborowski, <obz@Kodak.COM>
  7.  *        Ross Biro, <bir7@leland.Stanford.Edu>
  8.  *        Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
  9.  *
  10.  * Fixes:
  11.  *        Anonymous    :    NOTSOCK/BADF cleanup. Error fix in
  12.  *                    shutdown()
  13.  *        Alan Cox    :    verify_area() fixes
  14.  *
  15.  *
  16.  *        This program is free software; you can redistribute it and/or
  17.  *        modify it under the terms of the GNU General Public License
  18.  *        as published by the Free Software Foundation; either version
  19.  *        2 of the License, or (at your option) any later version.
  20.  */
  21.  
  22. #include <linux/config.h>
  23. #include <linux/signal.h>
  24. #include <linux/errno.h>
  25. #include <linux/sched.h>
  26. #include <linux/kernel.h>
  27. #include <linux/major.h>
  28. #include <linux/stat.h>
  29. #include <linux/socket.h>
  30. #include <linux/fcntl.h>
  31. #include <linux/net.h>
  32. #include <linux/ddi.h>
  33.  
  34. #include <asm/system.h>
  35. #include <asm/segment.h>
  36.  
  37. #undef SOCK_DEBUG
  38.  
  39. #ifdef SOCK_DEBUG
  40. #include <stdarg.h>
  41. #define DPRINTF(x) dprintf x
  42. #else
  43. #define DPRINTF(x) /**/
  44. #endif
  45.  
  46. static int sock_lseek(struct inode *inode, struct file *file, off_t offset,
  47.               int whence);
  48. static int sock_read(struct inode *inode, struct file *file, char *buf,
  49.              int size);
  50. static int sock_write(struct inode *inode, struct file *file, char *buf,
  51.               int size);
  52. static int sock_readdir(struct inode *inode, struct file *file,
  53.             struct dirent *dirent, int count);
  54. static void sock_close(struct inode *inode, struct file *file);
  55. static int sock_select(struct inode *inode, struct file *file, int which, select_table *seltable);
  56. static int sock_ioctl(struct inode *inode, struct file *file,
  57.               unsigned int cmd, unsigned long arg);
  58.  
  59.  
  60. static struct file_operations socket_file_ops = {
  61.   sock_lseek,
  62.   sock_read,
  63.   sock_write,
  64.   sock_readdir,
  65.   sock_select,
  66.   sock_ioctl,
  67.   NULL,            /* mmap */
  68.   NULL,            /* no special open code... */
  69.   sock_close
  70. };
  71.  
  72. static struct socket sockets[NSOCKETS];
  73. static struct wait_queue *socket_wait_free = NULL;
  74. static struct proto_ops *pops[NPROTO];
  75. static int net_debug = 0;
  76.  
  77. #define last_socket    (sockets + NSOCKETS - 1)
  78.  
  79. #ifdef SOCK_DEBUG
  80. /* Module debugging. */
  81. static void
  82. dprintf(int level, char *fmt, ...)
  83. {
  84.   char buff[1024];
  85.   va_list args;
  86.   extern int vsprintf(char * buf, const char * fmt, va_list args);
  87.  
  88.   if (level == 0) return;
  89.   va_start(args, fmt);
  90.   vsprintf(buff, fmt, args);
  91.   va_end(args);
  92.   printk(buff);
  93. }
  94. #endif
  95.  
  96. /* Obtains the first available file descriptor and sets it up for use. */
  97. static int
  98. get_fd(struct inode *inode)
  99. {
  100.   int fd;
  101.   struct file *file;
  102.  
  103.   /* Find a file descriptor suitable for return to the user. */
  104.   file = get_empty_filp();
  105.   if (!file) return(-1);
  106.   for (fd = 0; fd < NR_OPEN; ++fd)
  107.     if (!current->filp[fd]) break;
  108.   if (fd == NR_OPEN) {
  109.     file->f_count = 0;
  110.     return(-1);
  111.   }
  112.   FD_CLR(fd, ¤t->close_on_exec);
  113.   current->filp[fd] = file;
  114.   file->f_op = &socket_file_ops;
  115.   file->f_mode = 3;
  116.   file->f_flags = 0;
  117.   file->f_count = 1;
  118.   file->f_inode = inode;
  119.   if (inode) inode->i_count++;
  120.   file->f_pos = 0;
  121.   return(fd);
  122. }
  123.  
  124.  
  125. /*
  126.  * Reverses the action of get_fd() by releasing the file. it closes
  127.  * the descriptor, but makes sure it does nothing more. Called when
  128.  * an incomplete socket must be closed, along with sock_release().
  129.  */
  130. static inline void
  131. toss_fd(int fd)
  132. {
  133.   sys_close(fd);        /* the count protects us from iput */
  134. }
  135.  
  136.  
  137. struct socket *
  138. socki_lookup(struct inode *inode)
  139. {
  140.   struct socket *sock;
  141.  
  142.   if ((sock = inode->i_socket) != NULL) {
  143.     if (sock->state != SS_FREE && SOCK_INODE(sock) == inode)
  144.         return sock;
  145.     printk("socket.c: uhhuh. stale inode->i_socket pointer\n");
  146.   }
  147.   for (sock = sockets; sock <= last_socket; ++sock)
  148.     if (sock->state != SS_FREE && SOCK_INODE(sock) == inode) {
  149.         printk("socket.c: uhhuh. Found socket despite no inode->i_socket pointer\n");
  150.         return(sock);
  151.     }
  152.   return(NULL);
  153. }
  154.  
  155.  
  156. static inline struct socket *
  157. sockfd_lookup(int fd, struct file **pfile)
  158. {
  159.   struct file *file;
  160.  
  161.   if (fd < 0 || fd >= NR_OPEN || !(file = current->filp[fd])) return(NULL);
  162.   if (pfile) *pfile = file;
  163.   return(socki_lookup(file->f_inode));
  164. }
  165.  
  166.  
  167. static struct socket *
  168. sock_alloc(int wait)
  169. {
  170.   struct socket *sock;
  171.  
  172.   while (1) {
  173.     cli();
  174.     for (sock = sockets; sock <= last_socket; ++sock) {
  175.         if (sock->state == SS_FREE) {
  176.             sock->state = SS_UNCONNECTED;
  177.             sti();
  178.             sock->flags = 0;
  179.             sock->ops = NULL;
  180.             sock->data = NULL;
  181.             sock->conn = NULL;
  182.             sock->iconn = NULL;
  183.  
  184.             /*
  185.              * This really shouldn't be necessary, but everything
  186.              * else depends on inodes, so we grab it.
  187.              * Sleeps are also done on the i_wait member of this
  188.              * inode.  The close system call will iput this inode
  189.              * for us.
  190.              */
  191.             if (!(SOCK_INODE(sock) = get_empty_inode())) {
  192.                 printk("NET: sock_alloc: no more inodes\n");
  193.                 sock->state = SS_FREE;
  194.                 return(NULL);
  195.             }
  196.             SOCK_INODE(sock)->i_mode = S_IFSOCK;
  197.             SOCK_INODE(sock)->i_uid = current->euid;
  198.             SOCK_INODE(sock)->i_gid = current->egid;
  199.             SOCK_INODE(sock)->i_socket = sock;
  200.  
  201.             sock->wait = &SOCK_INODE(sock)->i_wait;
  202.             DPRINTF((net_debug,
  203.                 "NET: sock_alloc: sk 0x%x, ino 0x%x\n",
  204.                                    sock, SOCK_INODE(sock)));
  205.             return(sock);
  206.         }
  207.     }
  208.     sti();
  209.     if (!wait) return(NULL);
  210.     DPRINTF((net_debug, "NET: sock_alloc: no free sockets, sleeping...\n"));
  211.     interruptible_sleep_on(&socket_wait_free);
  212.     if (current->signal & ~current->blocked) {
  213.         DPRINTF((net_debug, "NET: sock_alloc: sleep was interrupted\n"));
  214.         return(NULL);
  215.     }
  216.     DPRINTF((net_debug, "NET: sock_alloc: wakeup... trying again...\n"));
  217.   }
  218. }
  219.  
  220.  
  221. static inline void
  222. sock_release_peer(struct socket *peer)
  223. {
  224.   peer->state = SS_DISCONNECTING;
  225.   wake_up_interruptible(peer->wait);
  226. }
  227.  
  228.  
  229. static void
  230. sock_release(struct socket *sock)
  231. {
  232.   int oldstate;
  233.   struct inode *inode;
  234.   struct socket *peersock, *nextsock;
  235.  
  236.   DPRINTF((net_debug, "NET: sock_release: socket 0x%x, inode 0x%x\n",
  237.                         sock, SOCK_INODE(sock)));
  238.   if ((oldstate = sock->state) != SS_UNCONNECTED)
  239.             sock->state = SS_DISCONNECTING;
  240.  
  241.   /* Wake up anyone waiting for connections. */
  242.   for (peersock = sock->iconn; peersock; peersock = nextsock) {
  243.     nextsock = peersock->next;
  244.     sock_release_peer(peersock);
  245.   }
  246.  
  247.   /*
  248.    * Wake up anyone we're connected to. First, we release the
  249.    * protocol, to give it a chance to flush data, etc.
  250.    */
  251.   peersock = (oldstate == SS_CONNECTED) ? sock->conn : NULL;
  252.   if (sock->ops) sock->ops->release(sock, peersock);
  253.   if (peersock) sock_release_peer(peersock);
  254.   inode = SOCK_INODE(sock);
  255.   sock->state = SS_FREE;        /* this really releases us */
  256.   wake_up_interruptible(&socket_wait_free);
  257.  
  258.   /* We need to do this. If sock alloc was called we already have an inode. */
  259.   iput(inode);
  260. }
  261.  
  262.  
  263. static int
  264. sock_lseek(struct inode *inode, struct file *file, off_t offset, int whence)
  265. {
  266.   DPRINTF((net_debug, "NET: sock_lseek: huh?\n"));
  267.   return(-ESPIPE);
  268. }
  269.  
  270.  
  271. static int
  272. sock_read(struct inode *inode, struct file *file, char *ubuf, int size)
  273. {
  274.   struct socket *sock;
  275.  
  276.   DPRINTF((net_debug, "NET: sock_read: buf=0x%x, size=%d\n", ubuf, size));
  277.   if (!(sock = socki_lookup(inode))) {
  278.     printk("NET: sock_read: can't find socket for inode!\n");
  279.     return(-EBADF);
  280.   }
  281.   if (sock->flags & SO_ACCEPTCON) return(-EINVAL);
  282.   return(sock->ops->read(sock, ubuf, size, (file->f_flags & O_NONBLOCK)));
  283. }
  284.  
  285.  
  286. static int
  287. sock_write(struct inode *inode, struct file *file, char *ubuf, int size)
  288. {
  289.   struct socket *sock;
  290.  
  291.   DPRINTF((net_debug, "NET: sock_write: buf=0x%x, size=%d\n", ubuf, size));
  292.   if (!(sock = socki_lookup(inode))) {
  293.     printk("NET: sock_write: can't find socket for inode!\n");
  294.     return(-EBADF);
  295.   }
  296.   if (sock->flags & SO_ACCEPTCON) return(-EINVAL);
  297.   return(sock->ops->write(sock, ubuf, size,(file->f_flags & O_NONBLOCK)));
  298. }
  299.  
  300.  
  301. static int
  302. sock_readdir(struct inode *inode, struct file *file, struct dirent *dirent,
  303.          int count)
  304. {
  305.   DPRINTF((net_debug, "NET: sock_readdir: huh?\n"));
  306.   return(-EBADF);
  307. }
  308.  
  309.  
  310. int
  311. sock_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
  312.        unsigned long arg)
  313. {
  314.   struct socket *sock;
  315.  
  316.   DPRINTF((net_debug, "NET: sock_ioctl: inode=0x%x cmd=0x%x arg=%d\n",
  317.                             inode, cmd, arg));
  318.   if (!(sock = socki_lookup(inode))) {
  319.     printk("NET: sock_ioctl: can't find socket for inode!\n");
  320.     return(-EBADF);
  321.   }
  322.   return(sock->ops->ioctl(sock, cmd, arg));
  323. }
  324.  
  325.  
  326. static int
  327. sock_select(struct inode *inode, struct file *file, int sel_type, select_table * wait)
  328. {
  329.   struct socket *sock;
  330.  
  331.   DPRINTF((net_debug, "NET: sock_select: inode = 0x%x, kind = %s\n", inode,
  332.        (sel_type == SEL_IN) ? "in" :
  333.        (sel_type == SEL_OUT) ? "out" : "ex"));
  334.   if (!(sock = socki_lookup(inode))) {
  335.     printk("NET: sock_select: can't find socket for inode!\n");
  336.     return(0);
  337.   }
  338.  
  339.   /* We can't return errors to select, so its either yes or no. */
  340.   if (sock->ops && sock->ops->select)
  341.     return(sock->ops->select(sock, sel_type, wait));
  342.   return(0);
  343. }
  344.  
  345.  
  346. void
  347. sock_close(struct inode *inode, struct file *file)
  348. {
  349.   struct socket *sock;
  350.  
  351.   DPRINTF((net_debug, "NET: sock_close: inode=0x%x (cnt=%d)\n",
  352.                         inode, inode->i_count));
  353.  
  354.   /* It's possible the inode is NULL if we're closing an unfinished socket. */
  355.   if (!inode) return;
  356.   if (!(sock = socki_lookup(inode))) {
  357.     printk("NET: sock_close: can't find socket for inode!\n");
  358.     return;
  359.   }
  360.   sock_release(sock);
  361. }
  362.  
  363.  
  364. int
  365. sock_awaitconn(struct socket *mysock, struct socket *servsock)
  366. {
  367.   struct socket *last;
  368.  
  369.   DPRINTF((net_debug,
  370.     "NET: sock_awaitconn: trying to connect socket 0x%x to 0x%x\n",
  371.                             mysock, servsock));
  372.   if (!(servsock->flags & SO_ACCEPTCON)) {
  373.     DPRINTF((net_debug,
  374.         "NET: sock_awaitconn: server not accepting connections\n"));
  375.     return(-EINVAL);
  376.   }
  377.  
  378.   /* Put ourselves on the server's incomplete connection queue. */
  379.   mysock->next = NULL;
  380.   cli();
  381.   if (!(last = servsock->iconn)) servsock->iconn = mysock;
  382.     else {
  383.     while (last->next) last = last->next;
  384.     last->next = mysock;
  385.   }
  386.   mysock->state = SS_CONNECTING;
  387.   mysock->conn = servsock;
  388.   sti();
  389.  
  390.   /*
  391.    * Wake up server, then await connection. server will set state to
  392.    * SS_CONNECTED if we're connected.
  393.    */
  394.   wake_up_interruptible(servsock->wait);
  395.   if (mysock->state != SS_CONNECTED) {
  396.     interruptible_sleep_on(mysock->wait);
  397.     if (mysock->state != SS_CONNECTED &&
  398.         mysock->state != SS_DISCONNECTING) {
  399.         /*
  400.          * if we're not connected we could have been
  401.          * 1) interrupted, so we need to remove ourselves
  402.          *    from the server list
  403.          * 2) rejected (mysock->conn == NULL), and have
  404.          *    already been removed from the list
  405.          */
  406.         if (mysock->conn == servsock) {
  407.             cli();
  408.             if ((last = servsock->iconn) == mysock)
  409.                     servsock->iconn = mysock->next;
  410.             else {
  411.                 while (last->next != mysock) last = last->next;
  412.                 last->next = mysock->next;
  413.             }
  414.             sti();
  415.         }
  416.         return(mysock->conn ? -EINTR : -EACCES);
  417.     }
  418.   }
  419.   return(0);
  420. }
  421.  
  422.  
  423. /*
  424.  * Perform the socket system call. we locate the appropriate
  425.  * family, then create a fresh socket.
  426.  */
  427. static int
  428. sock_socket(int family, int type, int protocol)
  429. {
  430.   int i, fd;
  431.   struct socket *sock;
  432.   struct proto_ops *ops;
  433.  
  434.   DPRINTF((net_debug,
  435.     "NET: sock_socket: family = %d, type = %d, protocol = %d\n",
  436.                         family, type, protocol));
  437.  
  438.   /* Locate the correct protocol family. */
  439.   for (i = 0; i < NPROTO; ++i) {
  440.     if (pops[i] == NULL) continue;
  441.     if (pops[i]->family == family) break;
  442.   }
  443.   if (i == NPROTO) {
  444.     DPRINTF((net_debug, "NET: sock_socket: family not found\n"));
  445.     return(-EINVAL);
  446.   }
  447.   ops = pops[i];
  448.  
  449.   /*
  450.    * Check that this is a type that we know how to manipulate and
  451.    * the protocol makes sense here. The family can still reject the
  452.    * protocol later.
  453.    */
  454.   if ((type != SOCK_STREAM && type != SOCK_DGRAM &&
  455.        type != SOCK_SEQPACKET && type != SOCK_RAW &&
  456.        type != SOCK_PACKET) || protocol < 0)
  457.                             return(-EINVAL);
  458.  
  459.   /*
  460.    * allocate the socket and allow the family to set things up. if
  461.    * the protocol is 0, the family is instructed to select an appropriate
  462.    * default.
  463.    */
  464.   if (!(sock = sock_alloc(1))) {
  465.     printk("sock_socket: no more sockets\n");
  466.     return(-EAGAIN);
  467.   }
  468.   sock->type = type;
  469.   sock->ops = ops;
  470.   if ((i = sock->ops->create(sock, protocol)) < 0) {
  471.     sock_release(sock);
  472.     return(i);
  473.   }
  474.  
  475.   if ((fd = get_fd(SOCK_INODE(sock))) < 0) {
  476.     sock_release(sock);
  477.     return(-EINVAL);
  478.   }
  479.  
  480.   return(fd);
  481. }
  482.  
  483.  
  484. static int
  485. sock_socketpair(int family, int type, int protocol, unsigned long usockvec[2])
  486. {
  487.   int fd1, fd2, i;
  488.   struct socket *sock1, *sock2;
  489.   int er;
  490.  
  491.   DPRINTF((net_debug,
  492.     "NET: sock_socketpair: family = %d, type = %d, protocol = %d\n",
  493.                             family, type, protocol));
  494.  
  495.   /*
  496.    * Obtain the first socket and check if the underlying protocol
  497.    * supports the socketpair call.
  498.    */
  499.   if ((fd1 = sock_socket(family, type, protocol)) < 0) return(fd1);
  500.   sock1 = sockfd_lookup(fd1, NULL);
  501.   if (!sock1->ops->socketpair) {
  502.     sys_close(fd1);
  503.     return(-EINVAL);
  504.   }
  505.  
  506.   /* Now grab another socket and try to connect the two together. */
  507.   if ((fd2 = sock_socket(family, type, protocol)) < 0) {
  508.     sys_close(fd1);
  509.     return(-EINVAL);
  510.   }
  511.   sock2 = sockfd_lookup(fd2, NULL);
  512.   if ((i = sock1->ops->socketpair(sock1, sock2)) < 0) {
  513.     sys_close(fd1);
  514.     sys_close(fd2);
  515.     return(i);
  516.   }
  517.   sock1->conn = sock2;
  518.   sock2->conn = sock1;
  519.   sock1->state = SS_CONNECTED;
  520.   sock2->state = SS_CONNECTED;
  521.  
  522.   er=verify_area(VERIFY_WRITE, usockvec, 2 * sizeof(int));
  523.   if(er)
  524.       return er;
  525.   put_fs_long(fd1, &usockvec[0]);
  526.   put_fs_long(fd2, &usockvec[1]);
  527.  
  528.   return(0);
  529. }
  530.  
  531.  
  532. /*
  533.  * Bind a name to a socket. Nothing much to do here since its
  534.  * the protocol's responsibility to handle the local address.
  535.  */
  536. static int
  537. sock_bind(int fd, struct sockaddr *umyaddr, int addrlen)
  538. {
  539.   struct socket *sock;
  540.   int i;
  541.  
  542.   DPRINTF((net_debug, "NET: sock_bind: fd = %d\n", fd));
  543.   if (fd < 0 || fd >= NR_OPEN || current->filp[fd] == NULL)
  544.                                 return(-EBADF);
  545.   if (!(sock = sockfd_lookup(fd, NULL))) return(-ENOTSOCK);
  546.   if ((i = sock->ops->bind(sock, umyaddr, addrlen)) < 0) {
  547.     DPRINTF((net_debug, "NET: sock_bind: bind failed\n"));
  548.     return(i);
  549.   }
  550.   return(0);
  551. }
  552.  
  553.  
  554. /*
  555.  * Perform a listen. Basically, we allow the protocol to do anything
  556.  * necessary for a listen, and if that works, we mark the socket as
  557.  * ready for listening.
  558.  */
  559. static int
  560. sock_listen(int fd, int backlog)
  561. {
  562.   struct socket *sock;
  563.  
  564.   DPRINTF((net_debug, "NET: sock_listen: fd = %d\n", fd));
  565.   if (fd < 0 || fd >= NR_OPEN || current->filp[fd] == NULL)
  566.                                 return(-EBADF);
  567.   if (!(sock = sockfd_lookup(fd, NULL))) return(-ENOTSOCK);
  568.   if (sock->state != SS_UNCONNECTED) {
  569.     DPRINTF((net_debug, "NET: sock_listen: socket isn't unconnected\n"));
  570.     return(-EINVAL);
  571.   }
  572.   if (sock->ops && sock->ops->listen) sock->ops->listen(sock, backlog);
  573.   sock->flags |= SO_ACCEPTCON;
  574.   return(0);
  575. }
  576.  
  577.  
  578. /*
  579.  * For accept, we attempt to create a new socket, set up the link
  580.  * with the client, wake up the client, then return the new
  581.  * connected fd.
  582.  */
  583. static int
  584. sock_accept(int fd, struct sockaddr *upeer_sockaddr, int *upeer_addrlen)
  585. {
  586.   struct file *file;
  587.   struct socket *sock, *newsock;
  588.   int i;
  589.  
  590.   DPRINTF((net_debug, "NET: sock_accept: fd = %d\n", fd));
  591.   if (fd < 0 || fd >= NR_OPEN || ((file = current->filp[fd]) == NULL))
  592.                                 return(-EBADF);
  593.   
  594.   if (!(sock = sockfd_lookup(fd, &file))) return(-ENOTSOCK);
  595.   if (sock->state != SS_UNCONNECTED) {
  596.     DPRINTF((net_debug, "NET: sock_accept: socket isn't unconnected\n"));
  597.     return(-EINVAL);
  598.   }
  599.   if (!(sock->flags & SO_ACCEPTCON)) {
  600.     DPRINTF((net_debug,
  601.         "NET: sock_accept: socket not accepting connections!\n"));
  602.     return(-EINVAL);
  603.   }
  604.  
  605.   if (!(newsock = sock_alloc(0))) {
  606.     printk("NET: sock_accept: no more sockets\n");
  607.     return(-EAGAIN);
  608.   }
  609.   newsock->type = sock->type;
  610.   newsock->ops = sock->ops;
  611.   if ((i = sock->ops->dup(newsock, sock)) < 0) {
  612.     sock_release(newsock);
  613.     return(i);
  614.   }
  615.  
  616.   i = newsock->ops->accept(sock, newsock, file->f_flags);
  617.   if ( i < 0) {
  618.     sock_release(newsock);
  619.     return(i);
  620.   }
  621.  
  622.   if ((fd = get_fd(SOCK_INODE(newsock))) < 0) {
  623.     sock_release(newsock);
  624.     return(-EINVAL);
  625.   }
  626.  
  627.   DPRINTF((net_debug, "NET: sock_accept: connected socket 0x%x via 0x%x\n",
  628.                             sock, newsock));
  629.  
  630.   if (upeer_sockaddr)
  631.     newsock->ops->getname(newsock, upeer_sockaddr, upeer_addrlen, 1);
  632.  
  633.   return(fd);
  634. }
  635.  
  636.  
  637. /* Attempt to connect to a socket with the server address. */
  638. static int
  639. sock_connect(int fd, struct sockaddr *uservaddr, int addrlen)
  640. {
  641.   struct socket *sock;
  642.   struct file *file;
  643.   int i;
  644.  
  645.   DPRINTF((net_debug, "NET: sock_connect: fd = %d\n", fd));
  646.   if (fd < 0 || fd >= NR_OPEN || (file=current->filp[fd]) == NULL)
  647.                                 return(-EBADF);
  648.   
  649.   if (!(sock = sockfd_lookup(fd, &file))) return(-ENOTSOCK);
  650.   switch(sock->state) {
  651.     case SS_UNCONNECTED:
  652.         /* This is ok... continue with connect */
  653.         break;
  654.     case SS_CONNECTED:
  655.         /* Socket is already connected */
  656.         return -EISCONN;
  657.     case SS_CONNECTING:
  658.         /* Not yet connected... we will check this. */
  659.         return(sock->ops->connect(sock, uservaddr,
  660.                       addrlen, file->f_flags));
  661.     default:
  662.         DPRINTF((net_debug,
  663.             "NET: sock_connect: socket not unconnected\n"));
  664.         return(-EINVAL);
  665.   }
  666.   i = sock->ops->connect(sock, uservaddr, addrlen, file->f_flags);
  667.   if (i < 0) {
  668.     DPRINTF((net_debug, "NET: sock_connect: connect failed\n"));
  669.     return(i);
  670.   }
  671.   return(0);
  672. }
  673.  
  674.  
  675. static int
  676. sock_getsockname(int fd, struct sockaddr *usockaddr, int *usockaddr_len)
  677. {
  678.   struct socket *sock;
  679.  
  680.   DPRINTF((net_debug, "NET: sock_getsockname: fd = %d\n", fd));
  681.   if (fd < 0 || fd >= NR_OPEN || current->filp[fd] == NULL)
  682.                                 return(-EBADF);
  683.   if (!(sock = sockfd_lookup(fd, NULL))) return(-ENOTSOCK);
  684.   return(sock->ops->getname(sock, usockaddr, usockaddr_len, 0));
  685. }
  686.  
  687.  
  688. static int
  689. sock_getpeername(int fd, struct sockaddr *usockaddr, int *usockaddr_len)
  690. {
  691.   struct socket *sock;
  692.  
  693.   DPRINTF((net_debug, "NET: sock_getpeername: fd = %d\n", fd));
  694.   if (fd < 0 || fd >= NR_OPEN || current->filp[fd] == NULL)
  695.             return(-EBADF);
  696.   if (!(sock = sockfd_lookup(fd, NULL))) return(-ENOTSOCK);
  697.   return(sock->ops->getname(sock, usockaddr, usockaddr_len, 1));
  698. }
  699.  
  700.  
  701. static int
  702. sock_send(int fd, void * buff, int len, unsigned flags)
  703. {
  704.   struct socket *sock;
  705.   struct file *file;
  706.  
  707.   DPRINTF((net_debug,
  708.     "NET: sock_send(fd = %d, buff = %X, len = %d, flags = %X)\n",
  709.                                    fd, buff, len, flags));
  710.  
  711.   if (fd < 0 || fd >= NR_OPEN || ((file = current->filp[fd]) == NULL))
  712.                                 return(-EBADF);
  713.   if (!(sock = sockfd_lookup(fd, NULL))) return(-ENOTSOCK);
  714.  
  715.   return(sock->ops->send(sock, buff, len, (file->f_flags & O_NONBLOCK), flags));
  716. }
  717.  
  718.  
  719. static int
  720. sock_sendto(int fd, void * buff, int len, unsigned flags,
  721.        struct sockaddr *addr, int addr_len)
  722. {
  723.   struct socket *sock;
  724.   struct file *file;
  725.  
  726.   DPRINTF((net_debug,
  727.     "NET: sock_sendto(fd = %d, buff = %X, len = %d, flags = %X,"
  728.      " addr=%X, alen = %d\n", fd, buff, len, flags, addr, addr_len));
  729.  
  730.   if (fd < 0 || fd >= NR_OPEN || ((file = current->filp[fd]) == NULL))
  731.                                 return(-EBADF);
  732.   if (!(sock = sockfd_lookup(fd, NULL))) return(-ENOTSOCK);
  733.  
  734.   return(sock->ops->sendto(sock, buff, len, (file->f_flags & O_NONBLOCK),
  735.                flags, addr, addr_len));
  736. }
  737.  
  738.  
  739. static int
  740. sock_recv(int fd, void * buff, int len, unsigned flags)
  741. {
  742.   struct socket *sock;
  743.   struct file *file;
  744.  
  745.   DPRINTF((net_debug,
  746.     "NET: sock_recv(fd = %d, buff = %X, len = %d, flags = %X)\n",
  747.                             fd, buff, len, flags));
  748.  
  749.   if (fd < 0 || fd >= NR_OPEN || ((file = current->filp[fd]) == NULL))
  750.                                 return(-EBADF);
  751.   if (!(sock = sockfd_lookup(fd, NULL))) return(-ENOTSOCK);
  752.  
  753.   return(sock->ops->recv(sock, buff, len,(file->f_flags & O_NONBLOCK), flags));
  754. }
  755.  
  756.  
  757. static int
  758. sock_recvfrom(int fd, void * buff, int len, unsigned flags,
  759.          struct sockaddr *addr, int *addr_len)
  760. {
  761.   struct socket *sock;
  762.   struct file *file;
  763.  
  764.   DPRINTF((net_debug,
  765.     "NET: sock_recvfrom(fd = %d, buff = %X, len = %d, flags = %X,"
  766.     " addr=%X, alen=%X\n", fd, buff, len, flags, addr, addr_len));
  767.  
  768.   if (fd < 0 || fd >= NR_OPEN || ((file = current->filp[fd]) == NULL))
  769.                                 return(-EBADF);
  770.   if (!(sock = sockfd_lookup(fd, NULL))) return(-ENOTSOCK);
  771.  
  772.   return(sock->ops->recvfrom(sock, buff, len, (file->f_flags & O_NONBLOCK),
  773.                  flags, addr, addr_len));
  774. }
  775.  
  776.  
  777. static int
  778. sock_setsockopt(int fd, int level, int optname, char *optval, int optlen)
  779. {
  780.   struct socket *sock;
  781.   struct file *file;
  782.     
  783.   DPRINTF((net_debug, "NET: sock_setsockopt(fd=%d, level=%d, optname=%d,\n",
  784.                             fd, level, optname));
  785.   DPRINTF((net_debug, "                     optval = %X, optlen = %d)\n",
  786.                             optval, optlen));
  787.  
  788.   if (fd < 0 || fd >= NR_OPEN || ((file = current->filp[fd]) == NULL))
  789.                                 return(-EBADF);
  790.   if (!(sock = sockfd_lookup(fd, NULL))) return(-ENOTSOCK);
  791.  
  792.   return(sock->ops->setsockopt(sock, level, optname, optval, optlen));
  793. }
  794.  
  795.  
  796. static int
  797. sock_getsockopt(int fd, int level, int optname, char *optval, int *optlen)
  798. {
  799.   struct socket *sock;
  800.   struct file *file;
  801.  
  802.   DPRINTF((net_debug, "NET: sock_getsockopt(fd=%d, level=%d, optname=%d,\n",
  803.                         fd, level, optname));
  804.   DPRINTF((net_debug, "                     optval = %X, optlen = %X)\n",
  805.                         optval, optlen));
  806.  
  807.   if (fd < 0 || fd >= NR_OPEN || ((file = current->filp[fd]) == NULL))
  808.                                 return(-EBADF);
  809.   if (!(sock = sockfd_lookup(fd, NULL))) return(-ENOTSOCK);
  810.         
  811.   if (!sock->ops || !sock->ops->getsockopt) return(0);
  812.   return(sock->ops->getsockopt(sock, level, optname, optval, optlen));
  813. }
  814.  
  815.  
  816. static int
  817. sock_shutdown(int fd, int how)
  818. {
  819.   struct socket *sock;
  820.   struct file *file;
  821.  
  822.   DPRINTF((net_debug, "NET: sock_shutdown(fd = %d, how = %d)\n", fd, how));
  823.  
  824.   if (fd < 0 || fd >= NR_OPEN || ((file = current->filp[fd]) == NULL))
  825.                                 return(-EBADF);
  826.  
  827.   if (!(sock = sockfd_lookup(fd, NULL))) return(-ENOTSOCK);
  828.  
  829.   return(sock->ops->shutdown(sock, how));
  830. }
  831.  
  832.  
  833. int
  834. sock_fcntl(struct file *filp, unsigned int cmd, unsigned long arg)
  835. {
  836.   struct socket *sock;
  837.  
  838.   sock = socki_lookup (filp->f_inode);
  839.   if (sock != NULL && sock->ops != NULL && sock->ops->fcntl != NULL)
  840.                 return(sock->ops->fcntl(sock, cmd, arg));
  841.   return(-EINVAL);
  842. }
  843.  
  844.  
  845. /*
  846.  * System call vectors. Since I (RIB) want to rewrite sockets as streams,
  847.  * we have this level of indirection. Not a lot of overhead, since more of
  848.  * the work is done via read/write/select directly.
  849.  */
  850. asmlinkage int
  851. sys_socketcall(int call, unsigned long *args)
  852. {
  853.   int er;
  854.   switch(call) {
  855.     case SYS_SOCKET:
  856.         er=verify_area(VERIFY_READ, args, 3 * sizeof(long));
  857.         if(er)
  858.             return er;
  859.         return(sock_socket(get_fs_long(args+0),
  860.                    get_fs_long(args+1),
  861.                    get_fs_long(args+2)));
  862.     case SYS_BIND:
  863.         er=verify_area(VERIFY_READ, args, 3 * sizeof(long));
  864.         if(er)
  865.             return er;
  866.         return(sock_bind(get_fs_long(args+0),
  867.                  (struct sockaddr *)get_fs_long(args+1),
  868.                  get_fs_long(args+2)));
  869.     case SYS_CONNECT:
  870.         er=verify_area(VERIFY_READ, args, 3 * sizeof(long));
  871.         if(er)
  872.             return er;
  873.         return(sock_connect(get_fs_long(args+0),
  874.                     (struct sockaddr *)get_fs_long(args+1),
  875.                     get_fs_long(args+2)));
  876.     case SYS_LISTEN:
  877.         er=verify_area(VERIFY_READ, args, 2 * sizeof(long));
  878.         if(er)
  879.             return er;
  880.         return(sock_listen(get_fs_long(args+0),
  881.                    get_fs_long(args+1)));
  882.     case SYS_ACCEPT:
  883.         er=verify_area(VERIFY_READ, args, 3 * sizeof(long));
  884.         if(er)
  885.             return er;
  886.         return(sock_accept(get_fs_long(args+0),
  887.                    (struct sockaddr *)get_fs_long(args+1),
  888.                    (int *)get_fs_long(args+2)));
  889.     case SYS_GETSOCKNAME:
  890.         er=verify_area(VERIFY_READ, args, 3 * sizeof(long));
  891.         if(er)
  892.             return er;
  893.         return(sock_getsockname(get_fs_long(args+0),
  894.                     (struct sockaddr *)get_fs_long(args+1),
  895.                     (int *)get_fs_long(args+2)));
  896.     case SYS_GETPEERNAME:
  897.         er=verify_area(VERIFY_READ, args, 3 * sizeof(long));
  898.         if(er)
  899.             return er;
  900.         return(sock_getpeername(get_fs_long(args+0),
  901.                     (struct sockaddr *)get_fs_long(args+1),
  902.                     (int *)get_fs_long(args+2)));
  903.     case SYS_SOCKETPAIR:
  904.         er=verify_area(VERIFY_READ, args, 4 * sizeof(long));
  905.         if(er)
  906.             return er;
  907.         return(sock_socketpair(get_fs_long(args+0),
  908.                        get_fs_long(args+1),
  909.                        get_fs_long(args+2),
  910.                        (unsigned long *)get_fs_long(args+3)));
  911.     case SYS_SEND:
  912.         er=verify_area(VERIFY_READ, args, 4 * sizeof(unsigned long));
  913.         if(er)
  914.             return er;
  915.         return(sock_send(get_fs_long(args+0),
  916.                  (void *)get_fs_long(args+1),
  917.                  get_fs_long(args+2),
  918.                  get_fs_long(args+3)));
  919.     case SYS_SENDTO:
  920.         er=verify_area(VERIFY_READ, args, 6 * sizeof(unsigned long));
  921.         if(er)
  922.             return er;
  923.         return(sock_sendto(get_fs_long(args+0),
  924.                    (void *)get_fs_long(args+1),
  925.                    get_fs_long(args+2),
  926.                    get_fs_long(args+3),
  927.                    (struct sockaddr *)get_fs_long(args+4),
  928.                    get_fs_long(args+5)));
  929.     case SYS_RECV:
  930.         er=verify_area(VERIFY_READ, args, 4 * sizeof(unsigned long));
  931.         if(er)
  932.             return er;
  933.         return(sock_recv(get_fs_long(args+0),
  934.                  (void *)get_fs_long(args+1),
  935.                  get_fs_long(args+2),
  936.                  get_fs_long(args+3)));
  937.     case SYS_RECVFROM:
  938.         er=verify_area(VERIFY_READ, args, 6 * sizeof(unsigned long));
  939.         if(er)
  940.             return er;
  941.         return(sock_recvfrom(get_fs_long(args+0),
  942.                      (void *)get_fs_long(args+1),
  943.                      get_fs_long(args+2),
  944.                      get_fs_long(args+3),
  945.                      (struct sockaddr *)get_fs_long(args+4),
  946.                      (int *)get_fs_long(args+5)));
  947.     case SYS_SHUTDOWN:
  948.         er=verify_area(VERIFY_READ, args, 2* sizeof(unsigned long));
  949.         if(er)
  950.             return er;
  951.         return(sock_shutdown(get_fs_long(args+0),
  952.                      get_fs_long(args+1)));
  953.     case SYS_SETSOCKOPT:
  954.         er=verify_area(VERIFY_READ, args, 5*sizeof(unsigned long));
  955.         if(er)
  956.             return er;
  957.         return(sock_setsockopt(get_fs_long(args+0),
  958.                        get_fs_long(args+1),
  959.                        get_fs_long(args+2),
  960.                        (char *)get_fs_long(args+3),
  961.                        get_fs_long(args+4)));
  962.     case SYS_GETSOCKOPT:
  963.         er=verify_area(VERIFY_READ, args, 5*sizeof(unsigned long));
  964.         if(er)
  965.             return er;
  966.         return(sock_getsockopt(get_fs_long(args+0),
  967.                        get_fs_long(args+1),
  968.                        get_fs_long(args+2),
  969.                        (char *)get_fs_long(args+3),
  970.                        (int *)get_fs_long(args+4)));
  971.     default:
  972.         return(-EINVAL);
  973.   }
  974. }
  975.  
  976.  
  977. static int
  978. net_ioctl(unsigned int cmd, unsigned long arg)
  979. {
  980.   int er;
  981.   switch(cmd) {
  982.     case DDIOCSDBG:
  983.         er=verify_area(VERIFY_READ, (void *)arg, sizeof(long));
  984.         if(er)
  985.             return er;
  986.         net_debug = get_fs_long((long *)arg);
  987.         if (net_debug != 0 && net_debug != 1) {
  988.             net_debug = 0;
  989.             return(-EINVAL);
  990.         }
  991.         return(0);
  992.     default:
  993.         return(-EINVAL);
  994.   }
  995.   /*NOTREACHED*/
  996.   return(0);
  997. }
  998.  
  999.  
  1000. /*
  1001.  * Handle the IOCTL system call for the NET devices.  This basically
  1002.  * means I/O control for the SOCKET layer (future expansions could be
  1003.  * a variable number of socket table entries, et al), and for the more
  1004.  * general protocols like ARP.  The latter currently lives in the INET
  1005.  * module, so we have to get ugly a tiny little bit.  Later... -FvK
  1006.  */
  1007. static int
  1008. net_fioctl(struct inode *inode, struct file *file,
  1009.        unsigned int cmd, unsigned long arg)
  1010. {
  1011.   extern int arp_ioctl(unsigned int, void *);
  1012.  
  1013.   /* Dispatch on the minor device. */
  1014.   switch(MINOR(inode->i_rdev)) {
  1015.     case 0:        /* NET (SOCKET) */
  1016.         DPRINTF((net_debug, "NET: SOCKET level I/O control request.\n"));
  1017.         return(net_ioctl(cmd, arg));
  1018. #ifdef CONFIG_INET
  1019.     case 1:        /* ARP */
  1020.         DPRINTF((net_debug, "NET: ARP level I/O control request.\n"));
  1021.         return(arp_ioctl(cmd, (void *) arg));
  1022. #endif
  1023.     default:
  1024.         return(-ENODEV);
  1025.   }
  1026.   /*NOTREACHED*/
  1027.   return(-EINVAL);
  1028. }
  1029.  
  1030.  
  1031. static struct file_operations net_fops = {
  1032.   NULL,        /* LSEEK    */
  1033.   NULL,        /* READ        */
  1034.   NULL,        /* WRITE    */
  1035.   NULL,        /* READDIR    */
  1036.   NULL,        /* SELECT    */
  1037.   net_fioctl,    /* IOCTL    */
  1038.   NULL,        /* MMAP        */
  1039.   NULL,        /* OPEN        */
  1040.   NULL        /* CLOSE    */
  1041. };
  1042.  
  1043.  
  1044. /*
  1045.  * This function is called by a protocol handler that wants to
  1046.  * advertise its address family, and have it linked into the
  1047.  * SOCKET module.
  1048.  */
  1049. int
  1050. sock_register(int family, struct proto_ops *ops)
  1051. {
  1052.   int i;
  1053.  
  1054.   cli();
  1055.   for(i = 0; i < NPROTO; i++) {
  1056.     if (pops[i] != NULL) continue;
  1057.     pops[i] = ops;
  1058.     pops[i]->family = family;
  1059.     sti();
  1060.     DPRINTF((net_debug, "NET: Installed protocol %d in slot %d (0x%X)\n",
  1061.                         family, i, (long)ops));
  1062.     return(i);
  1063.   }
  1064.   sti();
  1065.   return(-ENOMEM);
  1066. }
  1067.  
  1068.  
  1069. void
  1070. sock_init(void)
  1071. {
  1072.   struct socket *sock;
  1073.   int i;
  1074.  
  1075.   /* Set up our SOCKET VFS major device. */
  1076.   if (register_chrdev(SOCKET_MAJOR, "socket", &net_fops) < 0) {
  1077.     printk("NET: cannot register major device %d!\n", SOCKET_MAJOR);
  1078.     return;
  1079.   }
  1080.  
  1081.   /* Release all sockets. */
  1082.   for (sock = sockets; sock <= last_socket; ++sock) sock->state = SS_FREE;
  1083.  
  1084.   /* Initialize all address (protocol) families. */
  1085.   for (i = 0; i < NPROTO; ++i) pops[i] = NULL;
  1086.  
  1087.   /* Initialize the DDI module. */
  1088.   ddi_init();
  1089.  
  1090.   /* Initialize the ARP module. */
  1091. #if 0
  1092.   arp_init();
  1093. #endif
  1094. }
  1095.