add Berkeley header

[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 cd2f325..33b6274 100644 (file)
--- a/usr/src/sys/kern/uipc_socket.c
+++ b/usr/src/sys/kern/uipc_socket.c
@@ -1,31 +1,27 @@
 /*
 /*

- * Copyright (c) 1982 Regents of the University of California.
- * All rights reserved.  The Berkeley software License Agreement
- * specifies the terms and conditions for redistribution.
+ * Copyright (c) 1982, 1986 Regents of the University of California.
+ * All rights reserved.

  *
  *

- *     @(#)uipc_socket.c       6.18 (Berkeley) %G%
+ * Redistribution and use in source and binary forms are permitted
+ * provided that this notice is preserved and that due credit is given
+ * to the University of California at Berkeley. The name of the University
+ * may not be used to endorse or promote products derived from this
+ * software without specific prior written permission. This software
+ * is provided ``as is'' without express or implied warranty.
+ *
+ *     @(#)uipc_socket.c       7.7 (Berkeley) %G%

  */
 
 #include "param.h"
  */
 
 #include "param.h"

-#include "systm.h"

 #include "dir.h"
 #include "user.h"
 #include "proc.h"
 #include "file.h"
 #include "dir.h"
 #include "user.h"
 #include "proc.h"
 #include "file.h"

-#include "inode.h"
-#include "buf.h"

 #include "mbuf.h"
 #include "mbuf.h"

-#include "un.h"

 #include "domain.h"
 #include "protosw.h"
 #include "socket.h"
 #include "socketvar.h"
 #include "domain.h"
 #include "protosw.h"
 #include "socket.h"
 #include "socketvar.h"

-#include "stat.h"
-#include "ioctl.h"
-#include "uio.h"
-#include "../net/route.h"
-#include "../netinet/in.h"
-#include "../net/if.h"

 
 /*
  * Socket operation routines.
 
 /*
  * Socket operation routines.


@@ -121,13 +117,13 @@ sofree(so)
        register struct socket *so;
 {
 
        register struct socket *so;
 {
 

+       if (so->so_pcb || (so->so_state & SS_NOFDREF) == 0)
+               return;

        if (so->so_head) {
                if (!soqremque(so, 0) && !soqremque(so, 1))
                        panic("sofree dq");
                so->so_head = 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);
        sorflush(so);
        (void) m_free(dtom(so));
        sbrelease(&so->so_snd);
        sorflush(so);
        (void) m_free(dtom(so));


@@ -154,7 +150,7 @@ soclose(so)
                goto discard;
        if (so->so_state & SS_ISCONNECTED) {
                if ((so->so_state & SS_ISDISCONNECTING) == 0) {
                goto discard;
        if (so->so_state & SS_ISCONNECTED) {
                if ((so->so_state & SS_ISDISCONNECTING) == 0) {

-                       error = sodisconnect(so, (struct mbuf *)0);
+                       error = sodisconnect(so);

                        if (error)
                                goto drop;
                }
                        if (error)
                                goto drop;
                }


@@ -215,9 +211,12 @@ soconnect(so, nam)
        register struct socket *so;
        struct mbuf *nam;
 {
        register struct socket *so;
        struct mbuf *nam;
 {

-       int s = splnet();
+       int s;

        int error;
 
        int error;
 

+       if (so->so_options & SO_ACCEPTCONN)
+               return (EOPNOTSUPP);
+       s = splnet();

        /*
         * If protocol is connection-based, can only connect once.
         * Otherwise, if connected, try to disconnect first.
        /*
         * If protocol is connection-based, can only connect once.
         * Otherwise, if connected, try to disconnect first.


@@ -248,9 +247,8 @@ soconnect2(so1, so2)
        return (error);
 }
 
        return (error);
 }
 

-sodisconnect(so, nam)
+sodisconnect(so)

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

-       struct mbuf *nam;

 {
        int s = splnet();
        int error;
 {
        int s = splnet();
        int error;


@@ -264,7 +262,7 @@ sodisconnect(so, nam)
                goto bad;
        }
        error = (*so->so_proto->pr_usrreq)(so, PRU_DISCONNECT,
                goto bad;
        }
        error = (*so->so_proto->pr_usrreq)(so, PRU_DISCONNECT,

-           (struct mbuf *)0, nam, (struct mbuf *)0);
+           (struct mbuf *)0, (struct mbuf *)0, (struct mbuf *)0);

 bad:
        splx(s);
        return (error);
 bad:
        splx(s);
        return (error);


@@ -289,7 +287,7 @@ sosend(so, nam, uio, flags, rights)
        struct mbuf *top = 0;
        register struct mbuf *m, **mp;
        register int space;
        struct mbuf *top = 0;
        register struct mbuf *m, **mp;
        register int space;

-       int len, error = 0, s, dontroute, first = 1;
+       int len, rlen = 0, error = 0, s, dontroute, first = 1;

 
        if (sosendallatonce(so) && uio->uio_resid > so->so_snd.sb_hiwat)
                return (EMSGSIZE);
 
        if (sosendallatonce(so) && uio->uio_resid > so->so_snd.sb_hiwat)
                return (EMSGSIZE);


@@ -297,6 +295,8 @@ sosend(so, nam, uio, flags, rights)
            (flags & MSG_DONTROUTE) && (so->so_options & SO_DONTROUTE) == 0 &&
            (so->so_proto->pr_flags & PR_ATOMIC);
        u.u_ru.ru_msgsnd++;
            (flags & MSG_DONTROUTE) && (so->so_options & SO_DONTROUTE) == 0 &&
            (so->so_proto->pr_flags & PR_ATOMIC);
        u.u_ru.ru_msgsnd++;

+       if (rights)
+               rlen = rights->m_len;

 #define        snderr(errno)   { error = errno; splx(s); goto release; }
 
 restart:
 #define        snderr(errno)   { error = errno; splx(s); goto release; }
 
 restart:


@@ -321,8 +321,9 @@ restart:
                        space = 1024;
                else {
                        space = sbspace(&so->so_snd);
                        space = 1024;
                else {
                        space = sbspace(&so->so_snd);

-                       if (space <= 0 ||
-                          (sosendallatonce(so) && space < uio->uio_resid) ||
+                       if (space <= rlen ||
+                          (sosendallatonce(so) &&
+                               space < uio->uio_resid + rlen) ||

                           (uio->uio_resid >= CLBYTES && space < CLBYTES &&
                           so->so_snd.sb_cc >= CLBYTES &&
                           (so->so_state & SS_NBIO) == 0)) {
                           (uio->uio_resid >= CLBYTES && space < CLBYTES &&
                           so->so_snd.sb_cc >= CLBYTES &&
                           (so->so_state & SS_NBIO) == 0)) {


@@ -340,21 +341,18 @@ restart:
                }
                splx(s);
                mp = &top;
                }
                splx(s);
                mp = &top;

+               space -= rlen;

                while (space > 0) {
                while (space > 0) {

-                       register struct iovec *iov = uio->uio_iov;
-

                        MGET(m, M_WAIT, MT_DATA);
                        MGET(m, M_WAIT, MT_DATA);

-                       if (iov->iov_len >= NBPG && space >= CLBYTES) {
-                               register struct mbuf *p;
-                               MCLGET(p, 1);
-                               if (p == 0)
+                       if (uio->uio_resid >= CLBYTES / 2 && space >= CLBYTES) {
+                               MCLGET(m);
+                               if (m->m_len != CLBYTES)

                                        goto nopages;
                                        goto nopages;

-                               m->m_off = (int)p - (int)m;
-                               len = MIN(CLBYTES, iov->iov_len);
+                               len = MIN(CLBYTES, uio->uio_resid);

                                space -= CLBYTES;
                        } else {
 nopages:
                                space -= CLBYTES;
                        } else {
 nopages:

-                               len = MIN(MLEN, iov->iov_len);
+                               len = MIN(MIN(MLEN, uio->uio_resid), space);

                                space -= len;
                        }
                        error = uiomove(mtod(m, caddr_t), len, UIO_WRITE, uio);
                                space -= len;
                        }
                        error = uiomove(mtod(m, caddr_t), len, UIO_WRITE, uio);


@@ -365,12 +363,6 @@ nopages:
                        mp = &m->m_next;
                        if (uio->uio_resid <= 0)
                                break;
                        mp = &m->m_next;
                        if (uio->uio_resid <= 0)
                                break;

-                       while (uio->uio_iov->iov_len == 0) {
-                               uio->uio_iov++;
-                               uio->uio_iovcnt--;
-                               if (uio->uio_iovcnt <= 0)
-                                       panic("sosend");
-                       }

                }
                if (dontroute)
                        so->so_options |= SO_DONTROUTE;
                }
                if (dontroute)
                        so->so_options |= SO_DONTROUTE;


@@ -382,6 +374,7 @@ nopages:
                if (dontroute)
                        so->so_options &= ~SO_DONTROUTE;
                rights = 0;
                if (dontroute)
                        so->so_options &= ~SO_DONTROUTE;
                rights = 0;

+               rlen = 0;

                top = 0;
                first = 0;
                if (error)
                top = 0;
                first = 0;
                if (error)


@@ -397,6 +390,18 @@ release:
        return (error);
 }
 
        return (error);
 }
 

+/*
+ * Implement receive operations on a socket.
+ * We depend on the way that records are added to the sockbuf
+ * by sbappend*.  In particular, each record (mbufs linked through m_next)
+ * must begin with an address if the protocol so specifies,
+ * followed by an optional mbuf containing access rights if supported
+ * by the protocol, and then zero or more mbufs of data.
+ * In order to avoid blocking network interrupts for the entire time here,
+ * we splx() while doing the actual copy to user space.
+ * Although the sockbuf is locked, new data may still be appended,
+ * and thus we must maintain consistency of the sockbuf during that time.
+ */

 soreceive(so, aname, uio, flags, rightsp)
        register struct socket *so;
        struct mbuf **aname;
 soreceive(so, aname, uio, flags, rightsp)
        register struct socket *so;
        struct mbuf **aname;


@@ -404,8 +409,8 @@ soreceive(so, aname, uio, flags, rightsp)
        int flags;
        struct mbuf **rightsp;
 {
        int flags;
        struct mbuf **rightsp;
 {

-       register struct mbuf *m, *n;
-       register int len, error = 0, s, tomark;
+       register struct mbuf *m;
+       register int len, error = 0, s, offset;

        struct protosw *pr = so->so_proto;
        struct mbuf *nextrecord;
        int moff;
        struct protosw *pr = so->so_proto;
        struct mbuf *nextrecord;
        int moff;


@@ -438,23 +443,25 @@ restart:
        sblock(&so->so_rcv);
        s = splnet();
 
        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_error) {
                        error = so->so_error;
                        so->so_error = 0;
        if (so->so_rcv.sb_cc == 0) {
                if (so->so_error) {
                        error = so->so_error;
                        so->so_error = 0;

-                       splx(s);

                        goto release;
                }
                        goto release;
                }

-               if (so->so_state & SS_CANTRCVMORE) {
-                       splx(s);
+               if (so->so_state & SS_CANTRCVMORE)

                        goto release;
                        goto release;

-               }

                if ((so->so_state & SS_ISCONNECTED) == 0 &&
                if ((so->so_state & SS_ISCONNECTED) == 0 &&

-                   (so->so_proto->pr_flags & PR_CONNREQUIRED))
-                       rcverr(ENOTCONN);
-               if (so->so_state & SS_NBIO)
-                       rcverr(EWOULDBLOCK);
+                   (so->so_proto->pr_flags & PR_CONNREQUIRED)) {
+                       error = ENOTCONN;
+                       goto release;
+               }
+               if (uio->uio_resid == 0)
+                       goto release;
+               if (so->so_state & SS_NBIO) {
+                       error = EWOULDBLOCK;
+                       goto release;
+               }

                sbunlock(&so->so_rcv);
                sbwait(&so->so_rcv);
                splx(s);
                sbunlock(&so->so_rcv);
                sbwait(&so->so_rcv);
                splx(s);


@@ -462,51 +469,62 @@ restart:
        }
        u.u_ru.ru_msgrcv++;
        m = so->so_rcv.sb_mb;
        }
        u.u_ru.ru_msgrcv++;
        m = so->so_rcv.sb_mb;

+       if (m == 0)
+               panic("receive 1");
+       nextrecord = m->m_act;

        if (pr->pr_flags & PR_ADDR) {
        if (pr->pr_flags & PR_ADDR) {

-               if (m == 0 || m->m_type != MT_SONAME)
+               if (m->m_type != MT_SONAME)

                        panic("receive 1a");
                if (flags & MSG_PEEK) {
                        if (aname)
                                *aname = m_copy(m, 0, m->m_len);
                        panic("receive 1a");
                if (flags & MSG_PEEK) {
                        if (aname)
                                *aname = m_copy(m, 0, m->m_len);

-                       else
-                               m = m->m_act;
+                       m = m->m_next;

                } else {
                } else {

+                       sbfree(&so->so_rcv, m);

                        if (aname) {
                                *aname = m;
                        if (aname) {
                                *aname = m;

-                               sbfree(&so->so_rcv, m);
-if(m->m_next) panic("receive 1b");
-                               so->so_rcv.sb_mb = m = m->m_act;
-                       } else
-                               m = sbdroprecord(&so->so_rcv);
+                               m = m->m_next;
+                               (*aname)->m_next = 0;
+                               so->so_rcv.sb_mb = m;
+                       } else {
+                               MFREE(m, so->so_rcv.sb_mb);
+                               m = so->so_rcv.sb_mb;
+                       }
+                       if (m)
+                               m->m_act = nextrecord;

                }
        }
        if (m && m->m_type == MT_RIGHTS) {
                if ((pr->pr_flags & PR_RIGHTS) == 0)
                }
        }
        if (m && m->m_type == MT_RIGHTS) {
                if ((pr->pr_flags & PR_RIGHTS) == 0)

-                       panic("receive 2a");
+                       panic("receive 2");

                if (flags & MSG_PEEK) {
                        if (rightsp)
                                *rightsp = m_copy(m, 0, m->m_len);
                if (flags & MSG_PEEK) {
                        if (rightsp)
                                *rightsp = m_copy(m, 0, m->m_len);

-                       else
-                               m = m->m_act;
+                       m = m->m_next;

                } else {
                } else {

+                       sbfree(&so->so_rcv, m);

                        if (rightsp) {
                                *rightsp = m;
                        if (rightsp) {
                                *rightsp = m;

-                               sbfree(&so->so_rcv, m);
-if(m->m_next) panic("receive 2b");
-                               so->so_rcv.sb_mb = m = m->m_act;
-                       } else
-                               m = sbdroprecord(&so->so_rcv);
+                               so->so_rcv.sb_mb = m->m_next;
+                               m->m_next = 0;
+                               m = so->so_rcv.sb_mb;
+                       } else {
+                               MFREE(m, so->so_rcv.sb_mb);
+                               m = so->so_rcv.sb_mb;
+                       }
+                       if (m)
+                               m->m_act = nextrecord;

                }
        }
                }
        }

-       if (m == 0 || (m->m_type != MT_DATA && m->m_type != MT_HEADER))
-               panic("receive 3");

        moff = 0;
        moff = 0;

-       tomark = so->so_oobmark;
+       offset = 0;

        while (m && uio->uio_resid > 0 && error == 0) {
        while (m && uio->uio_resid > 0 && error == 0) {

+               if (m->m_type != MT_DATA && m->m_type != MT_HEADER)
+                       panic("receive 3");

                len = uio->uio_resid;
                so->so_state &= ~SS_RCVATMARK;
                len = uio->uio_resid;
                so->so_state &= ~SS_RCVATMARK;

-               if (tomark && len > tomark)
-                       len = tomark;
+               if (so->so_oobmark && len > so->so_oobmark - offset)
+                       len = so->so_oobmark - offset;

                if (len > m->m_len - moff)
                        len = m->m_len - moff;
                splx(s);
                if (len > m->m_len - moff)
                        len = m->m_len - moff;
                splx(s);


@@ -514,16 +532,17 @@ if(m->m_next) panic("receive 2b");
                    uiomove(mtod(m, caddr_t) + moff, (int)len, UIO_READ, uio);
                s = splnet();
                if (len == m->m_len - moff) {
                    uiomove(mtod(m, caddr_t) + moff, (int)len, UIO_READ, uio);
                s = splnet();
                if (len == m->m_len - moff) {

-                       if ((flags & MSG_PEEK) == 0) {
+                       if (flags & MSG_PEEK) {
+                               m = m->m_next;
+                               moff = 0;
+                       } else {

                                nextrecord = m->m_act;
                                sbfree(&so->so_rcv, m);
                                nextrecord = m->m_act;
                                sbfree(&so->so_rcv, m);

-                               MFREE(m, n);
-                               if (m = n)
+                               MFREE(m, so->so_rcv.sb_mb);
+                               m = so->so_rcv.sb_mb;
+                               if (m)

                                        m->m_act = nextrecord;
                                        m->m_act = nextrecord;

-                               so->so_rcv.sb_mb = m;
-                       } else
-                               m = m->m_next;
-                       moff = 0;
+                       }

                } else {
                        if (flags & MSG_PEEK)
                                moff += len;
                } else {
                        if (flags & MSG_PEEK)
                                moff += len;


@@ -533,17 +552,15 @@ if(m->m_next) panic("receive 2b");
                                so->so_rcv.sb_cc -= len;
                        }
                }
                                so->so_rcv.sb_cc -= len;
                        }
                }

-               if ((flags & MSG_PEEK) == 0 && so->so_oobmark) {
-                       so->so_oobmark -= len;
-                       if (so->so_oobmark == 0) {
-                               so->so_state |= SS_RCVATMARK;
-                               break;
-                       }
-               }
-               if (tomark) {
-                       tomark -= len;
-                       if (tomark == 0)
-                               break;
+               if (so->so_oobmark) {
+                       if ((flags & MSG_PEEK) == 0) {
+                               so->so_oobmark -= len;
+                               if (so->so_oobmark == 0) {
+                                       so->so_state |= SS_RCVATMARK;
+                                       break;
+                               }
+                       } else
+                               offset += len;

                }
        }
        if ((flags & MSG_PEEK) == 0) {
                }
        }
        if ((flags & MSG_PEEK) == 0) {


@@ -554,11 +571,12 @@ if(m->m_next) panic("receive 2b");
                if (pr->pr_flags & PR_WANTRCVD && so->so_pcb)
                        (*pr->pr_usrreq)(so, PRU_RCVD, (struct mbuf *)0,
                            (struct mbuf *)0, (struct mbuf *)0);
                if (pr->pr_flags & PR_WANTRCVD && so->so_pcb)
                        (*pr->pr_usrreq)(so, PRU_RCVD, (struct mbuf *)0,
                            (struct mbuf *)0, (struct mbuf *)0);

+               if (error == 0 && rightsp && *rightsp &&
+                   pr->pr_domain->dom_externalize)
+                       error = (*pr->pr_domain->dom_externalize)(*rightsp);

        }
 release:
        sbunlock(&so->so_rcv);
        }
 release:
        sbunlock(&so->so_rcv);

-       if (error == 0 && rightsp && *rightsp && pr->pr_domain->dom_externalize)
-               error = (*pr->pr_domain->dom_externalize)(*rightsp);

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


@@ -628,6 +646,7 @@ sosetopt(so, level, optname, m0)
                case SO_USELOOPBACK:
                case SO_BROADCAST:
                case SO_REUSEADDR:
                case SO_USELOOPBACK:
                case SO_BROADCAST:
                case SO_REUSEADDR:

+               case SO_OOBINLINE:

                        if (m == NULL || m->m_len < sizeof (int)) {
                                error = EINVAL;
                                goto bad;
                        if (m == NULL || m->m_len < sizeof (int)) {
                                error = EINVAL;
                                goto bad;


@@ -717,6 +736,7 @@ sogetopt(so, level, optname, mp)
                case SO_KEEPALIVE:
                case SO_REUSEADDR:
                case SO_BROADCAST:
                case SO_KEEPALIVE:
                case SO_REUSEADDR:
                case SO_BROADCAST:

+               case SO_OOBINLINE:

                        *mtod(m, int *) = so->so_options & optname;
                        break;
 
                        *mtod(m, int *) = so->so_options & optname;
                        break;
 


@@ -754,7 +774,7 @@ sogetopt(so, level, optname, mp)
                        break;
 
                default:
                        break;
 
                default:

-                       m_free(m);
+                       (void)m_free(m);

                        return (ENOPROTOOPT);
                }
                *mp = m;
                        return (ENOPROTOOPT);
                }
                *mp = m;