rearrange for kirk

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

diff --git a/usr/src/sys/kern/uipc_socket.c b/usr/src/sys/kern/uipc_socket.c
index 93b9a71..1a6eff6 100644 (file)
--- a/usr/src/sys/kern/uipc_socket.c
+++ b/usr/src/sys/kern/uipc_socket.c
@@ -1,4 +1,4 @@
-/*     uipc_socket.c   4.23    82/01/13        */
+/*     uipc_socket.c   4.34    82/03/15        */

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


@@ -70,6 +70,9 @@ COUNT(SOCREATE);
                return (ENOBUFS);
        so = mtod(m, struct socket *);
        so->so_options = options;
                return (ENOBUFS);
        so = mtod(m, struct socket *);
        so->so_options = options;

+       so->so_state = 0;
+       if (u.u_uid == 0)
+               so->so_state = SS_PRIV;

 
        /*
         * Attach protocol to socket, initializing
 
        /*
         * Attach protocol to socket, initializing


@@ -101,9 +104,12 @@ COUNT(SOFREE);
  * Close a socket on last file table reference removal.
  * Initiate disconnect if connected.
  * Free socket when disconnect complete.
  * Close a socket on last file table reference removal.
  * Initiate disconnect if connected.
  * Free socket when disconnect complete.

+ *
+ * THIS IS REALLY A UNIX INTERFACE ROUTINE

  */
  */

-soclose(so)
+soclose(so, exiting)

        register struct socket *so;
        register struct socket *so;

+       int exiting;

 {
        int s = splnet();               /* conservative */
 
 {
        int s = splnet();               /* conservative */
 


@@ -114,22 +120,26 @@ COUNT(SOCLOSE);
                if ((so->so_state & SS_ISDISCONNECTING) == 0) {
                        u.u_error = sodisconnect(so, (struct sockaddr *)0);
                        if (u.u_error) {
                if ((so->so_state & SS_ISDISCONNECTING) == 0) {
                        u.u_error = sodisconnect(so, (struct sockaddr *)0);
                        if (u.u_error) {

+                               if (exiting)
+                                       goto drop;

                                splx(s);
                                return;
                        }
                }
                if ((so->so_options & SO_DONTLINGER) == 0) {
                        if ((so->so_state & SS_ISDISCONNECTING) &&
                                splx(s);
                                return;
                        }
                }
                if ((so->so_options & SO_DONTLINGER) == 0) {
                        if ((so->so_state & SS_ISDISCONNECTING) &&

-                           (so->so_options & SO_NONBLOCKING)) {
+                           (so->so_state & SS_NBIO) &&
+                           exiting == 0) {

                                u.u_error = EINPROGRESS;
                                splx(s);
                                return;
                        }
                                u.u_error = EINPROGRESS;
                                splx(s);
                                return;
                        }

-                       /* should use tsleep here */
+                       /* should use tsleep here, for at most linger */

                        while (so->so_state & SS_ISCONNECTED)
                                sleep((caddr_t)&so->so_timeo, PZERO+1);
                }
        }
                        while (so->so_state & SS_ISCONNECTED)
                                sleep((caddr_t)&so->so_timeo, PZERO+1);
                }
        }

+drop:

        u.u_error = (*so->so_proto->pr_usrreq)(so, PRU_DETACH, 0, 0);
 discard:
        so->so_state |= SS_USERGONE;
        u.u_error = (*so->so_proto->pr_usrreq)(so, PRU_DETACH, 0, 0);
 discard:
        so->so_state |= SS_USERGONE;


@@ -259,11 +269,13 @@ sosend(so, asa)
        int error = 0, space, s;
 
 COUNT(SOSEND);
        int error = 0, space, s;
 
 COUNT(SOSEND);

-       if (so->so_state & SS_CANTSENDMORE)
+       if (so->so_state & SS_CANTSENDMORE) {
+               psignal(u.u_procp, SIGPIPE);

                return (EPIPE);
                return (EPIPE);

+       }

        if (sosendallatonce(so) && u.u_count > so->so_snd.sb_hiwat)
                return (EMSGSIZE);
        if (sosendallatonce(so) && u.u_count > so->so_snd.sb_hiwat)
                return (EMSGSIZE);

-       if ((so->so_snd.sb_flags & SB_LOCK) && (so->so_options & SO_NONBLOCKING))
+       if ((so->so_snd.sb_flags & SB_LOCK) && (so->so_state & SS_NBIO))

                return (EWOULDBLOCK);
        sblock(&so->so_snd);
 #define        snderr(errno)   { error = errno; splx(s); goto release; }
                return (EWOULDBLOCK);
        sblock(&so->so_snd);
 #define        snderr(errno)   { error = errno; splx(s); goto release; }


@@ -296,8 +308,8 @@ again:
                goto release;
        }
        space = sbspace(&so->so_snd);
                goto release;
        }
        space = sbspace(&so->so_snd);

-       if (space == 0 || sosendallatonce(so) && space < u.u_count) {
-               if (so->so_options & SO_NONBLOCKING)
+       if (space <= 0 || sosendallatonce(so) && space < u.u_count) {
+               if (so->so_state & SS_NBIO)

                        snderr(EWOULDBLOCK);
                sbunlock(&so->so_snd);
                sbwait(&so->so_snd);
                        snderr(EWOULDBLOCK);
                sbunlock(&so->so_snd);
                sbwait(&so->so_snd);


@@ -344,7 +356,8 @@ soreceive(so, asa)
 {
        register struct mbuf *m, *n;
        u_int len;
 {
        register struct mbuf *m, *n;
        u_int len;

-       int eor, s, error = 0;
+       int eor, s, error = 0, cnt = u.u_count;
+       caddr_t base = u.u_base;

 
 COUNT(SORECEIVE);
 restart:
 
 COUNT(SORECEIVE);
 restart:


@@ -366,7 +379,7 @@ restart:
                if ((so->so_state & SS_ISCONNECTED) == 0 &&
                    (so->so_proto->pr_flags & PR_CONNREQUIRED))
                        rcverr(ENOTCONN);
                if ((so->so_state & SS_ISCONNECTED) == 0 &&
                    (so->so_proto->pr_flags & PR_CONNREQUIRED))
                        rcverr(ENOTCONN);

-               if (so->so_options & SO_NONBLOCKING)
+               if (so->so_state & SS_NBIO)

                        rcverr(EWOULDBLOCK);
                sbunlock(&so->so_rcv);
                sbwait(&so->so_rcv);
                        rcverr(EWOULDBLOCK);
                sbunlock(&so->so_rcv);
                sbwait(&so->so_rcv);


@@ -388,25 +401,27 @@ restart:
                        panic("receive 2");
                so->so_rcv.sb_mb = m;
        }
                        panic("receive 2");
                so->so_rcv.sb_mb = m;
        }

+       so->so_state &= ~SS_RCVATMARK;
+       if (so->so_oobmark && cnt > so->so_oobmark)
+               cnt = so->so_oobmark;

        eor = 0;
        do {
        eor = 0;
        do {

-               len = MIN(m->m_len, u.u_count);
-               if (len == m->m_len) {
-                       eor = (int)m->m_act;
-                       sbfree(&so->so_rcv, m);
-                       so->so_rcv.sb_mb = m->m_next;
-               }
+               len = MIN(m->m_len, cnt);

                splx(s);
                iomove(mtod(m, caddr_t), len, B_READ);
                splx(s);
                iomove(mtod(m, caddr_t), len, B_READ);

+               cnt -= len;

                s = splnet();
                if (len == m->m_len) {
                s = splnet();
                if (len == m->m_len) {

+                       eor = (int)m->m_act;
+                       sbfree(&so->so_rcv, m);
+                       so->so_rcv.sb_mb = m->m_next;

                        MFREE(m, n);
                } else {
                        m->m_off += len;
                        m->m_len -= len;
                        so->so_rcv.sb_cc -= len;
                }
                        MFREE(m, n);
                } else {
                        m->m_off += len;
                        m->m_len -= len;
                        so->so_rcv.sb_cc -= len;
                }

-       } while ((m = so->so_rcv.sb_mb) && u.u_count && !eor);
+       } while ((m = so->so_rcv.sb_mb) && cnt && !eor);

        if ((so->so_proto->pr_flags & PR_ATOMIC) && eor == 0)
                do {
                        if (m == 0)
        if ((so->so_proto->pr_flags & PR_ATOMIC) && eor == 0)
                do {
                        if (m == 0)


@@ -419,12 +434,33 @@ restart:
                } while (eor == 0);
        if ((so->so_proto->pr_flags & PR_WANTRCVD) && so->so_pcb)
                (*so->so_proto->pr_usrreq)(so, PRU_RCVD, 0, 0);
                } while (eor == 0);
        if ((so->so_proto->pr_flags & PR_WANTRCVD) && so->so_pcb)
                (*so->so_proto->pr_usrreq)(so, PRU_RCVD, 0, 0);

+       if (so->so_oobmark) {
+               so->so_oobmark -= u.u_base - base;
+               if (so->so_oobmark == 0)
+                       so->so_state |= SS_RCVATMARK;
+       }

 release:
        sbunlock(&so->so_rcv);
        splx(s);
        return (error);
 }
 
 release:
        sbunlock(&so->so_rcv);
        splx(s);
        return (error);
 }
 

+sohasoutofband(so)
+       struct socket *so;
+{
+
+       if (so->so_pgrp == 0)
+               return;
+       if (so->so_pgrp > 0)
+               gsignal(so->so_pgrp, SIGURG);
+       else {
+               struct proc *p = pfind(-so->so_pgrp);
+
+               if (p)
+                       psignal(p, SIGURG);
+       }
+}
+

 /*ARGSUSED*/
 soioctl(so, cmd, cmdp)
        register struct socket *so;
 /*ARGSUSED*/
 soioctl(so, cmd, cmdp)
        register struct socket *so;


@@ -442,9 +478,9 @@ COUNT(SOIOCTL);
                        return;
                }
                if (nbio)
                        return;
                }
                if (nbio)

-                       so->so_options |= SO_NONBLOCKING;
+                       so->so_state |= SS_NBIO;

                else
                else

-                       so->so_options &= ~SO_NONBLOCKING;
+                       so->so_state &= ~SS_NBIO;

                return;
        }
 
                return;
        }
 


@@ -455,9 +491,9 @@ COUNT(SOIOCTL);
                        return;
                }
                if (async)
                        return;
                }
                if (async)

-                       ;
+                       so->so_state |= SS_ASYNC;

                else
                else

-                       ;
+                       so->so_state &= ~SS_ASYNC;

                return;
        }
 
                return;
        }
 


@@ -468,14 +504,14 @@ COUNT(SOIOCTL);
                        return;
                }
                if (keep)
                        return;
                }
                if (keep)

-                       so->so_options &= ~SO_NOKEEPALIVE;
+                       so->so_options &= ~SO_KEEPALIVE;

                else
                else

-                       so->so_options |= SO_NOKEEPALIVE;
+                       so->so_options |= SO_KEEPALIVE;

                return;
        }
 
        case SIOCGKEEP: {
                return;
        }
 
        case SIOCGKEEP: {

-               int keep = (so->so_options & SO_NOKEEPALIVE) == 0;
+               int keep = (so->so_options & SO_KEEPALIVE) != 0;

                if (copyout((caddr_t)&keep, cmdp, sizeof (keep)))
                        u.u_error = EFAULT;
                return;
                if (copyout((caddr_t)&keep, cmdp, sizeof (keep)))
                        u.u_error = EFAULT;
                return;


@@ -502,6 +538,23 @@ COUNT(SOIOCTL);
                        return;
                }
        }
                        return;
                }
        }

+       case SIOCSPGRP: {
+               int pgrp;
+               if (copyin(cmdp, (caddr_t)&pgrp, sizeof (pgrp))) {
+                       u.u_error = EFAULT;
+                       return;
+               }
+               so->so_pgrp = pgrp;
+               return;
+       }
+
+       case SIOCGPGRP: {
+               int pgrp = so->so_pgrp;
+               if (copyout((caddr_t)&pgrp, cmdp, sizeof (pgrp))) {
+                       u.u_error = EFAULT;
+                       return;
+               }
+       }

 
        case SIOCDONE: {
                int flags;
 
        case SIOCDONE: {
                int flags;


@@ -514,25 +567,57 @@ COUNT(SOIOCTL);
                        int s = splimp();
                        socantrcvmore(so);
                        sbflush(&so->so_rcv);
                        int s = splimp();
                        socantrcvmore(so);
                        sbflush(&so->so_rcv);

+                       splx(s);

                }
                if (flags & FWRITE)
                }
                if (flags & FWRITE)

-                       u.u_error = (*so->so_proto->pr_usrreq)(so, PRU_DISCONNECT, (struct mbuf *)0, 0);
+                       u.u_error = (*so->so_proto->pr_usrreq)(so, PRU_SHUTDOWN, (struct mbuf *)0, 0);

                return;
        }
 
                return;
        }
 

+       case SIOCSENDOOB: {
+               char oob;
+               struct mbuf *m;
+               if (copyin(cmdp, (caddr_t)&oob, sizeof (oob))) {
+                       u.u_error = EFAULT;
+                       return;
+               }
+               m = m_get(M_DONTWAIT);
+               if (m == 0) {
+                       u.u_error = ENOBUFS;
+                       return;
+               }
+               m->m_off = MMINOFF;
+               m->m_len = 1;
+               *mtod(m, caddr_t) = oob;
+               (*so->so_proto->pr_usrreq)(so, PRU_SENDOOB, m, 0);
+               return;

        }
        }

-       switch (so->so_type) {
-
-       case SOCK_STREAM:
-               break;
-
-       case SOCK_DGRAM:
-               break;

 
 

-       case SOCK_RDM:
-               break;
+       case SIOCRCVOOB: {
+               struct mbuf *m = m_get(M_DONTWAIT);
+               if (m == 0) {
+                       u.u_error = ENOBUFS;
+                       return;
+               }
+               m->m_off = MMINOFF; *mtod(m, caddr_t) = 0;
+               (*so->so_proto->pr_usrreq)(so, PRU_RCVOOB, m, 0);
+               if (copyout(mtod(m, caddr_t), cmdp, sizeof (char))) {
+                       u.u_error = EFAULT;
+                       return;
+               }
+               m_free(m);
+               return;
+       }

 
 

-       case SOCK_RAW:
-               break;
+       case SIOCATMARK: {
+               int atmark = (so->so_state&SS_RCVATMARK) != 0;
+               if (copyout((caddr_t)&atmark, cmdp, sizeof (atmark))) {
+                       u.u_error = EFAULT;
+                       return;
+               }
+               return;
+       }
+       /* type/protocol specific ioctls */

        }
        }

+       u.u_error = EOPNOTSUPP;

 }
 }