new clock style; select not tested

[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 2c3037e..9e3032a 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.28    82/01/19        */
+/*     uipc_socket.c   4.48    82/08/22        */

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


@@ -16,6 +16,8 @@
 #include "../h/ioctl.h"
 #include "../net/in.h"
 #include "../net/in_systm.h"
 #include "../h/ioctl.h"
 #include "../net/in.h"
 #include "../net/in_systm.h"

+#include "../net/route.h"
+#include "../h/uio.h"

 
 /*
  * Socket support routines.
 
 /*
  * Socket support routines.


@@ -37,7 +39,6 @@ socreate(aso, type, asp, asa, options)
        register struct socket *so;
        struct mbuf *m;
        int pf, proto, error;
        register struct socket *so;
        struct mbuf *m;
        int pf, proto, error;

-COUNT(SOCREATE);

 
        /*
         * Use process standard protocol/protocol family if none
 
        /*
         * Use process standard protocol/protocol family if none


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

+       if (options & SO_ACCEPTCONN) {
+               so->so_q = so;
+               so->so_q0 = so;
+               so->so_qlimit = (so->so_options & SO_NEWFDONCONN) ? 5 : 1;
+       }
+       so->so_state = 0;
+       if (u.u_uid == 0)
+               so->so_state = SS_PRIV;

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


@@ -78,7 +87,8 @@ COUNT(SOCREATE);
        so->so_proto = prp;
        error = (*prp->pr_usrreq)(so, PRU_ATTACH, 0, asa);
        if (error) {
        so->so_proto = prp;
        error = (*prp->pr_usrreq)(so, PRU_ATTACH, 0, asa);
        if (error) {

-               (void) m_free(dtom(so));
+               so->so_state |= SS_NOFDREF;
+               sofree(so);

                return (error);
        }
        *aso = so;
                return (error);
        }
        *aso = so;


@@ -89,8 +99,12 @@ sofree(so)
        struct socket *so;
 {
 
        struct socket *so;
 {
 

-COUNT(SOFREE);
-       if (so->so_pcb || (so->so_state & SS_USERGONE) == 0)
+       if (so->so_head) {
+               if (!soqremque(so, 0) && !soqremque(so, 1))
+                       panic("sofree dq");
+               so->so_head = 0;
+       }
+       if (so->so_pcb || (so->so_state & SS_NOFDREF) == 0)

                return;
        sbrelease(&so->so_snd);
        sbrelease(&so->so_rcv);
                return;
        sbrelease(&so->so_snd);
        sbrelease(&so->so_rcv);


@@ -101,8 +115,6 @@ 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, exiting)
        register struct socket *so;
  */
 soclose(so, exiting)
        register struct socket *so;


@@ -110,9 +122,16 @@ soclose(so, exiting)
 {
        int s = splnet();               /* conservative */
 
 {
        int s = splnet();               /* conservative */
 

-COUNT(SOCLOSE);
+       if (so->so_options & SO_ACCEPTCONN) {
+               while (so->so_q0 != so)
+                       soclose(so->so_q0, 1);
+               while (so->so_q != so)
+                       soclose(so->so_q, 1);
+       }

        if (so->so_pcb == 0)
                goto discard;
        if (so->so_pcb == 0)
                goto discard;

+       if (exiting)
+               so->so_options |= SO_KEEPALIVE;

        if (so->so_state & SS_ISCONNECTED) {
                if ((so->so_state & SS_ISDISCONNECTING) == 0) {
                        u.u_error = sodisconnect(so, (struct sockaddr *)0);
        if (so->so_state & SS_ISCONNECTED) {
                if ((so->so_state & SS_ISDISCONNECTING) == 0) {
                        u.u_error = sodisconnect(so, (struct sockaddr *)0);


@@ -125,7 +144,7 @@ COUNT(SOCLOSE);
                }
                if ((so->so_options & SO_DONTLINGER) == 0) {
                        if ((so->so_state & SS_ISDISCONNECTING) &&
                }
                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);
                            exiting == 0) {
                                u.u_error = EINPROGRESS;
                                splx(s);


@@ -137,36 +156,25 @@ COUNT(SOCLOSE);
                }
        }
 drop:
                }
        }
 drop:

-       u.u_error = (*so->so_proto->pr_usrreq)(so, PRU_DETACH, 0, 0);
+       if (so->so_pcb) {
+               u.u_error = (*so->so_proto->pr_usrreq)(so, PRU_DETACH, 0, 0);
+               if (exiting == 0 && u.u_error) {
+                       splx(s);
+                       return;
+               }
+       }

 discard:
 discard:

-       so->so_state |= SS_USERGONE;
+       so->so_state |= SS_NOFDREF;

        sofree(so);
        splx(s);
 }
 
        sofree(so);
        splx(s);
 }
 

-sosplice(pso, so)
-       struct socket *pso, *so;
-{
-
-COUNT(SOSPLICE);
-       if (pso->so_proto->pr_family != PF_UNIX) {
-               struct socket *tso;
-               tso = pso; pso = so; so = tso;
-       }
-       if (pso->so_proto->pr_family != PF_UNIX)
-               return (EOPNOTSUPP);
-       /* check types and buffer space */
-       /* merge buffers */
-       return (0);
-}
-

 /*ARGSUSED*/
 sostat(so, sb)
        struct socket *so;
        struct stat *sb;
 {
 
 /*ARGSUSED*/
 sostat(so, sb)
        struct socket *so;
        struct stat *sb;
 {
 

-COUNT(SOSTAT);

        bzero((caddr_t)sb, sizeof (*sb));               /* XXX */
        return (0);                                     /* XXX */
 }
        bzero((caddr_t)sb, sizeof (*sb));               /* XXX */
        return (0);                                     /* XXX */
 }


@@ -181,18 +189,7 @@ soaccept(so, asa)
        int s = splnet();
        int error;
 
        int s = splnet();
        int error;
 

-COUNT(SOACCEPT);
-       if ((so->so_options & SO_ACCEPTCONN) == 0) {
-               error = EINVAL;                 /* XXX */
-               goto bad;
-       }
-       if ((so->so_state & SS_CONNAWAITING) == 0) {
-               error = ENOTCONN;
-               goto bad;
-       }
-       so->so_state &= ~SS_CONNAWAITING;

        error = (*so->so_proto->pr_usrreq)(so, PRU_ACCEPT, 0, (caddr_t)asa);
        error = (*so->so_proto->pr_usrreq)(so, PRU_ACCEPT, 0, (caddr_t)asa);

-bad:

        splx(s);
        return (error);
 }
        splx(s);
        return (error);
 }


@@ -209,7 +206,6 @@ soconnect(so, asa)
        int s = splnet();
        int error;
 
        int s = splnet();
        int error;
 

-COUNT(SOCONNECT);

        if (so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING)) {
                error = EISCONN;
                goto bad;
        if (so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING)) {
                error = EISCONN;
                goto bad;


@@ -233,7 +229,6 @@ sodisconnect(so, asa)
        int s = splnet();
        int error;
 
        int s = splnet();
        int error;
 

-COUNT(SODISCONNECT);

        if ((so->so_state & SS_ISCONNECTED) == 0) {
                error = ENOTCONN;
                goto bad;
        if ((so->so_state & SS_ISCONNECTED) == 0) {
                error = ENOTCONN;
                goto bad;


@@ -256,30 +251,36 @@ bad:
  * If must go all at once and not enough room now, then
  * inform user that this would block and do nothing.
  */
  * If must go all at once and not enough room now, then
  * inform user that this would block and do nothing.
  */

-sosend(so, asa)
+sosend(so, asa, uio)

        register struct socket *so;
        struct sockaddr *asa;
        register struct socket *so;
        struct sockaddr *asa;

+       struct uio *uio;

 {
        struct mbuf *top = 0;
        register struct mbuf *m, **mp = ⊤
        register u_int len;
        int error = 0, space, s;
 
 {
        struct mbuf *top = 0;
        register struct mbuf *m, **mp = ⊤
        register u_int len;
        int error = 0, space, s;
 

-COUNT(SOSEND);
-       if (so->so_state & SS_CANTSENDMORE)
-               return (EPIPE);
-       if (sosendallatonce(so) && u.u_count > so->so_snd.sb_hiwat)
+       if (sosendallatonce(so) && uio->uio_resid > so->so_snd.sb_hiwat)

                return (EMSGSIZE);
                return (EMSGSIZE);

-       if ((so->so_snd.sb_flags & SB_LOCK) && (so->so_options & SO_NONBLOCKING))
+#ifdef notdef
+       /* NEED TO PREVENT BUSY WAITING IN SELECT FOR WRITING */
+       if ((so->so_snd.sb_flags & SB_LOCK) && (so->so_state & SS_NBIO))

                return (EWOULDBLOCK);
                return (EWOULDBLOCK);

+#endif
+restart:

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

-       s = splnet();

 again:
 again:

+       s = splnet();
+       if (so->so_state & SS_CANTSENDMORE) {
+               psignal(u.u_procp, SIGPIPE);
+               snderr(EPIPE);
+       }

        if (so->so_error) {
                error = so->so_error;
        if (so->so_error) {
                error = so->so_error;

-               so->so_error = 0;
+               so->so_error = 0;                               /* ??? */

                splx(s);
                goto release;
        }
                splx(s);
                goto release;
        }


@@ -291,35 +292,43 @@ again:
        }
        if (top) {
                error = (*so->so_proto->pr_usrreq)(so, PRU_SEND, top, asa);
        }
        if (top) {
                error = (*so->so_proto->pr_usrreq)(so, PRU_SEND, top, asa);

+               top = 0;

                if (error) {
                        splx(s);
                        goto release;
                }
                if (error) {
                        splx(s);
                        goto release;
                }

-               top = 0;

                mp = ⊤
        }
                mp = ⊤
        }

-       if (u.u_count == 0) {
+       if (uio->uio_resid == 0) {

                splx(s);
                goto release;
        }
        space = sbspace(&so->so_snd);
                splx(s);
                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 < uio->uio_resid) {
+               if (so->so_state & SS_NBIO)

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

-               goto again;
+               goto restart;

        }
        splx(s);
        }
        splx(s);

-       while (u.u_count && space > 0) {
+       while (uio->uio_resid > 0 && space > 0) {
+               register struct iovec *iov = uio->uio_iov;
+
+               if (iov->iov_len == 0) {
+                       uio->uio_iov++;
+                       uio->uio_iovcnt--;
+                       if (uio->uio_iovcnt < 0)
+                               panic("sosend");
+                       continue;
+               }

                MGET(m, 1);
                if (m == NULL) {
                MGET(m, 1);
                if (m == NULL) {

-                       error = ENOBUFS;
-                       m_freem(top);
+                       error = ENOBUFS;                        /* SIGPIPE? */

                        goto release;
                }
                        goto release;
                }

-               if (u.u_count >= CLBYTES && space >= CLBYTES) {
+               if (iov->iov_len >= CLBYTES && space >= CLBYTES) {

                        register struct mbuf *p;
                        MCLGET(p, 1);
                        if (p == 0)
                        register struct mbuf *p;
                        MCLGET(p, 1);
                        if (p == 0)


@@ -329,32 +338,33 @@ again:
                } else {
 nopages:
                        m->m_off = MMINOFF;
                } else {
 nopages:
                        m->m_off = MMINOFF;

-                       len = MIN(MLEN, u.u_count);
+                       len = MIN(MLEN, iov->iov_len);

                }
                }

-               iomove(mtod(m, caddr_t), len, B_WRITE);
+               uiomove(mtod(m, caddr_t), len, UIO_WRITE, uio);

                m->m_len = len;
                *mp = m;
                mp = &m->m_next;
                space = sbspace(&so->so_snd);
        }
                m->m_len = len;
                *mp = m;
                mp = &m->m_next;
                space = sbspace(&so->so_snd);
        }

-       s = splnet();

        goto again;
 
 release:
        sbunlock(&so->so_snd);
        goto again;
 
 release:
        sbunlock(&so->so_snd);

+       if (top)
+               m_freem(top);

        return (error);
 }
 
        return (error);
 }
 

-soreceive(so, asa)
+soreceive(so, asa, uio)

        register struct socket *so;
        struct sockaddr *asa;
        register struct socket *so;
        struct sockaddr *asa;

+       struct uio *uio;

 {
 {

+       register struct iovec *iov;

        register struct mbuf *m, *n;
        u_int len;
        register struct mbuf *m, *n;
        u_int len;

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

 
 

-COUNT(SORECEIVE);

 restart:
        sblock(&so->so_rcv);
        s = splnet();
 restart:
        sblock(&so->so_rcv);
        s = splnet();


@@ -374,7 +384,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);


@@ -396,29 +406,37 @@ 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, cnt);
+               if (uio->uio_resid <= 0)
+                       break;
+               len = uio->uio_resid;
+               so->so_state &= ~SS_RCVATMARK;
+               if (so->so_oobmark && len > so->so_oobmark)
+                       len = so->so_oobmark;
+               if (len > m->m_len)
+                       len = m->m_len;
+               splx(s);
+               uiomove(mtod(m, caddr_t), (int)len, UIO_READ, uio);
+               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;
                if (len == m->m_len) {
                        eor = (int)m->m_act;
                        sbfree(&so->so_rcv, m);
                        so->so_rcv.sb_mb = m->m_next;

-               }
-               splx(s);
-               iomove(mtod(m, caddr_t), len, B_READ);
-               cnt -= len;
-               s = splnet();
-               if (len == m->m_len) {

                        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) && cnt && !eor);
+               if (so->so_oobmark) {
+                       so->so_oobmark -= len;
+                       if (so->so_oobmark == 0) {
+                               so->so_state |= SS_RCVATMARK;
+                               break;
+                       }
+               }
+       } while ((m = so->so_rcv.sb_mb) && !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)


@@ -431,11 +449,6 @@ 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);
 release:
        sbunlock(&so->so_rcv);
        splx(s);


@@ -459,111 +472,68 @@ sohasoutofband(so)
 }
 
 /*ARGSUSED*/
 }
 
 /*ARGSUSED*/

-soioctl(so, cmd, cmdp)
+soioctl(so, cmd, data)

        register struct socket *so;
        int cmd;
        register struct socket *so;
        int cmd;

-       register caddr_t cmdp;
+       register char *data;

 {
 
 {
 

-COUNT(SOIOCTL);

        switch (cmd) {
 
        switch (cmd) {
 

-       case FIONBIO: {
-               int nbio;
-               if (copyin(cmdp, (caddr_t)&nbio, sizeof (nbio))) {
-                       u.u_error = EFAULT;
-                       return;
-               }
-               if (nbio)
-                       so->so_options |= SO_NONBLOCKING;
+       case FIONBIO:
+               if (*(int *)data)
+                       so->so_state |= SS_NBIO;

                else
                else

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

                return;
                return;

-       }

 
 

-       case FIOASYNC: {
-               int async;
-               if (copyin(cmdp, (caddr_t)&async, sizeof (async))) {
-                       u.u_error = EFAULT;
-                       return;
-               }
-               if (async)
-                       ;
+       case FIOASYNC:
+               if (*(int *)data)
+                       so->so_state |= SS_ASYNC;

                else
                else

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

                return;
                return;

-       }

 
 

-       case SIOCSKEEP: {
-               int keep;
-               if (copyin(cmdp, (caddr_t)&keep, sizeof (keep))) {
-                       u.u_error = EFAULT;
-                       return;
-               }
-               if (keep)
-                       so->so_options &= ~SO_NOKEEPALIVE;
+       case SIOCSKEEP:
+               if (*(int *)data)
+                       so->so_options &= ~SO_KEEPALIVE;

                else
                else

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

                return;
                return;

-       }

 
 

-       case SIOCGKEEP: {
-               int keep = (so->so_options & SO_NOKEEPALIVE) == 0;
-               if (copyout((caddr_t)&keep, cmdp, sizeof (keep)))
-                       u.u_error = EFAULT;
+       case SIOCGKEEP:
+               *(int *)data = (so->so_options & SO_KEEPALIVE) != 0;

                return;
                return;

-       }

 
 

-       case SIOCSLINGER: {
-               int linger;
-               if (copyin(cmdp, (caddr_t)&linger, sizeof (linger))) {
-                       u.u_error = EFAULT;
-                       return;
-               }
-               so->so_linger = linger;
+       case SIOCSLINGER:
+               so->so_linger = *(int *)data;

                if (so->so_linger)
                        so->so_options &= ~SO_DONTLINGER;
                else
                        so->so_options |= SO_DONTLINGER;
                return;
                if (so->so_linger)
                        so->so_options &= ~SO_DONTLINGER;
                else
                        so->so_options |= SO_DONTLINGER;
                return;

-       }

 
 

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

                return;
                return;

-       }

 
 

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

 
        case SIOCDONE: {
 
        case SIOCDONE: {

-               int flags;
-               if (copyin(cmdp, (caddr_t)&flags, sizeof (flags))) {
-                       u.u_error = EFAULT;
-                       return;
-               }
+               int flags = *(int *)data;
+

                flags++;
                if (flags & FREAD) {
                        int s = splimp();
                        socantrcvmore(so);
                        sbflush(&so->so_rcv);
                flags++;
                if (flags & FREAD) {
                        int s = splimp();
                        socantrcvmore(so);
                        sbflush(&so->so_rcv);

+                       splx(s);

                }
                if (flags & FWRITE)
                        u.u_error = (*so->so_proto->pr_usrreq)(so, PRU_SHUTDOWN, (struct mbuf *)0, 0);
                }
                if (flags & FWRITE)
                        u.u_error = (*so->so_proto->pr_usrreq)(so, PRU_SHUTDOWN, (struct mbuf *)0, 0);


@@ -571,48 +541,47 @@ COUNT(SOIOCTL);
        }
 
        case SIOCSENDOOB: {
        }
 
        case SIOCSENDOOB: {

-               char oob;
+               char oob = *(char *)data;

                struct mbuf *m;
                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_get(M_DONTWAIT);
                if (m == 0) {
                        u.u_error = ENOBUFS;
                        return;
                }
                m->m_off = MMINOFF;

-               m->m_len = 1;
-               *mtod(m, caddr_t) = oob;
+               m->m_len = sizeof (char);
+               *mtod(m, char *) = oob;

                (*so->so_proto->pr_usrreq)(so, PRU_SENDOOB, m, 0);
                return;
        }
 
        case SIOCRCVOOB: {
                struct mbuf *m = m_get(M_DONTWAIT);
                (*so->so_proto->pr_usrreq)(so, PRU_SENDOOB, m, 0);
                return;
        }
 
        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 (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);
+               *(char *)data = *mtod(m, char *);
+               (void) m_free(m);

                return;
        }
 
                return;
        }
 

-       case SIOCATMARK: {
-               int atmark = (so->so_state&SS_RCVATMARK) != 0;
-               if (copyout((caddr_t)&atmark, cmdp, sizeof (atmark))) {
-                       u.u_error = EFAULT;
+       case SIOCATMARK:
+               *(int *)data = (so->so_state&SS_RCVATMARK) != 0;
+               return;
+
+       /* routing table update calls */
+       case SIOCADDRT:
+       case SIOCDELRT:
+               if (!suser())

                        return;
                        return;

-               }
+               u.u_error = rtrequest(cmd, (struct rtentry *)data);

                return;
                return;

-       }
+

        /* type/protocol specific ioctls */
        }
        u.u_error = EOPNOTSUPP;
        /* type/protocol specific ioctls */
        }
        u.u_error = EOPNOTSUPP;