xnu-7195.101.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 12a8ead3cd8dd39822d797088c434997af1727b4..e004477544e2b1df49007962828a34ac54e87594 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-2011 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)      \
-       (*(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;
 
 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;
        sender_ip.sin_family = AF_INET;

-       _ip_copy(&sender_ip.sin_addr, (const struct in_addr *)ea->arp_spa);
+       _ip_copy(&sender_ip.sin_addr, ea->arp_spa);

        target_ip = sender_ip;
        target_ip = sender_ip;

-       _ip_copy(&target_ip.sin_addr, (const struct in_addr *)ea->arp_tpa);
+       _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.


@@ -244,35 +246,38 @@ ether_inet_pre_output(ifnet_t ifp, protocol_family_t protocol_family,
 
        switch (dst_netaddr->sa_family) {
        case AF_INET: {
 
        switch (dst_netaddr->sa_family) {
        case AF_INET: {

-               struct sockaddr_dl ll_dest;
+               struct sockaddr_dl ll_dest = {};

 
                result = arp_lookup_ip(ifp,
 
                result = arp_lookup_ip(ifp,

-                   (const struct sockaddr_in *)dst_netaddr, &ll_dest,
-                   sizeof (ll_dest), (route_t)route, *m0);
+                   (const struct sockaddr_in *)(uintptr_t)(size_t)dst_netaddr,
+                   &ll_dest, sizeof(ll_dest), (route_t)route, *m0);

                if (result == 0) {
                if (result == 0) {

+                       u_int16_t ethertype_ip = htons(ETHERTYPE_IP);
+

                        bcopy(LLADDR(&ll_dest), edst, ETHER_ADDR_LEN);
                        bcopy(LLADDR(&ll_dest), edst, ETHER_ADDR_LEN);

-                       *(u_int16_t *)type = htons(ETHERTYPE_IP);
+                       bcopy(&ethertype_ip, type, sizeof(ethertype_ip));

                }
                }

-       break;
+               break;

        }
 
        case pseudo_AF_HDRCMPLT:
        case AF_UNSPEC:
                m->m_flags &= ~M_LOOP;
        }
 
        case pseudo_AF_HDRCMPLT:
        case AF_UNSPEC:
                m->m_flags &= ~M_LOOP;

-               eh = (const struct ether_header *)dst_netaddr->sa_data;
+               eh = (const struct ether_header *)(uintptr_t)(size_t)
+                   dst_netaddr->sa_data;

                (void) memcpy(edst, eh->ether_dhost, 6);
                (void) memcpy(edst, eh->ether_dhost, 6);

-               *(u_short *)type = eh->ether_type;
+               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


@@ -281,16 +286,20 @@ ether_inet_resolve_multi(ifnet_t ifp, const struct sockaddr *proto_addr,
 {
        static const size_t minsize =
            offsetof(struct sockaddr_dl, sdl_data[0]) + ETHER_ADDR_LEN;
 {
        static const size_t minsize =
            offsetof(struct sockaddr_dl, sdl_data[0]) + ETHER_ADDR_LEN;

-       const struct sockaddr_in *sin = (const struct sockaddr_in *)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;


@@ -302,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


@@ -310,22 +319,33 @@ ether_inet_prmod_ioctl(ifnet_t ifp, protocol_family_t protocol_family,
     u_long command, void *data)
 {
 #pragma unused(protocol_family)
     u_long command, void *data)
 {
 #pragma unused(protocol_family)

-       ifaddr_t ifa = data;
-       struct ifreq *ifr = data;

        int error = 0;
 
        switch (command) {
        int error = 0;
 
        switch (command) {

-       case SIOCSIFADDR:
-       case SIOCAIFADDR:
+       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
+                * legacy reasons.
+                */
+               struct ifaddr *ifa = data;
+

                if (!(ifnet_flags(ifp) & IFF_RUNNING)) {
                        ifnet_set_flags(ifp, IFF_UP, IFF_UP);
                        ifnet_ioctl(ifp, 0, SIOCSIFFLAGS, NULL);
                }
 
                if (!(ifnet_flags(ifp) & IFF_RUNNING)) {
                        ifnet_set_flags(ifp, IFF_UP, IFF_UP);
                        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) {
+                       break;
+               }
+

                /*
                 * Register new IP and MAC addresses with the kernel
                 * debugger if the interface is the same as was registered
                /*
                 * Register new IP and MAC addresses with the kernel
                 * debugger if the interface is the same as was registered


@@ -334,25 +354,28 @@ ether_inet_prmod_ioctl(ifnet_t ifp, protocol_family_t protocol_family,
                 * Do this only for the first address of the interface
                 * and not for aliases.
                 */
                 * Do this only for the first address of the interface
                 * and not for aliases.
                 */

-               if (command == SIOCSIFADDR &&
-                   ((kdp_get_interface() != 0 &&
+               if ((kdp_get_interface() != 0 &&

                    kdp_get_interface() == ifp->if_softc) ||
                    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:
-               ifnet_lladdr_copy_bytes(ifp, ifr->ifr_addr.sa_data,
+       case SIOCGIFADDR: {             /* struct ifreq */
+               struct ifreq *ifr = data;
+               ifnet_guarded_lladdr_copy_bytes(ifp, ifr->ifr_addr.sa_data,

                    ETHER_ADDR_LEN);
                break;
                    ETHER_ADDR_LEN);
                break;

+       }

 
        default:
                error = EOPNOTSUPP;
                break;
        }
 
 
        default:
                error = EOPNOTSUPP;
                break;
        }
 

-       return (error);
+       return error;

 }
 
 static void
 }
 
 static void


@@ -362,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) {


@@ -385,71 +408,71 @@ 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 =

-           (const struct sockaddr_in *)sender_proto;
-       const struct sockaddr_in *target_ip =
-           (const struct sockaddr_in *)target_proto;
+           (const struct sockaddr_in *)(uintptr_t)(size_t)sender_proto;
+       const struct sockaddr_inarp *target_ip =
+           (const struct sockaddr_inarp *)(uintptr_t)(size_t)target_proto;

        char *datap;
 
        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;
 


@@ -459,8 +482,9 @@ ether_inet_arp(ifnet_t ifp, u_short arpop, const struct sockaddr_dl *sender_hw,
                        IFA_LOCK(ifa);
                        if (ifa->ifa_addr != NULL &&
                            ifa->ifa_addr->sa_family == AF_INET) {
                        IFA_LOCK(ifa);
                        if (ifa->ifa_addr != NULL &&
                            ifa->ifa_addr->sa_family == AF_INET) {

-                               bcopy(&((struct sockaddr_in *)ifa->ifa_addr)->
-                                   sin_addr, ea->arp_spa, sizeof(ea->arp_spa));
+                               bcopy(&((struct sockaddr_in *)(void *)
+                                   ifa->ifa_addr)->sin_addr, ea->arp_spa,
+                                   sizeof(ea->arp_spa));

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


@@ -470,28 +494,57 @@ 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)) {
+               m->m_pkthdr.pkt_flags |= PKTF_RESOLVE_RTR;
+       }
+
+       if (ifp->if_eflags & IFEF_TXSTART) {
+               /*
+                * Use control service class if the interface
+                * supports transmit-start model
+                */
+               (void) m_set_service_class(m, MBUF_SC_CTL);
+       }

 
        ifnet_output_raw(ifp, PF_INET, m);
 
 
        ifnet_output_raw(ifp, PF_INET, m);
 

-       return (0);
+       return 0;

 }
 
 errno_t
 }
 
 errno_t


@@ -502,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;


@@ -524,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