xnu-7195.50.7.100.1.tar.gz

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

diff --git a/bsd/net/ether_inet_pr_module.c b/bsd/net/ether_inet_pr_module.c
index b8820a5a5505178bd4036bd602683663f8035726..9830039bec6c5d074c9c31c600c79243125ace17 100644 (file)
--- a/bsd/net/ether_inet_pr_module.c
+++ b/bsd/net/ether_inet_pr_module.c
@@ -1,8 +1,8 @@
 /*
 /*

- * Copyright (c) 2000-2012 Apple Inc. All rights reserved.
+ * Copyright (c) 2000-2013 Apple Inc. All rights reserved.

  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@

- * 
+ *

  * 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
  * 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


@@ -11,10 +11,10 @@
  * unlawful or unlicensed copies of an Apple operating system, or to
  * circumvent, violate, or enable the circumvention or violation of, any
  * terms of an Apple operating system software license agreement.
  * unlawful or unlicensed copies of an Apple operating system, or to
  * circumvent, violate, or enable the circumvention or violation of, any
  * terms of an Apple operating system software license agreement.

- * 
+ *

  * Please obtain a copy of the License at
  * http://www.opensource.apple.com/apsl/ and read it before using this file.
  * 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,
  * 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,


@@ -22,7 +22,7 @@
  * 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.
  * 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_OSREFERENCE_LICENSE_HEADER_END@
  */
 /*
  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  */
 /*


@@ -74,15 +74,14 @@
 #include <sys/socket.h>
 #include <sys/sockio.h>
 #include <sys/sysctl.h>
 #include <sys/socket.h>
 #include <sys/sockio.h>
 #include <sys/sysctl.h>

-#include <kern/lock.h>

 
 

+#include <net/dlil.h>

 #include <net/if.h>
 #include <net/route.h>
 #include <net/if_llc.h>
 #include <net/if_dl.h>
 #include <net/if_types.h>
 #include <net/kpi_protocol.h>
 #include <net/if.h>
 #include <net/route.h>
 #include <net/if_llc.h>
 #include <net/if_dl.h>
 #include <net/if_types.h>
 #include <net/kpi_protocol.h>

-

 #include <netinet/in.h>
 #include <netinet/in_var.h>
 #include <netinet/if_ether.h>
 #include <netinet/in.h>
 #include <netinet/in_var.h>
 #include <netinet/if_ether.h>


@@ -108,26 +107,27 @@ extern void *kdp_get_interface(void);
 extern void kdp_set_ip_and_mac_addresses(struct in_addr *ipaddr,
     struct ether_addr *macaddr);
 
 extern void kdp_set_ip_and_mac_addresses(struct in_addr *ipaddr,
     struct ether_addr *macaddr);
 

-#define        _ip_copy(dst, src)      \
+#define _ip_copy(dst, src)      \

        bcopy(src, dst, sizeof (struct in_addr))
 
 static void
 ether_inet_arp_input(struct ifnet *ifp, struct mbuf *m)
 {
        struct ether_arp *ea;
        bcopy(src, dst, sizeof (struct in_addr))
 
 static void
 ether_inet_arp_input(struct ifnet *ifp, struct mbuf *m)
 {
        struct ether_arp *ea;

-       struct sockaddr_dl      sender_hw;
-       struct sockaddr_in      sender_ip;
-       struct sockaddr_in      target_ip;
+       struct sockaddr_dl      sender_hw;
+       struct sockaddr_in      sender_ip;
+       struct sockaddr_in      target_ip;

 
 

-       if (mbuf_len(m) < sizeof (*ea) && mbuf_pullup(&m, sizeof (*ea)) != 0)
+       if (mbuf_len(m) < sizeof(*ea) && mbuf_pullup(&m, sizeof(*ea)) != 0) {

                return;
                return;

+       }

 
        ea = mbuf_data(m);
 
        /* Verify this is an ethernet/ip arp and address lengths are correct */
        if (ntohs(ea->arp_hrd) != ARPHRD_ETHER ||
            ntohs(ea->arp_pro) != ETHERTYPE_IP ||
 
        ea = mbuf_data(m);
 
        /* Verify this is an ethernet/ip arp and address lengths are correct */
        if (ntohs(ea->arp_hrd) != ARPHRD_ETHER ||
            ntohs(ea->arp_pro) != ETHERTYPE_IP ||

-           ea->arp_pln != sizeof (struct in_addr) ||
+           ea->arp_pln != sizeof(struct in_addr) ||

            ea->arp_hln != ETHER_ADDR_LEN) {
                mbuf_freem(m);
                return;
            ea->arp_hln != ETHER_ADDR_LEN) {
                mbuf_freem(m);
                return;


@@ -139,15 +139,15 @@ ether_inet_arp_input(struct ifnet *ifp, struct mbuf *m)
                return;
        }
 
                return;
        }
 

-       bzero(&sender_ip, sizeof (sender_ip));
-       sender_ip.sin_len = sizeof (sender_ip);
+       bzero(&sender_ip, sizeof(sender_ip));
+       sender_ip.sin_len = sizeof(sender_ip);

        sender_ip.sin_family = AF_INET;
        _ip_copy(&sender_ip.sin_addr, ea->arp_spa);
        target_ip = sender_ip;
        _ip_copy(&target_ip.sin_addr, ea->arp_tpa);
 
        sender_ip.sin_family = AF_INET;
        _ip_copy(&sender_ip.sin_addr, ea->arp_spa);
        target_ip = sender_ip;
        _ip_copy(&target_ip.sin_addr, ea->arp_tpa);
 

-       bzero(&sender_hw, sizeof (sender_hw));
-       sender_hw.sdl_len = sizeof (sender_hw);
+       bzero(&sender_hw, sizeof(sender_hw));
+       sender_hw.sdl_len = sizeof(sender_hw);

        sender_hw.sdl_family = AF_LINK;
        sender_hw.sdl_type = IFT_ETHER;
        sender_hw.sdl_alen = ETHER_ADDR_LEN;
        sender_hw.sdl_family = AF_LINK;
        sender_hw.sdl_type = IFT_ETHER;
        sender_hw.sdl_alen = ETHER_ADDR_LEN;


@@ -167,13 +167,13 @@ ether_inet_arp_input(struct ifnet *ifp, struct mbuf *m)
  * the ether header, which is provided separately.
  */
 static errno_t
  * the ether header, which is provided separately.
  */
 static errno_t

-ether_inet_input(ifnet_t ifp, protocol_family_t        protocol_family,
+ether_inet_input(ifnet_t ifp, protocol_family_t protocol_family,

     mbuf_t m_list)
 {
 #pragma unused(ifp, protocol_family)
     mbuf_t m_list)
 {
 #pragma unused(ifp, protocol_family)

-       mbuf_t  m;
-       mbuf_t  *tailptr = &m_list;
-       mbuf_t  nextpkt;
+       mbuf_t  m;
+       mbuf_t  *tailptr = &m_list;
+       mbuf_t  nextpkt;

 
        /* Strip ARP and non-IP packets out of the list */
        for (m = m_list; m; m = nextpkt) {
 
        /* Strip ARP and non-IP packets out of the list */
        for (m = m_list; m; m = nextpkt) {


@@ -207,10 +207,11 @@ ether_inet_input(ifnet_t ifp, protocol_family_t   protocol_family,
                } else {
                        /* Pass ARP packets to arp input */
                        m->m_nextpkt = NULL;
                } else {
                        /* Pass ARP packets to arp input */
                        m->m_nextpkt = NULL;

-                       if (eh->ether_type == htons(ETHERTYPE_ARP))
+                       if (eh->ether_type == htons(ETHERTYPE_ARP)) {

                                ether_inet_arp_input(mifp, m);
                                ether_inet_arp_input(mifp, m);

-                       else
+                       } else {

                                mbuf_freem(m);
                                mbuf_freem(m);

+                       }

                }
        }
 
                }
        }
 


@@ -221,7 +222,7 @@ ether_inet_input(ifnet_t ifp, protocol_family_t     protocol_family,
                mbuf_freem_list(m_list);
        }
 
                mbuf_freem_list(m_list);
        }
 

-       return (EJUSTRETURN);
+       return EJUSTRETURN;

 }
 
 static errno_t
 }
 
 static errno_t


@@ -234,8 +235,9 @@ ether_inet_pre_output(ifnet_t ifp, protocol_family_t protocol_family,
        const struct ether_header *eh;
        errno_t result = 0;
 
        const struct ether_header *eh;
        errno_t result = 0;
 

-       if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING))
-               return (ENETDOWN);
+       if ((ifp->if_flags & (IFF_UP | IFF_RUNNING)) != (IFF_UP | IFF_RUNNING)) {
+               return ENETDOWN;
+       }

 
        /*
         * Tell ether_frameout it's ok to loop packet unless negated below.
 
        /*
         * Tell ether_frameout it's ok to loop packet unless negated below.


@@ -248,12 +250,12 @@ ether_inet_pre_output(ifnet_t ifp, protocol_family_t protocol_family,
 
                result = arp_lookup_ip(ifp,
                    (const struct sockaddr_in *)(uintptr_t)(size_t)dst_netaddr,
 
                result = arp_lookup_ip(ifp,
                    (const struct sockaddr_in *)(uintptr_t)(size_t)dst_netaddr,

-                   &ll_dest, sizeof (ll_dest), (route_t)route, *m0);
+                   &ll_dest, sizeof(ll_dest), (route_t)route, *m0);

                if (result == 0) {
                        u_int16_t ethertype_ip = htons(ETHERTYPE_IP);
 
                        bcopy(LLADDR(&ll_dest), edst, ETHER_ADDR_LEN);
                if (result == 0) {
                        u_int16_t ethertype_ip = htons(ETHERTYPE_IP);
 
                        bcopy(LLADDR(&ll_dest), edst, ETHER_ADDR_LEN);

-                       bcopy(&ethertype_ip, type, sizeof (ethertype_ip));
+                       bcopy(&ethertype_ip, type, sizeof(ethertype_ip));

                }
                break;
        }
                }
                break;
        }


@@ -264,18 +266,18 @@ ether_inet_pre_output(ifnet_t ifp, protocol_family_t protocol_family,
                eh = (const struct ether_header *)(uintptr_t)(size_t)
                    dst_netaddr->sa_data;
                (void) memcpy(edst, eh->ether_dhost, 6);
                eh = (const struct ether_header *)(uintptr_t)(size_t)
                    dst_netaddr->sa_data;
                (void) memcpy(edst, eh->ether_dhost, 6);

-               bcopy(&eh->ether_type, type, sizeof (u_short));
+               bcopy(&eh->ether_type, type, sizeof(u_short));

                break;
 
        default:
                break;
 
        default:

-               printf("%s%d: can't handle af%d\n", ifp->if_name, ifp->if_unit,
+               printf("%s: can't handle af%d\n", if_name(ifp),

                    dst_netaddr->sa_family);
 
                result = EAFNOSUPPORT;
                break;
        }
 
                    dst_netaddr->sa_family);
 
                result = EAFNOSUPPORT;
                break;
        }
 

-       return (result);
+       return result;

 }
 
 static errno_t
 }
 
 static errno_t


@@ -287,14 +289,17 @@ ether_inet_resolve_multi(ifnet_t ifp, const struct sockaddr *proto_addr,
        const struct sockaddr_in *sin =
            (const struct sockaddr_in *)(uintptr_t)(size_t)proto_addr;
 
        const struct sockaddr_in *sin =
            (const struct sockaddr_in *)(uintptr_t)(size_t)proto_addr;
 

-       if (proto_addr->sa_family != AF_INET)
-               return (EAFNOSUPPORT);
+       if (proto_addr->sa_family != AF_INET) {
+               return EAFNOSUPPORT;
+       }

 
 

-       if (proto_addr->sa_len < sizeof (struct sockaddr_in))
-               return (EINVAL);
+       if (proto_addr->sa_len < sizeof(struct sockaddr_in)) {
+               return EINVAL;
+       }

 
 

-       if (ll_len < minsize)
-               return (EMSGSIZE);
+       if (ll_len < minsize) {
+               return EMSGSIZE;
+       }

 
        bzero(out_ll, minsize);
        out_ll->sdl_len = minsize;
 
        bzero(out_ll, minsize);
        out_ll->sdl_len = minsize;


@@ -306,7 +311,7 @@ ether_inet_resolve_multi(ifnet_t ifp, const struct sockaddr *proto_addr,
        out_ll->sdl_slen = 0;
        ETHER_MAP_IP_MULTICAST(&sin->sin_addr, LLADDR(out_ll));
 
        out_ll->sdl_slen = 0;
        ETHER_MAP_IP_MULTICAST(&sin->sin_addr, LLADDR(out_ll));
 

-       return (0);
+       return 0;

 }
 
 static errno_t
 }
 
 static errno_t


@@ -317,8 +322,8 @@ ether_inet_prmod_ioctl(ifnet_t ifp, protocol_family_t protocol_family,
        int error = 0;
 
        switch (command) {
        int error = 0;
 
        switch (command) {

-       case SIOCSIFADDR:               /* struct ifaddr pointer */
-       case SIOCAIFADDR: {             /* struct ifaddr pointer */
+       case SIOCSIFADDR:               /* struct ifaddr pointer */
+       case SIOCAIFADDR: {             /* struct ifaddr pointer */

                /*
                 * Note: caller of ifnet_ioctl() passes in pointer to
                 * struct ifaddr as parameter to SIOC{A,S}IFADDR, for
                /*
                 * Note: caller of ifnet_ioctl() passes in pointer to
                 * struct ifaddr as parameter to SIOC{A,S}IFADDR, for


@@ -331,13 +336,15 @@ ether_inet_prmod_ioctl(ifnet_t ifp, protocol_family_t protocol_family,
                        ifnet_ioctl(ifp, 0, SIOCSIFFLAGS, NULL);
                }
 
                        ifnet_ioctl(ifp, 0, SIOCSIFFLAGS, NULL);
                }
 

-               if (ifaddr_address_family(ifa) != AF_INET)
+               if (ifaddr_address_family(ifa) != AF_INET) {

                        break;
                        break;

+               }

 
                inet_arp_init_ifaddr(ifp, ifa);
 
 
                inet_arp_init_ifaddr(ifp, ifa);
 

-               if (command != SIOCSIFADDR)
+               if (command != SIOCSIFADDR) {

                        break;
                        break;

+               }

 
                /*
                 * Register new IP and MAC addresses with the kernel
 
                /*
                 * Register new IP and MAC addresses with the kernel


@@ -349,16 +356,16 @@ ether_inet_prmod_ioctl(ifnet_t ifp, protocol_family_t protocol_family,
                 */
                if ((kdp_get_interface() != 0 &&
                    kdp_get_interface() == ifp->if_softc) ||
                 */
                if ((kdp_get_interface() != 0 &&
                    kdp_get_interface() == ifp->if_softc) ||

-                   (kdp_get_interface() == 0 && ifp->if_unit == 0))
+                   (kdp_get_interface() == 0 && ifp->if_unit == 0)) {

                        kdp_set_ip_and_mac_addresses(&(IA_SIN(ifa)->sin_addr),
                        kdp_set_ip_and_mac_addresses(&(IA_SIN(ifa)->sin_addr),

-                           ifnet_lladdr(ifp));
+                           (struct ether_addr *)IF_LLADDR(ifp));
+               }

                break;
        }
 
                break;
        }
 

-       case SIOCGIFADDR: {             /* struct ifreq */
+       case SIOCGIFADDR: {             /* struct ifreq */

                struct ifreq *ifr = data;
                struct ifreq *ifr = data;

-
-               ifnet_lladdr_copy_bytes(ifp, ifr->ifr_addr.sa_data,
+               ifnet_guarded_lladdr_copy_bytes(ifp, ifr->ifr_addr.sa_data,

                    ETHER_ADDR_LEN);
                break;
        }
                    ETHER_ADDR_LEN);
                break;
        }


@@ -368,7 +375,7 @@ ether_inet_prmod_ioctl(ifnet_t ifp, protocol_family_t protocol_family,
                break;
        }
 
                break;
        }
 

-       return (error);
+       return error;

 }
 
 static void
 }
 
 static void


@@ -378,7 +385,7 @@ ether_inet_event(ifnet_t ifp, protocol_family_t protocol,
 #pragma unused(protocol)
        ifaddr_t *addresses;
 
 #pragma unused(protocol)
        ifaddr_t *addresses;
 

-       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_LINK_ADDRESS_CHANGED) {
            event->kev_class != KEV_NETWORK_CLASS ||
            event->kev_subclass != KEV_DL_SUBCLASS ||
            event->event_code != KEV_DL_LINK_ADDRESS_CHANGED) {


@@ -401,8 +408,8 @@ ether_inet_arp(ifnet_t ifp, u_short arpop, const struct sockaddr_dl *sender_hw,
     const struct sockaddr *sender_proto, const struct sockaddr_dl *target_hw,
     const struct sockaddr *target_proto)
 {
     const struct sockaddr *sender_proto, const struct sockaddr_dl *target_hw,
     const struct sockaddr *target_proto)
 {

-       mbuf_t  m;
-       errno_t result;
+       mbuf_t  m;
+       errno_t result;

        struct ether_header *eh;
        struct ether_arp *ea;
        const struct sockaddr_in *sender_ip =
        struct ether_header *eh;
        struct ether_arp *ea;
        const struct sockaddr_in *sender_ip =


@@ -411,61 +418,61 @@ ether_inet_arp(ifnet_t ifp, u_short arpop, const struct sockaddr_dl *sender_hw,
            (const struct sockaddr_inarp *)(uintptr_t)(size_t)target_proto;
        char *datap;
 
            (const struct sockaddr_inarp *)(uintptr_t)(size_t)target_proto;
        char *datap;
 

-       if (target_ip == NULL)
-               return (EINVAL);
+       if (target_ip == NULL) {
+               return EINVAL;
+       }

 
        if ((sender_ip && sender_ip->sin_family != AF_INET) ||
 
        if ((sender_ip && sender_ip->sin_family != AF_INET) ||

-           target_ip->sin_family != AF_INET)
-               return (EAFNOSUPPORT);
+           target_ip->sin_family != AF_INET) {
+               return EAFNOSUPPORT;
+       }

 
        result = mbuf_gethdr(MBUF_DONTWAIT, MBUF_TYPE_DATA, &m);
 
        result = mbuf_gethdr(MBUF_DONTWAIT, MBUF_TYPE_DATA, &m);

-       if (result != 0)
-               return (result);
+       if (result != 0) {
+               return result;
+       }

 
 

-       mbuf_setlen(m, sizeof (*ea));
-       mbuf_pkthdr_setlen(m, sizeof (*ea));
+       mbuf_setlen(m, sizeof(*ea));
+       mbuf_pkthdr_setlen(m, sizeof(*ea));

 
        /* Move the data pointer in the mbuf to the end, aligned to 4 bytes */
        datap = mbuf_datastart(m);
        datap += mbuf_trailingspace(m);
        datap -= (((uintptr_t)datap) & 0x3);
 
        /* Move the data pointer in the mbuf to the end, aligned to 4 bytes */
        datap = mbuf_datastart(m);
        datap += mbuf_trailingspace(m);
        datap -= (((uintptr_t)datap) & 0x3);

-       mbuf_setdata(m, datap, sizeof (*ea));
+       mbuf_setdata(m, datap, sizeof(*ea));

        ea = mbuf_data(m);
 
        /*
         * Prepend the ethernet header, we will send the raw frame;
         * callee frees the original mbuf when allocation fails.
         */
        ea = mbuf_data(m);
 
        /*
         * Prepend the ethernet header, we will send the raw frame;
         * callee frees the original mbuf when allocation fails.
         */

-       result = mbuf_prepend(&m, sizeof (*eh), MBUF_DONTWAIT);
-       if (result != 0)
-               return (result);
+       result = mbuf_prepend(&m, sizeof(*eh), MBUF_DONTWAIT);
+       if (result != 0) {
+               return result;
+       }

 
        eh = mbuf_data(m);
        eh->ether_type = htons(ETHERTYPE_ARP);
 
 
        eh = mbuf_data(m);
        eh->ether_type = htons(ETHERTYPE_ARP);
 

-#if CONFIG_MACF_NET
-       mac_mbuf_label_associate_linklayer(ifp, m);
-#endif
-

        /* Fill out the arp header */
        ea->arp_pro = htons(ETHERTYPE_IP);
        /* Fill out the arp header */
        ea->arp_pro = htons(ETHERTYPE_IP);

-       ea->arp_hln = sizeof (ea->arp_sha);
-       ea->arp_pln = sizeof (ea->arp_spa);
+       ea->arp_hln = sizeof(ea->arp_sha);
+       ea->arp_pln = sizeof(ea->arp_spa);

        ea->arp_hrd = htons(ARPHRD_ETHER);
        ea->arp_op = htons(arpop);
 
        /* Sender Hardware */
        if (sender_hw != NULL) {
                bcopy(CONST_LLADDR(sender_hw), ea->arp_sha,
        ea->arp_hrd = htons(ARPHRD_ETHER);
        ea->arp_op = htons(arpop);
 
        /* Sender Hardware */
        if (sender_hw != NULL) {
                bcopy(CONST_LLADDR(sender_hw), ea->arp_sha,

-                   sizeof (ea->arp_sha));
+                   sizeof(ea->arp_sha));

        } else {
                ifnet_lladdr_copy_bytes(ifp, ea->arp_sha, ETHER_ADDR_LEN);
        }
        } else {
                ifnet_lladdr_copy_bytes(ifp, ea->arp_sha, ETHER_ADDR_LEN);
        }

-       ifnet_lladdr_copy_bytes(ifp, eh->ether_shost, sizeof (eh->ether_shost));
+       ifnet_lladdr_copy_bytes(ifp, eh->ether_shost, sizeof(eh->ether_shost));

 
        /* Sender IP */
        if (sender_ip != NULL) {
 
        /* Sender IP */
        if (sender_ip != NULL) {

-               bcopy(&sender_ip->sin_addr, ea->arp_spa, sizeof (ea->arp_spa));
+               bcopy(&sender_ip->sin_addr, ea->arp_spa, sizeof(ea->arp_spa));

        } else {
                struct ifaddr *ifa;
 
        } else {
                struct ifaddr *ifa;
 


@@ -477,7 +484,7 @@ ether_inet_arp(ifnet_t ifp, u_short arpop, const struct sockaddr_dl *sender_hw,
                            ifa->ifa_addr->sa_family == AF_INET) {
                                bcopy(&((struct sockaddr_in *)(void *)
                                    ifa->ifa_addr)->sin_addr, ea->arp_spa,
                            ifa->ifa_addr->sa_family == AF_INET) {
                                bcopy(&((struct sockaddr_in *)(void *)
                                    ifa->ifa_addr)->sin_addr, ea->arp_spa,

-                                   sizeof (ea->arp_spa));
+                                   sizeof(ea->arp_spa));

                                IFA_UNLOCK(ifa);
                                break;
                        }
                                IFA_UNLOCK(ifa);
                                break;
                        }


@@ -487,37 +494,49 @@ ether_inet_arp(ifnet_t ifp, u_short arpop, const struct sockaddr_dl *sender_hw,
 
                if (ifa == NULL) {
                        mbuf_freem(m);
 
                if (ifa == NULL) {
                        mbuf_freem(m);

-                       return (ENXIO);
+                       return ENXIO;

                }
        }
 
        /* Target Hardware */
        if (target_hw == NULL) {
                }
        }
 
        /* Target Hardware */
        if (target_hw == NULL) {

-               bzero(ea->arp_tha, sizeof (ea->arp_tha));
+               bzero(ea->arp_tha, sizeof(ea->arp_tha));

                bcopy(etherbroadcastaddr, eh->ether_dhost,
                bcopy(etherbroadcastaddr, eh->ether_dhost,

-                   sizeof (eh->ether_dhost));
+                   sizeof(eh->ether_dhost));
+               m->m_flags |= M_BCAST;

        } else {
                bcopy(CONST_LLADDR(target_hw), ea->arp_tha,
        } else {
                bcopy(CONST_LLADDR(target_hw), ea->arp_tha,

-                   sizeof (ea->arp_tha));
+                   sizeof(ea->arp_tha));

                bcopy(CONST_LLADDR(target_hw), eh->ether_dhost,
                bcopy(CONST_LLADDR(target_hw), eh->ether_dhost,

-                   sizeof (eh->ether_dhost));
+                   sizeof(eh->ether_dhost));
+
+               if (bcmp(eh->ether_dhost, etherbroadcastaddr,
+                   ETHER_ADDR_LEN) == 0) {
+                       m->m_flags |= M_BCAST;
+               }

        }
 
        /* Target IP */
        }
 
        /* Target IP */

-       bcopy(&target_ip->sin_addr, ea->arp_tpa, sizeof (ea->arp_tpa));
+       bcopy(&target_ip->sin_addr, ea->arp_tpa, sizeof(ea->arp_tpa));

 
 

+       /*
+        * PKTF_{INET,INET6}_RESOLVE_RTR are mutually exclusive, so make
+        * sure only one of them is set (just in case.)
+        */
+       m->m_pkthdr.pkt_flags &= ~(PKTF_INET6_RESOLVE | PKTF_RESOLVE_RTR);
+       m->m_pkthdr.pkt_flags |= PKTF_INET_RESOLVE;

        /*
         * If this is an ARP request for a (default) router, mark
         * the packet accordingly so that the driver can find out,
         * in case it needs to perform driver-specific action(s).
         */
        if (arpop == ARPOP_REQUEST && (target_ip->sin_other & SIN_ROUTER)) {
        /*
         * If this is an ARP request for a (default) router, mark
         * the packet accordingly so that the driver can find out,
         * in case it needs to perform driver-specific action(s).
         */
        if (arpop == ARPOP_REQUEST && (target_ip->sin_other & SIN_ROUTER)) {

-               m->m_pkthdr.aux_flags |= MAUXF_INET_RESOLVE_RTR;
-               VERIFY(!(m->m_pkthdr.aux_flags & MAUXF_INET6_RESOLVE_RTR));
+               m->m_pkthdr.pkt_flags |= PKTF_RESOLVE_RTR;

        }
 
        if (ifp->if_eflags & IFEF_TXSTART) {
        }
 
        if (ifp->if_eflags & IFEF_TXSTART) {

-               /* Use control service class if the interface 
+               /*
+                * Use control service class if the interface

                 * supports transmit-start model
                 */
                (void) m_set_service_class(m, MBUF_SC_CTL);
                 * supports transmit-start model
                 */
                (void) m_set_service_class(m, MBUF_SC_CTL);


@@ -525,7 +544,7 @@ ether_inet_arp(ifnet_t ifp, u_short arpop, const struct sockaddr_dl *sender_hw,
 
        ifnet_output_raw(ifp, PF_INET, m);
 
 
        ifnet_output_raw(ifp, PF_INET, m);
 

-       return (0);
+       return 0;

 }
 
 errno_t
 }
 
 errno_t


@@ -536,19 +555,19 @@ ether_attach_inet(struct ifnet *ifp, protocol_family_t proto_family)
        struct ifnet_demux_desc demux[2];
        u_short en_native = htons(ETHERTYPE_IP);
        u_short arp_native = htons(ETHERTYPE_ARP);
        struct ifnet_demux_desc demux[2];
        u_short en_native = htons(ETHERTYPE_IP);
        u_short arp_native = htons(ETHERTYPE_ARP);

-       errno_t error;
+       errno_t error;

 
 

-       bzero(&demux[0], sizeof (demux));
+       bzero(&demux[0], sizeof(demux));

        demux[0].type = DLIL_DESC_ETYPE2;
        demux[0].data = &en_native;
        demux[0].type = DLIL_DESC_ETYPE2;
        demux[0].data = &en_native;

-       demux[0].datalen = sizeof (en_native);
+       demux[0].datalen = sizeof(en_native);

        demux[1].type = DLIL_DESC_ETYPE2;
        demux[1].data = &arp_native;
        demux[1].type = DLIL_DESC_ETYPE2;
        demux[1].data = &arp_native;

-       demux[1].datalen = sizeof (arp_native);
+       demux[1].datalen = sizeof(arp_native);

 
 

-       bzero(&proto, sizeof (proto));
+       bzero(&proto, sizeof(proto));

        proto.demux_list = demux;
        proto.demux_list = demux;

-       proto.demux_count = sizeof (demux) / sizeof (demux[0]);
+       proto.demux_count = sizeof(demux) / sizeof(demux[0]);

        proto.input = ether_inet_input;
        proto.pre_output = ether_inet_pre_output;
        proto.ioctl = ether_inet_prmod_ioctl;
        proto.input = ether_inet_input;
        proto.pre_output = ether_inet_pre_output;
        proto.ioctl = ether_inet_prmod_ioctl;


@@ -558,10 +577,10 @@ ether_attach_inet(struct ifnet *ifp, protocol_family_t proto_family)
 
        error = ifnet_attach_protocol_v2(ifp, proto_family, &proto);
        if (error && error != EEXIST) {
 
        error = ifnet_attach_protocol_v2(ifp, proto_family, &proto);
        if (error && error != EEXIST) {

-               printf("WARNING: %s can't attach ip to %s%d\n", __func__,
-                   ifp->if_name, ifp->if_unit);
+               printf("WARNING: %s can't attach ip to %s\n", __func__,
+                   if_name(ifp));

        }
        }

-       return (error);
+       return error;

 }
 
 void
 }
 
 void