xnu-2422.1.72.tar.gz

[apple/xnu.git] / bsd / netinet / udp_usrreq.c

diff --git a/bsd/netinet/udp_usrreq.c b/bsd/netinet/udp_usrreq.c
index e5462393d0df2948afe2af3d2bbd5e46c3e042c0..1b2bd8b1fec4cf81ef82f6c647b3b0745d33fea1 100644 (file)
--- a/bsd/netinet/udp_usrreq.c
+++ b/bsd/netinet/udp_usrreq.c
@@ -1,5 +1,5 @@
 /*
 /*

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


@@ -76,24 +76,27 @@
 #include <net/ntstat.h>
 
 #include <kern/zalloc.h>
 #include <net/ntstat.h>
 
 #include <kern/zalloc.h>

+#include <mach/boolean.h>

 
 #include <net/if.h>
 #include <net/if_types.h>
 #include <net/route.h>
 
 #include <net/if.h>
 #include <net/if_types.h>
 #include <net/route.h>

+#include <net/dlil.h>

 
 #include <netinet/in.h>
 #include <netinet/in_systm.h>
 #include <netinet/ip.h>
 #if INET6
 #include <netinet/ip6.h>
 
 #include <netinet/in.h>
 #include <netinet/in_systm.h>
 #include <netinet/ip.h>
 #if INET6
 #include <netinet/ip6.h>

-#endif
+#endif /* INET6 */

 #include <netinet/in_pcb.h>
 #include <netinet/in_var.h>
 #include <netinet/ip_var.h>
 #if INET6
 #include <netinet6/in6_pcb.h>
 #include <netinet6/ip6_var.h>
 #include <netinet/in_pcb.h>
 #include <netinet/in_var.h>
 #include <netinet/ip_var.h>
 #if INET6
 #include <netinet6/in6_pcb.h>
 #include <netinet6/ip6_var.h>

-#endif
+#include <netinet6/udp6_var.h>
+#endif /* INET6 */

 #include <netinet/ip_icmp.h>
 #include <netinet/icmp_var.h>
 #include <netinet/udp.h>
 #include <netinet/ip_icmp.h>
 #include <netinet/icmp_var.h>
 #include <netinet/udp.h>


@@ -104,91 +107,80 @@
 #include <netinet6/ipsec.h>
 #include <netinet6/esp.h>
 extern int ipsec_bypass;
 #include <netinet6/ipsec.h>
 #include <netinet6/esp.h>
 extern int ipsec_bypass;

-#endif /*IPSEC*/
+extern int esp_udp_encap_port;
+#endif /* IPSEC */

 
 

-
-#define DBG_LAYER_IN_BEG       NETDBG_CODE(DBG_NETUDP, 0)
-#define DBG_LAYER_IN_END       NETDBG_CODE(DBG_NETUDP, 2)
-#define DBG_LAYER_OUT_BEG      NETDBG_CODE(DBG_NETUDP, 1)
-#define DBG_LAYER_OUT_END      NETDBG_CODE(DBG_NETUDP, 3)
-#define DBG_FNC_UDP_INPUT      NETDBG_CODE(DBG_NETUDP, (5 << 8))
-#define DBG_FNC_UDP_OUTPUT     NETDBG_CODE(DBG_NETUDP, (6 << 8) | 1)
+#define        DBG_LAYER_IN_BEG        NETDBG_CODE(DBG_NETUDP, 0)
+#define        DBG_LAYER_IN_END        NETDBG_CODE(DBG_NETUDP, 2)
+#define        DBG_LAYER_OUT_BEG       NETDBG_CODE(DBG_NETUDP, 1)
+#define        DBG_LAYER_OUT_END       NETDBG_CODE(DBG_NETUDP, 3)
+#define        DBG_FNC_UDP_INPUT       NETDBG_CODE(DBG_NETUDP, (5 << 8))
+#define        DBG_FNC_UDP_OUTPUT      NETDBG_CODE(DBG_NETUDP, (6 << 8) | 1)

 
 /*
  * UDP protocol implementation.
  * Per RFC 768, August, 1980.
  */
 #ifndef        COMPAT_42
 
 /*
  * UDP protocol implementation.
  * Per RFC 768, August, 1980.
  */
 #ifndef        COMPAT_42

-static int     udpcksum = 1;
+static int udpcksum = 1;

 #else
 #else

-static int     udpcksum = 0;           /* XXX */
+static int udpcksum = 0;               /* XXX */

 #endif
 #endif

-SYSCTL_INT(_net_inet_udp, UDPCTL_CHECKSUM, checksum, CTLFLAG_RW | CTLFLAG_LOCKED,
-               &udpcksum, 0, "");
-
-static u_int32_t udps_in_sw_cksum;
-SYSCTL_UINT(_net_inet_udp, OID_AUTO, in_sw_cksum, CTLFLAG_RD | CTLFLAG_LOCKED,
-    &udps_in_sw_cksum, 0,
-    "Number of received packets checksummed in software");
-
-static u_int64_t udps_in_sw_cksum_bytes;
-SYSCTL_QUAD(_net_inet_udp, OID_AUTO, in_sw_cksum_bytes, CTLFLAG_RD | CTLFLAG_LOCKED,
-    &udps_in_sw_cksum_bytes,
-    "Amount of received data checksummed in software");
-
-static u_int32_t udps_out_sw_cksum;
-SYSCTL_UINT(_net_inet_udp, OID_AUTO, out_sw_cksum, CTLFLAG_RD | CTLFLAG_LOCKED,
-    &udps_out_sw_cksum, 0,
-    "Number of transmitted packets checksummed in software");
-
-static u_int64_t udps_out_sw_cksum_bytes;
-SYSCTL_QUAD(_net_inet_udp, OID_AUTO, out_sw_cksum_bytes, CTLFLAG_RD | CTLFLAG_LOCKED,
-    &udps_out_sw_cksum_bytes,
-    "Amount of transmitted data checksummed in software");
-
-int    log_in_vain = 0;
+SYSCTL_INT(_net_inet_udp, UDPCTL_CHECKSUM, checksum,
+    CTLFLAG_RW | CTLFLAG_LOCKED, &udpcksum, 0, "");
+
+int udp_log_in_vain = 0;

 SYSCTL_INT(_net_inet_udp, OID_AUTO, log_in_vain, CTLFLAG_RW | CTLFLAG_LOCKED,
 SYSCTL_INT(_net_inet_udp, OID_AUTO, log_in_vain, CTLFLAG_RW | CTLFLAG_LOCKED,

-    &log_in_vain, 0, "Log all incoming UDP packets");
+    &udp_log_in_vain, 0, "Log all incoming UDP packets");

 
 

-static int     blackhole = 0;
+static int blackhole = 0;

 SYSCTL_INT(_net_inet_udp, OID_AUTO, blackhole, CTLFLAG_RW | CTLFLAG_LOCKED,
 SYSCTL_INT(_net_inet_udp, OID_AUTO, blackhole, CTLFLAG_RW | CTLFLAG_LOCKED,

-       &blackhole, 0, "Do not send port unreachables for refused connects");
+    &blackhole, 0, "Do not send port unreachables for refused connects");

 
 

-struct inpcbhead udb;          /* from udp_var.h */
+struct inpcbhead udb;          /* from udp_var.h */

 #define        udb6    udb  /* for KAME src sync over BSD*'s */
 #define        udb6    udb  /* for KAME src sync over BSD*'s */

-struct inpcbinfo udbinfo;
+struct inpcbinfo udbinfo;

 
 #ifndef UDBHASHSIZE
 #define UDBHASHSIZE 16
 #endif
 
 
 #ifndef UDBHASHSIZE
 #define UDBHASHSIZE 16
 #endif
 

-extern int     esp_udp_encap_port;
-
-extern  void    ipfwsyslog( int level, const char *format,...);
- 
-extern int fw_verbose;
-static int udp_gc_done = FALSE; /* Garbage collection performed last slowtimo */
+/* Garbage collection performed during most recent udp_gc() run */
+static boolean_t udp_gc_done = FALSE;

 
 #if IPFIREWALL
 
 #if IPFIREWALL

-#define log_in_vain_log( a ) {            \
-        if ( (log_in_vain == 3 ) && (fw_verbose == 2)) {        /* Apple logging, log to ipfw.log */ \
-                ipfwsyslog a ;  \
-        }                       \
-        else log a ;            \
+extern int fw_verbose;
+extern void ipfwsyslog( int level, const char *format,...);
+extern void ipfw_stealth_stats_incr_udp(void);
+
+/* Apple logging, log to ipfw.log */
+#define log_in_vain_log(a) {                                           \
+       if ((udp_log_in_vain == 3) && (fw_verbose == 2)) {              \
+               ipfwsyslog a;                                           \
+       } else if ((udp_log_in_vain == 4) && (fw_verbose == 2)) {       \
+               ipfw_stealth_stats_incr_udp();                          \
+       } else {                                                        \
+               log a;                                                  \
+       }                                                               \

 }
 }

-#else
+#else /* !IPFIREWALL */

 #define log_in_vain_log( a ) { log a; }
 #define log_in_vain_log( a ) { log a; }

-#endif
+#endif /* !IPFIREWALL */

 
 

+static int udp_getstat SYSCTL_HANDLER_ARGS;

 struct udpstat udpstat;        /* from udp_var.h */
 struct udpstat udpstat;        /* from udp_var.h */

-SYSCTL_STRUCT(_net_inet_udp, UDPCTL_STATS, stats, CTLFLAG_RD | CTLFLAG_LOCKED,
-    &udpstat, udpstat, "UDP statistics (struct udpstat, netinet/udp_var.h)");
-SYSCTL_INT(_net_inet_udp, OID_AUTO, pcbcount, CTLFLAG_RD | CTLFLAG_LOCKED, 
-    &udbinfo.ipi_count, 0, "Number of active PCBs");
+SYSCTL_PROC(_net_inet_udp, UDPCTL_STATS, stats, CTLFLAG_RD | CTLFLAG_LOCKED,
+    0, 0, udp_getstat, "S,udpstat",
+    "UDP statistics (struct udpstat, netinet/udp_var.h)");
+
+SYSCTL_INT(_net_inet_udp, OID_AUTO, pcbcount,
+    CTLFLAG_RD | CTLFLAG_LOCKED, &udbinfo.ipi_count, 0,
+    "Number of active PCBs");

 
 __private_extern__ int udp_use_randomport = 1;
 
 __private_extern__ int udp_use_randomport = 1;

-SYSCTL_INT(_net_inet_udp, OID_AUTO, randomize_ports, CTLFLAG_RW | CTLFLAG_LOCKED,
-    &udp_use_randomport, 0, "Randomize UDP port numbers");
+SYSCTL_INT(_net_inet_udp, OID_AUTO, randomize_ports,
+    CTLFLAG_RW | CTLFLAG_LOCKED, &udp_use_randomport, 0,
+    "Randomize UDP port numbers");

 
 #if INET6
 struct udp_in6 {
 
 #if INET6
 struct udp_in6 {


@@ -199,87 +191,124 @@ struct udp_ip6 {
        struct ip6_hdr          uip6_ip6;
        u_char                  uip6_init_done : 1;
 };
        struct ip6_hdr          uip6_ip6;
        u_char                  uip6_init_done : 1;
 };

+
+static int udp_abort(struct socket *);
+static int udp_attach(struct socket *, int, struct proc *);
+static int udp_bind(struct socket *, struct sockaddr *, struct proc *);
+static int udp_connect(struct socket *, struct sockaddr *, struct proc *);
+static int udp_connectx(struct socket *, struct sockaddr_list **,
+    struct sockaddr_list **, struct proc *, uint32_t, associd_t, connid_t *,
+    uint32_t, void *, uint32_t);
+static int udp_detach(struct socket *);
+static int udp_disconnect(struct socket *);
+static int udp_disconnectx(struct socket *, associd_t, connid_t);
+static int udp_send(struct socket *, int, struct mbuf *, struct sockaddr *,
+    struct mbuf *, struct proc *);
+static void udp_append(struct inpcb *, struct ip *, struct mbuf *, int,
+    struct sockaddr_in *, struct udp_in6 *, struct udp_ip6 *, struct ifnet *);
+#else /* !INET6 */
+static void udp_append(struct inpcb *, struct ip *, struct mbuf *, int,
+    struct sockaddr_in *, struct ifnet *);
+#endif /* !INET6 */
+static int udp_input_checksum(struct mbuf *, struct udphdr *, int, int);
+static int udp_output(struct inpcb *, struct mbuf *, struct sockaddr *,
+    struct mbuf *, struct proc *);

 static void ip_2_ip6_hdr(struct ip6_hdr *ip6, struct ip *ip);
 static void ip_2_ip6_hdr(struct ip6_hdr *ip6, struct ip *ip);

-static void udp_append(struct inpcb *last, struct ip *ip,
-    struct mbuf *n, int off, struct sockaddr_in *pudp_in,
-    struct udp_in6 *pudp_in6, struct udp_ip6 *pudp_ip6);
-#else
-static void udp_append(struct inpcb *last, struct ip *ip,
-    struct mbuf *n, int off, struct sockaddr_in *pudp_in);
-#endif
+static void udp_gc(struct inpcbinfo *);

 
 

-static int udp_detach(struct socket *so);
-static int udp_output(struct inpcb *, struct mbuf *, struct sockaddr *,
-                           struct mbuf *, struct proc *);
-extern int ChkAddressOK( __uint32_t dstaddr, __uint32_t srcaddr );
+struct pr_usrreqs udp_usrreqs = {
+       .pru_abort =            udp_abort,
+       .pru_attach =           udp_attach,
+       .pru_bind =             udp_bind,
+       .pru_connect =          udp_connect,
+       .pru_connectx =         udp_connectx,
+       .pru_control =          in_control,
+       .pru_detach =           udp_detach,
+       .pru_disconnect =       udp_disconnect,
+       .pru_disconnectx =      udp_disconnectx,
+       .pru_peeraddr =         in_getpeeraddr,
+       .pru_send =             udp_send,
+       .pru_shutdown =         udp_shutdown,
+       .pru_sockaddr =         in_getsockaddr,
+       .pru_sosend =           sosend,
+       .pru_soreceive =        soreceive,
+};

 
 void
 
 void

-udp_init()
+udp_init(struct protosw *pp, struct domain *dp)

 {
 {

-       vm_size_t                       str_size;
-       struct inpcbinfo        *pcbinfo;
-       
+#pragma unused(dp)
+       static int udp_initialized = 0;
+       vm_size_t               str_size;
+       struct inpcbinfo        *pcbinfo;
+
+       VERIFY((pp->pr_flags & (PR_INITIALIZED|PR_ATTACHED)) == PR_ATTACHED);
+
+       if (udp_initialized)
+               return;
+       udp_initialized = 1;

 
        LIST_INIT(&udb);
 
        LIST_INIT(&udb);

-       udbinfo.listhead = &udb;
-       udbinfo.hashbase = hashinit(UDBHASHSIZE, M_PCB, &udbinfo.hashmask);
-       udbinfo.porthashbase = hashinit(UDBHASHSIZE, M_PCB,
-                                       &udbinfo.porthashmask);
-#ifdef __APPLE__
-       str_size = (vm_size_t) sizeof(struct inpcb);
-       udbinfo.ipi_zone = (void *) zinit(str_size, 80000*str_size, 8192, "udpcb");
-
-       pcbinfo = &udbinfo;
+       udbinfo.ipi_listhead = &udb;
+       udbinfo.ipi_hashbase = hashinit(UDBHASHSIZE, M_PCB,
+           &udbinfo.ipi_hashmask);
+       udbinfo.ipi_porthashbase = hashinit(UDBHASHSIZE, M_PCB,
+           &udbinfo.ipi_porthashmask);
+       str_size = (vm_size_t) sizeof (struct inpcb);
+       udbinfo.ipi_zone = zinit(str_size, 80000*str_size, 8192, "udpcb");
+
+       pcbinfo = &udbinfo;

        /*
         * allocate lock group attribute and group for udp pcb mutexes
         */
        /*
         * allocate lock group attribute and group for udp pcb mutexes
         */

-       pcbinfo->mtx_grp_attr = lck_grp_attr_alloc_init();
-
-       pcbinfo->mtx_grp = lck_grp_alloc_init("udppcb", pcbinfo->mtx_grp_attr);
-               
-       pcbinfo->mtx_attr = lck_attr_alloc_init();
+       pcbinfo->ipi_lock_grp_attr = lck_grp_attr_alloc_init();
+       pcbinfo->ipi_lock_grp = lck_grp_alloc_init("udppcb",
+           pcbinfo->ipi_lock_grp_attr);
+       pcbinfo->ipi_lock_attr = lck_attr_alloc_init();
+       if ((pcbinfo->ipi_lock = lck_rw_alloc_init(pcbinfo->ipi_lock_grp,
+           pcbinfo->ipi_lock_attr)) == NULL) {
+               panic("%s: unable to allocate PCB lock\n", __func__);
+               /* NOTREACHED */
+       }

 
 

-       if ((pcbinfo->mtx = lck_rw_alloc_init(pcbinfo->mtx_grp, pcbinfo->mtx_attr)) == NULL)
-               return; /* pretty much dead if this fails... */
-#else
-       udbinfo.ipi_zone = zinit("udpcb", sizeof(struct inpcb), maxsockets,
-                                ZONE_INTERRUPT, 0);
-#endif
+       udbinfo.ipi_gc = udp_gc;
+       in_pcbinfo_attach(&udbinfo);

 }
 
 void
 }
 
 void

-udp_input(m, iphlen)
-       register struct mbuf *m;
-       int iphlen;
+udp_input(struct mbuf *m, int iphlen)

 {
 {

-       register struct ip *ip;
-       register struct udphdr *uh;
-       register struct inpcb *inp;
-       struct mbuf *opts = 0;
+       struct ip *ip;
+       struct udphdr *uh;
+       struct inpcb *inp;
+       struct mbuf *opts = NULL;

        int len, isbroadcast;
        struct ip save_ip;
        struct sockaddr *append_sa;
        struct inpcbinfo *pcbinfo = &udbinfo;
        int len, isbroadcast;
        struct ip save_ip;
        struct sockaddr *append_sa;
        struct inpcbinfo *pcbinfo = &udbinfo;

-       struct sockaddr_in udp_in = {
-               sizeof (udp_in), AF_INET, 0, { 0 }, { 0, 0, 0, 0, 0, 0, 0, 0 }
-       };
+       struct sockaddr_in udp_in;

        struct ip_moptions *imo = NULL;
        int foundmembership = 0, ret = 0;
 #if INET6
        struct ip_moptions *imo = NULL;
        int foundmembership = 0, ret = 0;
 #if INET6

-       struct udp_in6 udp_in6 = {
-               { sizeof (udp_in6.uin6_sin), AF_INET6, 0, 0,
-                   IN6ADDR_ANY_INIT, 0 },
-               0
-       };
+       struct udp_in6 udp_in6;

        struct udp_ip6 udp_ip6;
 #endif /* INET6 */
        struct udp_ip6 udp_ip6;
 #endif /* INET6 */

-       struct ifnet *ifp = (m->m_pkthdr.rcvif != NULL) ? m->m_pkthdr.rcvif: NULL;
+       struct ifnet *ifp = m->m_pkthdr.rcvif;
+       boolean_t cell = IFNET_IS_CELLULAR(ifp);
+       boolean_t wifi = (!cell && IFNET_IS_WIFI(ifp));
+
+       bzero(&udp_in, sizeof (udp_in));
+       udp_in.sin_len = sizeof (struct sockaddr_in);
+       udp_in.sin_family = AF_INET;
+#if INET6
+       bzero(&udp_in6, sizeof (udp_in6));
+       udp_in6.uin6_sin.sin6_len = sizeof (struct sockaddr_in6);
+       udp_in6.uin6_sin.sin6_family = AF_INET6;
+#endif /* INET6 */

 
        udpstat.udps_ipackets++;
 
        KERNEL_DEBUG(DBG_FNC_UDP_INPUT | DBG_FUNC_START, 0,0,0,0,0);
 
        udpstat.udps_ipackets++;
 
        KERNEL_DEBUG(DBG_FNC_UDP_INPUT | DBG_FUNC_START, 0,0,0,0,0);

-       if (m->m_pkthdr.csum_flags & CSUM_TCP_SUM16)
-               m->m_pkthdr.csum_flags = 0; /* invalidate hwcksum for UDP */

 
        /* Expect 32-bit aligned data pointer on strict-align platforms */
        MBUF_STRICT_DATA_ALIGNMENT_CHECK_32(m);
 
        /* Expect 32-bit aligned data pointer on strict-align platforms */
        MBUF_STRICT_DATA_ALIGNMENT_CHECK_32(m);


@@ -292,17 +321,19 @@ udp_input(m, iphlen)
         */
        if (iphlen > sizeof (struct ip)) {
                ip_stripoptions(m, (struct mbuf *)0);
         */
        if (iphlen > sizeof (struct ip)) {
                ip_stripoptions(m, (struct mbuf *)0);

-               iphlen = sizeof(struct ip);
+               iphlen = sizeof (struct ip);

        }
 
        /*
         * Get IP and UDP header together in first mbuf.
         */
        ip = mtod(m, struct ip *);
        }
 
        /*
         * Get IP and UDP header together in first mbuf.
         */
        ip = mtod(m, struct ip *);

-       if (m->m_len < iphlen + sizeof(struct udphdr)) {
-               if ((m = m_pullup(m, iphlen + sizeof(struct udphdr))) == 0) {
+       if (m->m_len < iphlen + sizeof (struct udphdr)) {
+               m = m_pullup(m, iphlen + sizeof (struct udphdr));
+               if (m == NULL) {

                        udpstat.udps_hdrops++;
                        udpstat.udps_hdrops++;

-                       KERNEL_DEBUG(DBG_FNC_UDP_INPUT | DBG_FUNC_END, 0,0,0,0,0);
+                       KERNEL_DEBUG(DBG_FNC_UDP_INPUT | DBG_FUNC_END,
+                           0,0,0,0,0);

                        return;
                }
                ip = mtod(m, struct ip *);
                        return;
                }
                ip = mtod(m, struct ip *);


@@ -311,15 +342,12 @@ udp_input(m, iphlen)
 
        /* destination port of 0 is illegal, based on RFC768. */
        if (uh->uh_dport == 0) {
 
        /* destination port of 0 is illegal, based on RFC768. */
        if (uh->uh_dport == 0) {

-       
-               if (ifp->if_udp_stat != NULL)
-                       atomic_add_64(&ifp->if_udp_stat->port0, 1);
-                               
+               IF_UDP_STATINC(ifp, port0);

                goto bad;
        }
 
        KERNEL_DEBUG(DBG_LAYER_IN_BEG, uh->uh_dport, uh->uh_sport,
                goto bad;
        }
 
        KERNEL_DEBUG(DBG_LAYER_IN_BEG, uh->uh_dport, uh->uh_sport,

-                    ip->ip_src.s_addr, ip->ip_dst.s_addr, uh->uh_ulen);
+           ip->ip_src.s_addr, ip->ip_dst.s_addr, uh->uh_ulen);

 
        /*
         * Make mbuf data length reflect UDP length.
 
        /*
         * Make mbuf data length reflect UDP length.


@@ -327,12 +355,9 @@ udp_input(m, iphlen)
         */
        len = ntohs((u_short)uh->uh_ulen);
        if (ip->ip_len != len) {
         */
        len = ntohs((u_short)uh->uh_ulen);
        if (ip->ip_len != len) {

-               if (len > ip->ip_len || len < sizeof(struct udphdr)) {
+               if (len > ip->ip_len || len < sizeof (struct udphdr)) {

                        udpstat.udps_badlen++;
                        udpstat.udps_badlen++;

-                       
-                       if (ifp->if_udp_stat != NULL)
-                               atomic_add_64(&ifp->if_udp_stat->badlength, 1);
-                       
+                       IF_UDP_STATINC(ifp, badlength);

                        goto bad;
                }
                m_adj(m, len - ip->ip_len);
                        goto bad;
                }
                m_adj(m, len - ip->ip_len);


@@ -347,50 +372,15 @@ udp_input(m, iphlen)
        /*
         * Checksum extended UDP header and data.
         */
        /*
         * Checksum extended UDP header and data.
         */

-       if (uh->uh_sum) {
-               if (m->m_pkthdr.csum_flags & CSUM_DATA_VALID) {
-                       if (m->m_pkthdr.csum_flags & CSUM_PSEUDO_HDR)
-                               uh->uh_sum = m->m_pkthdr.csum_data;
-                       else
-                               goto doudpcksum;
-                       uh->uh_sum ^= 0xffff;
-               } else {
-                       char b[9];
-doudpcksum:
-                       bcopy(((struct ipovly *)ip)->ih_x1, b,
-                           sizeof (((struct ipovly *)ip)->ih_x1));
-                       bzero(((struct ipovly *)ip)->ih_x1,
-                           sizeof (((struct ipovly *)ip)->ih_x1));
-                       ((struct ipovly *)ip)->ih_len = uh->uh_ulen;
-                       uh->uh_sum = in_cksum(m, len + sizeof (struct ip));
-                       bcopy(b, ((struct ipovly *)ip)->ih_x1,
-                           sizeof (((struct ipovly *)ip)->ih_x1));
-
-                       udp_in_cksum_stats(len);
-               }
-               if (uh->uh_sum) {
-                       udpstat.udps_badsum++;
-                       
-                       if (ifp->if_udp_stat != NULL)
-                               atomic_add_64(&ifp->if_udp_stat->badchksum, 1);
-                       
-                       m_freem(m);
-                       KERNEL_DEBUG(DBG_FNC_UDP_INPUT | DBG_FUNC_END, 0,0,0,0,0);
-                       return;
-               }
-       }
-#ifndef __APPLE__
-        else
-               udpstat.udps_nosum++;
-#endif
+       if (udp_input_checksum(m, uh, iphlen, len))
+               goto bad;

 
        isbroadcast = in_broadcast(ip->ip_dst, ifp);
 
        if (IN_MULTICAST(ntohl(ip->ip_dst.s_addr)) || isbroadcast) {
 
        isbroadcast = in_broadcast(ip->ip_dst, ifp);
 
        if (IN_MULTICAST(ntohl(ip->ip_dst.s_addr)) || isbroadcast) {

-

                int reuse_sock = 0, mcast_delivered = 0;
 
                int reuse_sock = 0, mcast_delivered = 0;
 

-               lck_rw_lock_shared(pcbinfo->mtx);
+               lck_rw_lock_shared(pcbinfo->ipi_lock);

                /*
                 * Deliver a multicast or broadcast datagram to *all* sockets
                 * for which the local and remote addresses and ports match
                /*
                 * Deliver a multicast or broadcast datagram to *all* sockets
                 * for which the local and remote addresses and ports match


@@ -407,7 +397,6 @@ doudpcksum:
                 * fixing the interface.  Maybe 4.5BSD will remedy this?)
                 */
 
                 * fixing the interface.  Maybe 4.5BSD will remedy this?)
                 */
 

-

                /*
                 * Construct sockaddr format source address.
                 */
                /*
                 * Construct sockaddr format source address.
                 */


@@ -419,34 +408,43 @@ doudpcksum:
                 */
 #if INET6
                udp_in6.uin6_init_done = udp_ip6.uip6_init_done = 0;
                 */
 #if INET6
                udp_in6.uin6_init_done = udp_ip6.uip6_init_done = 0;

-#endif
+#endif /* INET6 */

                LIST_FOREACH(inp, &udb, inp_list) {
                LIST_FOREACH(inp, &udb, inp_list) {

-                       if (inp->inp_socket == NULL) 
+#if IPSEC
+                       int skipit;
+#endif /* IPSEC */
+
+                       if (inp->inp_socket == NULL)

                                continue;
                                continue;

-                       if (inp != sotoinpcb(inp->inp_socket))
-                               panic("udp_input: bad so back ptr inp=%p\n", inp);
+                       if (inp != sotoinpcb(inp->inp_socket)) {
+                               panic("%s: bad so back ptr inp=%p\n",
+                                   __func__, inp);
+                               /* NOTREACHED */
+                       }

 #if INET6
                         if ((inp->inp_vflag & INP_IPV4) == 0)
                                 continue;
 #if INET6
                         if ((inp->inp_vflag & INP_IPV4) == 0)
                                 continue;

-#endif
-                       if (ip_restrictrecvif && ifp != NULL &&
-                           (ifp->if_eflags & IFEF_RESTRICTED_RECV) &&
-                           !(inp->inp_flags & INP_RECV_ANYIF))
+#endif /* INET6 */
+                       if (inp_restricted(inp, ifp))

                                continue;
 
                                continue;
 

-                       if ((inp->inp_moptions == NULL) && 
-                               (ntohl(ip->ip_dst.s_addr) != INADDR_ALLHOSTS_GROUP) && 
-                               (isbroadcast == 0) )
+                       if (IFNET_IS_CELLULAR(ifp) &&
+                           (inp->inp_flags & INP_NO_IFT_CELLULAR))

                                continue;
 
                                continue;
 

+                       if ((inp->inp_moptions == NULL) &&
+                           (ntohl(ip->ip_dst.s_addr) !=
+                           INADDR_ALLHOSTS_GROUP) && (isbroadcast == 0))
+                               continue;

 
 

-                       if (in_pcb_checkstate(inp, WNT_ACQUIRE, 0) == WNT_STOPUSING) {
+                       if (in_pcb_checkstate(inp, WNT_ACQUIRE, 0) ==
+                           WNT_STOPUSING)

                                continue;
                                continue;

-                       }
-                       
-                       udp_lock(inp->inp_socket, 1, 0);        

 
 

-                       if (in_pcb_checkstate(inp, WNT_RELEASE, 1) == WNT_STOPUSING) {
+                       udp_lock(inp->inp_socket, 1, 0);
+
+                       if (in_pcb_checkstate(inp, WNT_RELEASE, 1) ==
+                           WNT_STOPUSING) {

                                udp_unlock(inp->inp_socket, 1, 0);
                                continue;
                        }
                                udp_unlock(inp->inp_socket, 1, 0);
                                continue;
                        }


@@ -471,69 +469,73 @@ doudpcksum:
                                }
                        }
 
                                }
                        }
 

-                       if (isbroadcast == 0 && (ntohl(ip->ip_dst.s_addr) != INADDR_ALLHOSTS_GROUP)) {  
-                               if((imo = inp->inp_moptions) == NULL) {
+                       if (isbroadcast == 0 && (ntohl(ip->ip_dst.s_addr) !=
+                           INADDR_ALLHOSTS_GROUP)) {
+                               struct sockaddr_in group;
+                               int blocked;
+
+                               if ((imo = inp->inp_moptions) == NULL) {

                                        udp_unlock(inp->inp_socket, 1, 0);
                                        continue;
                                        udp_unlock(inp->inp_socket, 1, 0);
                                        continue;

-                               } else {
-                                       struct sockaddr_in       group;
-                                       int                      blocked;
-
-                                       IMO_LOCK(imo);
-
-                                       bzero(&group, sizeof(struct sockaddr_in));
-                                       group.sin_len = sizeof(struct sockaddr_in);
-                                       group.sin_family = AF_INET;
-                                       group.sin_addr = ip->ip_dst;
-
-                                       blocked = imo_multi_filter(imo, ifp,
-                                               (struct sockaddr *)&group,
-                                               (struct sockaddr *)&udp_in);
-                                       if (blocked == MCAST_PASS) 
-                                               foundmembership = 1;
-                               
-                                       IMO_UNLOCK(imo);
-                                       if (!foundmembership) {
-                                               udp_unlock(inp->inp_socket, 1, 0);
-                                               continue;
-                                       }
-                                       foundmembership = 0;

                                }
                                }

+                               IMO_LOCK(imo);
+
+                               bzero(&group, sizeof (struct sockaddr_in));
+                               group.sin_len = sizeof (struct sockaddr_in);
+                               group.sin_family = AF_INET;
+                               group.sin_addr = ip->ip_dst;
+
+                               blocked = imo_multi_filter(imo, ifp,
+                                   (struct sockaddr *)&group,
+                                   (struct sockaddr *)&udp_in);
+                               if (blocked == MCAST_PASS)
+                                       foundmembership = 1;
+
+                               IMO_UNLOCK(imo);
+                               if (!foundmembership) {
+                                       udp_unlock(inp->inp_socket, 1, 0);
+                                       if (blocked == MCAST_NOTSMEMBER ||
+                                           blocked == MCAST_MUTED)
+                                               udpstat.udps_filtermcast++;
+                                       continue;
+                               }
+                               foundmembership = 0;

                        }
                        }

-                       reuse_sock = inp->inp_socket->so_options& (SO_REUSEPORT|SO_REUSEADDR);
-                       {
+
+                       reuse_sock = (inp->inp_socket->so_options &
+                           (SO_REUSEPORT|SO_REUSEADDR));
+

 #if IPSEC
 #if IPSEC

-                               int skipit = 0;
-                               /* check AH/ESP integrity. */
-                               if (ipsec_bypass == 0) {
-                                       if (ipsec4_in_reject_so(m, inp->inp_socket)) {
-                                               IPSEC_STAT_INCREMENT(ipsecstat.in_polvio);
-                                               /* do not inject data to pcb */
-                                               skipit = 1;
-                                       }
-                               }
-                               if (skipit == 0) 
+                       skipit = 0;
+                       /* check AH/ESP integrity. */
+                       if (ipsec_bypass == 0 &&
+                           ipsec4_in_reject_so(m, inp->inp_socket)) {
+                               IPSEC_STAT_INCREMENT(ipsecstat.in_polvio);
+                               /* do not inject data to pcb */
+                               skipit = 1;
+                       }
+                       if (skipit == 0)

 #endif /*IPSEC*/
 #endif /*IPSEC*/

-                               {
-                                       struct mbuf *n = NULL;
-                                       
-                                       if (reuse_sock) 
-                                               n = m_copy(m, 0, M_COPYALL);
-#if INET6
-                                       udp_append(inp, ip, m,
-                                           iphlen + sizeof(struct udphdr),
-                                           &udp_in, &udp_in6, &udp_ip6);
-#else
-                                       udp_append(inp, ip, m,
-                                           iphlen + sizeof(struct udphdr),
-                                           &udp_in);
-#endif /* INET6 */
-                                       mcast_delivered++;
+                       {
+                               struct mbuf *n = NULL;

 
 

-                                       m = n;
-                               }
-                               udp_unlock(inp->inp_socket, 1, 0);
+                               if (reuse_sock)
+                                       n = m_copy(m, 0, M_COPYALL);
+#if INET6
+                               udp_append(inp, ip, m,
+                                   iphlen + sizeof (struct udphdr),
+                                   &udp_in, &udp_in6, &udp_ip6, ifp);
+#else /* !INET6 */
+                               udp_append(inp, ip, m,
+                                   iphlen + sizeof (struct udphdr),
+                                   &udp_in, ifp);
+#endif /* !INET6 */
+                               mcast_delivered++;
+
+                               m = n;

                        }
                        }

+                       udp_unlock(inp->inp_socket, 1, 0);
+

                        /*
                         * Don't look for additional matches if this one does
                         * not have either the SO_REUSEPORT or SO_REUSEADDR
                        /*
                         * Don't look for additional matches if this one does
                         * not have either the SO_REUSEPORT or SO_REUSEADDR


@@ -556,7 +558,7 @@ doudpcksum:
                        ip = mtod(m, struct ip *);
                        uh = (struct udphdr *)(void *)((caddr_t)ip + iphlen);
                }
                        ip = mtod(m, struct ip *);
                        uh = (struct udphdr *)(void *)((caddr_t)ip + iphlen);
                }

-               lck_rw_done(pcbinfo->mtx);
+               lck_rw_done(pcbinfo->ipi_lock);

 
                if (mcast_delivered == 0) {
                        /*
 
                if (mcast_delivered == 0) {
                        /*


@@ -565,14 +567,12 @@ doudpcksum:
                         * for a broadcast or multicast datgram.)
                         */
                        udpstat.udps_noportbcast++;
                         * for a broadcast or multicast datgram.)
                         */
                        udpstat.udps_noportbcast++;

-                       
-                       if (ifp->if_udp_stat != NULL)
-                               atomic_add_64(&ifp->if_udp_stat->port_unreach, 1);
-                       
+                       IF_UDP_STATINC(ifp, port_unreach);

                        goto bad;
                }
 
                        goto bad;
                }
 

-               if (m != NULL)  /* free the extra copy of mbuf or skipped by IPSec */
+               /* free the extra copy of mbuf or skipped by IPSec */
+               if (m != NULL)

                        m_freem(m);
                KERNEL_DEBUG(DBG_FNC_UDP_INPUT | DBG_FUNC_END, 0,0,0,0,0);
                return;
                        m_freem(m);
                KERNEL_DEBUG(DBG_FNC_UDP_INPUT | DBG_FUNC_END, 0,0,0,0,0);
                return;


@@ -587,12 +587,16 @@ doudpcksum:
         * or discard the NAT keep-alive.
         */
        if (ipsec_bypass == 0 && (esp_udp_encap_port & 0xFFFF) != 0 &&
         * or discard the NAT keep-alive.
         */
        if (ipsec_bypass == 0 && (esp_udp_encap_port & 0xFFFF) != 0 &&

-               uh->uh_dport == ntohs((u_short)esp_udp_encap_port)) {
-               int     payload_len = len - sizeof(struct udphdr) > 4 ? 4 : len - sizeof(struct udphdr);
-               if (m->m_len < iphlen + sizeof(struct udphdr) + payload_len) {
-                       if ((m = m_pullup(m, iphlen + sizeof(struct udphdr) + payload_len)) == 0) {
+           uh->uh_dport == ntohs((u_short)esp_udp_encap_port)) {
+               int payload_len = len - sizeof (struct udphdr) > 4 ? 4 :
+                   len - sizeof (struct udphdr);
+
+               if (m->m_len < iphlen + sizeof (struct udphdr) + payload_len) {
+                       if ((m = m_pullup(m, iphlen + sizeof (struct udphdr) +
+                           payload_len)) == NULL) {

                                udpstat.udps_hdrops++;
                                udpstat.udps_hdrops++;

-                               KERNEL_DEBUG(DBG_FNC_UDP_INPUT | DBG_FUNC_END, 0,0,0,0,0);
+                               KERNEL_DEBUG(DBG_FNC_UDP_INPUT | DBG_FUNC_END,
+                                   0,0,0,0,0);

                                return;
                        }
                        /*
                                return;
                        }
                        /*


@@ -605,20 +609,23 @@ doudpcksum:
                        uh = (struct udphdr *)(void *)((caddr_t)ip + iphlen);
                }
                /* Check for NAT keepalive packet */
                        uh = (struct udphdr *)(void *)((caddr_t)ip + iphlen);
                }
                /* Check for NAT keepalive packet */

-               if (payload_len == 1 && *(u_int8_t*)((caddr_t)uh + sizeof(struct udphdr)) == 0xFF) {
+               if (payload_len == 1 && *(u_int8_t*)
+                   ((caddr_t)uh + sizeof (struct udphdr)) == 0xFF) {

                        m_freem(m);
                        m_freem(m);

-                       KERNEL_DEBUG(DBG_FNC_UDP_INPUT | DBG_FUNC_END, 0,0,0,0,0);
+                       KERNEL_DEBUG(DBG_FNC_UDP_INPUT | DBG_FUNC_END,
+                           0,0,0,0,0);

                        return;
                        return;

-               }
-               else if (payload_len == 4 && *(u_int32_t*)(void *)((caddr_t)uh + sizeof(struct udphdr)) != 0) {
+               } else if (payload_len == 4 && *(u_int32_t*)(void *)
+                   ((caddr_t)uh + sizeof (struct udphdr)) != 0) {

                        /* UDP encapsulated IPSec packet to pass through NAT */
                        /* UDP encapsulated IPSec packet to pass through NAT */

-                       KERNEL_DEBUG(DBG_FNC_UDP_INPUT | DBG_FUNC_END, 0,0,0,0,0);
+                       KERNEL_DEBUG(DBG_FNC_UDP_INPUT | DBG_FUNC_END,
+                           0,0,0,0,0);

                        /* preserve the udp header */
                        /* preserve the udp header */

-                       esp4_input(m, iphlen + sizeof(struct udphdr));
+                       esp4_input(m, iphlen + sizeof (struct udphdr));

                        return;
                }
        }
                        return;
                }
        }

-#endif
+#endif /* IPSEC */

 
        /*
         * Locate pcb for datagram.
 
        /*
         * Locate pcb for datagram.


@@ -626,30 +633,30 @@ doudpcksum:
        inp = in_pcblookup_hash(&udbinfo, ip->ip_src, uh->uh_sport,
            ip->ip_dst, uh->uh_dport, 1, ifp);
        if (inp == NULL) {
        inp = in_pcblookup_hash(&udbinfo, ip->ip_src, uh->uh_sport,
            ip->ip_dst, uh->uh_dport, 1, ifp);
        if (inp == NULL) {

-               
-               if (ifp->if_udp_stat != NULL)
-                       atomic_add_64(&ifp->if_udp_stat->port_unreach, 1);
-       
-               if (log_in_vain) {
+               IF_UDP_STATINC(ifp, port_unreach);
+
+               if (udp_log_in_vain) {

                        char buf[MAX_IPv4_STR_LEN];
                        char buf2[MAX_IPv4_STR_LEN];
 
                        /* check src and dst address */
                        char buf[MAX_IPv4_STR_LEN];
                        char buf2[MAX_IPv4_STR_LEN];
 
                        /* check src and dst address */

-                       if (log_in_vain != 3)
-                               log(LOG_INFO,
-                                       "Connection attempt to UDP %s:%d from %s:%d\n",
-                                       inet_ntop(AF_INET, &ip->ip_dst, buf, sizeof(buf)),
-                                       ntohs(uh->uh_dport),
-                                       inet_ntop(AF_INET, &ip->ip_src, buf2, sizeof(buf2)),
+                       if (udp_log_in_vain < 3) {
+                               log(LOG_INFO, "Connection attempt to "
+                                   "UDP %s:%d from %s:%d\n", inet_ntop(AF_INET,
+                                       &ip->ip_dst, buf, sizeof (buf)),
+                                       ntohs(uh->uh_dport), inet_ntop(AF_INET,
+                                       &ip->ip_src, buf2, sizeof (buf2)),

                                        ntohs(uh->uh_sport));
                                        ntohs(uh->uh_sport));

-                       else if (!(m->m_flags & (M_BCAST | M_MCAST)) &&
-                                        ip->ip_dst.s_addr != ip->ip_src.s_addr)
+                       } else if (!(m->m_flags & (M_BCAST | M_MCAST)) &&
+                           ip->ip_dst.s_addr != ip->ip_src.s_addr) {

                                log_in_vain_log((LOG_INFO,
                                log_in_vain_log((LOG_INFO,

-                                       "Stealth Mode connection attempt to UDP %s:%d from %s:%d\n",
-                                       inet_ntop(AF_INET, &ip->ip_dst, buf, sizeof(buf)),
-                                       ntohs(uh->uh_dport),
-                                       inet_ntop(AF_INET, &ip->ip_src, buf2, sizeof(buf2)),
-                                       ntohs(uh->uh_sport)))
+                                   "Stealth Mode connection attempt to "
+                                   "UDP %s:%d from %s:%d\n", inet_ntop(AF_INET,
+                                   &ip->ip_dst, buf, sizeof (buf)),
+                                   ntohs(uh->uh_dport), inet_ntop(AF_INET,
+                                   &ip->ip_src, buf2, sizeof (buf2)),
+                                   ntohs(uh->uh_sport)))
+                       }

                }
                udpstat.udps_noport++;
                if (m->m_flags & (M_BCAST | M_MCAST)) {
                }
                udpstat.udps_noport++;
                if (m->m_flags & (M_BCAST | M_MCAST)) {


@@ -659,7 +666,7 @@ doudpcksum:
 #if ICMP_BANDLIM
                if (badport_bandlim(BANDLIM_ICMP_UNREACH) < 0)
                        goto bad;
 #if ICMP_BANDLIM
                if (badport_bandlim(BANDLIM_ICMP_UNREACH) < 0)
                        goto bad;

-#endif
+#endif /* ICMP_BANDLIM */

                if (blackhole)
                        if (ifp && ifp->if_type != IFT_LOOP)
                                goto bad;
                if (blackhole)
                        if (ifp && ifp->if_type != IFT_LOOP)
                                goto bad;


@@ -673,10 +680,7 @@ doudpcksum:
 
        if (in_pcb_checkstate(inp, WNT_RELEASE, 1) == WNT_STOPUSING) {
                udp_unlock(inp->inp_socket, 1, 0);
 
        if (in_pcb_checkstate(inp, WNT_RELEASE, 1) == WNT_STOPUSING) {
                udp_unlock(inp->inp_socket, 1, 0);

-               
-               if (ifp->if_udp_stat != NULL)
-                       atomic_add_64(&ifp->if_udp_stat->cleanup, 1);
-               
+               IF_UDP_STATINC(ifp, cleanup);

                goto bad;
        }
 #if IPSEC
                goto bad;
        }
 #if IPSEC


@@ -684,14 +688,11 @@ doudpcksum:
                if (ipsec4_in_reject_so(m, inp->inp_socket)) {
                        IPSEC_STAT_INCREMENT(ipsecstat.in_polvio);
                        udp_unlock(inp->inp_socket, 1, 0);
                if (ipsec4_in_reject_so(m, inp->inp_socket)) {
                        IPSEC_STAT_INCREMENT(ipsecstat.in_polvio);
                        udp_unlock(inp->inp_socket, 1, 0);

-                       
-                       if (ifp->if_udp_stat != NULL)
-                               atomic_add_64(&ifp->if_udp_stat->badipsec, 1);
-                       
+                       IF_UDP_STATINC(ifp, badipsec);

                        goto bad;
                }
        }
                        goto bad;
                }
        }

-#endif /*IPSEC*/
+#endif /* IPSEC */

 
        /*
         * Construct sockaddr format source address.
 
        /*
         * Construct sockaddr format source address.


@@ -699,9 +700,9 @@ doudpcksum:
         */
        udp_in.sin_port = uh->uh_sport;
        udp_in.sin_addr = ip->ip_src;
         */
        udp_in.sin_port = uh->uh_sport;
        udp_in.sin_addr = ip->ip_src;

-       if ((inp->inp_flags & INP_CONTROLOPTS) != 0
-           || (inp->inp_socket->so_options & SO_TIMESTAMP) != 0
-           || (inp->inp_socket->so_options & SO_TIMESTAMP_MONOTONIC) != 0) {
+       if ((inp->inp_flags & INP_CONTROLOPTS) != 0 ||
+           (inp->inp_socket->so_options & SO_TIMESTAMP) != 0 ||
+           (inp->inp_socket->so_options & SO_TIMESTAMP_MONOTONIC) != 0) {

 #if INET6
                if (inp->inp_vflag & INP_IPV6) {
                        int savedflags;
 #if INET6
                if (inp->inp_vflag & INP_IPV6) {
                        int savedflags;


@@ -712,7 +713,7 @@ doudpcksum:
                        ret = ip6_savecontrol(inp, m, &opts);
                        inp->inp_flags = savedflags;
                } else
                        ret = ip6_savecontrol(inp, m, &opts);
                        inp->inp_flags = savedflags;
                } else

-#endif
+#endif /* INET6 */

                {
                        ret = ip_savecontrol(inp, &opts, ip, m);
                }
                {
                        ret = ip_savecontrol(inp, &opts, ip, m);
                }


@@ -721,24 +722,27 @@ doudpcksum:
                        goto bad;
                }
        }
                        goto bad;
                }
        }

-       m_adj(m, iphlen + sizeof(struct udphdr));
+       m_adj(m, iphlen + sizeof (struct udphdr));

 
        KERNEL_DEBUG(DBG_LAYER_IN_END, uh->uh_dport, uh->uh_sport,
 
        KERNEL_DEBUG(DBG_LAYER_IN_END, uh->uh_dport, uh->uh_sport,

-                    save_ip.ip_src.s_addr, save_ip.ip_dst.s_addr, uh->uh_ulen);
+           save_ip.ip_src.s_addr, save_ip.ip_dst.s_addr, uh->uh_ulen);

 
 #if INET6
        if (inp->inp_vflag & INP_IPV6) {
                in6_sin_2_v4mapsin6(&udp_in, &udp_in6.uin6_sin);
                append_sa = (struct sockaddr *)&udp_in6.uin6_sin;
        } else
 
 #if INET6
        if (inp->inp_vflag & INP_IPV6) {
                in6_sin_2_v4mapsin6(&udp_in, &udp_in6.uin6_sin);
                append_sa = (struct sockaddr *)&udp_in6.uin6_sin;
        } else

-#endif
-       append_sa = (struct sockaddr *)&udp_in;
+#endif /* INET6 */
+       {
+               append_sa = (struct sockaddr *)&udp_in;
+       }

        if (nstat_collect) {
        if (nstat_collect) {

-               locked_add_64(&inp->inp_stat->rxpackets, 1);
-               locked_add_64(&inp->inp_stat->rxbytes, m->m_pkthdr.len);
+               INP_ADD_STAT(inp, cell, wifi, rxpackets, 1);
+               INP_ADD_STAT(inp, cell, wifi, rxbytes, m->m_pkthdr.len);

        }
        so_recv_data_stat(inp->inp_socket, m, 0);
        }
        so_recv_data_stat(inp->inp_socket, m, 0);

-       if (sbappendaddr(&inp->inp_socket->so_rcv, append_sa, m, opts, NULL) == 0) {
+       if (sbappendaddr(&inp->inp_socket->so_rcv, append_sa,
+           m, opts, NULL) == 0) {

                udpstat.udps_fullsock++;
        } else {
                sorwakeup(inp->inp_socket);
                udpstat.udps_fullsock++;
        } else {
                sorwakeup(inp->inp_socket);


@@ -751,16 +755,13 @@ bad:
        if (opts)
                m_freem(opts);
        KERNEL_DEBUG(DBG_FNC_UDP_INPUT | DBG_FUNC_END, 0,0,0,0,0);
        if (opts)
                m_freem(opts);
        KERNEL_DEBUG(DBG_FNC_UDP_INPUT | DBG_FUNC_END, 0,0,0,0,0);

-       return;

 }
 
 #if INET6
 static void
 }
 
 #if INET6
 static void

-ip_2_ip6_hdr(ip6, ip)
-       struct ip6_hdr *ip6;
-       struct ip *ip;
+ip_2_ip6_hdr(struct ip6_hdr *ip6, struct ip *ip)

 {
 {

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

 
        ip6->ip6_vfc = IPV6_VERSION;
        ip6->ip6_plen = ip->ip_len;
 
        ip6->ip6_vfc = IPV6_VERSION;
        ip6->ip6_plen = ip->ip_len;


@@ -775,7 +776,7 @@ ip_2_ip6_hdr(ip6, ip)
                ip6->ip6_dst.s6_addr32[3] = ip->ip_dst.s_addr;
        }
 }
                ip6->ip6_dst.s6_addr32[3] = ip->ip_dst.s_addr;
        }
 }

-#endif
+#endif /* INET6 */

 
 /*
  * subroutine of udp_input(), mainly for source code readability.
 
 /*
  * subroutine of udp_input(), mainly for source code readability.


@@ -784,14 +785,16 @@ static void
 #if INET6
 udp_append(struct inpcb *last, struct ip *ip, struct mbuf *n, int off,
     struct sockaddr_in *pudp_in, struct udp_in6 *pudp_in6,
 #if INET6
 udp_append(struct inpcb *last, struct ip *ip, struct mbuf *n, int off,
     struct sockaddr_in *pudp_in, struct udp_in6 *pudp_in6,

-    struct udp_ip6 *pudp_ip6)
-#else
+    struct udp_ip6 *pudp_ip6, struct ifnet *ifp)
+#else /* !INET6 */

 udp_append(struct inpcb *last, struct ip *ip, struct mbuf *n, int off,
 udp_append(struct inpcb *last, struct ip *ip, struct mbuf *n, int off,

-    struct sockaddr_in *pudp_in)
-#endif
+    struct sockaddr_in *pudp_in, struct ifnet *ifp)
+#endif /* !INET6 */

 {
        struct sockaddr *append_sa;
        struct mbuf *opts = 0;
 {
        struct sockaddr *append_sa;
        struct mbuf *opts = 0;

+       boolean_t cell = IFNET_IS_CELLULAR(ifp);
+       boolean_t wifi = (!cell && IFNET_IS_WIFI(ifp));

        int ret = 0;
 
 #if CONFIG_MACF_NET
        int ret = 0;
 
 #if CONFIG_MACF_NET


@@ -799,7 +802,7 @@ udp_append(struct inpcb *last, struct ip *ip, struct mbuf *n, int off,
                m_freem(n);
                return;
        }
                m_freem(n);
                return;
        }

-#endif
+#endif /* CONFIG_MACF_NET */

        if ((last->inp_flags & INP_CONTROLOPTS) != 0 ||
            (last->inp_socket->so_options & SO_TIMESTAMP) != 0 ||
            (last->inp_socket->so_options & SO_TIMESTAMP_MONOTONIC) != 0) {
        if ((last->inp_flags & INP_CONTROLOPTS) != 0 ||
            (last->inp_socket->so_options & SO_TIMESTAMP) != 0 ||
            (last->inp_socket->so_options & SO_TIMESTAMP_MONOTONIC) != 0) {


@@ -820,7 +823,7 @@ udp_append(struct inpcb *last, struct ip *ip, struct mbuf *n, int off,
                        }
                        last->inp_flags = savedflags;
                } else
                        }
                        last->inp_flags = savedflags;
                } else

-#endif
+#endif /* INET6 */

                {
                        ret = ip_savecontrol(last, &opts, ip, n);
                        if (ret != 0) {
                {
                        ret = ip_savecontrol(last, &opts, ip, n);
                        if (ret != 0) {


@@ -836,15 +839,16 @@ udp_append(struct inpcb *last, struct ip *ip, struct mbuf *n, int off,
                }
                append_sa = (struct sockaddr *)&pudp_in6->uin6_sin;
        } else
                }
                append_sa = (struct sockaddr *)&pudp_in6->uin6_sin;
        } else

-#endif
+#endif /* INET6 */

        append_sa = (struct sockaddr *)pudp_in;
        if (nstat_collect) {
        append_sa = (struct sockaddr *)pudp_in;
        if (nstat_collect) {

-               locked_add_64(&last->inp_stat->rxpackets, 1);
-               locked_add_64(&last->inp_stat->rxbytes, n->m_pkthdr.len);
+               INP_ADD_STAT(last, cell, wifi, rxpackets, 1);
+               INP_ADD_STAT(last, cell, wifi, rxbytes, n->m_pkthdr.len);

        }
        so_recv_data_stat(last->inp_socket, n, 0);
        m_adj(n, off);
        }
        so_recv_data_stat(last->inp_socket, n, 0);
        m_adj(n, off);

-       if (sbappendaddr(&last->inp_socket->so_rcv, append_sa, n, opts, NULL) == 0) {
+       if (sbappendaddr(&last->inp_socket->so_rcv, append_sa,
+           n, opts, NULL) == 0) {

                udpstat.udps_fullsock++;
        } else {
                sorwakeup(last->inp_socket);
                udpstat.udps_fullsock++;
        } else {
                sorwakeup(last->inp_socket);


@@ -861,9 +865,7 @@ error:
  * just wake up so that he can collect error status.
  */
 void
  * just wake up so that he can collect error status.
  */
 void

-udp_notify(inp, errno)
-       register struct inpcb *inp;
-       int errno;
+udp_notify(struct inpcb *inp, int errno)

 {
        inp->inp_socket->so_error = errno;
        sorwakeup(inp->inp_socket);
 {
        inp->inp_socket->so_error = errno;
        sorwakeup(inp->inp_socket);


@@ -871,10 +873,7 @@ udp_notify(inp, errno)
 }
 
 void
 }
 
 void

-udp_ctlinput(cmd, sa, vip)
-       int cmd;
-       struct sockaddr *sa;
-       void *vip;
+udp_ctlinput(int cmd, struct sockaddr *sa, void *vip)

 {
        struct ip *ip = vip;
        void (*notify)(struct inpcb *, int) = udp_notify;
 {
        struct ip *ip = vip;
        void (*notify)(struct inpcb *, int) = udp_notify;


@@ -888,10 +887,11 @@ udp_ctlinput(cmd, sa, vip)
        if (PRC_IS_REDIRECT(cmd)) {
                ip = 0;
                notify = in_rtchange;
        if (PRC_IS_REDIRECT(cmd)) {
                ip = 0;
                notify = in_rtchange;

-       } else if (cmd == PRC_HOSTDEAD)
+       } else if (cmd == PRC_HOSTDEAD) {

                ip = 0;
                ip = 0;

-       else if ((unsigned)cmd >= PRC_NCMDS || inetctlerrmap[cmd] == 0)
+       } else if ((unsigned)cmd >= PRC_NCMDS || inetctlerrmap[cmd] == 0) {

                return;
                return;

+       }

        if (ip) {
                struct udphdr uh;
 
        if (ip) {
                struct udphdr uh;
 


@@ -908,8 +908,9 @@ udp_ctlinput(cmd, sa, vip)
                        (*notify)(inp, inetctlerrmap[cmd]);
                        udp_unlock(inp->inp_socket, 1, 0);
                }
                        (*notify)(inp, inetctlerrmap[cmd]);
                        udp_unlock(inp->inp_socket, 1, 0);
                }

-       } else
+       } else {

                in_pcbnotifyall(&udbinfo, faddr, inetctlerrmap[cmd], notify);
                in_pcbnotifyall(&udbinfo, faddr, inetctlerrmap[cmd], notify);

+       }

 }
 
 int
 }
 
 int


@@ -990,18 +991,18 @@ udp_pcblist SYSCTL_HANDLER_ARGS
         * The process of preparing the TCB list is too time-consuming and
         * resource-intensive to repeat twice on every request.
         */
         * The process of preparing the TCB list is too time-consuming and
         * resource-intensive to repeat twice on every request.
         */

-       lck_rw_lock_exclusive(udbinfo.mtx);
+       lck_rw_lock_exclusive(udbinfo.ipi_lock);

        if (req->oldptr == USER_ADDR_NULL) {
                n = udbinfo.ipi_count;
        if (req->oldptr == USER_ADDR_NULL) {
                n = udbinfo.ipi_count;

-               req->oldidx = 2 * (sizeof xig)
-                       + (n + n/8) * sizeof(struct xinpcb);
-               lck_rw_done(udbinfo.mtx);
-               return 0;
+               req->oldidx = 2 * (sizeof (xig))
+                       + (n + n/8) * sizeof (struct xinpcb);
+               lck_rw_done(udbinfo.ipi_lock);
+               return (0);

        }
 
        if (req->newptr != USER_ADDR_NULL) {
        }
 
        if (req->newptr != USER_ADDR_NULL) {

-               lck_rw_done(udbinfo.mtx);
-               return EPERM;
+               lck_rw_done(udbinfo.ipi_lock);
+               return (EPERM);

        }
 
        /*
        }
 
        /*


@@ -1010,33 +1011,34 @@ udp_pcblist SYSCTL_HANDLER_ARGS
        gencnt = udbinfo.ipi_gencnt;
        n = udbinfo.ipi_count;
 
        gencnt = udbinfo.ipi_gencnt;
        n = udbinfo.ipi_count;
 

-       bzero(&xig, sizeof(xig));
-       xig.xig_len = sizeof xig;
+       bzero(&xig, sizeof (xig));
+       xig.xig_len = sizeof (xig);

        xig.xig_count = n;
        xig.xig_gen = gencnt;
        xig.xig_sogen = so_gencnt;
        xig.xig_count = n;
        xig.xig_gen = gencnt;
        xig.xig_sogen = so_gencnt;

-       error = SYSCTL_OUT(req, &xig, sizeof xig);
+       error = SYSCTL_OUT(req, &xig, sizeof (xig));

        if (error) {
        if (error) {

-               lck_rw_done(udbinfo.mtx);
-               return error;
+               lck_rw_done(udbinfo.ipi_lock);
+               return (error);

        }
        }

-    /*
-     * We are done if there is no pcb
-     */
-    if (n == 0) {
-       lck_rw_done(udbinfo.mtx);
-        return 0; 
-    }
-
-       inp_list = _MALLOC(n * sizeof *inp_list, M_TEMP, M_WAITOK);
+       /*
+        * We are done if there is no pcb
+        */
+       if (n == 0) {
+               lck_rw_done(udbinfo.ipi_lock);
+               return (0);
+       }
+
+       inp_list = _MALLOC(n * sizeof (*inp_list), M_TEMP, M_WAITOK);

        if (inp_list == 0) {
        if (inp_list == 0) {

-               lck_rw_done(udbinfo.mtx);
-               return ENOMEM;
+               lck_rw_done(udbinfo.ipi_lock);
+               return (ENOMEM);

        }
        }

-       
-       for (inp = LIST_FIRST(udbinfo.listhead), i = 0; inp && i < n;
+
+       for (inp = LIST_FIRST(udbinfo.ipi_listhead), i = 0; inp && i < n;

             inp = LIST_NEXT(inp, inp_list)) {
             inp = LIST_NEXT(inp, inp_list)) {

-               if (inp->inp_gencnt <= gencnt && inp->inp_state != INPCB_STATE_DEAD)
+               if (inp->inp_gencnt <= gencnt &&
+                   inp->inp_state != INPCB_STATE_DEAD)

                        inp_list[i++] = inp;
        }
        n = i;
                        inp_list[i++] = inp;
        }
        n = i;


@@ -1044,16 +1046,17 @@ udp_pcblist SYSCTL_HANDLER_ARGS
        error = 0;
        for (i = 0; i < n; i++) {
                inp = inp_list[i];
        error = 0;
        for (i = 0; i < n; i++) {
                inp = inp_list[i];

-               if (inp->inp_gencnt <= gencnt && inp->inp_state != INPCB_STATE_DEAD) {
+               if (inp->inp_gencnt <= gencnt &&
+                   inp->inp_state != INPCB_STATE_DEAD) {

                        struct xinpcb xi;
 
                        struct xinpcb xi;
 

-                       bzero(&xi, sizeof(xi));
-                       xi.xi_len = sizeof xi;
+                       bzero(&xi, sizeof (xi));
+                       xi.xi_len = sizeof (xi);

                        /* XXX should avoid extra copy */
                        inpcb_to_compat(inp, &xi.xi_inp);
                        if (inp->inp_socket)
                                sotoxsocket(inp->inp_socket, &xi.xi_socket);
                        /* XXX should avoid extra copy */
                        inpcb_to_compat(inp, &xi.xi_inp);
                        if (inp->inp_socket)
                                sotoxsocket(inp->inp_socket, &xi.xi_socket);

-                       error = SYSCTL_OUT(req, &xi, sizeof xi);
+                       error = SYSCTL_OUT(req, &xi, sizeof (xi));

                }
        }
        if (!error) {
                }
        }
        if (!error) {


@@ -1064,22 +1067,22 @@ udp_pcblist SYSCTL_HANDLER_ARGS
                 * while we were processing this request, and it
                 * might be necessary to retry.
                 */
                 * while we were processing this request, and it
                 * might be necessary to retry.
                 */

-               bzero(&xig, sizeof(xig));
-               xig.xig_len = sizeof xig;
+               bzero(&xig, sizeof (xig));
+               xig.xig_len = sizeof (xig);

                xig.xig_gen = udbinfo.ipi_gencnt;
                xig.xig_sogen = so_gencnt;
                xig.xig_count = udbinfo.ipi_count;
                xig.xig_gen = udbinfo.ipi_gencnt;
                xig.xig_sogen = so_gencnt;
                xig.xig_count = udbinfo.ipi_count;

-               error = SYSCTL_OUT(req, &xig, sizeof xig);
+               error = SYSCTL_OUT(req, &xig, sizeof (xig));

        }
        FREE(inp_list, M_TEMP);
        }
        FREE(inp_list, M_TEMP);

-       lck_rw_done(udbinfo.mtx);
-       return error;
+       lck_rw_done(udbinfo.ipi_lock);
+       return (error);

 }
 
 }
 

-SYSCTL_PROC(_net_inet_udp, UDPCTL_PCBLIST, pcblist, CTLFLAG_RD | CTLFLAG_LOCKED, 0, 0,
-           udp_pcblist, "S,xinpcb", "List of active UDP sockets");
+SYSCTL_PROC(_net_inet_udp, UDPCTL_PCBLIST, pcblist,
+    CTLFLAG_RD | CTLFLAG_LOCKED, 0, 0, udp_pcblist,
+    "S,xinpcb", "List of active UDP sockets");

 
 

-#if !CONFIG_EMBEDDED

 
 static int
 udp_pcblist64 SYSCTL_HANDLER_ARGS
 
 static int
 udp_pcblist64 SYSCTL_HANDLER_ARGS


@@ -1094,18 +1097,18 @@ udp_pcblist64 SYSCTL_HANDLER_ARGS
          * The process of preparing the TCB list is too time-consuming and
          * resource-intensive to repeat twice on every request.
          */
          * The process of preparing the TCB list is too time-consuming and
          * resource-intensive to repeat twice on every request.
          */

-        lck_rw_lock_shared(udbinfo.mtx);
+        lck_rw_lock_shared(udbinfo.ipi_lock);

         if (req->oldptr == USER_ADDR_NULL) {
                 n = udbinfo.ipi_count;
         if (req->oldptr == USER_ADDR_NULL) {
                 n = udbinfo.ipi_count;

-                req->oldidx = 2 * (sizeof xig)
-                        + (n + n/8) * sizeof(struct xinpcb64);
-                lck_rw_done(udbinfo.mtx);
-                return 0;
+                req->oldidx =
+                   2 * (sizeof (xig)) + (n + n/8) * sizeof (struct xinpcb64);
+                lck_rw_done(udbinfo.ipi_lock);
+                return (0);

         }
 
         if (req->newptr != USER_ADDR_NULL) {
         }
 
         if (req->newptr != USER_ADDR_NULL) {

-                lck_rw_done(udbinfo.mtx);
-                return EPERM;
+                lck_rw_done(udbinfo.ipi_lock);
+                return (EPERM);

         }
 
         /*
         }
 
         /*


@@ -1114,33 +1117,34 @@ udp_pcblist64 SYSCTL_HANDLER_ARGS
         gencnt = udbinfo.ipi_gencnt;
         n = udbinfo.ipi_count;
 
         gencnt = udbinfo.ipi_gencnt;
         n = udbinfo.ipi_count;
 

-        bzero(&xig, sizeof(xig));
-        xig.xig_len = sizeof xig;
+        bzero(&xig, sizeof (xig));
+        xig.xig_len = sizeof (xig);

         xig.xig_count = n;
         xig.xig_gen = gencnt;
         xig.xig_sogen = so_gencnt;
         xig.xig_count = n;
         xig.xig_gen = gencnt;
         xig.xig_sogen = so_gencnt;

-        error = SYSCTL_OUT(req, &xig, sizeof xig);
+        error = SYSCTL_OUT(req, &xig, sizeof (xig));

         if (error) {
         if (error) {

-                lck_rw_done(udbinfo.mtx);
-                return error;
+                lck_rw_done(udbinfo.ipi_lock);
+                return (error);

         }
         }

-    /*
-     * We are done if there is no pcb
-     */
-    if (n == 0) {
-        lck_rw_done(udbinfo.mtx);
-        return 0;
-    }
-
-        inp_list = _MALLOC(n * sizeof *inp_list, M_TEMP, M_WAITOK);
+       /*
+        * We are done if there is no pcb
+        */
+       if (n == 0) {
+               lck_rw_done(udbinfo.ipi_lock);
+               return (0);
+       }
+
+        inp_list = _MALLOC(n * sizeof (*inp_list), M_TEMP, M_WAITOK);

         if (inp_list == 0) {
         if (inp_list == 0) {

-                lck_rw_done(udbinfo.mtx);
-                return ENOMEM;
+                lck_rw_done(udbinfo.ipi_lock);
+                return (ENOMEM);

         }
 
         }
 

-        for (inp = LIST_FIRST(udbinfo.listhead), i = 0; inp && i < n;
+        for (inp = LIST_FIRST(udbinfo.ipi_listhead), i = 0; inp && i < n;

              inp = LIST_NEXT(inp, inp_list)) {
              inp = LIST_NEXT(inp, inp_list)) {

-                if (inp->inp_gencnt <= gencnt && inp->inp_state != INPCB_STATE_DEAD)
+                if (inp->inp_gencnt <= gencnt &&
+                   inp->inp_state != INPCB_STATE_DEAD)

                         inp_list[i++] = inp;
         }
         n = i;
                         inp_list[i++] = inp;
         }
         n = i;


@@ -1148,15 +1152,16 @@ udp_pcblist64 SYSCTL_HANDLER_ARGS
         error = 0;
         for (i = 0; i < n; i++) {
                 inp = inp_list[i];
         error = 0;
         for (i = 0; i < n; i++) {
                 inp = inp_list[i];

-                if (inp->inp_gencnt <= gencnt && inp->inp_state != INPCB_STATE_DEAD) {
+                if (inp->inp_gencnt <= gencnt &&
+                   inp->inp_state != INPCB_STATE_DEAD) {

                         struct xinpcb64 xi;
 
                         struct xinpcb64 xi;
 

-                        bzero(&xi, sizeof(xi));
-                        xi.xi_len = sizeof xi;
+                        bzero(&xi, sizeof (xi));
+                        xi.xi_len = sizeof (xi);

                         inpcb_to_xinpcb64(inp, &xi);
                         if (inp->inp_socket)
                                 sotoxsocket64(inp->inp_socket, &xi.xi_socket);
                         inpcb_to_xinpcb64(inp, &xi);
                         if (inp->inp_socket)
                                 sotoxsocket64(inp->inp_socket, &xi.xi_socket);

-                        error = SYSCTL_OUT(req, &xi, sizeof xi);
+                        error = SYSCTL_OUT(req, &xi, sizeof (xi));

                 }
         }
         if (!error) {
                 }
         }
         if (!error) {


@@ -1167,72 +1172,64 @@ udp_pcblist64 SYSCTL_HANDLER_ARGS
                  * while we were processing this request, and it
                  * might be necessary to retry.
                  */
                  * while we were processing this request, and it
                  * might be necessary to retry.
                  */

-                bzero(&xig, sizeof(xig));
-                xig.xig_len = sizeof xig;
+                bzero(&xig, sizeof (xig));
+                xig.xig_len = sizeof (xig);

                 xig.xig_gen = udbinfo.ipi_gencnt;
                 xig.xig_sogen = so_gencnt;
                 xig.xig_count = udbinfo.ipi_count;
                 xig.xig_gen = udbinfo.ipi_gencnt;
                 xig.xig_sogen = so_gencnt;
                 xig.xig_count = udbinfo.ipi_count;

-                error = SYSCTL_OUT(req, &xig, sizeof xig);
+                error = SYSCTL_OUT(req, &xig, sizeof (xig));

         }
         FREE(inp_list, M_TEMP);
         }
         FREE(inp_list, M_TEMP);

-        lck_rw_done(udbinfo.mtx);
-        return error;
+        lck_rw_done(udbinfo.ipi_lock);
+        return (error);

 }
 
 }
 

-SYSCTL_PROC(_net_inet_udp, OID_AUTO, pcblist64, CTLFLAG_RD | CTLFLAG_LOCKED, 0, 0,
-            udp_pcblist64, "S,xinpcb64", "List of active UDP sockets");
+SYSCTL_PROC(_net_inet_udp, OID_AUTO, pcblist64,
+    CTLFLAG_RD | CTLFLAG_LOCKED, 0, 0, udp_pcblist64,
+    "S,xinpcb64", "List of active UDP sockets");

 
 

-#endif /* !CONFIG_EMBEDDED */

 
 static int
 udp_pcblist_n SYSCTL_HANDLER_ARGS
 {
 #pragma unused(oidp, arg1, arg2)
 
 static int
 udp_pcblist_n SYSCTL_HANDLER_ARGS
 {
 #pragma unused(oidp, arg1, arg2)

-       int error = 0;
-       
-       error = get_pcblist_n(IPPROTO_UDP, req, &udbinfo);
-       
-       return error;
+       return (get_pcblist_n(IPPROTO_UDP, req, &udbinfo));

 }
 
 }
 

-SYSCTL_PROC(_net_inet_udp, OID_AUTO, pcblist_n, CTLFLAG_RD | CTLFLAG_LOCKED, 0, 0,
-            udp_pcblist_n, "S,xinpcb_n", "List of active UDP sockets");
-
+SYSCTL_PROC(_net_inet_udp, OID_AUTO, pcblist_n,
+    CTLFLAG_RD | CTLFLAG_LOCKED, 0, 0, udp_pcblist_n,
+    "S,xinpcb_n", "List of active UDP sockets");

 
 __private_extern__ void
 
 __private_extern__ void

-udp_get_ports_used(unsigned int ifindex, uint8_t *bitfield)
+udp_get_ports_used(uint32_t ifindex, int protocol, uint32_t wildcardok,
+    bitstr_t *bitfield)

 {
 {

-       inpcb_get_ports_used(ifindex, bitfield, &udbinfo);
+       inpcb_get_ports_used(ifindex, protocol, wildcardok, bitfield, &udbinfo);

 }
 
 __private_extern__ uint32_t
 udp_count_opportunistic(unsigned int ifindex, u_int32_t flags)
 {
 }
 
 __private_extern__ uint32_t
 udp_count_opportunistic(unsigned int ifindex, u_int32_t flags)
 {

-       return inpcb_count_opportunistic(ifindex, &udbinfo, flags);
+       return (inpcb_count_opportunistic(ifindex, &udbinfo, flags));

 }
 
 }
 

-static __inline__ u_int16_t
-get_socket_id(struct socket * s)
+__private_extern__ uint32_t
+udp_find_anypcb_byaddr(struct ifaddr *ifa)

 {
 {

-       u_int16_t               val;
-
-       if (s == NULL) {
-           return (0);
-       }
-       val = (u_int16_t)(((uintptr_t)s) / sizeof(struct socket));
-       if (val == 0) {
-               val = 0xffff;
-       }
-       return (val);
+       return (inpcb_find_anypcb_byaddr(ifa, &udbinfo));

 }
 
 static int
 }
 
 static int

-udp_check_pktinfo(struct mbuf *control, struct ifnet **outif, struct in_addr *laddr)
+udp_check_pktinfo(struct mbuf *control, struct ifnet **outif,
+    struct in_addr *laddr)

 {
        struct cmsghdr *cm = 0;
        struct in_pktinfo *pktinfo;
        struct ifnet *ifp;
 
 {
        struct cmsghdr *cm = 0;
        struct in_pktinfo *pktinfo;
        struct ifnet *ifp;
 

+       if (outif != NULL)
+               *outif = NULL;
+

        /*
         * XXX: Currently, we assume all the optional information is stored
         * in a single mbuf.
        /*
         * XXX: Currently, we assume all the optional information is stored
         * in a single mbuf.


@@ -1243,14 +1240,16 @@ udp_check_pktinfo(struct mbuf *control, struct ifnet **outif, struct in_addr *la
        if (control->m_len < CMSG_LEN(0))
                return (EINVAL);
 
        if (control->m_len < CMSG_LEN(0))
                return (EINVAL);
 

-       for (cm = M_FIRST_CMSGHDR(control); cm; cm = M_NXT_CMSGHDR(control, cm)) {
-               if (cm->cmsg_len < sizeof(struct cmsghdr) || cm->cmsg_len > control->m_len)
+       for (cm = M_FIRST_CMSGHDR(control); cm;
+           cm = M_NXT_CMSGHDR(control, cm)) {
+               if (cm->cmsg_len < sizeof (struct cmsghdr) ||
+                   cm->cmsg_len > control->m_len)

                        return (EINVAL);
 
                if (cm->cmsg_level != IPPROTO_IP || cm->cmsg_type != IP_PKTINFO)
                        continue;
 
                        return (EINVAL);
 
                if (cm->cmsg_level != IPPROTO_IP || cm->cmsg_type != IP_PKTINFO)
                        continue;
 

-               if (cm->cmsg_len != CMSG_LEN(sizeof(struct in_pktinfo)))
+               if (cm->cmsg_len != CMSG_LEN(sizeof (struct in_pktinfo)))

                        return (EINVAL);
 
                pktinfo =  (struct in_pktinfo *)(void *)CMSG_DATA(cm);
                        return (EINVAL);
 
                pktinfo =  (struct in_pktinfo *)(void *)CMSG_DATA(cm);


@@ -1263,28 +1262,31 @@ udp_check_pktinfo(struct mbuf *control, struct ifnet **outif, struct in_addr *la
                        return (ENXIO);
                }
 
                        return (ENXIO);
                }
 

-               /* If ipi_ifindex is specified it takes precedence over ipi_spec_dst */
-
+               /*
+                * If ipi_ifindex is specified it takes precedence
+                * over ipi_spec_dst.
+                */

                if (pktinfo->ipi_ifindex) {
                        ifp = ifindex2ifnet[pktinfo->ipi_ifindex];
                        if (ifp == NULL) {
                                ifnet_head_done();
                                return (ENXIO);
                        }
                if (pktinfo->ipi_ifindex) {
                        ifp = ifindex2ifnet[pktinfo->ipi_ifindex];
                        if (ifp == NULL) {
                                ifnet_head_done();
                                return (ENXIO);
                        }

-
-                       ifnet_head_done();
-
-                       if (outif != NULL)
+                       if (outif != NULL) {
+                               ifnet_reference(ifp);

                                *outif = ifp;
                                *outif = ifp;

+                       }
+                       ifnet_head_done();

                        laddr->s_addr = INADDR_ANY;
                        break;
                }
 
                ifnet_head_done();
 
                        laddr->s_addr = INADDR_ANY;
                        break;
                }
 
                ifnet_head_done();
 

-               /* Use the provided ipi_spec_dst address for temp source address */
-               if (outif != NULL)
-                       *outif = NULL;
+               /*
+                * Use the provided ipi_spec_dst address for temp
+                * source address.
+                */

                *laddr = pktinfo->ipi_spec_dst;
                break;
        }
                *laddr = pktinfo->ipi_spec_dst;
                break;
        }


@@ -1292,26 +1294,22 @@ udp_check_pktinfo(struct mbuf *control, struct ifnet **outif, struct in_addr *la
 }
 
 static int
 }
 
 static int

-udp_output(inp, m, addr, control, p)
-       register struct inpcb *inp;
-       struct mbuf *m;
-       struct sockaddr *addr;
-       struct mbuf *control;
-       struct proc *p;
+udp_output(struct inpcb *inp, struct mbuf *m, struct sockaddr *addr,
+    struct mbuf *control, struct proc *p)

 {
 {

-       register struct udpiphdr *ui;
-       register int len = m->m_pkthdr.len;
+       struct udpiphdr *ui;
+       int len = m->m_pkthdr.len;

        struct sockaddr_in *sin;
        struct in_addr origladdr, laddr, faddr, pi_laddr;
        u_short lport, fport;
        struct sockaddr_in *sin;
        struct in_addr origladdr, laddr, faddr, pi_laddr;
        u_short lport, fport;

-       struct sockaddr_in ifaddr;

        int error = 0, udp_dodisconnect = 0, pktinfo = 0;
        struct socket *so = inp->inp_socket;
        int soopts = 0;
        struct mbuf *inpopts;
        struct ip_moptions *mopts;
        struct route ro;
        int error = 0, udp_dodisconnect = 0, pktinfo = 0;
        struct socket *so = inp->inp_socket;
        int soopts = 0;
        struct mbuf *inpopts;
        struct ip_moptions *mopts;
        struct route ro;

-       struct ip_out_args ipoa = { IFSCOPE_NONE, { 0 }, IPOAF_SELECT_SRCIF };
+       struct ip_out_args ipoa =
+           { IFSCOPE_NONE, { 0 }, IPOAF_SELECT_SRCIF, 0 };

        struct ifnet *outif = NULL;
        struct flowadv *adv = &ipoa.ipoa_flowadv;
        mbuf_svc_class_t msc = MBUF_SC_UNSPEC;
        struct ifnet *outif = NULL;
        struct flowadv *adv = &ipoa.ipoa_flowadv;
        mbuf_svc_class_t msc = MBUF_SC_UNSPEC;


@@ -1320,7 +1318,6 @@ udp_output(inp, m, addr, control, p)
 
        /* Enable flow advisory only when connected */
        flowadv = (so->so_state & SS_ISCONNECTED) ? 1 : 0;
 
        /* Enable flow advisory only when connected */
        flowadv = (so->so_state & SS_ISCONNECTED) ? 1 : 0;

-

        pi_laddr.s_addr = INADDR_ANY;
 
        KERNEL_DEBUG(DBG_FNC_UDP_OUTPUT | DBG_FUNC_START, 0,0,0,0,0);
        pi_laddr.s_addr = INADDR_ANY;
 
        KERNEL_DEBUG(DBG_FNC_UDP_OUTPUT | DBG_FUNC_START, 0,0,0,0,0);


@@ -1328,10 +1325,10 @@ udp_output(inp, m, addr, control, p)
        lck_mtx_assert(&inp->inpcb_mtx, LCK_MTX_ASSERT_OWNED);
        if (control != NULL) {
                msc = mbuf_service_class_from_control(control);
        lck_mtx_assert(&inp->inpcb_mtx, LCK_MTX_ASSERT_OWNED);
        if (control != NULL) {
                msc = mbuf_service_class_from_control(control);

-
+               VERIFY(outif == NULL);

                error = udp_check_pktinfo(control, &outif, &pi_laddr);
                error = udp_check_pktinfo(control, &outif, &pi_laddr);

-

                m_freem(control);
                m_freem(control);

+               control = NULL;

                if (error)
                        goto release;
                pktinfo++;
                if (error)
                        goto release;
                pktinfo++;


@@ -1340,10 +1337,10 @@ udp_output(inp, m, addr, control, p)
        }
 
        KERNEL_DEBUG(DBG_LAYER_OUT_BEG, inp->inp_fport, inp->inp_lport,
        }
 
        KERNEL_DEBUG(DBG_LAYER_OUT_BEG, inp->inp_fport, inp->inp_lport,

-                    inp->inp_laddr.s_addr, inp->inp_faddr.s_addr,
-                    (htons((u_short)len + sizeof (struct udphdr))));
+           inp->inp_laddr.s_addr, inp->inp_faddr.s_addr,
+           (htons((u_short)len + sizeof (struct udphdr))));

 
 

-       if (len + sizeof(struct udpiphdr) > IP_MAXPACKET) {
+       if (len + sizeof (struct udpiphdr) > IP_MAXPACKET) {

                error = EMSGSIZE;
                goto release;
        }
                error = EMSGSIZE;
                goto release;
        }


@@ -1361,8 +1358,12 @@ udp_output(inp, m, addr, control, p)
         * If the ancillary IP_PKTINFO option contains an interface index,
         * it takes precedence over the one specified by IP_BOUND_IF.
         */
         * If the ancillary IP_PKTINFO option contains an interface index,
         * it takes precedence over the one specified by IP_BOUND_IF.
         */

-       if (ipoa.ipoa_boundif == IFSCOPE_NONE && 
-               (inp->inp_flags & INP_BOUND_IF)) {
+       if (ipoa.ipoa_boundif == IFSCOPE_NONE &&
+           (inp->inp_flags & INP_BOUND_IF)) {
+               VERIFY(inp->inp_boundifp != NULL);
+               ifnet_reference(inp->inp_boundifp);     /* for this routine */
+               if (outif != NULL)
+                       ifnet_release(outif);

                outif = inp->inp_boundifp;
                ipoa.ipoa_boundif = outif->if_index;
        }
                outif = inp->inp_boundifp;
                ipoa.ipoa_boundif = outif->if_index;
        }


@@ -1370,25 +1371,29 @@ udp_output(inp, m, addr, control, p)
                ipoa.ipoa_flags |=  IPOAF_NO_CELLULAR;
        soopts |= IP_OUTARGS;
 
                ipoa.ipoa_flags |=  IPOAF_NO_CELLULAR;
        soopts |= IP_OUTARGS;
 

-       /* If there was a routing change, discard cached route and check
-        * that we have a valid source address. 
-        * Reacquire a new source address if INADDR_ANY was specified
+       /*
+        * If there was a routing change, discard cached route and check
+        * that we have a valid source address.  Reacquire a new source
+        * address if INADDR_ANY was specified.

         */
         */

-       if (inp->inp_route.ro_rt != NULL &&
-           inp->inp_route.ro_rt->generation_id != route_generation) {
-               struct in_ifaddr *ia;
+       if (ROUTE_UNUSABLE(&inp->inp_route)) {
+               struct in_ifaddr *ia = NULL;
+
+               ROUTE_RELEASE(&inp->inp_route);

 
                /* src address is gone? */
 
                /* src address is gone? */

-               if ((ia = ifa_foraddr(inp->inp_laddr.s_addr)) == NULL) {
-                       if (((inp->inp_flags & INP_INADDR_ANY) == 0) || 
+               if (inp->inp_laddr.s_addr != INADDR_ANY &&
+                   (ia = ifa_foraddr(inp->inp_laddr.s_addr)) == NULL) {
+                       if (!(inp->inp_flags & INP_INADDR_ANY) ||

                            (so->so_state & SS_ISCONNECTED)) {
                            (so->so_state & SS_ISCONNECTED)) {

-                               /* Rdar://5448998
-                                * If the source address is gone, return an error if:
+                               /*
+                                * Rdar://5448998
+                                * If the source address is gone, return an
+                                * error if:

                                 * - the source was specified
                                 * - the socket was already connected
                                 */
                                 * - the source was specified
                                 * - the socket was already connected
                                 */

-                               soevent(so,
-                                   (SO_FILT_HINT_LOCKED | 
+                               soevent(so, (SO_FILT_HINT_LOCKED |

                                    SO_FILT_HINT_NOSRCADDR));
                                error = EADDRNOTAVAIL;
                                goto release;
                                    SO_FILT_HINT_NOSRCADDR));
                                error = EADDRNOTAVAIL;
                                goto release;


@@ -1400,24 +1405,24 @@ udp_output(inp, m, addr, control, p)
                }
                if (ia != NULL)
                        IFA_REMREF(&ia->ia_ifa);
                }
                if (ia != NULL)
                        IFA_REMREF(&ia->ia_ifa);

-               if (inp->inp_route.ro_rt != NULL)
-                       rtfree(inp->inp_route.ro_rt);
-               inp->inp_route.ro_rt = NULL;

        }
 
        origoutifp = inp->inp_last_outifp;
 
        }
 
        origoutifp = inp->inp_last_outifp;
 

-       /* IP_PKTINFO option check.
-        * If a temporary scope or src address is provided, use it for this packet only
-        * and make sure we forget it after sending this datagram.
+       /*
+        * IP_PKTINFO option check.  If a temporary scope or src address
+        * is provided, use it for this packet only and make sure we forget
+        * it after sending this datagram.

         */
         */

-

        if (pi_laddr.s_addr != INADDR_ANY ||
            (ipoa.ipoa_boundif != IFSCOPE_NONE && pktinfo)) {
        if (pi_laddr.s_addr != INADDR_ANY ||
            (ipoa.ipoa_boundif != IFSCOPE_NONE && pktinfo)) {

-               laddr = pi_laddr; /* temp src address for this datagram only */
+               /* temp src address for this datagram only */
+               laddr = pi_laddr;

                origladdr.s_addr = INADDR_ANY;
                origladdr.s_addr = INADDR_ANY;

-               udp_dodisconnect = 1; /* we don't want to keep the laddr or route */
-               inp->inp_flags |= INP_INADDR_ANY; /* remember we don't care about src addr.*/
+               /* we don't want to keep the laddr or route */
+               udp_dodisconnect = 1;
+               /* remember we don't care about src addr.*/
+               inp->inp_flags |= INP_INADDR_ANY;

        } else {
                origladdr = laddr = inp->inp_laddr;
        }
        } else {
                origladdr = laddr = inp->inp_laddr;
        }


@@ -1435,40 +1440,59 @@ udp_output(inp, m, addr, control, p)
                }
                if (lport == 0) {
                        /*
                }
                if (lport == 0) {
                        /*

-                        * In case we don't have a local port set, go through the full connect.
-                        * We don't have a local port yet (ie, we can't be looked up),
-                        * so it's not an issue if the input runs at the same time we do this.
+                        * In case we don't have a local port set, go through
+                        * the full connect.  We don't have a local port yet
+                        * (i.e., we can't be looked up), so it's not an issue
+                        * if the input runs at the same time we do this.

                         */
                         */

-
-                       if (pi_laddr.s_addr != INADDR_ANY)      /* if we have a source address specified, use that */
+                       /* if we have a source address specified, use that */
+                       if (pi_laddr.s_addr != INADDR_ANY)

                                inp->inp_laddr = pi_laddr;
                                inp->inp_laddr = pi_laddr;

-                       error = in_pcbconnect(inp, addr, p, &outif); /* if a scope is specified, use it */
-                       if (error) {
+                       /*
+                        * If a scope is specified, use it.  Scope from
+                        * IP_PKTINFO takes precendence over the the scope
+                        * set via INP_BOUND_IF.
+                        */
+                       error = in_pcbconnect(inp, addr, p, ipoa.ipoa_boundif,
+                           &outif);
+                       if (error)

                                goto release;
                                goto release;

-                       }
+

                        laddr = inp->inp_laddr;
                        lport = inp->inp_lport;
                        faddr = inp->inp_faddr;
                        fport = inp->inp_fport;
                        udp_dodisconnect = 1;
                        laddr = inp->inp_laddr;
                        lport = inp->inp_lport;
                        faddr = inp->inp_faddr;
                        fport = inp->inp_fport;
                        udp_dodisconnect = 1;

-                       ipoa.ipoa_boundif = (outif != NULL) ?
-                           outif->if_index : IFSCOPE_NONE;
+
+                       /* synch up in case in_pcbladdr() overrides */
+                       if (outif != NULL && ipoa.ipoa_boundif != IFSCOPE_NONE)
+                               ipoa.ipoa_boundif = outif->if_index;

                }
                else {
                }
                else {

-                       /* Fast path case
-                        * we have a full address and a local port.
-                        * use those info to build the packet without changing the pcb
-                        * and interfering with the input path. See 3851370
-                        * Note: if we may have a scope from IP_PKTINFO but the
-                        * priority is always given to the scope provided by INP_BOUND_IF.
+                       /*
+                        * Fast path case
+                        *
+                        * We have a full address and a local port; use those
+                        * info to build the packet without changing the pcb
+                        * and interfering with the input path. See 3851370.
+                        *
+                        * Scope from IP_PKTINFO takes precendence over the
+                        * the scope set via INP_BOUND_IF.

                         */
                        if (laddr.s_addr == INADDR_ANY) {
                         */
                        if (laddr.s_addr == INADDR_ANY) {

-                               if ((error = in_pcbladdr(inp, addr, &ifaddr, &outif)) != 0)
+                               if ((error = in_pcbladdr(inp, addr, &laddr,
+                                   ipoa.ipoa_boundif, &outif)) != 0)

                                        goto release;
                                        goto release;

-                               laddr = ifaddr.sin_addr;
-                               inp->inp_flags |= INP_INADDR_ANY; /* from pcbconnect: remember we don't care about src addr.*/
-                               ipoa.ipoa_boundif = (outif != NULL) ?
-                                   outif->if_index : IFSCOPE_NONE;
+                               /*
+                                * from pcbconnect: remember we don't
+                                * care about src addr.
+                                */
+                               inp->inp_flags |= INP_INADDR_ANY;
+
+                               /* synch up in case in_pcbladdr() overrides */
+                               if (outif != NULL &&
+                                   ipoa.ipoa_boundif != IFSCOPE_NONE)
+                                       ipoa.ipoa_boundif = outif->if_index;

                        }
 
                        faddr = sin->sin_addr;
                        }
 
                        faddr = sin->sin_addr;


@@ -1483,7 +1507,8 @@ udp_output(inp, m, addr, control, p)
 
 #if CONFIG_MACF_NET
        mac_mbuf_label_associate_inpcb(inp, m);
 
 #if CONFIG_MACF_NET
        mac_mbuf_label_associate_inpcb(inp, m);

-#endif
+#endif /* CONFIG_MACF_NET */
+

        if (inp->inp_flowhash == 0)
                inp->inp_flowhash = inp_calc_flowhash(inp);
 
        if (inp->inp_flowhash == 0)
                inp->inp_flowhash = inp_calc_flowhash(inp);
 


@@ -1491,7 +1516,7 @@ udp_output(inp, m, addr, control, p)
         * Calculate data length and get a mbuf
         * for UDP and IP headers.
         */
         * Calculate data length and get a mbuf
         * for UDP and IP headers.
         */

-       M_PREPEND(m, sizeof(struct udpiphdr), M_DONTWAIT);
+       M_PREPEND(m, sizeof (struct udpiphdr), M_DONTWAIT);

        if (m == 0) {
                error = ENOBUFS;
                goto abort;
        if (m == 0) {
                error = ENOBUFS;
                goto abort;


@@ -1502,20 +1527,20 @@ udp_output(inp, m, addr, control, p)
         * and addresses and length put into network format.
         */
        ui = mtod(m, struct udpiphdr *);
         * and addresses and length put into network format.
         */
        ui = mtod(m, struct udpiphdr *);

-       bzero(ui->ui_x1, sizeof(ui->ui_x1));    /* XXX still needed? */
+       bzero(ui->ui_x1, sizeof (ui->ui_x1));   /* XXX still needed? */

        ui->ui_pr = IPPROTO_UDP;
        ui->ui_src = laddr;
        ui->ui_dst = faddr;
        ui->ui_sport = lport;
        ui->ui_dport = fport;
        ui->ui_pr = IPPROTO_UDP;
        ui->ui_src = laddr;
        ui->ui_dst = faddr;
        ui->ui_sport = lport;
        ui->ui_dport = fport;

-       ui->ui_ulen = htons((u_short)len + sizeof(struct udphdr));
+       ui->ui_ulen = htons((u_short)len + sizeof (struct udphdr));

 
        /*
         * Set up checksum and output datagram.
         */
        if (udpcksum && !(inp->inp_flags & INP_UDP_NOCKSUM)) {
 
        /*
         * Set up checksum and output datagram.
         */
        if (udpcksum && !(inp->inp_flags & INP_UDP_NOCKSUM)) {

-               ui->ui_sum = in_pseudo(ui->ui_src.s_addr, ui->ui_dst.s_addr,
-                   htons((u_short)len + sizeof(struct udphdr) + IPPROTO_UDP));
+               ui->ui_sum = in_pseudo(ui->ui_src.s_addr, ui->ui_dst.s_addr,
+                   htons((u_short)len + sizeof (struct udphdr) + IPPROTO_UDP));

                m->m_pkthdr.csum_flags = CSUM_UDP;
                m->m_pkthdr.csum_data = offsetof(struct udphdr, uh_sum);
        } else {
                m->m_pkthdr.csum_flags = CSUM_UDP;
                m->m_pkthdr.csum_data = offsetof(struct udphdr, uh_sum);
        } else {


@@ -1534,7 +1559,7 @@ udp_output(inp, m, addr, control, p)
                error = ENOBUFS;
                goto abort;
        }
                error = ENOBUFS;
                goto abort;
        }

-#endif /*IPSEC*/
+#endif /* IPSEC */

 
        inpopts = inp->inp_options;
        soopts |= (inp->inp_socket->so_options & (SO_DONTROUTE | SO_BROADCAST));
 
        inpopts = inp->inp_options;
        soopts |= (inp->inp_socket->so_options & (SO_DONTROUTE | SO_BROADCAST));


@@ -1543,7 +1568,8 @@ udp_output(inp, m, addr, control, p)
                IMO_LOCK(mopts);
                IMO_ADDREF_LOCKED(mopts);
                if (IN_MULTICAST(ntohl(ui->ui_dst.s_addr)) &&
                IMO_LOCK(mopts);
                IMO_ADDREF_LOCKED(mopts);
                if (IN_MULTICAST(ntohl(ui->ui_dst.s_addr)) &&

-                               mopts->imo_multicast_ifp != NULL) {
+                   mopts->imo_multicast_ifp != NULL) {
+                       /* no reference needed */

                        inp->inp_last_outifp = mopts->imo_multicast_ifp;
                }
                IMO_UNLOCK(mopts);
                        inp->inp_last_outifp = mopts->imo_multicast_ifp;
                }
                IMO_UNLOCK(mopts);


@@ -1553,11 +1579,12 @@ udp_output(inp, m, addr, control, p)
        inp_route_copyout(inp, &ro);
 
        set_packet_service_class(m, so, msc, 0);
        inp_route_copyout(inp, &ro);
 
        set_packet_service_class(m, so, msc, 0);

-       m->m_pkthdr.socket_id = get_socket_id(inp->inp_socket);
-       m->m_pkthdr.m_flowhash = inp->inp_flowhash;
-       m->m_pkthdr.m_fhflags |= PF_TAG_FLOWHASH;
+       m->m_pkthdr.pkt_flowsrc = FLOWSRC_INPCB;
+       m->m_pkthdr.pkt_flowid = inp->inp_flowhash;
+       m->m_pkthdr.pkt_proto = IPPROTO_UDP;
+       m->m_pkthdr.pkt_flags |= (PKTF_FLOW_ID | PKTF_FLOW_LOCALSRC);

        if (flowadv)
        if (flowadv)

-               m->m_pkthdr.m_fhflags |= PF_TAG_FLOWADV;
+               m->m_pkthdr.pkt_flags |= PKTF_FLOW_ADV;

 
        if (ipoa.ipoa_boundif != IFSCOPE_NONE)
                ipoa.ipoa_flags |= IPOAF_BOUND_IF;
 
        if (ipoa.ipoa_boundif != IFSCOPE_NONE)
                ipoa.ipoa_flags |= IPOAF_BOUND_IF;


@@ -1568,15 +1595,23 @@ udp_output(inp, m, addr, control, p)
        inp->inp_sndinprog_cnt++;
 
        socket_unlock(so, 0);
        inp->inp_sndinprog_cnt++;
 
        socket_unlock(so, 0);

-       error = ip_output_list(m, 0, inpopts, &ro, soopts, mopts, &ipoa);
+       error = ip_output(m, inpopts, &ro, soopts, mopts, &ipoa);

        m = NULL;
        socket_lock(so, 0);
        if (mopts != NULL)
                IMO_REMREF(mopts);
 
        if (error == 0 && nstat_collect) {
        m = NULL;
        socket_lock(so, 0);
        if (mopts != NULL)
                IMO_REMREF(mopts);
 
        if (error == 0 && nstat_collect) {

-               locked_add_64(&inp->inp_stat->txpackets, 1);
-               locked_add_64(&inp->inp_stat->txbytes, len);
+               boolean_t cell, wifi;
+
+               if (ro.ro_rt != NULL) {
+                       cell = IFNET_IS_CELLULAR(ro.ro_rt->rt_ifp);
+                       wifi = (!cell && IFNET_IS_WIFI(ro.ro_rt->rt_ifp));
+               } else {
+                       cell = wifi = FALSE;
+               }
+               INP_ADD_STAT(inp, cell, wifi, txpackets, 1);
+               INP_ADD_STAT(inp, cell, wifi, txbytes, len);

        }
 
        if (flowadv && (adv->code == FADV_FLOW_CONTROLLED ||
        }
 
        if (flowadv && (adv->code == FADV_FLOW_CONTROLLED ||


@@ -1598,12 +1633,10 @@ udp_output(inp, m, addr, control, p)
 abort:
        if (udp_dodisconnect) {
                /* Always discard the cached route for unconnected socket */
 abort:
        if (udp_dodisconnect) {
                /* Always discard the cached route for unconnected socket */

-               if (inp->inp_route.ro_rt != NULL) {
-                       rtfree(inp->inp_route.ro_rt);
-                       inp->inp_route.ro_rt = NULL;
-               }
+               ROUTE_RELEASE(&inp->inp_route);

                in_pcbdisconnect(inp);
                inp->inp_laddr = origladdr;     /* XXX rehash? */
                in_pcbdisconnect(inp);
                inp->inp_laddr = origladdr;     /* XXX rehash? */

+               /* no reference needed */

                inp->inp_last_outifp = origoutifp;
        } else if (inp->inp_route.ro_rt != NULL) {
                struct rtentry *rt = inp->inp_route.ro_rt;
                inp->inp_last_outifp = origoutifp;
        } else if (inp->inp_route.ro_rt != NULL) {
                struct rtentry *rt = inp->inp_route.ro_rt;


@@ -1614,22 +1647,36 @@ abort:
                /*
                 * Always discard if it is a multicast or broadcast route.
                 */
                /*
                 * Always discard if it is a multicast or broadcast route.
                 */

-               if (rt == NULL) {
-                       rtfree(inp->inp_route.ro_rt);
-                       inp->inp_route.ro_rt = NULL;
-               }
+               if (rt == NULL)
+                       ROUTE_RELEASE(&inp->inp_route);
+

                /*
                 * If the destination route is unicast, update outifp with
                 * that of the route interface used by IP.
                 */
                if (rt != NULL && (outifp = rt->rt_ifp) != inp->inp_last_outifp)
                /*
                 * If the destination route is unicast, update outifp with
                 * that of the route interface used by IP.
                 */
                if (rt != NULL && (outifp = rt->rt_ifp) != inp->inp_last_outifp)

-                       inp->inp_last_outifp = outifp;
+                       inp->inp_last_outifp = outifp;  /* no reference needed */
+       } else {
+               ROUTE_RELEASE(&inp->inp_route);

        }
 
        }
 

+       /*
+        * If output interface was cellular, and this socket is denied
+        * access to it, generate an event.
+        */
+       if (error != 0 && (ipoa.ipoa_retflags & IPOARF_IFDENIED) &&
+           (inp->inp_flags & INP_NO_IFT_CELLULAR))
+               soevent(so, (SO_FILT_HINT_LOCKED|SO_FILT_HINT_IFDENIED));
+

 release:
 release:

+       KERNEL_DEBUG(DBG_FNC_UDP_OUTPUT | DBG_FUNC_END, error, 0, 0, 0, 0);
+

        if (m != NULL)
                m_freem(m);
        if (m != NULL)
                m_freem(m);

-       KERNEL_DEBUG(DBG_FNC_UDP_OUTPUT | DBG_FUNC_END, error, 0,0,0,0);
+
+       if (outif != NULL)
+               ifnet_release(outif);
+

        return (error);
 }
 
        return (error);
 }
 


@@ -1637,47 +1684,50 @@ u_int32_t       udp_sendspace = 9216;           /* really max datagram size */
 /* 187 1K datagrams (approx 192 KB) */
 u_int32_t      udp_recvspace = 187 * (1024 +
 #if INET6
 /* 187 1K datagrams (approx 192 KB) */
 u_int32_t      udp_recvspace = 187 * (1024 +
 #if INET6

-                                     sizeof(struct sockaddr_in6)
-#else
-                                     sizeof(struct sockaddr_in)
-#endif
-                                     );
+                   sizeof (struct sockaddr_in6)
+#else /* !INET6 */
+                   sizeof (struct sockaddr_in)
+#endif /* !INET6 */
+               );

 
 /* Check that the values of udp send and recv space do not exceed sb_max */
 static int
 
 /* Check that the values of udp send and recv space do not exceed sb_max */
 static int

-sysctl_udp_sospace(struct sysctl_oid *oidp, __unused void *arg1,
-       __unused int arg2, struct sysctl_req *req) {
+sysctl_udp_sospace(struct sysctl_oid *oidp, void *arg1, int arg2,
+    struct sysctl_req *req)
+{
+#pragma unused(arg1, arg2)

        u_int32_t new_value = 0, *space_p = NULL;
        int changed = 0, error = 0;
        u_int32_t new_value = 0, *space_p = NULL;
        int changed = 0, error = 0;

-       u_quad_t sb_effective_max = (sb_max/ (MSIZE+MCLBYTES)) * MCLBYTES;
+       u_quad_t sb_effective_max = (sb_max/(MSIZE+MCLBYTES)) * MCLBYTES;

 
        switch (oidp->oid_number) {
 
        switch (oidp->oid_number) {

-               case UDPCTL_RECVSPACE:
-                       space_p = &udp_recvspace;
-                       break;
-               case UDPCTL_MAXDGRAM:
-                       space_p = &udp_sendspace;
-                       break;
-               default:
-                       return EINVAL;
+       case UDPCTL_RECVSPACE:
+               space_p = &udp_recvspace;
+               break;
+       case UDPCTL_MAXDGRAM:
+               space_p = &udp_sendspace;
+               break;
+       default:
+               return EINVAL;

        }
        }

-        error = sysctl_io_number(req, *space_p, sizeof(u_int32_t),
-                &new_value, &changed);
+        error = sysctl_io_number(req, *space_p, sizeof (u_int32_t),
+           &new_value, &changed);

         if (changed) {
         if (changed) {

-                if (new_value > 0 && new_value <= sb_effective_max) {
+                if (new_value > 0 && new_value <= sb_effective_max)

                         *space_p = new_value;
                         *space_p = new_value;

-                } else {
+                else

                         error = ERANGE;
                         error = ERANGE;

-                }

         }
         }

-        return error;
+        return (error);

 }
 
 }
 

-SYSCTL_PROC(_net_inet_udp, UDPCTL_RECVSPACE, recvspace, CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED,
-    &udp_recvspace, 0, &sysctl_udp_sospace, "IU", "Maximum incoming UDP datagram size");
+SYSCTL_PROC(_net_inet_udp, UDPCTL_RECVSPACE, recvspace,
+    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED, &udp_recvspace, 0,
+    &sysctl_udp_sospace, "IU", "Maximum incoming UDP datagram size");

 
 

-SYSCTL_PROC(_net_inet_udp, UDPCTL_MAXDGRAM, maxdgram, CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED,
-    &udp_sendspace, 0, &sysctl_udp_sospace, "IU", "Maximum outgoing UDP datagram size");
+SYSCTL_PROC(_net_inet_udp, UDPCTL_MAXDGRAM, maxdgram,
+    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED, &udp_sendspace, 0,
+    &sysctl_udp_sospace, "IU", "Maximum outgoing UDP datagram size");

 
 static int
 udp_abort(struct socket *so)
 
 static int
 udp_abort(struct socket *so)


@@ -1685,35 +1735,39 @@ udp_abort(struct socket *so)
        struct inpcb *inp;
 
        inp = sotoinpcb(so);
        struct inpcb *inp;
 
        inp = sotoinpcb(so);

-       if (inp == 0)
-               panic("udp_abort: so=%p null inp\n", so);       /* ??? possible? panic instead? */
+       if (inp == NULL) {
+               panic("%s: so=%p null inp\n", __func__, so);
+               /* NOTREACHED */
+       }

        soisdisconnected(so);
        in_pcbdetach(inp);
        soisdisconnected(so);
        in_pcbdetach(inp);

-       return 0;
+       return (0);

 }
 
 static int
 }
 
 static int

-udp_attach(struct socket *so, __unused int proto, struct proc *p)
+udp_attach(struct socket *so, int proto, struct proc *p)

 {
 {

+#pragma unused(proto)

        struct inpcb *inp;
        int error;
 
        inp = sotoinpcb(so);
        struct inpcb *inp;
        int error;
 
        inp = sotoinpcb(so);

-       if (inp != 0)
-               panic ("udp_attach so=%p inp=%p\n", so, inp);
-
+       if (inp != NULL) {
+               panic ("%s so=%p inp=%p\n", __func__, so, inp);
+               /* NOTREACHED */
+       }

        error = in_pcballoc(so, &udbinfo, p);
        error = in_pcballoc(so, &udbinfo, p);

-       if (error)
-               return error;
+       if (error != 0)
+               return (error);

        error = soreserve(so, udp_sendspace, udp_recvspace);
        error = soreserve(so, udp_sendspace, udp_recvspace);

-       if (error) 
-               return error;
+       if (error != 0)
+               return (error);

        inp = (struct inpcb *)so->so_pcb;
        inp->inp_vflag |= INP_IPV4;
        inp->inp_ip_ttl = ip_defttl;
        if (nstat_collect)
                nstat_udp_new_pcb(inp);
        inp = (struct inpcb *)so->so_pcb;
        inp->inp_vflag |= INP_IPV4;
        inp->inp_ip_ttl = ip_defttl;
        if (nstat_collect)
                nstat_udp_new_pcb(inp);

-       return 0;
+       return (0);

 }
 
 static int
 }
 
 static int


@@ -1722,15 +1776,15 @@ udp_bind(struct socket *so, struct sockaddr *nam, struct proc *p)
        struct inpcb *inp;
        int error;
 
        struct inpcb *inp;
        int error;
 

-       if (nam->sa_family != 0 && nam->sa_family != AF_INET
-           && nam->sa_family != AF_INET6) {
-               return EAFNOSUPPORT;
-       }
+       if (nam->sa_family != 0 && nam->sa_family != AF_INET &&
+           nam->sa_family != AF_INET6)
+               return (EAFNOSUPPORT);
+

        inp = sotoinpcb(so);
        inp = sotoinpcb(so);

-       if (inp == 0)
-               return EINVAL;
+       if (inp == NULL || (inp->inp_flags2 & INP2_WANT_FLOW_DIVERT))
+               return (inp == NULL ? EINVAL : EPROTOTYPE);

        error = in_pcbbind(inp, nam, p);
        error = in_pcbbind(inp, nam, p);

-       return error;
+       return (error);

 }
 
 static int
 }
 
 static int


@@ -1740,17 +1794,86 @@ udp_connect(struct socket *so, struct sockaddr *nam, struct proc *p)
        int error;
 
        inp = sotoinpcb(so);
        int error;
 
        inp = sotoinpcb(so);

-       if (inp == 0)
-               return EINVAL;
+       if (inp == NULL || (inp->inp_flags2 & INP2_WANT_FLOW_DIVERT))
+               return (inp == NULL ? EINVAL : EPROTOTYPE);

        if (inp->inp_faddr.s_addr != INADDR_ANY)
        if (inp->inp_faddr.s_addr != INADDR_ANY)

-               return EISCONN;
-       error = in_pcbconnect(inp, nam, p, NULL);
+               return (EISCONN);
+       error = in_pcbconnect(inp, nam, p, IFSCOPE_NONE, NULL);

        if (error == 0) {
                soisconnected(so);
                if (inp->inp_flowhash == 0)
                        inp->inp_flowhash = inp_calc_flowhash(inp);
        }
        if (error == 0) {
                soisconnected(so);
                if (inp->inp_flowhash == 0)
                        inp->inp_flowhash = inp_calc_flowhash(inp);
        }

-       return error;
+       return (error);
+}
+
+int
+udp_connectx_common(struct socket *so, int af,
+    struct sockaddr_list **src_sl, struct sockaddr_list **dst_sl,
+    struct proc *p, uint32_t ifscope, associd_t aid, connid_t *pcid,
+    uint32_t flags, void *arg, uint32_t arglen)
+{
+#pragma unused(aid, flags, arg, arglen)
+       struct sockaddr_entry *src_se = NULL, *dst_se = NULL;
+       struct inpcb *inp = sotoinpcb(so);
+       int error;
+
+       if (inp == NULL)
+               return (EINVAL);
+
+       VERIFY(dst_sl != NULL);
+
+       /* select source (if specified) and destination addresses */
+       error = in_selectaddrs(af, src_sl, &src_se, dst_sl, &dst_se);
+       if (error != 0)
+               return (error);
+
+       VERIFY(*dst_sl != NULL && dst_se != NULL);
+       VERIFY(src_se == NULL || *src_sl != NULL);
+       VERIFY(dst_se->se_addr->sa_family == af);
+       VERIFY(src_se == NULL || src_se->se_addr->sa_family == af);
+
+       /* bind socket to the specified interface, if requested */
+       if (ifscope != IFSCOPE_NONE &&
+           (error = inp_bindif(inp, ifscope, NULL)) != 0)
+               return (error);
+
+       /* if source address and/or port is specified, bind to it */
+       if (src_se != NULL) {
+               struct sockaddr *sa = src_se->se_addr;
+               error = sobindlock(so, sa, 0);  /* already locked */
+               if (error != 0)
+                       return (error);
+       }
+
+       switch (af) {
+       case AF_INET:
+               error = udp_connect(so, dst_se->se_addr, p);
+               break;
+#if INET6
+       case AF_INET6:
+               error = udp6_connect(so, dst_se->se_addr, p);
+               break;
+#endif /* INET6 */
+       default:
+               VERIFY(0);
+               /* NOTREACHED */
+       }
+
+       if (error == 0 && pcid != NULL)
+               *pcid = 1;      /* there is only 1 connection for a UDP */
+
+       return (error);
+}
+
+static int
+udp_connectx(struct socket *so, struct sockaddr_list **src_sl,
+    struct sockaddr_list **dst_sl, struct proc *p, uint32_t ifscope,
+    associd_t aid, connid_t *pcid, uint32_t flags, void *arg,
+    uint32_t arglen)
+{
+       return (udp_connectx_common(so, AF_INET, src_sl, dst_sl,
+           p, ifscope, aid, pcid, flags, arg, arglen));

 }
 
 static int
 }
 
 static int


@@ -1759,11 +1882,13 @@ udp_detach(struct socket *so)
        struct inpcb *inp;
 
        inp = sotoinpcb(so);
        struct inpcb *inp;
 
        inp = sotoinpcb(so);

-       if (inp == 0)
-               panic("udp_detach: so=%p null inp\n", so);      /* ??? possible? panic instead? */
+       if (inp == NULL) {
+               panic("%s: so=%p null inp\n", __func__, so);
+               /* NOTREACHED */
+       }

        in_pcbdetach(inp);
        inp->inp_state = INPCB_STATE_DEAD;
        in_pcbdetach(inp);
        inp->inp_state = INPCB_STATE_DEAD;

-       return 0;
+       return (0);

 }
 
 static int
 }
 
 static int


@@ -1772,35 +1897,49 @@ udp_disconnect(struct socket *so)
        struct inpcb *inp;
 
        inp = sotoinpcb(so);
        struct inpcb *inp;
 
        inp = sotoinpcb(so);

-       if (inp == 0)
-               return EINVAL;
+       if (inp == NULL || (inp->inp_flags2 & INP2_WANT_FLOW_DIVERT))
+               return (inp == NULL ? EINVAL : EPROTOTYPE);

        if (inp->inp_faddr.s_addr == INADDR_ANY)
        if (inp->inp_faddr.s_addr == INADDR_ANY)

-               return ENOTCONN;
+               return (ENOTCONN);

 
        in_pcbdisconnect(inp);
 
        in_pcbdisconnect(inp);

-       
+

        /* reset flow controlled state, just in case */
        inp_reset_fc_state(inp);
 
        inp->inp_laddr.s_addr = INADDR_ANY;
        so->so_state &= ~SS_ISCONNECTED;                /* XXX */
        inp->inp_last_outifp = NULL;
        /* reset flow controlled state, just in case */
        inp_reset_fc_state(inp);
 
        inp->inp_laddr.s_addr = INADDR_ANY;
        so->so_state &= ~SS_ISCONNECTED;                /* XXX */
        inp->inp_last_outifp = NULL;

-       return 0;
+       return (0);

 }
 
 static int
 }
 
 static int

-udp_send(struct socket *so, __unused int flags, struct mbuf *m, struct sockaddr *addr,
-           struct mbuf *control, struct proc *p)
+udp_disconnectx(struct socket *so, associd_t aid, connid_t cid)

 {
 {

+#pragma unused(cid)
+       if (aid != ASSOCID_ANY && aid != ASSOCID_ALL)
+               return (EINVAL);
+
+       return (udp_disconnect(so));
+}
+
+static int
+udp_send(struct socket *so, int flags, struct mbuf *m,
+    struct sockaddr *addr, struct mbuf *control, struct proc *p)
+{
+#pragma unused(flags)

        struct inpcb *inp;
 
        inp = sotoinpcb(so);
        struct inpcb *inp;
 
        inp = sotoinpcb(so);

-       if (inp == 0) {
-               m_freem(m);
-               return EINVAL;
+       if (inp == NULL || (inp->inp_flags2 & INP2_WANT_FLOW_DIVERT)) {
+               if (m != NULL)
+                       m_freem(m);
+               if (control != NULL)
+                       m_freem(control);
+               return (inp == NULL ? EINVAL : EPROTOTYPE);

        }
        }

-       
-       return udp_output(inp, m, addr, control, p);
+
+       return (udp_output(inp, m, addr, control, p));

 }
 
 int
 }
 
 int


@@ -1809,21 +1948,12 @@ udp_shutdown(struct socket *so)
        struct inpcb *inp;
 
        inp = sotoinpcb(so);
        struct inpcb *inp;
 
        inp = sotoinpcb(so);

-       if (inp == 0)
-               return EINVAL;
+       if (inp == NULL)
+               return (EINVAL);

        socantsendmore(so);
        socantsendmore(so);

-       return 0;
+       return (0);

 }
 
 }
 

-struct pr_usrreqs udp_usrreqs = {
-       udp_abort, pru_accept_notsupp, udp_attach, udp_bind, udp_connect, 
-       pru_connect2_notsupp, in_control, udp_detach, udp_disconnect, 
-       pru_listen_notsupp, in_setpeeraddr, pru_rcvd_notsupp, 
-       pru_rcvoob_notsupp, udp_send, pru_sense_null, udp_shutdown,
-       in_setsockaddr, sosend, soreceive, pru_sopoll_notsupp
-};
-
-

 int
 udp_lock(struct socket *so, int refcount, void *debug)
 {
 int
 udp_lock(struct socket *so, int refcount, void *debug)
 {


@@ -1834,12 +1964,12 @@ udp_lock(struct socket *so, int refcount, void *debug)
        else
                lr_saved = debug;
 
        else
                lr_saved = debug;
 

-       if (so->so_pcb) {
+       if (so->so_pcb != NULL) {

                lck_mtx_assert(&((struct inpcb *)so->so_pcb)->inpcb_mtx,
                    LCK_MTX_ASSERT_NOTOWNED);
                lck_mtx_lock(&((struct inpcb *)so->so_pcb)->inpcb_mtx);
        } else {
                lck_mtx_assert(&((struct inpcb *)so->so_pcb)->inpcb_mtx,
                    LCK_MTX_ASSERT_NOTOWNED);
                lck_mtx_lock(&((struct inpcb *)so->so_pcb)->inpcb_mtx);
        } else {

-               panic("udp_lock: so=%p NO PCB! lr=%p lrh= %s\n", 
+               panic("%s: so=%p NO PCB! lr=%p lrh= %s\n", __func__,

                    so, lr_saved, solockhistory_nr(so));
                /* NOTREACHED */
        }
                    so, lr_saved, solockhistory_nr(so));
                /* NOTREACHED */
        }


@@ -1865,7 +1995,7 @@ udp_unlock(struct socket *so, int refcount, void *debug)
                so->so_usecount--;
 
        if (so->so_pcb == NULL) {
                so->so_usecount--;
 
        if (so->so_pcb == NULL) {

-               panic("udp_unlock: so=%p NO PCB! lr=%p lrh= %s\n", 
+               panic("%s: so=%p NO PCB! lr=%p lrh= %s\n", __func__,

                    so, lr_saved, solockhistory_nr(so));
                /* NOTREACHED */
        } else {
                    so, lr_saved, solockhistory_nr(so));
                /* NOTREACHED */
        } else {


@@ -1875,39 +2005,42 @@ udp_unlock(struct socket *so, int refcount, void *debug)
                so->next_unlock_lr = (so->next_unlock_lr+1) % SO_LCKDBG_MAX;
                lck_mtx_unlock(&((struct inpcb *)so->so_pcb)->inpcb_mtx);
        }
                so->next_unlock_lr = (so->next_unlock_lr+1) % SO_LCKDBG_MAX;
                lck_mtx_unlock(&((struct inpcb *)so->so_pcb)->inpcb_mtx);
        }

-
-

        return (0);
 }
 
 lck_mtx_t *
        return (0);
 }
 
 lck_mtx_t *

-udp_getlock(struct socket *so, __unused int locktype)
+udp_getlock(struct socket *so, int locktype)

 {
 {

+#pragma unused(locktype)

        struct inpcb *inp = sotoinpcb(so);
 
        struct inpcb *inp = sotoinpcb(so);
 

-
-       if (so->so_pcb)
-               return(&inp->inpcb_mtx);
-       else {
-               panic("udp_getlock: so=%p NULL so_pcb lrh= %s\n", 
-                       so, solockhistory_nr(so));
-               return (so->so_proto->pr_domain->dom_mtx);
+       if (so->so_pcb == NULL) {
+               panic("%s: so=%p NULL so_pcb lrh= %s\n", __func__,
+                   so, solockhistory_nr(so));
+               /* NOTREACHED */

        }
        }

+       return (&inp->inpcb_mtx);

 }
 
 }
 

-void
-udp_slowtimo()
+/*
+ * UDP garbage collector callback (inpcb_timer_func_t).
+ *
+ * Returns > 0 to keep timer active.
+ */
+static void
+udp_gc(struct inpcbinfo *ipi)

 {
        struct inpcb *inp, *inpnxt;
        struct socket *so;
 {
        struct inpcb *inp, *inpnxt;
        struct socket *so;

-       struct inpcbinfo *pcbinfo       = &udbinfo;

 
 

-       if (lck_rw_try_lock_exclusive(pcbinfo->mtx) == FALSE) {
+       if (lck_rw_try_lock_exclusive(ipi->ipi_lock) == FALSE) {

                if (udp_gc_done == TRUE) {
                        udp_gc_done = FALSE;
                if (udp_gc_done == TRUE) {
                        udp_gc_done = FALSE;

-                       return; /* couldn't get the lock, better lock next time */
+                       /* couldn't get the lock, must lock next time */
+                       atomic_add_32(&ipi->ipi_gc_req.intimer_fast, 1);
+                       return;

                }
                }

-               lck_rw_lock_exclusive(pcbinfo->mtx);
+               lck_rw_lock_exclusive(ipi->ipi_lock);

        }
 
        udp_gc_done = TRUE;
        }
 
        udp_gc_done = TRUE;


@@ -1915,49 +2048,163 @@ udp_slowtimo()
        for (inp = udb.lh_first; inp != NULL; inp = inpnxt) {
                inpnxt = inp->inp_list.le_next;
 
        for (inp = udb.lh_first; inp != NULL; inp = inpnxt) {
                inpnxt = inp->inp_list.le_next;
 

-               if (inp->inp_wantcnt != WNT_STOPUSING) 
+               /*
+                * Skip unless it's STOPUSING; garbage collector will
+                * be triggered by in_pcb_checkstate() upon setting
+                * wantcnt to that value.  If the PCB is already dead,
+                * keep gc active to anticipate wantcnt changing.
+                */
+               if (inp->inp_wantcnt != WNT_STOPUSING)

                        continue;
 
                        continue;
 

-               so = inp->inp_socket;
-               if (!lck_mtx_try_lock(&inp->inpcb_mtx)) /* skip if busy, no hurry for cleanup... */
+               /*
+                * Skip if busy, no hurry for cleanup.  Keep gc active
+                * and try the lock again during next round.
+                */
+               if (!lck_mtx_try_lock(&inp->inpcb_mtx)) {
+                       atomic_add_32(&ipi->ipi_gc_req.intimer_fast, 1);

                        continue;
                        continue;

+               }

 
 

+               /*
+                * Keep gc active unless usecount is 0.
+                */
+               so = inp->inp_socket;

                if (so->so_usecount == 0) {
                        if (inp->inp_state != INPCB_STATE_DEAD) {
 #if INET6
                if (so->so_usecount == 0) {
                        if (inp->inp_state != INPCB_STATE_DEAD) {
 #if INET6

-                               if (INP_CHECK_SOCKAF(so, AF_INET6))
+                               if (SOCK_CHECK_DOM(so, PF_INET6))

                                        in6_pcbdetach(inp);
                                else
 #endif /* INET6 */
                                        in6_pcbdetach(inp);
                                else
 #endif /* INET6 */

-                               in_pcbdetach(inp);
+                                       in_pcbdetach(inp);

                        }
                        in_pcbdispose(inp);
                } else {
                        lck_mtx_unlock(&inp->inpcb_mtx);
                        }
                        in_pcbdispose(inp);
                } else {
                        lck_mtx_unlock(&inp->inpcb_mtx);

+                       atomic_add_32(&ipi->ipi_gc_req.intimer_fast, 1);

                }
        }
                }
        }

-       lck_rw_done(pcbinfo->mtx);
+       lck_rw_done(ipi->ipi_lock);
+
+       return;

 }
 
 }
 

-int
-ChkAddressOK( __uint32_t dstaddr, __uint32_t srcaddr )
+static int
+udp_getstat SYSCTL_HANDLER_ARGS

 {
 {

-        if ( dstaddr == srcaddr ){
-                return 0;
-        }
-        return 1;
+#pragma unused(oidp, arg1, arg2)
+       if (req->oldptr == USER_ADDR_NULL)
+               req->oldlen = (size_t)sizeof (struct udpstat);
+
+       return (SYSCTL_OUT(req, &udpstat, MIN(sizeof (udpstat), req->oldlen)));

 }
 
 void
 udp_in_cksum_stats(u_int32_t len)
 {
 }
 
 void
 udp_in_cksum_stats(u_int32_t len)
 {

-       udps_in_sw_cksum++;
-       udps_in_sw_cksum_bytes += len;
+       udpstat.udps_rcv_swcsum++;
+       udpstat.udps_rcv_swcsum_bytes += len;

 }
 
 void
 udp_out_cksum_stats(u_int32_t len)
 {
 }
 
 void
 udp_out_cksum_stats(u_int32_t len)
 {

-       udps_out_sw_cksum++;
-       udps_out_sw_cksum_bytes += len;
+       udpstat.udps_snd_swcsum++;
+       udpstat.udps_snd_swcsum_bytes += len;
+}
+
+#if INET6
+void
+udp_in6_cksum_stats(u_int32_t len)
+{
+       udpstat.udps_rcv6_swcsum++;
+       udpstat.udps_rcv6_swcsum_bytes += len;
+}
+
+void
+udp_out6_cksum_stats(u_int32_t len)
+{
+       udpstat.udps_snd6_swcsum++;
+       udpstat.udps_snd6_swcsum_bytes += len;
+}
+#endif /* INET6 */
+
+/*
+ * Checksum extended UDP header and data.
+ */
+static int
+udp_input_checksum(struct mbuf *m, struct udphdr *uh, int off, int ulen)
+{
+       struct ifnet *ifp = m->m_pkthdr.rcvif;
+       struct ip *ip = mtod(m, struct ip *);
+       struct ipovly *ipov = (struct ipovly *)ip;
+
+       if (uh->uh_sum == 0) {
+               udpstat.udps_nosum++;
+               return (0);
+       }
+
+       if ((hwcksum_rx || (ifp->if_flags & IFF_LOOPBACK) ||
+           (m->m_pkthdr.pkt_flags & PKTF_LOOP)) &&
+           (m->m_pkthdr.csum_flags & CSUM_DATA_VALID)) {
+               if (m->m_pkthdr.csum_flags & CSUM_PSEUDO_HDR) {
+                       uh->uh_sum = m->m_pkthdr.csum_rx_val;
+               } else {
+                       uint16_t sum = m->m_pkthdr.csum_rx_val;
+                       uint16_t start = m->m_pkthdr.csum_rx_start;
+
+                       /*
+                        * Perform 1's complement adjustment of octets
+                        * that got included/excluded in the hardware-
+                        * calculated checksum value.  Ignore cases
+                        * where the value includes or excludes the
+                        * IP header span, as the sum for those octets
+                        * would already be 0xffff and thus no-op.
+                        */
+                       if ((m->m_pkthdr.csum_flags & CSUM_PARTIAL) &&
+                           start != 0 && (off - start) != off) {
+#if BYTE_ORDER != BIG_ENDIAN
+                               if (start < off) {
+                                       HTONS(ip->ip_len);
+                                       HTONS(ip->ip_off);
+                               }
+#endif /* BYTE_ORDER != BIG_ENDIAN */
+                               /* callee folds in sum */
+                               sum = m_adj_sum16(m, start, off, sum);
+#if BYTE_ORDER != BIG_ENDIAN
+                               if (start < off) {
+                                       NTOHS(ip->ip_off);
+                                       NTOHS(ip->ip_len);
+                               }
+#endif /* BYTE_ORDER != BIG_ENDIAN */
+                       }
+
+                       /* callee folds in sum */
+                       uh->uh_sum = in_pseudo(ip->ip_src.s_addr,
+                           ip->ip_dst.s_addr, sum + htonl(ulen + IPPROTO_UDP));
+               }
+               uh->uh_sum ^= 0xffff;
+       } else {
+               uint16_t ip_sum;
+               char b[9];
+
+               bcopy(ipov->ih_x1, b, sizeof (ipov->ih_x1));
+               bzero(ipov->ih_x1, sizeof (ipov->ih_x1));
+               ip_sum = ipov->ih_len;
+               ipov->ih_len = uh->uh_ulen;
+               uh->uh_sum = in_cksum(m, ulen + sizeof (struct ip));
+               bcopy(b, ipov->ih_x1, sizeof (ipov->ih_x1));
+               ipov->ih_len = ip_sum;
+
+               udp_in_cksum_stats(ulen);
+       }
+
+       if (uh->uh_sum != 0) {
+               udpstat.udps_badsum++;
+               IF_UDP_STATINC(ifp, badchksum);
+               return (-1);
+       }
+
+       return (0);

 }
 }