X-Git-Url: https://git.saurik.com/apple/xnu.git/blobdiff_plain/4452a7af2eac33dbad800bcc91f2399d62c18f53..935ed37a5c468c8a1c07408573c08b8b7ef80e8b:/bsd/kern/uipc_socket2.c

diff --git a/bsd/kern/uipc_socket2.c b/bsd/kern/uipc_socket2.c
index 591ee95de..41a606ca3 100644
--- a/bsd/kern/uipc_socket2.c
+++ b/bsd/kern/uipc_socket2.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 1998-2007 Apple Inc. All rights reserved.
  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  * 
@@ -25,7 +25,6 @@
  * 
  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  */
-/* Copyright (c) 1998, 1999 Apple Computer, Inc. All Rights Reserved */
 /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
 /*
  * Copyright (c) 1982, 1986, 1988, 1990, 1993
@@ -62,6 +61,12 @@
  *	@(#)uipc_socket2.c	8.1 (Berkeley) 6/10/93
  * $FreeBSD: src/sys/kern/uipc_socket2.c,v 1.55.2.9 2001/07/26 18:53:02 peter Exp $
  */
+/*
+ * NOTICE: This file was modified by SPARTA, Inc. in 2005 to introduce
+ * support for mandatory and extensible security protections.  This notice
+ * is included in support of clause 2.2 (b) of the Apple Public License,
+ * Version 2.0.
+ */
 
 #include <sys/param.h>
 #include <sys/systm.h>
@@ -83,19 +88,37 @@
 #include <netinet/in.h>
 #include <netinet/in_pcb.h>
 #include <sys/kdebug.h>
+#include <libkern/OSAtomic.h>
+
+#if CONFIG_MACF
+#include <security/mac_framework.h>
+#endif
+
+/* TODO: this should be in a header file somewhere */
+extern void postevent(struct socket *, struct sockbuf *, int);
 
 #define DBG_FNC_SBDROP	NETDBG_CODE(DBG_NETSOCK, 4)
 #define DBG_FNC_SBAPPEND	NETDBG_CODE(DBG_NETSOCK, 5)
 
-static int sbcompress(struct sockbuf *, struct mbuf *, struct mbuf *);
+static inline void sbcompress(struct sockbuf *, struct mbuf *, struct mbuf *);
+static struct socket *sonewconn_internal(struct socket *, int);
+static int sbappendaddr_internal(struct sockbuf *, struct sockaddr *,
+    struct mbuf *, struct mbuf *);
+static int sbappendcontrol_internal(struct sockbuf *, struct mbuf *,
+    struct mbuf *);
 
 /*
  * Primitive routines for operating on sockets and socket buffers
  */
+static int soqlimitcompat = 1;
+static int soqlencomp = 0;
 
 u_long	sb_max = SB_MAX;		/* XXX should be static */
 
 static	u_long sb_efficiency = 8;	/* parameter for sbreserve() */
+__private_extern__ unsigned int total_mb_cnt = 0;
+__private_extern__ unsigned int total_cl_cnt = 0;
+__private_extern__ int sbspace_factor = 8;
 
 /*
  * Procedures to manipulate state flags of socket
@@ -127,27 +150,25 @@ static	u_long sb_efficiency = 8;	/* parameter for sbreserve() */
  * cause software-interrupt process scheduling.
  */
 void
-soisconnecting(so)
-	register struct socket *so;
+soisconnecting(struct socket *so)
 {
 
 	so->so_state &= ~(SS_ISCONNECTED|SS_ISDISCONNECTING);
 	so->so_state |= SS_ISCONNECTING;
-	
+
 	sflt_notify(so, sock_evt_connecting, NULL);
 }
 
 void
-soisconnected(so)
-	struct socket *so;
+soisconnected(struct socket *so)
 {
 	struct socket *head = so->so_head;
 
 	so->so_state &= ~(SS_ISCONNECTING|SS_ISDISCONNECTING|SS_ISCONFIRMING);
 	so->so_state |= SS_ISCONNECTED;
-	
+
 	sflt_notify(so, sock_evt_connected, NULL);
-	
+
 	if (head && (so->so_state & SS_INCOMP)) {
 		so->so_state &= ~SS_INCOMP;
 		so->so_state |= SS_COMP;
@@ -174,8 +195,7 @@ soisconnected(so)
 }
 
 void
-soisdisconnecting(so)
-	register struct socket *so;
+soisdisconnecting(struct socket *so)
 {
 	so->so_state &= ~SS_ISCONNECTING;
 	so->so_state |= (SS_ISDISCONNECTING|SS_CANTRCVMORE|SS_CANTSENDMORE);
@@ -186,8 +206,7 @@ soisdisconnecting(so)
 }
 
 void
-soisdisconnected(so)
-	register struct socket *so;
+soisdisconnected(struct socket *so)
 {
 	so->so_state &= ~(SS_ISCONNECTING|SS_ISCONNECTED|SS_ISDISCONNECTING);
 	so->so_state |= (SS_CANTRCVMORE|SS_CANTSENDMORE|SS_ISDISCONNECTED);
@@ -197,59 +216,6 @@ soisdisconnected(so)
 	sorwakeup(so);
 }
 
-/*
- * Return a random connection that hasn't been serviced yet and
- * is eligible for discard.  There is a one in qlen chance that
- * we will return a null, saying that there are no dropable
- * requests.  In this case, the protocol specific code should drop
- * the new request.  This insures fairness.
- *
- * This may be used in conjunction with protocol specific queue
- * congestion routines.
- */
-struct socket *
-sodropablereq(head)
-	register struct socket *head;
-{
-	struct socket *so, *sonext = NULL;
-	unsigned int i, j, qlen;
-	static int rnd;
-	static struct timeval old_runtime;
-	static unsigned int cur_cnt, old_cnt;
-	struct timeval tv;
-
-	microtime(&tv);
-	if ((i = (tv.tv_sec - old_runtime.tv_sec)) != 0) {
-		old_runtime = tv;
-		old_cnt = cur_cnt / i;
-		cur_cnt = 0;
-	}
-
-	so = TAILQ_FIRST(&head->so_incomp);
-	if (!so)
-		return (NULL);
-
-	qlen = head->so_incqlen;
-	if (++cur_cnt > qlen || old_cnt > qlen) {
-		rnd = (314159 * rnd + 66329) & 0xffff;
-		j = ((qlen + 1) * rnd) >> 16;
-//###LD To clean up
-		while (j-- && so) {
-//			if (in_pcb_checkstate(so->so_pcb, WNT_ACQUIRE, 0) != WNT_STOPUSING) {
-				socket_lock(so, 1);
-		    		sonext = TAILQ_NEXT(so, so_list);
-//				in_pcb_check_state(so->so_pcb, WNT_RELEASE, 0);
-				socket_unlock(so, 1);	
-		    		so = sonext;
-		}
-	}
-
-//	if (in_pcb_checkstate(so->so_pcb, WNT_ACQUIRE, 0) == WNT_STOPUSING) 
-//		return (NULL);
-//	else
-		return (so);
-}
-
 /*
  * When an attempt at a new connection is noted on a socket
  * which accepts connections, sonewconn is called.  If the
@@ -259,29 +225,49 @@ sodropablereq(head)
  * Connstatus may be 0, or SO_ISCONFIRMING, or SO_ISCONNECTED.
  */
 static struct socket *
-sonewconn_internal(head, connstatus)
-	register struct socket *head;
-	int connstatus;
+sonewconn_internal(struct socket *head, int connstatus)
 {
-	int error = 0;
-	register struct socket *so;
+	int so_qlen, error = 0;
+	struct socket *so;
 	lck_mtx_t *mutex_held;
 
-	if (head->so_proto->pr_getlock != NULL) 
+	if (head->so_proto->pr_getlock != NULL)
 		mutex_held = (*head->so_proto->pr_getlock)(head, 0);
-	else 
+	else
 		mutex_held = head->so_proto->pr_domain->dom_mtx;
 	lck_mtx_assert(mutex_held, LCK_MTX_ASSERT_OWNED);
 
-	if (head->so_qlen > 3 * head->so_qlimit / 2)
+	if (!soqlencomp) {
+		/*
+		 * This is the default case; so_qlen represents the
+		 * sum of both incomplete and completed queues.
+		 */
+		so_qlen = head->so_qlen;
+	} else {
+		/*
+		 * When kern.ipc.soqlencomp is set to 1, so_qlen
+		 * represents only the completed queue.  Since we
+		 * cannot let the incomplete queue goes unbounded
+		 * (in case of SYN flood), we cap the incomplete
+		 * queue length to at most somaxconn, and use that
+		 * as so_qlen so that we fail immediately below.
+		 */
+		so_qlen = head->so_qlen - head->so_incqlen;
+		if (head->so_incqlen > somaxconn)
+			so_qlen = somaxconn;
+	}
+
+	if (so_qlen >=
+	    (soqlimitcompat ? head->so_qlimit : (3 * head->so_qlimit / 2)))
 		return ((struct socket *)0);
-	so = soalloc(1, head->so_proto->pr_domain->dom_family, head->so_type);
+	so = soalloc(M_NOWAIT, head->so_proto->pr_domain->dom_family,
+	    head->so_type);
 	if (so == NULL)
 		return ((struct socket *)0);
 	/* check if head was closed during the soalloc */
 	if (head->so_proto == NULL) {
-	  sodealloc(so);
-	  return ((struct socket *)0);
+		sodealloc(so);
+		return ((struct socket *)0);
 	}
 
 	so->so_head = head;
@@ -293,6 +279,7 @@ sonewconn_internal(head, connstatus)
 	so->so_timeo = head->so_timeo;
 	so->so_pgid  = head->so_pgid;
 	so->so_uid = head->so_uid;
+	so->so_flags = head->so_flags & (SOF_REUSESHAREUID|SOF_NOTIFYCONFLICT); /* inherit SO_REUSESHAREUID and SO_NOTIFYCONFLICT ocket options */
 	so->so_usecount = 1;
 	so->next_lock_lr = 0;
 	so->next_unlock_lr = 0;
@@ -303,6 +290,10 @@ sonewconn_internal(head, connstatus)
 	TAILQ_INIT(&so->so_evlist);
 #endif
 
+#if CONFIG_MACF_SOCKET
+	mac_socket_label_associate_accept(head, so);
+#endif
+
 	if (soreserve(so, head->so_snd.sb_hiwat, head->so_rcv.sb_hiwat)) {
 		sflt_termsock(so);
 		sodealloc(so);
@@ -310,11 +301,13 @@ sonewconn_internal(head, connstatus)
 	}
 
 	/*
-	 * Must be done with head unlocked to avoid deadlock for protocol with per socket mutexes.
+	 * Must be done with head unlocked to avoid deadlock
+	 * for protocol with per socket mutexes.
 	 */
 	if (head->so_proto->pr_unlock)
 		socket_unlock(head, 0);
-	if (((*so->so_proto->pr_usrreqs->pru_attach)(so, 0, NULL) != 0) || error) {
+	if (((*so->so_proto->pr_usrreqs->pru_attach)(so, 0, NULL) != 0) ||
+	    error) {
 		sflt_termsock(so);
 		sodealloc(so);
 		if (head->so_proto->pr_unlock)
@@ -341,6 +334,7 @@ sonewconn_internal(head, connstatus)
 	/* Attach socket filters for this protocol */
 	sflt_initsock(so);
 #endif
+
 	if (connstatus) {
 		so->so_state |= connstatus;
 		sorwakeup(head);
@@ -351,38 +345,34 @@ sonewconn_internal(head, connstatus)
 
 
 struct socket *
-sonewconn(
-	struct socket *head,
-	int connstatus,
-	const struct sockaddr *from)
+sonewconn(struct socket *head, int connstatus, const struct sockaddr *from)
 {
 	int error = 0;
-	struct socket_filter_entry	*filter;
-	int						 	filtered = 0;
-	
-	error = 0;
+	struct socket_filter_entry *filter;
+	int filtered = 0;
+
 	for (filter = head->so_filt; filter && (error == 0);
-		 filter = filter->sfe_next_onsocket) {
+	    filter = filter->sfe_next_onsocket) {
 		if (filter->sfe_filter->sf_filter.sf_connect_in) {
 			if (filtered == 0) {
 				filtered = 1;
 				sflt_use(head);
 				socket_unlock(head, 0);
 			}
-			error = filter->sfe_filter->sf_filter.sf_connect_in(
-						filter->sfe_cookie, head, from);
+			error = filter->sfe_filter->sf_filter.
+			    sf_connect_in(filter->sfe_cookie, head, from);
 		}
 	}
 	if (filtered != 0) {
 		socket_lock(head, 0);
 		sflt_unuse(head);
 	}
-	
+
 	if (error) {
-		return NULL;
+		return (NULL);
 	}
-	
-	return sonewconn_internal(head, connstatus);
+
+	return (sonewconn_internal(head, connstatus));
 }
 
 /*
@@ -396,8 +386,7 @@ sonewconn(
  */
 
 void
-socantsendmore(so)
-	struct socket *so;
+socantsendmore(struct socket *so)
 {
 	so->so_state |= SS_CANTSENDMORE;
 	sflt_notify(so, sock_evt_cantsendmore, NULL);
@@ -405,8 +394,7 @@ socantsendmore(so)
 }
 
 void
-socantrcvmore(so)
-	struct socket *so;
+socantrcvmore(struct socket *so)
 {
 	so->so_state |= SS_CANTRCVMORE;
 	sflt_notify(so, sock_evt_cantrecvmore, NULL);
@@ -415,10 +403,13 @@ socantrcvmore(so)
 
 /*
  * Wait for data to arrive at/drain from a socket buffer.
+ *
+ * Returns:	0			Success
+ *		EBADF
+ *	msleep:EINTR
  */
 int
-sbwait(sb)
-	struct sockbuf *sb;
+sbwait(struct sockbuf *sb)
 {
 	int error = 0, lr_saved;
 	struct socket *so = sb->sb_so;
@@ -426,26 +417,25 @@ sbwait(sb)
 	struct timespec ts;
 
 	lr_saved = (unsigned int) __builtin_return_address(0);
-	
-	if (so->so_proto->pr_getlock != NULL) 
+
+	if (so->so_proto->pr_getlock != NULL)
 		mutex_held = (*so->so_proto->pr_getlock)(so, 0);
-	else 
+	else
 		mutex_held = so->so_proto->pr_domain->dom_mtx;
 
 	sb->sb_flags |= SB_WAIT;
 
 	if (so->so_usecount < 1)
-		panic("sbwait: so=%x refcount=%d\n", so, so->so_usecount);
+		panic("sbwait: so=%p refcount=%d\n", so, so->so_usecount);
 	ts.tv_sec = sb->sb_timeo.tv_sec;
 	ts.tv_nsec = sb->sb_timeo.tv_usec * 1000;
 	error = msleep((caddr_t)&sb->sb_cc, mutex_held,
-    		(sb->sb_flags & SB_NOINTR) ? PSOCK : PSOCK | PCATCH, "sbwait",
-    		&ts);
+	    (sb->sb_flags & SB_NOINTR) ? PSOCK : PSOCK | PCATCH, "sbwait", &ts);
 
 	lck_mtx_assert(mutex_held, LCK_MTX_ASSERT_OWNED);
 
 	if (so->so_usecount < 1)
-		panic("sbwait: so=%x refcount=%d\n", so, so->so_usecount);
+		panic("sbwait: so=%p refcount=%d\n", so, so->so_usecount);
 
 	if ((so->so_state & SS_DRAINING)) {
 		error = EBADF;
@@ -457,32 +447,37 @@ sbwait(sb)
 /*
  * Lock a sockbuf already known to be locked;
  * return any error returned from sleep (EINTR).
+ *
+ * Returns:	0			Success
+ *		EINTR
  */
 int
-sb_lock(sb)
-	register struct sockbuf *sb;
+sb_lock(struct sockbuf *sb)
 {
 	struct socket *so = sb->sb_so;
-	lck_mtx_t * mutex_held;
+	lck_mtx_t *mutex_held;
 	int error = 0;
-	
+
 	if (so == NULL)
-		panic("sb_lock: null so back pointer sb=%x\n", sb);
+		panic("sb_lock: null so back pointer sb=%p\n", sb);
 
 	while (sb->sb_flags & SB_LOCK) {
 		sb->sb_flags |= SB_WANT;
-		if (so->so_proto->pr_getlock != NULL) 
+		if (so->so_proto->pr_getlock != NULL)
 			mutex_held = (*so->so_proto->pr_getlock)(so, 0);
 		else
 			mutex_held = so->so_proto->pr_domain->dom_mtx;
 		if (so->so_usecount < 1)
-			panic("sb_lock: so=%x refcount=%d\n", so, so->so_usecount);
+			panic("sb_lock: so=%p refcount=%d\n", so,
+			    so->so_usecount);
 
 		error = msleep((caddr_t)&sb->sb_flags, mutex_held,
-	    		(sb->sb_flags & SB_NOINTR) ? PSOCK : PSOCK | PCATCH, "sblock", 0);
+		    (sb->sb_flags & SB_NOINTR) ? PSOCK : PSOCK | PCATCH,
+		    "sb_lock", 0);
 		if (so->so_usecount < 1)
-			panic("sb_lock: 2 so=%x refcount=%d\n", so, so->so_usecount);
-		if (error) 
+			panic("sb_lock: 2 so=%p refcount=%d\n", so,
+			    so->so_usecount);
+		if (error)
 			return (error);
 	}
 	sb->sb_flags |= SB_LOCK;
@@ -495,11 +490,8 @@ sb_lock(sb)
  * if the socket has the SS_ASYNC flag set.
  */
 void
-sowakeup(so, sb)
-	register struct socket *so;
-	register struct sockbuf *sb;
+sowakeup(struct socket *so, struct sockbuf *sb)
 {
-	struct proc *p = current_proc();
 	sb->sb_flags &= ~SB_SEL;
 	selwakeup(&sb->sb_sel);
 	if (sb->sb_flags & SB_WAIT) {
@@ -509,16 +501,29 @@ sowakeup(so, sb)
 	if (so->so_state & SS_ASYNC) {
 		if (so->so_pgid < 0)
 			gsignal(-so->so_pgid, SIGIO);
-		else if (so->so_pgid > 0 && (p = pfind(so->so_pgid)) != 0)
-			psignal(p, SIGIO);
+		else if (so->so_pgid > 0)
+			proc_signal(so->so_pgid, SIGIO);
 	}
 	if (sb->sb_flags & SB_KNOTE) {
 		KNOTE(&sb->sb_sel.si_note, SO_FILT_HINT_LOCKED);
 	}
 	if (sb->sb_flags & SB_UPCALL) {
+		void (*so_upcall)(struct socket *, caddr_t, int);
+		caddr_t so_upcallarg;
+
+		so_upcall = so->so_upcall;
+		so_upcallarg = so->so_upcallarg;
+		/* Let close know that we're about to do an upcall */
+		so->so_flags |= SOF_UPCALLINUSE;
+
 		socket_unlock(so, 0);
-		(*so->so_upcall)(so, so->so_upcallarg, M_DONTWAIT);
+		(*so_upcall)(so, so_upcallarg, M_DONTWAIT);
 		socket_lock(so, 0);
+
+		so->so_flags &= ~SOF_UPCALLINUSE;
+		/* Tell close that it's safe to proceed */
+		if (so->so_flags & SOF_CLOSEWAIT)
+			wakeup((caddr_t)&so->so_upcall);
 	}
 }
 
@@ -554,10 +559,12 @@ sowakeup(so, sb)
  * should be released by calling sbrelease() when the socket is destroyed.
  */
 
+/*
+ * Returns:	0			Success
+ *		ENOBUFS
+ */
 int
-soreserve(so, sndcc, rcvcc)
-	register struct socket *so;
-	u_long sndcc, rcvcc;
+soreserve(struct socket *so, u_long sndcc, u_long rcvcc)
 {
 
 	if (sbreserve(&so->so_snd, sndcc) == 0)
@@ -586,9 +593,7 @@ bad:
  * if buffering efficiency is near the normal case.
  */
 int
-sbreserve(sb, cc)
-	struct sockbuf *sb;
-	u_long cc;
+sbreserve(struct sockbuf *sb, u_long cc)
 {
 	if ((u_quad_t)cc > (u_quad_t)sb_max * MCLBYTES / (MSIZE + MCLBYTES))
 		return (0);
@@ -602,16 +607,13 @@ sbreserve(sb, cc)
 /*
  * Free mbufs held by a socket, and reserved mbuf space.
  */
- /*  WARNING needs to do selthreadclear() before calling this */
+/*  WARNING needs to do selthreadclear() before calling this */
 void
-sbrelease(sb)
-	struct sockbuf *sb;
+sbrelease(struct sockbuf *sb)
 {
-
 	sbflush(sb);
 	sb->sb_hiwat = 0;
 	sb->sb_mbmax = 0;
-	
 }
 
 /*
@@ -646,73 +648,88 @@ sbrelease(sb)
  * discarded and mbufs are compacted where possible.
  */
 int
-sbappend(sb, m)
-	struct sockbuf *sb;
-	struct mbuf *m;
+sbappend(struct sockbuf *sb, struct mbuf *m)
 {
-	register struct mbuf *n, *sb_first;
-	int result = 0;
-	int error = 0;
-	int	filtered = 0;
+	struct socket *so = sb->sb_so;
 
+	if (m == NULL || (sb->sb_flags & SB_DROP)) {
+		if (m != NULL)
+			m_freem(m);
+		return (0);
+	}
 
-	KERNEL_DEBUG((DBG_FNC_SBAPPEND | DBG_FUNC_START), sb, m->m_len, 0, 0, 0);
+	SBLASTRECORDCHK(sb, "sbappend 1");
 
-	if (m == 0)
-		return 0;
-	
-again:
-	sb_first = n = sb->sb_mb;
-	if (n) {
-		while (n->m_nextpkt)
-			n = n->m_nextpkt;
-		do {
-			if (n->m_flags & M_EOR) {
-				result = sbappendrecord(sb, m); /* XXXXXX!!!! */
-				KERNEL_DEBUG((DBG_FNC_SBAPPEND | DBG_FUNC_END), sb, sb->sb_cc, 0, 0, 0);
-				return result;
-			}
-		} while (n->m_next && (n = n->m_next));
-	}
-	
-	if (!filtered && (sb->sb_flags & SB_RECV) != 0) {
-		error = sflt_data_in(sb->sb_so, NULL, &m, NULL, 0, &filtered);
-		if (error) {
-			/* no data was appended, caller should not call sowakeup */
-			return 0;
+	if (sb->sb_lastrecord != NULL && (sb->sb_mbtail->m_flags & M_EOR))
+		return (sbappendrecord(sb, m));
+
+	if (sb->sb_flags & SB_RECV) {
+		int error = sflt_data_in(so, NULL, &m, NULL, 0, NULL);
+		SBLASTRECORDCHK(sb, "sbappend 2");
+		if (error != 0) {
+			if (error != EJUSTRETURN)
+				m_freem(m);
+			return (0);
 		}
-		
-		/*
-		  If we any filters, the socket lock was dropped. n and sb_first
-		  cached data from the socket buffer. This cache is not valid
-		  since we dropped the lock. We must start over. Since filtered
-		  is set we won't run through the filters a second time. We just
-		  set n and sb_start again.
-		*/
-		if (filtered)
-			goto again;
 	}
 
-	result = sbcompress(sb, m, n);
+	/* If this is the first record, it's also the last record */
+	if (sb->sb_lastrecord == NULL)
+		sb->sb_lastrecord = m;
 
-	KERNEL_DEBUG((DBG_FNC_SBAPPEND | DBG_FUNC_END), sb, sb->sb_cc, 0, 0, 0);
-	
-	return result;
+	sbcompress(sb, m, sb->sb_mbtail);
+	SBLASTRECORDCHK(sb, "sbappend 3");
+	return (1);
+}
+
+/*
+ * Similar to sbappend, except that this is optimized for stream sockets.
+ */
+int
+sbappendstream(struct sockbuf *sb, struct mbuf *m)
+{
+	struct socket *so = sb->sb_so;
+
+	if (m->m_nextpkt != NULL || (sb->sb_mb != sb->sb_lastrecord))
+		panic("sbappendstream: nexpkt %p || mb %p != lastrecord %p\n",
+		    m->m_nextpkt, sb->sb_mb, sb->sb_lastrecord);
+
+	SBLASTMBUFCHK(sb, __func__);
+
+	if (m == NULL || (sb->sb_flags & SB_DROP)) {
+		if (m != NULL)
+			m_freem(m);
+		return (0);
+	}
+
+	if (sb->sb_flags & SB_RECV) {
+		int error = sflt_data_in(so, NULL, &m, NULL, 0, NULL);
+		SBLASTRECORDCHK(sb, "sbappendstream 1");
+		if (error != 0) {
+			if (error != EJUSTRETURN)
+				m_freem(m);
+			return (0);
+		}
+	}
+
+	sbcompress(sb, m, sb->sb_mbtail);
+	sb->sb_lastrecord = sb->sb_mb;
+	SBLASTRECORDCHK(sb, "sbappendstream 2");
+	return (1);
 }
 
 #ifdef SOCKBUF_DEBUG
 void
-sbcheck(sb)
-	register struct sockbuf *sb;
+sbcheck(struct sockbuf *sb)
 {
-	register struct mbuf *m;
-	register struct mbuf *n = 0;
-	register u_long len = 0, mbcnt = 0;
+	struct mbuf *m;
+	struct mbuf *n = 0;
+	u_long len = 0, mbcnt = 0;
 	lck_mtx_t *mutex_held;
 
-	if (sb->sb_so->so_proto->pr_getlock != NULL) 
+	if (sb->sb_so->so_proto->pr_getlock != NULL)
 		mutex_held = (*sb->sb_so->so_proto->pr_getlock)(sb->sb_so, 0);
-	else 
+	else
 		mutex_held = sb->sb_so->so_proto->pr_domain->dom_mtx;
 
 	lck_mtx_assert(mutex_held, LCK_MTX_ASSERT_OWNED);
@@ -721,65 +738,122 @@ sbcheck(sb)
 		return;
 
 	for (m = sb->sb_mb; m; m = n) {
-	    n = m->m_nextpkt;
-	    for (; m; m = m->m_next) {
-                len += m->m_len;
-                mbcnt += MSIZE;
-                if (m->m_flags & M_EXT) /*XXX*/ /* pretty sure this is bogus */
-                    mbcnt += m->m_ext.ext_size;
-            }
+		n = m->m_nextpkt;
+		for (; m; m = m->m_next) {
+			len += m->m_len;
+			mbcnt += MSIZE;
+			/* XXX pretty sure this is bogus */
+			if (m->m_flags & M_EXT)
+				mbcnt += m->m_ext.ext_size;
+		}
+	}
+	if (len != sb->sb_cc || mbcnt != sb->sb_mbcnt) {
+		panic("cc %ld != %ld || mbcnt %ld != %ld\n", len, sb->sb_cc,
+		    mbcnt, sb->sb_mbcnt);
 	}
-        if (len != sb->sb_cc || mbcnt != sb->sb_mbcnt) {
-                panic("cc %ld != %ld || mbcnt %ld != %ld\n", len, sb->sb_cc,
-                    mbcnt, sb->sb_mbcnt);
-        }
 }
 #endif
 
+void
+sblastrecordchk(struct sockbuf *sb, const char *where)
+{
+	struct mbuf *m = sb->sb_mb;
+
+	while (m && m->m_nextpkt)
+		m = m->m_nextpkt;
+
+	if (m != sb->sb_lastrecord) {
+		printf("sblastrecordchk: mb %p lastrecord %p last %p\n",
+		    sb->sb_mb, sb->sb_lastrecord, m);
+		printf("packet chain:\n");
+		for (m = sb->sb_mb; m != NULL; m = m->m_nextpkt)
+			printf("\t%p\n", m);
+		panic("sblastrecordchk from %s", where);
+	}
+}
+
+void
+sblastmbufchk(struct sockbuf *sb, const char *where)
+{
+	struct mbuf *m = sb->sb_mb;
+	struct mbuf *n;
+
+	while (m && m->m_nextpkt)
+		m = m->m_nextpkt;
+
+	while (m && m->m_next)
+		m = m->m_next;
+
+	if (m != sb->sb_mbtail) {
+		printf("sblastmbufchk: mb %p mbtail %p last %p\n",
+		    sb->sb_mb, sb->sb_mbtail, m);
+		printf("packet tree:\n");
+		for (m = sb->sb_mb; m != NULL; m = m->m_nextpkt) {
+			printf("\t");
+			for (n = m; n != NULL; n = n->m_next)
+				printf("%p ", n);
+			printf("\n");
+		}
+		panic("sblastmbufchk from %s", where);
+	}
+}
+
 /*
- * As above, except the mbuf chain
- * begins a new record.
+ * Similar to sbappend, except the mbuf chain begins a new record.
  */
 int
-sbappendrecord(sb, m0)
-	register struct sockbuf *sb;
-	struct mbuf *m0;
+sbappendrecord(struct sockbuf *sb, struct mbuf *m0)
 {
-	register struct mbuf *m;
-	int result = 0;
+	struct mbuf *m;
+	int space = 0;
 
-	if (m0 == 0)
-		return 0;
-    
-	if ((sb->sb_flags & SB_RECV) != 0) {
-		int error = sflt_data_in(sb->sb_so, NULL, &m0, NULL, sock_data_filt_flag_record, NULL);
+	if (m0 == NULL || (sb->sb_flags & SB_DROP)) {
+		if (m0 != NULL)
+			m_freem(m0);
+		return (0);
+	}
+
+	for (m = m0; m != NULL; m = m->m_next)
+		space += m->m_len;
+
+	if (space > sbspace(sb) && !(sb->sb_flags & SB_UNIX)) {
+		m_freem(m0);
+		return (0);
+	}
+
+	if (sb->sb_flags & SB_RECV) {
+		int error = sflt_data_in(sb->sb_so, NULL, &m0, NULL,
+		    sock_data_filt_flag_record, NULL);
 		if (error != 0) {
+			SBLASTRECORDCHK(sb, "sbappendrecord 1");
 			if (error != EJUSTRETURN)
 				m_freem(m0);
-			return 0;
+			return (0);
 		}
 	}
-    
-	m = sb->sb_mb;
-	if (m)
-		while (m->m_nextpkt)
-			m = m->m_nextpkt;
+
 	/*
-	 * Put the first mbuf on the queue.
 	 * Note this permits zero length records.
 	 */
 	sballoc(sb, m0);
-	if (m)
-		m->m_nextpkt = m0;
-	else
+	SBLASTRECORDCHK(sb, "sbappendrecord 2");
+	if (sb->sb_lastrecord != NULL) {
+		sb->sb_lastrecord->m_nextpkt = m0;
+	}  else {
 		sb->sb_mb = m0;
+	}
+	sb->sb_lastrecord = m0;
+	sb->sb_mbtail = m0;
+
 	m = m0->m_next;
 	m0->m_next = 0;
 	if (m && (m0->m_flags & M_EOR)) {
 		m0->m_flags &= ~M_EOR;
 		m->m_flags |= M_EOR;
 	}
-	return sbcompress(sb, m, m0);
+	sbcompress(sb, m, m0);
+	SBLASTRECORDCHK(sb, "sbappendrecord 3");
+	return (1);
 }
 
 /*
@@ -788,31 +862,32 @@ sbappendrecord(sb, m0)
  * but after any other OOB data.
  */
 int
-sbinsertoob(sb, m0)
-	struct sockbuf *sb;
-	struct mbuf *m0;
+sbinsertoob(struct sockbuf *sb, struct mbuf *m0)
 {
 	struct mbuf *m;
 	struct mbuf **mp;
 
 	if (m0 == 0)
-		return 0;
-	
+		return (0);
+
+	SBLASTRECORDCHK(sb, "sbinsertoob 1");
+
 	if ((sb->sb_flags & SB_RECV) != 0) {
 		int error = sflt_data_in(sb->sb_so, NULL, &m0, NULL,
-								 sock_data_filt_flag_oob, NULL);
-		
+		    sock_data_filt_flag_oob, NULL);
+
+		SBLASTRECORDCHK(sb, "sbinsertoob 2");
 		if (error) {
 			if (error != EJUSTRETURN) {
 				m_freem(m0);
 			}
-			return 0;
+			return (0);
 		}
 	}
-    
-	for (mp = &sb->sb_mb; *mp ; mp = &((*mp)->m_nextpkt)) {
-	    m = *mp;
-	    again:
+
+	for (mp = &sb->sb_mb; *mp; mp = &((*mp)->m_nextpkt)) {
+		m = *mp;
+again:
 		switch (m->m_type) {
 
 		case MT_OOBDATA:
@@ -831,6 +906,10 @@ sbinsertoob(sb, m0)
 	 */
 	sballoc(sb, m0);
 	m0->m_nextpkt = *mp;
+	if (*mp == NULL) {
+		/* m0 is actually the new tail */
+		sb->sb_lastrecord = m0;
+	}
 	*mp = m0;
 	m = m0->m_next;
 	m0->m_next = 0;
@@ -838,7 +917,9 @@ sbinsertoob(sb, m0)
 		m0->m_flags &= ~M_EOR;
 		m->m_flags |= M_EOR;
 	}
-	return sbcompress(sb, m, m0);
+	sbcompress(sb, m, m0);
+	SBLASTRECORDCHK(sb, "sbinsertoob 3");
+	return (1);
 }
 
 /*
@@ -846,14 +927,15 @@ sbinsertoob(sb, m0)
  * to the receive queue of a socket.  If present,
  * m0 must include a packet header with total length.
  * Returns 0 if no space in sockbuf or insufficient mbufs.
+ *
+ * Returns:	0			No space/out of mbufs
+ *		1			Success
  */
 static int
-sbappendaddr_internal(sb, asa, m0, control)
-	register struct sockbuf *sb;
-	struct sockaddr *asa;
-	struct mbuf *m0, *control;
+sbappendaddr_internal(struct sockbuf *sb, struct sockaddr *asa,
+    struct mbuf *m0, struct mbuf *control)
 {
-	register struct mbuf *m, *n;
+	struct mbuf *m, *n, *nlast;
 	int space = asa->sa_len;
 
 	if (m0 && (m0->m_flags & M_PKTHDR) == 0)
@@ -880,64 +962,96 @@ sbappendaddr_internal(sb, asa, m0, control)
 	else
 		control = m0;
 	m->m_next = control;
-	for (n = m; n; n = n->m_next)
+
+	SBLASTRECORDCHK(sb, "sbappendadddr 1");
+
+	for (n = m; n->m_next != NULL; n = n->m_next)
 		sballoc(sb, n);
-	n = sb->sb_mb;
-	if (n) {
-		while (n->m_nextpkt)
-			n = n->m_nextpkt;
-		n->m_nextpkt = m;
-	} else
+	sballoc(sb, n);
+	nlast = n;
+
+	if (sb->sb_lastrecord != NULL) {
+		sb->sb_lastrecord->m_nextpkt = m;
+	} else {
 		sb->sb_mb = m;
-	postevent(0,sb,EV_RWBYTES);
+	}
+	sb->sb_lastrecord = m;
+	sb->sb_mbtail = nlast;
+
+	SBLASTMBUFCHK(sb, __func__);
+	SBLASTRECORDCHK(sb, "sbappendadddr 2");
+
+	postevent(0, sb, EV_RWBYTES);
 	return (1);
 }
 
+/*
+ * Returns:	0			Error: No space/out of mbufs/etc.
+ *		1			Success
+ *
+ * Imputed:	(*error_out)		errno for error
+ *		ENOBUFS
+ *	sflt_data_in:???		[whatever a filter author chooses]
+ */
 int
-sbappendaddr(
-	struct sockbuf* sb,
-	struct sockaddr* asa,
-	struct mbuf *m0,
-	struct mbuf *control,
-	int	*error_out)
+sbappendaddr(struct sockbuf *sb, struct sockaddr *asa, struct mbuf *m0,
+    struct mbuf *control, int *error_out)
 {
 	int result = 0;
-	
-	if (error_out) *error_out = 0;
-	
+	boolean_t sb_unix = (sb->sb_flags & SB_UNIX);
+
+	if (error_out)
+		*error_out = 0;
+
 	if (m0 && (m0->m_flags & M_PKTHDR) == 0)
 		panic("sbappendaddrorfree");
-	
+
+	if (sb->sb_flags & SB_DROP) {
+		if (m0 != NULL)
+			m_freem(m0);
+		if (control != NULL && !sb_unix)
+			m_freem(control);
+		if (error_out != NULL)
+			*error_out = EINVAL;
+		return (0);
+	}
+
 	/* Call socket data in filters */
 	if ((sb->sb_flags & SB_RECV) != 0) {
 		int error;
 		error = sflt_data_in(sb->sb_so, asa, &m0, &control, 0, NULL);
+		SBLASTRECORDCHK(sb, __func__);
 		if (error) {
 			if (error != EJUSTRETURN) {
-				if (m0) m_freem(m0);
-				if (control) m_freem(control);
-				if (error_out) *error_out = error;
+				if (m0)
+					m_freem(m0);
+				if (control != NULL && !sb_unix)
+					m_freem(control);
+				if (error_out)
+					*error_out = error;
 			}
-			return 0;
+			return (0);
 		}
 	}
-	
+
 	result = sbappendaddr_internal(sb, asa, m0, control);
 	if (result == 0) {
-		if (m0) m_freem(m0);
-		if (control) m_freem(control);
-		if (error_out) *error_out = ENOBUFS;
+		if (m0)
+			m_freem(m0);
+		if (control != NULL && !sb_unix)
+			m_freem(control);
+		if (error_out)
+			*error_out = ENOBUFS;
 	}
-	
-	return result;
+
+	return (result);
 }
 
 static int
-sbappendcontrol_internal(sb, m0, control)
-	struct sockbuf *sb;
-	struct mbuf *control, *m0;
+sbappendcontrol_internal(struct sockbuf *sb, struct mbuf *m0,
+    struct mbuf *control)
 {
-	register struct mbuf *m, *n;
+	struct mbuf *m, *mlast, *n;
 	int space = 0;
 
 	if (control == 0)
@@ -951,54 +1065,81 @@ sbappendcontrol_internal(sb, m0, control)
 	n = m;			/* save pointer to last control buffer */
 	for (m = m0; m; m = m->m_next)
 		space += m->m_len;
-	if (space > sbspace(sb))
+	if (space > sbspace(sb) && !(sb->sb_flags & SB_UNIX))
 		return (0);
 	n->m_next = m0;			/* concatenate data to control */
-	for (m = control; m; m = m->m_next)
+
+	SBLASTRECORDCHK(sb, "sbappendcontrol 1");
+
+	for (m = control; m->m_next != NULL; m = m->m_next)
 		sballoc(sb, m);
-	n = sb->sb_mb;
-	if (n) {
-		while (n->m_nextpkt)
-			n = n->m_nextpkt;
-		n->m_nextpkt = control;
-	} else
+	sballoc(sb, m);
+	mlast = m;
+
+	if (sb->sb_lastrecord != NULL) {
+		sb->sb_lastrecord->m_nextpkt = control;
+	} else {
 		sb->sb_mb = control;
-	postevent(0,sb,EV_RWBYTES);
+	}
+	sb->sb_lastrecord = control;
+	sb->sb_mbtail = mlast;
+
+	SBLASTMBUFCHK(sb, __func__);
+	SBLASTRECORDCHK(sb, "sbappendcontrol 2");
+
+	postevent(0, sb, EV_RWBYTES);
 	return (1);
 }
 
 int
-sbappendcontrol(
-	struct sockbuf	*sb,
-	struct mbuf		*m0,
-	struct mbuf		*control,
-	int				*error_out)
+sbappendcontrol(struct sockbuf *sb, struct mbuf	*m0, struct mbuf *control,
+    int *error_out)
 {
 	int result = 0;
-	
-	if (error_out) *error_out = 0;
-	
+	boolean_t sb_unix = (sb->sb_flags & SB_UNIX);
+
+	if (error_out)
+		*error_out = 0;
+
+	if (sb->sb_flags & SB_DROP) {
+		if (m0 != NULL)
+			m_freem(m0);
+		if (control != NULL && !sb_unix)
+			m_freem(control);
+		if (error_out != NULL)
+			*error_out = EINVAL;
+		return (0);
+	}
+
 	if (sb->sb_flags & SB_RECV) {
 		int error;
+
 		error = sflt_data_in(sb->sb_so, NULL, &m0, &control, 0, NULL);
+		SBLASTRECORDCHK(sb, __func__);
 		if (error) {
 			if (error != EJUSTRETURN) {
-				if (m0) m_freem(m0);
-				if (control) m_freem(control);
-				if (error_out) *error_out = error;
+				if (m0)
+					m_freem(m0);
+				if (control != NULL && !sb_unix)
+					m_freem(control);
+				if (error_out)
+					*error_out = error;
 			}
-			return 0;
+			return (0);
 		}
 	}
-	
+
 	result = sbappendcontrol_internal(sb, m0, control);
 	if (result == 0) {
-		if (m0) m_freem(m0);
-		if (control) m_freem(control);
-		if (error_out) *error_out = ENOBUFS;
+		if (m0)
+			m_freem(m0);
+		if (control != NULL && !sb_unix)
+			m_freem(control);
+		if (error_out)
+			*error_out = ENOBUFS;
 	}
-	
-	return result;
+
+	return (result);
 }
 
 /*
@@ -1006,20 +1147,26 @@ sbappendcontrol(
  * buffer sb following mbuf n.  If n
  * is null, the buffer is presumed empty.
  */
-static int
-sbcompress(sb, m, n)
-	register struct sockbuf *sb;
-	register struct mbuf *m, *n;
-{
-	register int eor = 0;
-	register struct mbuf *o;
+static inline void
+sbcompress(struct sockbuf *sb, struct mbuf *m, struct mbuf *n)
+{
+	int eor = 0;
+	struct mbuf *o;
+
+	if (m == NULL) {
+		/* There is nothing to compress; just update the tail */
+		for (; n->m_next != NULL; n = n->m_next)
+			;
+		sb->sb_mbtail = n;
+		goto done;
+	}
 
 	while (m) {
 		eor |= m->m_flags & M_EOR;
-		if (m->m_len == 0 &&
-		    (eor == 0 ||
-		     (((o = m->m_next) || (o = n)) &&
-		      o->m_type == m->m_type))) {
+		if (m->m_len == 0 && (eor == 0 ||
+		    (((o = m->m_next) || (o = n)) && o->m_type == m->m_type))) {
+			if (sb->sb_lastrecord == m)
+				sb->sb_lastrecord = m->m_next;
 			m = m_free(m);
 			continue;
 		}
@@ -1034,6 +1181,10 @@ sbcompress(sb, m, n)
 			    (unsigned)m->m_len);
 			n->m_len += m->m_len;
 			sb->sb_cc += m->m_len;
+			if (m->m_type != MT_DATA && m->m_type != MT_HEADER &&
+				m->m_type != MT_OOBDATA)
+				/* XXX: Probably don't need.*/
+				sb->sb_ctl += m->m_len;
 			m = m_free(m);
 			continue;
 		}
@@ -1041,6 +1192,7 @@ sbcompress(sb, m, n)
 			n->m_next = m;
 		else
 			sb->sb_mb = m;
+		sb->sb_mbtail = m;
 		sballoc(sb, m);
 		n = m;
 		m->m_flags &= ~M_EOR;
@@ -1053,8 +1205,21 @@ sbcompress(sb, m, n)
 		else
 			printf("semi-panic: sbcompress\n");
 	}
-	postevent(0,sb, EV_RWBYTES);
-	return 1;
+done:
+	SBLASTMBUFCHK(sb, __func__);
+	postevent(0, sb, EV_RWBYTES);
+}
+
+void
+sb_empty_assert(struct sockbuf *sb, const char *where)
+{
+	if (!(sb->sb_cc == 0 && sb->sb_mb == NULL && sb->sb_mbcnt == 0 &&
+	    sb->sb_mbtail == NULL && sb->sb_lastrecord == NULL)) {
+		panic("%s: sb %p so %p cc %ld mbcnt %ld mb %p mbtail %p "
+		    "lastrecord %p\n", where, sb, sb->sb_so, sb->sb_cc,
+		    sb->sb_mbcnt, sb->sb_mb, sb->sb_mbtail, sb->sb_lastrecord);
+		/* NOTREACHED */
+	}
 }
 
 /*
@@ -1062,12 +1227,11 @@ sbcompress(sb, m, n)
  * Check that all resources are reclaimed.
  */
 void
-sbflush(sb)
-	register struct sockbuf *sb;
+sbflush(struct sockbuf *sb)
 {
 	if (sb->sb_so == NULL)
-		panic ("sbflush sb->sb_so already null sb=%x\n", sb);
-	(void)sblock(sb, M_WAIT);
+		panic("sbflush sb->sb_so already null sb=%p\n", sb);
+	(void) sblock(sb, M_WAIT);
 	while (sb->sb_mbcnt) {
 		/*
 		 * Don't call sbdrop(sb, 0) if the leading mbuf is non-empty:
@@ -1077,9 +1241,7 @@ sbflush(sb)
 			break;
 		sbdrop(sb, (int)sb->sb_cc);
 	}
-	if (sb->sb_cc || sb->sb_mb || sb->sb_mbcnt || sb->sb_so == NULL)
-		panic("sbflush: cc %ld || mb %p || mbcnt %ld sb_so=%x", sb->sb_cc, (void *)sb->sb_mb, sb->sb_mbcnt, sb->sb_so);
-
+	sb_empty_assert(sb, __func__);
 	postevent(0, sb, EV_RWBYTES);
 	sbunlock(sb, 1);	/* keep socket locked */
 
@@ -1097,11 +1259,9 @@ sbflush(sb)
  * m_freem_list.
  */
 void
-sbdrop(sb, len)
-	register struct sockbuf *sb;
-	register int len;
+sbdrop(struct sockbuf *sb, int len)
 {
-	register struct mbuf *m, *free_list, *ml;
+	struct mbuf *m, *free_list, *ml;
 	struct mbuf *next, *last;
 
 	KERNEL_DEBUG((DBG_FNC_SBDROP | DBG_FUNC_START), sb, len, 0, 0, 0);
@@ -1112,28 +1272,36 @@ sbdrop(sb, len)
 
 	while (len > 0) {
 		if (m == 0) {
-		  if (next == 0) {
-		    /* temporarily replacing this panic with printf because
-		     * it occurs occasionally when closing a socket when there
-		     * is no harm in ignoring it.  This problem will be investigated
-		     * further.
-		     */
-		    /* panic("sbdrop"); */
-		    printf("sbdrop - count not zero\n");
-		    len = 0;
-		    /* zero the counts. if we have no mbufs, we have no data (PR-2986815) */
-		    sb->sb_cc = 0;
-		    sb->sb_mbcnt = 0;
-		    break;
-		  }
-		  m = last = next;
-		  next = m->m_nextpkt;
-		  continue;
+			if (next == 0) {
+				/*
+				 * temporarily replacing this panic with printf
+				 * because it occurs occasionally when closing
+				 * a socket when there is no harm in ignoring
+				 * it. This problem will be investigated
+				 * further.
+				 */
+				/* panic("sbdrop"); */
+				printf("sbdrop - count not zero\n");
+				len = 0;
+				/*
+				 * zero the counts. if we have no mbufs,
+				 * we have no data (PR-2986815)
+				 */
+				sb->sb_cc = 0;
+				sb->sb_mbcnt = 0;
+				break;
+			}
+			m = last = next;
+			next = m->m_nextpkt;
+			continue;
 		}
 		if (m->m_len > len) {
 			m->m_len -= len;
 			m->m_data += len;
 			sb->sb_cc -= len;
+			if (m->m_type != MT_DATA && m->m_type != MT_HEADER &&
+				m->m_type != MT_OOBDATA)
+				sb->sb_ctl -= len;
 			break;
 		}
 		len -= m->m_len;
@@ -1149,15 +1317,29 @@ sbdrop(sb, len)
 		m = m->m_next;
 	}
 	if (ml) {
-	        ml->m_next = (struct mbuf *)0;
+		ml->m_next = (struct mbuf *)0;
 		last->m_nextpkt = (struct mbuf *)0;
-	        m_freem_list(free_list);
+		m_freem_list(free_list);
 	}
 	if (m) {
 		sb->sb_mb = m;
 		m->m_nextpkt = next;
-	} else
+	} else {
 		sb->sb_mb = next;
+	}
+
+	/*
+	 * First part is an inline SB_EMPTY_FIXUP().  Second part
+	 * makes sure sb_lastrecord is up-to-date if we dropped
+	 * part of the last record.
+	 */
+	m = sb->sb_mb;
+	if (m == NULL) {
+		sb->sb_mbtail = NULL;
+		sb->sb_lastrecord = NULL;
+	} else if (m->m_nextpkt == NULL) {
+		sb->sb_lastrecord = m;
+	}
 
 	postevent(0, sb, EV_RWBYTES);
 
@@ -1169,10 +1351,9 @@ sbdrop(sb, len)
  * and move the next record to the front.
  */
 void
-sbdroprecord(sb)
-	register struct sockbuf *sb;
+sbdroprecord(struct sockbuf *sb)
 {
-	register struct mbuf *m, *mn;
+	struct mbuf *m, *mn;
 
 	m = sb->sb_mb;
 	if (m) {
@@ -1183,6 +1364,7 @@ sbdroprecord(sb)
 			m = mn;
 		} while (m);
 	}
+	SB_EMPTY_FIXUP(sb);
 	postevent(0, sb, EV_RWBYTES);
 }
 
@@ -1191,21 +1373,18 @@ sbdroprecord(sb)
  * with the specified type for presentation on a socket buffer.
  */
 struct mbuf *
-sbcreatecontrol(p, size, type, level)
-	caddr_t p;
-	register int size;
-	int type, level;
+sbcreatecontrol(caddr_t p, int size, int type, int level)
 {
-	register struct cmsghdr *cp;
+	struct cmsghdr *cp;
 	struct mbuf *m;
 
 	if (CMSG_SPACE((u_int)size) > MLEN)
-		return ((struct mbuf *) NULL);
+		return ((struct mbuf *)NULL);
 	if ((m = m_get(M_DONTWAIT, MT_CONTROL)) == NULL)
-		return ((struct mbuf *) NULL);
+		return ((struct mbuf *)NULL);
 	cp = mtod(m, struct cmsghdr *);
 	/* XXX check size? */
-	(void)memcpy(CMSG_DATA(cp), p, size);
+	(void) memcpy(CMSG_DATA(cp), p, size);
 	m->m_len = CMSG_SPACE(size);
 	cp->cmsg_len = CMSG_LEN(size);
 	cp->cmsg_level = level;
@@ -1218,92 +1397,95 @@ sbcreatecontrol(p, size, type, level)
  * supported by a protocol.  Fill in as needed.
  */
 int
-pru_abort_notsupp(struct socket *so)
+pru_abort_notsupp(__unused struct socket *so)
 {
-	return EOPNOTSUPP;
+	return (EOPNOTSUPP);
 }
 
-
 int
-pru_accept_notsupp(struct socket *so, struct sockaddr **nam)
+pru_accept_notsupp(__unused struct socket *so, __unused struct sockaddr **nam)
 {
-	return EOPNOTSUPP;
+	return (EOPNOTSUPP);
 }
 
 int
-pru_attach_notsupp(struct socket *so, int proto, struct proc *p)
+pru_attach_notsupp(__unused struct socket *so, __unused int proto,
+    __unused struct proc *p)
 {
-	return EOPNOTSUPP;
+	return (EOPNOTSUPP);
 }
 
 int
-pru_bind_notsupp(struct socket *so, struct sockaddr *nam, struct proc *p)
+pru_bind_notsupp(__unused struct socket *so, __unused struct sockaddr *nam,
+    __unused struct proc *p)
 {
-	return EOPNOTSUPP;
+	return (EOPNOTSUPP);
 }
 
 int
-pru_connect_notsupp(struct socket *so, struct sockaddr *nam, struct proc *p)
+pru_connect_notsupp(__unused struct socket *so, __unused struct sockaddr *nam,
+    __unused struct proc *p)
 {
-	return EOPNOTSUPP;
+	return (EOPNOTSUPP);
 }
 
 int
-pru_connect2_notsupp(struct socket *so1, struct socket *so2)
+pru_connect2_notsupp(__unused struct socket *so1, __unused struct socket *so2)
 {
-	return EOPNOTSUPP;
+	return (EOPNOTSUPP);
 }
 
 int
-pru_control_notsupp(struct socket *so, u_long cmd, caddr_t data,
-		    struct ifnet *ifp, struct proc *p)
+pru_control_notsupp(__unused struct socket *so, __unused u_long cmd,
+    __unused caddr_t data, __unused struct ifnet *ifp, __unused struct proc *p)
 {
-	return EOPNOTSUPP;
+	return (EOPNOTSUPP);
 }
 
 int
-pru_detach_notsupp(struct socket *so)
+pru_detach_notsupp(__unused struct socket *so)
 {
-	return EOPNOTSUPP;
+	return (EOPNOTSUPP);
 }
 
 int
-pru_disconnect_notsupp(struct socket *so)
+pru_disconnect_notsupp(__unused struct socket *so)
 {
-	return EOPNOTSUPP;
+	return (EOPNOTSUPP);
 }
 
 int
-pru_listen_notsupp(struct socket *so, struct proc *p)
+pru_listen_notsupp(__unused struct socket *so, __unused struct proc *p)
 {
-	return EOPNOTSUPP;
+	return (EOPNOTSUPP);
 }
 
 int
-pru_peeraddr_notsupp(struct socket *so, struct sockaddr **nam)
+pru_peeraddr_notsupp(__unused struct socket *so, __unused struct sockaddr **nam)
 {
-	return EOPNOTSUPP;
+	return (EOPNOTSUPP);
 }
 
 int
-pru_rcvd_notsupp(struct socket *so, int flags)
+pru_rcvd_notsupp(__unused struct socket *so, __unused int flags)
 {
-	return EOPNOTSUPP;
+	return (EOPNOTSUPP);
 }
 
 int
-pru_rcvoob_notsupp(struct socket *so, struct mbuf *m, int flags)
+pru_rcvoob_notsupp(__unused struct socket *so, __unused struct mbuf *m,
+    __unused int flags)
 {
-	return EOPNOTSUPP;
+	return (EOPNOTSUPP);
 }
 
 int
-pru_send_notsupp(struct socket *so, int flags, struct mbuf *m,
-		 struct sockaddr *addr, struct mbuf *control,
-		 struct proc *p)
+pru_send_notsupp(__unused struct socket *so, __unused int flags,
+    __unused struct mbuf *m, __unused struct sockaddr *addr,
+    __unused struct mbuf *control, __unused struct proc *p)
 
 {
-	return EOPNOTSUPP;
+	return (EOPNOTSUPP);
 }
 
 
@@ -1312,63 +1494,59 @@ pru_send_notsupp(struct socket *so, int flags, struct mbuf *m,
  * and doesn't do anything destructive.
  */
 int
-pru_sense_null(struct socket *so, struct stat *sb)
+pru_sense_null(struct socket *so, void *ub, int isstat64)
 {
-	sb->st_blksize = so->so_snd.sb_hiwat;
-	return 0;
-}
+	if (isstat64 != 0) {
+		struct stat64 *sb64;
 
+		sb64 = (struct stat64 *)ub;
+		sb64->st_blksize = so->so_snd.sb_hiwat;
+	} else {
+		struct stat *sb;
 
-int	pru_sosend_notsupp(struct socket *so, struct sockaddr *addr,
-		   struct uio *uio, struct mbuf *top,
-		   struct mbuf *control, int flags)
+		sb = (struct stat *)ub;
+		sb->st_blksize = so->so_snd.sb_hiwat;
+	}
 
-{
-    return EOPNOTSUPP;
+	return (0);
 }
 
-int	pru_soreceive_notsupp(struct socket *so, 
-		      struct sockaddr **paddr,
-		      struct uio *uio, struct mbuf **mp0,
-		      struct mbuf **controlp, int *flagsp)
-{
-    return EOPNOTSUPP;
-}
 
 int
+pru_sosend_notsupp(__unused struct socket *so, __unused struct sockaddr *addr,
+    __unused struct uio *uio, __unused struct mbuf *top,
+    __unused struct mbuf *control, __unused int flags)
 
-pru_shutdown_notsupp(struct socket *so)
 {
-	return EOPNOTSUPP;
+	return (EOPNOTSUPP);
 }
 
 int
-pru_sockaddr_notsupp(struct socket *so, struct sockaddr **nam)
+pru_soreceive_notsupp(__unused struct socket *so,
+    __unused struct sockaddr **paddr,
+    __unused struct uio *uio, __unused struct mbuf **mp0,
+    __unused struct mbuf **controlp, __unused int *flagsp)
 {
-	return EOPNOTSUPP;
+	return (EOPNOTSUPP);
 }
 
-int     pru_sosend(struct socket *so, struct sockaddr *addr,
-		   struct uio *uio, struct mbuf *top,
-		   struct mbuf *control, int flags)
+int
+pru_shutdown_notsupp(__unused struct socket *so)
 {
-	return EOPNOTSUPP;
+	return (EOPNOTSUPP);
 }
 
-int     pru_soreceive(struct socket *so,
-		      struct sockaddr **paddr,
-		      struct uio *uio, struct mbuf **mp0,
-		      struct mbuf **controlp, int *flagsp)
+int
+pru_sockaddr_notsupp(__unused struct socket *so, __unused struct sockaddr **nam)
 {
-	return EOPNOTSUPP;
+	return (EOPNOTSUPP);
 }
 
-
 int
 pru_sopoll_notsupp(__unused struct socket *so, __unused int events,
-		   __unused kauth_cred_t cred, __unused void *wql)
+    __unused kauth_cred_t cred, __unused void *wql)
 {
-    return EOPNOTSUPP;
+	return (EOPNOTSUPP);
 }
 
 
@@ -1381,10 +1559,11 @@ pru_sopoll_notsupp(__unused struct socket *so, __unused int events,
  * Do we need to notify the other side when I/O is possible?
  */
 
-int 
+int
 sb_notify(struct sockbuf *sb)
 {
-	return ((sb->sb_flags & (SB_WAIT|SB_SEL|SB_ASYNC|SB_UPCALL|SB_KNOTE)) != 0); 
+	return ((sb->sb_flags &
+	    (SB_WAIT|SB_SEL|SB_ASYNC|SB_UPCALL|SB_KNOTE)) != 0);
 }
 
 /*
@@ -1396,24 +1575,24 @@ sb_notify(struct sockbuf *sb)
 long
 sbspace(struct sockbuf *sb)
 {
-    return ((long) imin((int)(sb->sb_hiwat - sb->sb_cc), 
-	 (int)(sb->sb_mbmax - sb->sb_mbcnt)));
+	return ((long)imin((int)(sb->sb_hiwat - sb->sb_cc),
+	    (int)(sb->sb_mbmax - sb->sb_mbcnt)));
 }
 
 /* do we have to send all at once on a socket? */
 int
 sosendallatonce(struct socket *so)
 {
-    return (so->so_proto->pr_flags & PR_ATOMIC);
+	return (so->so_proto->pr_flags & PR_ATOMIC);
 }
 
 /* can we read something from so? */
 int
 soreadable(struct socket *so)
 {
-    return (so->so_rcv.sb_cc >= so->so_rcv.sb_lowat || 
-	(so->so_state & SS_CANTRCVMORE) || 
-	so->so_comp.tqh_first || so->so_error);
+	return (so->so_rcv.sb_cc >= so->so_rcv.sb_lowat ||
+	    (so->so_state & SS_CANTRCVMORE) ||
+	    so->so_comp.tqh_first || so->so_error);
 }
 
 /* can we write something to so? */
@@ -1421,11 +1600,11 @@ soreadable(struct socket *so)
 int
 sowriteable(struct socket *so)
 {
-    return ((sbspace(&(so)->so_snd) >= (so)->so_snd.sb_lowat && 
-	((so->so_state&SS_ISCONNECTED) || 
-	  (so->so_proto->pr_flags&PR_CONNREQUIRED)==0)) || 
-     (so->so_state & SS_CANTSENDMORE) || 
-     so->so_error);
+	return ((sbspace(&(so)->so_snd) >= (long)(so)->so_snd.sb_lowat &&
+	    ((so->so_state&SS_ISCONNECTED) ||
+	    (so->so_proto->pr_flags&PR_CONNREQUIRED) == 0)) ||
+	    (so->so_state & SS_CANTSENDMORE) ||
+	    so->so_error);
 }
 
 /* adjust counters in sb reflecting allocation of m */
@@ -1433,33 +1612,57 @@ sowriteable(struct socket *so)
 void
 sballoc(struct sockbuf *sb, struct mbuf *m)
 {
+	int cnt = 1;
 	sb->sb_cc += m->m_len; 
+	if (m->m_type != MT_DATA && m->m_type != MT_HEADER && 
+		m->m_type != MT_OOBDATA)
+		sb->sb_ctl += m->m_len;
 	sb->sb_mbcnt += MSIZE; 
-	if (m->m_flags & M_EXT) 
+	
+	if (m->m_flags & M_EXT) {
 		sb->sb_mbcnt += m->m_ext.ext_size; 
+		cnt += m->m_ext.ext_size / MSIZE ;
+	}
+	OSAddAtomic(cnt, (SInt32*)&total_mb_cnt);
 }
 
 /* adjust counters in sb reflecting freeing of m */
 void
 sbfree(struct sockbuf *sb, struct mbuf *m)
 {
-	sb->sb_cc -= m->m_len; 
+	int cnt = -1;
+	sb->sb_cc -= m->m_len;
+	if (m->m_type != MT_DATA && m->m_type != MT_HEADER &&     
+		m->m_type != MT_OOBDATA)
+		sb->sb_ctl -= m->m_len;
 	sb->sb_mbcnt -= MSIZE; 
-	if (m->m_flags & M_EXT) 
+	if (m->m_flags & M_EXT) {
 		sb->sb_mbcnt -= m->m_ext.ext_size; 
+		cnt -= m->m_ext.ext_size / MSIZE ;
+	}
+	OSAddAtomic(cnt, (SInt32*)&total_mb_cnt);
 }
 
 /*
  * Set lock on sockbuf sb; sleep if lock is already held.
  * Unless SB_NOINTR is set on sockbuf, sleep is interruptible.
  * Returns error without lock if sleep is interrupted.
+ *
+ * Returns:	0			Success
+ *		EWOULDBLOCK
+ *	sb_lock:EINTR
  */
 int
 sblock(struct sockbuf *sb, int wf)
 {
-	return(sb->sb_flags & SB_LOCK ? 
-		((wf == M_WAIT) ? sb_lock(sb) : EWOULDBLOCK) : 
-		(sb->sb_flags |= SB_LOCK), 0);
+	int error = 0;
+
+	if (sb->sb_flags & SB_LOCK)
+		error = (wf == M_WAIT) ? sb_lock(sb) : EWOULDBLOCK;
+	else
+		sb->sb_flags |= SB_LOCK;
+
+	return (error);
 }
 
 /* release lock on sockbuf sb */
@@ -1470,66 +1673,66 @@ sbunlock(struct sockbuf *sb, int keeplocked)
 	int lr_saved;
 	lck_mtx_t *mutex_held;
 
-
 	lr_saved = (unsigned int) __builtin_return_address(0);
 
-	sb->sb_flags &= ~SB_LOCK; 
+	sb->sb_flags &= ~SB_LOCK;
 
-	if (so->so_proto->pr_getlock != NULL) 
-		mutex_held = (*so->so_proto->pr_getlock)(so, 0);
-	else 
-		mutex_held = so->so_proto->pr_domain->dom_mtx;
-
-	if (keeplocked == 0)
-		lck_mtx_assert(mutex_held, LCK_MTX_ASSERT_OWNED);
-
-	if (sb->sb_flags & SB_WANT) { 
-		sb->sb_flags &= ~SB_WANT; 
+	if (sb->sb_flags & SB_WANT) {
+		sb->sb_flags &= ~SB_WANT;
 		if (so->so_usecount < 0)
-			panic("sbunlock: b4 wakeup so=%x ref=%d lr=%x sb_flags=%x\n", sb->sb_so, so->so_usecount, lr_saved, sb->sb_flags);
+			panic("sbunlock: b4 wakeup so=%p ref=%d lr=%x "
+			    "sb_flags=%x\n", sb->sb_so, so->so_usecount,
+			    lr_saved, sb->sb_flags);
 
-		wakeup((caddr_t)&(sb)->sb_flags); 
-	} 
+		wakeup((caddr_t)&(sb)->sb_flags);
+	}
 	if (keeplocked == 0) {	/* unlock on exit */
+		if (so->so_proto->pr_getlock != NULL) 
+			mutex_held = (*so->so_proto->pr_getlock)(so, 0);
+		else 
+			mutex_held = so->so_proto->pr_domain->dom_mtx;
+	
+		lck_mtx_assert(mutex_held, LCK_MTX_ASSERT_OWNED);
+
 		so->so_usecount--;
 		if (so->so_usecount < 0)
-			panic("sbunlock: unlock on exit so=%x lr=%x sb_flags=%x\n", so, so->so_usecount,lr_saved, sb->sb_flags);
-		so->unlock_lr[so->next_unlock_lr] = (void *)lr_saved;
+			panic("sbunlock: unlock on exit so=%p ref=%d lr=%x "
+			    "sb_flags=%x\n", so, so->so_usecount, lr_saved,
+			    sb->sb_flags);
+		so->unlock_lr[so->next_unlock_lr] = (u_int32_t)lr_saved;
 		so->next_unlock_lr = (so->next_unlock_lr+1) % SO_LCKDBG_MAX;
 		lck_mtx_unlock(mutex_held);
 	}
 }
 
 void
-sorwakeup(struct socket * so)
+sorwakeup(struct socket *so)
 {
-  if (sb_notify(&so->so_rcv)) 
-	sowakeup(so, &so->so_rcv); 
+	if (sb_notify(&so->so_rcv))
+		sowakeup(so, &so->so_rcv);
 }
 
 void
-sowwakeup(struct socket * so)
+sowwakeup(struct socket *so)
 {
-  if (sb_notify(&so->so_snd)) 
-	sowakeup(so, &so->so_snd); 
+	if (sb_notify(&so->so_snd))
+		sowakeup(so, &so->so_snd);
 }
-#endif __APPLE__
+#endif /* __APPLE__ */
 
 /*
  * Make a copy of a sockaddr in a malloced buffer of type M_SONAME.
  */
 struct sockaddr *
-dup_sockaddr(sa, canwait)
-	struct sockaddr *sa;
-	int canwait;
+dup_sockaddr(struct sockaddr *sa, int canwait)
 {
 	struct sockaddr *sa2;
 
-	MALLOC(sa2, struct sockaddr *, sa->sa_len, M_SONAME, 
-	       canwait ? M_WAITOK : M_NOWAIT);
+	MALLOC(sa2, struct sockaddr *, sa->sa_len, M_SONAME,
+	    canwait ? M_WAITOK : M_NOWAIT);
 	if (sa2)
 		bcopy(sa, sa2, sa->sa_len);
-	return sa2;
+	return (sa2);
 }
 
 /*
@@ -1543,7 +1746,7 @@ dup_sockaddr(sa, canwait)
 void
 sotoxsocket(struct socket *so, struct xsocket *xso)
 {
-	xso->xso_len = sizeof *xso;
+	xso->xso_len = sizeof (*xso);
 	xso->xso_so = so;
 	xso->so_type = so->so_type;
 	xso->so_options = so->so_options;
@@ -1553,9 +1756,9 @@ sotoxsocket(struct socket *so, struct xsocket *xso)
 	if (so->so_proto) {
 		xso->xso_protocol = so->so_proto->pr_protocol;
 		xso->xso_family = so->so_proto->pr_domain->dom_family;
-	}
-	else 
+	} else {
 		xso->xso_protocol = xso->xso_family = 0;
+	}
 	xso->so_qlen = so->so_qlen;
 	xso->so_incqlen = so->so_incqlen;
 	xso->so_qlimit = so->so_qlimit;
@@ -1583,7 +1786,8 @@ sbtoxsockbuf(struct sockbuf *sb, struct xsockbuf *xsb)
 	xsb->sb_mbmax = sb->sb_mbmax;
 	xsb->sb_lowat = sb->sb_lowat;
 	xsb->sb_flags = sb->sb_flags;
-	xsb->sb_timeo = (u_long)(sb->sb_timeo.tv_sec * hz) + sb->sb_timeo.tv_usec / tick;
+	xsb->sb_timeo = (u_long)
+	    (sb->sb_timeo.tv_sec * hz) + sb->sb_timeo.tv_usec / tick;
 	if (xsb->sb_timeo == 0 && sb->sb_timeo.tv_usec != 0)
 		xsb->sb_timeo = 1;
 }
@@ -1592,17 +1796,25 @@ sbtoxsockbuf(struct sockbuf *sb, struct xsockbuf *xsb)
  * Here is the definition of some of the basic objects in the kern.ipc
  * branch of the MIB.
  */
-SYSCTL_NODE(_kern, KERN_IPC, ipc, CTLFLAG_RW, 0, "IPC");
+SYSCTL_NODE(_kern, KERN_IPC, ipc, CTLFLAG_RW|CTLFLAG_LOCKED, 0, "IPC");
 
 /* This takes the place of kern.maxsockbuf, which moved to kern.ipc. */
 static int dummy;
 SYSCTL_INT(_kern, KERN_DUMMY, dummy, CTLFLAG_RW, &dummy, 0, "");
 
-SYSCTL_INT(_kern_ipc, KIPC_MAXSOCKBUF, maxsockbuf, CTLFLAG_RW, 
+SYSCTL_INT(_kern_ipc, KIPC_MAXSOCKBUF, maxsockbuf, CTLFLAG_RW,
     &sb_max, 0, "Maximum socket buffer size");
-SYSCTL_INT(_kern_ipc, OID_AUTO, maxsockets, CTLFLAG_RD, 
+SYSCTL_INT(_kern_ipc, OID_AUTO, maxsockets, CTLFLAG_RD,
     &maxsockets, 0, "Maximum number of sockets avaliable");
 SYSCTL_INT(_kern_ipc, KIPC_SOCKBUF_WASTE, sockbuf_waste_factor, CTLFLAG_RW,
-	   &sb_efficiency, 0, "");
-SYSCTL_INT(_kern_ipc, KIPC_NMBCLUSTERS, nmbclusters, CTLFLAG_RD, &nmbclusters, 0, "");
-
+    &sb_efficiency, 0, "");
+SYSCTL_INT(_kern_ipc, OID_AUTO, sbspace_factor, CTLFLAG_RW,
+    &sbspace_factor, 0, "Ratio of mbuf/cluster use for socket layers");
+SYSCTL_INT(_kern_ipc, KIPC_NMBCLUSTERS, nmbclusters, CTLFLAG_RD,
+    &nmbclusters, 0, "");
+SYSCTL_INT(_kern_ipc, OID_AUTO, njcl, CTLFLAG_RD, &njcl, 0, "");
+SYSCTL_INT(_kern_ipc, OID_AUTO, njclbytes, CTLFLAG_RD, &njclbytes, 0, "");
+SYSCTL_INT(_kern_ipc, KIPC_SOQLIMITCOMPAT, soqlimitcompat, CTLFLAG_RW,
+    &soqlimitcompat, 1, "Enable socket queue limit compatibility");
+SYSCTL_INT(_kern_ipc, OID_AUTO, soqlencomp, CTLFLAG_RW,
+    &soqlencomp, 0, "Listen backlog represents only complete queue");