xnu-6153.141.1.tar.gz

[apple/xnu.git] / bsd / net / ndrv.c

diff --git a/bsd/net/ndrv.c b/bsd/net/ndrv.c
index 41603c5b2c9bedceabadc5131901ea348b184b6a..aeec3bb461640148a9d16ee3ea4522452fcac660 100644 (file)
--- a/bsd/net/ndrv.c
+++ b/bsd/net/ndrv.c
@@ -80,7 +80,12 @@
 
 static unsigned int ndrv_multi_max_count = NDRV_DMUX_MAX_DESCR;
 SYSCTL_UINT(_net, OID_AUTO, ndrv_multi_max_count, CTLFLAG_RW | CTLFLAG_LOCKED,
 
 static unsigned int ndrv_multi_max_count = NDRV_DMUX_MAX_DESCR;
 SYSCTL_UINT(_net, OID_AUTO, ndrv_multi_max_count, CTLFLAG_RW | CTLFLAG_LOCKED,

-        &ndrv_multi_max_count, 0, "Number of allowed multicast addresses per NRDV socket");
+    &ndrv_multi_max_count, 0, "Number of allowed multicast addresses per NRDV socket");
+
+/*
+ * The locking strategy relies on the PF_NRDRV domain mutex that protects both the
+ * PCB list "ndrvl" and the sockets themselves
+ */

 
 static int ndrv_do_detach(struct ndrv_cb *);
 static int ndrv_do_disconnect(struct ndrv_cb *);
 
 static int ndrv_do_detach(struct ndrv_cb *);
 static int ndrv_do_disconnect(struct ndrv_cb *);


@@ -97,12 +102,12 @@ static void ndrv_dominit(struct domain *);
 
 u_int32_t  ndrv_sendspace = NDRVSNDQ;
 u_int32_t  ndrv_recvspace = NDRVRCVQ;
 
 u_int32_t  ndrv_sendspace = NDRVSNDQ;
 u_int32_t  ndrv_recvspace = NDRVRCVQ;

-TAILQ_HEAD(, ndrv_cb)  ndrvl = TAILQ_HEAD_INITIALIZER(ndrvl);
+TAILQ_HEAD(, ndrv_cb)   ndrvl = TAILQ_HEAD_INITIALIZER(ndrvl);

 
 static struct domain *ndrvdomain = NULL;
 extern struct domain ndrvdomain_s;
 
 
 static struct domain *ndrvdomain = NULL;
 extern struct domain ndrvdomain_s;
 

-#define NDRV_PROTODEMUX_COUNT  10
+#define NDRV_PROTODEMUX_COUNT   10

 
 /*
  * Verify these values match.
 
 /*
  * Verify these values match.


@@ -127,9 +132,9 @@ extern struct domain ndrvdomain_s;
 static int
 ndrv_output(struct mbuf *m, struct socket *so)
 {
 static int
 ndrv_output(struct mbuf *m, struct socket *so)
 {

-    struct ndrv_cb *np = sotondrvcb(so);
+       struct ndrv_cb *np = sotondrvcb(so);

        struct ifnet *ifp = np->nd_if;
        struct ifnet *ifp = np->nd_if;

-    int        result = 0;
+       int result = 0;

 
 #if NDRV_DEBUG
        printf("NDRV output: %x, %x, %x\n", m, so, np);
 
 #if NDRV_DEBUG
        printf("NDRV output: %x, %x, %x\n", m, so, np);


@@ -138,67 +143,77 @@ ndrv_output(struct mbuf *m, struct socket *so)
        /*
         * No header is a format error
         */
        /*
         * No header is a format error
         */

-       if ((m->m_flags&M_PKTHDR) == 0)
-               return(EINVAL);
+       if ((m->m_flags & M_PKTHDR) == 0) {
+               return EINVAL;
+       }

 
        /* Unlock before calling ifnet_output */
        socket_unlock(so, 0);
 
        /*
 
        /* Unlock before calling ifnet_output */
        socket_unlock(so, 0);
 
        /*

-     * Call DLIL if we can. DLIL is much safer than calling the
-     * ifp directly.
-     */
+        * Call DLIL if we can. DLIL is much safer than calling the
+        * ifp directly.
+        */

        result = ifnet_output_raw(ifp, np->nd_proto_family, m);
 
        socket_lock(so, 0);
 
        result = ifnet_output_raw(ifp, np->nd_proto_family, m);
 
        socket_lock(so, 0);
 

-       return (result);
+       return result;

 }
 
 /* Our input routine called from DLIL */
 static errno_t
 ndrv_input(
 }
 
 /* Our input routine called from DLIL */
 static errno_t
 ndrv_input(

-       ifnet_t                         ifp,
-       protocol_family_t       proto_family,
-       mbuf_t                          m,
-       char                            *frame_header)
+       ifnet_t                         ifp,
+       protocol_family_t       proto_family,
+       mbuf_t                          m,
+       char                            *frame_header)

 {
        struct socket *so;
        struct sockaddr_dl ndrvsrc;
        struct ndrv_cb *np;
        int error = 0;
 
 {
        struct socket *so;
        struct sockaddr_dl ndrvsrc;
        struct ndrv_cb *np;
        int error = 0;
 

-    ndrvsrc.sdl_len = sizeof (struct sockaddr_dl);
-    ndrvsrc.sdl_family = AF_NDRV;
-    ndrvsrc.sdl_index = 0;
+       ndrvsrc.sdl_len = sizeof(struct sockaddr_dl);
+       ndrvsrc.sdl_family = AF_NDRV;
+       ndrvsrc.sdl_index = 0;

 
 

-    /* move packet from if queue to socket */
+       /* move packet from if queue to socket */

        /* Should be media-independent */
        /* Should be media-independent */

-    ndrvsrc.sdl_type = IFT_ETHER;
-    ndrvsrc.sdl_nlen = 0;
-    ndrvsrc.sdl_alen = 6;
-    ndrvsrc.sdl_slen = 0;
-    bcopy(frame_header, &ndrvsrc.sdl_data, 6);
+       ndrvsrc.sdl_type = IFT_ETHER;
+       ndrvsrc.sdl_nlen = 0;
+       ndrvsrc.sdl_alen = 6;
+       ndrvsrc.sdl_slen = 0;
+       bcopy(frame_header, &ndrvsrc.sdl_data, 6);
+
+       /* prepend the frame header */
+       m = m_prepend(m, ifnet_hdrlen(ifp), M_NOWAIT);
+       if (m == NULL) {
+               return EJUSTRETURN;
+       }
+       bcopy(frame_header, m->m_data, ifnet_hdrlen(ifp));
+
+       /*
+        * We need to take the domain mutex before the list RW lock
+        */
+       LCK_MTX_ASSERT(ndrvdomain->dom_mtx, LCK_MTX_ASSERT_NOTOWNED);
+       lck_mtx_lock(ndrvdomain->dom_mtx);

 
        np = ndrv_find_inbound(ifp, proto_family);
 
        np = ndrv_find_inbound(ifp, proto_family);

-       if (np == NULL)
-       {
-               return(ENOENT);
+       if (np == NULL) {
+               lck_mtx_unlock(ndrvdomain->dom_mtx);
+               return ENOENT;

        }
        }

+

        so = np->nd_socket;
        so = np->nd_socket;

-    /* prepend the frame header */
-    m = m_prepend(m, ifnet_hdrlen(ifp), M_NOWAIT);
-    if (m == NULL)
-        return EJUSTRETURN;
-    bcopy(frame_header, m->m_data, ifnet_hdrlen(ifp));

 
 

-       LCK_MTX_ASSERT(ndrvdomain->dom_mtx, LCK_MTX_ASSERT_NOTOWNED);
-       lck_mtx_lock(ndrvdomain->dom_mtx);

        if (sbappendaddr(&(so->so_rcv), (struct sockaddr *)&ndrvsrc,
        if (sbappendaddr(&(so->so_rcv), (struct sockaddr *)&ndrvsrc,

-                                        m, (struct mbuf *)0, &error) != 0) {
+           m, NULL, &error) != 0) {

                sorwakeup(so);
        }
                sorwakeup(so);
        }

+

        lck_mtx_unlock(ndrvdomain->dom_mtx);
        lck_mtx_unlock(ndrvdomain->dom_mtx);

+

        return 0; /* radar 4030377 - always return 0 */
 }
 
        return 0; /* radar 4030377 - always return 0 */
 }
 


@@ -208,24 +223,27 @@ ndrv_input(
 static int
 ndrv_attach(struct socket *so, int proto, __unused struct proc *p)
 {
 static int
 ndrv_attach(struct socket *so, int proto, __unused struct proc *p)
 {

-    int error;
+       int error;

        struct ndrv_cb *np = sotondrvcb(so);
 
        struct ndrv_cb *np = sotondrvcb(so);
 

-       if ((so->so_state & SS_PRIV) == 0)
-               return(EPERM);
+       if ((so->so_state & SS_PRIV) == 0) {
+               return EPERM;
+       }

 
 #if NDRV_DEBUG
        printf("NDRV attach: %x, %x, %x\n", so, proto, np);
 #endif
 
 
 #if NDRV_DEBUG
        printf("NDRV attach: %x, %x, %x\n", so, proto, np);
 #endif
 

-        if ((error = soreserve(so, ndrv_sendspace, ndrv_recvspace)))
-                return(error);
+       if ((error = soreserve(so, ndrv_sendspace, ndrv_recvspace))) {
+               return error;
+       }

 
        MALLOC(np, struct ndrv_cb *, sizeof(*np), M_PCB, M_WAITOK);
 
        MALLOC(np, struct ndrv_cb *, sizeof(*np), M_PCB, M_WAITOK);

-       if (np == NULL)
-               return (ENOMEM);
-    so->so_pcb = (caddr_t)np;
-    bzero(np, sizeof(*np));
+       if (np == NULL) {
+               return ENOMEM;
+       }
+       so->so_pcb = (caddr_t)np;
+       bzero(np, sizeof(*np));

 #if NDRV_DEBUG
        printf("NDRV attach: %x, %x, %x\n", so, proto, np);
 #endif
 #if NDRV_DEBUG
        printf("NDRV attach: %x, %x, %x\n", so, proto, np);
 #endif


@@ -234,12 +252,22 @@ ndrv_attach(struct socket *so, int proto, __unused struct proc *p)
        np->nd_socket = so;
        np->nd_proto.sp_family = SOCK_DOM(so);
        np->nd_proto.sp_protocol = proto;
        np->nd_socket = so;
        np->nd_proto.sp_family = SOCK_DOM(so);
        np->nd_proto.sp_protocol = proto;

-    np->nd_if = NULL;
-    np->nd_proto_family = 0;
-    np->nd_family = 0;
-    np->nd_unit = 0;
-    TAILQ_INSERT_TAIL(&ndrvl, np, nd_next);
-       return(0);
+       np->nd_if = NULL;
+       np->nd_proto_family = 0;
+       np->nd_family = 0;
+       np->nd_unit = 0;
+
+       /*
+        * Use the domain mutex to protect the list
+        */
+       LCK_MTX_ASSERT(ndrvdomain->dom_mtx, LCK_MTX_ASSERT_NOTOWNED);
+       lck_mtx_lock(ndrvdomain->dom_mtx);
+
+       TAILQ_INSERT_TAIL(&ndrvl, np, nd_next);
+
+       lck_mtx_unlock(ndrvdomain->dom_mtx);
+
+       return 0;

 }
 
 /*
 }
 
 /*


@@ -252,8 +280,9 @@ ndrv_detach(struct socket *so)
 {
        struct ndrv_cb *np = sotondrvcb(so);
 
 {
        struct ndrv_cb *np = sotondrvcb(so);
 

-       if (np == 0)
+       if (np == 0) {

                return EINVAL;
                return EINVAL;

+       }

        return ndrv_do_detach(np);
 }
 
        return ndrv_do_detach(np);
 }
 


@@ -272,17 +301,20 @@ ndrv_connect(struct socket *so, struct sockaddr *nam, __unused struct proc *p)
 {
        struct ndrv_cb *np = sotondrvcb(so);
 
 {
        struct ndrv_cb *np = sotondrvcb(so);
 

-       if (np == 0)
+       if (np == 0) {

                return EINVAL;
                return EINVAL;

+       }

 
 

-       if (np->nd_faddr)
+       if (np->nd_faddr) {

                return EISCONN;
                return EISCONN;

+       }

 
        /* Allocate memory to store the remote address */
        MALLOC(np->nd_faddr, struct sockaddr_ndrv*,
 
        /* Allocate memory to store the remote address */
        MALLOC(np->nd_faddr, struct sockaddr_ndrv*,

-                nam->sa_len, M_IFADDR, M_WAITOK);
-       if (np->nd_faddr == NULL)
+           nam->sa_len, M_IFADDR, M_WAITOK);
+       if (np->nd_faddr == NULL) {

                return ENOMEM;
                return ENOMEM;

+       }

 
        bcopy((caddr_t) nam, (caddr_t) np->nd_faddr, nam->sa_len);
        soisconnected(so);
 
        bcopy((caddr_t) nam, (caddr_t) np->nd_faddr, nam->sa_len);
        soisconnected(so);


@@ -291,12 +323,12 @@ ndrv_connect(struct socket *so, struct sockaddr *nam, __unused struct proc *p)
 
 static void
 ndrv_event(struct ifnet *ifp, __unused protocol_family_t protocol,
 
 static void
 ndrv_event(struct ifnet *ifp, __unused protocol_family_t protocol,

-                  const struct kev_msg *event)
+    const struct kev_msg *event)

 {
        if (event->vendor_code == KEV_VENDOR_APPLE &&
 {
        if (event->vendor_code == KEV_VENDOR_APPLE &&

-               event->kev_class == KEV_NETWORK_CLASS &&
-               event->kev_subclass == KEV_DL_SUBCLASS &&
-               event->event_code == KEV_DL_IF_DETACHING) {
+           event->kev_class == KEV_NETWORK_CLASS &&
+           event->kev_subclass == KEV_DL_SUBCLASS &&
+           event->event_code == KEV_DL_IF_DETACHING) {

                LCK_MTX_ASSERT(ndrvdomain->dom_mtx, LCK_MTX_ASSERT_NOTOWNED);
                lck_mtx_lock(ndrvdomain->dom_mtx);
                ndrv_handle_ifp_detach(ifnet_family(ifp), ifnet_unit(ifp));
                LCK_MTX_ASSERT(ndrvdomain->dom_mtx, LCK_MTX_ASSERT_NOTOWNED);
                lck_mtx_lock(ndrvdomain->dom_mtx);
                ndrv_handle_ifp_detach(ifnet_family(ifp), ifnet_unit(ifp));


@@ -314,30 +346,34 @@ static int name_cmp(struct ifnet *, char *);
 static int
 ndrv_bind(struct socket *so, struct sockaddr *nam, __unused struct proc *p)
 {
 static int
 ndrv_bind(struct socket *so, struct sockaddr *nam, __unused struct proc *p)
 {

-    struct sockaddr_ndrv *sa = (struct sockaddr_ndrv *) nam;
+       struct sockaddr_ndrv *sa = (struct sockaddr_ndrv *) nam;

        char *dname;
        struct ndrv_cb *np;
        struct ifnet *ifp;
        char *dname;
        struct ndrv_cb *np;
        struct ifnet *ifp;

-    int        result;
+       int result;

 
 

-       if TAILQ_EMPTY(&ifnet_head)
-               return(EADDRNOTAVAIL); /* Quick sanity check */
+       if (TAILQ_EMPTY(&ifnet_head)) {
+               return EADDRNOTAVAIL;        /* Quick sanity check */
+       }

        np = sotondrvcb(so);
        np = sotondrvcb(so);

-       if (np == 0)
+       if (np == 0) {

                return EINVAL;
                return EINVAL;

+       }

 
 

-       if (np->nd_laddr)
-               return EINVAL;                  /* XXX */
-
+       if (np->nd_laddr) {
+               return EINVAL;                  /* XXX */
+       }

        /* I think we just latch onto a copy here; the caller frees */
        np->nd_laddr = _MALLOC(sizeof(struct sockaddr_ndrv), M_IFADDR, M_WAITOK);
        /* I think we just latch onto a copy here; the caller frees */
        np->nd_laddr = _MALLOC(sizeof(struct sockaddr_ndrv), M_IFADDR, M_WAITOK);

-       if (np->nd_laddr == NULL)
-               return(ENOMEM);
+       if (np->nd_laddr == NULL) {
+               return ENOMEM;
+       }

        bcopy((caddr_t) sa, (caddr_t) np->nd_laddr, sizeof(struct sockaddr_ndrv));
        dname = (char *) sa->snd_name;
        np->nd_laddr->snd_len = sizeof(struct sockaddr_ndrv);
        bcopy((caddr_t) sa, (caddr_t) np->nd_laddr, sizeof(struct sockaddr_ndrv));
        dname = (char *) sa->snd_name;
        np->nd_laddr->snd_len = sizeof(struct sockaddr_ndrv);

-       if (*dname == '\0')
-               return(EINVAL);
+       if (*dname == '\0') {
+               return EINVAL;
+       }

 #if NDRV_DEBUG
        printf("NDRV bind: %x, %x, %s\n", so, np, dname);
 #endif
 #if NDRV_DEBUG
        printf("NDRV bind: %x, %x, %s\n", so, np, dname);
 #endif


@@ -347,19 +383,20 @@ ndrv_bind(struct socket *so, struct sockaddr *nam, __unused struct proc *p)
         */
        ifnet_head_lock_shared();
        TAILQ_FOREACH(ifp, &ifnet_head, if_link) {
         */
        ifnet_head_lock_shared();
        TAILQ_FOREACH(ifp, &ifnet_head, if_link) {

-               if (name_cmp(ifp, dname) == 0)
+               if (name_cmp(ifp, dname) == 0) {

                        break;
                        break;

+               }

        }
        ifnet_head_done();
 
        }
        ifnet_head_done();
 

-       if (ifp == NULL)
-               return(EADDRNOTAVAIL);
+       if (ifp == NULL) {
+               return EADDRNOTAVAIL;
+       }

 
        // PPP doesn't support PF_NDRV.
 
        // PPP doesn't support PF_NDRV.

-       if (ifnet_family(ifp) != APPLE_IF_FAM_PPP)
-       {
+       if (ifnet_family(ifp) != APPLE_IF_FAM_PPP) {

                /* NDRV on this interface */
                /* NDRV on this interface */

-               struct ifnet_attach_proto_param ndrv_proto;
+               struct ifnet_attach_proto_param ndrv_proto;

                result = 0;
                bzero(&ndrv_proto, sizeof(ndrv_proto));
                ndrv_proto.event = ndrv_event;
                result = 0;
                bzero(&ndrv_proto, sizeof(ndrv_proto));
                ndrv_proto.event = ndrv_event;


@@ -372,16 +409,15 @@ ndrv_bind(struct socket *so, struct sockaddr *nam, __unused struct proc *p)
                        return result;
                }
                np->nd_proto_family = PF_NDRV;
                        return result;
                }
                np->nd_proto_family = PF_NDRV;

-       }
-       else {
+       } else {

                np->nd_proto_family = 0;
        }
 
        np->nd_if = ifp;
                np->nd_proto_family = 0;
        }
 
        np->nd_if = ifp;

-    np->nd_family = ifnet_family(ifp);
-    np->nd_unit = ifnet_unit(ifp);
+       np->nd_family = ifnet_family(ifp);
+       np->nd_unit = ifnet_unit(ifp);

 
 

-       return(0);
+       return 0;

 }
 
 static int
 }
 
 static int


@@ -389,11 +425,13 @@ ndrv_disconnect(struct socket *so)
 {
        struct ndrv_cb *np = sotondrvcb(so);
 
 {
        struct ndrv_cb *np = sotondrvcb(so);
 

-       if (np == 0)
+       if (np == 0) {

                return EINVAL;
                return EINVAL;

+       }

 
 

-       if (np->nd_faddr == 0)
+       if (np->nd_faddr == 0) {

                return ENOTCONN;
                return ENOTCONN;

+       }

 
        ndrv_do_disconnect(np);
        return 0;
 
        ndrv_do_disconnect(np);
        return 0;


@@ -417,13 +455,14 @@ ndrv_shutdown(struct socket *so)
  */
 static int
 ndrv_send(struct socket *so, __unused int flags, struct mbuf *m,
  */
 static int
 ndrv_send(struct socket *so, __unused int flags, struct mbuf *m,

-         __unused struct sockaddr *addr, struct mbuf *control,
-         __unused struct proc *p)
+    __unused struct sockaddr *addr, struct mbuf *control,
+    __unused struct proc *p)

 {
        int error;
 
 {
        int error;
 

-       if (control)
+       if (control) {

                return EOPNOTSUPP;
                return EOPNOTSUPP;

+       }

 
        error = ndrv_output(m, so);
        m = NULL;
 
        error = ndrv_output(m, so);
        m = NULL;


@@ -436,8 +475,9 @@ ndrv_abort(struct socket *so)
 {
        struct ndrv_cb *np = sotondrvcb(so);
 
 {
        struct ndrv_cb *np = sotondrvcb(so);
 

-       if (np == 0)
+       if (np == 0) {

                return EINVAL;
                return EINVAL;

+       }

 
        ndrv_do_disconnect(np);
        return 0;
 
        ndrv_do_disconnect(np);
        return 0;


@@ -449,18 +489,21 @@ ndrv_sockaddr(struct socket *so, struct sockaddr **nam)
        struct ndrv_cb *np = sotondrvcb(so);
        int len;
 
        struct ndrv_cb *np = sotondrvcb(so);
        int len;
 

-       if (np == 0)
+       if (np == 0) {

                return EINVAL;
                return EINVAL;

+       }

 
 

-       if (np->nd_laddr == 0)
+       if (np->nd_laddr == 0) {

                return EINVAL;
                return EINVAL;

+       }

 
        len = np->nd_laddr->snd_len;
        MALLOC(*nam, struct sockaddr *, len, M_SONAME, M_WAITOK);
 
        len = np->nd_laddr->snd_len;
        MALLOC(*nam, struct sockaddr *, len, M_SONAME, M_WAITOK);

-       if (*nam == NULL)
+       if (*nam == NULL) {

                return ENOMEM;
                return ENOMEM;

+       }

        bcopy((caddr_t)np->nd_laddr, *nam,
        bcopy((caddr_t)np->nd_laddr, *nam,

-             (unsigned)len);
+           (unsigned)len);

        return 0;
 }
 
        return 0;
 }
 


@@ -471,18 +514,21 @@ ndrv_peeraddr(struct socket *so, struct sockaddr **nam)
        struct ndrv_cb *np = sotondrvcb(so);
        int len;
 
        struct ndrv_cb *np = sotondrvcb(so);
        int len;
 

-       if (np == 0)
+       if (np == 0) {

                return EINVAL;
                return EINVAL;

+       }

 
 

-       if (np->nd_faddr == 0)
+       if (np->nd_faddr == 0) {

                return ENOTCONN;
                return ENOTCONN;

+       }

 
        len = np->nd_faddr->snd_len;
        MALLOC(*nam, struct sockaddr *, len, M_SONAME, M_WAITOK);
 
        len = np->nd_faddr->snd_len;
        MALLOC(*nam, struct sockaddr *, len, M_SONAME, M_WAITOK);

-       if (*nam == NULL)
+       if (*nam == NULL) {

                return ENOMEM;
                return ENOMEM;

+       }

        bcopy((caddr_t)np->nd_faddr, *nam,
        bcopy((caddr_t)np->nd_faddr, *nam,

-             (unsigned)len);
+           (unsigned)len);

        return 0;
 }
 
        return 0;
 }
 


@@ -492,58 +538,59 @@ ndrv_peeraddr(struct socket *so, struct sockaddr **nam)
 static int
 ndrv_ctloutput(struct socket *so, struct sockopt *sopt)
 {
 static int
 ndrv_ctloutput(struct socket *so, struct sockopt *sopt)
 {

-    struct ndrv_cb *np = sotondrvcb(so);
+       struct ndrv_cb *np = sotondrvcb(so);

        int error = 0;
 
        int error = 0;
 

-    switch(sopt->sopt_name)
-    {
-        case NDRV_DELDMXSPEC: /* Delete current spec */
-            /* Verify no parameter was passed */
-            if (sopt->sopt_val != 0 || sopt->sopt_valsize != 0) {
-                /*
-                 * We don't support deleting a specific demux, it's
-                 * all or nothing.
-                 */
-                return EINVAL;
-            }
-            error = ndrv_delspec(np);
-            break;
-        case NDRV_SETDMXSPEC: /* Set protocol spec */
-            error = ndrv_setspec(np, sopt);
-            break;
-        case NDRV_ADDMULTICAST:
-            error = ndrv_do_add_multicast(np, sopt);
-            break;
-        case NDRV_DELMULTICAST:
-            error = ndrv_do_remove_multicast(np, sopt);
-            break;
-        default:
-            error = ENOTSUP;
-    }
+       switch (sopt->sopt_name) {
+       case NDRV_DELDMXSPEC: /* Delete current spec */
+               /* Verify no parameter was passed */
+               if (sopt->sopt_val != 0 || sopt->sopt_valsize != 0) {
+                       /*
+                        * We don't support deleting a specific demux, it's
+                        * all or nothing.
+                        */
+                       return EINVAL;
+               }
+               error = ndrv_delspec(np);
+               break;
+       case NDRV_SETDMXSPEC: /* Set protocol spec */
+               error = ndrv_setspec(np, sopt);
+               break;
+       case NDRV_ADDMULTICAST:
+               error = ndrv_do_add_multicast(np, sopt);
+               break;
+       case NDRV_DELMULTICAST:
+               error = ndrv_do_remove_multicast(np, sopt);
+               break;
+       default:
+               error = ENOTSUP;
+       }

 #ifdef NDRV_DEBUG
        log(LOG_WARNING, "NDRV CTLOUT: %x returns %d\n", sopt->sopt_name,
            error);
 #endif
 #ifdef NDRV_DEBUG
        log(LOG_WARNING, "NDRV CTLOUT: %x returns %d\n", sopt->sopt_name,
            error);
 #endif

-       return(error);
+       return error;

 }
 
 static int
 ndrv_do_detach(struct ndrv_cb *np)
 {
 }
 
 static int
 ndrv_do_detach(struct ndrv_cb *np)
 {

-    struct ndrv_cb*    cur_np = NULL;
-    struct socket *so = np->nd_socket;
-    int error = 0;
-    struct ifnet * ifp;
+       struct ndrv_cb*     cur_np = NULL;
+       struct socket *so = np->nd_socket;
+       int error = 0;
+       struct ifnet * ifp;

 
 #if NDRV_DEBUG
        printf("NDRV detach: %x, %x\n", so, np);
 #endif
 
 #if NDRV_DEBUG
        printf("NDRV detach: %x, %x\n", so, np);
 #endif

-    ndrv_remove_all_multicast(np);
+       ndrv_remove_all_multicast(np);
+
+       /* Remove from the linked list of control blocks */
+       LCK_MTX_ASSERT(ndrvdomain->dom_mtx, LCK_MTX_ASSERT_OWNED);
+       TAILQ_REMOVE(&ndrvl, np, nd_next);

 
 

-    ifp = np->nd_if;
-    /* Remove from the linked list of control blocks */
-    TAILQ_REMOVE(&ndrvl, np, nd_next);
-    if (ifp != NULL) {
+       ifp = np->nd_if;
+       if (ifp != NULL) {

                u_int32_t proto_family = np->nd_proto_family;
 
                if (proto_family != PF_NDRV && proto_family != 0) {
                u_int32_t proto_family = np->nd_proto_family;
 
                if (proto_family != PF_NDRV && proto_family != 0) {


@@ -553,9 +600,10 @@ ndrv_do_detach(struct ndrv_cb *np)
                }
 
                /* Check if this is the last socket attached to this interface */
                }
 
                /* Check if this is the last socket attached to this interface */

+               LCK_MTX_ASSERT(ndrvdomain->dom_mtx, LCK_MTX_ASSERT_OWNED);

                TAILQ_FOREACH(cur_np, &ndrvl, nd_next) {
                        if (cur_np->nd_family == np->nd_family &&
                TAILQ_FOREACH(cur_np, &ndrvl, nd_next) {
                        if (cur_np->nd_family == np->nd_family &&

-                               cur_np->nd_unit == np->nd_unit) {
+                           cur_np->nd_unit == np->nd_unit) {

                                break;
                        }
                }
                                break;
                        }
                }


@@ -567,11 +615,11 @@ ndrv_do_detach(struct ndrv_cb *np)
                        socket_lock(so, 0);
                }
        }
                        socket_lock(so, 0);
                }
        }

-       if (np->nd_laddr != NULL) {
-               FREE((caddr_t)np->nd_laddr, M_IFADDR);
+       if (np->nd_laddr != NULL) {
+               FREE(np->nd_laddr, M_IFADDR);

                np->nd_laddr = NULL;
        }
                np->nd_laddr = NULL;
        }

-       FREE((caddr_t)np, M_PCB);
+       FREE(np, M_PCB);

        so->so_pcb = 0;
        so->so_flags |= SOF_PCBCLEARING;
        sofree(so);
        so->so_pcb = 0;
        so->so_flags |= SOF_PCBCLEARING;
        sofree(so);


@@ -585,9 +633,8 @@ ndrv_do_disconnect(struct ndrv_cb *np)
 #if NDRV_DEBUG
        printf("NDRV disconnect: %x\n", np);
 #endif
 #if NDRV_DEBUG
        printf("NDRV disconnect: %x\n", np);
 #endif

-       if (np->nd_faddr)
-       {
-        FREE(np->nd_faddr, M_IFADDR);
+       if (np->nd_faddr) {
+               FREE(np->nd_faddr, M_IFADDR);

                np->nd_faddr = 0;
        }
        /*
                np->nd_faddr = 0;
        }
        /*


@@ -595,34 +642,39 @@ ndrv_do_disconnect(struct ndrv_cb *np)
         * so check for SOF_MP_SUBFLOW socket flag before detaching the PCB;
         * when the socket is closed for real, SOF_MP_SUBFLOW would be cleared.
         */
         * so check for SOF_MP_SUBFLOW socket flag before detaching the PCB;
         * when the socket is closed for real, SOF_MP_SUBFLOW would be cleared.
         */

-       if (!(so->so_flags & SOF_MP_SUBFLOW) && (so->so_state & SS_NOFDREF))
+       if (!(so->so_flags & SOF_MP_SUBFLOW) && (so->so_state & SS_NOFDREF)) {

                ndrv_do_detach(np);
                ndrv_do_detach(np);

+       }

        soisdisconnected(so);
        soisdisconnected(so);

-       return(0);
+       return 0;

 }
 
 /* Hackery - return a string version of a decimal number */
 static void
 sprint_d(u_int n, char *buf, int buflen)
 }
 
 /* Hackery - return a string version of a decimal number */
 static void
 sprint_d(u_int n, char *buf, int buflen)

-{      char dbuf[IFNAMSIZ];
-       char *cp = dbuf+IFNAMSIZ-1;
+{
+       char dbuf[IFNAMSIZ];
+       char *cp = dbuf + IFNAMSIZ - 1;

 
 

-        *cp = 0;
-        do {   buflen--;
+       *cp = 0;
+       do {
+               buflen--;

                cp--;
                cp--;

-                *cp = "0123456789"[n % 10];
-                n /= 10;
-        } while (n != 0 && buflen > 0);
-       strlcpy(buf, cp, IFNAMSIZ-buflen);
-        return;
+               *cp = "0123456789"[n % 10];
+               n /= 10;
+       } while (n != 0 && buflen > 0);
+       strlcpy(buf, cp, IFNAMSIZ - buflen);
+       return;

 }
 
 /*
  * Try to compare a device name (q) with one of the funky ifnet
  *  device names (ifp).
  */
 }
 
 /*
  * Try to compare a device name (q) with one of the funky ifnet
  *  device names (ifp).
  */

-static int name_cmp(struct ifnet *ifp, char *q)
-{      char *r;
+static int
+name_cmp(struct ifnet *ifp, char *q)
+{
+       char *r;

        int len;
        char buf[IFNAMSIZ];
 
        int len;
        char buf[IFNAMSIZ];
 


@@ -630,11 +682,11 @@ static int name_cmp(struct ifnet *ifp, char *q)
        len = strlen(ifnet_name(ifp));
        strlcpy(r, ifnet_name(ifp), IFNAMSIZ);
        r += len;
        len = strlen(ifnet_name(ifp));
        strlcpy(r, ifnet_name(ifp), IFNAMSIZ);
        r += len;

-       sprint_d(ifnet_unit(ifp), r, IFNAMSIZ-(r-buf));
+       sprint_d(ifnet_unit(ifp), r, IFNAMSIZ - (r - buf));

 #if NDRV_DEBUG
        printf("Comparing %s, %s\n", buf, q);
 #endif
 #if NDRV_DEBUG
        printf("Comparing %s, %s\n", buf, q);
 #endif

-       return(strncmp(buf, q, IFNAMSIZ));
+       return strncmp(buf, q, IFNAMSIZ);

 }
 
 #if 0
 }
 
 #if 0


@@ -645,15 +697,16 @@ static int name_cmp(struct ifnet *ifp, char *q)
 void
 ndrv_flushq(struct ifqueue *q)
 {
 void
 ndrv_flushq(struct ifqueue *q)
 {

-    struct mbuf *m;
-       for (;;)
-       {
+       struct mbuf *m;
+       for (;;) {

                IF_DEQUEUE(q, m);
                IF_DEQUEUE(q, m);

-               if (m == NULL)
+               if (m == NULL) {

                        break;
                        break;

+               }

                IF_DROP(q);
                IF_DROP(q);

-               if (m)
+               if (m) {

                        m_freem(m);
                        m_freem(m);

+               }

        }
 }
 #endif
        }
 }
 #endif


@@ -661,45 +714,50 @@ ndrv_flushq(struct ifqueue *q)
 int
 ndrv_setspec(struct ndrv_cb *np, struct sockopt *sopt)
 {
 int
 ndrv_setspec(struct ndrv_cb *np, struct sockopt *sopt)
 {

-       struct ifnet_attach_proto_param proto_param;
-       struct ndrv_protocol_desc       ndrvSpec;
-       struct ndrv_demux_desc*         ndrvDemux = NULL;
-       int                                                     error = 0;
-       struct socket *                         so = np->nd_socket;
-       user_addr_t                                     user_addr;
+       struct ifnet_attach_proto_param proto_param;
+       struct ndrv_protocol_desc       ndrvSpec;
+       struct ndrv_demux_desc*         ndrvDemux = NULL;
+       int                                                     error = 0;
+       struct socket *                         so = np->nd_socket;
+       user_addr_t                                     user_addr;

 
        /* Sanity checking */
 
        /* Sanity checking */

-       if (np->nd_proto_family != PF_NDRV)
+       if (np->nd_proto_family != PF_NDRV) {

                return EBUSY;
                return EBUSY;

-       if (np->nd_if == NULL)
+       }
+       if (np->nd_if == NULL) {

                return EINVAL;
                return EINVAL;

+       }

 
        /* Copy the ndrvSpec */
        if (proc_is64bit(sopt->sopt_p)) {
 
        /* Copy the ndrvSpec */
        if (proc_is64bit(sopt->sopt_p)) {

-               struct ndrv_protocol_desc64     ndrvSpec64;
+               struct ndrv_protocol_desc64     ndrvSpec64;

 
 

-               if (sopt->sopt_valsize != sizeof(ndrvSpec64))
+               if (sopt->sopt_valsize != sizeof(ndrvSpec64)) {

                        return EINVAL;
                        return EINVAL;

+               }

 
                error = sooptcopyin(sopt, &ndrvSpec64, sizeof(ndrvSpec64), sizeof(ndrvSpec64));
 
                error = sooptcopyin(sopt, &ndrvSpec64, sizeof(ndrvSpec64), sizeof(ndrvSpec64));

-               if (error != 0)
+               if (error != 0) {

                        return error;
                        return error;

+               }

 
                ndrvSpec.version         = ndrvSpec64.version;
                ndrvSpec.protocol_family = ndrvSpec64.protocol_family;
                ndrvSpec.demux_count     = ndrvSpec64.demux_count;
 
                user_addr = ndrvSpec64.demux_list;
 
                ndrvSpec.version         = ndrvSpec64.version;
                ndrvSpec.protocol_family = ndrvSpec64.protocol_family;
                ndrvSpec.demux_count     = ndrvSpec64.demux_count;
 
                user_addr = ndrvSpec64.demux_list;

-       }
-       else {
-               struct ndrv_protocol_desc32     ndrvSpec32;
+       } else {
+               struct ndrv_protocol_desc32     ndrvSpec32;

 
 

-               if (sopt->sopt_valsize != sizeof(ndrvSpec32))
+               if (sopt->sopt_valsize != sizeof(ndrvSpec32)) {

                        return EINVAL;
                        return EINVAL;

+               }

 
                error = sooptcopyin(sopt, &ndrvSpec32, sizeof(ndrvSpec32), sizeof(ndrvSpec32));
 
                error = sooptcopyin(sopt, &ndrvSpec32, sizeof(ndrvSpec32), sizeof(ndrvSpec32));

-               if (error != 0)
+               if (error != 0) {

                        return error;
                        return error;

+               }

 
                ndrvSpec.version         = ndrvSpec32.version;
                ndrvSpec.protocol_family = ndrvSpec32.protocol_family;
 
                ndrvSpec.version         = ndrvSpec32.version;
                ndrvSpec.protocol_family = ndrvSpec32.protocol_family;


@@ -709,72 +767,74 @@ ndrv_setspec(struct ndrv_cb *np, struct sockopt *sopt)
        }
 
        /* Verify the parameter */
        }
 
        /* Verify the parameter */

-       if (ndrvSpec.version > NDRV_PROTOCOL_DESC_VERS)
+       if (ndrvSpec.version > NDRV_PROTOCOL_DESC_VERS) {

                return ENOTSUP; // version is too new!
                return ENOTSUP; // version is too new!

-       else if (ndrvSpec.version < 1)
+       } else if (ndrvSpec.version < 1) {

                return EINVAL; // version is not valid
                return EINVAL; // version is not valid

-       else if (ndrvSpec.demux_count > NDRV_PROTODEMUX_COUNT || ndrvSpec.demux_count == 0)
+       } else if (ndrvSpec.demux_count > NDRV_PROTODEMUX_COUNT || ndrvSpec.demux_count == 0) {

                return EINVAL; // demux_count is not valid
                return EINVAL; // demux_count is not valid

-
+       }

        bzero(&proto_param, sizeof(proto_param));
        proto_param.demux_count = ndrvSpec.demux_count;
 
        /* Allocate storage for demux array */
        MALLOC(ndrvDemux, struct ndrv_demux_desc*, proto_param.demux_count *
        bzero(&proto_param, sizeof(proto_param));
        proto_param.demux_count = ndrvSpec.demux_count;
 
        /* Allocate storage for demux array */
        MALLOC(ndrvDemux, struct ndrv_demux_desc*, proto_param.demux_count *

-                  sizeof(struct ndrv_demux_desc), M_TEMP, M_WAITOK);
-       if (ndrvDemux == NULL)
+           sizeof(struct ndrv_demux_desc), M_TEMP, M_WAITOK);
+       if (ndrvDemux == NULL) {

                return ENOMEM;
                return ENOMEM;

+       }

 
        /* Allocate enough ifnet_demux_descs */
        MALLOC(proto_param.demux_array, struct ifnet_demux_desc*,
 
        /* Allocate enough ifnet_demux_descs */
        MALLOC(proto_param.demux_array, struct ifnet_demux_desc*,

-                  sizeof(*proto_param.demux_array) * ndrvSpec.demux_count,
-                  M_TEMP, M_WAITOK);
-       if (proto_param.demux_array == NULL)
+           sizeof(*proto_param.demux_array) * ndrvSpec.demux_count,
+           M_TEMP, M_WAITOK);
+       if (proto_param.demux_array == NULL) {

                error = ENOMEM;
                error = ENOMEM;

+       }

 
 

-       if (error == 0)
-       {
+       if (error == 0) {

                /* Copy the ndrv demux array from userland */
                error = copyin(user_addr, ndrvDemux,
                /* Copy the ndrv demux array from userland */
                error = copyin(user_addr, ndrvDemux,

-                                          ndrvSpec.demux_count * sizeof(struct ndrv_demux_desc));
+                   ndrvSpec.demux_count * sizeof(struct ndrv_demux_desc));

                ndrvSpec.demux_list = ndrvDemux;
        }
 
                ndrvSpec.demux_list = ndrvDemux;
        }
 

-       if (error == 0)
-       {
+       if (error == 0) {

                /* At this point, we've at least got enough bytes to start looking around */
                /* At this point, we've at least got enough bytes to start looking around */

-               u_int32_t       demuxOn = 0;
+               u_int32_t       demuxOn = 0;

 
                proto_param.demux_count = ndrvSpec.demux_count;
                proto_param.input = ndrv_input;
                proto_param.event = ndrv_event;
 
 
                proto_param.demux_count = ndrvSpec.demux_count;
                proto_param.input = ndrv_input;
                proto_param.event = ndrv_event;
 

-               for (demuxOn = 0; demuxOn < ndrvSpec.demux_count; demuxOn++)
-               {
+               for (demuxOn = 0; demuxOn < ndrvSpec.demux_count; demuxOn++) {

                        /* Convert an ndrv_demux_desc to a ifnet_demux_desc */
                        error = ndrv_to_ifnet_demux(&ndrvSpec.demux_list[demuxOn],
                        /* Convert an ndrv_demux_desc to a ifnet_demux_desc */
                        error = ndrv_to_ifnet_demux(&ndrvSpec.demux_list[demuxOn],

-                                                                               &proto_param.demux_array[demuxOn]);
-                       if (error)
+                           &proto_param.demux_array[demuxOn]);
+                       if (error) {

                                break;
                                break;

+                       }

                }
        }
 
                }
        }
 

-       if (error == 0)
-       {
+       if (error == 0) {

                /* We've got all our ducks lined up...lets attach! */
                socket_unlock(so, 0);
                error = ifnet_attach_protocol(np->nd_if, ndrvSpec.protocol_family,
                /* We've got all our ducks lined up...lets attach! */
                socket_unlock(so, 0);
                error = ifnet_attach_protocol(np->nd_if, ndrvSpec.protocol_family,

-                                                                         &proto_param);
+                   &proto_param);

                socket_lock(so, 0);
                socket_lock(so, 0);

-               if (error == 0)
+               if (error == 0) {

                        np->nd_proto_family = ndrvSpec.protocol_family;
                        np->nd_proto_family = ndrvSpec.protocol_family;

+               }

        }
 
        /* Free any memory we've allocated */
        }
 
        /* Free any memory we've allocated */

-       if (proto_param.demux_array)
+       if (proto_param.demux_array) {

                FREE(proto_param.demux_array, M_TEMP);
                FREE(proto_param.demux_array, M_TEMP);

-       if (ndrvDemux)
+       }
+       if (ndrvDemux) {

                FREE(ndrvDemux, M_TEMP);
                FREE(ndrvDemux, M_TEMP);

+       }

 
        return error;
 }
 
        return error;
 }


@@ -783,38 +843,37 @@ ndrv_setspec(struct ndrv_cb *np, struct sockopt *sopt)
 int
 ndrv_to_ifnet_demux(struct ndrv_demux_desc* ndrv, struct ifnet_demux_desc* ifdemux)
 {
 int
 ndrv_to_ifnet_demux(struct ndrv_demux_desc* ndrv, struct ifnet_demux_desc* ifdemux)
 {

-    bzero(ifdemux, sizeof(*ifdemux));
+       bzero(ifdemux, sizeof(*ifdemux));

 
 

-    if (ndrv->type < DLIL_DESC_ETYPE2)
-    {
-        /* using old "type", not supported */
-        return ENOTSUP;
-    }
+       if (ndrv->type < DLIL_DESC_ETYPE2) {
+               /* using old "type", not supported */
+               return ENOTSUP;
+       }

 
 

-    if (ndrv->length > 28)
-    {
-        return EINVAL;
-    }
+       if (ndrv->length > 28) {
+               return EINVAL;
+       }

 
 

-    ifdemux->type = ndrv->type;
-    ifdemux->data = ndrv->data.other;
-    ifdemux->datalen = ndrv->length;
+       ifdemux->type = ndrv->type;
+       ifdemux->data = ndrv->data.other;
+       ifdemux->datalen = ndrv->length;

 
 

-    return 0;
+       return 0;

 }
 
 int
 ndrv_delspec(struct ndrv_cb *np)
 {
 }
 
 int
 ndrv_delspec(struct ndrv_cb *np)
 {

-    int result = 0;
+       int result = 0;

 
 

-    if (np->nd_proto_family == PF_NDRV ||
-       np->nd_proto_family == 0)
-        return EINVAL;
+       if (np->nd_proto_family == PF_NDRV ||
+           np->nd_proto_family == 0) {
+               return EINVAL;
+       }

 
 

-    /* Detach the protocol */
-    result = ifnet_detach_protocol(np->nd_if, np->nd_proto_family);
-    np->nd_proto_family = PF_NDRV;
+       /* Detach the protocol */
+       result = ifnet_detach_protocol(np->nd_if, np->nd_proto_family);
+       np->nd_proto_family = PF_NDRV;

 
        return result;
 }
 
        return result;
 }


@@ -822,16 +881,20 @@ ndrv_delspec(struct ndrv_cb *np)
 struct ndrv_cb *
 ndrv_find_inbound(struct ifnet *ifp, u_int32_t protocol)
 {
 struct ndrv_cb *
 ndrv_find_inbound(struct ifnet *ifp, u_int32_t protocol)
 {

-    struct ndrv_cb* np;
+       struct ndrv_cb* np;

 
 

-       if (protocol == PF_NDRV) return NULL;
+       LCK_MTX_ASSERT(ndrvdomain->dom_mtx, LCK_MTX_ASSERT_OWNED);

 
 

-    TAILQ_FOREACH(np, &ndrvl, nd_next) {
-        if (np->nd_proto_family == protocol &&
-               np->nd_if == ifp) {
-            return np;
-        }
-    }
+       if (protocol == PF_NDRV) {
+               return NULL;
+       }
+
+       TAILQ_FOREACH(np, &ndrvl, nd_next) {
+               if (np->nd_proto_family == protocol &&
+                   np->nd_if == ifp) {
+                       return np;
+               }
+       }

 
        return NULL;
 }
 
        return NULL;
 }


@@ -839,239 +902,233 @@ ndrv_find_inbound(struct ifnet *ifp, u_int32_t protocol)
 static void
 ndrv_handle_ifp_detach(u_int32_t family, short unit)
 {
 static void
 ndrv_handle_ifp_detach(u_int32_t family, short unit)
 {

-    struct ndrv_cb* np;
-    struct ifnet       *ifp = NULL;
-    struct socket *so;
-
-    /* Find all sockets using this interface. */
-    TAILQ_FOREACH(np, &ndrvl, nd_next) {
-        if (np->nd_family == family &&
-            np->nd_unit == unit)
-        {
-            /* This cb is using the detaching interface, but not for long. */
-            /* Let the protocol go */
-            ifp = np->nd_if;
-            if (np->nd_proto_family != 0)
-                ndrv_delspec(np);
-
-            /* Delete the multicasts first */
-            ndrv_remove_all_multicast(np);
-
-            /* Disavow all knowledge of the ifp */
-            np->nd_if = NULL;
-            np->nd_unit = 0;
-            np->nd_family = 0;
-
-                 so = np->nd_socket;
-            /* Make sure sending returns an error */
-               LCK_MTX_ASSERT(ndrvdomain->dom_mtx, LCK_MTX_ASSERT_OWNED);
-            socantsendmore(so);
-            socantrcvmore(so);
-        }
-    }
-
-    /* Unregister our protocol */
-    if (ifp) {
-        ifnet_detach_protocol(ifp, PF_NDRV);
-    }
+       struct ndrv_cb* np;
+       struct ifnet        *ifp = NULL;
+       struct socket *so;
+
+       /* Find all sockets using this interface. */
+       TAILQ_FOREACH(np, &ndrvl, nd_next) {
+               if (np->nd_family == family &&
+                   np->nd_unit == unit) {
+                       /* This cb is using the detaching interface, but not for long. */
+                       /* Let the protocol go */
+                       ifp = np->nd_if;
+                       if (np->nd_proto_family != 0) {
+                               ndrv_delspec(np);
+                       }
+
+                       /* Delete the multicasts first */
+                       ndrv_remove_all_multicast(np);
+
+                       /* Disavow all knowledge of the ifp */
+                       np->nd_if = NULL;
+                       np->nd_unit = 0;
+                       np->nd_family = 0;
+
+                       so = np->nd_socket;
+                       /* Make sure sending returns an error */
+                       LCK_MTX_ASSERT(ndrvdomain->dom_mtx, LCK_MTX_ASSERT_OWNED);
+                       socantsendmore(so);
+                       socantrcvmore(so);
+               }
+       }
+
+       /* Unregister our protocol */
+       if (ifp) {
+               ifnet_detach_protocol(ifp, PF_NDRV);
+       }

 }
 
 static int
 ndrv_do_add_multicast(struct ndrv_cb *np, struct sockopt *sopt)
 {
 }
 
 static int
 ndrv_do_add_multicast(struct ndrv_cb *np, struct sockopt *sopt)
 {

-    struct ndrv_multiaddr*     ndrv_multi;
-    int                                                result;
-
-    if (sopt->sopt_val == 0 || sopt->sopt_valsize < 2 ||
-        sopt->sopt_level != SOL_NDRVPROTO || sopt->sopt_valsize > SOCK_MAXADDRLEN)
-        return EINVAL;
-    if (np->nd_if == NULL)
-        return ENXIO;
-       if (!(np->nd_dlist_cnt < ndrv_multi_max_count))
+       struct ndrv_multiaddr*      ndrv_multi;
+       int                                         result;
+
+       if (sopt->sopt_val == 0 || sopt->sopt_valsize < 2 ||
+           sopt->sopt_level != SOL_NDRVPROTO || sopt->sopt_valsize > SOCK_MAXADDRLEN) {
+               return EINVAL;
+       }
+       if (np->nd_if == NULL) {
+               return ENXIO;
+       }
+       if (!(np->nd_dlist_cnt < ndrv_multi_max_count)) {

                return EPERM;
                return EPERM;

+       }
+
+       // Allocate storage
+       MALLOC(ndrv_multi, struct ndrv_multiaddr*, sizeof(struct ndrv_multiaddr) -
+           sizeof(struct sockaddr) + sopt->sopt_valsize, M_IFADDR, M_WAITOK);
+       if (ndrv_multi == NULL) {
+               return ENOMEM;
+       }
+
+       // Copy in the address
+       result = copyin(sopt->sopt_val, &ndrv_multi->addr, sopt->sopt_valsize);
+
+       // Validate the sockaddr
+       if (result == 0 && sopt->sopt_valsize != ndrv_multi->addr.sa_len) {
+               result = EINVAL;
+       }
+
+       if (result == 0 && ndrv_have_multicast(np, &ndrv_multi->addr)) {
+               result = EEXIST;
+       }

 
 

-    // Allocate storage
-    MALLOC(ndrv_multi, struct ndrv_multiaddr*, sizeof(struct ndrv_multiaddr) -
-        sizeof(struct sockaddr) + sopt->sopt_valsize, M_IFADDR, M_WAITOK);
-    if (ndrv_multi == NULL)
-        return ENOMEM;
-
-    // Copy in the address
-    result = copyin(sopt->sopt_val, &ndrv_multi->addr, sopt->sopt_valsize);
-
-    // Validate the sockaddr
-    if (result == 0 && sopt->sopt_valsize != ndrv_multi->addr.sa_len)
-        result = EINVAL;
-
-    if (result == 0 && ndrv_have_multicast(np, &ndrv_multi->addr))
-        result = EEXIST;
-
-    if (result == 0)
-    {
-        // Try adding the multicast
-        result = ifnet_add_multicast(np->nd_if, &ndrv_multi->addr,
-                                                                &ndrv_multi->ifma);
-    }
-
-    if (result == 0)
-    {
-        // Add to our linked list
-        ndrv_multi->next = np->nd_multiaddrs;
-        np->nd_multiaddrs = ndrv_multi;
+       if (result == 0) {
+               // Try adding the multicast
+               result = ifnet_add_multicast(np->nd_if, &ndrv_multi->addr,
+                   &ndrv_multi->ifma);
+       }
+
+       if (result == 0) {
+               // Add to our linked list
+               ndrv_multi->next = np->nd_multiaddrs;
+               np->nd_multiaddrs = ndrv_multi;

                np->nd_dlist_cnt++;
                np->nd_dlist_cnt++;

-    }
-    else
-    {
-        // Free up the memory, something went wrong
-        FREE(ndrv_multi, M_IFADDR);
-    }
-
-    return result;
+       } else {
+               // Free up the memory, something went wrong
+               FREE(ndrv_multi, M_IFADDR);
+       }
+
+       return result;

 }
 
 static int
 ndrv_do_remove_multicast(struct ndrv_cb *np, struct sockopt *sopt)
 {
 }
 
 static int
 ndrv_do_remove_multicast(struct ndrv_cb *np, struct sockopt *sopt)
 {

-    struct sockaddr*           multi_addr;
-    struct ndrv_multiaddr*     ndrv_entry = NULL;
-    int                                        result;
-
-    if (sopt->sopt_val == 0 || sopt->sopt_valsize < 2 ||
-        sopt->sopt_level != SOL_NDRVPROTO)
-        return EINVAL;
-    if (np->nd_if == NULL || np->nd_dlist_cnt == 0)
-        return ENXIO;
-
-    // Allocate storage
-    MALLOC(multi_addr, struct sockaddr*, sopt->sopt_valsize,
-            M_TEMP, M_WAITOK);
-    if (multi_addr == NULL)
-        return ENOMEM;
-
-    // Copy in the address
-    result = copyin(sopt->sopt_val, multi_addr, sopt->sopt_valsize);
-
-    // Validate the sockaddr
-    if (result == 0 && sopt->sopt_valsize != multi_addr->sa_len)
-        result = EINVAL;
-
-    if (result == 0)
-    {
-        /* Find the old entry */
-        ndrv_entry = ndrv_have_multicast(np, multi_addr);
-
-        if (ndrv_entry == NULL)
-            result = ENOENT;
-    }
-
-    if (result == 0)
-    {
-        // Try deleting the multicast
-        result = ifnet_remove_multicast(ndrv_entry->ifma);
-    }
-
-    if (result == 0)
-    {
-        // Remove from our linked list
-        struct ndrv_multiaddr* cur = np->nd_multiaddrs;
-
-        ifmaddr_release(ndrv_entry->ifma);
-
-        if (cur == ndrv_entry)
-        {
-            np->nd_multiaddrs = cur->next;
-        }
-        else
-        {
-            for (cur = cur->next; cur != NULL; cur = cur->next)
-            {
-                if (cur->next == ndrv_entry)
-                {
-                    cur->next = cur->next->next;
-                    break;
-                }
-            }
-        }
+       struct sockaddr*            multi_addr;
+       struct ndrv_multiaddr*      ndrv_entry = NULL;
+       int                                 result;
+
+       if (sopt->sopt_val == 0 || sopt->sopt_valsize < 2 ||
+           sopt->sopt_level != SOL_NDRVPROTO) {
+               return EINVAL;
+       }
+       if (np->nd_if == NULL || np->nd_dlist_cnt == 0) {
+               return ENXIO;
+       }
+
+       // Allocate storage
+       MALLOC(multi_addr, struct sockaddr*, sopt->sopt_valsize,
+           M_TEMP, M_WAITOK);
+       if (multi_addr == NULL) {
+               return ENOMEM;
+       }
+
+       // Copy in the address
+       result = copyin(sopt->sopt_val, multi_addr, sopt->sopt_valsize);
+
+       // Validate the sockaddr
+       if (result == 0 && sopt->sopt_valsize != multi_addr->sa_len) {
+               result = EINVAL;
+       }
+
+       if (result == 0) {
+               /* Find the old entry */
+               ndrv_entry = ndrv_have_multicast(np, multi_addr);
+
+               if (ndrv_entry == NULL) {
+                       result = ENOENT;
+               }
+       }
+
+       if (result == 0) {
+               // Try deleting the multicast
+               result = ifnet_remove_multicast(ndrv_entry->ifma);
+       }
+
+       if (result == 0) {
+               // Remove from our linked list
+               struct ndrv_multiaddr*  cur = np->nd_multiaddrs;
+
+               ifmaddr_release(ndrv_entry->ifma);
+
+               if (cur == ndrv_entry) {
+                       np->nd_multiaddrs = cur->next;
+               } else {
+                       for (cur = cur->next; cur != NULL; cur = cur->next) {
+                               if (cur->next == ndrv_entry) {
+                                       cur->next = cur->next->next;
+                                       break;
+                               }
+                       }
+               }

 
                np->nd_dlist_cnt--;
 
 
                np->nd_dlist_cnt--;
 

-        // Free the memory
-        FREE(ndrv_entry, M_IFADDR);
-    }
-    FREE(multi_addr, M_TEMP);
+               // Free the memory
+               FREE(ndrv_entry, M_IFADDR);
+       }
+       FREE(multi_addr, M_TEMP);

 
 

-    return result;
+       return result;

 }
 
 static struct ndrv_multiaddr*
 ndrv_have_multicast(struct ndrv_cb *np, struct sockaddr* inAddr)
 {
 }
 
 static struct ndrv_multiaddr*
 ndrv_have_multicast(struct ndrv_cb *np, struct sockaddr* inAddr)
 {

-    struct ndrv_multiaddr*     cur;
-    for (cur = np->nd_multiaddrs; cur != NULL; cur = cur->next)
-    {
-
-        if ((inAddr->sa_len == cur->addr.sa_len) &&
-            (bcmp(&cur->addr, inAddr, inAddr->sa_len) == 0))
-        {
-            // Found a match
-            return cur;
-        }
-    }
-
-    return NULL;
+       struct ndrv_multiaddr*      cur;
+       for (cur = np->nd_multiaddrs; cur != NULL; cur = cur->next) {
+               if ((inAddr->sa_len == cur->addr.sa_len) &&
+                   (bcmp(&cur->addr, inAddr, inAddr->sa_len) == 0)) {
+                       // Found a match
+                       return cur;
+               }
+       }
+
+       return NULL;

 }
 
 static void
 ndrv_remove_all_multicast(struct ndrv_cb* np)
 {
 }
 
 static void
 ndrv_remove_all_multicast(struct ndrv_cb* np)
 {

-    struct ndrv_multiaddr*     cur;
-
-    if (np->nd_if != NULL)
-    {
-        while (np->nd_multiaddrs != NULL)
-        {
-            cur = np->nd_multiaddrs;
-            np->nd_multiaddrs = cur->next;
-
-            ifnet_remove_multicast(cur->ifma);
-            ifmaddr_release(cur->ifma);
-            FREE(cur, M_IFADDR);
-        }
-    }
+       struct ndrv_multiaddr*      cur;
+
+       if (np->nd_if != NULL) {
+               while (np->nd_multiaddrs != NULL) {
+                       cur = np->nd_multiaddrs;
+                       np->nd_multiaddrs = cur->next;
+
+                       ifnet_remove_multicast(cur->ifma);
+                       ifmaddr_release(cur->ifma);
+                       FREE(cur, M_IFADDR);
+               }
+       }

 }
 
 static struct pr_usrreqs ndrv_usrreqs = {
 }
 
 static struct pr_usrreqs ndrv_usrreqs = {

-       .pru_abort =            ndrv_abort,
-       .pru_attach =           ndrv_attach,
-       .pru_bind =             ndrv_bind,
-       .pru_connect =          ndrv_connect,
-       .pru_detach =           ndrv_detach,
-       .pru_disconnect =       ndrv_disconnect,
-       .pru_peeraddr =         ndrv_peeraddr,
-       .pru_send =             ndrv_send,
-       .pru_shutdown =         ndrv_shutdown,
-       .pru_sockaddr =         ndrv_sockaddr,
-       .pru_sosend =           sosend,
-       .pru_soreceive =        soreceive,
+       .pru_abort =            ndrv_abort,
+       .pru_attach =           ndrv_attach,
+       .pru_bind =             ndrv_bind,
+       .pru_connect =          ndrv_connect,
+       .pru_detach =           ndrv_detach,
+       .pru_disconnect =       ndrv_disconnect,
+       .pru_peeraddr =         ndrv_peeraddr,
+       .pru_send =             ndrv_send,
+       .pru_shutdown =         ndrv_shutdown,
+       .pru_sockaddr =         ndrv_sockaddr,
+       .pru_sosend =           sosend,
+       .pru_soreceive =        soreceive,

 };
 
 static struct protosw ndrvsw[] = {
 };
 
 static struct protosw ndrvsw[] = {

-{
-       .pr_type =              SOCK_RAW,
-       .pr_protocol =          NDRVPROTO_NDRV,
-       .pr_flags =             PR_ATOMIC|PR_ADDR,
-       .pr_output =            ndrv_output,
-       .pr_ctloutput =         ndrv_ctloutput,
-       .pr_usrreqs =           &ndrv_usrreqs,
-}
+       {
+               .pr_type =              SOCK_RAW,
+               .pr_protocol =          NDRVPROTO_NDRV,
+               .pr_flags =             PR_ATOMIC | PR_ADDR,
+               .pr_output =            ndrv_output,
+               .pr_ctloutput =         ndrv_ctloutput,
+               .pr_usrreqs =           &ndrv_usrreqs,
+       }

 };
 
 };
 

-static int ndrv_proto_count = (sizeof (ndrvsw) / sizeof (struct protosw));
+static int ndrv_proto_count = (sizeof(ndrvsw) / sizeof(struct protosw));

 
 struct domain ndrvdomain_s = {
 
 struct domain ndrvdomain_s = {

-       .dom_family =           PF_NDRV,
-       .dom_name =             "NetDriver",
-       .dom_init =             ndrv_dominit,
+       .dom_family =           PF_NDRV,
+       .dom_name =             "NetDriver",
+       .dom_init =             ndrv_dominit,

 };
 
 static void
 };
 
 static void


@@ -1085,6 +1142,7 @@ ndrv_dominit(struct domain *dp)
 
        ndrvdomain = dp;
 
 
        ndrvdomain = dp;
 

-       for (i = 0, pr = &ndrvsw[0]; i < ndrv_proto_count; i++, pr++)
+       for (i = 0, pr = &ndrvsw[0]; i < ndrv_proto_count; i++, pr++) {

                net_add_proto(pr, dp, 1);
                net_add_proto(pr, dp, 1);

+       }

 }
 }