Home | History | Annotate | Line # | Download | only in netinet
      1 /*	$NetBSD: if_arp.c,v 1.252 2017/06/21 09:05:31 ozaki-r Exp $	*/
      2 
      3 /*-
      4  * Copyright (c) 1998, 2000, 2008 The NetBSD Foundation, Inc.
      5  * All rights reserved.
      6  *
      7  * This code is derived from software contributed to The NetBSD Foundation
      8  * by Public Access Networks Corporation ("Panix").  It was developed under
      9  * contract to Panix by Eric Haszlakiewicz and Thor Lancelot Simon.
     10  *
     11  * Redistribution and use in source and binary forms, with or without
     12  * modification, are permitted provided that the following conditions
     13  * are met:
     14  * 1. Redistributions of source code must retain the above copyright
     15  *    notice, this list of conditions and the following disclaimer.
     16  * 2. Redistributions in binary form must reproduce the above copyright
     17  *    notice, this list of conditions and the following disclaimer in the
     18  *    documentation and/or other materials provided with the distribution.
     19  *
     20  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     21  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     22  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     23  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     24  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     25  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     26  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     27  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     28  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     29  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     30  * POSSIBILITY OF SUCH DAMAGE.
     31  */
     32 
     33 /*
     34  * Copyright (c) 1982, 1986, 1988, 1993
     35  *	The Regents of the University of California.  All rights reserved.
     36  *
     37  * Redistribution and use in source and binary forms, with or without
     38  * modification, are permitted provided that the following conditions
     39  * are met:
     40  * 1. Redistributions of source code must retain the above copyright
     41  *    notice, this list of conditions and the following disclaimer.
     42  * 2. Redistributions in binary form must reproduce the above copyright
     43  *    notice, this list of conditions and the following disclaimer in the
     44  *    documentation and/or other materials provided with the distribution.
     45  * 3. Neither the name of the University nor the names of its contributors
     46  *    may be used to endorse or promote products derived from this software
     47  *    without specific prior written permission.
     48  *
     49  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     50  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     51  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     52  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     53  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     54  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     55  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     56  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     57  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     58  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     59  * SUCH DAMAGE.
     60  *
     61  *	@(#)if_ether.c	8.2 (Berkeley) 9/26/94
     62  */
     63 
     64 /*
     65  * Ethernet address resolution protocol.
     66  * TODO:
     67  *	add "inuse/lock" bit (or ref. count) along with valid bit
     68  */
     69 
     70 #include <sys/cdefs.h>
     71 __KERNEL_RCSID(0, "$NetBSD: if_arp.c,v 1.252 2017/06/21 09:05:31 ozaki-r Exp $");
     72 
     73 #ifdef _KERNEL_OPT
     74 #include "opt_ddb.h"
     75 #include "opt_inet.h"
     76 #include "opt_net_mpsafe.h"
     77 #endif
     78 
     79 #ifdef INET
     80 
     81 #include "arp.h"
     82 #include "bridge.h"
     83 
     84 #include <sys/param.h>
     85 #include <sys/systm.h>
     86 #include <sys/callout.h>
     87 #include <sys/kmem.h>
     88 #include <sys/mbuf.h>
     89 #include <sys/socket.h>
     90 #include <sys/time.h>
     91 #include <sys/timetc.h>
     92 #include <sys/kernel.h>
     93 #include <sys/errno.h>
     94 #include <sys/ioctl.h>
     95 #include <sys/syslog.h>
     96 #include <sys/proc.h>
     97 #include <sys/protosw.h>
     98 #include <sys/domain.h>
     99 #include <sys/sysctl.h>
    100 #include <sys/socketvar.h>
    101 #include <sys/percpu.h>
    102 #include <sys/cprng.h>
    103 #include <sys/kmem.h>
    104 
    105 #include <net/ethertypes.h>
    106 #include <net/if.h>
    107 #include <net/if_dl.h>
    108 #include <net/if_token.h>
    109 #include <net/if_types.h>
    110 #include <net/if_ether.h>
    111 #include <net/if_llatbl.h>
    112 #include <net/net_osdep.h>
    113 #include <net/route.h>
    114 #include <net/net_stats.h>
    115 
    116 #include <netinet/in.h>
    117 #include <netinet/in_systm.h>
    118 #include <netinet/in_var.h>
    119 #include <netinet/ip.h>
    120 #include <netinet/if_inarp.h>
    121 
    122 #include "arcnet.h"
    123 #if NARCNET > 0
    124 #include <net/if_arc.h>
    125 #endif
    126 #include "fddi.h"
    127 #if NFDDI > 0
    128 #include <net/if_fddi.h>
    129 #endif
    130 #include "token.h"
    131 #include "carp.h"
    132 #if NCARP > 0
    133 #include <netinet/ip_carp.h>
    134 #endif
    135 
    136 /*
    137  * ARP trailer negotiation.  Trailer protocol is not IP specific,
    138  * but ARP request/response use IP addresses.
    139  */
    140 #define ETHERTYPE_IPTRAILERS ETHERTYPE_TRAIL
    141 
    142 /* timer values */
    143 static int	arpt_keep = (20*60);	/* once resolved, good for 20 more minutes */
    144 static int	arpt_down = 20;		/* once declared down, don't send for 20 secs */
    145 static int	arp_maxhold = 1;	/* number of packets to hold per ARP entry */
    146 #define	rt_expire rt_rmx.rmx_expire
    147 #define	rt_pksent rt_rmx.rmx_pksent
    148 
    149 int		ip_dad_count = PROBE_NUM;
    150 #ifdef ARP_DEBUG
    151 int		arp_debug = 1;
    152 #else
    153 int		arp_debug = 0;
    154 #endif
    155 
    156 static	void arp_init(void);
    157 
    158 static	void arprequest(struct ifnet *,
    159     const struct in_addr *, const struct in_addr *,
    160     const u_int8_t *);
    161 static	void arpannounce1(struct ifaddr *);
    162 static	struct sockaddr *arp_setgate(struct rtentry *, struct sockaddr *,
    163 	    const struct sockaddr *);
    164 static	void arptimer(void *);
    165 static	void arp_settimer(struct llentry *, int);
    166 static	struct llentry *arplookup(struct ifnet *, struct mbuf *,
    167 	    const struct in_addr *, const struct sockaddr *, int);
    168 static	struct llentry *arpcreate(struct ifnet *, struct mbuf *,
    169 	    const struct in_addr *, const struct sockaddr *, int);
    170 static	void in_arpinput(struct mbuf *);
    171 static	void in_revarpinput(struct mbuf *);
    172 static	void revarprequest(struct ifnet *);
    173 
    174 static	void arp_drainstub(void);
    175 
    176 static void arp_dad_timer(struct ifaddr *);
    177 static void arp_dad_start(struct ifaddr *);
    178 static void arp_dad_stop(struct ifaddr *);
    179 static void arp_dad_duplicated(struct ifaddr *, const char *);
    180 
    181 static void arp_init_llentry(struct ifnet *, struct llentry *);
    182 #if NTOKEN > 0
    183 static void arp_free_llentry_tokenring(struct llentry *);
    184 #endif
    185 
    186 struct	ifqueue arpintrq = {
    187 	.ifq_head = NULL,
    188 	.ifq_tail = NULL,
    189 	.ifq_len = 0,
    190 	.ifq_maxlen = 50,
    191 	.ifq_drops = 0,
    192 };
    193 static int	arp_maxtries = 5;
    194 static int	useloopback = 1;	/* use loopback interface for local traffic */
    195 
    196 static percpu_t *arpstat_percpu;
    197 
    198 #define	ARP_STAT_GETREF()	_NET_STAT_GETREF(arpstat_percpu)
    199 #define	ARP_STAT_PUTREF()	_NET_STAT_PUTREF(arpstat_percpu)
    200 
    201 #define	ARP_STATINC(x)		_NET_STATINC(arpstat_percpu, x)
    202 #define	ARP_STATADD(x, v)	_NET_STATADD(arpstat_percpu, x, v)
    203 
    204 /* revarp state */
    205 static struct	in_addr myip, srv_ip;
    206 static int	myip_initialized = 0;
    207 static int	revarp_in_progress = 0;
    208 static struct	ifnet *myip_ifp = NULL;
    209 
    210 static int arp_drainwanted;
    211 
    212 static int log_movements = 1;
    213 static int log_permanent_modify = 1;
    214 static int log_wrong_iface = 1;
    215 static int log_unknown_network = 1;
    216 
    217 /*
    218  * this should be elsewhere.
    219  */
    220 
    221 #define	LLA_ADDRSTRLEN	(16 * 3)
    222 
    223 static char *
    224 lla_snprintf(char *, u_int8_t *, int);
    225 
    226 static char *
    227 lla_snprintf(char *dst, u_int8_t *adrp, int len)
    228 {
    229 	int i;
    230 	char *p;
    231 
    232 	p = dst;
    233 
    234 	*p++ = hexdigits[(*adrp) >> 4];
    235 	*p++ = hexdigits[(*adrp++) & 0xf];
    236 
    237 	for (i = 1; i < len && i < 16; i++) {
    238 		*p++ = ':';
    239 		*p++ = hexdigits[(*adrp) >> 4];
    240 		*p++ = hexdigits[(*adrp++) & 0xf];
    241 	}
    242 
    243 	*p = 0;
    244 	return dst;
    245 }
    246 
    247 DOMAIN_DEFINE(arpdomain);	/* forward declare and add to link set */
    248 
    249 static void
    250 arp_fasttimo(void)
    251 {
    252 	if (arp_drainwanted) {
    253 		arp_drain();
    254 		arp_drainwanted = 0;
    255 	}
    256 }
    257 
    258 const struct protosw arpsw[] = {
    259 	{ .pr_type = 0,
    260 	  .pr_domain = &arpdomain,
    261 	  .pr_protocol = 0,
    262 	  .pr_flags = 0,
    263 	  .pr_input = 0,
    264 	  .pr_ctlinput = 0,
    265 	  .pr_ctloutput = 0,
    266 	  .pr_usrreqs = 0,
    267 	  .pr_init = arp_init,
    268 	  .pr_fasttimo = arp_fasttimo,
    269 	  .pr_slowtimo = 0,
    270 	  .pr_drain = arp_drainstub,
    271 	}
    272 };
    273 
    274 struct domain arpdomain = {
    275 	.dom_family = PF_ARP,
    276 	.dom_name = "arp",
    277 	.dom_protosw = arpsw,
    278 	.dom_protoswNPROTOSW = &arpsw[__arraycount(arpsw)],
    279 };
    280 
    281 static void sysctl_net_inet_arp_setup(struct sysctllog **);
    282 
    283 void
    284 arp_init(void)
    285 {
    286 
    287 	sysctl_net_inet_arp_setup(NULL);
    288 	arpstat_percpu = percpu_alloc(sizeof(uint64_t) * ARP_NSTATS);
    289 	IFQ_LOCK_INIT(&arpintrq);
    290 }
    291 
    292 static void
    293 arp_drainstub(void)
    294 {
    295 	arp_drainwanted = 1;
    296 }
    297 
    298 /*
    299  * ARP protocol drain routine.  Called when memory is in short supply.
    300  * Called at splvm();  don't acquire softnet_lock as can be called from
    301  * hardware interrupt handlers.
    302  */
    303 void
    304 arp_drain(void)
    305 {
    306 
    307 	lltable_drain(AF_INET);
    308 }
    309 
    310 static void
    311 arptimer(void *arg)
    312 {
    313 	struct llentry *lle = arg;
    314 	struct ifnet *ifp;
    315 
    316 	if (lle == NULL)
    317 		return;
    318 
    319 	if (lle->la_flags & LLE_STATIC)
    320 		return;
    321 
    322 	LLE_WLOCK(lle);
    323 	if (callout_pending(&lle->la_timer)) {
    324 		/*
    325 		 * Here we are a bit odd here in the treatment of
    326 		 * active/pending. If the pending bit is set, it got
    327 		 * rescheduled before I ran. The active
    328 		 * bit we ignore, since if it was stopped
    329 		 * in ll_tablefree() and was currently running
    330 		 * it would have return 0 so the code would
    331 		 * not have deleted it since the callout could
    332 		 * not be stopped so we want to go through
    333 		 * with the delete here now. If the callout
    334 		 * was restarted, the pending bit will be back on and
    335 		 * we just want to bail since the callout_reset would
    336 		 * return 1 and our reference would have been removed
    337 		 * by arpresolve() below.
    338 		 */
    339 		LLE_WUNLOCK(lle);
    340 		return;
    341 	}
    342 	ifp = lle->lle_tbl->llt_ifp;
    343 
    344 	callout_stop(&lle->la_timer);
    345 
    346 	/* XXX: LOR avoidance. We still have ref on lle. */
    347 	LLE_WUNLOCK(lle);
    348 
    349 	IF_AFDATA_LOCK(ifp);
    350 	LLE_WLOCK(lle);
    351 
    352 	/* Guard against race with other llentry_free(). */
    353 	if (lle->la_flags & LLE_LINKED) {
    354 		size_t pkts_dropped;
    355 
    356 		LLE_REMREF(lle);
    357 		pkts_dropped = llentry_free(lle);
    358 		ARP_STATADD(ARP_STAT_DFRDROPPED, pkts_dropped);
    359 		ARP_STATADD(ARP_STAT_DFRTOTAL, pkts_dropped);
    360 	} else {
    361 		LLE_FREE_LOCKED(lle);
    362 	}
    363 
    364 	IF_AFDATA_UNLOCK(ifp);
    365 }
    366 
    367 static void
    368 arp_settimer(struct llentry *la, int sec)
    369 {
    370 
    371 	LLE_WLOCK_ASSERT(la);
    372 	LLE_ADDREF(la);
    373 	callout_reset(&la->la_timer, hz * sec, arptimer, la);
    374 }
    375 
    376 /*
    377  * We set the gateway for RTF_CLONING routes to a "prototype"
    378  * link-layer sockaddr whose interface type (if_type) and interface
    379  * index (if_index) fields are prepared.
    380  */
    381 static struct sockaddr *
    382 arp_setgate(struct rtentry *rt, struct sockaddr *gate,
    383     const struct sockaddr *netmask)
    384 {
    385 	const struct ifnet *ifp = rt->rt_ifp;
    386 	uint8_t namelen = strlen(ifp->if_xname);
    387 	uint8_t addrlen = ifp->if_addrlen;
    388 
    389 	/*
    390 	 * XXX: If this is a manually added route to interface
    391 	 * such as older version of routed or gated might provide,
    392 	 * restore cloning bit.
    393 	 */
    394 	if ((rt->rt_flags & RTF_HOST) == 0 && netmask != NULL &&
    395 	    satocsin(netmask)->sin_addr.s_addr != 0xffffffff)
    396 		rt->rt_flags |= RTF_CONNECTED;
    397 
    398 	if ((rt->rt_flags & (RTF_CONNECTED | RTF_LOCAL))) {
    399 		union {
    400 			struct sockaddr sa;
    401 			struct sockaddr_storage ss;
    402 			struct sockaddr_dl sdl;
    403 		} u;
    404 		/*
    405 		 * Case 1: This route should come from a route to iface.
    406 		 */
    407 		sockaddr_dl_init(&u.sdl, sizeof(u.ss),
    408 		    ifp->if_index, ifp->if_type, NULL, namelen, NULL, addrlen);
    409 		rt_setgate(rt, &u.sa);
    410 		gate = rt->rt_gateway;
    411 	}
    412 	return gate;
    413 }
    414 
    415 static void
    416 arp_init_llentry(struct ifnet *ifp, struct llentry *lle)
    417 {
    418 
    419 	switch (ifp->if_type) {
    420 #if NTOKEN > 0
    421 	case IFT_ISO88025:
    422 		lle->la_opaque = kmem_intr_alloc(sizeof(struct token_rif),
    423 		    KM_NOSLEEP);
    424 		lle->lle_ll_free = arp_free_llentry_tokenring;
    425 		break;
    426 #endif
    427 	}
    428 }
    429 
    430 #if NTOKEN > 0
    431 static void
    432 arp_free_llentry_tokenring(struct llentry *lle)
    433 {
    434 
    435 	kmem_intr_free(lle->la_opaque, sizeof(struct token_rif));
    436 }
    437 #endif
    438 
    439 /*
    440  * Parallel to llc_rtrequest.
    441  */
    442 void
    443 arp_rtrequest(int req, struct rtentry *rt, const struct rt_addrinfo *info)
    444 {
    445 	struct sockaddr *gate = rt->rt_gateway;
    446 	struct in_ifaddr *ia;
    447 	struct ifaddr *ifa;
    448 	struct ifnet *ifp = rt->rt_ifp;
    449 	int bound;
    450 	int s;
    451 
    452 	if (req == RTM_LLINFO_UPD) {
    453 		if ((ifa = info->rti_ifa) != NULL)
    454 			arpannounce1(ifa);
    455 		return;
    456 	}
    457 
    458 	if ((rt->rt_flags & RTF_GATEWAY) != 0) {
    459 		if (req != RTM_ADD)
    460 			return;
    461 
    462 		/*
    463 		 * linklayers with particular link MTU limitation.
    464 		 */
    465 		switch(ifp->if_type) {
    466 #if NFDDI > 0
    467 		case IFT_FDDI:
    468 			if (ifp->if_mtu > FDDIIPMTU)
    469 				rt->rt_rmx.rmx_mtu = FDDIIPMTU;
    470 			break;
    471 #endif
    472 #if NARCNET > 0
    473 		case IFT_ARCNET:
    474 		    {
    475 			int arcipifmtu;
    476 
    477 			if (ifp->if_flags & IFF_LINK0)
    478 				arcipifmtu = arc_ipmtu;
    479 			else
    480 				arcipifmtu = ARCMTU;
    481 			if (ifp->if_mtu > arcipifmtu)
    482 				rt->rt_rmx.rmx_mtu = arcipifmtu;
    483 			break;
    484 		    }
    485 #endif
    486 		}
    487 		return;
    488 	}
    489 
    490 	switch (req) {
    491 	case RTM_SETGATE:
    492 		gate = arp_setgate(rt, gate, info->rti_info[RTAX_NETMASK]);
    493 		break;
    494 	case RTM_ADD:
    495 		gate = arp_setgate(rt, gate, info->rti_info[RTAX_NETMASK]);
    496 		if (gate == NULL) {
    497 			log(LOG_ERR, "%s: arp_setgate failed\n", __func__);
    498 			break;
    499 		}
    500 		if ((rt->rt_flags & RTF_CONNECTED) ||
    501 		    (rt->rt_flags & RTF_LOCAL)) {
    502 			/*
    503 			 * Give this route an expiration time, even though
    504 			 * it's a "permanent" route, so that routes cloned
    505 			 * from it do not need their expiration time set.
    506 			 */
    507 			KASSERT(time_uptime != 0);
    508 			rt->rt_expire = time_uptime;
    509 			/*
    510 			 * linklayers with particular link MTU limitation.
    511 			 */
    512 			switch (ifp->if_type) {
    513 #if NFDDI > 0
    514 			case IFT_FDDI:
    515 				if ((rt->rt_rmx.rmx_locks & RTV_MTU) == 0 &&
    516 				    (rt->rt_rmx.rmx_mtu > FDDIIPMTU ||
    517 				     (rt->rt_rmx.rmx_mtu == 0 &&
    518 				      ifp->if_mtu > FDDIIPMTU)))
    519 					rt->rt_rmx.rmx_mtu = FDDIIPMTU;
    520 				break;
    521 #endif
    522 #if NARCNET > 0
    523 			case IFT_ARCNET:
    524 			    {
    525 				int arcipifmtu;
    526 				if (ifp->if_flags & IFF_LINK0)
    527 					arcipifmtu = arc_ipmtu;
    528 				else
    529 					arcipifmtu = ARCMTU;
    530 
    531 				if ((rt->rt_rmx.rmx_locks & RTV_MTU) == 0 &&
    532 				    (rt->rt_rmx.rmx_mtu > arcipifmtu ||
    533 				     (rt->rt_rmx.rmx_mtu == 0 &&
    534 				      ifp->if_mtu > arcipifmtu)))
    535 					rt->rt_rmx.rmx_mtu = arcipifmtu;
    536 				break;
    537 			    }
    538 #endif
    539 			}
    540 			if (rt->rt_flags & RTF_CONNECTED)
    541 				break;
    542 		}
    543 
    544 		bound = curlwp_bind();
    545 		/* Announce a new entry if requested. */
    546 		if (rt->rt_flags & RTF_ANNOUNCE) {
    547 			struct psref psref;
    548 			ia = in_get_ia_on_iface_psref(
    549 			    satocsin(rt_getkey(rt))->sin_addr, ifp, &psref);
    550 			if (ia != NULL) {
    551 				arpannounce(ifp, &ia->ia_ifa,
    552 				    CLLADDR(satocsdl(gate)));
    553 				ia4_release(ia, &psref);
    554 			}
    555 		}
    556 
    557 		if (gate->sa_family != AF_LINK ||
    558 		    gate->sa_len < sockaddr_dl_measure(0, ifp->if_addrlen)) {
    559 			log(LOG_DEBUG, "%s: bad gateway value\n", __func__);
    560 			goto out;
    561 		}
    562 
    563 		satosdl(gate)->sdl_type = ifp->if_type;
    564 		satosdl(gate)->sdl_index = ifp->if_index;
    565 
    566 		/* If the route is for a broadcast address mark it as such.
    567 		 * This way we can avoid an expensive call to in_broadcast()
    568 		 * in ip_output() most of the time (because the route passed
    569 		 * to ip_output() is almost always a host route). */
    570 		if (rt->rt_flags & RTF_HOST &&
    571 		    !(rt->rt_flags & RTF_BROADCAST) &&
    572 		    in_broadcast(satocsin(rt_getkey(rt))->sin_addr, rt->rt_ifp))
    573 			rt->rt_flags |= RTF_BROADCAST;
    574 		/* There is little point in resolving the broadcast address */
    575 		if (rt->rt_flags & RTF_BROADCAST)
    576 			goto out;
    577 
    578 		/*
    579 		 * When called from rt_ifa_addlocal, we cannot depend on that
    580 		 * the address (rt_getkey(rt)) exits in the address list of the
    581 		 * interface. So check RTF_LOCAL instead.
    582 		 */
    583 		if (rt->rt_flags & RTF_LOCAL) {
    584 			rt->rt_expire = 0;
    585 			if (useloopback) {
    586 				rt->rt_ifp = lo0ifp;
    587 				rt->rt_rmx.rmx_mtu = 0;
    588 			}
    589 			goto out;
    590 		}
    591 
    592 		s = pserialize_read_enter();
    593 		ia = in_get_ia_on_iface(satocsin(rt_getkey(rt))->sin_addr, ifp);
    594 		if (ia == NULL) {
    595 			pserialize_read_exit(s);
    596 			goto out;
    597 		}
    598 
    599 		rt->rt_expire = 0;
    600 		if (useloopback) {
    601 			rt->rt_ifp = lo0ifp;
    602 			rt->rt_rmx.rmx_mtu = 0;
    603 		}
    604 		rt->rt_flags |= RTF_LOCAL;
    605 		/*
    606 		 * make sure to set rt->rt_ifa to the interface
    607 		 * address we are using, otherwise we will have trouble
    608 		 * with source address selection.
    609 		 */
    610 		ifa = &ia->ia_ifa;
    611 		if (ifa != rt->rt_ifa)
    612 			/* Assume it doesn't sleep */
    613 			rt_replace_ifa(rt, ifa);
    614 		pserialize_read_exit(s);
    615 	out:
    616 		curlwp_bindx(bound);
    617 		break;
    618 	}
    619 }
    620 
    621 /*
    622  * Broadcast an ARP request. Caller specifies:
    623  *	- arp header source ip address
    624  *	- arp header target ip address
    625  *	- arp header source ethernet address
    626  */
    627 static void
    628 arprequest(struct ifnet *ifp,
    629     const struct in_addr *sip, const struct in_addr *tip,
    630     const u_int8_t *enaddr)
    631 {
    632 	struct mbuf *m;
    633 	struct arphdr *ah;
    634 	struct sockaddr sa;
    635 	uint64_t *arps;
    636 
    637 	KASSERT(sip != NULL);
    638 	KASSERT(tip != NULL);
    639 	KASSERT(enaddr != NULL);
    640 
    641 	if ((m = m_gethdr(M_DONTWAIT, MT_DATA)) == NULL)
    642 		return;
    643 	MCLAIM(m, &arpdomain.dom_mowner);
    644 	switch (ifp->if_type) {
    645 	case IFT_IEEE1394:
    646 		m->m_len = sizeof(*ah) + 2 * sizeof(struct in_addr) +
    647 		    ifp->if_addrlen;
    648 		break;
    649 	default:
    650 		m->m_len = sizeof(*ah) + 2 * sizeof(struct in_addr) +
    651 		    2 * ifp->if_addrlen;
    652 		break;
    653 	}
    654 	m->m_pkthdr.len = m->m_len;
    655 	MH_ALIGN(m, m->m_len);
    656 	ah = mtod(m, struct arphdr *);
    657 	memset(ah, 0, m->m_len);
    658 	switch (ifp->if_type) {
    659 	case IFT_IEEE1394:	/* RFC2734 */
    660 		/* fill it now for ar_tpa computation */
    661 		ah->ar_hrd = htons(ARPHRD_IEEE1394);
    662 		break;
    663 	default:
    664 		/* ifp->if_output will fill ar_hrd */
    665 		break;
    666 	}
    667 	ah->ar_pro = htons(ETHERTYPE_IP);
    668 	ah->ar_hln = ifp->if_addrlen;		/* hardware address length */
    669 	ah->ar_pln = sizeof(struct in_addr);	/* protocol address length */
    670 	ah->ar_op = htons(ARPOP_REQUEST);
    671 	memcpy(ar_sha(ah), enaddr, ah->ar_hln);
    672 	memcpy(ar_spa(ah), sip, ah->ar_pln);
    673 	memcpy(ar_tpa(ah), tip, ah->ar_pln);
    674 	sa.sa_family = AF_ARP;
    675 	sa.sa_len = 2;
    676 	m->m_flags |= M_BCAST;
    677 	arps = ARP_STAT_GETREF();
    678 	arps[ARP_STAT_SNDTOTAL]++;
    679 	arps[ARP_STAT_SENDREQUEST]++;
    680 	ARP_STAT_PUTREF();
    681 	if_output_lock(ifp, ifp, m, &sa, NULL);
    682 }
    683 
    684 void
    685 arpannounce(struct ifnet *ifp, struct ifaddr *ifa, const uint8_t *enaddr)
    686 {
    687 	struct in_ifaddr *ia = ifatoia(ifa);
    688 	struct in_addr *ip = &IA_SIN(ifa)->sin_addr;
    689 
    690 	if (ia->ia4_flags & (IN_IFF_NOTREADY | IN_IFF_DETACHED)) {
    691 		ARPLOG(LOG_DEBUG, "%s not ready\n", ARPLOGADDR(ip));
    692 		return;
    693 	}
    694 	arprequest(ifp, ip, ip, enaddr);
    695 }
    696 
    697 static void
    698 arpannounce1(struct ifaddr *ifa)
    699 {
    700 
    701 	arpannounce(ifa->ifa_ifp, ifa, CLLADDR(ifa->ifa_ifp->if_sadl));
    702 }
    703 
    704 /*
    705  * Resolve an IP address into an ethernet address.  If success,
    706  * desten is filled in.  If there is no entry in arptab,
    707  * set one up and broadcast a request for the IP address.
    708  * Hold onto this mbuf and resend it once the address
    709  * is finally resolved.  A return value of 0 indicates
    710  * that desten has been filled in and the packet should be sent
    711  * normally; a return value of EWOULDBLOCK indicates that the packet has been
    712  * held pending resolution.
    713  * Any other value indicates an error.
    714  */
    715 int
    716 arpresolve(struct ifnet *ifp, const struct rtentry *rt, struct mbuf *m,
    717     const struct sockaddr *dst, void *desten, size_t destlen)
    718 {
    719 	struct llentry *la;
    720 	const char *create_lookup;
    721 	bool renew;
    722 	int error;
    723 	struct ifnet *origifp = ifp;
    724 #if NCARP > 0
    725 	if (rt != NULL && rt->rt_ifp->if_type == IFT_CARP)
    726 		ifp = rt->rt_ifp;
    727 #endif
    728 
    729 	KASSERT(m != NULL);
    730 
    731 	la = arplookup(ifp, m, NULL, dst, 0);
    732 	if (la == NULL)
    733 		goto notfound;
    734 
    735 	if ((la->la_flags & LLE_VALID) &&
    736 	    ((la->la_flags & LLE_STATIC) || la->la_expire > time_uptime)) {
    737 		KASSERT(destlen >= ifp->if_addrlen);
    738 		memcpy(desten, &la->ll_addr, ifp->if_addrlen);
    739 		LLE_RUNLOCK(la);
    740 		return 0;
    741 	}
    742 
    743 notfound:
    744 #ifdef IFF_STATICARP /* FreeBSD */
    745 #define _IFF_NOARP (IFF_NOARP | IFF_STATICARP)
    746 #else
    747 #define _IFF_NOARP IFF_NOARP
    748 #endif
    749 	if (ifp->if_flags & _IFF_NOARP) {
    750 		if (la != NULL)
    751 			LLE_RUNLOCK(la);
    752 		error = ENOTSUP;
    753 		goto bad;
    754 	}
    755 #undef _IFF_NOARP
    756 	if (la == NULL) {
    757 		create_lookup = "create";
    758 		IF_AFDATA_WLOCK(ifp);
    759 		la = lla_create(LLTABLE(ifp), LLE_EXCLUSIVE, dst);
    760 		IF_AFDATA_WUNLOCK(ifp);
    761 		if (la == NULL)
    762 			ARP_STATINC(ARP_STAT_ALLOCFAIL);
    763 		else {
    764 			struct sockaddr_in sin;
    765 
    766 			arp_init_llentry(ifp, la);
    767 			sockaddr_in_init(&sin, &la->r_l3addr.addr4, 0);
    768 			rt_clonedmsg(sintosa(&sin), ifp, rt);
    769 		}
    770 	} else if (LLE_TRY_UPGRADE(la) == 0) {
    771 		create_lookup = "lookup";
    772 		LLE_RUNLOCK(la);
    773 		IF_AFDATA_RLOCK(ifp);
    774 		la = lla_lookup(LLTABLE(ifp), LLE_EXCLUSIVE, dst);
    775 		IF_AFDATA_RUNLOCK(ifp);
    776 	}
    777 
    778 	error = EINVAL;
    779 	if (la == NULL) {
    780 		log(LOG_DEBUG,
    781 		    "%s: failed to %s llentry for %s on %s\n",
    782 		    __func__, create_lookup, inet_ntoa(satocsin(dst)->sin_addr),
    783 		    ifp->if_xname);
    784 		goto bad;
    785 	}
    786 
    787 	if ((la->la_flags & LLE_VALID) &&
    788 	    ((la->la_flags & LLE_STATIC) || la->la_expire > time_uptime))
    789 	{
    790 		KASSERT(destlen >= ifp->if_addrlen);
    791 		memcpy(desten, &la->ll_addr, ifp->if_addrlen);
    792 		renew = false;
    793 		/*
    794 		 * If entry has an expiry time and it is approaching,
    795 		 * see if we need to send an ARP request within this
    796 		 * arpt_down interval.
    797 		 */
    798 		if (!(la->la_flags & LLE_STATIC) &&
    799 		    time_uptime + la->la_preempt > la->la_expire)
    800 		{
    801 			renew = true;
    802 			la->la_preempt--;
    803 		}
    804 
    805 		LLE_WUNLOCK(la);
    806 
    807 		if (renew) {
    808 			const u_int8_t *enaddr =
    809 			    CLLADDR(ifp->if_sadl);
    810 			arprequest(origifp,
    811 			    &satocsin(rt->rt_ifa->ifa_addr)->sin_addr,
    812 			    &satocsin(dst)->sin_addr, enaddr);
    813 		}
    814 
    815 		return 0;
    816 	}
    817 
    818 	if (la->la_flags & LLE_STATIC) {   /* should not happen! */
    819 		LLE_RUNLOCK(la);
    820 		log(LOG_DEBUG, "%s: ouch, empty static llinfo for %s\n",
    821 		    __func__, inet_ntoa(satocsin(dst)->sin_addr));
    822 		error = EINVAL;
    823 		goto bad;
    824 	}
    825 
    826 	renew = (la->la_asked == 0 || la->la_expire != time_uptime);
    827 
    828 	/*
    829 	 * There is an arptab entry, but no ethernet address
    830 	 * response yet.  Add the mbuf to the list, dropping
    831 	 * the oldest packet if we have exceeded the system
    832 	 * setting.
    833 	 */
    834 	LLE_WLOCK_ASSERT(la);
    835 	if (la->la_numheld >= arp_maxhold) {
    836 		if (la->la_hold != NULL) {
    837 			struct mbuf *next = la->la_hold->m_nextpkt;
    838 			m_freem(la->la_hold);
    839 			la->la_hold = next;
    840 			la->la_numheld--;
    841 			ARP_STATINC(ARP_STAT_DFRDROPPED);
    842 			ARP_STATINC(ARP_STAT_DFRTOTAL);
    843 		}
    844 	}
    845 	if (la->la_hold != NULL) {
    846 		struct mbuf *curr = la->la_hold;
    847 		while (curr->m_nextpkt != NULL)
    848 			curr = curr->m_nextpkt;
    849 		curr->m_nextpkt = m;
    850 	} else
    851 		la->la_hold = m;
    852 	la->la_numheld++;
    853 	if (!renew)
    854 		LLE_DOWNGRADE(la);
    855 
    856 	/*
    857 	 * Return EWOULDBLOCK if we have tried less than arp_maxtries. It
    858 	 * will be masked by ether_output(). Return EHOSTDOWN/EHOSTUNREACH
    859 	 * if we have already sent arp_maxtries ARP requests. Retransmit the
    860 	 * ARP request, but not faster than one request per second.
    861 	 */
    862 	if (la->la_asked < arp_maxtries)
    863 		error = EWOULDBLOCK;	/* First request. */
    864 	else
    865 		error = (rt != NULL && rt->rt_flags & RTF_GATEWAY) ?
    866 		    EHOSTUNREACH : EHOSTDOWN;
    867 
    868 	if (renew) {
    869 		const u_int8_t *enaddr =
    870 		    CLLADDR(ifp->if_sadl);
    871 		la->la_expire = time_uptime;
    872 		arp_settimer(la, arpt_down);
    873 		la->la_asked++;
    874 		LLE_WUNLOCK(la);
    875 
    876 		if (rt != NULL) {
    877 			arprequest(origifp,
    878 			    &satocsin(rt->rt_ifa->ifa_addr)->sin_addr,
    879 			    &satocsin(dst)->sin_addr, enaddr);
    880 		} else {
    881 			struct sockaddr_in sin;
    882 			struct rtentry *_rt;
    883 
    884 			sockaddr_in_init(&sin, &la->r_l3addr.addr4, 0);
    885 
    886 			/* XXX */
    887 			_rt = rtalloc1((struct sockaddr *)&sin, 0);
    888 			if (_rt == NULL)
    889 				goto bad;
    890 			arprequest(origifp,
    891 			    &satocsin(_rt->rt_ifa->ifa_addr)->sin_addr,
    892 			    &satocsin(dst)->sin_addr, enaddr);
    893 			rt_unref(_rt);
    894 		}
    895 		return error;
    896 	}
    897 
    898 	LLE_RUNLOCK(la);
    899 	return error;
    900 
    901 bad:
    902 	m_freem(m);
    903 	return error;
    904 }
    905 
    906 /*
    907  * Common length and type checks are done here,
    908  * then the protocol-specific routine is called.
    909  */
    910 void
    911 arpintr(void)
    912 {
    913 	struct mbuf *m;
    914 	struct arphdr *ar;
    915 	int s;
    916 	int arplen;
    917 
    918 #ifndef NET_MPSAFE
    919 	mutex_enter(softnet_lock);
    920 	KERNEL_LOCK(1, NULL);
    921 #endif
    922 	for (;;) {
    923 		struct ifnet *rcvif;
    924 
    925 		IFQ_LOCK(&arpintrq);
    926 		IF_DEQUEUE(&arpintrq, m);
    927 		IFQ_UNLOCK(&arpintrq);
    928 		if (m == NULL)
    929 			goto out;
    930 		if ((m->m_flags & M_PKTHDR) == 0)
    931 			panic("arpintr");
    932 
    933 		MCLAIM(m, &arpdomain.dom_mowner);
    934 		ARP_STATINC(ARP_STAT_RCVTOTAL);
    935 
    936 		/*
    937 		 * First, make sure we have at least struct arphdr.
    938 		 */
    939 		if (m->m_len < sizeof(struct arphdr) ||
    940 		    (ar = mtod(m, struct arphdr *)) == NULL)
    941 			goto badlen;
    942 
    943 		rcvif = m_get_rcvif(m, &s);
    944 		if (__predict_false(rcvif == NULL)) {
    945 			ARP_STATINC(ARP_STAT_RCVNOINT);
    946 			goto free;
    947 		}
    948 		switch (rcvif->if_type) {
    949 		case IFT_IEEE1394:
    950 			arplen = sizeof(struct arphdr) +
    951 			    ar->ar_hln + 2 * ar->ar_pln;
    952 			break;
    953 		default:
    954 			arplen = sizeof(struct arphdr) +
    955 			    2 * ar->ar_hln + 2 * ar->ar_pln;
    956 			break;
    957 		}
    958 		m_put_rcvif(rcvif, &s);
    959 
    960 		if (/* XXX ntohs(ar->ar_hrd) == ARPHRD_ETHER && */
    961 		    m->m_len >= arplen)
    962 			switch (ntohs(ar->ar_pro)) {
    963 			case ETHERTYPE_IP:
    964 			case ETHERTYPE_IPTRAILERS:
    965 				in_arpinput(m);
    966 				continue;
    967 			default:
    968 				ARP_STATINC(ARP_STAT_RCVBADPROTO);
    969 			}
    970 		else {
    971 badlen:
    972 			ARP_STATINC(ARP_STAT_RCVBADLEN);
    973 		}
    974 free:
    975 		m_freem(m);
    976 	}
    977 out:
    978 #ifndef NET_MPSAFE
    979 	KERNEL_UNLOCK_ONE(NULL);
    980 	mutex_exit(softnet_lock);
    981 #else
    982 	return; /* XXX gcc */
    983 #endif
    984 }
    985 
    986 /*
    987  * ARP for Internet protocols on 10 Mb/s Ethernet. Algorithm is that given in
    988  * RFC 826. In addition, a sanity check is performed on the sender protocol
    989  * address, to catch impersonators.
    990  *
    991  * We no longer handle negotiations for use of trailer protocol: formerly, ARP
    992  * replied for protocol type ETHERTYPE_TRAIL sent along with IP replies if we
    993  * wanted trailers sent to us, and also sent them in response to IP replies.
    994  * This allowed either end to announce the desire to receive trailer packets.
    995  *
    996  * We no longer reply to requests for ETHERTYPE_TRAIL protocol either, but
    997  * formerly didn't normally send requests.
    998  */
    999 static void
   1000 in_arpinput(struct mbuf *m)
   1001 {
   1002 	struct arphdr *ah;
   1003 	struct ifnet *ifp, *rcvif = NULL;
   1004 	struct llentry *la = NULL;
   1005 	struct in_ifaddr *ia = NULL;
   1006 #if NBRIDGE > 0
   1007 	struct in_ifaddr *bridge_ia = NULL;
   1008 #endif
   1009 #if NCARP > 0
   1010 	u_int32_t count = 0, index = 0;
   1011 #endif
   1012 	struct sockaddr sa;
   1013 	struct in_addr isaddr, itaddr, myaddr;
   1014 	int op;
   1015 	void *tha;
   1016 	uint64_t *arps;
   1017 	struct psref psref, psref_ia;
   1018 	int s;
   1019 	char llabuf[LLA_ADDRSTRLEN];
   1020 	char ipbuf[INET_ADDRSTRLEN];
   1021 	bool do_dad;
   1022 
   1023 	if (__predict_false(m_makewritable(&m, 0, m->m_pkthdr.len, M_DONTWAIT)))
   1024 		goto out;
   1025 	ah = mtod(m, struct arphdr *);
   1026 	op = ntohs(ah->ar_op);
   1027 
   1028 	if (ah->ar_pln != sizeof(struct in_addr))
   1029 		goto out;
   1030 
   1031 	ifp = if_get_bylla(ar_sha(ah), ah->ar_hln, &psref);
   1032 	if (ifp) {
   1033 		if_put(ifp, &psref);
   1034 		ARP_STATINC(ARP_STAT_RCVLOCALSHA);
   1035 		goto out;	/* it's from me, ignore it. */
   1036 	}
   1037 
   1038 	rcvif = ifp = m_get_rcvif_psref(m, &psref);
   1039 	if (__predict_false(rcvif == NULL))
   1040 		goto drop;
   1041 
   1042 	/*
   1043 	 * Fix up ah->ar_hrd if necessary, before using ar_tha() or ar_tpa().
   1044 	 * XXX check ar_hrd more strictly?
   1045 	 */
   1046 	switch (ifp->if_type) {
   1047 	case IFT_IEEE1394:
   1048 		if (ntohs(ah->ar_hrd) == ARPHRD_IEEE1394)
   1049 			;
   1050 		else {
   1051 			/* XXX this is to make sure we compute ar_tha right */
   1052 			ah->ar_hrd = htons(ARPHRD_IEEE1394);
   1053 		}
   1054 		break;
   1055 	default:
   1056 		break;
   1057 	}
   1058 
   1059 	memcpy(&isaddr, ar_spa(ah), sizeof(isaddr));
   1060 	memcpy(&itaddr, ar_tpa(ah), sizeof(itaddr));
   1061 
   1062 	if (m->m_flags & (M_BCAST|M_MCAST))
   1063 		ARP_STATINC(ARP_STAT_RCVMCAST);
   1064 
   1065 	/*
   1066 	 * Search for a matching interface address
   1067 	 * or any address on the interface to use
   1068 	 * as a dummy address in the rest of this function.
   1069 	 *
   1070 	 * If the target IP address is zero then try and find
   1071 	 * the sender address for DAD.
   1072 	 */
   1073 	myaddr = in_nullhost(itaddr) ? isaddr : itaddr;
   1074 	s = pserialize_read_enter();
   1075 	IN_ADDRHASH_READER_FOREACH(ia, myaddr.s_addr) {
   1076 		if (!in_hosteq(ia->ia_addr.sin_addr, myaddr))
   1077 			continue;
   1078 #if NCARP > 0
   1079 		if (ia->ia_ifp->if_type == IFT_CARP &&
   1080 		    ((ia->ia_ifp->if_flags & (IFF_UP|IFF_RUNNING)) ==
   1081 		    (IFF_UP|IFF_RUNNING))) {
   1082 			index++;
   1083 			/* XXX: ar_hln? */
   1084 			if (ia->ia_ifp == rcvif && (ah->ar_hln >= 6) &&
   1085 			    carp_iamatch(ia, ar_sha(ah),
   1086 			    &count, index)) {
   1087 				break;
   1088 			}
   1089 		} else
   1090 #endif
   1091 		if (ia->ia_ifp == rcvif)
   1092 			break;
   1093 #if NBRIDGE > 0
   1094 		/*
   1095 		 * If the interface we received the packet on
   1096 		 * is part of a bridge, check to see if we need
   1097 		 * to "bridge" the packet to ourselves at this
   1098 		 * layer.  Note we still prefer a perfect match,
   1099 		 * but allow this weaker match if necessary.
   1100 		 */
   1101 		if (rcvif->if_bridge != NULL &&
   1102 		    rcvif->if_bridge == ia->ia_ifp->if_bridge)
   1103 			bridge_ia = ia;
   1104 #endif /* NBRIDGE > 0 */
   1105 	}
   1106 
   1107 #if NBRIDGE > 0
   1108 	if (ia == NULL && bridge_ia != NULL) {
   1109 		ia = bridge_ia;
   1110 		m_put_rcvif_psref(rcvif, &psref);
   1111 		rcvif = NULL;
   1112 		/* FIXME */
   1113 		ifp = bridge_ia->ia_ifp;
   1114 	}
   1115 #endif
   1116 	if (ia != NULL)
   1117 		ia4_acquire(ia, &psref_ia);
   1118 	pserialize_read_exit(s);
   1119 
   1120 	if (ah->ar_hln != ifp->if_addrlen) {
   1121 		ARP_STATINC(ARP_STAT_RCVBADLEN);
   1122 		log(LOG_WARNING,
   1123 		    "arp from %s: addr len: new %d, i/f %d (ignored)\n",
   1124 		    IN_PRINT(ipbuf, &isaddr), ah->ar_hln, ifp->if_addrlen);
   1125 		goto out;
   1126 	}
   1127 
   1128 	/* Only do DaD if we have a matching address. */
   1129 	do_dad = (ia != NULL);
   1130 
   1131 	if (ia == NULL) {
   1132 		ia = in_get_ia_on_iface_psref(isaddr, rcvif, &psref_ia);
   1133 		if (ia == NULL) {
   1134 			ia = in_get_ia_from_ifp_psref(ifp, &psref_ia);
   1135 			if (ia == NULL) {
   1136 				ARP_STATINC(ARP_STAT_RCVNOINT);
   1137 				goto out;
   1138 			}
   1139 		}
   1140 	}
   1141 
   1142 	myaddr = ia->ia_addr.sin_addr;
   1143 
   1144 	/* XXX checks for bridge case? */
   1145 	if (!memcmp(ar_sha(ah), ifp->if_broadcastaddr, ifp->if_addrlen)) {
   1146 		ARP_STATINC(ARP_STAT_RCVBCASTSHA);
   1147 		log(LOG_ERR,
   1148 		    "%s: arp: link address is broadcast for IP address %s!\n",
   1149 		    ifp->if_xname, IN_PRINT(ipbuf, &isaddr));
   1150 		goto out;
   1151 	}
   1152 
   1153 	/*
   1154 	 * If the source IP address is zero, this is an RFC 5227 ARP probe
   1155 	 */
   1156 	if (in_nullhost(isaddr))
   1157 		ARP_STATINC(ARP_STAT_RCVZEROSPA);
   1158 	else if (in_hosteq(isaddr, myaddr))
   1159 		ARP_STATINC(ARP_STAT_RCVLOCALSPA);
   1160 
   1161 	if (in_nullhost(itaddr))
   1162 		ARP_STATINC(ARP_STAT_RCVZEROTPA);
   1163 
   1164 	/*
   1165 	 * DAD check, RFC 5227.
   1166 	 * Collision on sender address is always a duplicate.
   1167 	 * Collision on target address is only a duplicate IF
   1168 	 * the sender address is the null host (ie a DAD probe) AND
   1169 	 * our address is in the TENTATIVE state.
   1170 	 * DUPLICATED state is also checked so that processing stops here
   1171 	 * and an error can be logged.
   1172 	 */
   1173 	if (do_dad &&
   1174 	    (in_hosteq(isaddr, myaddr) ||
   1175 	    (in_nullhost(isaddr) && in_hosteq(itaddr, myaddr)
   1176 	    && ia->ia4_flags & (IN_IFF_TENTATIVE | IN_IFF_DUPLICATED))))
   1177 	{
   1178 		arp_dad_duplicated((struct ifaddr *)ia,
   1179 		    lla_snprintf(llabuf, ar_sha(ah), ah->ar_hln));
   1180 		goto out;
   1181 	}
   1182 
   1183 	/*
   1184 	 * If the target IP address is zero, ignore the packet.
   1185 	 * This prevents the code below from trying to answer
   1186 	 * when we are using IP address zero (booting).
   1187 	 */
   1188 	if (in_nullhost(itaddr))
   1189 		goto out;
   1190 
   1191 	if (in_nullhost(isaddr))
   1192 		goto reply;
   1193 
   1194 	if (in_hosteq(itaddr, myaddr))
   1195 		la = arpcreate(ifp, m, &isaddr, NULL, 1);
   1196 	else
   1197 		la = arplookup(ifp, m, &isaddr, NULL, 1);
   1198 	if (la == NULL)
   1199 		goto reply;
   1200 
   1201 	if ((la->la_flags & LLE_VALID) &&
   1202 	    memcmp(ar_sha(ah), &la->ll_addr, ifp->if_addrlen)) {
   1203 		if (la->la_flags & LLE_STATIC) {
   1204 			ARP_STATINC(ARP_STAT_RCVOVERPERM);
   1205 			if (!log_permanent_modify)
   1206 				goto out;
   1207 			log(LOG_INFO,
   1208 			    "%s tried to overwrite permanent arp info"
   1209 			    " for %s\n",
   1210 			    lla_snprintf(llabuf, ar_sha(ah), ah->ar_hln),
   1211 			    IN_PRINT(ipbuf, &isaddr));
   1212 			goto out;
   1213 		} else if (la->lle_tbl->llt_ifp != ifp) {
   1214 			/* XXX should not happen? */
   1215 			ARP_STATINC(ARP_STAT_RCVOVERINT);
   1216 			if (!log_wrong_iface)
   1217 				goto out;
   1218 			log(LOG_INFO,
   1219 			    "%s on %s tried to overwrite "
   1220 			    "arp info for %s on %s\n",
   1221 			    lla_snprintf(llabuf, ar_sha(ah), ah->ar_hln),
   1222 			    ifp->if_xname, IN_PRINT(ipbuf, &isaddr),
   1223 			    la->lle_tbl->llt_ifp->if_xname);
   1224 				goto out;
   1225 		} else {
   1226 			ARP_STATINC(ARP_STAT_RCVOVER);
   1227 			if (log_movements)
   1228 				log(LOG_INFO, "arp info overwritten "
   1229 				    "for %s by %s\n",
   1230 				    IN_PRINT(ipbuf, &isaddr),
   1231 				    lla_snprintf(llabuf, ar_sha(ah),
   1232 				    ah->ar_hln));
   1233 		}
   1234 	}
   1235 
   1236 	/* XXX llentry should have addrlen? */
   1237 #if 0
   1238 	/*
   1239 	 * sanity check for the address length.
   1240 	 * XXX this does not work for protocols with variable address
   1241 	 * length. -is
   1242 	 */
   1243 	if (sdl->sdl_alen && sdl->sdl_alen != ah->ar_hln) {
   1244 		ARP_STATINC(ARP_STAT_RCVLENCHG);
   1245 		log(LOG_WARNING,
   1246 		    "arp from %s: new addr len %d, was %d\n",
   1247 		    IN_PRINT(ipbuf, &isaddr), ah->ar_hln, sdl->sdl_alen);
   1248 	}
   1249 #endif
   1250 
   1251 #if NTOKEN > 0
   1252 	/*
   1253 	 * XXX uses m_data and assumes the complete answer including
   1254 	 * XXX token-ring headers is in the same buf
   1255 	 */
   1256 	if (ifp->if_type == IFT_ISO88025) {
   1257 		struct token_header *trh;
   1258 
   1259 		trh = (struct token_header *)M_TRHSTART(m);
   1260 		if (trh->token_shost[0] & TOKEN_RI_PRESENT) {
   1261 			struct token_rif *rif;
   1262 			size_t riflen;
   1263 
   1264 			rif = TOKEN_RIF(trh);
   1265 			riflen = (ntohs(rif->tr_rcf) &
   1266 			    TOKEN_RCF_LEN_MASK) >> 8;
   1267 
   1268 			if (riflen > 2 &&
   1269 			    riflen < sizeof(struct token_rif) &&
   1270 			    (riflen & 1) == 0) {
   1271 				rif->tr_rcf ^= htons(TOKEN_RCF_DIRECTION);
   1272 				rif->tr_rcf &= htons(~TOKEN_RCF_BROADCAST_MASK);
   1273 				memcpy(TOKEN_RIF_LLE(la), rif, riflen);
   1274 			}
   1275 		}
   1276 	}
   1277 #endif /* NTOKEN > 0 */
   1278 
   1279 	KASSERT(sizeof(la->ll_addr) >= ifp->if_addrlen);
   1280 	memcpy(&la->ll_addr, ar_sha(ah), ifp->if_addrlen);
   1281 	la->la_flags |= LLE_VALID;
   1282 	if ((la->la_flags & LLE_STATIC) == 0) {
   1283 		la->la_expire = time_uptime + arpt_keep;
   1284 		arp_settimer(la, arpt_keep);
   1285 	}
   1286 	la->la_asked = 0;
   1287 	/* rt->rt_flags &= ~RTF_REJECT; */
   1288 
   1289 	if (la->la_hold != NULL) {
   1290 		int n = la->la_numheld;
   1291 		struct mbuf *m_hold, *m_hold_next;
   1292 		struct sockaddr_in sin;
   1293 
   1294 		sockaddr_in_init(&sin, &la->r_l3addr.addr4, 0);
   1295 
   1296 		m_hold = la->la_hold;
   1297 		la->la_hold = NULL;
   1298 		la->la_numheld = 0;
   1299 		/*
   1300 		 * We have to unlock here because if_output would call
   1301 		 * arpresolve
   1302 		 */
   1303 		LLE_WUNLOCK(la);
   1304 		ARP_STATADD(ARP_STAT_DFRSENT, n);
   1305 		ARP_STATADD(ARP_STAT_DFRTOTAL, n);
   1306 		for (; m_hold != NULL; m_hold = m_hold_next) {
   1307 			m_hold_next = m_hold->m_nextpkt;
   1308 			m_hold->m_nextpkt = NULL;
   1309 			if_output_lock(ifp, ifp, m_hold, sintosa(&sin), NULL);
   1310 		}
   1311 	} else
   1312 		LLE_WUNLOCK(la);
   1313 	la = NULL;
   1314 
   1315 reply:
   1316 	if (la != NULL) {
   1317 		LLE_WUNLOCK(la);
   1318 		la = NULL;
   1319 	}
   1320 	if (op != ARPOP_REQUEST) {
   1321 		if (op == ARPOP_REPLY)
   1322 			ARP_STATINC(ARP_STAT_RCVREPLY);
   1323 		goto out;
   1324 	}
   1325 	ARP_STATINC(ARP_STAT_RCVREQUEST);
   1326 	if (in_hosteq(itaddr, myaddr)) {
   1327 		/* If our address is unusable, don't reply */
   1328 		if (ia->ia4_flags & (IN_IFF_NOTREADY | IN_IFF_DETACHED))
   1329 			goto out;
   1330 		/* I am the target */
   1331 		tha = ar_tha(ah);
   1332 		if (tha)
   1333 			memcpy(tha, ar_sha(ah), ah->ar_hln);
   1334 		memcpy(ar_sha(ah), CLLADDR(ifp->if_sadl), ah->ar_hln);
   1335 	} else {
   1336 		/* Proxy ARP */
   1337 		struct llentry *lle = NULL;
   1338 		struct sockaddr_in sin;
   1339 #if NCARP > 0
   1340 		if (ifp->if_type == IFT_CARP) {
   1341 			struct ifnet *_rcvif = m_get_rcvif(m, &s);
   1342 			int iftype = 0;
   1343 			if (__predict_true(_rcvif != NULL))
   1344 				iftype = _rcvif->if_type;
   1345 			m_put_rcvif(_rcvif, &s);
   1346 			if (iftype != IFT_CARP)
   1347 				goto out;
   1348 		}
   1349 #endif
   1350 
   1351 		tha = ar_tha(ah);
   1352 
   1353 		sockaddr_in_init(&sin, &itaddr, 0);
   1354 
   1355 		IF_AFDATA_RLOCK(ifp);
   1356 		lle = lla_lookup(LLTABLE(ifp), 0, (struct sockaddr *)&sin);
   1357 		IF_AFDATA_RUNLOCK(ifp);
   1358 
   1359 		if ((lle != NULL) && (lle->la_flags & LLE_PUB)) {
   1360 			if (tha)
   1361 				memcpy(tha, ar_sha(ah), ah->ar_hln);
   1362 			memcpy(ar_sha(ah), &lle->ll_addr, ah->ar_hln);
   1363 			LLE_RUNLOCK(lle);
   1364 		} else {
   1365 			if (lle != NULL)
   1366 				LLE_RUNLOCK(lle);
   1367 			goto drop;
   1368 		}
   1369 	}
   1370 	ia4_release(ia, &psref_ia);
   1371 
   1372 	memcpy(ar_tpa(ah), ar_spa(ah), ah->ar_pln);
   1373 	memcpy(ar_spa(ah), &itaddr, ah->ar_pln);
   1374 	ah->ar_op = htons(ARPOP_REPLY);
   1375 	ah->ar_pro = htons(ETHERTYPE_IP); /* let's be sure! */
   1376 	switch (ifp->if_type) {
   1377 	case IFT_IEEE1394:
   1378 		/*
   1379 		 * ieee1394 arp reply is broadcast
   1380 		 */
   1381 		m->m_flags &= ~M_MCAST;
   1382 		m->m_flags |= M_BCAST;
   1383 		m->m_len = sizeof(*ah) + (2 * ah->ar_pln) + ah->ar_hln;
   1384 		break;
   1385 	default:
   1386 		m->m_flags &= ~(M_BCAST|M_MCAST); /* never reply by broadcast */
   1387 		m->m_len = sizeof(*ah) + (2 * ah->ar_pln) + (2 * ah->ar_hln);
   1388 		break;
   1389 	}
   1390 	m->m_pkthdr.len = m->m_len;
   1391 	sa.sa_family = AF_ARP;
   1392 	sa.sa_len = 2;
   1393 	arps = ARP_STAT_GETREF();
   1394 	arps[ARP_STAT_SNDTOTAL]++;
   1395 	arps[ARP_STAT_SNDREPLY]++;
   1396 	ARP_STAT_PUTREF();
   1397 	if_output_lock(ifp, ifp, m, &sa, NULL);
   1398 	if (rcvif != NULL)
   1399 		m_put_rcvif_psref(rcvif, &psref);
   1400 	return;
   1401 
   1402 out:
   1403 	if (la != NULL)
   1404 		LLE_WUNLOCK(la);
   1405 drop:
   1406 	if (ia != NULL)
   1407 		ia4_release(ia, &psref_ia);
   1408 	if (rcvif != NULL)
   1409 		m_put_rcvif_psref(rcvif, &psref);
   1410 	m_freem(m);
   1411 }
   1412 
   1413 /*
   1414  * Lookup or a new address in arptab.
   1415  */
   1416 static struct llentry *
   1417 arplookup(struct ifnet *ifp, struct mbuf *m, const struct in_addr *addr,
   1418     const struct sockaddr *sa, int wlock)
   1419 {
   1420 	struct sockaddr_in sin;
   1421 	struct llentry *la;
   1422 	int flags = wlock ? LLE_EXCLUSIVE : 0;
   1423 
   1424 
   1425 	if (sa == NULL) {
   1426 		KASSERT(addr != NULL);
   1427 		sockaddr_in_init(&sin, addr, 0);
   1428 		sa = sintocsa(&sin);
   1429 	}
   1430 
   1431 	IF_AFDATA_RLOCK(ifp);
   1432 	la = lla_lookup(LLTABLE(ifp), flags, sa);
   1433 	IF_AFDATA_RUNLOCK(ifp);
   1434 
   1435 	return la;
   1436 }
   1437 
   1438 static struct llentry *
   1439 arpcreate(struct ifnet *ifp, struct mbuf *m, const struct in_addr *addr,
   1440     const struct sockaddr *sa, int wlock)
   1441 {
   1442 	struct sockaddr_in sin;
   1443 	struct llentry *la;
   1444 	int flags = wlock ? LLE_EXCLUSIVE : 0;
   1445 
   1446 	if (sa == NULL) {
   1447 		KASSERT(addr != NULL);
   1448 		sockaddr_in_init(&sin, addr, 0);
   1449 		sa = sintocsa(&sin);
   1450 	}
   1451 
   1452 	la = arplookup(ifp, m, addr, sa, wlock);
   1453 
   1454 	if (la == NULL) {
   1455 		IF_AFDATA_WLOCK(ifp);
   1456 		la = lla_create(LLTABLE(ifp), flags, sa);
   1457 		IF_AFDATA_WUNLOCK(ifp);
   1458 
   1459 		if (la != NULL)
   1460 			arp_init_llentry(ifp, la);
   1461 	}
   1462 
   1463 	return la;
   1464 }
   1465 
   1466 int
   1467 arpioctl(u_long cmd, void *data)
   1468 {
   1469 
   1470 	return EOPNOTSUPP;
   1471 }
   1472 
   1473 void
   1474 arp_ifinit(struct ifnet *ifp, struct ifaddr *ifa)
   1475 {
   1476 	struct in_ifaddr *ia = (struct in_ifaddr *)ifa;
   1477 
   1478 	ifa->ifa_rtrequest = arp_rtrequest;
   1479 	ifa->ifa_flags |= RTF_CONNECTED;
   1480 
   1481 	/* ARP will handle DAD for this address. */
   1482 	if (in_nullhost(IA_SIN(ifa)->sin_addr)) {
   1483 		if (ia->ia_dad_stop != NULL)	/* safety */
   1484 			ia->ia_dad_stop(ifa);
   1485 		ia->ia_dad_start = NULL;
   1486 		ia->ia_dad_stop = NULL;
   1487 		ia->ia4_flags &= ~IN_IFF_TENTATIVE;
   1488 	} else {
   1489 		ia->ia_dad_start = arp_dad_start;
   1490 		ia->ia_dad_stop = arp_dad_stop;
   1491 		if (ia->ia4_flags & IN_IFF_TRYTENTATIVE && ip_dad_count > 0)
   1492 			ia->ia4_flags |= IN_IFF_TENTATIVE;
   1493 		else
   1494 			arpannounce1(ifa);
   1495 	}
   1496 }
   1497 
   1498 TAILQ_HEAD(dadq_head, dadq);
   1499 struct dadq {
   1500 	TAILQ_ENTRY(dadq) dad_list;
   1501 	struct ifaddr *dad_ifa;
   1502 	int dad_count;		/* max ARP to send */
   1503 	int dad_arp_tcount;	/* # of trials to send ARP */
   1504 	int dad_arp_ocount;	/* ARP sent so far */
   1505 	int dad_arp_announce;	/* max ARP announcements */
   1506 	int dad_arp_acount;	/* # of announcements */
   1507 	struct callout dad_timer_ch;
   1508 };
   1509 
   1510 static struct dadq_head dadq;
   1511 static int dad_init = 0;
   1512 static int dad_maxtry = 15;     /* max # of *tries* to transmit DAD packet */
   1513 static kmutex_t arp_dad_lock;
   1514 
   1515 static struct dadq *
   1516 arp_dad_find(struct ifaddr *ifa)
   1517 {
   1518 	struct dadq *dp;
   1519 
   1520 	KASSERT(mutex_owned(&arp_dad_lock));
   1521 
   1522 	TAILQ_FOREACH(dp, &dadq, dad_list) {
   1523 		if (dp->dad_ifa == ifa)
   1524 			return dp;
   1525 	}
   1526 	return NULL;
   1527 }
   1528 
   1529 static void
   1530 arp_dad_starttimer(struct dadq *dp, int ticks)
   1531 {
   1532 
   1533 	callout_reset(&dp->dad_timer_ch, ticks,
   1534 	    (void (*)(void *))arp_dad_timer, (void *)dp->dad_ifa);
   1535 }
   1536 
   1537 static void
   1538 arp_dad_stoptimer(struct dadq *dp)
   1539 {
   1540 
   1541 #ifdef NET_MPSAFE
   1542 	callout_halt(&dp->dad_timer_ch, NULL);
   1543 #else
   1544 	callout_halt(&dp->dad_timer_ch, softnet_lock);
   1545 #endif
   1546 }
   1547 
   1548 static void
   1549 arp_dad_output(struct dadq *dp, struct ifaddr *ifa)
   1550 {
   1551 	struct in_ifaddr *ia = (struct in_ifaddr *)ifa;
   1552 	struct ifnet *ifp = ifa->ifa_ifp;
   1553 	struct in_addr sip;
   1554 
   1555 	dp->dad_arp_tcount++;
   1556 	if ((ifp->if_flags & IFF_UP) == 0)
   1557 		return;
   1558 	if ((ifp->if_flags & IFF_RUNNING) == 0)
   1559 		return;
   1560 
   1561 	dp->dad_arp_tcount = 0;
   1562 	dp->dad_arp_ocount++;
   1563 
   1564 	memset(&sip, 0, sizeof(sip));
   1565 	arprequest(ifa->ifa_ifp, &sip, &ia->ia_addr.sin_addr,
   1566 	    CLLADDR(ifa->ifa_ifp->if_sadl));
   1567 }
   1568 
   1569 /*
   1570  * Start Duplicate Address Detection (DAD) for specified interface address.
   1571  */
   1572 static void
   1573 arp_dad_start(struct ifaddr *ifa)
   1574 {
   1575 	struct in_ifaddr *ia = (struct in_ifaddr *)ifa;
   1576 	struct dadq *dp;
   1577 	char ipbuf[INET_ADDRSTRLEN];
   1578 
   1579 	if (!dad_init) {
   1580 		TAILQ_INIT(&dadq);
   1581 		mutex_init(&arp_dad_lock, MUTEX_DEFAULT, IPL_NONE);
   1582 		dad_init++;
   1583 	}
   1584 
   1585 	/*
   1586 	 * If we don't need DAD, don't do it.
   1587 	 * - DAD is disabled (ip_dad_count == 0)
   1588 	 */
   1589 	if (!(ia->ia4_flags & IN_IFF_TENTATIVE)) {
   1590 		log(LOG_DEBUG,
   1591 		    "%s: called with non-tentative address %s(%s)\n", __func__,
   1592 		    IN_PRINT(ipbuf, &ia->ia_addr.sin_addr),
   1593 		    ifa->ifa_ifp ? if_name(ifa->ifa_ifp) : "???");
   1594 		return;
   1595 	}
   1596 	if (!ip_dad_count) {
   1597 		ia->ia4_flags &= ~IN_IFF_TENTATIVE;
   1598 		rt_newaddrmsg(RTM_NEWADDR, ifa, 0, NULL);
   1599 		arpannounce1(ifa);
   1600 		return;
   1601 	}
   1602 	KASSERT(ifa->ifa_ifp != NULL);
   1603 	if (!(ifa->ifa_ifp->if_flags & IFF_UP))
   1604 		return;
   1605 
   1606 	dp = kmem_intr_alloc(sizeof(*dp), KM_NOSLEEP);
   1607 
   1608 	mutex_enter(&arp_dad_lock);
   1609 	if (arp_dad_find(ifa) != NULL) {
   1610 		mutex_exit(&arp_dad_lock);
   1611 		/* DAD already in progress */
   1612 		if (dp != NULL)
   1613 			kmem_intr_free(dp, sizeof(*dp));
   1614 		return;
   1615 	}
   1616 
   1617 	if (dp == NULL) {
   1618 		mutex_exit(&arp_dad_lock);
   1619 		log(LOG_ERR, "%s: memory allocation failed for %s(%s)\n",
   1620 		    __func__, IN_PRINT(ipbuf, &ia->ia_addr.sin_addr),
   1621 		    ifa->ifa_ifp ? if_name(ifa->ifa_ifp) : "???");
   1622 		return;
   1623 	}
   1624 
   1625 	/*
   1626 	 * Send ARP packet for DAD, ip_dad_count times.
   1627 	 * Note that we must delay the first transmission.
   1628 	 */
   1629 	callout_init(&dp->dad_timer_ch, CALLOUT_MPSAFE);
   1630 	dp->dad_ifa = ifa;
   1631 	ifaref(ifa);	/* just for safety */
   1632 	dp->dad_count = ip_dad_count;
   1633 	dp->dad_arp_announce = 0; /* Will be set when starting to announce */
   1634 	dp->dad_arp_acount = dp->dad_arp_ocount = dp->dad_arp_tcount = 0;
   1635 	TAILQ_INSERT_TAIL(&dadq, (struct dadq *)dp, dad_list);
   1636 
   1637 	ARPLOG(LOG_DEBUG, "%s: starting DAD for %s\n", if_name(ifa->ifa_ifp),
   1638 	    ARPLOGADDR(&ia->ia_addr.sin_addr));
   1639 
   1640 	arp_dad_starttimer(dp, cprng_fast32() % (PROBE_WAIT * hz));
   1641 
   1642 	mutex_exit(&arp_dad_lock);
   1643 }
   1644 
   1645 /*
   1646  * terminate DAD unconditionally.  used for address removals.
   1647  */
   1648 static void
   1649 arp_dad_stop(struct ifaddr *ifa)
   1650 {
   1651 	struct dadq *dp;
   1652 
   1653 	if (!dad_init)
   1654 		return;
   1655 
   1656 	mutex_enter(&arp_dad_lock);
   1657 	dp = arp_dad_find(ifa);
   1658 	if (dp == NULL) {
   1659 		mutex_exit(&arp_dad_lock);
   1660 		/* DAD wasn't started yet */
   1661 		return;
   1662 	}
   1663 
   1664 	/* Prevent the timer from running anymore. */
   1665 	TAILQ_REMOVE(&dadq, dp, dad_list);
   1666 	mutex_exit(&arp_dad_lock);
   1667 
   1668 	arp_dad_stoptimer(dp);
   1669 
   1670 	kmem_intr_free(dp, sizeof(*dp));
   1671 	ifafree(ifa);
   1672 }
   1673 
   1674 static void
   1675 arp_dad_timer(struct ifaddr *ifa)
   1676 {
   1677 	struct in_ifaddr *ia = (struct in_ifaddr *)ifa;
   1678 	struct dadq *dp;
   1679 	char ipbuf[INET_ADDRSTRLEN];
   1680 	bool need_free = false;
   1681 
   1682 #ifndef NET_MPSAFE
   1683 	mutex_enter(softnet_lock);
   1684 	KERNEL_LOCK(1, NULL);
   1685 #endif
   1686 	mutex_enter(&arp_dad_lock);
   1687 
   1688 	/* Sanity check */
   1689 	if (ia == NULL) {
   1690 		log(LOG_ERR, "%s: called with null parameter\n", __func__);
   1691 		goto done;
   1692 	}
   1693 	dp = arp_dad_find(ifa);
   1694 	if (dp == NULL) {
   1695 		/* DAD seems to be stopping, so do nothing. */
   1696 		goto done;
   1697 	}
   1698 	if (ia->ia4_flags & IN_IFF_DUPLICATED) {
   1699 		log(LOG_ERR, "%s: called with duplicate address %s(%s)\n",
   1700 		    __func__, IN_PRINT(ipbuf, &ia->ia_addr.sin_addr),
   1701 		    ifa->ifa_ifp ? if_name(ifa->ifa_ifp) : "???");
   1702 		goto done;
   1703 	}
   1704 	if ((ia->ia4_flags & IN_IFF_TENTATIVE) == 0 && dp->dad_arp_acount == 0)
   1705 	{
   1706 		log(LOG_ERR, "%s: called with non-tentative address %s(%s)\n",
   1707 		    __func__, IN_PRINT(ipbuf, &ia->ia_addr.sin_addr),
   1708 		    ifa->ifa_ifp ? if_name(ifa->ifa_ifp) : "???");
   1709 		goto done;
   1710 	}
   1711 
   1712 	/* timeouted with IFF_{RUNNING,UP} check */
   1713 	if (dp->dad_arp_tcount > dad_maxtry) {
   1714 		ARPLOG(LOG_INFO, "%s: could not run DAD, driver problem?\n",
   1715 		    if_name(ifa->ifa_ifp));
   1716 
   1717 		TAILQ_REMOVE(&dadq, dp, dad_list);
   1718 		need_free = true;
   1719 		goto done;
   1720 	}
   1721 
   1722 	/* Need more checks? */
   1723 	if (dp->dad_arp_ocount < dp->dad_count) {
   1724 		int adelay;
   1725 
   1726 		/*
   1727 		 * We have more ARP to go.  Send ARP packet for DAD.
   1728 		 */
   1729 		arp_dad_output(dp, ifa);
   1730 		if (dp->dad_arp_ocount < dp->dad_count)
   1731 			adelay = (PROBE_MIN * hz) +
   1732 			    (cprng_fast32() %
   1733 			    ((PROBE_MAX * hz) - (PROBE_MIN * hz)));
   1734 		else
   1735 			adelay = ANNOUNCE_WAIT * hz;
   1736 		arp_dad_starttimer(dp, adelay);
   1737 		goto done;
   1738 	} else if (dp->dad_arp_acount == 0) {
   1739 		/*
   1740 		 * We are done with DAD.
   1741 		 * No duplicate address found.
   1742 		 */
   1743 		ia->ia4_flags &= ~IN_IFF_TENTATIVE;
   1744 		rt_newaddrmsg(RTM_NEWADDR, ifa, 0, NULL);
   1745 		ARPLOG(LOG_DEBUG,
   1746 		    "%s: DAD complete for %s - no duplicates found\n",
   1747 		    if_name(ifa->ifa_ifp), ARPLOGADDR(&ia->ia_addr.sin_addr));
   1748 		dp->dad_arp_announce = ANNOUNCE_NUM;
   1749 		goto announce;
   1750 	} else if (dp->dad_arp_acount < dp->dad_arp_announce) {
   1751 announce:
   1752 		/*
   1753 		 * Announce the address.
   1754 		 */
   1755 		arpannounce1(ifa);
   1756 		dp->dad_arp_acount++;
   1757 		if (dp->dad_arp_acount < dp->dad_arp_announce) {
   1758 			arp_dad_starttimer(dp, ANNOUNCE_INTERVAL * hz);
   1759 			goto done;
   1760 		}
   1761 		ARPLOG(LOG_DEBUG,
   1762 		    "%s: ARP announcement complete for %s\n",
   1763 		    if_name(ifa->ifa_ifp), ARPLOGADDR(&ia->ia_addr.sin_addr));
   1764 	}
   1765 
   1766 	TAILQ_REMOVE(&dadq, dp, dad_list);
   1767 	need_free = true;
   1768 done:
   1769 	mutex_exit(&arp_dad_lock);
   1770 
   1771 	if (need_free) {
   1772 		kmem_intr_free(dp, sizeof(*dp));
   1773 		ifafree(ifa);
   1774 	}
   1775 
   1776 #ifndef NET_MPSAFE
   1777 	KERNEL_UNLOCK_ONE(NULL);
   1778 	mutex_exit(softnet_lock);
   1779 #endif
   1780 }
   1781 
   1782 static void
   1783 arp_dad_duplicated(struct ifaddr *ifa, const char *sha)
   1784 {
   1785 	struct in_ifaddr *ia = (struct in_ifaddr *)ifa;
   1786 	struct ifnet *ifp = ifa->ifa_ifp;
   1787 	char ipbuf[INET_ADDRSTRLEN];
   1788 	const char *iastr;
   1789 
   1790 	iastr = IN_PRINT(ipbuf, &ia->ia_addr.sin_addr);
   1791 
   1792 	if (ia->ia4_flags & (IN_IFF_TENTATIVE|IN_IFF_DUPLICATED)) {
   1793 		log(LOG_ERR,
   1794 		    "%s: DAD duplicate address %s from %s\n",
   1795 		    if_name(ifp), iastr, sha);
   1796 	} else if (ia->ia_dad_defended == 0 ||
   1797 		   ia->ia_dad_defended < time_uptime - DEFEND_INTERVAL) {
   1798 		ia->ia_dad_defended = time_uptime;
   1799 		arpannounce1(ifa);
   1800 		log(LOG_ERR,
   1801 		    "%s: DAD defended address %s from %s\n",
   1802 		    if_name(ifp), iastr, sha);
   1803 		return;
   1804 	} else {
   1805 		/* If DAD is disabled, just report the duplicate. */
   1806 		if (ip_dad_count == 0) {
   1807 			log(LOG_ERR,
   1808 			    "%s: DAD ignoring duplicate address %s from %s\n",
   1809 			    if_name(ifp), iastr, sha);
   1810 			return;
   1811 		}
   1812 		log(LOG_ERR,
   1813 		    "%s: DAD defence failed for %s from %s\n",
   1814 		    if_name(ifp), iastr, sha);
   1815 	}
   1816 
   1817 	arp_dad_stop(ifa);
   1818 
   1819 	ia->ia4_flags &= ~IN_IFF_TENTATIVE;
   1820 	if ((ia->ia4_flags & IN_IFF_DUPLICATED) == 0) {
   1821 		ia->ia4_flags |= IN_IFF_DUPLICATED;
   1822 		/* Inform the routing socket of the duplicate address */
   1823 		rt_newaddrmsg(RTM_NEWADDR, ifa, 0, NULL);
   1824 	}
   1825 }
   1826 
   1827 /*
   1828  * Called from 10 Mb/s Ethernet interrupt handlers
   1829  * when ether packet type ETHERTYPE_REVARP
   1830  * is received.  Common length and type checks are done here,
   1831  * then the protocol-specific routine is called.
   1832  */
   1833 void
   1834 revarpinput(struct mbuf *m)
   1835 {
   1836 	struct arphdr *ar;
   1837 
   1838 	if (m->m_len < sizeof(struct arphdr))
   1839 		goto out;
   1840 	ar = mtod(m, struct arphdr *);
   1841 #if 0 /* XXX I don't think we need this... and it will prevent other LL */
   1842 	if (ntohs(ar->ar_hrd) != ARPHRD_ETHER)
   1843 		goto out;
   1844 #endif
   1845 	if (m->m_len < sizeof(struct arphdr) + 2 * (ar->ar_hln + ar->ar_pln))
   1846 		goto out;
   1847 	switch (ntohs(ar->ar_pro)) {
   1848 	case ETHERTYPE_IP:
   1849 	case ETHERTYPE_IPTRAILERS:
   1850 		in_revarpinput(m);
   1851 		return;
   1852 
   1853 	default:
   1854 		break;
   1855 	}
   1856 out:
   1857 	m_freem(m);
   1858 }
   1859 
   1860 /*
   1861  * RARP for Internet protocols on 10 Mb/s Ethernet.
   1862  * Algorithm is that given in RFC 903.
   1863  * We are only using for bootstrap purposes to get an ip address for one of
   1864  * our interfaces.  Thus we support no user-interface.
   1865  *
   1866  * Since the contents of the RARP reply are specific to the interface that
   1867  * sent the request, this code must ensure that they are properly associated.
   1868  *
   1869  * Note: also supports ARP via RARP packets, per the RFC.
   1870  */
   1871 void
   1872 in_revarpinput(struct mbuf *m)
   1873 {
   1874 	struct arphdr *ah;
   1875 	void *tha;
   1876 	int op;
   1877 	struct ifnet *rcvif;
   1878 	int s;
   1879 
   1880 	ah = mtod(m, struct arphdr *);
   1881 	op = ntohs(ah->ar_op);
   1882 
   1883 	rcvif = m_get_rcvif(m, &s);
   1884 	if (__predict_false(rcvif == NULL))
   1885 		goto out;
   1886 	switch (rcvif->if_type) {
   1887 	case IFT_IEEE1394:
   1888 		/* ARP without target hardware address is not supported */
   1889 		goto out;
   1890 	default:
   1891 		break;
   1892 	}
   1893 
   1894 	switch (op) {
   1895 	case ARPOP_REQUEST:
   1896 	case ARPOP_REPLY:	/* per RFC */
   1897 		m_put_rcvif(rcvif, &s);
   1898 		in_arpinput(m);
   1899 		return;
   1900 	case ARPOP_REVREPLY:
   1901 		break;
   1902 	case ARPOP_REVREQUEST:	/* handled by rarpd(8) */
   1903 	default:
   1904 		goto out;
   1905 	}
   1906 	if (!revarp_in_progress)
   1907 		goto out;
   1908 	if (rcvif != myip_ifp) /* !same interface */
   1909 		goto out;
   1910 	if (myip_initialized)
   1911 		goto wake;
   1912 	tha = ar_tha(ah);
   1913 	if (tha == NULL)
   1914 		goto out;
   1915 	if (ah->ar_pln != sizeof(struct in_addr))
   1916 		goto out;
   1917 	if (ah->ar_hln != rcvif->if_sadl->sdl_alen)
   1918 		goto out;
   1919 	if (memcmp(tha, CLLADDR(rcvif->if_sadl), rcvif->if_sadl->sdl_alen))
   1920 		goto out;
   1921 	memcpy(&srv_ip, ar_spa(ah), sizeof(srv_ip));
   1922 	memcpy(&myip, ar_tpa(ah), sizeof(myip));
   1923 	myip_initialized = 1;
   1924 wake:	/* Do wakeup every time in case it was missed. */
   1925 	wakeup((void *)&myip);
   1926 
   1927 out:
   1928 	m_put_rcvif(rcvif, &s);
   1929 	m_freem(m);
   1930 }
   1931 
   1932 /*
   1933  * Send a RARP request for the ip address of the specified interface.
   1934  * The request should be RFC 903-compliant.
   1935  */
   1936 static void
   1937 revarprequest(struct ifnet *ifp)
   1938 {
   1939 	struct sockaddr sa;
   1940 	struct mbuf *m;
   1941 	struct arphdr *ah;
   1942 	void *tha;
   1943 
   1944 	if ((m = m_gethdr(M_DONTWAIT, MT_DATA)) == NULL)
   1945 		return;
   1946 	MCLAIM(m, &arpdomain.dom_mowner);
   1947 	m->m_len = sizeof(*ah) + 2*sizeof(struct in_addr) +
   1948 	    2*ifp->if_addrlen;
   1949 	m->m_pkthdr.len = m->m_len;
   1950 	MH_ALIGN(m, m->m_len);
   1951 	ah = mtod(m, struct arphdr *);
   1952 	memset(ah, 0, m->m_len);
   1953 	ah->ar_pro = htons(ETHERTYPE_IP);
   1954 	ah->ar_hln = ifp->if_addrlen;		/* hardware address length */
   1955 	ah->ar_pln = sizeof(struct in_addr);	/* protocol address length */
   1956 	ah->ar_op = htons(ARPOP_REVREQUEST);
   1957 
   1958 	memcpy(ar_sha(ah), CLLADDR(ifp->if_sadl), ah->ar_hln);
   1959 	tha = ar_tha(ah);
   1960 	if (tha == NULL) {
   1961 		m_free(m);
   1962 		return;
   1963 	}
   1964 	memcpy(tha, CLLADDR(ifp->if_sadl), ah->ar_hln);
   1965 
   1966 	sa.sa_family = AF_ARP;
   1967 	sa.sa_len = 2;
   1968 	m->m_flags |= M_BCAST;
   1969 
   1970 	if_output_lock(ifp, ifp, m, &sa, NULL);
   1971 }
   1972 
   1973 /*
   1974  * RARP for the ip address of the specified interface, but also
   1975  * save the ip address of the server that sent the answer.
   1976  * Timeout if no response is received.
   1977  */
   1978 int
   1979 revarpwhoarewe(struct ifnet *ifp, struct in_addr *serv_in,
   1980     struct in_addr *clnt_in)
   1981 {
   1982 	int result, count = 20;
   1983 
   1984 	myip_initialized = 0;
   1985 	myip_ifp = ifp;
   1986 
   1987 	revarp_in_progress = 1;
   1988 	while (count--) {
   1989 		revarprequest(ifp);
   1990 		result = tsleep((void *)&myip, PSOCK, "revarp", hz/2);
   1991 		if (result != EWOULDBLOCK)
   1992 			break;
   1993 	}
   1994 	revarp_in_progress = 0;
   1995 
   1996 	if (!myip_initialized)
   1997 		return ENETUNREACH;
   1998 
   1999 	memcpy(serv_in, &srv_ip, sizeof(*serv_in));
   2000 	memcpy(clnt_in, &myip, sizeof(*clnt_in));
   2001 	return 0;
   2002 }
   2003 
   2004 void
   2005 arp_stat_add(int type, uint64_t count)
   2006 {
   2007 	ARP_STATADD(type, count);
   2008 }
   2009 
   2010 static int
   2011 sysctl_net_inet_arp_stats(SYSCTLFN_ARGS)
   2012 {
   2013 
   2014 	return NETSTAT_SYSCTL(arpstat_percpu, ARP_NSTATS);
   2015 }
   2016 
   2017 static void
   2018 sysctl_net_inet_arp_setup(struct sysctllog **clog)
   2019 {
   2020 	const struct sysctlnode *node;
   2021 
   2022 	sysctl_createv(clog, 0, NULL, NULL,
   2023 			CTLFLAG_PERMANENT,
   2024 			CTLTYPE_NODE, "inet", NULL,
   2025 			NULL, 0, NULL, 0,
   2026 			CTL_NET, PF_INET, CTL_EOL);
   2027 	sysctl_createv(clog, 0, NULL, &node,
   2028 			CTLFLAG_PERMANENT,
   2029 			CTLTYPE_NODE, "arp",
   2030 			SYSCTL_DESCR("Address Resolution Protocol"),
   2031 			NULL, 0, NULL, 0,
   2032 			CTL_NET, PF_INET, CTL_CREATE, CTL_EOL);
   2033 
   2034 	sysctl_createv(clog, 0, NULL, NULL,
   2035 			CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2036 			CTLTYPE_INT, "keep",
   2037 			SYSCTL_DESCR("Valid ARP entry lifetime in seconds"),
   2038 			NULL, 0, &arpt_keep, 0,
   2039 			CTL_NET,PF_INET, node->sysctl_num, CTL_CREATE, CTL_EOL);
   2040 
   2041 	sysctl_createv(clog, 0, NULL, NULL,
   2042 			CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2043 			CTLTYPE_INT, "down",
   2044 			SYSCTL_DESCR("Failed ARP entry lifetime in seconds"),
   2045 			NULL, 0, &arpt_down, 0,
   2046 			CTL_NET,PF_INET, node->sysctl_num, CTL_CREATE, CTL_EOL);
   2047 
   2048 	sysctl_createv(clog, 0, NULL, NULL,
   2049 			CTLFLAG_PERMANENT,
   2050 			CTLTYPE_STRUCT, "stats",
   2051 			SYSCTL_DESCR("ARP statistics"),
   2052 			sysctl_net_inet_arp_stats, 0, NULL, 0,
   2053 			CTL_NET,PF_INET, node->sysctl_num, CTL_CREATE, CTL_EOL);
   2054 
   2055 	sysctl_createv(clog, 0, NULL, NULL,
   2056 			CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2057 			CTLTYPE_INT, "log_movements",
   2058 			SYSCTL_DESCR("log ARP replies from MACs different than"
   2059 			    " the one in the cache"),
   2060 			NULL, 0, &log_movements, 0,
   2061 			CTL_NET,PF_INET, node->sysctl_num, CTL_CREATE, CTL_EOL);
   2062 
   2063 	sysctl_createv(clog, 0, NULL, NULL,
   2064 			CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2065 			CTLTYPE_INT, "log_permanent_modify",
   2066 			SYSCTL_DESCR("log ARP replies from MACs different than"
   2067 			    " the one in the permanent arp entry"),
   2068 			NULL, 0, &log_permanent_modify, 0,
   2069 			CTL_NET,PF_INET, node->sysctl_num, CTL_CREATE, CTL_EOL);
   2070 
   2071 	sysctl_createv(clog, 0, NULL, NULL,
   2072 			CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2073 			CTLTYPE_INT, "log_wrong_iface",
   2074 			SYSCTL_DESCR("log ARP packets arriving on the wrong"
   2075 			    " interface"),
   2076 			NULL, 0, &log_wrong_iface, 0,
   2077 			CTL_NET,PF_INET, node->sysctl_num, CTL_CREATE, CTL_EOL);
   2078 
   2079 	sysctl_createv(clog, 0, NULL, NULL,
   2080 			CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2081 			CTLTYPE_INT, "log_unknown_network",
   2082 			SYSCTL_DESCR("log ARP packets from non-local network"),
   2083 			NULL, 0, &log_unknown_network, 0,
   2084 			CTL_NET,PF_INET, node->sysctl_num, CTL_CREATE, CTL_EOL);
   2085 
   2086 	sysctl_createv(clog, 0, NULL, NULL,
   2087 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2088 		       CTLTYPE_INT, "debug",
   2089 		       SYSCTL_DESCR("Enable ARP DAD debug output"),
   2090 		       NULL, 0, &arp_debug, 0,
   2091 		       CTL_NET, PF_INET, node->sysctl_num, CTL_CREATE, CTL_EOL);
   2092 }
   2093 
   2094 #endif /* INET */
   2095