projects / unix-history / blobdiff
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
purge COUNT crap now that we have gprof
[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 3b650f0..150ba40 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.6     81/11/18        */
+/*     uipc_socket.c   4.42    82/06/20        */
 
 #include "../h/param.h"
 #include "../h/systm.h"
 
 #include "../h/param.h"
 #include "../h/systm.h"
@@ -13,8 +13,10 @@
 #include "../h/socket.h"
 #include "../h/socketvar.h"
 #include "../h/stat.h"
 #include "../h/socket.h"
 #include "../h/socketvar.h"
 #include "../h/stat.h"
-#include "../net/inet.h"
-#include "../net/inet_systm.h"
+#include "../h/ioctl.h"
+#include "../net/in.h"
+#include "../net/in_systm.h"
+#include "../net/route.h"
 
 /*
  * Socket support routines.
 
 /*
  * Socket support routines.
@@ -36,7 +38,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
@@ -69,16 +70,21 @@ 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
         * and reserving resources.
         */
        so->so_proto = prp;
 
        /*
         * Attach protocol to socket, initializing
         * and reserving resources.
         */
        so->so_proto = prp;
-       (*prp->pr_usrreq)(so, PRU_ATTACH, 0, asa);
-       if (so->so_error) {
-               error = so->so_error;
-               m_free(dtom(so));
+       error = (*prp->pr_usrreq)(so, PRU_ATTACH, 0, asa);
+       if (error) {
+               if (so->so_snd.sb_mbmax || so->so_rcv.sb_mbmax)
+                       panic("socreate");
+               so->so_state |= SS_USERGONE;
+               sofree(so);
                return (error);
        }
        *aso = so;
                return (error);
        }
        *aso = so;
@@ -89,71 +95,75 @@ sofree(so)
        struct socket *so;
 {
 
        struct socket *so;
 {
 
-COUNT(SOFREE);
-       m_free(dtom(so));
+       if (so->so_pcb || (so->so_state & SS_USERGONE) == 0)
+               return;
+       sbrelease(&so->so_snd);
+       sbrelease(&so->so_rcv);
+       (void) m_free(dtom(so));
 }
 
 /*
  * 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 */
 
-COUNT(SOCLOSE);
        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 (u.u_error) {
        if (so->so_state & SS_ISCONNECTED) {
                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) &&
+                           (so->so_state & SS_NBIO) &&
+                           exiting == 0) {
+                               u.u_error = EINPROGRESS;
                                splx(s);
                                return;
                        }
                                splx(s);
                                return;
                        }
+                       /* should use tsleep here, for at most linger */
+                       while (so->so_state & SS_ISCONNECTED)
+                               sleep((caddr_t)&so->so_timeo, PZERO+1);
                }
                }
-               if ((so->so_state & SS_ISDISCONNECTING) &&
-                   (so->so_options & SO_NBIO)) {
-                       u.u_error = EINPROGRESS;
+       }
+drop:
+       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;
                }
                        splx(s);
                        return;
                }
-               while (so->so_state & SS_ISCONNECTED)
-                       sleep((caddr_t)&so->so_timeo, PZERO+1);
        }
        }
-       u.u_error = (*so->so_proto->pr_usrreq)(so, PRU_DETACH, 0, 0);
 discard:
 discard:
-       if (so->so_pcb == 0)
-               sofree(so);
+       so->so_state |= SS_USERGONE;
+       sofree(so);
        splx(s);
 }
 
        splx(s);
 }
 
-sosplice(pso, so)
-       struct socket *pso, *so;
-{
-
-COUNT(SOSPLICE);
-       if (pso->so_proto->pr_family != PF_LOCAL) {
-               struct socket *tso;
-               tso = pso; pso = so; so = tso;
-       }
-       if (pso->so_proto->pr_family != PF_LOCAL)
-               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);
-       return (EOPNOTSUPP);
+       bzero((caddr_t)sb, sizeof (*sb));               /* XXX */
+       return (0);                                     /* XXX */
 }
 
 /*
 }
 
 /*
@@ -166,15 +176,15 @@ soaccept(so, asa)
        int s = splnet();
        int error;
 
        int s = splnet();
        int error;
 
-COUNT(SOACCEPT);
-       if (so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING)) {
-               error = EISCONN;
-               goto bad;
-       }
        if ((so->so_options & SO_ACCEPTCONN) == 0) {
                error = EINVAL;                 /* XXX */
                goto bad;
        }
        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);
 bad:
        splx(s);
        error = (*so->so_proto->pr_usrreq)(so, PRU_ACCEPT, 0, (caddr_t)asa);
 bad:
        splx(s);
@@ -193,7 +203,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;
@@ -217,7 +226,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;
@@ -249,58 +257,71 @@ sosend(so, asa)
        register u_int len;
        int error = 0, space, s;
 
        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)
                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_NBIO))
+#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;
+               so->so_error = 0;                               /* ??? */
+               splx(s);
+               goto release;
+       }
        if ((so->so_state & SS_ISCONNECTED) == 0) {
                if (so->so_proto->pr_flags & PR_CONNREQUIRED)
                        snderr(ENOTCONN);
                if (asa == 0)
                        snderr(EDESTADDRREQ);
        }
        if ((so->so_state & SS_ISCONNECTED) == 0) {
                if (so->so_proto->pr_flags & PR_CONNREQUIRED)
                        snderr(ENOTCONN);
                if (asa == 0)
                        snderr(EDESTADDRREQ);
        }
-       if (so->so_error)
-               snderr(so->so_error);
        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 (sosendallatonce(so) && sbspace(&so->so_snd) < u.u_count) {
-               if (so->so_options & SO_NBIO)
+       if (u.u_count == 0) {
+               splx(s);
+               goto release;
+       }
+       space = sbspace(&so->so_snd);
+       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);
                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 = sbspace(&so->so_snd)) > 0) {
+       while (u.u_count && space > 0) {
                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 >= PGSIZE && space >= NMBPG) {
+               if (u.u_count >= CLBYTES && space >= CLBYTES) {
                        register struct mbuf *p;
                        register struct mbuf *p;
-                       MPGET(p, 1);
+                       MCLGET(p, 1);
                        if (p == 0)
                                goto nopages;
                        m->m_off = (int)p - (int)m;
                        if (p == 0)
                                goto nopages;
                        m->m_off = (int)p - (int)m;
-                       len = PGSIZE;
+                       len = CLBYTES;
                } else {
 nopages:
                        m->m_off = MMINOFF;
                } else {
 nopages:
                        m->m_off = MMINOFF;
@@ -310,12 +331,14 @@ nopages:
                m->m_len = len;
                *mp = m;
                mp = &m->m_next;
                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);
 }
 
@@ -325,61 +348,71 @@ 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:
        sblock(&so->so_rcv);
        s = splnet();
 
 #define        rcverr(errno)   { error = errno; splx(s); goto release; }
        if (so->so_rcv.sb_cc == 0) {
 restart:
        sblock(&so->so_rcv);
        s = splnet();
 
 #define        rcverr(errno)   { error = errno; splx(s); goto release; }
        if (so->so_rcv.sb_cc == 0) {
-               if ((so->so_state & SS_ISCONNECTED) == 0 &&
-                   (so->so_proto->pr_flags & PR_CONNREQUIRED))
-                       rcverr(ENOTCONN);
+               if (so->so_error) {
+                       error = so->so_error;
+                       so->so_error = 0;
+                       splx(s);
+                       goto release;
+               }
                if (so->so_state & SS_CANTRCVMORE) {
                        splx(s);
                        goto release;
                }
                if (so->so_state & SS_CANTRCVMORE) {
                        splx(s);
                        goto release;
                }
-               if (so->so_options & SO_NBIO)
-                       rcverr (EWOULDBLOCK);
+               if ((so->so_state & SS_ISCONNECTED) == 0 &&
+                   (so->so_proto->pr_flags & PR_CONNREQUIRED))
+                       rcverr(ENOTCONN);
+               if (so->so_state & SS_NBIO)
+                       rcverr(EWOULDBLOCK);
                sbunlock(&so->so_rcv);
                sbunlock(&so->so_rcv);
-               sleep((caddr_t)&so->so_rcv.sb_cc, PZERO+1);
+               sbwait(&so->so_rcv);
+               splx(s);
                goto restart;
        }
        m = so->so_rcv.sb_mb;
        if (m == 0)
                panic("receive");
                goto restart;
        }
        m = so->so_rcv.sb_mb;
        if (m == 0)
                panic("receive");
-       if ((so->so_proto->pr_flags & PR_ADDR)) {
-               so->so_rcv.sb_mb = m->m_next;
-               if (asa) {
-                       so->so_rcv.sb_cc -= m->m_len;
-                       len = MIN(m->m_len, sizeof (struct sockaddr));
-                       bcopy(mtod(m, caddr_t), (caddr_t)asa, len);
-               } else
-                       bzero((caddr_t)asa, sizeof (*asa));
-               m = so->so_rcv.sb_mb;
+       if (so->so_proto->pr_flags & PR_ADDR) {
+               if (m->m_len != sizeof (struct sockaddr))
+                       panic("soreceive addr");
+               if (asa)
+                       bcopy(mtod(m, caddr_t), (caddr_t)asa, sizeof (*asa));
+               so->so_rcv.sb_cc -= m->m_len;
+               so->so_rcv.sb_mbcnt -= MSIZE;
+               m = m_free(m);
                if (m == 0)
                        panic("receive 2");
                if (m == 0)
                        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);
-               }
+               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)
@@ -392,12 +425,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;
@@ -405,23 +459,171 @@ soioctl(so, cmd, cmdp)
        register caddr_t cmdp;
 {
 
        register caddr_t cmdp;
 {
 
-COUNT(SOIOCTL);
-       switch (cmdp) {
+       switch (cmd) {
+
+       case FIONBIO: {
+               int nbio;
+               if (copyin(cmdp, (caddr_t)&nbio, sizeof (nbio))) {
+                       u.u_error = EFAULT;
+                       return;
+               }
+               if (nbio)
+                       so->so_state |= SS_NBIO;
+               else
+                       so->so_state &= ~SS_NBIO;
+               return;
+       }
+
+       case FIOASYNC: {
+               int async;
+               if (copyin(cmdp, (caddr_t)&async, sizeof (async))) {
+                       u.u_error = EFAULT;
+                       return;
+               }
+               if (async)
+                       so->so_state |= SS_ASYNC;
+               else
+                       so->so_state &= ~SS_ASYNC;
+               return;
+       }
+
+       case SIOCSKEEP: {
+               int keep;
+               if (copyin(cmdp, (caddr_t)&keep, sizeof (keep))) {
+                       u.u_error = EFAULT;
+                       return;
+               }
+               if (keep)
+                       so->so_options &= ~SO_KEEPALIVE;
+               else
+                       so->so_options |= SO_KEEPALIVE;
+               return;
+       }
+
+       case SIOCGKEEP: {
+               int keep = (so->so_options & SO_KEEPALIVE) != 0;
+               if (copyout((caddr_t)&keep, cmdp, sizeof (keep)))
+                       u.u_error = EFAULT;
+               return;
+       }
+
+       case SIOCSLINGER: {
+               int linger;
+               if (copyin(cmdp, (caddr_t)&linger, sizeof (linger))) {
+                       u.u_error = EFAULT;
+                       return;
+               }
+               so->so_linger = linger;
+               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;
+               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;
+               if (copyin(cmdp, (caddr_t)&flags, sizeof (flags))) {
+                       u.u_error = EFAULT;
+                       return;
+               }
+               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);
+               return;
        }
        }
-       switch (so->so_type) {
 
 
-       case SOCK_STREAM:
-               break;
+       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;
+       }
 
 
-       case SOCK_DGRAM:
-               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_RDM:
-               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;
+       }
 
 
-       case SOCK_RAW:
-               break;
+       /* routing table update calls */
+       case SIOCADDRT:
+       case SIOCDELRT:
+       case SIOCCHGRT: {
+               struct rtentry route;
+               if (!suser())
+                       return;
+               if (copyin(cmdp, (caddr_t)&route, sizeof (route))) {
+                       u.u_error = EFAULT;
+                       return;
+               }
+               u.u_error = rtrequest(cmd, &route);
+               return;
+       }
 
 
+       /* type/protocol specific ioctls */
        }
        }
+       u.u_error = EOPNOTSUPP;
 }
 }
Continuous source code history from original PDP-7 UNIX to FreeBSD 2, the first fully unencumbered FreeBSD release.