use rdwri()

[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 98ee4a0..1193d69 100644 (file)
--- a/usr/src/sys/kern/uipc_socket.c
+++ b/usr/src/sys/kern/uipc_socket.c
@@ -1,4 +1,4 @@
-/*     socket.c        4.43    82/07/21        */
+/*     uipc_socket.c   4.47    82/08/14        */

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


@@ -17,6 +17,7 @@
 #include "../net/in.h"
 #include "../net/in_systm.h"
 #include "../net/route.h"
 #include "../net/in.h"
 #include "../net/in_systm.h"
 #include "../net/route.h"

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

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


@@ -345,14 +346,16 @@ release:
        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, resid = uio->uio_resid;
+       int cnt;

 
 restart:
        sblock(&so->so_rcv);
 
 restart:
        sblock(&so->so_rcv);


@@ -395,15 +398,19 @@ 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_iovcnt == 0)
+                       break;
+               iov = uio->uio_iov;
+               len = iov->iov_len;
+               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);
                splx(s);

-               iomove(mtod(m, caddr_t), len, B_READ);
-               cnt -= len;
+               uiomove(mtod(m, caddr_t), len, UIO_WRITETO, uio);

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


@@ -415,7 +422,14 @@ restart:
                        m->m_len -= len;
                        so->so_rcv.sb_cc -= 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)


@@ -428,11 +442,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);


@@ -456,105 +465,62 @@ 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;

 {
 
        switch (cmd) {
 
 {
 
        switch (cmd) {
 

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

                        so->so_state |= SS_NBIO;
                else
                        so->so_state &= ~SS_NBIO;
                return;
                        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)
+       case FIOASYNC:
+               if (*(int *)data)

                        so->so_state |= SS_ASYNC;
                else
                        so->so_state &= ~SS_ASYNC;
                return;
                        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)
+       case SIOCSKEEP:
+               if (*(int *)data)

                        so->so_options &= ~SO_KEEPALIVE;
                else
                        so->so_options |= SO_KEEPALIVE;
                return;
                        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;
+       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();
                flags++;
                if (flags & FREAD) {
                        int s = splimp();


@@ -568,63 +534,46 @@ soioctl(so, cmd, cmdp)
        }
 
        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;
-                       return;
-               }
+       case SIOCATMARK:
+               *(int *)data = (so->so_state&SS_RCVATMARK) != 0;

                return;
                return;

-       }

 
        /* routing table update calls */
        case SIOCADDRT:
        case SIOCDELRT:
 
        /* routing table update calls */
        case SIOCADDRT:
        case SIOCDELRT:

-       case SIOCCHGRT: {
-               struct rtentry route;

                if (!suser())
                        return;
                if (!suser())
                        return;

-               if (copyin(cmdp, (caddr_t)&route, sizeof (route))) {
-                       u.u_error = EFAULT;
-                       return;
-               }
-               u.u_error = rtrequest(cmd, &route);
+               u.u_error = rtrequest(cmd, (struct rtentry *)data);

                return;
                return;

-       }

 
        /* type/protocol specific ioctls */
        }
 
        /* type/protocol specific ioctls */
        }