X-Git-Url: https://git.saurik.com/apple/xnu.git/blobdiff_plain/3e170ce000f1506b7b5d2c5c7faec85ceabb573d..b226f5e54a60dc81db17b1260381d7dbfea3cdf1:/bsd/netinet/in.c?ds=sidebyside diff --git a/bsd/netinet/in.c b/bsd/netinet/in.c index f25e77c05..61de1526d 100644 --- a/bsd/netinet/in.c +++ b/bsd/netinet/in.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2000-2015 Apple Inc. All rights reserved. + * Copyright (c) 2000-2016 Apple Inc. All rights reserved. * * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ * @@ -83,6 +83,8 @@ #include #include #include +#include +#include #if PF #include #endif /* PF */ @@ -95,6 +97,7 @@ #include #include #include +#include static int inctl_associd(struct socket *, u_long, caddr_t); static int inctl_connid(struct socket *, u_long, caddr_t); @@ -135,9 +138,24 @@ static void in_ifaddr_trace(struct ifaddr *, int); static int in_getassocids(struct socket *, uint32_t *, user_addr_t); static int in_getconnids(struct socket *, sae_associd_t, uint32_t *, user_addr_t); -static int in_getconninfo(struct socket *, sae_connid_t, uint32_t *, - uint32_t *, int32_t *, user_addr_t, socklen_t *, user_addr_t, socklen_t *, - uint32_t *, user_addr_t, uint32_t *); + +/* IPv4 Layer 2 neighbor cache management routines */ +static void in_lltable_destroy_lle_unlocked(struct llentry *lle); +static void in_lltable_destroy_lle(struct llentry *lle); +static struct llentry *in_lltable_new(struct in_addr addr4, u_int flags); +static int in_lltable_match_prefix(const struct sockaddr *saddr, + const struct sockaddr *smask, u_int flags, struct llentry *lle); +static void in_lltable_free_entry(struct lltable *llt, struct llentry *lle); +static int in_lltable_rtcheck(struct ifnet *ifp, u_int flags, const struct sockaddr *l3addr); +static inline uint32_t in_lltable_hash_dst(const struct in_addr dst, uint32_t hsize); +static uint32_t in_lltable_hash(const struct llentry *lle, uint32_t hsize); +static void in_lltable_fill_sa_entry(const struct llentry *lle, struct sockaddr *sa); +static inline struct llentry * in_lltable_find_dst(struct lltable *llt, struct in_addr dst); +static void in_lltable_delete_entry(struct lltable *llt, struct llentry *lle); +static struct llentry * in_lltable_alloc(struct lltable *llt, u_int flags, const struct sockaddr *l3addr); +static struct llentry * in_lltable_lookup(struct lltable *llt, u_int flags, const struct sockaddr *l3addr); +static int in_lltable_dump_entry(struct lltable *llt, struct llentry *lle, struct sysctl_req *wr); +static struct lltable * in_lltattach(struct ifnet *ifp); static int subnetsarelocal = 0; SYSCTL_INT(_net_inet_ip, OID_AUTO, subnets_are_local, @@ -234,8 +252,9 @@ inaddr_local(struct in_addr in) /* * Return 1 if an internet address is for a ``local'' host * (one to which we have a connection). If subnetsarelocal - * is true, this includes other subnets of the local net. - * Otherwise, it includes only the directly-connected (sub)nets. + * is true, this includes other subnets of the local net, + * otherwise, it includes the directly-connected (sub)nets. + * The IPv4 link local prefix 169.254/16 is also included. */ int in_localaddr(struct in_addr in) @@ -243,6 +262,9 @@ in_localaddr(struct in_addr in) u_int32_t i = ntohl(in.s_addr); struct in_ifaddr *ia; + if (IN_LINKLOCAL(i)) + return (1); + if (subnetsarelocal) { lck_rw_lock_shared(in_ifaddr_rwlock); for (ia = in_ifaddrhead.tqh_first; ia != NULL; @@ -349,6 +371,7 @@ in_domifattach(struct ifnet *ifp) pbuf = (void **)((intptr_t)base - sizeof (void *)); *pbuf = ext; ifp->if_inetdata = base; + IN_IFEXTRA(ifp)->ii_llt = in_lltattach(ifp); VERIFY(IS_P2ALIGNED(ifp->if_inetdata, sizeof (uint64_t))); } done: @@ -725,7 +748,7 @@ inctl_ifaddr(struct ifnet *ifp, struct in_ifaddr *ia, u_long cmd, ev_msg.dv[0].data_length = sizeof (struct kev_in_data); ev_msg.dv[1].data_length = 0; - kev_post_msg(&ev_msg); + dlil_post_complete_msg(ifp, &ev_msg); } else { IFA_UNLOCK(&ia->ia_ifa); } @@ -737,8 +760,13 @@ inctl_ifaddr(struct ifnet *ifp, struct in_ifaddr *ia, u_long cmd, error = ifnet_ioctl(ifp, PF_INET, SIOCDIFADDR, ia); if (error == EOPNOTSUPP) error = 0; - if (error != 0) + if (error != 0) { + /* Reset the detaching flag */ + IFA_LOCK(&ia->ia_ifa); + ia->ia_ifa.ifa_debug &= ~IFD_DETACHING; + IFA_UNLOCK(&ia->ia_ifa); break; + } /* Fill out the kernel event information */ ev_msg.vendor_code = KEV_VENDOR_APPLE; @@ -827,7 +855,7 @@ inctl_ifaddr(struct ifnet *ifp, struct in_ifaddr *ia, u_long cmd, } /* Post the kernel event */ - kev_post_msg(&ev_msg); + dlil_post_complete_msg(ifp, &ev_msg); /* * See if there is any IPV4 address left and if so, @@ -946,7 +974,7 @@ inctl_ifdstaddr(struct ifnet *ifp, struct in_ifaddr *ia, u_long cmd, ev_msg.dv[0].data_length = sizeof (struct kev_in_data); ev_msg.dv[1].data_length = 0; - kev_post_msg(&ev_msg); + dlil_post_complete_msg(ifp, &ev_msg); lck_mtx_lock(rnh_lock); IFA_LOCK(&ia->ia_ifa); @@ -1041,7 +1069,7 @@ inctl_ifbrdaddr(struct ifnet *ifp, struct in_ifaddr *ia, u_long cmd, ev_msg.dv[0].data_length = sizeof (struct kev_in_data); ev_msg.dv[1].data_length = 0; - kev_post_msg(&ev_msg); + dlil_post_complete_msg(ifp, &ev_msg); break; default: @@ -1119,7 +1147,7 @@ inctl_ifnetmask(struct ifnet *ifp, struct in_ifaddr *ia, u_long cmd, ev_msg.dv[0].data_length = sizeof (struct kev_in_data); ev_msg.dv[1].data_length = 0; - kev_post_msg(&ev_msg); + dlil_post_complete_msg(ifp, &ev_msg); break; } @@ -1287,15 +1315,28 @@ in_control(struct socket *so, u_long cmd, caddr_t data, struct ifnet *ifp, if (iap->ia_ifp == ifp && iap->ia_addr.sin_addr.s_addr == sa->sin_addr.s_addr) { + /* + * Avoid the race condition seen when two + * threads process SIOCDIFADDR command + * at the same time (radar 28942007) + */ + if (cmd == SIOCDIFADDR) { + if (iap->ia_ifa.ifa_debug & + IFD_DETACHING) { + IFA_UNLOCK(&iap->ia_ifa); + continue; + } else { + iap->ia_ifa.ifa_debug |= + IFD_DETACHING; + } + } ia = iap; + IFA_ADDREF_LOCKED(&iap->ia_ifa); IFA_UNLOCK(&iap->ia_ifa); break; } IFA_UNLOCK(&iap->ia_ifa); } - /* take a reference on ia before releasing lock */ - if (ia != NULL) - IFA_ADDREF(&ia->ia_ifa); lck_rw_done(in_ifaddr_rwlock); if (ia == NULL) { @@ -1507,7 +1548,7 @@ in_ifscrub(struct ifnet *ifp, struct in_ifaddr *ia, int locked) static void in_iahash_remove(struct in_ifaddr *ia) { - lck_rw_assert(in_ifaddr_rwlock, LCK_RW_ASSERT_EXCLUSIVE); + LCK_RW_ASSERT(in_ifaddr_rwlock, LCK_RW_ASSERT_EXCLUSIVE); IFA_LOCK_ASSERT_HELD(&ia->ia_ifa); if (!IA_IS_HASHED(ia)) { @@ -1529,7 +1570,7 @@ in_iahash_remove(struct in_ifaddr *ia) static void in_iahash_insert(struct in_ifaddr *ia) { - lck_rw_assert(in_ifaddr_rwlock, LCK_RW_ASSERT_EXCLUSIVE); + LCK_RW_ASSERT(in_ifaddr_rwlock, LCK_RW_ASSERT_EXCLUSIVE); IFA_LOCK_ASSERT_HELD(&ia->ia_ifa); if (ia->ia_addr.sin_family != AF_INET) { @@ -1559,7 +1600,7 @@ in_iahash_insert_ptp(struct in_ifaddr *ia) struct in_ifaddr *tmp_ifa; struct ifnet *tmp_ifp; - lck_rw_assert(in_ifaddr_rwlock, LCK_RW_ASSERT_EXCLUSIVE); + LCK_RW_ASSERT(in_ifaddr_rwlock, LCK_RW_ASSERT_EXCLUSIVE); IFA_LOCK_ASSERT_HELD(&ia->ia_ifa); if (ia->ia_addr.sin_family != AF_INET) { @@ -1907,119 +1948,6 @@ in_purgeaddrs(struct ifnet *ifp) } } -/* - * Select endpoint address(es). For now just take the first matching - * address and discard the rest, if present. - */ -int -in_selectaddrs(int af, struct sockaddr_list **src_sl, - struct sockaddr_entry **src_se, struct sockaddr_list **dst_sl, - struct sockaddr_entry **dst_se) -{ - struct sockaddr_entry *se; - int error = 0; - - VERIFY(src_sl != NULL && dst_sl != NULL && *dst_sl != NULL); - VERIFY(src_se != NULL && dst_se != NULL); - - *src_se = *dst_se = NULL; - - /* pick a source address, if available */ - if (*src_sl != NULL) { - TAILQ_FOREACH(se, &(*src_sl)->sl_head, se_link) { - VERIFY(se->se_addr != NULL); - /* - * Take the first source address, or the first - * one with matching address family. - */ - if (af == AF_UNSPEC || se->se_addr->sa_family == af) { - sockaddrlist_remove(*src_sl, se); - *src_se = se; - break; - } - } - /* get rid of the rest */ - TAILQ_FOREACH(se, &(*src_sl)->sl_head, se_link) { - sockaddrlist_remove(*src_sl, se); - sockaddrentry_free(se); - } - if (*src_se != NULL) { - /* insert the first src address back in */ - sockaddrlist_insert(*src_sl, *src_se); - VERIFY((*src_sl)->sl_cnt == 1); - /* destination address must be of this family */ - af = (*src_se)->se_addr->sa_family; - } else { - /* no usable source address with matching family */ - VERIFY(af != AF_UNSPEC); - error = EAFNOSUPPORT; - goto out; - } - } - /* pick a (matching) destination address */ - TAILQ_FOREACH(se, &(*dst_sl)->sl_head, se_link) { - VERIFY(se->se_addr != NULL); - /* - * Take the first destination address; if source is specified, - * find one which uses the same address family. - */ - if (af == AF_UNSPEC || se->se_addr->sa_family == af) { - sockaddrlist_remove(*dst_sl, se); - *dst_se = se; - break; - } - } - /* get rid of the rest */ - TAILQ_FOREACH(se, &(*dst_sl)->sl_head, se_link) { - sockaddrlist_remove(*dst_sl, se); - sockaddrentry_free(se); - } - if (*dst_se != NULL) { - /* insert the first dst address back in */ - sockaddrlist_insert(*dst_sl, *dst_se); - VERIFY((*dst_sl)->sl_cnt == 1); - } else { - /* source and destination address families don't match */ - error = EAFNOSUPPORT; - goto out; - } - - af = (*dst_se)->se_addr->sa_family; - VERIFY(*src_se == NULL || (*src_se)->se_addr->sa_family == af); - - /* verify address length */ - switch (af) { - case AF_INET: - if ((*dst_se)->se_addr->sa_len != - sizeof (struct sockaddr_in)) { - error = EAFNOSUPPORT; - goto out; - } - break; -#if INET6 - case AF_INET6: - if ((*dst_se)->se_addr->sa_len != - sizeof (struct sockaddr_in6)) { - error = EAFNOSUPPORT; - goto out; - } - break; -#endif /* INET6 */ - default: - error = EAFNOSUPPORT; - goto out; - } - - /* if source address is specified, length must match destination */ - if (*src_se != NULL && (*src_se)->se_addr->sa_len != - (*dst_se)->se_addr->sa_len) { - error = EAFNOSUPPORT; - goto out; - } -out: - return (error); -} - /* * Called as part of ip_init */ @@ -2226,13 +2154,12 @@ in_getconnids(struct socket *so, sae_associd_t aid, uint32_t *cnt, /* * Handle SIOCGCONNINFO ioctl for PF_INET domain. */ -static int +int in_getconninfo(struct socket *so, sae_connid_t cid, uint32_t *flags, uint32_t *ifindex, int32_t *soerror, user_addr_t src, socklen_t *src_len, user_addr_t dst, socklen_t *dst_len, uint32_t *aux_type, user_addr_t aux_data, uint32_t *aux_len) { -#pragma unused(aux_data) struct inpcb *inp = sotoinpcb(so); struct sockaddr_in sin; struct ifnet *ifp = NULL; @@ -2300,8 +2227,6 @@ in_getconninfo(struct socket *so, sae_connid_t cid, uint32_t *flags, } } - *aux_type = 0; - *aux_len = 0; if (SOCK_PROTO(so) == IPPROTO_TCP) { struct conninfo_tcp tcp_ci; @@ -2319,8 +2244,416 @@ in_getconninfo(struct socket *so, sae_connid_t cid, uint32_t *flags, *aux_len = copy_len; } } + } else { + *aux_type = 0; + *aux_len = 0; } out: return (error); } + +struct in_llentry { + struct llentry base; +}; + +#define IN_LLTBL_DEFAULT_HSIZE 32 +#define IN_LLTBL_HASH(k, h) \ + ((((((((k) >> 8) ^ (k)) >> 8) ^ (k)) >> 8) ^ (k)) & ((h) - 1)) + +/* + * Do actual deallocation of @lle. + */ +static void +in_lltable_destroy_lle_unlocked(struct llentry *lle) +{ + LLE_LOCK_DESTROY(lle); + LLE_REQ_DESTROY(lle); + FREE(lle, M_LLTABLE); +} + +/* + * Called by LLE_FREE_LOCKED when number of references + * drops to zero. + */ +static void +in_lltable_destroy_lle(struct llentry *lle) +{ + LLE_WUNLOCK(lle); + in_lltable_destroy_lle_unlocked(lle); +} + +static struct llentry * +in_lltable_new(struct in_addr addr4, u_int flags) +{ +#pragma unused(flags) + struct in_llentry *lle; + + MALLOC(lle, struct in_llentry *, sizeof(struct in_llentry), M_LLTABLE, M_NOWAIT | M_ZERO); + if (lle == NULL) /* NB: caller generates msg */ + return NULL; + + /* + * For IPv4 this will trigger "arpresolve" to generate + * an ARP request. + */ + lle->base.la_expire = net_uptime(); /* mark expired */ + lle->base.r_l3addr.addr4 = addr4; + lle->base.lle_refcnt = 1; + lle->base.lle_free = in_lltable_destroy_lle; + + LLE_LOCK_INIT(&lle->base); + LLE_REQ_INIT(&lle->base); + //callout_init(&lle->base.lle_timer, 1); + + return (&lle->base); +} + +#define IN_ARE_MASKED_ADDR_EQUAL(d, a, m) ( \ + ((((d).s_addr ^ (a).s_addr) & (m).s_addr)) == 0 ) + +static int +in_lltable_match_prefix(const struct sockaddr *saddr, + const struct sockaddr *smask, u_int flags, struct llentry *lle) +{ + struct in_addr addr, mask, lle_addr; + + addr = ((const struct sockaddr_in *)(const void *)saddr)->sin_addr; + mask = ((const struct sockaddr_in *)(const void *)smask)->sin_addr; + lle_addr.s_addr = ntohl(lle->r_l3addr.addr4.s_addr); + + if (IN_ARE_MASKED_ADDR_EQUAL(lle_addr, addr, mask) == 0) + return (0); + + if (lle->la_flags & LLE_IFADDR) { + /* + * Delete LLE_IFADDR records IFF address & flag matches. + * Note that addr is the interface address within prefix + * being matched. + * Note also we should handle 'ifdown' cases without removing + * ifaddr macs. + */ + if (addr.s_addr == lle_addr.s_addr && (flags & LLE_STATIC) != 0) + return (1); + return (0); + } + + /* flags & LLE_STATIC means deleting both dynamic and static entries */ + if ((flags & LLE_STATIC) || !(lle->la_flags & LLE_STATIC)) + return (1); + + return (0); +} + +static void +in_lltable_free_entry(struct lltable *llt, struct llentry *lle) +{ + struct ifnet *ifp; + size_t pkts_dropped; + + LLE_WLOCK_ASSERT(lle); + KASSERT(llt != NULL, ("lltable is NULL")); + + /* Unlink entry from table if not already */ + if ((lle->la_flags & LLE_LINKED) != 0) { + ifp = llt->llt_ifp; + IF_AFDATA_WLOCK_ASSERT(ifp, llt->llt_af); + lltable_unlink_entry(llt, lle); + } + +#if 0 + /* cancel timer */ + if (callout_stop(&lle->lle_timer) > 0) + LLE_REMREF(lle); +#endif + /* Drop hold queue */ + pkts_dropped = llentry_free(lle); + arpstat.dropped += pkts_dropped; +} + + +static int +in_lltable_rtcheck(struct ifnet *ifp, u_int flags, const struct sockaddr *l3addr) +{ +#pragma unused(flags) + struct rtentry *rt; + + KASSERT(l3addr->sa_family == AF_INET, + ("sin_family %d", l3addr->sa_family)); + + /* XXX rtalloc1 should take a const param */ + rt = rtalloc1(__DECONST(struct sockaddr *, l3addr), 0, 0); + if (rt == NULL || (rt->rt_flags & RTF_GATEWAY) || rt->rt_ifp != ifp) { + log(LOG_INFO, "IPv4 address: \"%s\" is not on the network\n", + inet_ntoa(((const struct sockaddr_in *)(const void *)l3addr)->sin_addr)); + if (rt != NULL) + rtfree_locked(rt); + return (EINVAL); + } + rtfree_locked(rt); + return 0; +} + +static inline uint32_t +in_lltable_hash_dst(const struct in_addr dst, uint32_t hsize) +{ + return (IN_LLTBL_HASH(dst.s_addr, hsize)); +} + +static uint32_t +in_lltable_hash(const struct llentry *lle, uint32_t hsize) +{ + return (in_lltable_hash_dst(lle->r_l3addr.addr4, hsize)); +} + + +static void +in_lltable_fill_sa_entry(const struct llentry *lle, struct sockaddr *sa) +{ + struct sockaddr_in *sin; + + sin = (struct sockaddr_in *)(void *)sa; + bzero(sin, sizeof(*sin)); + sin->sin_family = AF_INET; + sin->sin_len = sizeof(*sin); + sin->sin_addr = lle->r_l3addr.addr4; +} + +static inline struct llentry * +in_lltable_find_dst(struct lltable *llt, struct in_addr dst) +{ + struct llentry *lle; + struct llentries *lleh; + u_int hashidx; + + hashidx = in_lltable_hash_dst(dst, llt->llt_hsize); + lleh = &llt->lle_head[hashidx]; + LIST_FOREACH(lle, lleh, lle_next) { + if (lle->la_flags & LLE_DELETED) + continue; + if (lle->r_l3addr.addr4.s_addr == dst.s_addr) + break; + } + + return (lle); +} + +static void +in_lltable_delete_entry(struct lltable *llt, struct llentry *lle) +{ +#pragma unused(llt) + lle->la_flags |= LLE_DELETED; + //EVENTHANDLER_INVOKE(lle_event, lle, LLENTRY_DELETED); +#ifdef DIAGNOSTIC + log(LOG_INFO, "ifaddr cache = %p is deleted\n", lle); +#endif + llentry_free(lle); +} + +static struct llentry * +in_lltable_alloc(struct lltable *llt, u_int flags, const struct sockaddr *l3addr) +{ + const struct sockaddr_in *sin = (const struct sockaddr_in *) (const void *)l3addr; + struct ifnet *ifp = llt->llt_ifp; + struct llentry *lle; + + KASSERT(l3addr->sa_family == AF_INET, + ("sin_family %d", l3addr->sa_family)); + + /* + * A route that covers the given address must have + * been installed 1st because we are doing a resolution, + * verify this. + */ + if (!(flags & LLE_IFADDR) && + in_lltable_rtcheck(ifp, flags, l3addr) != 0) + return (NULL); + + lle = in_lltable_new(sin->sin_addr, flags); + if (lle == NULL) { + log(LOG_INFO, "lla_lookup: new lle malloc failed\n"); + return (NULL); + } + lle->la_flags = flags & ~LLE_CREATE; + if (flags & LLE_STATIC) + lle->r_flags |= RLLE_VALID; + if ((flags & LLE_IFADDR) == LLE_IFADDR) { + lltable_set_entry_addr(ifp, lle, LLADDR(SDL(ifp->if_lladdr->ifa_addr))); + lle->la_flags |= LLE_STATIC; + lle->r_flags |= (RLLE_VALID | RLLE_IFADDR); + } + return (lle); +} + +/* + * Return NULL if not found or marked for deletion. + * If found return lle read locked. + */ +static struct llentry * +in_lltable_lookup(struct lltable *llt, u_int flags, const struct sockaddr *l3addr) +{ + const struct sockaddr_in *sin = (const struct sockaddr_in *)(const void *)l3addr; + struct llentry *lle; + + IF_AFDATA_WLOCK_ASSERT(llt->llt_ifp, llt->llt_af); + + KASSERT(l3addr->sa_family == AF_INET, + ("sin_family %d", l3addr->sa_family)); + lle = in_lltable_find_dst(llt, sin->sin_addr); + + if (lle == NULL) + return (NULL); + + KASSERT((flags & (LLE_UNLOCKED|LLE_EXCLUSIVE)) != + (LLE_UNLOCKED|LLE_EXCLUSIVE),("wrong lle request flags: 0x%X", + flags)); + + if (flags & LLE_UNLOCKED) + return (lle); + + if (flags & LLE_EXCLUSIVE) + LLE_WLOCK(lle); + else + LLE_RLOCK(lle); + + return (lle); +} + +static int +in_lltable_dump_entry(struct lltable *llt, struct llentry *lle, + struct sysctl_req *wr) +{ + struct ifnet *ifp = llt->llt_ifp; + /* XXX stack use */ + struct { + struct rt_msghdr rtm; + struct sockaddr_in sin; + struct sockaddr_dl sdl; + } arpc; + struct sockaddr_dl *sdl; + int error; + + bzero(&arpc, sizeof(arpc)); + /* skip deleted entries */ + if ((lle->la_flags & LLE_DELETED) == LLE_DELETED) + return (0); + /* Skip if jailed and not a valid IP of the prison. */ + lltable_fill_sa_entry(lle,(struct sockaddr *)&arpc.sin); + /* + * produce a msg made of: + * struct rt_msghdr; + * struct sockaddr_in; (IPv4) + * struct sockaddr_dl; + */ + arpc.rtm.rtm_msglen = sizeof(arpc); + arpc.rtm.rtm_version = RTM_VERSION; + arpc.rtm.rtm_type = RTM_GET; + arpc.rtm.rtm_flags = RTF_UP; + arpc.rtm.rtm_addrs = RTA_DST | RTA_GATEWAY; + + /* publish */ + if (lle->la_flags & LLE_PUB) + arpc.rtm.rtm_flags |= RTF_ANNOUNCE; + + sdl = &arpc.sdl; + sdl->sdl_family = AF_LINK; + sdl->sdl_len = sizeof(*sdl); + sdl->sdl_index = ifp->if_index; + sdl->sdl_type = ifp->if_type; + if ((lle->la_flags & LLE_VALID) == LLE_VALID) { + sdl->sdl_alen = ifp->if_addrlen; + bcopy(&lle->ll_addr, LLADDR(sdl), ifp->if_addrlen); + } else { + sdl->sdl_alen = 0; + bzero(LLADDR(sdl), ifp->if_addrlen); + } + + arpc.rtm.rtm_rmx.rmx_expire = + lle->la_flags & LLE_STATIC ? 0 : lle->la_expire; + arpc.rtm.rtm_flags |= (RTF_HOST | RTF_LLDATA); + if (lle->la_flags & LLE_STATIC) + arpc.rtm.rtm_flags |= RTF_STATIC; + if (lle->la_flags & LLE_IFADDR) + arpc.rtm.rtm_flags |= RTF_PINNED; + arpc.rtm.rtm_flags |= RTF_PINNED; + arpc.rtm.rtm_index = ifp->if_index; + error = SYSCTL_OUT(wr, &arpc, sizeof(arpc)); + + return (error); +} + +static struct lltable * +in_lltattach(struct ifnet *ifp) +{ + struct lltable *llt; + + llt = lltable_allocate_htbl(IN_LLTBL_DEFAULT_HSIZE); + llt->llt_af = AF_INET; + llt->llt_ifp = ifp; + + llt->llt_lookup = in_lltable_lookup; + llt->llt_alloc_entry = in_lltable_alloc; + llt->llt_delete_entry = in_lltable_delete_entry; + llt->llt_dump_entry = in_lltable_dump_entry; + llt->llt_hash = in_lltable_hash; + llt->llt_fill_sa_entry = in_lltable_fill_sa_entry; + llt->llt_free_entry = in_lltable_free_entry; + llt->llt_match_prefix = in_lltable_match_prefix; + lltable_link(llt); + + return (llt); +} + +struct in_ifaddr* +inifa_ifpwithflag(struct ifnet * ifp, uint32_t flag) +{ + struct ifaddr *ifa; + + ifnet_lock_shared(ifp); + TAILQ_FOREACH(ifa, &ifp->if_addrlist, ifa_link) + { + IFA_LOCK_SPIN(ifa); + if (ifa->ifa_addr->sa_family != AF_INET) { + IFA_UNLOCK(ifa); + continue; + } + if ((((struct in_ifaddr *)ifa)->ia_flags & flag) == flag) { + IFA_ADDREF_LOCKED(ifa); + IFA_UNLOCK(ifa); + break; + } + IFA_UNLOCK(ifa); + } + ifnet_lock_done(ifp); + + return ((struct in_ifaddr *)ifa); +} + +struct in_ifaddr * +inifa_ifpclatv4(struct ifnet * ifp) +{ + struct ifaddr *ifa; + + ifnet_lock_shared(ifp); + TAILQ_FOREACH(ifa, &ifp->if_addrlist, ifa_link) + { + uint32_t addr = 0; + IFA_LOCK_SPIN(ifa); + if (ifa->ifa_addr->sa_family != AF_INET) { + IFA_UNLOCK(ifa); + continue; + } + + addr = ntohl(SIN(ifa->ifa_addr)->sin_addr.s_addr); + if (!IN_LINKLOCAL(addr) && + !IN_LOOPBACK(addr)) { + IFA_ADDREF_LOCKED(ifa); + IFA_UNLOCK(ifa); + break; + } + IFA_UNLOCK(ifa); + } + ifnet_lock_done(ifp); + + return ((struct in_ifaddr *)ifa); +}