merge in vnode changes

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

diff --git a/usr/src/sys/kern/uipc_syscalls.c b/usr/src/sys/kern/uipc_syscalls.c
index 2dac5ba..c652eb9 100644 (file)
--- a/usr/src/sys/kern/uipc_syscalls.c
+++ b/usr/src/sys/kern/uipc_syscalls.c
@@ -1,18 +1,33 @@
-/*     uipc_syscalls.c 4.47    83/06/14        */
-
-#include "../h/param.h"
-#include "../h/systm.h"
-#include "../h/dir.h"
-#include "../h/user.h"
-#include "../h/proc.h"
-#include "../h/file.h"
-#include "../h/inode.h"
-#include "../h/buf.h"
-#include "../h/mbuf.h"
-#include "../h/protosw.h"
-#include "../h/socket.h"
-#include "../h/socketvar.h"
-#include "../h/uio.h"
+/*
+ * Copyright (c) 1982, 1986, 1988 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, 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'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ *     @(#)uipc_syscalls.c     7.8 (Berkeley) %G%
+ */
+
+#include "param.h"
+#include "dir.h"
+#include "user.h"
+#include "proc.h"
+#include "file.h"
+#include "buf.h"
+#include "malloc.h"
+#include "mbuf.h"
+#include "protosw.h"
+#include "socket.h"
+#include "socketvar.h"

 
 /*
  * System call interface to the socket abstraction.
 
 /*
  * System call interface to the socket abstraction.


@@ -59,7 +74,7 @@ bind()
        fp = getsock(uap->s);
        if (fp == 0)
                return;
        fp = getsock(uap->s);
        if (fp == 0)
                return;

-       u.u_error = sockargs(&nam, uap->name, uap->namelen);
+       u.u_error = sockargs(&nam, uap->name, uap->namelen, MT_SONAME);

        if (u.u_error)
                return;
        u.u_error = sobind((struct socket *)fp->f_data, nam);
        if (u.u_error)
                return;
        u.u_error = sobind((struct socket *)fp->f_data, nam);


@@ -80,7 +95,21 @@ listen()
        u.u_error = solisten((struct socket *)fp->f_data, uap->backlog);
 }
 
        u.u_error = solisten((struct socket *)fp->f_data, uap->backlog);
 }
 

+#ifdef COMPAT_43
+accept()
+{
+       accept1(0);
+}
+
+oaccept()
+{
+       accept1(1);
+}
+
+accept1(compat_43)
+#else

 accept()
 accept()

+#endif

 {
        register struct a {
                int     s;
 {
        register struct a {
                int     s;


@@ -128,6 +157,7 @@ noname:
        }
        if (so->so_error) {
                u.u_error = so->so_error;
        }
        if (so->so_error) {
                u.u_error = so->so_error;

+               so->so_error = 0;

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


@@ -153,6 +183,11 @@ noname:
        nam = m_get(M_WAIT, MT_SONAME);
        (void) soaccept(so, nam);
        if (uap->name) {
        nam = m_get(M_WAIT, MT_SONAME);
        (void) soaccept(so, nam);
        if (uap->name) {

+#ifdef COMPAT_43
+               if (compat_43)
+                       mtod(nam, struct osockaddr *)->sa_family =
+                           mtod(nam, struct sockaddr *)->sa_family;
+#endif

                if (namelen > nam->m_len)
                        namelen = nam->m_len;
                /* SHOULD COPY OUT A CHAIN HERE */
                if (namelen > nam->m_len)
                        namelen = nam->m_len;
                /* SHOULD COPY OUT A CHAIN HERE */


@@ -181,18 +216,24 @@ connect()
        if (fp == 0)
                return;
        so = (struct socket *)fp->f_data;
        if (fp == 0)
                return;
        so = (struct socket *)fp->f_data;

-       u.u_error = sockargs(&nam, uap->name, uap->namelen);
+       if ((so->so_state & SS_NBIO) &&
+           (so->so_state & SS_ISCONNECTING)) {
+               u.u_error = EALREADY;
+               return;
+       }
+       u.u_error = sockargs(&nam, uap->name, uap->namelen, MT_SONAME);

        if (u.u_error)
                return;
        u.u_error = soconnect(so, nam);
        if (u.u_error)
                goto bad;
        if (u.u_error)
                return;
        u.u_error = soconnect(so, nam);
        if (u.u_error)
                goto bad;

-       s = splnet();

        if ((so->so_state & SS_NBIO) &&
            (so->so_state & SS_ISCONNECTING)) {
                u.u_error = EINPROGRESS;
        if ((so->so_state & SS_NBIO) &&
            (so->so_state & SS_ISCONNECTING)) {
                u.u_error = EINPROGRESS;

-               goto bad2;
+               m_freem(nam);
+               return;

        }
        }

+       s = splnet();

        if (setjmp(&u.u_qsave)) {
                if (u.u_error == 0)
                        u.u_error = EINTR;
        if (setjmp(&u.u_qsave)) {
                if (u.u_error == 0)
                        u.u_error = EINTR;


@@ -205,6 +246,7 @@ connect()
 bad2:
        splx(s);
 bad:
 bad2:
        splx(s);
 bad:

+       so->so_state &= ~SS_ISCONNECTING;

        m_freem(nam);
 }
 
        m_freem(nam);
 }
 


@@ -229,7 +271,7 @@ socketpair()
                return;
        u.u_error = socreate(uap->domain, &so2, uap->type, uap->protocol);
        if (u.u_error)
                return;
        u.u_error = socreate(uap->domain, &so2, uap->type, uap->protocol);
        if (u.u_error)

-               goto free;
+               goto freeit;

        fp1 = falloc();
        if (fp1 == NULL)
                goto free2;
        fp1 = falloc();
        if (fp1 == NULL)
                goto free2;


@@ -249,6 +291,15 @@ socketpair()
        u.u_error = soconnect2(so1, so2);
        if (u.u_error)
                goto free4;
        u.u_error = soconnect2(so1, so2);
        if (u.u_error)
                goto free4;

+       if (uap->type == SOCK_DGRAM) {
+               /*
+                * Datagram socket connection is asymmetric.
+                */
+                u.u_error = soconnect2(so2, so1);
+                if (u.u_error)
+                       goto free4;
+       }
+       u.u_r.r_val1 = 0;

        (void) copyout((caddr_t)sv, (caddr_t)uap->rsv, 2 * sizeof (int));
        return;
 free4:
        (void) copyout((caddr_t)sv, (caddr_t)uap->rsv, 2 * sizeof (int));
        return;
 free4:


@@ -258,11 +309,9 @@ free3:
        fp1->f_count = 0;
        u.u_ofile[sv[0]] = 0;
 free2:
        fp1->f_count = 0;
        u.u_ofile[sv[0]] = 0;
 free2:

-       so2->so_state |= SS_NOFDREF;
-       sofree(so2);
-free:
-       so1->so_state |= SS_NOFDREF;
-       sofree(so1);
+       (void)soclose(so2);
+freeit:
+       (void)soclose(so1);

 }
 
 sendto()
 }
 
 sendto()


@@ -285,11 +334,13 @@ sendto()
        aiov.iov_base = uap->buf;
        aiov.iov_len = uap->len;
        msg.msg_accrights = 0;
        aiov.iov_base = uap->buf;
        aiov.iov_len = uap->len;
        msg.msg_accrights = 0;

-       msg.msg_accrightslen = 0;
+       msg.msg_control = 0;

        sendit(uap->s, &msg, uap->flags);
 }
 
        sendit(uap->s, &msg, uap->flags);
 }
 

-send()
+#ifdef COMPAT_43
+
+osend()

 {
        register struct a {
                int     s;
 {
        register struct a {
                int     s;


@@ -307,9 +358,36 @@ send()
        aiov.iov_base = uap->buf;
        aiov.iov_len = uap->len;
        msg.msg_accrights = 0;
        aiov.iov_base = uap->buf;
        aiov.iov_len = uap->len;
        msg.msg_accrights = 0;

-       msg.msg_accrightslen = 0;
+       msg.msg_control = 0;
+       sendit(uap->s, &msg, uap->flags);
+}
+
+osendmsg()
+{
+       register struct a {
+               int     s;
+               caddr_t msg;
+               int     flags;
+       } *uap = (struct a *)u.u_ap;
+       struct msghdr msg;
+       struct iovec aiov[MSG_MAXIOVLEN];
+
+       u.u_error = copyin(uap->msg, (caddr_t)&msg, sizeof (struct omsghdr));
+       if (u.u_error)
+               return;
+       if ((u_int)msg.msg_iovlen >= sizeof (aiov) / sizeof (aiov[0])) {
+               u.u_error = EMSGSIZE;
+               return;
+       }
+       u.u_error = copyin((caddr_t)msg.msg_iov, (caddr_t)aiov,
+               (unsigned)(msg.msg_iovlen * sizeof (aiov[0])));
+       if (u.u_error)
+               return;
+       msg.msg_control = 0;
+       msg.msg_controllen = 0;

        sendit(uap->s, &msg, uap->flags);
 }
        sendit(uap->s, &msg, uap->flags);
 }

+#endif

 
 sendmsg()
 {
 
 sendmsg()
 {


@@ -328,17 +406,11 @@ sendmsg()
                u.u_error = EMSGSIZE;
                return;
        }
                u.u_error = EMSGSIZE;
                return;
        }

-       u.u_error =
-           copyin((caddr_t)msg.msg_iov, (caddr_t)aiov,
+       u.u_error = copyin((caddr_t)msg.msg_iov, (caddr_t)aiov,

                (unsigned)(msg.msg_iovlen * sizeof (aiov[0])));
        if (u.u_error)
                return;
        msg.msg_iov = aiov;
                (unsigned)(msg.msg_iovlen * sizeof (aiov[0])));
        if (u.u_error)
                return;
        msg.msg_iov = aiov;

-#ifdef notdef
-printf("sendmsg name %x namelen %d iov %x iovlen %d accrights %x &len %d\n",
-msg.msg_name, msg.msg_namelen, msg.msg_iov, msg.msg_iovlen,
-msg.msg_accrights, msg.msg_accrightslen);
-#endif

        sendit(uap->s, &msg, uap->flags);
 }
 
        sendit(uap->s, &msg, uap->flags);
 }
 


@@ -351,7 +423,7 @@ sendit(s, mp, flags)
        struct uio auio;
        register struct iovec *iov;
        register int i;
        struct uio auio;
        register struct iovec *iov;
        register int i;

-       struct mbuf *to, *rights;
+       struct mbuf *to, *rights, *control;

        int len;
        
        fp = getsock(s);
        int len;
        
        fp = getsock(s);


@@ -359,49 +431,85 @@ sendit(s, mp, flags)
                return;
        auio.uio_iov = mp->msg_iov;
        auio.uio_iovcnt = mp->msg_iovlen;
                return;
        auio.uio_iov = mp->msg_iov;
        auio.uio_iovcnt = mp->msg_iovlen;

-       auio.uio_segflg = 0;
+       auio.uio_segflg = UIO_USERSPACE;

        auio.uio_offset = 0;                    /* XXX */
        auio.uio_resid = 0;
        iov = mp->msg_iov;
        auio.uio_offset = 0;                    /* XXX */
        auio.uio_resid = 0;
        iov = mp->msg_iov;

-       for (i = 0; i < mp->msg_iovlen; i++) {
+       for (i = 0; i < mp->msg_iovlen; i++, iov++) {

                if (iov->iov_len < 0) {
                        u.u_error = EINVAL;
                        return;
                }
                if (iov->iov_len < 0) {
                        u.u_error = EINVAL;
                        return;
                }

+               if (iov->iov_len == 0)
+                       continue;

                if (useracc(iov->iov_base, (u_int)iov->iov_len, B_READ) == 0) {
                        u.u_error = EFAULT;
                        return;
                }
                auio.uio_resid += iov->iov_len;
                if (useracc(iov->iov_base, (u_int)iov->iov_len, B_READ) == 0) {
                        u.u_error = EFAULT;
                        return;
                }
                auio.uio_resid += iov->iov_len;

-               iov++;

        }
        if (mp->msg_name) {
                u.u_error =
        }
        if (mp->msg_name) {
                u.u_error =

-                   sockargs(&to, mp->msg_name, mp->msg_namelen);
+                   sockargs(&to, mp->msg_name, mp->msg_namelen, MT_SONAME);

                if (u.u_error)
                        return;
        } else
                to = 0;
        if (mp->msg_accrights) {
                u.u_error =
                if (u.u_error)
                        return;
        } else
                to = 0;
        if (mp->msg_accrights) {
                u.u_error =

-                   sockargs(&rights, mp->msg_accrights, mp->msg_accrightslen);
+                   sockargs(&rights, mp->msg_accrights, mp->msg_accrightslen,
+                   MT_RIGHTS);

                if (u.u_error)
                        goto bad;
        } else
                rights = 0;
                if (u.u_error)
                        goto bad;
        } else
                rights = 0;

+       if (mp->msg_control) {
+               u.u_error =
+                   sockargs(&control, mp->msg_control, mp->msg_controllen,
+                   MT_CONTROL);
+               if (u.u_error)
+                       goto bad;
+       } else
+               control = 0;

        len = auio.uio_resid;
        len = auio.uio_resid;

-       u.u_error =
-           sosend((struct socket *)fp->f_data, to, &auio, flags, rights);
+       if (setjmp(&u.u_qsave)) {                       /* XXX */
+               if (auio.uio_resid == len) {
+                       if ((u.u_sigintr & sigmask(u.u_procp->p_cursig)) != 0)
+                               u.u_error = EINTR;
+                       else
+                               u.u_eosys = RESTARTSYS;
+               }
+       } else
+               u.u_error = sosend((struct socket *)fp->f_data, to, &auio,
+                   flags, rights, control);

        u.u_r.r_val1 = len - auio.uio_resid;
        u.u_r.r_val1 = len - auio.uio_resid;

+bad:

        if (rights)
                m_freem(rights);
        if (rights)
                m_freem(rights);

-bad:

        if (to)
                m_freem(to);
        if (to)
                m_freem(to);

+       if (control)
+               m_freem(control);

 }
 
 }
 

+#ifdef COMPAT_43

 recvfrom()
 {
 recvfrom()
 {

+       recvfrom1(0);
+}
+
+orecvfrom()
+{
+       recvfrom1(1);
+}
+
+recvfrom1(compat_43)
+{      /* vi will want an extra } to be happy! */
+#else
+recvfrom()
+{
+       int compat_43 = 0;
+#endif

        register struct a {
                int     s;
                caddr_t buf;
        register struct a {
                int     s;
                caddr_t buf;


@@ -414,10 +522,13 @@ recvfrom()
        struct iovec aiov;
        int len;
 
        struct iovec aiov;
        int len;
 

-       u.u_error = copyin((caddr_t)uap->fromlenaddr, (caddr_t)&len,
-          sizeof (len));
-       if (u.u_error)
-               return;
+       if (uap->fromlenaddr) {
+               u.u_error = copyin((caddr_t)uap->fromlenaddr, (caddr_t)&len,
+                  sizeof (len));
+               if (u.u_error)
+                       return;
+       } else
+               len = 0;

        msg.msg_name = uap->from;
        msg.msg_namelen = len;
        msg.msg_iov = &aiov;
        msg.msg_name = uap->from;
        msg.msg_namelen = len;
        msg.msg_iov = &aiov;


@@ -425,11 +536,12 @@ recvfrom()
        aiov.iov_base = uap->buf;
        aiov.iov_len = uap->len;
        msg.msg_accrights = 0;
        aiov.iov_base = uap->buf;
        aiov.iov_len = uap->len;
        msg.msg_accrights = 0;

-       msg.msg_accrightslen = 0;
-       recvit(uap->s, &msg, uap->flags, (caddr_t)uap->fromlenaddr, (caddr_t)0);
+       msg.msg_control = 0;
+       msg.msg_flags = uap->flags;
+       recvit(uap->s, &msg, (caddr_t)uap->fromlenaddr, (caddr_t)0, compat_43);

 }
 }

-
-recv()
+#ifdef COMPAT_43
+orecv()

 {
        register struct a {
                int     s;
 {
        register struct a {
                int     s;


@@ -447,9 +559,47 @@ recv()
        aiov.iov_base = uap->buf;
        aiov.iov_len = uap->len;
        msg.msg_accrights = 0;
        aiov.iov_base = uap->buf;
        aiov.iov_len = uap->len;
        msg.msg_accrights = 0;

-       msg.msg_accrightslen = 0;
-       recvit(uap->s, &msg, uap->flags, (caddr_t)0, (caddr_t)0);
+       msg.msg_control = 0;
+       msg.msg_flags = uap->flags;
+       recvit(uap->s, &msg, (caddr_t)0, (caddr_t)0, 0);
+}
+
+orecvmsg()
+{
+       register struct a {
+               int     s;
+               struct  omsghdr *msg;
+               int     flags;
+       } *uap = (struct a *)u.u_ap;
+       struct msghdr msg;
+       struct iovec aiov[MSG_MAXIOVLEN];
+
+       u.u_error = copyin((caddr_t)uap->msg, (caddr_t)&msg,
+           sizeof (struct omsghdr));
+       if (u.u_error)
+               return;
+       if ((u_int)msg.msg_iovlen >= sizeof (aiov) / sizeof (aiov[0])) {
+               u.u_error = EMSGSIZE;
+               return;
+       }
+       msg.msg_control = 0;
+       msg.msg_flags = uap->flags;
+       u.u_error = copyin((caddr_t)msg.msg_iov, (caddr_t)aiov,
+               (unsigned)(msg.msg_iovlen * sizeof (aiov[0])));
+       if (u.u_error)
+               return;
+       msg.msg_iov = aiov;
+       if (msg.msg_accrights)
+               if (useracc((caddr_t)msg.msg_accrights,
+                   (unsigned)msg.msg_accrightslen, B_WRITE) == 0) {
+                       u.u_error = EFAULT;
+                       return;
+               }
+           
+       recvit(uap->s, &msg, (caddr_t)&uap->msg->msg_namelen,
+           (caddr_t)&uap->msg->msg_accrightslen, /* compat_43 */1);

 }
 }

+#endif

 
 recvmsg()
 {
 
 recvmsg()
 {


@@ -459,7 +609,7 @@ recvmsg()
                int     flags;
        } *uap = (struct a *)u.u_ap;
        struct msghdr msg;
                int     flags;
        } *uap = (struct a *)u.u_ap;
        struct msghdr msg;

-       struct iovec aiov[MSG_MAXIOVLEN];
+       struct iovec aiov[MSG_MAXIOVLEN], *uiov;

 
        u.u_error = copyin((caddr_t)uap->msg, (caddr_t)&msg, sizeof (msg));
        if (u.u_error)
 
        u.u_error = copyin((caddr_t)uap->msg, (caddr_t)&msg, sizeof (msg));
        if (u.u_error)


@@ -468,11 +618,12 @@ recvmsg()
                u.u_error = EMSGSIZE;
                return;
        }
                u.u_error = EMSGSIZE;
                return;
        }

-       u.u_error =
-           copyin((caddr_t)msg.msg_iov, (caddr_t)aiov,
+       msg.msg_flags = uap->flags;
+       u.u_error = copyin((caddr_t)msg.msg_iov, (caddr_t)aiov,

                (unsigned)(msg.msg_iovlen * sizeof (aiov[0])));
        if (u.u_error)
                return;
                (unsigned)(msg.msg_iovlen * sizeof (aiov[0])));
        if (u.u_error)
                return;

+       uiov = msg.msg_iov;

        msg.msg_iov = aiov;
        if (msg.msg_accrights)
                if (useracc((caddr_t)msg.msg_accrights,
        msg.msg_iov = aiov;
        if (msg.msg_accrights)
                if (useracc((caddr_t)msg.msg_accrights,


@@ -480,61 +631,81 @@ recvmsg()
                        u.u_error = EFAULT;
                        return;
                }
                        u.u_error = EFAULT;
                        return;
                }

-       recvit(uap->s, &msg, uap->flags,
-           (caddr_t)&uap->msg->msg_namelen,
-           (caddr_t)&uap->msg->msg_accrightslen);
+       if (msg.msg_control)
+               if (useracc((caddr_t)msg.msg_control,
+                   (unsigned)msg.msg_controllen, B_WRITE) == 0) {
+                       u.u_error = EFAULT;
+                       return;
+               }
+       recvit(uap->s, &msg, (caddr_t)0, (caddr_t)0, 0);
+       msg.msg_iov = uiov;
+       u.u_error = copyout((caddr_t)&msg, (caddr_t)uap->msg, sizeof(msg));

 }
 
 }
 

-recvit(s, mp, flags, namelenp, rightslenp)
-       int s;
+recvit(s, mp, namelenp, rightslenp, compat_43)
+       int s, compat_43;

        register struct msghdr *mp;
        register struct msghdr *mp;

-       int flags;

        caddr_t namelenp, rightslenp;
 {
        register struct file *fp;
        struct uio auio;
        register struct iovec *iov;
        register int i;
        caddr_t namelenp, rightslenp;
 {
        register struct file *fp;
        struct uio auio;
        register struct iovec *iov;
        register int i;

-       struct mbuf *from, *rights;

        int len;
        int len;

+       struct mbuf *from = 0, *rights = 0, *control = 0;

        
        fp = getsock(s);
        if (fp == 0)
                return;
        auio.uio_iov = mp->msg_iov;
        auio.uio_iovcnt = mp->msg_iovlen;
        
        fp = getsock(s);
        if (fp == 0)
                return;
        auio.uio_iov = mp->msg_iov;
        auio.uio_iovcnt = mp->msg_iovlen;

-       auio.uio_segflg = 0;
+       auio.uio_segflg = UIO_USERSPACE;

        auio.uio_offset = 0;                    /* XXX */
        auio.uio_resid = 0;
        iov = mp->msg_iov;
        auio.uio_offset = 0;                    /* XXX */
        auio.uio_resid = 0;
        iov = mp->msg_iov;

-       for (i = 0; i < mp->msg_iovlen; i++) {
+       for (i = 0; i < mp->msg_iovlen; i++, iov++) {

                if (iov->iov_len < 0) {
                        u.u_error = EINVAL;
                        return;
                }
                if (iov->iov_len < 0) {
                        u.u_error = EINVAL;
                        return;
                }

+               if (iov->iov_len == 0)
+                       continue;

                if (useracc(iov->iov_base, (u_int)iov->iov_len, B_WRITE) == 0) {
                        u.u_error = EFAULT;
                        return;
                }
                auio.uio_resid += iov->iov_len;
                if (useracc(iov->iov_base, (u_int)iov->iov_len, B_WRITE) == 0) {
                        u.u_error = EFAULT;
                        return;
                }
                auio.uio_resid += iov->iov_len;

-               iov++;

        }
        len = auio.uio_resid;
        }
        len = auio.uio_resid;

-       u.u_error =
-           soreceive((struct socket *)fp->f_data, &from, &auio,
-               flags, &rights);
+       if (setjmp(&u.u_qsave)) {                       /* XXX */
+               if (auio.uio_resid == len) {
+                       if ((u.u_sigintr & sigmask(u.u_procp->p_cursig)) != 0)
+                               u.u_error = EINTR;
+                       else
+                               u.u_eosys = RESTARTSYS;
+               }
+       } else
+               u.u_error = soreceive((struct socket *)fp->f_data, &from, &auio,
+                   &mp->msg_flags, &rights, &control);

        u.u_r.r_val1 = len - auio.uio_resid;
        if (mp->msg_name) {
                len = mp->msg_namelen;
                if (len <= 0 || from == 0)
                        len = 0;
                else {
        u.u_r.r_val1 = len - auio.uio_resid;
        if (mp->msg_name) {
                len = mp->msg_namelen;
                if (len <= 0 || from == 0)
                        len = 0;
                else {

-                       if (len > from->m_len)
+#ifdef COMPAT_43
+                       if (compat_43)
+                               mtod(from, struct osockaddr *)->sa_family =
+                                   mtod(from, struct sockaddr *)->sa_family;
+#endif
+                       if (len > from->m_len)          /* ??? */

                                len = from->m_len;
                                len = from->m_len;

-                       (void) copyout((caddr_t)mtod(from, caddr_t),
+                       (void) copyout(mtod(from, caddr_t),

                            (caddr_t)mp->msg_name, (unsigned)len);
                }
                            (caddr_t)mp->msg_name, (unsigned)len);
                }

-               (void) copyout((caddr_t)&len, namelenp, sizeof (int));
+               mp->msg_namelen = len;
+               if (namelenp)
+                       (void) copyout((caddr_t)&len, namelenp, sizeof (int));

        }
        if (mp->msg_accrights) {
                len = mp->msg_accrightslen;
        }
        if (mp->msg_accrights) {
                len = mp->msg_accrightslen;


@@ -546,12 +717,30 @@ recvit(s, mp, flags, namelenp, rightslenp)
                        (void) copyout((caddr_t)mtod(rights, caddr_t),
                            (caddr_t)mp->msg_accrights, (unsigned)len);
                }
                        (void) copyout((caddr_t)mtod(rights, caddr_t),
                            (caddr_t)mp->msg_accrights, (unsigned)len);
                }

-               (void) copyout((caddr_t)&len, rightslenp, sizeof (int));
+               mp->msg_accrightslen = len;
+               if (rightslenp)
+                       (void) copyout((caddr_t)&len, rightslenp, sizeof (int));
+       }
+       if (mp->msg_control) {
+               len = mp->msg_controllen;
+               if (len <= 0 || control == 0)
+                       len = 0;
+               else {
+                       if (len >= control->m_len)
+                               len = control->m_len;
+                       else
+                               mp->msg_flags |= MSG_CTRUNC;
+                       (void) copyout((caddr_t)mtod(control, caddr_t),
+                           (caddr_t)mp->msg_control, (unsigned)len);
+               }
+               mp->msg_controllen = len;

        }
        if (rights)
                m_freem(rights);
        if (from)
                m_freem(from);
        }
        if (rights)
                m_freem(rights);
        if (from)
                m_freem(from);

+       if (control)
+               m_freem(control);

 }
 
 shutdown()
 }
 
 shutdown()


@@ -595,15 +784,14 @@ setsockopt()
                }
                u.u_error =
                    copyin(uap->val, mtod(m, caddr_t), (u_int)uap->valsize);
                }
                u.u_error =
                    copyin(uap->val, mtod(m, caddr_t), (u_int)uap->valsize);

-               if (u.u_error)
-                       goto bad;
+               if (u.u_error) {
+                       (void) m_free(m);
+                       return;
+               }

                m->m_len = uap->valsize;
        }
        u.u_error =
            sosetopt((struct socket *)fp->f_data, uap->level, uap->name, m);
                m->m_len = uap->valsize;
        }
        u.u_error =
            sosetopt((struct socket *)fp->f_data, uap->level, uap->name, m);

-bad:
-       if (m != NULL)
-               (void) m_free(m);

 }
 
 getsockopt()
 }
 
 getsockopt()


@@ -627,17 +815,13 @@ getsockopt()
                        sizeof (valsize));
                if (u.u_error)
                        return;
                        sizeof (valsize));
                if (u.u_error)
                        return;

-               m = m_get(M_WAIT, MT_SOOPTS);
-               if (m == NULL) {
-                       u.u_error = ENOBUFS;
-                       return;
-               }
-       }
+       } else
+               valsize = 0;

        u.u_error =
        u.u_error =

-           sogetopt((struct socket *)fp->f_data, uap->level, uap->name, m);
+           sogetopt((struct socket *)fp->f_data, uap->level, uap->name, &m);

        if (u.u_error)
                goto bad;
        if (u.u_error)
                goto bad;

-       if (uap->val) {
+       if (uap->val && valsize && m != NULL) {

                if (valsize > m->m_len)
                        valsize = m->m_len;
                u.u_error = copyout(mtod(m, caddr_t), uap->val, (u_int)valsize);
                if (valsize > m->m_len)
                        valsize = m->m_len;
                u.u_error = copyout(mtod(m, caddr_t), uap->val, (u_int)valsize);


@@ -662,7 +846,7 @@ pipe()
                return;
        u.u_error = socreate(AF_UNIX, &wso, SOCK_STREAM, 0);
        if (u.u_error)
                return;
        u.u_error = socreate(AF_UNIX, &wso, SOCK_STREAM, 0);
        if (u.u_error)

-               goto free;
+               goto freeit;

        rf = falloc();
        if (rf == NULL)
                goto free2;
        rf = falloc();
        if (rf == NULL)
                goto free2;


@@ -680,8 +864,10 @@ pipe()
        wf->f_data = (caddr_t)wso;
        u.u_r.r_val2 = u.u_r.r_val1;
        u.u_r.r_val1 = r;
        wf->f_data = (caddr_t)wso;
        u.u_r.r_val2 = u.u_r.r_val1;
        u.u_r.r_val1 = r;

-       if (piconnect(wso, rso) == 0)
+       if (u.u_error = unp_connect2(wso, rso))

                goto free4;
                goto free4;

+       wso->so_state |= SS_CANTRCVMORE;
+       rso->so_state |= SS_CANTSENDMORE;

        return;
 free4:
        wf->f_count = 0;
        return;
 free4:
        wf->f_count = 0;


@@ -690,17 +876,29 @@ free3:
        rf->f_count = 0;
        u.u_ofile[r] = 0;
 free2:
        rf->f_count = 0;
        u.u_ofile[r] = 0;
 free2:

-       wso->so_state |= SS_NOFDREF;
-       sofree(wso);
-free:
-       rso->so_state |= SS_NOFDREF;
-       sofree(rso);
+       (void)soclose(wso);
+freeit:
+       (void)soclose(rso);

 }
 
 /*
  * Get socket name.
  */
 }
 
 /*
  * Get socket name.
  */

+#ifdef COMPAT_43

 getsockname()
 getsockname()

+{
+       getsockname1(0);
+}
+
+ogetsockname()
+{
+       getsockname1(1);
+}
+
+getsockname1(compat_43)
+#else
+getsockname()
+#endif

 {
        register struct a {
                int     fdes;
 {
        register struct a {
                int     fdes;


@@ -729,6 +927,74 @@ getsockname()
                goto bad;
        if (len > m->m_len)
                len = m->m_len;
                goto bad;
        if (len > m->m_len)
                len = m->m_len;

+#ifdef COMPAT_43
+       if (compat_43)
+               mtod(m, struct osockaddr *)->sa_family =
+                   mtod(m, struct sockaddr *)->sa_family;
+#endif
+       u.u_error = copyout(mtod(m, caddr_t), (caddr_t)uap->asa, (u_int)len);
+       if (u.u_error == 0)
+               u.u_error = copyout((caddr_t)&len, (caddr_t)uap->alen,
+                   sizeof (len));
+bad:
+       m_freem(m);
+}
+
+/*
+ * Get name of peer for connected socket.
+ */
+#ifdef COMPAT_43
+getpeername()
+{
+       getpeername1(0);
+}
+
+ogetpeername()
+{
+       getpeername1(1);
+}
+
+getpeername1(compat_43)
+#else
+getpeername()
+#endif
+{
+       register struct a {
+               int     fdes;
+               caddr_t asa;
+               int     *alen;
+       } *uap = (struct a *)u.u_ap;
+       register struct file *fp;
+       register struct socket *so;
+       struct mbuf *m;
+       int len;
+
+       fp = getsock(uap->fdes);
+       if (fp == 0)
+               return;
+       so = (struct socket *)fp->f_data;
+       if ((so->so_state & SS_ISCONNECTED) == 0) {
+               u.u_error = ENOTCONN;
+               return;
+       }
+       m = m_getclr(M_WAIT, MT_SONAME);
+       if (m == NULL) {
+               u.u_error = ENOBUFS;
+               return;
+       }
+       u.u_error = copyin((caddr_t)uap->alen, (caddr_t)&len, sizeof (len));
+       if (u.u_error)
+               return;
+       u.u_error = (*so->so_proto->pr_usrreq)(so, PRU_PEERADDR, 0, m, 0);
+       if (u.u_error)
+               goto bad;
+       if (len > m->m_len)
+               len = m->m_len;
+#ifdef COMPAT_43
+       if (compat_43)
+               mtod(m, struct osockaddr *)->sa_family =
+                   mtod(m, struct sockaddr *)->sa_family;
+#endif

        u.u_error = copyout(mtod(m, caddr_t), (caddr_t)uap->asa, (u_int)len);
        if (u.u_error)
                goto bad;
        u.u_error = copyout(mtod(m, caddr_t), (caddr_t)uap->asa, (u_int)len);
        if (u.u_error)
                goto bad;


@@ -737,17 +1003,17 @@ bad:
        m_freem(m);
 }
 
        m_freem(m);
 }
 

-sockargs(aname, name, namelen)
+sockargs(aname, name, namelen, type)

        struct mbuf **aname;
        caddr_t name;
        struct mbuf **aname;
        caddr_t name;

-       int namelen;
+       int namelen, type;

 {
        register struct mbuf *m;
        int error;
 
 {
        register struct mbuf *m;
        int error;
 

-       if (namelen > MLEN)
+       if ((u_int)namelen > MLEN)

                return (EINVAL);
                return (EINVAL);

-       m = m_get(M_WAIT, MT_SONAME);
+       m = m_get(M_WAIT, type);

        if (m == NULL)
                return (ENOBUFS);
        m->m_len = namelen;
        if (m == NULL)
                return (ENOBUFS);
        m->m_len = namelen;


@@ -756,6 +1022,14 @@ sockargs(aname, name, namelen)
                (void) m_free(m);
        else
                *aname = m;
                (void) m_free(m);
        else
                *aname = m;

+       if (type == MT_SONAME) {
+               register struct sockaddr *sa = mtod(m, struct sockaddr *);
+#if defined(COMPAT_43) && BYTE_ORDER != BIG_ENDIAN
+               if (sa->sa_family == 0 && sa->sa_len < AF_MAX)
+                       sa->sa_family = sa->sa_len;
+#endif
+               sa->sa_len = namelen;
+       }

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