FreeBSD/Linux Kernel Cross Reference
sys/bsd/net/ndrv.c

     /*
      * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
      *
      * @APPLE_LICENSE_HEADER_START@
      * 
      * Copyright (c) 1999-2003 Apple Computer, Inc.  All Rights Reserved.
      * 
      * This file contains Original Code and/or Modifications of Original Code
      * as defined in and that are subject to the Apple Public Source License
     * Version 2.0 (the 'License'). You may not use this file except in
     * compliance with the License. Please obtain a copy of the License at
     * http://www.opensource.apple.com/apsl/ and read it before using this
     * file.
     * 
     * The Original Code and all software distributed under the License are
     * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
     * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
     * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
     * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
     * Please see the License for the specific language governing rights and
     * limitations under the License.
     * 
     * @APPLE_LICENSE_HEADER_END@
     */
    /* Copyright (c) 1997, 1998 Apple Computer, Inc. All Rights Reserved */
    /*
     *      @(#)ndrv.c      1.1 (MacOSX) 6/10/43
     * Justin Walker, 970604
     *   AF_NDRV support
     * 980130 - Cleanup, reorg, performance improvemements
     * 000816 - Removal of Y adapter cruft
     */
    
    /*
     * PF_NDRV allows raw access to a specified network device, directly
     *  with a socket.  Expected use involves a socket option to request
     *  protocol packets.  This lets ndrv_output() call dlil_output(), and
     *  lets DLIL find the proper recipient for incoming packets.
     *  The purpose here is for user-mode protocol implementation.
     * Note that "pure raw access" will still be accomplished with BPF.
     *
     * In addition to the former use, when combined with socket NKEs,
     * PF_NDRV permits a fairly flexible mechanism for implementing
     * strange protocol support.  One of the main ones will be the
     * BlueBox/Classic Shared IP Address support.
     */
    #include <mach/mach_types.h>
    
    #include <sys/param.h>
    #include <sys/systm.h>
    #include <sys/kernel.h>
    #include <sys/malloc.h>
    #include <sys/mbuf.h>
    #include <sys/protosw.h>
    #include <sys/domain.h>
    #include <sys/socket.h>
    #include <sys/socketvar.h>
    #include <sys/ioctl.h>
    #include <sys/errno.h>
    #include <sys/syslog.h>
    #include <sys/proc.h>
    
    #include <kern/queue.h>
    
    #include <net/ndrv.h>
    #include <net/netisr.h>
    #include <net/route.h>
    #include <net/if_llc.h>
    #include <net/if_dl.h>
    #include <net/if_types.h>
    #include <net/ndrv_var.h>
    
    #if INET
    #include <netinet/in.h>
    #include <netinet/in_var.h>
    #endif
    #include <netinet/if_ether.h>
    
    #include <machine/spl.h>
    
    int ndrv_do_detach(struct ndrv_cb *);
    int ndrv_do_disconnect(struct ndrv_cb *);
    struct ndrv_cb *ndrv_find_tag(unsigned int);
    void ndrv_read_event(struct socket* inSo, caddr_t ref, int waitf);
    int ndrv_setspec(struct ndrv_cb *np, struct sockopt *sopt);
    int ndrv_delspec(struct ndrv_cb *);
    int ndrv_to_dlil_demux(struct ndrv_demux_desc* ndrv, struct dlil_demux_desc* dlil);
    void ndrv_handle_ifp_detach(u_long family, short unit);
    static int ndrv_do_add_multicast(struct ndrv_cb *np, struct sockopt *sopt);
    static int ndrv_do_remove_multicast(struct ndrv_cb *np, struct sockopt *sopt);
    static struct ndrv_multiaddr* ndrv_have_multicast(struct ndrv_cb *np, struct sockaddr* addr);
    static void ndrv_remove_all_multicast(struct ndrv_cb *np);
    
    unsigned long  ndrv_sendspace = NDRVSNDQ;
    unsigned long  ndrv_recvspace = NDRVRCVQ;
    struct ndrv_cb ndrvl;           /* Head of controlblock list */
    
    struct domain ndrvdomain;
    struct protosw ndrvsw;
   static struct socket* ndrv_so;
   
   
   /*
    * Protocol init function for NDRV protocol
    * Init the control block list.
    */
   void
   ndrv_init()
   {
       int retval;
       struct kev_request kev_request;
       
           ndrvl.nd_next = ndrvl.nd_prev = &ndrvl;
       
       /* Create a PF_SYSTEM socket so we can listen for events */
       retval = socreate(PF_SYSTEM, &ndrv_so, SOCK_RAW, SYSPROTO_EVENT);
       if (retval != 0 || ndrv_so == NULL)
           retval = KERN_FAILURE;
       
       /* Install a callback function for the socket */
       ndrv_so->so_rcv.sb_flags |= SB_NOTIFY|SB_UPCALL;
       ndrv_so->so_upcall = ndrv_read_event;
       ndrv_so->so_upcallarg = NULL;
       
       /* Configure the socket to receive the events we're interested in */
       kev_request.vendor_code = KEV_VENDOR_APPLE;
       kev_request.kev_class = KEV_NETWORK_CLASS;
       kev_request.kev_subclass = KEV_DL_SUBCLASS;
       retval = ndrv_so->so_proto->pr_usrreqs->pru_control(ndrv_so, SIOCSKEVFILT, (caddr_t)&kev_request, 0, 0);
       if (retval != 0)
       {
           /*
            * We will not get attaching or detaching events in this case.
            * We should probably prevent any sockets from binding so we won't
            * panic later if the interface goes away.
            */
           log(LOG_WARNING, "PF_NDRV: ndrv_init - failed to set event filter (%d)",
               retval);
       }
   }
   
   /*
    * Protocol output - Called to output a raw network packet directly
    *  to the driver.
    */
   int
   ndrv_output(register struct mbuf *m, register struct socket *so)
   {
       register struct ndrv_cb *np = sotondrvcb(so);
           register struct ifnet *ifp = np->nd_if;
           extern void kprintf(const char *, ...);
       int result = 0;
   
   #if NDRV_DEBUG
           kprintf("NDRV output: %x, %x, %x\n", m, so, np);
   #endif
   
           /*
            * No header is a format error
            */
           if ((m->m_flags&M_PKTHDR) == 0)
                   return(EINVAL);
   
           /*
        * Call DLIL if we can. DLIL is much safer than calling the
        * ifp directly.
        */
       if (np->nd_tag != 0)
           result = dlil_output(np->nd_tag, m, (caddr_t)NULL,
                               (struct sockaddr*)NULL, 1);
       else if (np->nd_send_tag != 0)
           result = dlil_output(np->nd_send_tag, m, (caddr_t)NULL,
                               (struct sockaddr*)NULL, 1);
       else
           result = ENXIO;
           return (result);
   }
   
   /* Our input routine called from DLIL */
   int
   ndrv_input(struct mbuf *m,
              char *frame_header,
              struct ifnet *ifp,
              u_long  dl_tag,
              int sync_ok)
   {
           struct socket *so;
           struct sockaddr_dl ndrvsrc = {sizeof (struct sockaddr_dl), AF_NDRV};
           register struct ndrv_cb *np;
   
   
       /* move packet from if queue to socket */
           /* 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);
   
           np = ndrv_find_tag(dl_tag);
           if (np == NULL)
           {
                   return(ENOENT);
           }
           so = np->nd_socket;
       /* prepend the frame header */
       m = m_prepend(m, ifp->if_data.ifi_hdrlen, M_NOWAIT);
       if (m == NULL)
           return EJUSTRETURN;
       bcopy(frame_header, m->m_data, ifp->if_data.ifi_hdrlen);
           if (sbappendaddr(&(so->so_rcv), (struct sockaddr *)&ndrvsrc,
                            m, (struct mbuf *)0) == 0)
           {
           /* yes, sbappendaddr returns zero if the sockbuff is full... */
           /* caller will free m */
                   return(ENOMEM);
           } else
                   sorwakeup(so);
           return(0);
   }
   
   int
   ndrv_control(struct socket *so, u_long cmd, caddr_t data,
                     struct ifnet *ifp, struct proc *p)
   {
           return (0);
   }
   
   /*
    * Allocate an ndrv control block and some buffer space for the socket
    */
   int
   ndrv_attach(struct socket *so, int proto, struct proc *p)
   {
       int error;
           register struct ndrv_cb *np = sotondrvcb(so);
   
           if ((so->so_state & SS_PRIV) == 0)
                   return(EPERM);
   
   #if NDRV_DEBUG
           kprintf("NDRV attach: %x, %x, %x\n", so, proto, np);
   #endif
   
           if ((error = soreserve(so, ndrv_sendspace, ndrv_recvspace)))
                   return(error);
   
           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 NDRV_DEBUG
           kprintf("NDRV attach: %x, %x, %x\n", so, proto, np);
   #endif
           TAILQ_INIT(&np->nd_dlist);
           np->nd_signature = NDRV_SIGNATURE;
           np->nd_socket = so;
           np->nd_proto.sp_family = so->so_proto->pr_domain->dom_family;
           np->nd_proto.sp_protocol = proto;
       np->nd_if = NULL;
       np->nd_tag = 0;
       np->nd_family = 0;
       np->nd_unit = 0;
           insque((queue_t)np, (queue_t)&ndrvl);
           return(0);
   }
   
   /*
    * Destroy state just before socket deallocation.
    * Flush data or not depending on the options.
    */
   
   int
   ndrv_detach(struct socket *so)
   {
           register struct ndrv_cb *np = sotondrvcb(so);
   
           if (np == 0)
                   return EINVAL;
           return ndrv_do_detach(np);
   }
   
   
   /*
    * If a socket isn't bound to a single address,
    * the ndrv input routine will hand it anything
    * within that protocol family (assuming there's
    * nothing else around it should go to).
    *
    * Don't expect this to be used.
    */
   
   int ndrv_connect(struct socket *so, struct sockaddr *nam, struct proc *p)
   {
           register struct ndrv_cb *np = sotondrvcb(so);
       int result = 0;
   
           if (np == 0)
                   return EINVAL;
   
           if (np->nd_faddr)
                   return EISCONN;
       
       /* Allocate memory to store the remote address */
       MALLOC(np->nd_faddr, struct sockaddr_ndrv*,
                   nam->sa_len, M_IFADDR, M_WAITOK);
       if (result != 0)
           return result;
       if (np->nd_faddr == NULL)
           return ENOMEM;
       
           bcopy((caddr_t) nam, (caddr_t) np->nd_faddr, nam->sa_len);
           soisconnected(so);
           return 0;
   }
   
   /*
    * This is the "driver open" hook - we 'bind' to the
    *  named driver.
    * Here's where we latch onto the driver.
    */
   int
   ndrv_bind(struct socket *so, struct sockaddr *nam, struct proc *p)
   {
       register struct sockaddr_ndrv *sa = (struct sockaddr_ndrv *) nam;
           register char *dname;
           register struct ndrv_cb *np;
           register struct ifnet *ifp;
           extern int name_cmp(struct ifnet *, char *);
       int result;
   
           if TAILQ_EMPTY(&ifnet)
                   return(EADDRNOTAVAIL); /* Quick sanity check */
           np = sotondrvcb(so);
           if (np == 0)
                   return EINVAL;
   
           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);
           if (np->nd_laddr == NULL)
                   return(ENOMEM);
           bcopy((caddr_t) sa, (caddr_t) np->nd_laddr, sizeof(struct sockaddr_ndrv));
           dname = sa->snd_name;
           if (*dname == '\0')
                   return(EINVAL);
   #if NDRV_DEBUG
           kprintf("NDRV bind: %x, %x, %s\n", so, np, dname);
   #endif
           /* Track down the driver and its ifnet structure.
            * There's no internal call for this so we have to dup the code
            *  in if.c/ifconf()
            */
           TAILQ_FOREACH(ifp, &ifnet, if_link) {
                   if (name_cmp(ifp, dname) == 0)
                           break;
           }
   
           if (ifp == NULL)
                   return(EADDRNOTAVAIL);
       
       /* 
        * Loopback demuxing doesn't work with PF_NDRV.
        * The first 4 bytes of the packet must be the
        * protocol ptr. Can't get that from userland.
        */
       if (ifp->if_family == APPLE_IF_FAM_LOOPBACK)
           return (ENOTSUP);
       
       if ((dlil_find_dltag(ifp->if_family, ifp->if_unit,
                            PF_NDRV, &np->nd_send_tag) != 0) &&
           (ifp->if_family != APPLE_IF_FAM_PPP)) {
           /* NDRV isn't registered on this interface, lets change that */
           struct dlil_proto_reg_str       ndrv_proto;
           int     result = 0;
           bzero(&ndrv_proto, sizeof(ndrv_proto));
           TAILQ_INIT(&ndrv_proto.demux_desc_head);
           
           ndrv_proto.interface_family = ifp->if_family;
           ndrv_proto.protocol_family = PF_NDRV;
           ndrv_proto.unit_number = ifp->if_unit;
           
           result = dlil_attach_protocol(&ndrv_proto, &np->nd_send_tag);
           
           /*
            * If the interface does not allow PF_NDRV to attach, we will
            * respect it's wishes. Sending will be disabled. No error is
            * returned because the client may later attach a real protocol
            * that the interface may accept.
            */
           if (result != 0)
               np->nd_send_tag = 0;
       }
       
           np->nd_if = ifp;
       np->nd_family = ifp->if_family;
       np->nd_unit = ifp->if_unit;
       
           return(0);
   }
   
   int
   ndrv_disconnect(struct socket *so)
   {
           register struct ndrv_cb *np = sotondrvcb(so);
   
           if (np == 0)
                   return EINVAL;
   
           if (np->nd_faddr == 0)
                   return ENOTCONN;
   
           ndrv_do_disconnect(np);
           return 0;
   }
   
   /*
    * Accessor function
    */
   struct ifnet*
   ndrv_get_ifp(caddr_t ndrv_pcb)
   {
       struct ndrv_cb*     np = (struct ndrv_cb*)ndrv_pcb;
       
   #if DEBUG
       {
           struct ndrv_cb* temp = ndrvl.nd_next;
           /* Verify existence of pcb */
           for (temp = ndrvl.nd_next; temp != &ndrvl; temp = temp->nd_next)
           {
               if (temp == np)
                   break;
           }
           
           if (temp != np)
           {
               log(LOG_WARNING, "PF_NDRV: ndrv_get_ifp called with invalid ndrv_cb!");
               return NULL;
           }
       }
   #endif
       
       return np->nd_if;
   }
   
   /*
    * Mark the connection as being incapable of further input.
    */
   int
   ndrv_shutdown(struct socket *so)
   {
           socantsendmore(so);
           return 0;
   }
   
   /*
    * Ship a packet out.  The ndrv output will pass it
    *  to the appropriate driver.  The really tricky part
    *  is the destination address...
    */
   int
   ndrv_send(struct socket *so, int flags, struct mbuf *m,
             struct sockaddr *addr, struct mbuf *control,
             struct proc *p)
   {
           int error;
   
           if (control)
                   return EOPNOTSUPP;
   
           error = ndrv_output(m, so);
           m = NULL;
           return error;
   }
   
   
   int
   ndrv_abort(struct socket *so)
   {
           register struct ndrv_cb *np = sotondrvcb(so);
   
           if (np == 0)
                   return EINVAL;
   
           ndrv_do_disconnect(np);
           return 0;
   }
   
   int
   ndrv_sense(struct socket *so, struct stat *sb)
   {
           /*
            * stat: don't bother with a blocksize.
            */
           return (0);
   }
   
   int
   ndrv_sockaddr(struct socket *so, struct sockaddr **nam)
   {
           register struct ndrv_cb *np = sotondrvcb(so);
           int len;
   
           if (np == 0)
                   return EINVAL;
   
           if (np->nd_laddr == 0)
                   return EINVAL;
   
           len = np->nd_laddr->snd_len;
           bcopy((caddr_t)np->nd_laddr, *nam,
                 (unsigned)len);
           return 0;
   }
   
   
   int
   ndrv_peeraddr(struct socket *so, struct sockaddr **nam)
   {
           register struct ndrv_cb *np = sotondrvcb(so);
           int len;
   
           if (np == 0)
                   return EINVAL;
   
           if (np->nd_faddr == 0)
                   return ENOTCONN;
   
           len = np->nd_faddr->snd_len;
           bcopy((caddr_t)np->nd_faddr, *nam,
                 (unsigned)len);
           return 0;
   }
   
   
   /* Control input */
   
   void
   ndrv_ctlinput(int dummy1, struct sockaddr *dummy2, void *dummy3)
   {
   }
   
   /* Control output */
   
   int
   ndrv_ctloutput(struct socket *so, struct sockopt *sopt)
   {
       register struct ndrv_cb *np = sotondrvcb(so);
           int error = 0;
       
       switch(sopt->sopt_name)
       {
           case NDRV_DELDMXSPEC: /* Delete current spec */
               /* Verify no parameter was passed */
               if (sopt->sopt_val != NULL || 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
           return(error);
   }
   
   /* Drain the queues */
   void
   ndrv_drain()
   {
   }
   
   /* Sysctl hook for NDRV */
   int
   ndrv_sysctl()
   {
           return(0);
   }
   
   int
   ndrv_do_detach(register struct ndrv_cb *np)
   {
       struct ndrv_cb*     cur_np = NULL;
       struct socket *so = np->nd_socket;
       struct ndrv_multicast*      next;
       int error = 0;
   
   #if NDRV_DEBUG
           kprintf("NDRV detach: %x, %x\n", so, np);
   #endif
       ndrv_remove_all_multicast(np);
       
       if (np->nd_tag != 0)
       {
           error = dlil_detach_protocol(np->nd_tag);
           if (error)
           {
               log(LOG_WARNING, "NDRV ndrv_do_detach: error %d removing dl_tag %d",
                   error, np->nd_tag);
               return error;
           }
       }
       
       /* Remove from the linked list of control blocks */
           remque((queue_t)np);
       
       if (np->nd_send_tag != 0)
       {
           /* Check if this is the last socket attached to this interface */
           for (cur_np = ndrvl.nd_next; cur_np != &ndrvl; cur_np = cur_np->nd_next)
           {
               if (cur_np->nd_family == np->nd_family &&
                   cur_np->nd_unit == np->nd_unit)
               {
                   break;
               }
           }
           
           /* If there are no other interfaces, detach PF_NDRV from the interface */
           if (cur_np == &ndrvl)
           {
               dlil_detach_protocol(np->nd_send_tag);
           }
       }
       
           FREE((caddr_t)np, M_PCB);
           so->so_pcb = 0;
           sofree(so);
           return error;
   }
   
   int
   ndrv_do_disconnect(register struct ndrv_cb *np)
   {
   #if NDRV_DEBUG
           kprintf("NDRV disconnect: %x\n", np);
   #endif
           if (np->nd_faddr)
           {
           FREE(np->nd_faddr, M_IFADDR);
                   np->nd_faddr = 0;
           }
           if (np->nd_socket->so_state & SS_NOFDREF)
                   ndrv_do_detach(np);
           soisdisconnected(np->nd_socket);
           return(0);
   }
   
   /*
    * Try to compare a device name (q) with one of the funky ifnet
    *  device names (ifp).
    */
   int name_cmp(register struct ifnet *ifp, register char *q)
   {       register char *r;
           register int len;
           char buf[IFNAMSIZ];
           static char *sprint_d();
   
           r = buf;
           len = strlen(ifp->if_name);
           strncpy(r, ifp->if_name, IFNAMSIZ);
           r += len;
           (void)sprint_d(ifp->if_unit, r, IFNAMSIZ-(r-buf));
   #if NDRV_DEBUG
           kprintf("Comparing %s, %s\n", buf, q);
   #endif
           return(strncmp(buf, q, IFNAMSIZ));
   }
   
   /* Hackery - return a string version of a decimal number */
   static char *
   sprint_d(n, buf, buflen)
           u_int n;
           char *buf;
           int buflen;
   {       char dbuf[IFNAMSIZ];
           register char *cp = dbuf+IFNAMSIZ-1;
   
           *cp = 0;
           do {    buflen--;
                   cp--;
                   *cp = "0123456789"[n % 10];
                   n /= 10;
           } while (n != 0 && buflen > 0);
           strncpy(buf, cp, IFNAMSIZ-buflen);
           return (cp);
   }
   
   /*
    * When closing, dump any enqueued mbufs.
    */
   void
   ndrv_flushq(register struct ifqueue *q)
   {
       register struct mbuf *m;
           for (;;)
           {
                   IF_DEQUEUE(q, m);
                   if (m == NULL)
                           break;
                   IF_DROP(q);
                   if (m)
                           m_freem(m);
           }
   }
   
   int
   ndrv_setspec(struct ndrv_cb *np, struct sockopt *sopt)
   {
       struct dlil_proto_reg_str   dlilSpec;
       struct ndrv_protocol_desc   ndrvSpec;
       struct dlil_demux_desc*             dlilDemux = NULL;
       struct ndrv_demux_desc*             ndrvDemux = NULL;
       int                                                 error = 0;
       
       /* Sanity checking */
       if (np->nd_tag)
           return EBUSY;
       if (np->nd_if == NULL)
           return EINVAL;
       if (sopt->sopt_valsize != sizeof(struct ndrv_protocol_desc))
           return EINVAL;
       
       /* Copy the ndrvSpec */
       error = sooptcopyin(sopt, &ndrvSpec, sizeof(struct ndrv_protocol_desc),
                           sizeof(struct ndrv_protocol_desc));
       if (error != 0)
           return error;
       
       /* Verify the parameter */
       if (ndrvSpec.version > NDRV_PROTOCOL_DESC_VERS)
           return ENOTSUP; // version is too new!
       else if (ndrvSpec.version < 1)
           return EINVAL; // version is not valid
       
       /* Allocate storage for demux array */
       MALLOC(ndrvDemux, struct ndrv_demux_desc*,
               ndrvSpec.demux_count * sizeof(struct ndrv_demux_desc), M_TEMP, M_WAITOK);
       if (ndrvDemux == NULL)
           return ENOMEM;
       
       /* Allocate enough dlil_demux_descs */
       MALLOC(dlilDemux, struct dlil_demux_desc*,
               sizeof(*dlilDemux) * ndrvSpec.demux_count, M_TEMP, M_WAITOK);
       if (dlilDemux == NULL)
           error = ENOMEM;
       
       if (error == 0)
       {
           /* Copy the ndrv demux array from userland */
           error = copyin(ndrvSpec.demux_list, ndrvDemux,
                       ndrvSpec.demux_count * sizeof(struct ndrv_demux_desc));
           ndrvSpec.demux_list = ndrvDemux;
       }
       
       if (error == 0)
       {
           /* At this point, we've at least got enough bytes to start looking around */
           u_long  demuxOn = 0;
           
           bzero(&dlilSpec, sizeof(dlilSpec));
           TAILQ_INIT(&dlilSpec.demux_desc_head);
           dlilSpec.interface_family = np->nd_family;
           dlilSpec.unit_number = np->nd_unit;
           dlilSpec.input = ndrv_input;
           dlilSpec.protocol_family = ndrvSpec.protocol_family;
           
           for (demuxOn = 0; demuxOn < ndrvSpec.demux_count; demuxOn++)
           {
               /* Convert an ndrv_demux_desc to a dlil_demux_desc */
               error = ndrv_to_dlil_demux(&ndrvSpec.demux_list[demuxOn], &dlilDemux[demuxOn]);
               if (error)
                   break;
               
               /* Add the dlil_demux_desc to the list */
               TAILQ_INSERT_TAIL(&dlilSpec.demux_desc_head, &dlilDemux[demuxOn], next);
           }
       }
       
       if (error == 0)
       {
           /* We've got all our ducks lined up...lets attach! */
           error = dlil_attach_protocol(&dlilSpec, &np->nd_tag);
       }
       
       /* Free any memory we've allocated */
       if (dlilDemux)
           FREE(dlilDemux, M_TEMP);
       if (ndrvDemux)
           FREE(ndrvDemux, M_TEMP);
       
       return error;
   }
   
   
   int
   ndrv_to_dlil_demux(struct ndrv_demux_desc* ndrv, struct dlil_demux_desc* dlil)
   {
       bzero(dlil, sizeof(*dlil));
       
       if (ndrv->type < DLIL_DESC_ETYPE2)
       {
           /* using old "type", not supported */
           return ENOTSUP;
       }
       
       if (ndrv->length > 28)
       {
           return EINVAL;
       }
       
       dlil->type = ndrv->type;
       dlil->native_type = ndrv->data.other;
       dlil->variants.native_type_length = ndrv->length;
       
       return 0;
   }
   
   int
   ndrv_delspec(struct ndrv_cb *np)
   {
       int result = 0;
       
       if (np->nd_tag == 0)
           return EINVAL;
       
       /* Detach the protocol */
       result = dlil_detach_protocol(np->nd_tag);
       if (result == 0)
       {
           np->nd_tag = 0;
       }
       
           return result;
   }
   
   struct ndrv_cb *
   ndrv_find_tag(unsigned int tag)
   {
       struct ndrv_cb* np;
           int i;
       
       if (tag == 0)
           return NULL;
       
       for (np = ndrvl.nd_next; np != NULL; np = np->nd_next)
       {
           if (np->nd_tag == tag)
           {
               return np;
           }
       }
       
           return NULL;
   }
   
   void ndrv_dominit()
   {
           static int ndrv_dominited = 0;
   
           if (ndrv_dominited == 0 &&
               net_add_proto(&ndrvsw, &ndrvdomain) == 0)
                   ndrv_dominited = 1;
   }
   
   void
   ndrv_read_event(struct socket* so, caddr_t ref, int waitf)
   {
       // Read an event
       struct mbuf *m = NULL;
       struct kern_event_msg *msg;
       struct uio auio = {0};
       int result = 0;
       int flags = 0;
       
       // Get the data
       auio.uio_resid = 1000000; // large number to get all of the data
       flags = MSG_DONTWAIT;
       result = soreceive(so, (struct sockaddr**)NULL, &auio, &m,
           (struct mbuf**)NULL, &flags);
       if (result != 0 || m == NULL)
           return;
       
       // cast the mbuf to a kern_event_msg
       // this is dangerous, doesn't handle linked mbufs
       msg = mtod(m, struct kern_event_msg*);
       
       // check for detaches, assume even filtering is working
       if (msg->event_code == KEV_DL_IF_DETACHING ||
           msg->event_code == KEV_DL_IF_DETACHED)
       {
           struct net_event_data *ev_data;
           ev_data = (struct net_event_data*)msg->event_data;
           ndrv_handle_ifp_detach(ev_data->if_family, ev_data->if_unit);
       }
       
       m_free(m);
   }
   
   void
   ndrv_handle_ifp_detach(u_long family, short unit)
   {
       struct ndrv_cb* np;
       u_long                      dl_tag;
       
       /* Find all sockets using this interface. */
       for (np = ndrvl.nd_next; np != &ndrvl; np = np->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 */
               if (np->nd_tag != 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;
               np->nd_send_tag = 0;
               
               /* Make sure sending returns an error */
               /* Is this safe? Will we drop the funnel? */
               socantsendmore(np->nd_socket);
               socantrcvmore(np->nd_socket);
           }
       }
       
       /* Unregister our protocol */
       if (dlil_find_dltag(family, unit, PF_NDRV, &dl_tag) == 0) {
           dlil_detach_protocol(dl_tag);
       }
   }
   
   static int
   ndrv_do_add_multicast(struct ndrv_cb *np, struct sockopt *sopt)
   {
       struct ndrv_multiaddr*      ndrv_multi;
       int                                         result;
       
       if (sopt->sopt_val == NULL || sopt->sopt_valsize < 2 ||
           sopt->sopt_level != SOL_NDRVPROTO)
           return EINVAL;
       if (np->nd_if == NULL)
           return ENXIO;
       
       // 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 = if_addmulti(np->nd_if, &ndrv_multi->addr, NULL);
       }
       
       if (result == 0)
       {
           // Add to our linked list
           ndrv_multi->next = np->nd_multiaddrs;
           np->nd_multiaddrs = ndrv_multi;
       }
       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)
  {
      struct sockaddr*            multi_addr;
      struct ndrv_multiaddr*      ndrv_entry = NULL;
      int                                 result;
      
      if (sopt->sopt_val == NULL || sopt->sopt_valsize < 2 ||
          sopt->sopt_level != SOL_NDRVPROTO)
          return EINVAL;
      if (np->nd_if == NULL)
          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 = if_delmulti(np->nd_if, &ndrv_entry->addr);
      }
      
      if (result == 0)
      {
          // Remove from our linked list
          struct ndrv_multiaddr*  cur = np->nd_multiaddrs;
          
          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;
                  }
              }
          }
          
          // Free the memory
          FREE(ndrv_entry, M_IFADDR);
      }
      FREE(multi_addr, M_TEMP);
      
      return result;
  }
  
  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;
  }
  
  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;
              
              if_delmulti(np->nd_if, &cur->addr);
              FREE(cur, M_IFADDR);
          }
      }
  }
  
  struct pr_usrreqs ndrv_usrreqs = {
          ndrv_abort, pru_accept_notsupp, ndrv_attach, ndrv_bind,
          ndrv_connect, pru_connect2_notsupp, ndrv_control, ndrv_detach,
          ndrv_disconnect, pru_listen_notsupp, ndrv_peeraddr, pru_rcvd_notsupp,
          pru_rcvoob_notsupp, ndrv_send, ndrv_sense, ndrv_shutdown,
          ndrv_sockaddr, sosend, soreceive, sopoll
  };
  
  struct protosw ndrvsw =
  {       SOCK_RAW, &ndrvdomain, NDRVPROTO_NDRV, PR_ATOMIC|PR_ADDR,
      0, ndrv_output, ndrv_ctlinput, ndrv_ctloutput,
      0, ndrv_init, 0, 0,
      ndrv_drain, ndrv_sysctl, &ndrv_usrreqs
  };
  
  struct domain ndrvdomain =
  {       AF_NDRV, "NetDriver", ndrv_dominit, NULL, NULL,
          NULL,
          NULL, NULL, 0, 0, 0, 0
  };

Cache object: 0a177ebc9e796cac799b82eefcbbcaba