Please note that diffs are not public domain; they are subject to the
copyright notices on the relevant files.

===================================================================
RCS file: /ftp/cvs/cvsroot/src/sys/kern/uipc_socket.c,v
rcsdiff: /ftp/cvs/cvsroot/src/sys/kern/uipc_socket.c,v: warning: Unknown phrases like `commitid ...;' are present.
retrieving revision 1.2
retrieving revision 1.56.4.1
diff -u -p -r1.2 -r1.56.4.1
--- src/sys/kern/uipc_socket.c	1993/05/18 18:19:36	1.2
+++ src/sys/kern/uipc_socket.c	2001/10/01 12:46:57	1.56.4.1
@@ -1,6 +1,8 @@
+/*	$NetBSD: uipc_socket.c,v 1.56.4.1 2001/10/01 12:46:57 fvdl Exp $	*/
+
 /*
- * Copyright (c) 1982, 1986, 1988, 1990 Regents of the University of California.
- * All rights reserved.
+ * Copyright (c) 1982, 1986, 1988, 1990, 1993
+ *	The Regents of the University of California.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -30,22 +32,38 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
- *	from: @(#)uipc_socket.c	7.28 (Berkeley) 5/4/91
- *	$Id: uipc_socket.c,v 1.2 1993/05/18 18:19:36 cgd Exp $
+ *	@(#)uipc_socket.c	8.6 (Berkeley) 5/2/95
  */
 
-#include "param.h"
-#include "proc.h"
-#include "file.h"
-#include "malloc.h"
-#include "mbuf.h"
-#include "domain.h"
-#include "kernel.h"
-#include "select.h"
-#include "protosw.h"
-#include "socket.h"
-#include "socketvar.h"
-#include "resourcevar.h"
+#include "opt_compat_sunos.h"
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/proc.h>
+#include <sys/file.h>
+#include <sys/malloc.h>
+#include <sys/mbuf.h>
+#include <sys/domain.h>
+#include <sys/kernel.h>
+#include <sys/protosw.h>
+#include <sys/socket.h>
+#include <sys/socketvar.h>
+#include <sys/signalvar.h>
+#include <sys/resourcevar.h>
+#include <sys/pool.h>
+
+struct pool	socket_pool;
+
+extern int	somaxconn;			/* patchable (XXX sysctl) */
+int		somaxconn = SOMAXCONN;
+
+void
+soinit(void)
+{
+
+	pool_init(&socket_pool, sizeof(struct socket), 0, 0, 0,
+	    "sockpl", 0, NULL, NULL, M_SOCKET);
+}
 
 /*
  * Socket operation routines.
@@ -55,92 +73,105 @@
  * switching out to the protocol specific routines.
  */
 /*ARGSUSED*/
-socreate(dom, aso, type, proto)
-	struct socket **aso;
-	register int type;
-	int proto;
-{
-	struct proc *p = curproc;		/* XXX */
-	register struct protosw *prp;
-	register struct socket *so;
-	register int error;
+int
+socreate(int dom, struct socket **aso, int type, int proto)
+{
+	struct proc	*p;
+	struct protosw	*prp;
+	struct socket	*so;
+	int		error, s;
 
+	p = curproc;		/* XXX */
 	if (proto)
 		prp = pffindproto(dom, proto, type);
 	else
 		prp = pffindtype(dom, type);
-	if (prp == 0)
+	if (prp == 0 || prp->pr_usrreq == 0)
 		return (EPROTONOSUPPORT);
 	if (prp->pr_type != type)
 		return (EPROTOTYPE);
-	MALLOC(so, struct socket *, sizeof(*so), M_SOCKET, M_WAIT);
-	bzero((caddr_t)so, sizeof(*so));
+	s = splsoftnet();
+	so = pool_get(&socket_pool, PR_WAITOK);
+	memset((caddr_t)so, 0, sizeof(*so));
+	TAILQ_INIT(&so->so_q0);
+	TAILQ_INIT(&so->so_q);
 	so->so_type = type;
-	if (p->p_ucred->cr_uid == 0)
-		so->so_state = SS_PRIV;
 	so->so_proto = prp;
-	error =
-	    (*prp->pr_usrreq)(so, PRU_ATTACH,
-		(struct mbuf *)0, (struct mbuf *)proto, (struct mbuf *)0);
+	so->so_send = sosend;
+	so->so_receive = soreceive;
+	if (p != 0)
+		so->so_uid = p->p_ucred->cr_uid;
+	error = (*prp->pr_usrreq)(so, PRU_ATTACH, (struct mbuf *)0,
+	    (struct mbuf *)(long)proto, (struct mbuf *)0, p);
 	if (error) {
 		so->so_state |= SS_NOFDREF;
 		sofree(so);
+		splx(s);
 		return (error);
 	}
+#ifdef COMPAT_SUNOS
+	{
+		extern struct emul emul_sunos;
+		if (p->p_emul == &emul_sunos && type == SOCK_DGRAM)
+			so->so_options |= SO_BROADCAST;
+	}
+#endif
+	splx(s);
 	*aso = so;
 	return (0);
 }
 
-sobind(so, nam)
-	struct socket *so;
-	struct mbuf *nam;
-{
-	int s = splnet();
-	int error;
-
-	error =
-	    (*so->so_proto->pr_usrreq)(so, PRU_BIND,
-		(struct mbuf *)0, nam, (struct mbuf *)0);
+int
+sobind(struct socket *so, struct mbuf *nam, struct proc *p)
+{
+	int	s, error;
+
+	s = splsoftnet();
+	error = (*so->so_proto->pr_usrreq)(so, PRU_BIND, (struct mbuf *)0,
+	    nam, (struct mbuf *)0, p);
 	splx(s);
 	return (error);
 }
 
-solisten(so, backlog)
-	register struct socket *so;
-	int backlog;
-{
-	int s = splnet(), error;
-
-	error =
-	    (*so->so_proto->pr_usrreq)(so, PRU_LISTEN,
-		(struct mbuf *)0, (struct mbuf *)0, (struct mbuf *)0);
+int
+solisten(struct socket *so, int backlog)
+{
+	int	s, error;
+
+	s = splsoftnet();
+	error = (*so->so_proto->pr_usrreq)(so, PRU_LISTEN, (struct mbuf *)0,
+	    (struct mbuf *)0, (struct mbuf *)0, (struct proc *)0);
 	if (error) {
 		splx(s);
 		return (error);
 	}
-	if (so->so_q == 0)
+	if (so->so_q.tqh_first == NULL)
 		so->so_options |= SO_ACCEPTCONN;
 	if (backlog < 0)
 		backlog = 0;
-	so->so_qlimit = min(backlog, SOMAXCONN);
+	so->so_qlimit = min(backlog, somaxconn);
 	splx(s);
 	return (0);
 }
 
-sofree(so)
-	register struct socket *so;
+void
+sofree(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;
+		/*
+		 * We must not decommission a socket that's on the accept(2)
+		 * queue.  If we do, then accept(2) may hang after select(2)
+		 * indicated that the listening socket was ready.
+		 */
+		if (!soqremque(so, 0))
+			return;
 	}
 	sbrelease(&so->so_snd);
 	sorflush(so);
-	FREE(so, M_SOCKET);
+	pool_put(&socket_pool, so);
 }
 
 /*
@@ -148,17 +179,23 @@ sofree(so)
  * Initiate disconnect if connected.
  * Free socket when disconnect complete.
  */
-soclose(so)
-	register struct socket *so;
+int
+soclose(struct socket *so)
 {
-	int s = splnet();		/* conservative */
-	int error = 0;
+	struct socket	*so2;
+	int		s, error;
 
+	error = 0;
+	s = splsoftnet();		/* conservative */
 	if (so->so_options & SO_ACCEPTCONN) {
-		while (so->so_q0)
-			(void) soabort(so->so_q0);
-		while (so->so_q)
-			(void) soabort(so->so_q);
+		while ((so2 = so->so_q0.tqh_first) != 0) {
+			(void) soqremque(so2, 0);
+			(void) soabort(so2);
+		}
+		while ((so2 = so->so_q.tqh_first) != 0) {
+			(void) soqremque(so2, 1);
+			(void) soabort(so2);
+		}
 	}
 	if (so->so_pcb == 0)
 		goto discard;
@@ -172,21 +209,24 @@ soclose(so)
 			if ((so->so_state & SS_ISDISCONNECTING) &&
 			    (so->so_state & SS_NBIO))
 				goto drop;
-			while (so->so_state & SS_ISCONNECTED)
-				if (error = tsleep((caddr_t)&so->so_timeo,
-				    PSOCK | PCATCH, netcls, so->so_linger))
+			while (so->so_state & SS_ISCONNECTED) {
+				error = tsleep((caddr_t)&so->so_timeo,
+					       PSOCK | PCATCH, netcls,
+					       so->so_linger * hz);
+				if (error)
 					break;
+			}
 		}
 	}
-drop:
+ drop:
 	if (so->so_pcb) {
-		int error2 =
-		    (*so->so_proto->pr_usrreq)(so, PRU_DETACH,
-			(struct mbuf *)0, (struct mbuf *)0, (struct mbuf *)0);
+		int error2 = (*so->so_proto->pr_usrreq)(so, PRU_DETACH,
+		    (struct mbuf *)0, (struct mbuf *)0, (struct mbuf *)0,
+		    (struct proc *)0);
 		if (error == 0)
 			error = error2;
 	}
-discard:
+ discard:
 	if (so->so_state & SS_NOFDREF)
 		panic("soclose: NOFDREF");
 	so->so_state |= SS_NOFDREF;
@@ -196,43 +236,47 @@ discard:
 }
 
 /*
- * Must be called at splnet...
+ * Must be called at splsoftnet...
  */
-soabort(so)
-	struct socket *so;
+int
+soabort(struct socket *so)
 {
 
-	return (
-	    (*so->so_proto->pr_usrreq)(so, PRU_ABORT,
-		(struct mbuf *)0, (struct mbuf *)0, (struct mbuf *)0));
+	return (*so->so_proto->pr_usrreq)(so, PRU_ABORT, (struct mbuf *)0,
+	    (struct mbuf *)0, (struct mbuf *)0, (struct proc *)0);
 }
 
-soaccept(so, nam)
-	register struct socket *so;
-	struct mbuf *nam;
+int
+soaccept(struct socket *so, struct mbuf *nam)
 {
-	int s = splnet();
-	int error;
+	int	s, error;
 
+	error = 0;
+	s = splsoftnet();
 	if ((so->so_state & SS_NOFDREF) == 0)
 		panic("soaccept: !NOFDREF");
 	so->so_state &= ~SS_NOFDREF;
-	error = (*so->so_proto->pr_usrreq)(so, PRU_ACCEPT,
-	    (struct mbuf *)0, nam, (struct mbuf *)0);
+	if ((so->so_state & SS_ISDISCONNECTED) == 0 ||
+	    (so->so_proto->pr_flags & PR_ABRTACPTDIS) == 0)
+		error = (*so->so_proto->pr_usrreq)(so, PRU_ACCEPT,
+		    (struct mbuf *)0, nam, (struct mbuf *)0, (struct proc *)0);
+	else
+		error = ECONNABORTED;
+
 	splx(s);
 	return (error);
 }
 
-soconnect(so, nam)
-	register struct socket *so;
-	struct mbuf *nam;
+int
+soconnect(struct socket *so, struct mbuf *nam)
 {
-	int s;
-	int error;
+	struct proc	*p;
+	int		s, error;
 
+	p = curproc;		/* XXX */
 	if (so->so_options & SO_ACCEPTCONN)
 		return (EOPNOTSUPP);
-	s = splnet();
+	s = splsoftnet();
 	/*
 	 * If protocol is connection-based, can only connect once.
 	 * Otherwise, if connected, try to disconnect first.
@@ -245,30 +289,30 @@ soconnect(so, nam)
 		error = EISCONN;
 	else
 		error = (*so->so_proto->pr_usrreq)(so, PRU_CONNECT,
-		    (struct mbuf *)0, nam, (struct mbuf *)0);
+		    (struct mbuf *)0, nam, (struct mbuf *)0, p);
 	splx(s);
 	return (error);
 }
 
-soconnect2(so1, so2)
-	register struct socket *so1;
-	struct socket *so2;
+int
+soconnect2(struct socket *so1, struct socket *so2)
 {
-	int s = splnet();
-	int error;
+	int	s, error;
 
+	s = splsoftnet();
 	error = (*so1->so_proto->pr_usrreq)(so1, PRU_CONNECT2,
-	    (struct mbuf *)0, (struct mbuf *)so2, (struct mbuf *)0);
+	    (struct mbuf *)0, (struct mbuf *)so2, (struct mbuf *)0,
+	    (struct proc *)0);
 	splx(s);
 	return (error);
 }
 
-sodisconnect(so)
-	register struct socket *so;
+int
+sodisconnect(struct socket *so)
 {
-	int s = splnet();
-	int error;
+	int	s, error;
 
+	s = splsoftnet();
 	if ((so->so_state & SS_ISCONNECTED) == 0) {
 		error = ENOTCONN;
 		goto bad;
@@ -278,12 +322,14 @@ sodisconnect(so)
 		goto bad;
 	}
 	error = (*so->so_proto->pr_usrreq)(so, PRU_DISCONNECT,
-	    (struct mbuf *)0, (struct mbuf *)0, (struct mbuf *)0);
-bad:
+	    (struct mbuf *)0, (struct mbuf *)0, (struct mbuf *)0,
+	    (struct proc *)0);
+ bad:
 	splx(s);
 	return (error);
 }
 
+#define	SBLOCKWAIT(f)	(((f) & MSG_DONTWAIT) ? M_NOWAIT : M_WAITOK)
 /*
  * Send on a socket.
  * If send must go all at once and message is larger than
@@ -301,25 +347,33 @@ bad:
  * must check for short counts if EINTR/ERESTART are returned.
  * Data and control buffers are freed on return.
  */
-sosend(so, addr, uio, top, control, flags)
-	register struct socket *so;
-	struct mbuf *addr;
-	struct uio *uio;
-	struct mbuf *top;
-	struct mbuf *control;
-	int flags;
-{
-	struct proc *p = curproc;		/* XXX */
-	struct mbuf **mp;
-	register struct mbuf *m;
-	register long space, len, resid;
-	int clen = 0, error, s, dontroute, mlen;
-	int atomic = sosendallatonce(so) || top;
-
+int
+sosend(struct socket *so, struct mbuf *addr, struct uio *uio, struct mbuf *top,
+	struct mbuf *control, int flags)
+{
+	struct proc	*p;
+	struct mbuf	**mp, *m;
+	long		space, len, resid, clen, mlen;
+	int		error, s, dontroute, atomic;
+
+	p = curproc;		/* XXX */
+	clen = 0;
+	atomic = sosendallatonce(so) || top;
 	if (uio)
 		resid = uio->uio_resid;
 	else
 		resid = top->m_pkthdr.len;
+	/*
+	 * In theory resid should be unsigned.
+	 * However, space must be signed, as it might be less than 0
+	 * if we over-committed, and we must use a signed comparison
+	 * of space and resid.  On the other hand, a negative resid
+	 * causes us to loop sending 0-length segments to the protocol.
+	 */
+	if (resid < 0) {
+		error = EINVAL;
+		goto out;
+	}
 	dontroute =
 	    (flags & MSG_DONTROUTE) && (so->so_options & SO_DONTROUTE) == 0 &&
 	    (so->so_proto->pr_flags & PR_ATOMIC);
@@ -328,15 +382,19 @@ sosend(so, addr, uio, top, control, flag
 		clen = control->m_len;
 #define	snderr(errno)	{ error = errno; splx(s); goto release; }
 
-restart:
-	if (error = sblock(&so->so_snd))
+ restart:
+	if ((error = sblock(&so->so_snd, SBLOCKWAIT(flags))) != 0)
 		goto out;
 	do {
-		s = splnet();
+		s = splsoftnet();
 		if (so->so_state & SS_CANTSENDMORE)
 			snderr(EPIPE);
-		if (so->so_error)
-			snderr(so->so_error);
+		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) {
 				if ((so->so_state & SS_ISCONFIRMING) == 0 &&
@@ -348,11 +406,11 @@ restart:
 		space = sbspace(&so->so_snd);
 		if (flags & MSG_OOB)
 			space += 1024;
-		if (space < resid + clen &&
+		if ((atomic && resid > so->so_snd.sb_hiwat) ||
+		    clen > so->so_snd.sb_hiwat)
+			snderr(EMSGSIZE);
+		if (space < resid + clen && uio &&
 		    (atomic || space < so->so_snd.sb_lowat || space < clen)) {
-			if (atomic && resid > so->so_snd.sb_hiwat ||
-			    clen > so->so_snd.sb_hiwat)
-				snderr(EMSGSIZE);
 			if (so->so_state & SS_NBIO)
 				snderr(EWOULDBLOCK);
 			sbunlock(&so->so_snd);
@@ -366,84 +424,96 @@ restart:
 		mp = &top;
 		space -= clen;
 		do {
-		    if (uio == NULL) {
-			/*
-			 * Data is prepackaged in "top".
-			 */
-			resid = 0;
-			if (flags & MSG_EOR)
-				top->m_flags |= M_EOR;
-		    } else do {
-			if (top == 0) {
-				MGETHDR(m, M_WAIT, MT_DATA);
-				mlen = MHLEN;
-				m->m_pkthdr.len = 0;
-				m->m_pkthdr.rcvif = (struct ifnet *)0;
-			} else {
-				MGET(m, M_WAIT, MT_DATA);
-				mlen = MLEN;
-			}
-			if (resid >= MINCLSIZE && space >= MCLBYTES) {
-				MCLGET(m, M_WAIT);
-				if ((m->m_flags & M_EXT) == 0)
-					goto nopages;
-				mlen = MCLBYTES;
+			if (uio == NULL) {
+				/*
+				 * Data is prepackaged in "top".
+				 */
+				resid = 0;
+				if (flags & MSG_EOR)
+					top->m_flags |= M_EOR;
+			} else do {
+				if (top == 0) {
+					MGETHDR(m, M_WAIT, MT_DATA);
+					mlen = MHLEN;
+					m->m_pkthdr.len = 0;
+					m->m_pkthdr.rcvif = (struct ifnet *)0;
+				} else {
+					MGET(m, M_WAIT, MT_DATA);
+					mlen = MLEN;
+				}
+				if (resid >= MINCLSIZE && space >= MCLBYTES) {
+					MCLGET(m, M_WAIT);
+					if ((m->m_flags & M_EXT) == 0)
+						goto nopages;
+					mlen = MCLBYTES;
 #ifdef	MAPPED_MBUFS
-				len = min(MCLBYTES, resid);
+					len = lmin(MCLBYTES, resid);
 #else
-				if (top == 0) {
-					len = min(MCLBYTES - max_hdr, resid);
-					m->m_data += max_hdr;
-				} else
-					len = min(MCLBYTES, resid);
+					if (atomic && top == 0) {
+						len = lmin(MCLBYTES - max_hdr,
+						    resid);
+						m->m_data += max_hdr;
+					} else
+						len = lmin(MCLBYTES, resid);
 #endif
-				space -= MCLBYTES;
-			} else {
+					space -= len;
+				} else {
 nopages:
-				len = min(min(mlen, resid), space);
-				space -= len;
-				/*
-				 * For datagram protocols, leave room
-				 * for protocol headers in first mbuf.
-				 */
-				if (atomic && top == 0 && len < mlen)
-					MH_ALIGN(m, len);
-			}
-			error = uiomove(mtod(m, caddr_t), (int)len, uio);
-			resid = uio->uio_resid;
-			m->m_len = len;
-			*mp = m;
-			top->m_pkthdr.len += len;
+					len = lmin(lmin(mlen, resid), space);
+					space -= len;
+					/*
+					 * For datagram protocols, leave room
+					 * for protocol headers in first mbuf.
+					 */
+					if (atomic && top == 0 && len < mlen)
+						MH_ALIGN(m, len);
+				}
+				error = uiomove(mtod(m, caddr_t), (int)len,
+				    uio);
+				resid = uio->uio_resid;
+				m->m_len = len;
+				*mp = m;
+				top->m_pkthdr.len += len;
+				if (error)
+					goto release;
+				mp = &m->m_next;
+				if (resid <= 0) {
+					if (flags & MSG_EOR)
+						top->m_flags |= M_EOR;
+					break;
+				}
+			} while (space > 0 && atomic);
+			
+			s = splsoftnet();
+
+			if (so->so_state & SS_CANTSENDMORE)
+				snderr(EPIPE);
+
+			if (dontroute)
+				so->so_options |= SO_DONTROUTE;
+			if (resid > 0)
+				so->so_state |= SS_MORETOCOME;
+			error = (*so->so_proto->pr_usrreq)(so,
+			    (flags & MSG_OOB) ? PRU_SENDOOB : PRU_SEND,
+			    top, addr, control, p);
+			if (dontroute)
+				so->so_options &= ~SO_DONTROUTE;
+			if (resid > 0)
+				so->so_state &= ~SS_MORETOCOME;
+			splx(s);
+
+			clen = 0;
+			control = 0;
+			top = 0;
+			mp = &top;
 			if (error)
 				goto release;
-			mp = &m->m_next;
-			if (resid <= 0) {
-				if (flags & MSG_EOR)
-					top->m_flags |= M_EOR;
-				break;
-			}
-		    } while (space > 0 && atomic);
-		    if (dontroute)
-			    so->so_options |= SO_DONTROUTE;
-		    s = splnet();				/* XXX */
-		    error = (*so->so_proto->pr_usrreq)(so,
-			(flags & MSG_OOB) ? PRU_SENDOOB : PRU_SEND,
-			top, addr, control);
-		    splx(s);
-		    if (dontroute)
-			    so->so_options &= ~SO_DONTROUTE;
-		    clen = 0;
-		    control = 0;
-		    top = 0;
-		    mp = &top;
-		    if (error)
-			goto release;
 		} while (resid && space > 0);
 	} while (resid);
 
-release:
+ release:
 	sbunlock(&so->so_snd);
-out:
+ out:
 	if (top)
 		m_freem(top);
 	if (control)
@@ -467,22 +537,19 @@ out:
  * an mbuf **mp0 for use in returning the chain.  The uio is then used
  * only for the count in uio_resid.
  */
-soreceive(so, paddr, uio, mp0, controlp, flagsp)
-	register struct socket *so;
-	struct mbuf **paddr;
-	struct uio *uio;
-	struct mbuf **mp0;
-	struct mbuf **controlp;
-	int *flagsp;
-{
-	struct proc *p = curproc;		/* XXX */
-	register struct mbuf *m, **mp;
-	register int flags, len, error, s, offset;
-	struct protosw *pr = so->so_proto;
-	struct mbuf *nextrecord;
-	int moff, type;
+int
+soreceive(struct socket *so, struct mbuf **paddr, struct uio *uio,
+	struct mbuf **mp0, struct mbuf **controlp, int *flagsp)
+{
+	struct mbuf	*m, **mp;
+	int		flags, len, error, s, offset, moff, type, orig_resid;
+	struct protosw	*pr;
+	struct mbuf	*nextrecord;
 
+	pr = so->so_proto;
 	mp = mp0;
+	type = 0;
+	orig_resid = uio->uio_resid;
 	if (paddr)
 		*paddr = 0;
 	if (controlp)
@@ -493,8 +560,9 @@ soreceive(so, paddr, uio, mp0, controlp,
 		flags = 0;
 	if (flags & MSG_OOB) {
 		m = m_get(M_WAIT, MT_DATA);
-		error = (*pr->pr_usrreq)(so, PRU_RCVOOB,
-		    m, (struct mbuf *)(flags & MSG_PEEK), (struct mbuf *)0);
+		error = (*pr->pr_usrreq)(so, PRU_RCVOOB, m,
+		    (struct mbuf *)(long)(flags & MSG_PEEK), (struct mbuf *)0,
+		    (struct proc *)0);
 		if (error)
 			goto bad;
 		do {
@@ -502,7 +570,7 @@ soreceive(so, paddr, uio, mp0, controlp,
 			    (int) min(uio->uio_resid, m->m_len), uio);
 			m = m_free(m);
 		} while (uio->uio_resid && error == 0 && m);
-bad:
+ bad:
 		if (m)
 			m_freem(m);
 		return (error);
@@ -511,35 +579,37 @@ bad:
 		*mp = (struct mbuf *)0;
 	if (so->so_state & SS_ISCONFIRMING && uio->uio_resid)
 		(*pr->pr_usrreq)(so, PRU_RCVD, (struct mbuf *)0,
-		    (struct mbuf *)0, (struct mbuf *)0);
+		    (struct mbuf *)0, (struct mbuf *)0, (struct proc *)0);
 
-restart:
-	if (error = sblock(&so->so_rcv))
+ restart:
+	if ((error = sblock(&so->so_rcv, SBLOCKWAIT(flags))) != 0)
 		return (error);
-	s = splnet();
+	s = splsoftnet();
 
 	m = so->so_rcv.sb_mb;
 	/*
 	 * If we have less data than requested, block awaiting more
 	 * (subject to any timeout) if:
-	 *   1. the current count is less than the low water mark, or
+	 *   1. the current count is less than the low water mark,
 	 *   2. MSG_WAITALL is set, and it is possible to do the entire
-	 *	receive operation at once if we block (resid <= hiwat).
+	 *	receive operation at once if we block (resid <= hiwat), or
+	 *   3. MSG_DONTWAIT is not set.
 	 * If MSG_WAITALL is set but resid is larger than the receive buffer,
 	 * we have to do the receive in sections, and thus risk returning
 	 * a short count if a timeout or signal occurs after we start.
 	 */
-	while (m == 0 || so->so_rcv.sb_cc < uio->uio_resid &&
+	if (m == 0 || (((flags & MSG_DONTWAIT) == 0 &&
+	    so->so_rcv.sb_cc < uio->uio_resid) &&
 	    (so->so_rcv.sb_cc < so->so_rcv.sb_lowat ||
 	    ((flags & MSG_WAITALL) && uio->uio_resid <= so->so_rcv.sb_hiwat)) &&
-	    m->m_nextpkt == 0) {
+	    m->m_nextpkt == 0 && (pr->pr_flags & PR_ATOMIC) == 0)) {
 #ifdef DIAGNOSTIC
 		if (m == 0 && so->so_rcv.sb_cc)
 			panic("receive 1");
 #endif
 		if (so->so_error) {
 			if (m)
-				break;
+				goto dontblock;
 			error = so->so_error;
 			if ((flags & MSG_PEEK) == 0)
 				so->so_error = 0;
@@ -547,7 +617,7 @@ restart:
 		}
 		if (so->so_state & SS_CANTRCVMORE) {
 			if (m)
-				break;
+				goto dontblock;
 			else
 				goto release;
 		}
@@ -563,7 +633,7 @@ restart:
 		}
 		if (uio->uio_resid == 0)
 			goto release;
-		if (so->so_state & SS_NBIO) {
+		if ((so->so_state & SS_NBIO) || (flags & MSG_DONTWAIT)) {
 			error = EWOULDBLOCK;
 			goto release;
 		}
@@ -574,14 +644,18 @@ restart:
 			return (error);
 		goto restart;
 	}
-dontblock:
-	p->p_stats->p_ru.ru_msgrcv++;
+ dontblock:
+#ifdef notyet /* XXXX */
+	if (uio->uio_procp)
+		uio->uio_procp->p_stats->p_ru.ru_msgrcv++;
+#endif
 	nextrecord = m->m_nextpkt;
 	if (pr->pr_flags & PR_ADDR) {
 #ifdef DIAGNOSTIC
 		if (m->m_type != MT_SONAME)
 			panic("receive 1a");
 #endif
+		orig_resid = 0;
 		if (flags & MSG_PEEK) {
 			if (paddr)
 				*paddr = m_copy(m, 0, m->m_len);
@@ -610,7 +684,7 @@ dontblock:
 				if (pr->pr_domain->dom_externalize &&
 				    mtod(m, struct cmsghdr *)->cmsg_type ==
 				    SCM_RIGHTS)
-				   error = (*pr->pr_domain->dom_externalize)(m);
+					error = (*pr->pr_domain->dom_externalize)(m);
 				*controlp = m;
 				so->so_rcv.sb_mb = m->m_next;
 				m->m_next = 0;
@@ -620,8 +694,10 @@ dontblock:
 				m = so->so_rcv.sb_mb;
 			}
 		}
-		if (controlp)
+		if (controlp) {
+			orig_resid = 0;
 			controlp = &(*controlp)->m_next;
+		}
 	}
 	if (m) {
 		if ((flags & MSG_PEEK) == 0)
@@ -659,7 +735,9 @@ dontblock:
 		if (mp == 0) {
 			splx(s);
 			error = uiomove(mtod(m, caddr_t) + moff, (int)len, uio);
-			s = splnet();
+			s = splsoftnet();
+			if (error)
+				goto release;
 		} else
 			uio->uio_resid -= len;
 		if (len == m->m_len - moff) {
@@ -701,8 +779,11 @@ dontblock:
 					so->so_state |= SS_RCVATMARK;
 					break;
 				}
-			} else
+			} else {
 				offset += len;
+				if (offset == so->so_oobmark)
+					break;
+			}
 		}
 		if (flags & MSG_EOR)
 			break;
@@ -714,7 +795,7 @@ dontblock:
 		 * Keep sockbuf locked against other readers.
 		 */
 		while (flags & MSG_WAITALL && m == 0 && uio->uio_resid > 0 &&
-		    !sosendallatonce(so)) {
+		    !sosendallatonce(so) && !nextrecord) {
 			if (so->so_error || so->so_state & SS_CANTRCVMORE)
 				break;
 			error = sbwait(&so->so_rcv);
@@ -723,74 +804,86 @@ dontblock:
 				splx(s);
 				return (0);
 			}
-			if (m = so->so_rcv.sb_mb)
+			if ((m = so->so_rcv.sb_mb) != NULL)
 				nextrecord = m->m_nextpkt;
 		}
 	}
+
+	if (m && pr->pr_flags & PR_ATOMIC) {
+		flags |= MSG_TRUNC;
+		if ((flags & MSG_PEEK) == 0)
+			(void) sbdroprecord(&so->so_rcv);
+	}
 	if ((flags & MSG_PEEK) == 0) {
 		if (m == 0)
 			so->so_rcv.sb_mb = nextrecord;
-		else if (pr->pr_flags & PR_ATOMIC) {
-			flags |= MSG_TRUNC;
-			(void) sbdroprecord(&so->so_rcv);
-		}
 		if (pr->pr_flags & PR_WANTRCVD && so->so_pcb)
 			(*pr->pr_usrreq)(so, PRU_RCVD, (struct mbuf *)0,
-			    (struct mbuf *)flags, (struct mbuf *)0,
-			    (struct mbuf *)0);
+			    (struct mbuf *)(long)flags, (struct mbuf *)0,
+			    (struct proc *)0);
 	}
+	if (orig_resid == uio->uio_resid && orig_resid &&
+	    (flags & MSG_EOR) == 0 && (so->so_state & SS_CANTRCVMORE) == 0) {
+		sbunlock(&so->so_rcv);
+		splx(s);
+		goto restart;
+	}
+		
 	if (flagsp)
 		*flagsp |= flags;
-release:
+ release:
 	sbunlock(&so->so_rcv);
 	splx(s);
 	return (error);
 }
 
-soshutdown(so, how)
-	register struct socket *so;
-	register int how;
+int
+soshutdown(struct socket *so, int how)
 {
-	register struct protosw *pr = so->so_proto;
+	struct protosw	*pr;
+
+	pr = so->so_proto;
+	if (!(how == SHUT_RD || how == SHUT_WR || how == SHUT_RDWR))
+		return (EINVAL);
 
-	how++;
-	if (how & FREAD)
+	if (how == SHUT_RD || how == SHUT_RDWR)
 		sorflush(so);
-	if (how & FWRITE)
-		return ((*pr->pr_usrreq)(so, PRU_SHUTDOWN,
-		    (struct mbuf *)0, (struct mbuf *)0, (struct mbuf *)0));
+	if (how == SHUT_WR || how == SHUT_RDWR)
+		return (*pr->pr_usrreq)(so, PRU_SHUTDOWN, (struct mbuf *)0,
+		    (struct mbuf *)0, (struct mbuf *)0, (struct proc *)0);
 	return (0);
 }
 
-sorflush(so)
-	register struct socket *so;
+void
+sorflush(struct socket *so)
 {
-	register struct sockbuf *sb = &so->so_rcv;
-	register struct protosw *pr = so->so_proto;
-	register int s;
-	struct sockbuf asb;
+	struct sockbuf	*sb, asb;
+	struct protosw	*pr;
+	int		s;
 
+	sb = &so->so_rcv;
+	pr = so->so_proto;
 	sb->sb_flags |= SB_NOINTR;
-	(void) sblock(sb);
-	s = splimp();
+	(void) sblock(sb, M_WAITOK);
+	s = splnet();
 	socantrcvmore(so);
 	sbunlock(sb);
 	asb = *sb;
-	bzero((caddr_t)sb, sizeof (*sb));
+	memset((caddr_t)sb, 0, sizeof(*sb));
 	splx(s);
 	if (pr->pr_flags & PR_RIGHTS && pr->pr_domain->dom_dispose)
 		(*pr->pr_domain->dom_dispose)(asb.sb_mb);
 	sbrelease(&asb);
 }
 
-sosetopt(so, level, optname, m0)
-	register struct socket *so;
-	int level, optname;
-	struct mbuf *m0;
+int
+sosetopt(struct socket *so, int level, int optname, struct mbuf *m0)
 {
-	int error = 0;
-	register struct mbuf *m = m0;
+	int		error;
+	struct mbuf	*m;
 
+	error = 0;
+	m = m0;
 	if (level != SOL_SOCKET) {
 		if (so->so_proto && so->so_proto->pr_ctloutput)
 			return ((*so->so_proto->pr_ctloutput)
@@ -800,7 +893,7 @@ sosetopt(so, level, optname, m0)
 		switch (optname) {
 
 		case SO_LINGER:
-			if (m == NULL || m->m_len != sizeof (struct linger)) {
+			if (m == NULL || m->m_len != sizeof(struct linger)) {
 				error = EINVAL;
 				goto bad;
 			}
@@ -813,8 +906,10 @@ sosetopt(so, level, optname, m0)
 		case SO_USELOOPBACK:
 		case SO_BROADCAST:
 		case SO_REUSEADDR:
+		case SO_REUSEPORT:
 		case SO_OOBINLINE:
-			if (m == NULL || m->m_len < sizeof (int)) {
+		case SO_TIMESTAMP:
+			if (m == NULL || m->m_len < sizeof(int)) {
 				error = EINVAL;
 				goto bad;
 			}
@@ -828,30 +923,53 @@ sosetopt(so, level, optname, m0)
 		case SO_RCVBUF:
 		case SO_SNDLOWAT:
 		case SO_RCVLOWAT:
-			if (m == NULL || m->m_len < sizeof (int)) {
+		    {
+			int optval;
+
+			if (m == NULL || m->m_len < sizeof(int)) {
 				error = EINVAL;
 				goto bad;
 			}
+
+			/*
+			 * Values < 1 make no sense for any of these
+			 * options, so disallow them.
+			 */
+			optval = *mtod(m, int *);
+			if (optval < 1) {
+				error = EINVAL;
+				goto bad;
+			}
+
 			switch (optname) {
 
 			case SO_SNDBUF:
 			case SO_RCVBUF:
 				if (sbreserve(optname == SO_SNDBUF ?
 				    &so->so_snd : &so->so_rcv,
-				    (u_long) *mtod(m, int *)) == 0) {
+				    (u_long) optval) == 0) {
 					error = ENOBUFS;
 					goto bad;
 				}
 				break;
 
+			/*
+			 * Make sure the low-water is never greater than
+			 * the high-water.
+			 */
 			case SO_SNDLOWAT:
-				so->so_snd.sb_lowat = *mtod(m, int *);
+				so->so_snd.sb_lowat =
+				    (optval > so->so_snd.sb_hiwat) ?
+				    so->so_snd.sb_hiwat : optval;
 				break;
 			case SO_RCVLOWAT:
-				so->so_rcv.sb_lowat = *mtod(m, int *);
+				so->so_rcv.sb_lowat =
+				    (optval > so->so_rcv.sb_hiwat) ?
+				    so->so_rcv.sb_hiwat : optval;
 				break;
 			}
 			break;
+		    }
 
 		case SO_SNDTIMEO:
 		case SO_RCVTIMEO:
@@ -859,12 +977,12 @@ sosetopt(so, level, optname, m0)
 			struct timeval *tv;
 			short val;
 
-			if (m == NULL || m->m_len < sizeof (*tv)) {
+			if (m == NULL || m->m_len < sizeof(*tv)) {
 				error = EINVAL;
 				goto bad;
 			}
 			tv = mtod(m, struct timeval *);
-			if (tv->tv_sec > SHRT_MAX / hz - hz) {
+			if (tv->tv_sec * hz + tv->tv_usec / tick > SHRT_MAX) {
 				error = EDOM;
 				goto bad;
 			}
@@ -886,19 +1004,22 @@ sosetopt(so, level, optname, m0)
 			error = ENOPROTOOPT;
 			break;
 		}
+		if (error == 0 && so->so_proto && so->so_proto->pr_ctloutput) {
+			(void) ((*so->so_proto->pr_ctloutput)
+				  (PRCO_SETOPT, so, level, optname, &m0));
+			m = NULL;	/* freed by protocol */
+		}
 	}
-bad:
+ bad:
 	if (m)
 		(void) m_free(m);
 	return (error);
 }
 
-sogetopt(so, level, optname, mp)
-	register struct socket *so;
-	int level, optname;
-	struct mbuf **mp;
+int
+sogetopt(struct socket *so, int level, int optname, struct mbuf **mp)
 {
-	register struct mbuf *m;
+	struct mbuf	*m;
 
 	if (level != SOL_SOCKET) {
 		if (so->so_proto && so->so_proto->pr_ctloutput) {
@@ -908,12 +1029,12 @@ sogetopt(so, level, optname, mp)
 			return (ENOPROTOOPT);
 	} else {
 		m = m_get(M_WAIT, MT_SOOPTS);
-		m->m_len = sizeof (int);
+		m->m_len = sizeof(int);
 
 		switch (optname) {
 
 		case SO_LINGER:
-			m->m_len = sizeof (struct linger);
+			m->m_len = sizeof(struct linger);
 			mtod(m, struct linger *)->l_onoff =
 				so->so_options & SO_LINGER;
 			mtod(m, struct linger *)->l_linger = so->so_linger;
@@ -924,8 +1045,10 @@ sogetopt(so, level, optname, mp)
 		case SO_DEBUG:
 		case SO_KEEPALIVE:
 		case SO_REUSEADDR:
+		case SO_REUSEPORT:
 		case SO_BROADCAST:
 		case SO_OOBINLINE:
+		case SO_TIMESTAMP:
 			*mtod(m, int *) = so->so_options & optname;
 			break;
 
@@ -963,7 +1086,7 @@ sogetopt(so, level, optname, mp)
 			m->m_len = sizeof(struct timeval);
 			mtod(m, struct timeval *)->tv_sec = val / hz;
 			mtod(m, struct timeval *)->tv_usec =
-			    (val % hz) / tick;
+			    (val % hz) * tick;
 			break;
 		    }
 
@@ -976,8 +1099,8 @@ sogetopt(so, level, optname, mp)
 	}
 }
 
-sohasoutofband(so)
-	register struct socket *so;
+void
+sohasoutofband(struct socket *so)
 {
 	struct proc *p;