no more opt parameter to usrreq

[unix-history] / usr / src / sys / kern / uipc_socket2.c

diff --git a/usr/src/sys/kern/uipc_socket2.c b/usr/src/sys/kern/uipc_socket2.c
index 068ad44..6eaf141 100644 (file)
--- a/usr/src/sys/kern/uipc_socket2.c
+++ b/usr/src/sys/kern/uipc_socket2.c
@@ -1,4 +1,4 @@
-/*     uipc_socket2.c  4.23    82/06/14        */
+/*     uipc_socket2.c  4.35    83/01/13        */

 
 #include "../h/param.h"
 #include "../h/systm.h"
 
 #include "../h/param.h"
 #include "../h/systm.h"


@@ -12,8 +12,6 @@
 #include "../h/protosw.h"
 #include "../h/socket.h"
 #include "../h/socketvar.h"
 #include "../h/protosw.h"
 #include "../h/socket.h"
 #include "../h/socketvar.h"

-#include "../net/in.h"
-#include "../net/in_systm.h"

 
 /*
  * Primitive routines for operating on sockets and socket buffers
 
 /*
  * Primitive routines for operating on sockets and socket buffers


@@ -21,8 +19,9 @@
 
 /*
  * Procedures to manipulate state flags of socket
 
 /*
  * Procedures to manipulate state flags of socket

- * and do appropriate wakeups.  Normal sequence is that
- * soisconnecting() is called during processing of connect() call,
+ * and do appropriate wakeups.  Normal sequence from the
+ * active (originating) side is that soisconnecting() is
+ * called during processing of connect() call,

  * resulting in an eventual call to soisconnected() if/when the
  * connection is established.  When the connection is torn down
  * soisdisconnecting() is called during processing of disconnect() call,
  * resulting in an eventual call to soisconnected() if/when the
  * connection is established.  When the connection is torn down
  * soisdisconnecting() is called during processing of disconnect() call,


@@ -32,7 +31,18 @@
  * only, bypassing the in-progress calls when setting up a ``connection''
  * takes no time.
  *
  * only, bypassing the in-progress calls when setting up a ``connection''
  * takes no time.
  *

- * When higher level protocols are implemented in
+ * From the passive side, a socket is created with SO_ACCEPTCONN
+ * creating two queues of sockets: so_q0 for connections in progress
+ * and so_q for connections already made and awaiting user acceptance.
+ * As a protocol is preparing incoming connections, it creates a socket
+ * structure queued on so_q0 by calling sonewconn().  When the connection
+ * is established, soisconnected() is called, and transfers the
+ * socket structure to so_q, making it available to accept().
+ * 
+ * If a SO_ACCEPTCONN socket is closed with sockets on either
+ * so_q0 or so_q, these sockets are dropped.
+ *
+ * If and when higher level protocols are implemented in

  * the kernel, the wakeups done here will sometimes
  * be implemented as software-interrupt process scheduling.
  */
  * the kernel, the wakeups done here will sometimes
  * be implemented as software-interrupt process scheduling.
  */


@@ -49,7 +59,14 @@ soisconnecting(so)
 soisconnected(so)
        struct socket *so;
 {
 soisconnected(so)
        struct socket *so;
 {

+       register struct socket *head = so->so_head;

 
 

+       if (head) {
+               if (soqremque(so, 0) == 0)
+                       panic("soisconnected");
+               soqinsque(head, so, 1);
+               wakeup((caddr_t)&head->so_timeo);
+       }

        so->so_state &= ~(SS_ISCONNECTING|SS_ISDISCONNECTING);
        so->so_state |= SS_ISCONNECTED;
        wakeup((caddr_t)&so->so_timeo);
        so->so_state &= ~(SS_ISCONNECTING|SS_ISDISCONNECTING);
        so->so_state |= SS_ISCONNECTED;
        wakeup((caddr_t)&so->so_timeo);


@@ -79,6 +96,90 @@ soisdisconnected(so)
        sorwakeup(so);
 }
 
        sorwakeup(so);
 }
 

+/*
+ * When an attempt at a new connection is noted on a socket
+ * which accepts connections, sonewconn is called.  If the
+ * connection is possible (subject to space constraints, etc.)
+ * then we allocate a new structure, propoerly linked into the
+ * data structure of the original socket, and return this.
+ */
+struct socket *
+sonewconn(head)
+       register struct socket *head;
+{
+       register struct socket *so;
+       struct mbuf *m;
+
+       if (head->so_qlen + head->so_q0len > 3 * head->so_qlimit / 2)
+               goto bad;
+       m = m_getclr(M_DONTWAIT, MT_SOCKET);
+       if (m == NULL)
+               goto bad;
+       so = mtod(m, struct socket *);
+       so->so_type = head->so_type;
+       so->so_options = head->so_options &~ SO_ACCEPTCONN;
+       so->so_linger = head->so_linger;
+       so->so_state = head->so_state | SS_NOFDREF;
+       so->so_proto = head->so_proto;
+       so->so_timeo = head->so_timeo;
+       so->so_pgrp = head->so_pgrp;
+       soqinsque(head, so, 0);
+       if ((*so->so_proto->pr_usrreq)(so, PRU_ATTACH, (struct mbuf *)0,
+         (struct mbuf *)0)) {
+               (void) soqremque(so, 0);
+               (void) m_free(m);
+               goto bad;
+       }
+       return (so);
+bad:
+       return ((struct socket *)0);
+}
+
+soqinsque(head, so, q)
+       register struct socket *head, *so;
+       int q;
+{
+
+       so->so_head = head;
+       if (q == 0) {
+               head->so_q0len++;
+               so->so_q0 = head->so_q0;
+               head->so_q0 = so;
+       } else {
+               head->so_qlen++;
+               so->so_q = head->so_q;
+               head->so_q = so;
+       }
+}
+
+soqremque(so, q)
+       register struct socket *so;
+       int q;
+{
+       register struct socket *head, *prev, *next;
+
+       head = so->so_head;
+       prev = head;
+       for (;;) {
+               next = q ? prev->so_q : prev->so_q0;
+               if (next == so)
+                       break;
+               if (next == head)
+                       return (0);
+               prev = next;
+       }
+       if (q == 0) {
+               prev->so_q0 = next->so_q0;
+               head->so_q0len--;
+       } else {
+               prev->so_q = next->so_q;
+               head->so_qlen--;
+       }
+       next->so_q0 = next->so_q = 0;
+       next->so_head = 0;
+       return (1);
+}
+

 /*
  * Socantsendmore indicates that no more data will be sent on the
  * socket; it would normally be applied to a socket when the user
 /*
  * Socantsendmore indicates that no more data will be sent on the
  * socket; it would normally be applied to a socket when the user


@@ -222,6 +323,22 @@ sbwakeup(sb)
  * also add data to, and remove data from socket buffers repectively.
  */
 
  * also add data to, and remove data from socket buffers repectively.
  */
 

+soreserve(so, sndcc, rcvcc)
+       struct socket *so;
+       int sndcc, rcvcc;
+{
+
+       if (sbreserve(&so->so_snd, sndcc) == 0)
+               goto bad;
+       if (sbreserve(&so->so_rcv, rcvcc) == 0)
+               goto bad2;
+       return (0);
+bad2:
+       sbrelease(&so->so_snd);
+bad:
+       return (ENOBUFS);
+}
+

 /*
  * Allot mbufs to a sockbuf.
  */
 /*
  * Allot mbufs to a sockbuf.
  */


@@ -231,6 +348,7 @@ sbreserve(sb, cc)
 
        /* someday maybe this routine will fail... */
        sb->sb_hiwat = cc;
 
        /* someday maybe this routine will fail... */
        sb->sb_hiwat = cc;

+       /* the 2 implies names can be no more than 1 mbuf each */

        sb->sb_mbmax = cc*2;
        return (1);
 }
        sb->sb_mbmax = cc*2;
        return (1);
 }


@@ -317,10 +435,9 @@ sbappendaddr(sb, asa, m0)
        }
        if (len > sbspace(sb))
                return (0);
        }
        if (len > sbspace(sb))
                return (0);

-       m = m_get(M_DONTWAIT);
+       m = m_get(M_DONTWAIT, MT_SONAME);

        if (m == 0)
                return (0);
        if (m == 0)
                return (0);

-       m->m_off = MMINOFF;

        m->m_len = sizeof (struct sockaddr);
        msa = mtod(m, struct sockaddr *);
        *msa = *asa;
        m->m_len = sizeof (struct sockaddr);
        msa = mtod(m, struct sockaddr *);
        *msa = *asa;


@@ -330,6 +447,28 @@ sbappendaddr(sb, asa, m0)
        return (1);
 }
 
        return (1);
 }
 

+#ifdef notdef
+SBCHECK(sb, str)
+       struct sockbuf *sb;
+       char *str;
+{
+       register int cnt = sb->sb_cc;
+       register int mbcnt = sb->sb_mbcnt;
+       register struct mbuf *m;
+
+       for (m = sb->sb_mb; m; m = m->m_next) {
+               cnt -= m->m_len;
+               mbcnt -= MSIZE;
+               if (m->m_off > MMAXOFF)
+                       mbcnt -= CLBYTES;
+       }
+       if (cnt || mbcnt) {
+               printf("cnt %d mbcnt %d\n", cnt, mbcnt);
+               panic(str);
+       }
+}
+#endif
+

 /*
  * Free all mbufs on a sockbuf mbuf chain.
  * Check that resource allocations return to 0.
 /*
  * Free all mbufs on a sockbuf mbuf chain.
  * Check that resource allocations return to 0.