xnu-517.7.7.tar.gz

[apple/xnu.git] / bsd / kern / uipc_socket2.c

diff --git a/bsd/kern/uipc_socket2.c b/bsd/kern/uipc_socket2.c
index 4026fe6773f4c75e2a16b27bb7d7127c25bb1bb2..175824a8aa4bb0399646f5a05f5d2af4817fc2c7 100644 (file)
--- a/bsd/kern/uipc_socket2.c
+++ b/bsd/kern/uipc_socket2.c
@@ -54,6 +54,7 @@
  * SUCH DAMAGE.
  *
  *     @(#)uipc_socket2.c      8.1 (Berkeley) 6/10/93
  * SUCH DAMAGE.
  *
  *     @(#)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 $

  */
 
 #include <sys/param.h>
  */
 
 #include <sys/param.h>


@@ -71,6 +72,12 @@
 #include <sys/sysctl.h>
 #include <sys/ev.h>
 
 #include <sys/sysctl.h>
 #include <sys/ev.h>
 

+#include <sys/kdebug.h>
+
+#define DBG_FNC_SBDROP NETDBG_CODE(DBG_NETSOCK, 4)
+#define DBG_FNC_SBAPPEND       NETDBG_CODE(DBG_NETSOCK, 5)
+
+

 /*
  * Primitive routines for operating on sockets and socket buffers
  */
 /*
  * Primitive routines for operating on sockets and socket buffers
  */


@@ -79,8 +86,6 @@ u_long        sb_max = SB_MAX;                /* XXX should be static */
 
 static u_long sb_efficiency = 8;       /* parameter for sbreserve() */
 
 
 static u_long sb_efficiency = 8;       /* parameter for sbreserve() */
 

-char netcon[] = "netcon";
-

 /*
  * Procedures to manipulate state flags of socket
  * and do appropriate wakeups.  Normal sequence from the
 /*
  * Procedures to manipulate state flags of socket
  * and do appropriate wakeups.  Normal sequence from the


@@ -88,7 +93,7 @@ char netcon[] = "netcon";
  * called during processing of connect() call,
  * resulting in an eventual call to soisconnected() if/when the
  * connection is established.  When the connection is torn down
  * called during processing of connect() call,
  * resulting in an eventual call to soisconnected() if/when the
  * connection is established.  When the connection is torn down

- * soisdisconnecting() is called during processing of disconnect() call,   
+ * soisdisconnecting() is called during processing of disconnect() call,

  * and soisdisconnected() is called when the connection to the peer
  * is totally severed.  The semantics of these routines are such that
  * connectionless protocols can call soisconnected() and soisdisconnected()
  * and soisdisconnected() is called when the connection to the peer
  * is totally severed.  The semantics of these routines are such that
  * connectionless protocols can call soisconnected() and soisdisconnected()


@@ -98,14 +103,14 @@ char netcon[] = "netcon";
  * From the passive side, a socket is created with
  * two queues of sockets: so_incomp for connections in progress
  * and so_comp for connections already made and awaiting user acceptance.
  * From the passive side, a socket is created with
  * two queues of sockets: so_incomp for connections in progress
  * and so_comp for connections already made and awaiting user acceptance.

- * As a protocol is preparing incoming connections, it creates a socket      
+ * As a protocol is preparing incoming connections, it creates a socket

  * structure queued on so_incomp by calling sonewconn().  When the connection
  * is established, soisconnected() is called, and transfers the
  * socket structure to so_comp, making it available to accept().
  *
  * structure queued on so_incomp by calling sonewconn().  When the connection
  * is established, soisconnected() is called, and transfers the
  * socket structure to so_comp, making it available to accept().
  *

- * If a socket is closed with sockets on either       
+ * If a socket is closed with sockets on either

  * so_incomp or so_comp, these sockets are dropped.
  * so_incomp or so_comp, these sockets are dropped.

- * 
+ *

  * If higher level protocols are implemented in
  * the kernel, the wakeups done here will sometimes
  * cause software-interrupt process scheduling.
  * If higher level protocols are implemented in
  * the kernel, the wakeups done here will sometimes
  * cause software-interrupt process scheduling.


@@ -122,14 +127,15 @@ soisconnecting(so)
 
 void
 soisconnected(so)
 
 void
 soisconnected(so)

-       register struct socket *so;
-{      register struct kextcb *kp;
-       register struct socket *head = so->so_head;
+       struct socket *so;
+{
+       struct socket *head = so->so_head;
+       struct kextcb *kp;

 
        kp = sotokextcb(so);
 
        kp = sotokextcb(so);

-       while (kp)
-       {       if (kp->e_soif && kp->e_soif->sf_soisconnected)
-               {       if ((*kp->e_soif->sf_soisconnected)(so, kp))
+       while (kp) {
+               if (kp->e_soif && kp->e_soif->sf_soisconnected) {
+                       if ((*kp->e_soif->sf_soisconnected)(so, kp))

                                return;
                }
                kp = kp->e_next;
                                return;
                }
                kp = kp->e_next;


@@ -145,7 +151,7 @@ soisconnected(so)
                TAILQ_INSERT_TAIL(&head->so_comp, so, so_list);
                so->so_state |= SS_COMP;
                sorwakeup(head);
                TAILQ_INSERT_TAIL(&head->so_comp, so, so_list);
                so->so_state |= SS_COMP;
                sorwakeup(head);

-               wakeup((caddr_t)&head->so_timeo);
+               wakeup_one(&head->so_timeo);

        } else {
                postevent(so,0,EV_WCONN);
                wakeup((caddr_t)&so->so_timeo);
        } else {
                postevent(so,0,EV_WCONN);
                wakeup((caddr_t)&so->so_timeo);


@@ -157,12 +163,13 @@ soisconnected(so)
 void
 soisdisconnecting(so)
        register struct socket *so;
 void
 soisdisconnecting(so)
        register struct socket *so;

-{      register struct kextcb *kp;
+{
+       register struct kextcb *kp;

 
        kp = sotokextcb(so);
 
        kp = sotokextcb(so);

-       while (kp)
-       {       if (kp->e_soif && kp->e_soif->sf_soisdisconnecting)
-               {       if ((*kp->e_soif->sf_soisdisconnecting)(so, kp))
+       while (kp) {
+               if (kp->e_soif && kp->e_soif->sf_soisdisconnecting) {
+                       if ((*kp->e_soif->sf_soisdisconnecting)(so, kp))

                                return;
                }
                kp = kp->e_next;
                                return;
                }
                kp = kp->e_next;


@@ -178,19 +185,20 @@ soisdisconnecting(so)
 void
 soisdisconnected(so)
        register struct socket *so;
 void
 soisdisconnected(so)
        register struct socket *so;

-{      register struct kextcb *kp;
+{
+       register struct kextcb *kp;

 
        kp = sotokextcb(so);
 
        kp = sotokextcb(so);

-       while (kp)
-       {       if (kp->e_soif && kp->e_soif->sf_soisdisconnected)
-               {       if ((*kp->e_soif->sf_soisdisconnected)(so, kp))
+       while (kp) {
+               if (kp->e_soif && kp->e_soif->sf_soisdisconnected) {
+                       if ((*kp->e_soif->sf_soisdisconnected)(so, kp))

                                return;
                }
                kp = kp->e_next;
        }
 
        so->so_state &= ~(SS_ISCONNECTING|SS_ISCONNECTED|SS_ISDISCONNECTING);
                                return;
                }
                kp = kp->e_next;
        }
 
        so->so_state &= ~(SS_ISCONNECTING|SS_ISCONNECTED|SS_ISDISCONNECTING);

-       so->so_state |= (SS_CANTRCVMORE|SS_CANTSENDMORE);
+       so->so_state |= (SS_CANTRCVMORE|SS_CANTSENDMORE|SS_ISDISCONNECTED);

        wakeup((caddr_t)&so->so_timeo);
        sowwakeup(so);
        sorwakeup(so);
        wakeup((caddr_t)&so->so_timeo);
        sowwakeup(so);
        sorwakeup(so);


@@ -252,7 +260,8 @@ struct socket *
 sonewconn(head, connstatus)
        register struct socket *head;
        int connstatus;
 sonewconn(head, connstatus)
        register struct socket *head;
        int connstatus;

-{      int error = 0;
+{
+       int error = 0;

        register struct socket *so;
        register struct kextcb *kp;
 
        register struct socket *so;
        register struct kextcb *kp;
 


@@ -261,14 +270,10 @@ sonewconn(head, connstatus)
        so = soalloc(1, head->so_proto->pr_domain->dom_family, head->so_type);
        if (so == NULL)
                return ((struct socket *)0);
        so = soalloc(1, head->so_proto->pr_domain->dom_family, head->so_type);
        if (so == NULL)
                return ((struct socket *)0);

-        
-       kp = sotokextcb(so);
-       while (kp)
-       {       if (kp->e_soif && kp->e_soif->sf_sonewconn1)
-               {       if ((*kp->e_soif->sf_sonewconn1)(so, connstatus, kp))
-                               return;
-               }
-               kp = kp->e_next;
+       /* check if head was closed during the soalloc */
+       if (head->so_proto == NULL) {
+         sodealloc(so);
+         return ((struct socket *)0);

        }
 
        so->so_head = head;
        }
 
        so->so_head = head;


@@ -280,17 +285,39 @@ sonewconn(head, connstatus)
        so->so_timeo = head->so_timeo;
        so->so_pgid  = head->so_pgid;
        so->so_uid = head->so_uid;
        so->so_timeo = head->so_timeo;
        so->so_pgid  = head->so_pgid;
        so->so_uid = head->so_uid;

-       so->so_rcv.sb_flags |= SB_RECV; /* XXX */
-       (void) soreserve(so, head->so_snd.sb_hiwat, head->so_rcv.sb_hiwat);

 
 

+       /* Attach socket filters for this protocol */

        if (so->so_proto->pr_sfilter.tqh_first)
                error = sfilter_init(so);
        if (so->so_proto->pr_sfilter.tqh_first)
                error = sfilter_init(so);

-       if (error == 0 && (*so->so_proto->pr_usrreqs->pru_attach)(so, 0, NULL)) {
+       if (error != 0) {
+               sodealloc(so);
+               return ((struct socket *)0);
+       }
+
+       /* Call socket filters' sonewconn1 function if set */
+       kp = sotokextcb(so);
+       while (kp) {
+               if (kp->e_soif && kp->e_soif->sf_sonewconn) {
+                       error = (int)(*kp->e_soif->sf_sonewconn)(so, connstatus, kp);
+                       if (error == EJUSTRETURN) {
+                               return so;
+                       } else if (error != 0) {
+                               sodealloc(so);
+                               return NULL;
+                       }
+               }
+               kp = kp->e_next;
+       }
+
+       if (soreserve(so, head->so_snd.sb_hiwat, head->so_rcv.sb_hiwat) ||
+           (*so->so_proto->pr_usrreqs->pru_attach)(so, 0, NULL)) {

                sfilter_term(so);
                sodealloc(so);
                return ((struct socket *)0);
        }
                sfilter_term(so);
                sodealloc(so);
                return ((struct socket *)0);
        }

+#ifdef __APPLE__

        so->so_proto->pr_domain->dom_refs++;
        so->so_proto->pr_domain->dom_refs++;

+#endif

 
        if (connstatus) {
                TAILQ_INSERT_TAIL(&head->so_comp, so, so_list);
 
        if (connstatus) {
                TAILQ_INSERT_TAIL(&head->so_comp, so, so_list);


@@ -306,8 +333,10 @@ sonewconn(head, connstatus)
                wakeup((caddr_t)&head->so_timeo);
                so->so_state |= connstatus;
        }
                wakeup((caddr_t)&head->so_timeo);
                so->so_state |= connstatus;
        }

+#ifdef __APPLE__

        so->so_rcv.sb_so = so->so_snd.sb_so = so;
        TAILQ_INIT(&so->so_evlist);
        so->so_rcv.sb_so = so->so_snd.sb_so = so;
        TAILQ_INIT(&so->so_evlist);

+#endif

        return (so);
 }
 
        return (so);
 }
 


@@ -324,12 +353,13 @@ sonewconn(head, connstatus)
 void
 socantsendmore(so)
        struct socket *so;
 void
 socantsendmore(so)
        struct socket *so;

-{      register struct kextcb *kp;
-
+{
+       register struct kextcb *kp;
+       

        kp = sotokextcb(so);
        kp = sotokextcb(so);

-       while (kp)
-       {       if (kp->e_soif && kp->e_soif->sf_socantsendmore)
-               {       if ((*kp->e_soif->sf_socantsendmore)(so, kp))
+       while (kp) {
+               if (kp->e_soif && kp->e_soif->sf_socantsendmore) {
+                       if ((*kp->e_soif->sf_socantsendmore)(so, kp))

                                return;
                }
                kp = kp->e_next;
                                return;
                }
                kp = kp->e_next;


@@ -343,12 +373,13 @@ socantsendmore(so)
 void
 socantrcvmore(so)
        struct socket *so;
 void
 socantrcvmore(so)
        struct socket *so;

-{      register struct kextcb *kp;
+{
+       register struct kextcb *kp;

 
        kp = sotokextcb(so);
 
        kp = sotokextcb(so);

-       while (kp)
-       {       if (kp->e_soif && kp->e_soif->sf_socantrcvmore)
-               {       if ((*kp->e_soif->sf_socantrcvmore)(so, kp))
+       while (kp) {
+               if (kp->e_soif && kp->e_soif->sf_socantrcvmore) {
+                       if ((*kp->e_soif->sf_socantrcvmore)(so, kp))

                                return;
                }
                kp = kp->e_next;
                                return;
                }
                kp = kp->e_next;


@@ -406,13 +437,10 @@ sowakeup(so, sb)
        register struct sockbuf *sb;
 {
        struct proc *p = current_proc();
        register struct sockbuf *sb;
 {
        struct proc *p = current_proc();

-
-
-
-
+       /* We clear the flag before calling selwakeup. */
+       /* BSD calls selwakeup then sets the flag */

        sb->sb_flags &= ~SB_SEL;
        selwakeup(&sb->sb_sel);
        sb->sb_flags &= ~SB_SEL;
        selwakeup(&sb->sb_sel);

-

        if (sb->sb_flags & SB_WAIT) {
                sb->sb_flags &= ~SB_WAIT;
                wakeup((caddr_t)&sb->sb_cc);
        if (sb->sb_flags & SB_WAIT) {
                sb->sb_flags &= ~SB_WAIT;
                wakeup((caddr_t)&sb->sb_cc);


@@ -423,9 +451,11 @@ sowakeup(so, sb)
                else if (so->so_pgid > 0 && (p = pfind(so->so_pgid)) != 0)
                        psignal(p, SIGIO);
        }
                else if (so->so_pgid > 0 && (p = pfind(so->so_pgid)) != 0)
                        psignal(p, SIGIO);
        }

-

        if (sb->sb_flags & SB_UPCALL)
                (*so->so_upcall)(so, so->so_upcallarg, M_DONTWAIT);
        if (sb->sb_flags & SB_UPCALL)
                (*so->so_upcall)(so, so->so_upcallarg, M_DONTWAIT);

+       if (sb->sb_flags & SB_KNOTE &&
+               !(sb->sb_sel.si_flags & SI_INITED))
+               KNOTE(&sb->sb_sel.si_note, 0);

 }
 
 /*
 }
 
 /*


@@ -468,9 +498,9 @@ soreserve(so, sndcc, rcvcc)
        register struct kextcb *kp;
 
        kp = sotokextcb(so);
        register struct kextcb *kp;
 
        kp = sotokextcb(so);

-       while (kp)
-       {       if (kp->e_soif && kp->e_soif->sf_soreserve)
-               {       if ((*kp->e_soif->sf_soreserve)(so, sndcc, rcvcc, kp))
+       while (kp) {
+               if (kp->e_soif && kp->e_soif->sf_soreserve) {
+                       if ((*kp->e_soif->sf_soreserve)(so, sndcc, rcvcc, kp))

                                return;
                }
                kp = kp->e_next;
                                return;
                }
                kp = kp->e_next;


@@ -488,7 +518,9 @@ soreserve(so, sndcc, rcvcc)
                so->so_snd.sb_lowat = so->so_snd.sb_hiwat;
        return (0);
 bad2:
                so->so_snd.sb_lowat = so->so_snd.sb_hiwat;
        return (0);
 bad2:

+#ifdef __APPLE__

        selthreadclear(&so->so_snd.sb_sel);
        selthreadclear(&so->so_snd.sb_sel);

+#endif

        sbrelease(&so->so_snd);
 bad:
        return (ENOBUFS);
        sbrelease(&so->so_snd);
 bad:
        return (ENOBUFS);


@@ -523,15 +555,9 @@ sbrelease(sb)
 {
 
        sbflush(sb);
 {
 
        sbflush(sb);

-       sb->sb_hiwat = sb->sb_mbmax = 0;
-#if 0
-       /* this is getting called with bzeroed sb in sorflush */
-       {
-               int oldpri = splimp();
-               selthreadclear(&sb->sb_sel);
-               splx(oldpri);
-       }
-#endif
+       sb->sb_hiwat = 0;
+       sb->sb_mbmax = 0;
+       

 }
 
 /*
 }
 
 /*


@@ -569,31 +595,40 @@ void
 sbappend(sb, m)
        struct sockbuf *sb;
        struct mbuf *m;
 sbappend(sb, m)
        struct sockbuf *sb;
        struct mbuf *m;

-{      register struct kextcb *kp;
+{
+       struct kextcb *kp;

        register struct mbuf *n;
 
        register struct mbuf *n;
 

+
+       KERNEL_DEBUG((DBG_FNC_SBAPPEND | DBG_FUNC_START), sb, m->m_len, 0, 0, 0);
+

        if (m == 0)
                return;
        kp = sotokextcb(sbtoso(sb));
        if (m == 0)
                return;
        kp = sotokextcb(sbtoso(sb));

-       while (kp)
-       {       if (kp->e_sout && kp->e_sout->su_sbappend)
-               {       if ((*kp->e_sout->su_sbappend)(sb, m, kp))
+       while (kp) {
+               if (kp->e_sout && kp->e_sout->su_sbappend) {
+                       if ((*kp->e_sout->su_sbappend)(sb, m, kp)) {
+                               KERNEL_DEBUG((DBG_FNC_SBAPPEND | DBG_FUNC_END), sb, sb->sb_cc, kp, 0, 0);

                                return;
                                return;

+                       }

                }
                kp = kp->e_next;
        }
                }
                kp = kp->e_next;
        }

-
-       if (n = sb->sb_mb) {
+       n = sb->sb_mb;
+       if (n) {

                while (n->m_nextpkt)
                        n = n->m_nextpkt;
                do {
                        if (n->m_flags & M_EOR) {
                                sbappendrecord(sb, m); /* XXXXXX!!!! */
                while (n->m_nextpkt)
                        n = n->m_nextpkt;
                do {
                        if (n->m_flags & M_EOR) {
                                sbappendrecord(sb, m); /* XXXXXX!!!! */

+                               KERNEL_DEBUG((DBG_FNC_SBAPPEND | DBG_FUNC_END), sb, sb->sb_cc, 0, 0, 0);

                                return;
                        }
                } while (n->m_next && (n = n->m_next));
        }
        sbcompress(sb, m, n);
                                return;
                        }
                } while (n->m_next && (n = n->m_next));
        }
        sbcompress(sb, m, n);

+
+       KERNEL_DEBUG((DBG_FNC_SBAPPEND | DBG_FUNC_END), sb, sb->sb_cc, 0, 0, 0);

 }
 
 #ifdef SOCKBUF_DEBUG
 }
 
 #ifdef SOCKBUF_DEBUG


@@ -608,18 +643,24 @@ sbcheck(sb)
        for (m = sb->sb_mb; m; m = n) {
            n = m->m_nextpkt;
            for (; m; m = m->m_next) {
        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;
-               if (m->m_nextpkt)
-                       panic("sbcheck nextpkt");
-       }
-       if (len != sb->sb_cc || mbcnt != sb->sb_mbcnt) {
-               printf("cc %ld != %ld || mbcnt %ld != %ld\n", len, sb->sb_cc,
-                   mbcnt, sb->sb_mbcnt);
-               panic("sbcheck");
+                len += m->m_len;
+                mbcnt += MSIZE;
+                if (m->m_flags & M_EXT) /*XXX*/ /* pretty sure this is bogus */
+                    mbcnt += m->m_ext.ext_size;
+            }

        }
        }

+#ifndef __APPLE__
+        if (len != sb->sb_cc || mbcnt != sb->sb_mbcnt) {
+                printf("cc %ld != %ld || mbcnt %ld != %ld\n", len, sb->sb_cc,
+                    mbcnt, sb->sb_mbcnt);
+                panic("sbcheck");
+        }
+#else
+       if (len != sb->sb_cc)
+           printf("sbcheck len %ld != sb_cc %ld\n", len, sb->sb_cc);
+       if (mbcnt != sb->sb_mbcnt)
+           printf("sbcheck mbcnt %ld != sb_mbcnt %ld\n", mbcnt, sb->sb_mbcnt);
+#endif

 }
 #endif
 
 }
 #endif
 


@@ -634,7 +675,7 @@ sbappendrecord(sb, m0)
 {
        register struct mbuf *m;
        register struct kextcb *kp;
 {
        register struct mbuf *m;
        register struct kextcb *kp;

-    
+

        if (m0 == 0)
                return;
         
        if (m0 == 0)
                return;
         


@@ -855,8 +896,12 @@ sbcompress(sb, m, n)
                        m = m_free(m);
                        continue;
                }
                        m = m_free(m);
                        continue;
                }

-               if (n && (n->m_flags & (M_EXT | M_EOR)) == 0 &&
-                   (n->m_data + n->m_len + m->m_len) < &n->m_dat[MLEN] &&
+               if (n && (n->m_flags & M_EOR) == 0 &&
+#ifndef __APPLE__
+                   M_WRITABLE(n) &&
+#endif
+                   m->m_len <= MCLBYTES / 4 && /* XXX: Don't copy too much */
+                   m->m_len <= M_TRAILINGSPACE(n) &&

                    n->m_type == m->m_type) {
                        bcopy(mtod(m, caddr_t), mtod(n, caddr_t) + n->m_len,
                            (unsigned)m->m_len);
                    n->m_type == m->m_type) {
                        bcopy(mtod(m, caddr_t), mtod(n, caddr_t) + n->m_len,
                            (unsigned)m->m_len);


@@ -895,52 +940,87 @@ sbflush(sb)
        register struct kextcb *kp;
 
        kp = sotokextcb(sbtoso(sb));
        register struct kextcb *kp;
 
        kp = sotokextcb(sbtoso(sb));

-       while (kp)
-       {       if (kp->e_sout && kp->e_sout->su_sbflush)
-               {       if ((*kp->e_sout->su_sbflush)(sb, kp))
+       while (kp) {
+               if (kp->e_sout && kp->e_sout->su_sbflush) {
+                       if ((*kp->e_sout->su_sbflush)(sb, kp))

                                return;
                }
                kp = kp->e_next;
        }
 
                                return;
                }
                kp = kp->e_next;
        }
 

-       if (sb->sb_flags & SB_LOCK)
-               panic("sbflush: locked");
-       while (sb->sb_mbcnt && sb->sb_cc)
+       (void)sblock(sb, M_WAIT);
+       while (sb->sb_mbcnt) {
+               /*
+                * Don't call sbdrop(sb, 0) if the leading mbuf is non-empty:
+                * we would loop forever. Panic instead.
+                */
+               if (!sb->sb_cc && (sb->sb_mb == NULL || sb->sb_mb->m_len))
+                       break;

                sbdrop(sb, (int)sb->sb_cc);
                sbdrop(sb, (int)sb->sb_cc);

+       }

        if (sb->sb_cc || sb->sb_mb || sb->sb_mbcnt)
                panic("sbflush: cc %ld || mb %p || mbcnt %ld", sb->sb_cc, (void *)sb->sb_mb, sb->sb_mbcnt);
        if (sb->sb_cc || sb->sb_mb || sb->sb_mbcnt)
                panic("sbflush: cc %ld || mb %p || mbcnt %ld", sb->sb_cc, (void *)sb->sb_mb, sb->sb_mbcnt);

+
+       sbunlock(sb);
+

        postevent(0, sb, EV_RWBYTES);
 }
 
 /*
  * Drop data from (the front of) a sockbuf.
        postevent(0, sb, EV_RWBYTES);
 }
 
 /*
  * Drop data from (the front of) a sockbuf.

+ * use m_freem_list to free the mbuf structures
+ * under a single lock... this is done by pruning
+ * the top of the tree from the body by keeping track
+ * of where we get to in the tree and then zeroing the
+ * two pertinent pointers m_nextpkt and m_next
+ * the socket buffer is then updated to point at the new
+ * top of the tree and the pruned area is released via
+ * m_freem_list.

  */
 void
 sbdrop(sb, len)
        register struct sockbuf *sb;
        register int len;
 {
  */
 void
 sbdrop(sb, len)
        register struct sockbuf *sb;
        register int len;
 {

-       register struct mbuf *m, *mn;
-       struct mbuf *next;
+       register struct mbuf *m, *free_list, *ml;
+       struct mbuf *next, *last;

        register struct kextcb *kp;
 
        register struct kextcb *kp;
 

+       KERNEL_DEBUG((DBG_FNC_SBDROP | DBG_FUNC_START), sb, len, 0, 0, 0);
+

        kp = sotokextcb(sbtoso(sb));
        kp = sotokextcb(sbtoso(sb));

-       while (kp)
-       {       if (kp->e_sout && kp->e_sout->su_sbdrop)
-               {       if ((*kp->e_sout->su_sbdrop)(sb, len, kp))
+       while (kp) {
+               if (kp->e_sout && kp->e_sout->su_sbdrop) {
+                       if ((*kp->e_sout->su_sbdrop)(sb, len, kp)) {
+                               KERNEL_DEBUG((DBG_FNC_SBDROP | DBG_FUNC_END), sb, len, kp, 0, 0);

                                return;
                                return;

+                       }

                }
                kp = kp->e_next;
        }
                }
                kp = kp->e_next;
        }

-

        next = (m = sb->sb_mb) ? m->m_nextpkt : 0;
        next = (m = sb->sb_mb) ? m->m_nextpkt : 0;

+       free_list = last = m;
+       ml = (struct mbuf *)0;
+

        while (len > 0) {
                if (m == 0) {
        while (len > 0) {
                if (m == 0) {

-                       if (next == 0)
-                               panic("sbdrop");
-                       m = 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;
                }
                if (m->m_len > len) {
                        m->m_len -= len;


@@ -950,20 +1030,30 @@ sbdrop(sb, len)
                }
                len -= m->m_len;
                sbfree(sb, m);
                }
                len -= m->m_len;
                sbfree(sb, m);

-               MFREE(m, mn);
-               m = mn;
+
+               ml = m;
+               m = m->m_next;

        }
        while (m && m->m_len == 0) {
                sbfree(sb, m);
        }
        while (m && m->m_len == 0) {
                sbfree(sb, m);

-               MFREE(m, mn);
-               m = mn;
+
+               ml = m;
+               m = m->m_next;
+       }
+       if (ml) {
+               ml->m_next = (struct mbuf *)0;
+               last->m_nextpkt = (struct mbuf *)0;
+               m_freem_list(free_list);

        }
        if (m) {
                sb->sb_mb = m;
                m->m_nextpkt = next;
        } else
                sb->sb_mb = next;
        }
        if (m) {
                sb->sb_mb = m;
                m->m_nextpkt = next;
        } else
                sb->sb_mb = next;

+

        postevent(0, sb, EV_RWBYTES);
        postevent(0, sb, EV_RWBYTES);

+
+       KERNEL_DEBUG((DBG_FNC_SBDROP | DBG_FUNC_END), sb, 0, 0, 0, 0);

 }
 
 /*
 }
 
 /*


@@ -978,9 +1068,9 @@ sbdroprecord(sb)
        register struct kextcb *kp;
 
        kp = sotokextcb(sbtoso(sb));
        register struct kextcb *kp;
 
        kp = sotokextcb(sbtoso(sb));

-       while (kp)
-       {       if (kp->e_sout && kp->e_sout->su_sbdroprecord)
-               {       if ((*kp->e_sout->su_sbdroprecord)(sb, kp))
+       while (kp) {
+               if (kp->e_sout && kp->e_sout->su_sbdroprecord) {
+                       if ((*kp->e_sout->su_sbdroprecord)(sb, kp))

                                return;
                }
                kp = kp->e_next;
                                return;
                }
                kp = kp->e_next;


@@ -992,7 +1082,8 @@ sbdroprecord(sb)
                do {
                        sbfree(sb, m);
                        MFREE(m, mn);
                do {
                        sbfree(sb, m);
                        MFREE(m, mn);

-               } while (m = mn);
+                       m = mn;
+               } while (m);

        }
        postevent(0, sb, EV_RWBYTES);
 }
        }
        postevent(0, sb, EV_RWBYTES);
 }


@@ -1010,14 +1101,15 @@ sbcreatecontrol(p, size, type, level)
        register struct cmsghdr *cp;
        struct mbuf *m;
 
        register struct cmsghdr *cp;
        struct mbuf *m;
 

+       if (CMSG_SPACE((u_int)size) > MLEN)
+               return ((struct mbuf *) NULL);

        if ((m = m_get(M_DONTWAIT, MT_CONTROL)) == NULL)
                return ((struct mbuf *) NULL);
        cp = mtod(m, struct cmsghdr *);
        /* XXX check size? */
        (void)memcpy(CMSG_DATA(cp), p, size);
        if ((m = m_get(M_DONTWAIT, MT_CONTROL)) == NULL)
                return ((struct mbuf *) NULL);
        cp = mtod(m, struct cmsghdr *);
        /* XXX check size? */
        (void)memcpy(CMSG_DATA(cp), p, size);

-       size += sizeof(*cp);
-       m->m_len = size;
-       cp->cmsg_len = size;
+       m->m_len = CMSG_SPACE(size);
+       cp->cmsg_len = CMSG_LEN(size);

        cp->cmsg_level = level;
        cp->cmsg_type = type;
        return (m);
        cp->cmsg_level = level;
        cp->cmsg_type = type;
        return (m);


@@ -1181,6 +1273,10 @@ int      pru_sopoll_notsupp(struct socket *so, int events,
 }
 
 
 }
 
 

+#ifdef __APPLE__
+/*
+ * The following are macros on BSD and functions on Darwin
+ */

 
 /*
  * Do we need to notify the other side when I/O is possible?
 
 /*
  * Do we need to notify the other side when I/O is possible?


@@ -1189,7 +1285,7 @@ int       pru_sopoll_notsupp(struct socket *so, int events,
 int 
 sb_notify(struct sockbuf *sb)
 {
 int 
 sb_notify(struct sockbuf *sb)
 {

-       return ((sb->sb_flags & (SB_WAIT|SB_SEL|SB_ASYNC|SB_UPCALL)) != 0); 
+       return ((sb->sb_flags & (SB_WAIT|SB_SEL|SB_ASYNC|SB_UPCALL|SB_KNOTE)) != 0); 

 }
 
 /*
 }
 
 /*


@@ -1291,6 +1387,7 @@ 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__

 
 /*
  * Make a copy of a sockaddr in a malloced buffer of type M_SONAME.
 
 /*
  * Make a copy of a sockaddr in a malloced buffer of type M_SONAME.


@@ -1363,16 +1460,16 @@ 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.
  */
  * 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");
 
 /* 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_NODE(_kern, KERN_IPC, ipc, CTLFLAG_RW, 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, &sb_max, 0, "");
-SYSCTL_INT(_kern_ipc, OID_AUTO, maxsockets, CTLFLAG_RD, &maxsockets, 0, "");
+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, 
+    &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, "");
 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, "");