#include <kern/debug.h>
#include <netinet/in_arp.h>
#include <sys/types.h>
#include <sys/param.h>
#include <sys/kernel_types.h>
#include <sys/syslog.h>
#include <sys/systm.h>
#include <sys/time.h>
#include <sys/kernel.h>
#include <sys/mbuf.h>
#include <sys/sysctl.h>
#include <string.h>
#include <net/if_arp.h>
#include <net/if_dl.h>
#include <net/dlil.h>
#include <net/if_types.h>
#include <net/route.h>
#include <netinet/if_ether.h>
#include <netinet/in_var.h>
#include <kern/zalloc.h>
#define SA(p) ((struct sockaddr *)(p))
#define SIN(s) ((struct sockaddr_in *)s)
#define CONST_LLADDR(s) ((const u_char*)((s)->sdl_data + (s)->sdl_nlen))
#define rt_expire rt_rmx.rmx_expire
#define equal(a1, a2) (bcmp((caddr_t)(a1), (caddr_t)(a2), (a1)->sa_len) == 0)
static const size_t MAX_HW_LEN = 10;
SYSCTL_DECL(_net_link_ether);
SYSCTL_NODE(_net_link_ether, PF_INET, inet, CTLFLAG_RW|CTLFLAG_LOCKED, 0, "");
static int arpt_prune = (5*60*1);
static int arpt_keep = (20*60);
static int arpt_down = 20;
int apple_hwcksum_tx = 1;
int apple_hwcksum_rx = 1;
SYSCTL_INT(_net_link_ether_inet, OID_AUTO, prune_intvl, CTLFLAG_RW,
&arpt_prune, 0, "");
SYSCTL_INT(_net_link_ether_inet, OID_AUTO, max_age, CTLFLAG_RW,
&arpt_keep, 0, "");
SYSCTL_INT(_net_link_ether_inet, OID_AUTO, host_down_time, CTLFLAG_RW,
&arpt_down, 0, "");
SYSCTL_INT(_net_link_ether_inet, OID_AUTO, apple_hwcksum_tx, CTLFLAG_RW,
&apple_hwcksum_tx, 0, "");
SYSCTL_INT(_net_link_ether_inet, OID_AUTO, apple_hwcksum_rx, CTLFLAG_RW,
&apple_hwcksum_rx, 0, "");
struct llinfo_arp {
LIST_ENTRY(llinfo_arp) la_le;
struct rtentry *la_rt;
struct mbuf *la_hold;
int32_t la_asked;
};
static LIST_HEAD(, llinfo_arp) llinfo_arp;
static int arp_inuse, arp_allocated;
static int arp_maxtries = 5;
static int useloopback = 1;
static int arp_proxyall = 0;
static int arp_sendllconflict = 0;
SYSCTL_INT(_net_link_ether_inet, OID_AUTO, maxtries, CTLFLAG_RW,
&arp_maxtries, 0, "");
SYSCTL_INT(_net_link_ether_inet, OID_AUTO, useloopback, CTLFLAG_RW,
&useloopback, 0, "");
SYSCTL_INT(_net_link_ether_inet, OID_AUTO, proxyall, CTLFLAG_RW,
&arp_proxyall, 0, "");
SYSCTL_INT(_net_link_ether_inet, OID_AUTO, sendllconflict, CTLFLAG_RW,
&arp_sendllconflict, 0, "");
static int log_arp_warnings = 0;
SYSCTL_INT(_net_link_ether_inet, OID_AUTO, log_arp_warnings, CTLFLAG_RW,
&log_arp_warnings, 0,
"log arp warning messages");
static int keep_announcements = 1;
SYSCTL_INT(_net_link_ether_inet, OID_AUTO, keep_announcements, CTLFLAG_RW,
&keep_announcements, 0,
"keep arp announcements");
static int send_conflicting_probes = 1;
SYSCTL_INT(_net_link_ether_inet, OID_AUTO, send_conflicting_probes, CTLFLAG_RW,
&send_conflicting_probes, 0,
"send conflicting link-local arp probes");
static errno_t arp_lookup_route(const struct in_addr *, int,
int, route_t *, unsigned int);
static void arptimer(void *);
static struct llinfo_arp *arp_llinfo_alloc(void);
static void arp_llinfo_free(void *);
extern u_int32_t ipv4_ll_arp_aware;
static int arpinit_done;
static struct zone *llinfo_arp_zone;
#define LLINFO_ARP_ZONE_MAX 256
#define LLINFO_ARP_ZONE_NAME "llinfo_arp"
void
arp_init(void)
{
if (arpinit_done) {
log(LOG_NOTICE, "arp_init called more than once (ignored)\n");
return;
}
LIST_INIT(&llinfo_arp);
llinfo_arp_zone = zinit(sizeof (struct llinfo_arp),
LLINFO_ARP_ZONE_MAX * sizeof (struct llinfo_arp), 0,
LLINFO_ARP_ZONE_NAME);
if (llinfo_arp_zone == NULL)
panic("%s: failed allocating llinfo_arp_zone", __func__);
zone_change(llinfo_arp_zone, Z_EXPAND, TRUE);
arpinit_done = 1;
timeout(arptimer, (caddr_t)0, hz);
}
static struct llinfo_arp *
arp_llinfo_alloc(void)
{
return (zalloc(llinfo_arp_zone));
}
static void
arp_llinfo_free(void *arg)
{
struct llinfo_arp *la = arg;
if (la->la_le.le_next != NULL || la->la_le.le_prev != NULL) {
panic("%s: trying to free %p when it is in use", __func__, la);
}
if (la->la_hold != NULL) {
m_freem(la->la_hold);
la->la_hold = NULL;
}
zfree(llinfo_arp_zone, la);
}
static void
arptfree(struct llinfo_arp *la)
{
struct rtentry *rt = la->la_rt;
struct sockaddr_dl *sdl;
lck_mtx_assert(rnh_lock, LCK_MTX_ASSERT_OWNED);
RT_LOCK_ASSERT_HELD(rt);
if (rt->rt_refcnt > 0 && (sdl = SDL(rt->rt_gateway)) &&
sdl->sdl_family == AF_LINK) {
sdl->sdl_alen = 0;
la->la_asked = 0;
rt->rt_flags &= ~RTF_REJECT;
RT_UNLOCK(rt);
} else {
RT_UNLOCK(rt);
rtrequest_locked(RTM_DELETE, rt_key(rt), NULL, rt_mask(rt),
0, NULL);
}
}
void
in_arpdrain(void *ignored_arg)
{
#pragma unused (ignored_arg)
struct llinfo_arp *la, *ola;
struct timeval timenow;
lck_mtx_lock(rnh_lock);
la = llinfo_arp.lh_first;
getmicrotime(&timenow);
while ((ola = la) != 0) {
struct rtentry *rt = la->la_rt;
la = la->la_le.le_next;
RT_LOCK(rt);
if (rt->rt_expire && rt->rt_expire <= timenow.tv_sec)
arptfree(ola);
else
RT_UNLOCK(rt);
}
lck_mtx_unlock(rnh_lock);
}
static void
arptimer(void *ignored_arg)
{
#pragma unused (ignored_arg)
in_arpdrain(NULL);
timeout(arptimer, (caddr_t)0, arpt_prune * hz);
}
static void
arp_rtrequest(
int req,
struct rtentry *rt,
__unused struct sockaddr *sa)
{
struct sockaddr *gate = rt->rt_gateway;
struct llinfo_arp *la = rt->rt_llinfo;
static struct sockaddr_dl null_sdl = {sizeof(null_sdl), AF_LINK, 0, 0, 0, 0, 0, {0}};
struct timeval timenow;
if (!arpinit_done) {
panic("%s: ARP has not been initialized", __func__);
}
lck_mtx_assert(rnh_lock, LCK_MTX_ASSERT_OWNED);
RT_LOCK_ASSERT_HELD(rt);
if (rt->rt_flags & RTF_GATEWAY)
return;
getmicrotime(&timenow);
switch (req) {
case RTM_ADD:
if ((rt->rt_flags & RTF_HOST) == 0 &&
SIN(rt_mask(rt))->sin_addr.s_addr != 0xffffffff)
rt->rt_flags |= RTF_CLONING;
if (rt->rt_flags & RTF_CLONING) {
if (rt_setgate(rt, rt_key(rt),
(struct sockaddr *)&null_sdl) == 0) {
gate = rt->rt_gateway;
SDL(gate)->sdl_type = rt->rt_ifp->if_type;
SDL(gate)->sdl_index = rt->rt_ifp->if_index;
rt->rt_expire = MAX(timenow.tv_sec, 1);
}
break;
}
if (rt->rt_flags & RTF_ANNOUNCE) {
RT_UNLOCK(rt);
dlil_send_arp(rt->rt_ifp, ARPOP_REQUEST,
SDL(gate), rt_key(rt), NULL, rt_key(rt));
RT_LOCK(rt);
}
case RTM_RESOLVE:
if (gate->sa_family != AF_LINK ||
gate->sa_len < sizeof(null_sdl)) {
if (log_arp_warnings)
log(LOG_DEBUG, "arp_rtrequest: bad gateway value\n");
break;
}
SDL(gate)->sdl_type = rt->rt_ifp->if_type;
SDL(gate)->sdl_index = rt->rt_ifp->if_index;
if (la != 0)
break;
rt->rt_llinfo = la = arp_llinfo_alloc();
if (la == NULL) {
if (log_arp_warnings)
log(LOG_DEBUG, "%s: malloc failed\n", __func__);
break;
}
rt->rt_llinfo_free = arp_llinfo_free;
arp_inuse++, arp_allocated++;
Bzero(la, sizeof(*la));
la->la_rt = rt;
rt->rt_flags |= RTF_LLINFO;
LIST_INSERT_HEAD(&llinfo_arp, la, la_le);
if (IN_MULTICAST(ntohl(SIN(rt_key(rt))->sin_addr.s_addr))) {
RT_UNLOCK(rt);
dlil_resolve_multi(rt->rt_ifp, rt_key(rt), gate,
sizeof(struct sockaddr_dl));
RT_LOCK(rt);
rt->rt_expire = 0;
}
else if (in_broadcast(SIN(rt_key(rt))->sin_addr, rt->rt_ifp)) {
struct sockaddr_dl *gate_ll = SDL(gate);
size_t broadcast_len;
ifnet_llbroadcast_copy_bytes(rt->rt_ifp,
LLADDR(gate_ll), sizeof(gate_ll->sdl_data),
&broadcast_len);
gate_ll->sdl_alen = broadcast_len;
gate_ll->sdl_family = AF_LINK;
gate_ll->sdl_len = sizeof(struct sockaddr_dl);
rt->rt_expire = MAX(timenow.tv_sec, 1);
}
if (SIN(rt_key(rt))->sin_addr.s_addr ==
(IA_SIN(rt->rt_ifa))->sin_addr.s_addr) {
rt->rt_expire = 0;
ifnet_lladdr_copy_bytes(rt->rt_ifp, LLADDR(SDL(gate)), SDL(gate)->sdl_alen = 6);
if (useloopback) {
#if IFNET_ROUTE_REFCNT
if (rt->rt_if_ref_fn != NULL &&
rt->rt_ifp != lo_ifp) {
rt->rt_if_ref_fn(lo_ifp, 1);
rt->rt_if_ref_fn(rt->rt_ifp, -1);
}
#endif
rt->rt_ifp = lo_ifp;
}
}
break;
case RTM_DELETE:
if (la == 0)
break;
arp_inuse--;
LIST_REMOVE(la, la_le);
la->la_le.le_next = NULL;
la->la_le.le_prev = NULL;
rt->rt_flags &= ~RTF_LLINFO;
if (la->la_hold != NULL)
m_freem(la->la_hold);
la->la_hold = NULL;
}
}
static const char *
sdl_addr_to_hex(const struct sockaddr_dl *sdl, char * orig_buf, int buflen)
{
char * buf = orig_buf;
int i;
const u_char * lladdr = (u_char *)(size_t)sdl->sdl_data;
int maxbytes = buflen / 3;
if (maxbytes > sdl->sdl_alen) {
maxbytes = sdl->sdl_alen;
}
*buf = '\0';
for (i = 0; i < maxbytes; i++) {
snprintf(buf, 3, "%02x", lladdr[i]);
buf += 2;
*buf = (i == maxbytes - 1) ? '\0' : ':';
buf++;
}
return (orig_buf);
}
static errno_t
arp_lookup_route(const struct in_addr *addr, int create, int proxy,
route_t *route, unsigned int ifscope)
{
struct sockaddr_inarp sin = {sizeof(sin), AF_INET, 0, {0}, {0}, 0, 0};
const char *why = NULL;
errno_t error = 0;
route_t rt;
*route = NULL;
sin.sin_addr.s_addr = addr->s_addr;
sin.sin_other = proxy ? SIN_PROXY : 0;
rt = rtalloc1_scoped((struct sockaddr*)&sin, create, 0, ifscope);
if (rt == NULL)
return (ENETUNREACH);
RT_LOCK(rt);
if (rt->rt_flags & RTF_GATEWAY) {
why = "host is not on local network";
error = ENETUNREACH;
} else if (!(rt->rt_flags & RTF_LLINFO)) {
why = "could not allocate llinfo";
error = ENOMEM;
} else if (rt->rt_gateway->sa_family != AF_LINK) {
why = "gateway route is not ours";
error = EPROTONOSUPPORT;
}
if (error != 0) {
if (create && log_arp_warnings) {
char tmp[MAX_IPv4_STR_LEN];
log(LOG_DEBUG, "arplookup link#%d %s failed: %s\n",
ifscope, inet_ntop(AF_INET, addr, tmp,
sizeof (tmp)), why);
}
if (rt->rt_refcnt == 1 &&
(rt->rt_flags & (RTF_WASCLONED | RTF_STATIC)) ==
RTF_WASCLONED) {
rt->rt_flags |= RTF_CONDEMNED;
RT_UNLOCK(rt);
rtrequest(RTM_DELETE, rt_key(rt), rt->rt_gateway,
rt_mask(rt), rt->rt_flags, 0);
rtfree(rt);
} else {
RT_REMREF_LOCKED(rt);
RT_UNLOCK(rt);
}
return (error);
}
*route = rt;
return (0);
}
#define senderr(e) { error = (e); goto bad; }
__private_extern__ errno_t
arp_route_to_gateway_route(const struct sockaddr *net_dest, route_t hint0,
route_t *out_route)
{
struct timeval timenow;
route_t rt = hint0, hint = hint0;
errno_t error = 0;
*out_route = NULL;
if (rt != NULL) {
unsigned int ifindex;
RT_LOCK_SPIN(rt);
ifindex = rt->rt_ifp->if_index;
RT_ADDREF_LOCKED(rt);
if (!(rt->rt_flags & RTF_UP)) {
RT_REMREF_LOCKED(rt);
RT_UNLOCK(rt);
hint = rt = rtalloc1_scoped((struct sockaddr *)
(size_t)net_dest, 1, 0, ifindex);
if (hint != NULL) {
RT_LOCK_SPIN(rt);
ifindex = rt->rt_ifp->if_index;
} else {
senderr(EHOSTUNREACH);
}
}
RT_LOCK_ASSERT_HELD(rt);
if (rt->rt_flags & RTF_GATEWAY) {
struct rtentry *gwrt = rt->rt_gwroute;
struct sockaddr_in gw;
if (gwrt == NULL) {
gw = *((struct sockaddr_in *)rt->rt_gateway);
RT_UNLOCK(rt);
goto lookup;
}
RT_CONVERT_LOCK(rt);
RT_LOCK_SPIN(gwrt);
if (!(gwrt->rt_flags & RTF_UP)) {
struct rtentry *ogwrt;
rt->rt_gwroute = NULL;
RT_UNLOCK(gwrt);
gw = *((struct sockaddr_in *)rt->rt_gateway);
RT_UNLOCK(rt);
rtfree(gwrt);
lookup:
gwrt = rtalloc1_scoped(
(struct sockaddr *)&gw, 1, 0, ifindex);
RT_LOCK(rt);
if (!(rt->rt_flags & RTF_UP) ||
gwrt == NULL || gwrt == rt ||
!equal(SA(&gw), rt->rt_gateway)) {
if (gwrt == rt) {
RT_REMREF_LOCKED(gwrt);
gwrt = NULL;
}
RT_UNLOCK(rt);
if (gwrt != NULL)
rtfree(gwrt);
senderr(EHOSTUNREACH);
}
ogwrt = rt->rt_gwroute;
if ((rt->rt_gwroute = gwrt) != NULL)
RT_ADDREF(gwrt);
if (rt == hint0) {
RT_REMREF_LOCKED(rt);
RT_UNLOCK(rt);
} else {
RT_UNLOCK(rt);
rtfree(rt);
}
rt = gwrt;
if (ogwrt != NULL)
rtfree(ogwrt);
if (rt == NULL)
senderr(EHOSTUNREACH);
} else {
RT_ADDREF_LOCKED(gwrt);
RT_UNLOCK(gwrt);
if (rt == hint0) {
RT_REMREF_LOCKED(rt);
RT_UNLOCK(rt);
} else {
RT_UNLOCK(rt);
rtfree(rt);
}
rt = gwrt;
}
RT_LOCK_SPIN(rt);
if (!(rt->rt_flags & RTF_UP)) {
RT_UNLOCK(rt);
senderr(EHOSTUNREACH);
}
}
if (rt->rt_flags & RTF_REJECT) {
getmicrotime(&timenow);
if (rt->rt_rmx.rmx_expire == 0 ||
timenow.tv_sec < rt->rt_rmx.rmx_expire) {
RT_UNLOCK(rt);
senderr(rt == hint ? EHOSTDOWN : EHOSTUNREACH);
}
}
RT_CONVERT_LOCK(rt);
*out_route = rt;
}
return (0);
bad:
if (rt != NULL) {
RT_LOCK_SPIN(rt);
if (rt == hint0) {
RT_REMREF_LOCKED(rt);
RT_UNLOCK(rt);
} else {
RT_UNLOCK(rt);
rtfree(rt);
}
}
return (error);
}
#undef senderr
errno_t
arp_lookup_ip(ifnet_t ifp, const struct sockaddr_in *net_dest,
struct sockaddr_dl *ll_dest, size_t ll_dest_len, route_t hint,
mbuf_t packet)
{
route_t route = NULL;
errno_t result = 0;
struct sockaddr_dl *gateway;
struct llinfo_arp *llinfo;
struct timeval timenow;
if (net_dest->sin_family != AF_INET)
return (EAFNOSUPPORT);
if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING))
return (ENETDOWN);
if (hint != NULL) {
result = arp_route_to_gateway_route((const struct sockaddr*)
net_dest, hint, &route);
if (result != 0)
return (result);
if (route != NULL)
RT_LOCK_ASSERT_HELD(route);
}
if (packet->m_flags & M_BCAST) {
size_t broadcast_len;
bzero(ll_dest, ll_dest_len);
result = ifnet_llbroadcast_copy_bytes(ifp, LLADDR(ll_dest),
ll_dest_len - offsetof(struct sockaddr_dl, sdl_data),
&broadcast_len);
if (result == 0) {
ll_dest->sdl_alen = broadcast_len;
ll_dest->sdl_family = AF_LINK;
ll_dest->sdl_len = sizeof(struct sockaddr_dl);
}
goto release;
}
if (packet->m_flags & M_MCAST) {
if (route != NULL)
RT_UNLOCK(route);
result = dlil_resolve_multi(ifp,
(const struct sockaddr*)net_dest,
(struct sockaddr*)ll_dest, ll_dest_len);
if (route != NULL)
RT_LOCK(route);
goto release;
}
if (route == NULL || route->rt_llinfo == NULL) {
if (route != NULL) {
if (route == hint) {
RT_REMREF_LOCKED(route);
RT_UNLOCK(route);
} else {
RT_UNLOCK(route);
rtfree(route);
}
}
result = arp_lookup_route(&net_dest->sin_addr, 1, 0, &route,
ifp->if_index);
if (result == 0)
RT_LOCK_ASSERT_HELD(route);
}
if (result || route == NULL || route->rt_llinfo == NULL) {
char tmp[MAX_IPv4_STR_LEN];
if (result == 0)
result = EHOSTUNREACH;
if (log_arp_warnings &&
route != NULL && route->rt_llinfo == NULL)
log(LOG_DEBUG, "arpresolve: can't allocate llinfo "
"for %s\n", inet_ntop(AF_INET, &net_dest->sin_addr,
tmp, sizeof(tmp)));
goto release;
}
gateway = SDL(route->rt_gateway);
getmicrotime(&timenow);
if ((route->rt_rmx.rmx_expire == 0 ||
route->rt_rmx.rmx_expire > timenow.tv_sec) && gateway != NULL &&
gateway->sdl_family == AF_LINK && gateway->sdl_alen != 0) {
bcopy(gateway, ll_dest, MIN(gateway->sdl_len, ll_dest_len));
result = 0;
goto release;
}
if (ifp->if_flags & IFF_NOARP) {
result = ENOTSUP;
goto release;
}
llinfo = route->rt_llinfo;
if (packet != NULL) {
if (llinfo->la_hold != NULL)
m_freem(llinfo->la_hold);
llinfo->la_hold = packet;
}
if (route->rt_rmx.rmx_expire) {
route->rt_flags &= ~RTF_REJECT;
if (llinfo->la_asked == 0 ||
route->rt_rmx.rmx_expire != timenow.tv_sec) {
route->rt_rmx.rmx_expire = timenow.tv_sec;
if (llinfo->la_asked++ < arp_maxtries) {
struct ifaddr *rt_ifa = route->rt_ifa;
ifaref(rt_ifa);
RT_UNLOCK(route);
dlil_send_arp(ifp, ARPOP_REQUEST, NULL,
rt_ifa->ifa_addr, NULL,
(const struct sockaddr*)net_dest);
ifafree(rt_ifa);
RT_LOCK(route);
result = EJUSTRETURN;
goto release;
} else {
route->rt_flags |= RTF_REJECT;
route->rt_rmx.rmx_expire = rt_expiry(route,
route->rt_rmx.rmx_expire, arpt_down);
llinfo->la_asked = 0;
llinfo->la_hold = NULL;
result = EHOSTUNREACH;
goto release;
}
}
}
result = EJUSTRETURN;
release:
if (route != NULL) {
if (route == hint) {
RT_REMREF_LOCKED(route);
RT_UNLOCK(route);
} else {
RT_UNLOCK(route);
rtfree(route);
}
}
return (result);
}
errno_t
arp_ip_handle_input(
ifnet_t ifp,
u_short arpop,
const struct sockaddr_dl *sender_hw,
const struct sockaddr_in *sender_ip,
const struct sockaddr_in *target_ip)
{
char ipv4str[MAX_IPv4_STR_LEN];
struct sockaddr_dl proxied;
struct sockaddr_dl *gateway, *target_hw = NULL;
struct ifaddr *ifa;
struct in_ifaddr *ia;
struct in_ifaddr *best_ia = NULL;
route_t route = NULL;
char buf[3 * MAX_HW_LEN]; struct llinfo_arp *llinfo;
errno_t error;
int created_announcement = 0;
int bridged = 0, is_bridge = 0;
if (target_ip->sin_addr.s_addr == 0 && arpop == ARPOP_REQUEST)
goto done;
if (ifp->if_bridge)
bridged = 1;
if (ifp->if_type == IFT_BRIDGE)
is_bridge = 1;
lck_rw_lock_shared(in_ifaddr_rwlock);
TAILQ_FOREACH(ia, INADDR_HASH(target_ip->sin_addr.s_addr), ia_hash) {
if (((bridged && ia->ia_ifp->if_bridge != NULL) ||
(ia->ia_ifp == ifp)) &&
ia->ia_addr.sin_addr.s_addr == target_ip->sin_addr.s_addr) {
best_ia = ia;
ifaref(&best_ia->ia_ifa);
lck_rw_done(in_ifaddr_rwlock);
goto match;
}
}
TAILQ_FOREACH(ia, INADDR_HASH(sender_ip->sin_addr.s_addr), ia_hash) {
if (((bridged && ia->ia_ifp->if_bridge != NULL) ||
(ia->ia_ifp == ifp)) &&
ia->ia_addr.sin_addr.s_addr == sender_ip->sin_addr.s_addr) {
best_ia = ia;
ifaref(&best_ia->ia_ifa);
lck_rw_done(in_ifaddr_rwlock);
goto match;
}
}
#define BDG_MEMBER_MATCHES_ARP(addr, ifp, ia) \
(ia->ia_ifp->if_bridge == ifp->if_softc && \
!bcmp(ifnet_lladdr(ia->ia_ifp), ifnet_lladdr(ifp), ifp->if_addrlen) && \
addr == ia->ia_addr.sin_addr.s_addr)
if (is_bridge) {
TAILQ_FOREACH(ia, INADDR_HASH(target_ip->sin_addr.s_addr), ia_hash) {
if (BDG_MEMBER_MATCHES_ARP(target_ip->sin_addr.s_addr, ifp, ia)) {
ifp = ia->ia_ifp;
best_ia = ia;
ifaref(&best_ia->ia_ifa);
lck_rw_done(in_ifaddr_rwlock);
goto match;
}
}
}
lck_rw_done(in_ifaddr_rwlock);
ifnet_lock_shared(ifp);
TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
if (ifa->ifa_addr->sa_family != AF_INET)
continue;
best_ia = (struct in_ifaddr *)ifa;
ifaref(&best_ia->ia_ifa);
ifnet_lock_done(ifp);
goto match;
}
ifnet_lock_done(ifp);
if (!bridged || best_ia == NULL)
goto done;
match:
if (!bcmp(CONST_LLADDR(sender_hw), ifnet_lladdr(ifp), sender_hw->sdl_len)) {
goto done;
}
if (!bridged && sender_ip->sin_addr.s_addr == best_ia->ia_addr.sin_addr.s_addr) {
struct kev_msg ev_msg;
struct kev_in_collision *in_collision;
u_char storage[sizeof(struct kev_in_collision) + MAX_HW_LEN];
in_collision = (struct kev_in_collision*)storage;
log(LOG_ERR, "%s%d duplicate IP address %s sent from address %s\n",
ifp->if_name, ifp->if_unit,
inet_ntop(AF_INET, &sender_ip->sin_addr, ipv4str, sizeof(ipv4str)),
sdl_addr_to_hex(sender_hw, buf, sizeof(buf)));
in_collision->link_data.if_family = ifp->if_family;
in_collision->link_data.if_unit = ifp->if_unit;
strncpy(&in_collision->link_data.if_name[0], ifp->if_name, IFNAMSIZ);
in_collision->ia_ipaddr = sender_ip->sin_addr;
in_collision->hw_len = sender_hw->sdl_alen < MAX_HW_LEN ? sender_hw->sdl_alen : MAX_HW_LEN;
bcopy(CONST_LLADDR(sender_hw), (caddr_t)in_collision->hw_addr, in_collision->hw_len);
ev_msg.vendor_code = KEV_VENDOR_APPLE;
ev_msg.kev_class = KEV_NETWORK_CLASS;
ev_msg.kev_subclass = KEV_INET_SUBCLASS;
ev_msg.event_code = KEV_INET_ARPCOLLISION;
ev_msg.dv[0].data_ptr = in_collision;
ev_msg.dv[0].data_length = sizeof(struct kev_in_collision) + in_collision->hw_len;
ev_msg.dv[1].data_length = 0;
kev_post_msg(&ev_msg);
goto respond;
}
error = arp_lookup_route(&sender_ip->sin_addr,
(target_ip->sin_addr.s_addr == best_ia->ia_addr.sin_addr.s_addr &&
sender_ip->sin_addr.s_addr != 0), 0, &route, ifp->if_index);
if (error == 0)
RT_LOCK_ASSERT_HELD(route);
if (error || route == 0 || route->rt_gateway == 0) {
if (arpop != ARPOP_REQUEST) {
goto respond;
}
if (arp_sendllconflict
&& send_conflicting_probes != 0
&& (ifp->if_eflags & IFEF_ARPLL) != 0
&& IN_LINKLOCAL(ntohl(target_ip->sin_addr.s_addr))
&& sender_ip->sin_addr.s_addr == 0) {
if (route != NULL) {
RT_REMREF_LOCKED(route);
RT_UNLOCK(route);
route = NULL;
}
error = arp_lookup_route(&target_ip->sin_addr, 0, 0,
&route, ifp->if_index);
if (error == 0)
RT_LOCK_ASSERT_HELD(route);
if (error == 0 && route && route->rt_gateway) {
gateway = SDL(route->rt_gateway);
if (route->rt_ifp != ifp && gateway->sdl_alen != 0
&& (gateway->sdl_alen != sender_hw->sdl_alen
|| bcmp(CONST_LLADDR(gateway), CONST_LLADDR(sender_hw),
gateway->sdl_alen) != 0)) {
if (log_arp_warnings) {
log(LOG_INFO,
"arp: %s on %s%d sent probe for %s, already on %s%d\n",
sdl_addr_to_hex(sender_hw, buf, sizeof(buf)),
ifp->if_name, ifp->if_unit,
inet_ntop(AF_INET, &target_ip->sin_addr, ipv4str,
sizeof(ipv4str)),
route->rt_ifp->if_name, route->rt_ifp->if_unit);
log(LOG_INFO,
"arp: sending conflicting probe to %s on %s%d\n",
sdl_addr_to_hex(sender_hw, buf, sizeof(buf)),
ifp->if_name, ifp->if_unit);
}
RT_REMREF_LOCKED(route);
RT_UNLOCK(route);
route = NULL;
ifnet_lock_shared(ifp);
ifa = TAILQ_FIRST(&ifp->if_addrhead);
if (ifa != NULL)
ifaref(ifa);
ifnet_lock_done(ifp);
dlil_send_arp_internal(ifp, ARPOP_REQUEST,
ifa != NULL ? SDL(ifa->ifa_addr) : NULL,
(const struct sockaddr*)sender_ip, sender_hw,
(const struct sockaddr*)target_ip);
if (ifa != NULL) {
ifafree(ifa);
ifa = NULL;
}
}
}
goto respond;
} else if (keep_announcements != 0
&& target_ip->sin_addr.s_addr == sender_ip->sin_addr.s_addr) {
if (!IN_LINKLOCAL(ntohl(sender_ip->sin_addr.s_addr))
|| (ifp->if_eflags & IFEF_ARPLL) != 0) {
if (route != NULL) {
RT_REMREF_LOCKED(route);
RT_UNLOCK(route);
route = NULL;
}
error = arp_lookup_route(&sender_ip->sin_addr,
1, 0, &route, ifp->if_index);
if (error == 0)
RT_LOCK_ASSERT_HELD(route);
if (error == 0 && route != NULL && route->rt_gateway != NULL) {
created_announcement = 1;
}
}
if (created_announcement == 0) {
goto respond;
}
} else {
goto respond;
}
}
RT_LOCK_ASSERT_HELD(route);
gateway = SDL(route->rt_gateway);
if (!bridged && route->rt_ifp != ifp) {
if (!IN_LINKLOCAL(ntohl(sender_ip->sin_addr.s_addr)) || (ifp->if_eflags & IFEF_ARPLL) == 0) {
if (log_arp_warnings)
log(LOG_ERR, "arp: %s is on %s%d but got reply from %s on %s%d\n",
inet_ntop(AF_INET, &sender_ip->sin_addr, ipv4str,
sizeof(ipv4str)),
route->rt_ifp->if_name,
route->rt_ifp->if_unit,
sdl_addr_to_hex(sender_hw, buf, sizeof(buf)),
ifp->if_name, ifp->if_unit);
goto respond;
}
else {
if (route->rt_rmx.rmx_expire == 0) {
goto respond;
}
RT_UNLOCK(route);
lck_mtx_lock(rnh_lock);
RT_LOCK(route);
gateway = SDL(route->rt_gateway);
if ((gateway->sdl_alen != 0 && route->rt_parent &&
route->rt_parent->rt_ifp == route->rt_ifp) ||
(route->rt_flags & RTF_CONDEMNED)) {
RT_REMREF_LOCKED(route);
RT_UNLOCK(route);
route = NULL;
lck_mtx_unlock(rnh_lock);
goto respond;
}
#if IFNET_ROUTE_REFCNT
if (route->rt_if_ref_fn != NULL &&
route->rt_ifp != ifp) {
route->rt_if_ref_fn(ifp, 1);
route->rt_if_ref_fn(route->rt_ifp, -1);
}
#endif
route->rt_ifp = ifp;
rtsetifa(route, &best_ia->ia_ifa);
gateway->sdl_index = ifp->if_index;
RT_UNLOCK(route);
lck_mtx_unlock(rnh_lock);
RT_LOCK(route);
if (!(route->rt_flags & RTF_UP))
goto respond;
gateway = SDL(route->rt_gateway);
}
RT_LOCK_ASSERT_HELD(route);
}
if (gateway->sdl_alen && bcmp(LLADDR(gateway), CONST_LLADDR(sender_hw), gateway->sdl_alen)) {
if (route->rt_rmx.rmx_expire && log_arp_warnings) {
char buf2[3 * MAX_HW_LEN];
log(LOG_INFO, "arp: %s moved from %s to %s on %s%d\n",
inet_ntop(AF_INET, &sender_ip->sin_addr, ipv4str,
sizeof(ipv4str)),
sdl_addr_to_hex(gateway, buf, sizeof(buf)),
sdl_addr_to_hex(sender_hw, buf2, sizeof(buf2)),
ifp->if_name, ifp->if_unit);
}
else if (route->rt_rmx.rmx_expire == 0) {
if (log_arp_warnings) {
log(LOG_ERR, "arp: %s attempts to modify "
"permanent entry for %s on %s%d\n",
sdl_addr_to_hex(sender_hw, buf,
sizeof(buf)),
inet_ntop(AF_INET, &sender_ip->sin_addr,
ipv4str, sizeof(ipv4str)),
ifp->if_name, ifp->if_unit);
}
goto respond;
}
}
gateway->sdl_alen = sender_hw->sdl_alen;
bcopy(CONST_LLADDR(sender_hw), LLADDR(gateway), gateway->sdl_alen);
if (route->rt_rmx.rmx_expire) {
struct timeval timenow;
getmicrotime(&timenow);
route->rt_rmx.rmx_expire =
rt_expiry(route, timenow.tv_sec, arpt_keep);
}
route->rt_flags &= ~RTF_REJECT;
llinfo = route->rt_llinfo;
llinfo->la_asked = 0;
if (llinfo->la_hold) {
struct mbuf *m0;
m0 = llinfo->la_hold;
llinfo->la_hold = 0;
RT_UNLOCK(route);
dlil_output(ifp, PF_INET, m0, (caddr_t)route, rt_key(route), 0);
RT_REMREF(route);
route = NULL;
}
respond:
if (route != NULL) {
RT_REMREF_LOCKED(route);
RT_UNLOCK(route);
route = NULL;
}
if (arpop != ARPOP_REQUEST)
goto done;
if (target_ip->sin_addr.s_addr != best_ia->ia_addr.sin_addr.s_addr) {
error = arp_lookup_route(&target_ip->sin_addr, 0, SIN_PROXY,
&route, ifp->if_index);
if (error == 0) {
RT_LOCK_ASSERT_HELD(route);
if (route->rt_ifp != ifp &&
(route->rt_ifp->if_bridge != ifp->if_bridge ||
ifp->if_bridge == NULL)) {
RT_REMREF_LOCKED(route);
RT_UNLOCK(route);
goto done;
}
proxied = *SDL(route->rt_gateway);
target_hw = &proxied;
} else {
if (!arp_proxyall)
goto done;
route = rtalloc1_scoped((struct sockaddr *)
(size_t)target_ip, 0, 0, ifp->if_index);
if (!route)
goto done;
RT_LOCK(route);
if (route->rt_ifp == ifp) {
RT_UNLOCK(route);
rtfree(route);
goto done;
}
}
RT_REMREF_LOCKED(route);
RT_UNLOCK(route);
}
dlil_send_arp(ifp, ARPOP_REPLY,
target_hw, (const struct sockaddr*)target_ip,
sender_hw, (const struct sockaddr*)sender_ip);
done:
if (best_ia != NULL)
ifafree(&best_ia->ia_ifa);
return 0;
}
void
arp_ifinit(
struct ifnet *ifp,
struct ifaddr *ifa)
{
ifa->ifa_rtrequest = arp_rtrequest;
ifa->ifa_flags |= RTF_CLONING;
dlil_send_arp(ifp, ARPOP_REQUEST, NULL, ifa->ifa_addr, NULL, ifa->ifa_addr);
}