xref: /freebsd/sys/netinet/if_ether.c (revision b8a6e03fac922677455d8e0977831506cf8212e8)
1c398230bSWarner Losh /*-
251369649SPedro F. Giffuni  * SPDX-License-Identifier: BSD-3-Clause
351369649SPedro F. Giffuni  *
4df8bae1dSRodney W. Grimes  * Copyright (c) 1982, 1986, 1988, 1993
5df8bae1dSRodney W. Grimes  *	The Regents of the University of California.  All rights reserved.
6df8bae1dSRodney W. Grimes  *
7df8bae1dSRodney W. Grimes  * Redistribution and use in source and binary forms, with or without
8df8bae1dSRodney W. Grimes  * modification, are permitted provided that the following conditions
9df8bae1dSRodney W. Grimes  * are met:
10df8bae1dSRodney W. Grimes  * 1. Redistributions of source code must retain the above copyright
11df8bae1dSRodney W. Grimes  *    notice, this list of conditions and the following disclaimer.
12df8bae1dSRodney W. Grimes  * 2. Redistributions in binary form must reproduce the above copyright
13df8bae1dSRodney W. Grimes  *    notice, this list of conditions and the following disclaimer in the
14df8bae1dSRodney W. Grimes  *    documentation and/or other materials provided with the distribution.
15fbbd9655SWarner Losh  * 3. Neither the name of the University nor the names of its contributors
16df8bae1dSRodney W. Grimes  *    may be used to endorse or promote products derived from this software
17df8bae1dSRodney W. Grimes  *    without specific prior written permission.
18df8bae1dSRodney W. Grimes  *
19df8bae1dSRodney W. Grimes  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
20df8bae1dSRodney W. Grimes  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21df8bae1dSRodney W. Grimes  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22df8bae1dSRodney W. Grimes  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
23df8bae1dSRodney W. Grimes  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24df8bae1dSRodney W. Grimes  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25df8bae1dSRodney W. Grimes  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26df8bae1dSRodney W. Grimes  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27df8bae1dSRodney W. Grimes  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28df8bae1dSRodney W. Grimes  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29df8bae1dSRodney W. Grimes  * SUCH DAMAGE.
30df8bae1dSRodney W. Grimes  *
31df8bae1dSRodney W. Grimes  *	@(#)if_ether.c	8.1 (Berkeley) 6/10/93
32df8bae1dSRodney W. Grimes  */
33df8bae1dSRodney W. Grimes 
34df8bae1dSRodney W. Grimes /*
35df8bae1dSRodney W. Grimes  * Ethernet address resolution protocol.
36df8bae1dSRodney W. Grimes  * TODO:
37df8bae1dSRodney W. Grimes  *	add "inuse/lock" bit (or ref. count) along with valid bit
38df8bae1dSRodney W. Grimes  */
39df8bae1dSRodney W. Grimes 
404b421e2dSMike Silbersack #include <sys/cdefs.h>
414b421e2dSMike Silbersack __FBSDID("$FreeBSD$");
424b421e2dSMike Silbersack 
431d5e9e22SEivind Eklund #include "opt_inet.h"
441d5e9e22SEivind Eklund 
45df8bae1dSRodney W. Grimes #include <sys/param.h>
46e2e050c8SConrad Meyer #include <sys/eventhandler.h>
47df8bae1dSRodney W. Grimes #include <sys/kernel.h>
48cc0a3c8cSAndrey V. Elsukov #include <sys/lock.h>
49ce02431fSDoug Rabson #include <sys/queue.h>
50885f1aa4SPoul-Henning Kamp #include <sys/sysctl.h>
51885f1aa4SPoul-Henning Kamp #include <sys/systm.h>
52885f1aa4SPoul-Henning Kamp #include <sys/mbuf.h>
53885f1aa4SPoul-Henning Kamp #include <sys/malloc.h>
54de34ad3fSJulian Elischer #include <sys/proc.h>
55cc0a3c8cSAndrey V. Elsukov #include <sys/rmlock.h>
564458ac71SBruce Evans #include <sys/socket.h>
57885f1aa4SPoul-Henning Kamp #include <sys/syslog.h>
58df8bae1dSRodney W. Grimes 
59df8bae1dSRodney W. Grimes #include <net/if.h>
6076039bc8SGleb Smirnoff #include <net/if_var.h>
61df8bae1dSRodney W. Grimes #include <net/if_dl.h>
62722012ccSJulian Elischer #include <net/if_types.h>
63748e0b0aSGarrett Wollman #include <net/netisr.h>
64c8f8e9c1SJulian Elischer #include <net/ethernet.h>
655736e6fbSBjoern A. Zeeb #include <net/route.h>
66530c0060SRobert Watson #include <net/vnet.h>
67df8bae1dSRodney W. Grimes 
68df8bae1dSRodney W. Grimes #include <netinet/in.h>
699977be4aSAlexander V. Chernikov #include <netinet/in_fib.h>
70df8bae1dSRodney W. Grimes #include <netinet/in_var.h>
716e6b3f7cSQing Li #include <net/if_llatbl.h>
72df8bae1dSRodney W. Grimes #include <netinet/if_ether.h>
7383e521ecSBjoern A. Zeeb #ifdef INET
749963e8a5SWill Andrews #include <netinet/ip_carp.h>
759963e8a5SWill Andrews #endif
76df8bae1dSRodney W. Grimes 
77aed55708SRobert Watson #include <security/mac/mac_framework.h>
78aed55708SRobert Watson 
7947e8d432SGleb Smirnoff #define SIN(s) ((const struct sockaddr_in *)(s))
80eec33ea0SAlexander V. Chernikov 
81eec33ea0SAlexander V. Chernikov static struct timeval arp_lastlog;
82eec33ea0SAlexander V. Chernikov static int arp_curpps;
83eec33ea0SAlexander V. Chernikov static int arp_maxpps = 1;
84df8bae1dSRodney W. Grimes 
85f8aee88fSAlexander V. Chernikov /* Simple ARP state machine */
86f8aee88fSAlexander V. Chernikov enum arp_llinfo_state {
87f8aee88fSAlexander V. Chernikov 	ARP_LLINFO_INCOMPLETE = 0, /* No LLE data */
88f8aee88fSAlexander V. Chernikov 	ARP_LLINFO_REACHABLE,	/* LLE is valid */
89f8aee88fSAlexander V. Chernikov 	ARP_LLINFO_VERIFY,	/* LLE is valid, need refresh */
90f8aee88fSAlexander V. Chernikov 	ARP_LLINFO_DELETED,	/* LLE is deleted */
91f8aee88fSAlexander V. Chernikov };
92f8aee88fSAlexander V. Chernikov 
93ce02431fSDoug Rabson SYSCTL_DECL(_net_link_ether);
946472ac3dSEd Schouten static SYSCTL_NODE(_net_link_ether, PF_INET, inet, CTLFLAG_RW, 0, "");
956472ac3dSEd Schouten static SYSCTL_NODE(_net_link_ether, PF_ARP, arp, CTLFLAG_RW, 0, "");
96df8bae1dSRodney W. Grimes 
97df8bae1dSRodney W. Grimes /* timer values */
985f901c92SAndrew Turner VNET_DEFINE_STATIC(int, arpt_keep) = (20*60);	/* once resolved, good for 20
99eddfbb76SRobert Watson 						 * minutes */
1005f901c92SAndrew Turner VNET_DEFINE_STATIC(int, arp_maxtries) = 5;
1015f901c92SAndrew Turner VNET_DEFINE_STATIC(int, arp_proxyall) = 0;
1025f901c92SAndrew Turner VNET_DEFINE_STATIC(int, arpt_down) = 20;	/* keep incomplete entries for
10393704ac5SQing Li 						 * 20 seconds */
1045f901c92SAndrew Turner VNET_DEFINE_STATIC(int, arpt_rexmit) = 1;	/* retransmit arp entries, sec*/
1055b7cb97cSAndrey V. Elsukov VNET_PCPUSTAT_DEFINE(struct arpstat, arpstat);  /* ARP statistics, see if_arp.h */
1065b7cb97cSAndrey V. Elsukov VNET_PCPUSTAT_SYSINIT(arpstat);
1075b7cb97cSAndrey V. Elsukov 
1085b7cb97cSAndrey V. Elsukov #ifdef VIMAGE
1095b7cb97cSAndrey V. Elsukov VNET_PCPUSTAT_SYSUNINIT(arpstat);
1105b7cb97cSAndrey V. Elsukov #endif /* VIMAGE */
111e162ea60SGeorge V. Neville-Neil 
1125f901c92SAndrew Turner VNET_DEFINE_STATIC(int, arp_maxhold) = 1;
113885f1aa4SPoul-Henning Kamp 
1141e77c105SRobert Watson #define	V_arpt_keep		VNET(arpt_keep)
11593704ac5SQing Li #define	V_arpt_down		VNET(arpt_down)
116f8aee88fSAlexander V. Chernikov #define	V_arpt_rexmit		VNET(arpt_rexmit)
1171e77c105SRobert Watson #define	V_arp_maxtries		VNET(arp_maxtries)
1181e77c105SRobert Watson #define	V_arp_proxyall		VNET(arp_proxyall)
119e162ea60SGeorge V. Neville-Neil #define	V_arp_maxhold		VNET(arp_maxhold)
120885f1aa4SPoul-Henning Kamp 
1216df8a710SGleb Smirnoff SYSCTL_INT(_net_link_ether_inet, OID_AUTO, max_age, CTLFLAG_VNET | CTLFLAG_RW,
122eddfbb76SRobert Watson 	&VNET_NAME(arpt_keep), 0,
123eddfbb76SRobert Watson 	"ARP entry lifetime in seconds");
1246df8a710SGleb Smirnoff SYSCTL_INT(_net_link_ether_inet, OID_AUTO, maxtries, CTLFLAG_VNET | CTLFLAG_RW,
125eddfbb76SRobert Watson 	&VNET_NAME(arp_maxtries), 0,
1268b615593SMarko Zec 	"ARP resolution attempts before returning error");
1276df8a710SGleb Smirnoff SYSCTL_INT(_net_link_ether_inet, OID_AUTO, proxyall, CTLFLAG_VNET | CTLFLAG_RW,
128eddfbb76SRobert Watson 	&VNET_NAME(arp_proxyall), 0,
1298b615593SMarko Zec 	"Enable proxy ARP for all suitable requests");
1306df8a710SGleb Smirnoff SYSCTL_INT(_net_link_ether_inet, OID_AUTO, wait, CTLFLAG_VNET | CTLFLAG_RW,
131e162ea60SGeorge V. Neville-Neil 	&VNET_NAME(arpt_down), 0,
132e162ea60SGeorge V. Neville-Neil 	"Incomplete ARP entry lifetime in seconds");
1335b7cb97cSAndrey V. Elsukov SYSCTL_VNET_PCPUSTAT(_net_link_ether_arp, OID_AUTO, stats, struct arpstat,
1345b7cb97cSAndrey V. Elsukov     arpstat, "ARP statistics (struct arpstat, net/if_arp.h)");
1356df8a710SGleb Smirnoff SYSCTL_INT(_net_link_ether_inet, OID_AUTO, maxhold, CTLFLAG_VNET | CTLFLAG_RW,
136e162ea60SGeorge V. Neville-Neil 	&VNET_NAME(arp_maxhold), 0,
137e162ea60SGeorge V. Neville-Neil 	"Number of packets to hold per ARP entry");
138eec33ea0SAlexander V. Chernikov SYSCTL_INT(_net_link_ether_inet, OID_AUTO, max_log_per_second,
139eec33ea0SAlexander V. Chernikov 	CTLFLAG_RW, &arp_maxpps, 0,
140eec33ea0SAlexander V. Chernikov 	"Maximum number of remotely triggered ARP messages that can be "
141eec33ea0SAlexander V. Chernikov 	"logged per second");
142eec33ea0SAlexander V. Chernikov 
1432d9db0bcSEric van Gyzen /*
1442d9db0bcSEric van Gyzen  * Due to the exponential backoff algorithm used for the interval between GARP
1452d9db0bcSEric van Gyzen  * retransmissions, the maximum number of retransmissions is limited for
1462d9db0bcSEric van Gyzen  * sanity. This limit corresponds to a maximum interval between retransmissions
1472d9db0bcSEric van Gyzen  * of 2^16 seconds ~= 18 hours.
1482d9db0bcSEric van Gyzen  *
1492d9db0bcSEric van Gyzen  * Making this limit more dynamic is more complicated than worthwhile,
1502d9db0bcSEric van Gyzen  * especially since sending out GARPs spaced days apart would be of little
1512d9db0bcSEric van Gyzen  * use. A maximum dynamic limit would look something like:
1522d9db0bcSEric van Gyzen  *
1532d9db0bcSEric van Gyzen  * const int max = fls(INT_MAX / hz) - 1;
1542d9db0bcSEric van Gyzen  */
1552d9db0bcSEric van Gyzen #define MAX_GARP_RETRANSMITS 16
1562d9db0bcSEric van Gyzen static int sysctl_garp_rexmit(SYSCTL_HANDLER_ARGS);
1572d9db0bcSEric van Gyzen static int garp_rexmit_count = 0; /* GARP retransmission setting. */
1582d9db0bcSEric van Gyzen 
1592d9db0bcSEric van Gyzen SYSCTL_PROC(_net_link_ether_inet, OID_AUTO, garp_rexmit_count,
1602d9db0bcSEric van Gyzen     CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_MPSAFE,
1612d9db0bcSEric van Gyzen     &garp_rexmit_count, 0, sysctl_garp_rexmit, "I",
1622d9db0bcSEric van Gyzen     "Number of times to retransmit GARP packets;"
1632d9db0bcSEric van Gyzen     " 0 to disable, maximum of 16");
1642d9db0bcSEric van Gyzen 
165b25d74e0SBjoern A. Zeeb VNET_DEFINE_STATIC(int, arp_log_level) = LOG_INFO;	/* Min. log(9) level. */
166b25d74e0SBjoern A. Zeeb #define	V_arp_log_level		VNET(arp_log_level)
167b25d74e0SBjoern A. Zeeb SYSCTL_INT(_net_link_ether_arp, OID_AUTO, log_level, CTLFLAG_VNET | CTLFLAG_RW,
168b25d74e0SBjoern A. Zeeb 	&VNET_NAME(arp_log_level), 0,
169b25d74e0SBjoern A. Zeeb 	"Minimum log(9) level for recording rate limited arp log messages. "
170b25d74e0SBjoern A. Zeeb 	"The higher will be log more (emerg=0, info=6 (default), debug=7).");
171eec33ea0SAlexander V. Chernikov #define	ARP_LOG(pri, ...)	do {					\
172b25d74e0SBjoern A. Zeeb 	if ((pri) <= V_arp_log_level &&					\
173b25d74e0SBjoern A. Zeeb 	    ppsratecheck(&arp_lastlog, &arp_curpps, arp_maxpps))	\
174eec33ea0SAlexander V. Chernikov 		log((pri), "arp: " __VA_ARGS__);			\
175eec33ea0SAlexander V. Chernikov } while (0)
176eec33ea0SAlexander V. Chernikov 
177885f1aa4SPoul-Henning Kamp 
1781cafed39SJonathan Lemon static void	arpintr(struct mbuf *);
1794d77a549SAlfred Perlstein static void	arptimer(void *);
1801d5e9e22SEivind Eklund #ifdef INET
1814d77a549SAlfred Perlstein static void	in_arpinput(struct mbuf *);
1821d5e9e22SEivind Eklund #endif
18328e82295SGarrett Wollman 
184f3bfa7d1SAlexander V. Chernikov static void arp_check_update_lle(struct arphdr *ah, struct in_addr isaddr,
185f3bfa7d1SAlexander V. Chernikov     struct ifnet *ifp, int bridged, struct llentry *la);
186f3bfa7d1SAlexander V. Chernikov static void arp_mark_lle_reachable(struct llentry *la);
187b13c5b5dSAlexander V. Chernikov static void arp_iflladdr(void *arg __unused, struct ifnet *ifp);
188f3bfa7d1SAlexander V. Chernikov 
189b13c5b5dSAlexander V. Chernikov static eventhandler_tag iflladdr_tag;
190f3bfa7d1SAlexander V. Chernikov 
191d4b5cae4SRobert Watson static const struct netisr_handler arp_nh = {
192d4b5cae4SRobert Watson 	.nh_name = "arp",
193d4b5cae4SRobert Watson 	.nh_handler = arpintr,
194d4b5cae4SRobert Watson 	.nh_proto = NETISR_ARP,
195d4b5cae4SRobert Watson 	.nh_policy = NETISR_POLICY_SOURCE,
196d4b5cae4SRobert Watson };
197d4b5cae4SRobert Watson 
1986e6b3f7cSQing Li /*
1996e6b3f7cSQing Li  * Timeout routine.  Age arp_tab entries periodically.
200df8bae1dSRodney W. Grimes  */
201df8bae1dSRodney W. Grimes static void
2021daaa65dSGleb Smirnoff arptimer(void *arg)
203df8bae1dSRodney W. Grimes {
204ea537929SGleb Smirnoff 	struct llentry *lle = (struct llentry *)arg;
2056e6b3f7cSQing Li 	struct ifnet *ifp;
206f8aee88fSAlexander V. Chernikov 	int r_skip_req;
207df8bae1dSRodney W. Grimes 
208ea537929SGleb Smirnoff 	if (lle->la_flags & LLE_STATIC) {
2092575fbb8SRandall Stewart 		return;
2102575fbb8SRandall Stewart 	}
2112575fbb8SRandall Stewart 	LLE_WLOCK(lle);
2120447c136SAlexander V. Chernikov 	if (callout_pending(&lle->lle_timer)) {
2132575fbb8SRandall Stewart 		/*
2142575fbb8SRandall Stewart 		 * Here we are a bit odd here in the treatment of
2152575fbb8SRandall Stewart 		 * active/pending. If the pending bit is set, it got
2162575fbb8SRandall Stewart 		 * rescheduled before I ran. The active
2172575fbb8SRandall Stewart 		 * bit we ignore, since if it was stopped
2182575fbb8SRandall Stewart 		 * in ll_tablefree() and was currently running
2192575fbb8SRandall Stewart 		 * it would have return 0 so the code would
2202575fbb8SRandall Stewart 		 * not have deleted it since the callout could
2212575fbb8SRandall Stewart 		 * not be stopped so we want to go through
2222575fbb8SRandall Stewart 		 * with the delete here now. If the callout
2232575fbb8SRandall Stewart 		 * was restarted, the pending bit will be back on and
2242575fbb8SRandall Stewart 		 * we just want to bail since the callout_reset would
2252575fbb8SRandall Stewart 		 * return 1 and our reference would have been removed
2262575fbb8SRandall Stewart 		 * by arpresolve() below.
2272575fbb8SRandall Stewart 		 */
228ea537929SGleb Smirnoff 		LLE_WUNLOCK(lle);
229ea537929SGleb Smirnoff  		return;
230ea537929SGleb Smirnoff  	}
2316e6b3f7cSQing Li 	ifp = lle->lle_tbl->llt_ifp;
23254fc657dSGeorge V. Neville-Neil 	CURVNET_SET(ifp->if_vnet);
23309fe6320SNavdeep Parhar 
234f8aee88fSAlexander V. Chernikov 	switch (lle->ln_state) {
235f8aee88fSAlexander V. Chernikov 	case ARP_LLINFO_REACHABLE:
236f8aee88fSAlexander V. Chernikov 
237f8aee88fSAlexander V. Chernikov 		/*
238f8aee88fSAlexander V. Chernikov 		 * Expiration time is approaching.
239f8aee88fSAlexander V. Chernikov 		 * Let's try to refresh entry if it is still
240f8aee88fSAlexander V. Chernikov 		 * in use.
241f8aee88fSAlexander V. Chernikov 		 *
242f8aee88fSAlexander V. Chernikov 		 * Set r_skip_req to get feedback from
243f8aee88fSAlexander V. Chernikov 		 * fast path. Change state and re-schedule
244f8aee88fSAlexander V. Chernikov 		 * ourselves.
245f8aee88fSAlexander V. Chernikov 		 */
246f8aee88fSAlexander V. Chernikov 		LLE_REQ_LOCK(lle);
247f8aee88fSAlexander V. Chernikov 		lle->r_skip_req = 1;
248f8aee88fSAlexander V. Chernikov 		LLE_REQ_UNLOCK(lle);
249f8aee88fSAlexander V. Chernikov 		lle->ln_state = ARP_LLINFO_VERIFY;
250f8aee88fSAlexander V. Chernikov 		callout_schedule(&lle->lle_timer, hz * V_arpt_rexmit);
251f8aee88fSAlexander V. Chernikov 		LLE_WUNLOCK(lle);
252f8aee88fSAlexander V. Chernikov 		CURVNET_RESTORE();
253f8aee88fSAlexander V. Chernikov 		return;
254f8aee88fSAlexander V. Chernikov 	case ARP_LLINFO_VERIFY:
255f8aee88fSAlexander V. Chernikov 		LLE_REQ_LOCK(lle);
256f8aee88fSAlexander V. Chernikov 		r_skip_req = lle->r_skip_req;
257f8aee88fSAlexander V. Chernikov 		LLE_REQ_UNLOCK(lle);
258f8aee88fSAlexander V. Chernikov 
259f8aee88fSAlexander V. Chernikov 		if (r_skip_req == 0 && lle->la_preempt > 0) {
260f8aee88fSAlexander V. Chernikov 			/* Entry was used, issue refresh request */
261*b8a6e03fSGleb Smirnoff 			struct epoch_tracker et;
262f8aee88fSAlexander V. Chernikov 			struct in_addr dst;
263*b8a6e03fSGleb Smirnoff 
264f8aee88fSAlexander V. Chernikov 			dst = lle->r_l3addr.addr4;
265f8aee88fSAlexander V. Chernikov 			lle->la_preempt--;
266f8aee88fSAlexander V. Chernikov 			callout_schedule(&lle->lle_timer, hz * V_arpt_rexmit);
267f8aee88fSAlexander V. Chernikov 			LLE_WUNLOCK(lle);
268*b8a6e03fSGleb Smirnoff 			NET_EPOCH_ENTER(et);
269f8aee88fSAlexander V. Chernikov 			arprequest(ifp, NULL, &dst, NULL);
270*b8a6e03fSGleb Smirnoff 			NET_EPOCH_EXIT(et);
271f8aee88fSAlexander V. Chernikov 			CURVNET_RESTORE();
272f8aee88fSAlexander V. Chernikov 			return;
273f8aee88fSAlexander V. Chernikov 		}
274f8aee88fSAlexander V. Chernikov 		/* Nothing happened. Reschedule if not too late */
275f8aee88fSAlexander V. Chernikov 		if (lle->la_expire > time_uptime) {
276f8aee88fSAlexander V. Chernikov 			callout_schedule(&lle->lle_timer, hz * V_arpt_rexmit);
277f8aee88fSAlexander V. Chernikov 			LLE_WUNLOCK(lle);
278f8aee88fSAlexander V. Chernikov 			CURVNET_RESTORE();
279f8aee88fSAlexander V. Chernikov 			return;
280f8aee88fSAlexander V. Chernikov 		}
281f8aee88fSAlexander V. Chernikov 		break;
282f8aee88fSAlexander V. Chernikov 	case ARP_LLINFO_INCOMPLETE:
283f8aee88fSAlexander V. Chernikov 	case ARP_LLINFO_DELETED:
284f8aee88fSAlexander V. Chernikov 		break;
285f8aee88fSAlexander V. Chernikov 	}
286f8aee88fSAlexander V. Chernikov 
287e364d8c4SNavdeep Parhar 	if ((lle->la_flags & LLE_DELETED) == 0) {
28809fe6320SNavdeep Parhar 		int evt;
28909fe6320SNavdeep Parhar 
29009fe6320SNavdeep Parhar 		if (lle->la_flags & LLE_VALID)
29109fe6320SNavdeep Parhar 			evt = LLENTRY_EXPIRED;
29209fe6320SNavdeep Parhar 		else
29309fe6320SNavdeep Parhar 			evt = LLENTRY_TIMEDOUT;
29409fe6320SNavdeep Parhar 		EVENTHANDLER_INVOKE(lle_event, lle, evt);
29509fe6320SNavdeep Parhar 	}
29609fe6320SNavdeep Parhar 
2970447c136SAlexander V. Chernikov 	callout_stop(&lle->lle_timer);
298ea537929SGleb Smirnoff 
299ea537929SGleb Smirnoff 	/* XXX: LOR avoidance. We still have ref on lle. */
300ea537929SGleb Smirnoff 	LLE_WUNLOCK(lle);
301ea537929SGleb Smirnoff 	IF_AFDATA_LOCK(ifp);
302ea537929SGleb Smirnoff 	LLE_WLOCK(lle);
303ea537929SGleb Smirnoff 
304b1ec2940SGleb Smirnoff 	/* Guard against race with other llentry_free(). */
305b1ec2940SGleb Smirnoff 	if (lle->la_flags & LLE_LINKED) {
306ea537929SGleb Smirnoff 		LLE_REMREF(lle);
307d3cdb716SAlexander V. Chernikov 		lltable_unlink_entry(lle->lle_tbl, lle);
308d3cdb716SAlexander V. Chernikov 	}
309b1ec2940SGleb Smirnoff 	IF_AFDATA_UNLOCK(ifp);
310b1ec2940SGleb Smirnoff 
311d3cdb716SAlexander V. Chernikov 	size_t pkts_dropped = llentry_free(lle);
312d3cdb716SAlexander V. Chernikov 
313d3cdb716SAlexander V. Chernikov 	ARPSTAT_ADD(dropped, pkts_dropped);
31454fc657dSGeorge V. Neville-Neil 	ARPSTAT_INC(timeouts);
315b1ec2940SGleb Smirnoff 
31654fc657dSGeorge V. Neville-Neil 	CURVNET_RESTORE();
317df8bae1dSRodney W. Grimes }
318df8bae1dSRodney W. Grimes 
319df8bae1dSRodney W. Grimes /*
3204fb3a820SAlexander V. Chernikov  * Stores link-layer header for @ifp in format suitable for if_output()
3214fb3a820SAlexander V. Chernikov  * into buffer @buf. Resulting header length is stored in @bufsize.
3224fb3a820SAlexander V. Chernikov  *
3234fb3a820SAlexander V. Chernikov  * Returns 0 on success.
3244fb3a820SAlexander V. Chernikov  */
3254fb3a820SAlexander V. Chernikov static int
3264fb3a820SAlexander V. Chernikov arp_fillheader(struct ifnet *ifp, struct arphdr *ah, int bcast, u_char *buf,
3274fb3a820SAlexander V. Chernikov     size_t *bufsize)
3284fb3a820SAlexander V. Chernikov {
3294fb3a820SAlexander V. Chernikov 	struct if_encap_req ereq;
3304fb3a820SAlexander V. Chernikov 	int error;
3314fb3a820SAlexander V. Chernikov 
3324fb3a820SAlexander V. Chernikov 	bzero(buf, *bufsize);
3334fb3a820SAlexander V. Chernikov 	bzero(&ereq, sizeof(ereq));
3344fb3a820SAlexander V. Chernikov 	ereq.buf = buf;
3354fb3a820SAlexander V. Chernikov 	ereq.bufsize = *bufsize;
3364fb3a820SAlexander V. Chernikov 	ereq.rtype = IFENCAP_LL;
3374fb3a820SAlexander V. Chernikov 	ereq.family = AF_ARP;
3384fb3a820SAlexander V. Chernikov 	ereq.lladdr = ar_tha(ah);
3394fb3a820SAlexander V. Chernikov 	ereq.hdata = (u_char *)ah;
3404fb3a820SAlexander V. Chernikov 	if (bcast)
3414fb3a820SAlexander V. Chernikov 		ereq.flags = IFENCAP_FLAG_BROADCAST;
3424fb3a820SAlexander V. Chernikov 	error = ifp->if_requestencap(ifp, &ereq);
3434fb3a820SAlexander V. Chernikov 	if (error == 0)
3444fb3a820SAlexander V. Chernikov 		*bufsize = ereq.bufsize;
3454fb3a820SAlexander V. Chernikov 
3464fb3a820SAlexander V. Chernikov 	return (error);
3474fb3a820SAlexander V. Chernikov }
3484fb3a820SAlexander V. Chernikov 
3494fb3a820SAlexander V. Chernikov 
3504fb3a820SAlexander V. Chernikov /*
351df8bae1dSRodney W. Grimes  * Broadcast an ARP request. Caller specifies:
352df8bae1dSRodney W. Grimes  *	- arp header source ip address
353df8bae1dSRodney W. Grimes  *	- arp header target ip address
354df8bae1dSRodney W. Grimes  *	- arp header source ethernet address
355df8bae1dSRodney W. Grimes  */
356a4c69b8bSBjoern A. Zeeb static int
357a4c69b8bSBjoern A. Zeeb arprequest_internal(struct ifnet *ifp, const struct in_addr *sip,
35847e8d432SGleb Smirnoff     const struct in_addr *tip, u_char *enaddr)
359df8bae1dSRodney W. Grimes {
360e952fa39SMatthew N. Dodd 	struct mbuf *m;
361e952fa39SMatthew N. Dodd 	struct arphdr *ah;
362df8bae1dSRodney W. Grimes 	struct sockaddr sa;
363aa24ae3cSGleb Smirnoff 	u_char *carpaddr = NULL;
3644fb3a820SAlexander V. Chernikov 	uint8_t linkhdr[LLE_MAX_LINKHDR];
3654fb3a820SAlexander V. Chernikov 	size_t linkhdrsize;
3664fb3a820SAlexander V. Chernikov 	struct route ro;
3674fb3a820SAlexander V. Chernikov 	int error;
368df8bae1dSRodney W. Grimes 
369*b8a6e03fSGleb Smirnoff 	NET_EPOCH_ASSERT();
370*b8a6e03fSGleb Smirnoff 
3716e6b3f7cSQing Li 	if (sip == NULL) {
3726e6b3f7cSQing Li 		/*
3736e6b3f7cSQing Li 		 * The caller did not supply a source address, try to find
3746e6b3f7cSQing Li 		 * a compatible one among those assigned to this interface.
3756e6b3f7cSQing Li 		 */
3766e6b3f7cSQing Li 		struct ifaddr *ifa;
3776e6b3f7cSQing Li 
378d7c5a620SMatt Macy 		CK_STAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
379aa24ae3cSGleb Smirnoff 			if (ifa->ifa_addr->sa_family != AF_INET)
3806e6b3f7cSQing Li 				continue;
381aa24ae3cSGleb Smirnoff 
382aa24ae3cSGleb Smirnoff 			if (ifa->ifa_carp) {
383aa24ae3cSGleb Smirnoff 				if ((*carp_iamatch_p)(ifa, &carpaddr) == 0)
384aa24ae3cSGleb Smirnoff 					continue;
385aa24ae3cSGleb Smirnoff 				sip = &IA_SIN(ifa)->sin_addr;
386aa24ae3cSGleb Smirnoff 			} else {
387aa24ae3cSGleb Smirnoff 				carpaddr = NULL;
388aa24ae3cSGleb Smirnoff 				sip = &IA_SIN(ifa)->sin_addr;
389aa24ae3cSGleb Smirnoff 			}
390aa24ae3cSGleb Smirnoff 
3916e6b3f7cSQing Li 			if (0 == ((sip->s_addr ^ tip->s_addr) &
392aa24ae3cSGleb Smirnoff 			    IA_MASKSIN(ifa)->sin_addr.s_addr))
3936e6b3f7cSQing Li 				break;  /* found it. */
3946e6b3f7cSQing Li 		}
3956e6b3f7cSQing Li 		if (sip == NULL) {
3966e6b3f7cSQing Li 			printf("%s: cannot find matching address\n", __func__);
397a4c69b8bSBjoern A. Zeeb 			return (EADDRNOTAVAIL);
3986e6b3f7cSQing Li 		}
3996e6b3f7cSQing Li 	}
400aa24ae3cSGleb Smirnoff 	if (enaddr == NULL)
401aa24ae3cSGleb Smirnoff 		enaddr = carpaddr ? carpaddr : (u_char *)IF_LLADDR(ifp);
4026e6b3f7cSQing Li 
403eb1b1807SGleb Smirnoff 	if ((m = m_gethdr(M_NOWAIT, MT_DATA)) == NULL)
404a4c69b8bSBjoern A. Zeeb 		return (ENOMEM);
40564bf80ceSMatthew N. Dodd 	m->m_len = sizeof(*ah) + 2 * sizeof(struct in_addr) +
406546451a2SGleb Smirnoff 		2 * ifp->if_addrlen;
40764bf80ceSMatthew N. Dodd 	m->m_pkthdr.len = m->m_len;
408ed6a66caSRobert Watson 	M_ALIGN(m, m->m_len);
40964bf80ceSMatthew N. Dodd 	ah = mtod(m, struct arphdr *);
41064bf80ceSMatthew N. Dodd 	bzero((caddr_t)ah, m->m_len);
41119527d3eSRobert Watson #ifdef MAC
412b9b0dac3SRobert Watson 	mac_netinet_arp_send(ifp, m);
41319527d3eSRobert Watson #endif
414322dcb8dSMax Khon 	ah->ar_pro = htons(ETHERTYPE_IP);
415322dcb8dSMax Khon 	ah->ar_hln = ifp->if_addrlen;		/* hardware address length */
416322dcb8dSMax Khon 	ah->ar_pln = sizeof(struct in_addr);	/* protocol address length */
417322dcb8dSMax Khon 	ah->ar_op = htons(ARPOP_REQUEST);
41847e8d432SGleb Smirnoff 	bcopy(enaddr, ar_sha(ah), ah->ar_hln);
41947e8d432SGleb Smirnoff 	bcopy(sip, ar_spa(ah), ah->ar_pln);
42047e8d432SGleb Smirnoff 	bcopy(tip, ar_tpa(ah), ah->ar_pln);
42164bf80ceSMatthew N. Dodd 	sa.sa_family = AF_ARP;
42264bf80ceSMatthew N. Dodd 	sa.sa_len = 2;
4234fb3a820SAlexander V. Chernikov 
4244fb3a820SAlexander V. Chernikov 	/* Calculate link header for sending frame */
4254fb3a820SAlexander V. Chernikov 	bzero(&ro, sizeof(ro));
4264fb3a820SAlexander V. Chernikov 	linkhdrsize = sizeof(linkhdr);
4274fb3a820SAlexander V. Chernikov 	error = arp_fillheader(ifp, ah, 1, linkhdr, &linkhdrsize);
4284fb3a820SAlexander V. Chernikov 	if (error != 0 && error != EAFNOSUPPORT) {
4294fb3a820SAlexander V. Chernikov 		ARP_LOG(LOG_ERR, "Failed to calculate ARP header on %s: %d\n",
4304fb3a820SAlexander V. Chernikov 		    if_name(ifp), error);
431a4c69b8bSBjoern A. Zeeb 		return (error);
4324fb3a820SAlexander V. Chernikov 	}
4334fb3a820SAlexander V. Chernikov 
4344fb3a820SAlexander V. Chernikov 	ro.ro_prepend = linkhdr;
4354fb3a820SAlexander V. Chernikov 	ro.ro_plen = linkhdrsize;
4364fb3a820SAlexander V. Chernikov 	ro.ro_flags = 0;
4374fb3a820SAlexander V. Chernikov 
43864bf80ceSMatthew N. Dodd 	m->m_flags |= M_BCAST;
43986bd0491SAndre Oppermann 	m_clrprotoflags(m);	/* Avoid confusing lower layers. */
440a4c69b8bSBjoern A. Zeeb 	error = (*ifp->if_output)(ifp, m, &sa, &ro);
44154fc657dSGeorge V. Neville-Neil 	ARPSTAT_INC(txrequests);
442b25d74e0SBjoern A. Zeeb 	if (error) {
443b25d74e0SBjoern A. Zeeb 		ARPSTAT_INC(txerrors);
444a4c69b8bSBjoern A. Zeeb 		ARP_LOG(LOG_DEBUG, "Failed to send ARP packet on %s: %d\n",
445a4c69b8bSBjoern A. Zeeb 		    if_name(ifp), error);
446b25d74e0SBjoern A. Zeeb 	}
447a4c69b8bSBjoern A. Zeeb 	return (error);
448df8bae1dSRodney W. Grimes }
449df8bae1dSRodney W. Grimes 
450a4c69b8bSBjoern A. Zeeb void
451a4c69b8bSBjoern A. Zeeb arprequest(struct ifnet *ifp, const struct in_addr *sip,
452a4c69b8bSBjoern A. Zeeb     const struct in_addr *tip, u_char *enaddr)
453a4c69b8bSBjoern A. Zeeb {
454a4c69b8bSBjoern A. Zeeb 
455a4c69b8bSBjoern A. Zeeb 	(void) arprequest_internal(ifp, sip, tip, enaddr);
456a4c69b8bSBjoern A. Zeeb }
4574fb3a820SAlexander V. Chernikov 
458df8bae1dSRodney W. Grimes /*
459512e30efSAlexander V. Chernikov  * Resolve an IP address into an ethernet address - heavy version.
460512e30efSAlexander V. Chernikov  * Used internally by arpresolve().
461945aad9cSBjoern A. Zeeb  * We have already checked that we can't use an existing lle without
462945aad9cSBjoern A. Zeeb  * modification so we have to acquire an LLE_EXCLUSIVE lle lock.
463cd46a114SLuigi Rizzo  *
464945aad9cSBjoern A. Zeeb  * On success, desten and pflags are filled in and the function returns 0;
465cd46a114SLuigi Rizzo  * If the packet must be held pending resolution, we return EWOULDBLOCK
466cd46a114SLuigi Rizzo  * On other errors, we return the corresponding error code.
467b6ae6984SJulian Elischer  * Note that m_freem() handles NULL.
468df8bae1dSRodney W. Grimes  */
469512e30efSAlexander V. Chernikov static int
4704fb3a820SAlexander V. Chernikov arpresolve_full(struct ifnet *ifp, int is_gw, int flags, struct mbuf *m,
4716d768226SGeorge V. Neville-Neil 	const struct sockaddr *dst, u_char *desten, uint32_t *pflags,
4726d768226SGeorge V. Neville-Neil 	struct llentry **plle)
473df8bae1dSRodney W. Grimes {
4745a255516SAlexander V. Chernikov 	struct llentry *la = NULL, *la_tmp;
475e162ea60SGeorge V. Neville-Neil 	struct mbuf *curr = NULL;
476e162ea60SGeorge V. Neville-Neil 	struct mbuf *next = NULL;
477512e30efSAlexander V. Chernikov 	int error, renew;
4784fb3a820SAlexander V. Chernikov 	char *lladdr;
4794fb3a820SAlexander V. Chernikov 	int ll_len;
480df8bae1dSRodney W. Grimes 
481*b8a6e03fSGleb Smirnoff 	NET_EPOCH_ASSERT();
482*b8a6e03fSGleb Smirnoff 
48374860d4fSAlexander V. Chernikov 	if (pflags != NULL)
48474860d4fSAlexander V. Chernikov 		*pflags = 0;
4856d768226SGeorge V. Neville-Neil 	if (plle != NULL)
4866d768226SGeorge V. Neville-Neil 		*plle = NULL;
48774860d4fSAlexander V. Chernikov 
488*b8a6e03fSGleb Smirnoff 	if ((flags & LLE_CREATE) == 0)
489512e30efSAlexander V. Chernikov 		la = lla_lookup(LLTABLE(ifp), LLE_EXCLUSIVE, dst);
490512e30efSAlexander V. Chernikov 	if (la == NULL && (ifp->if_flags & (IFF_NOARP | IFF_STATICARP)) == 0) {
4915a255516SAlexander V. Chernikov 		la = lltable_alloc_entry(LLTABLE(ifp), 0, dst);
4921ed7bf1eSGleb Smirnoff 		if (la == NULL) {
4938144690aSEric van Gyzen 			char addrbuf[INET_ADDRSTRLEN];
4948144690aSEric van Gyzen 
4951ed7bf1eSGleb Smirnoff 			log(LOG_DEBUG,
496743c072aSAlan Somers 			    "arpresolve: can't allocate llinfo for %s on %s\n",
4978144690aSEric van Gyzen 			    inet_ntoa_r(SIN(dst)->sin_addr, addrbuf),
4988144690aSEric van Gyzen 			    if_name(ifp));
4995a255516SAlexander V. Chernikov 			m_freem(m);
5005a255516SAlexander V. Chernikov 			return (EINVAL);
5015a255516SAlexander V. Chernikov 		}
5025a255516SAlexander V. Chernikov 
5035a255516SAlexander V. Chernikov 		IF_AFDATA_WLOCK(ifp);
5045a255516SAlexander V. Chernikov 		LLE_WLOCK(la);
5055a255516SAlexander V. Chernikov 		la_tmp = lla_lookup(LLTABLE(ifp), LLE_EXCLUSIVE, dst);
5065a255516SAlexander V. Chernikov 		/* Prefer ANY existing lle over newly-created one */
5075a255516SAlexander V. Chernikov 		if (la_tmp == NULL)
5085a255516SAlexander V. Chernikov 			lltable_link_entry(LLTABLE(ifp), la);
5095a255516SAlexander V. Chernikov 		IF_AFDATA_WUNLOCK(ifp);
5105a255516SAlexander V. Chernikov 		if (la_tmp != NULL) {
5115a255516SAlexander V. Chernikov 			lltable_free_entry(LLTABLE(ifp), la);
5125a255516SAlexander V. Chernikov 			la = la_tmp;
5135a255516SAlexander V. Chernikov 		}
5145a255516SAlexander V. Chernikov 	}
5155a255516SAlexander V. Chernikov 	if (la == NULL) {
5161ed7bf1eSGleb Smirnoff 		m_freem(m);
5176e6b3f7cSQing Li 		return (EINVAL);
5181ed7bf1eSGleb Smirnoff 	}
519a20e2538SGleb Smirnoff 
5206e6b3f7cSQing Li 	if ((la->la_flags & LLE_VALID) &&
521a98c06f1SGleb Smirnoff 	    ((la->la_flags & LLE_STATIC) || la->la_expire > time_uptime)) {
5224fb3a820SAlexander V. Chernikov 		if (flags & LLE_ADDRONLY) {
5234fb3a820SAlexander V. Chernikov 			lladdr = la->ll_addr;
5244fb3a820SAlexander V. Chernikov 			ll_len = ifp->if_addrlen;
5254fb3a820SAlexander V. Chernikov 		} else {
5264fb3a820SAlexander V. Chernikov 			lladdr = la->r_linkdata;
5274fb3a820SAlexander V. Chernikov 			ll_len = la->r_hdrlen;
5284fb3a820SAlexander V. Chernikov 		}
5294fb3a820SAlexander V. Chernikov 		bcopy(lladdr, desten, ll_len);
530f8aee88fSAlexander V. Chernikov 
5311435dcd9SAlexander V. Chernikov 		/* Notify LLE code that the entry was used by datapath */
5321435dcd9SAlexander V. Chernikov 		llentry_mark_used(la);
53374860d4fSAlexander V. Chernikov 		if (pflags != NULL)
534f8aee88fSAlexander V. Chernikov 			*pflags = la->la_flags & (LLE_VALID|LLE_IFADDR);
5356d768226SGeorge V. Neville-Neil 		if (plle) {
5366d768226SGeorge V. Neville-Neil 			LLE_ADDREF(la);
5376d768226SGeorge V. Neville-Neil 			*plle = la;
5386d768226SGeorge V. Neville-Neil 		}
539f0516b3cSErmal Luçi 		LLE_WUNLOCK(la);
540f0516b3cSErmal Luçi 		return (0);
541df8bae1dSRodney W. Grimes 	}
5426e6b3f7cSQing Li 
543a98c06f1SGleb Smirnoff 	renew = (la->la_asked == 0 || la->la_expire != time_uptime);
54408aadfbbSJonathan Lemon 	/*
545df8bae1dSRodney W. Grimes 	 * There is an arptab entry, but no ethernet address
546e162ea60SGeorge V. Neville-Neil 	 * response yet.  Add the mbuf to the list, dropping
547e162ea60SGeorge V. Neville-Neil 	 * the oldest packet if we have exceeded the system
548e162ea60SGeorge V. Neville-Neil 	 * setting.
549df8bae1dSRodney W. Grimes 	 */
5506e6b3f7cSQing Li 	if (m != NULL) {
551e162ea60SGeorge V. Neville-Neil 		if (la->la_numheld >= V_arp_maxhold) {
55254fc657dSGeorge V. Neville-Neil 			if (la->la_hold != NULL) {
553e162ea60SGeorge V. Neville-Neil 				next = la->la_hold->m_nextpkt;
554df8bae1dSRodney W. Grimes 				m_freem(la->la_hold);
555e162ea60SGeorge V. Neville-Neil 				la->la_hold = next;
556e162ea60SGeorge V. Neville-Neil 				la->la_numheld--;
55754fc657dSGeorge V. Neville-Neil 				ARPSTAT_INC(dropped);
55854fc657dSGeorge V. Neville-Neil 			}
559e162ea60SGeorge V. Neville-Neil 		}
560e162ea60SGeorge V. Neville-Neil 		if (la->la_hold != NULL) {
561e162ea60SGeorge V. Neville-Neil 			curr = la->la_hold;
562e162ea60SGeorge V. Neville-Neil 			while (curr->m_nextpkt != NULL)
563e162ea60SGeorge V. Neville-Neil 				curr = curr->m_nextpkt;
564e162ea60SGeorge V. Neville-Neil 			curr->m_nextpkt = m;
565e162ea60SGeorge V. Neville-Neil 		} else
566df8bae1dSRodney W. Grimes 			la->la_hold = m;
567e162ea60SGeorge V. Neville-Neil 		la->la_numheld++;
5686e6b3f7cSQing Li 	}
569e1ff74c5SGleb Smirnoff 	/*
570e1ff74c5SGleb Smirnoff 	 * Return EWOULDBLOCK if we have tried less than arp_maxtries. It
571e1ff74c5SGleb Smirnoff 	 * will be masked by ether_output(). Return EHOSTDOWN/EHOSTUNREACH
572e1ff74c5SGleb Smirnoff 	 * if we have already sent arp_maxtries ARP requests. Retransmit the
573e1ff74c5SGleb Smirnoff 	 * ARP request, but not faster than one request per second.
574e1ff74c5SGleb Smirnoff 	 */
575603724d3SBjoern A. Zeeb 	if (la->la_asked < V_arp_maxtries)
576e1ff74c5SGleb Smirnoff 		error = EWOULDBLOCK;	/* First request. */
577e1ff74c5SGleb Smirnoff 	else
57874860d4fSAlexander V. Chernikov 		error = is_gw != 0 ? EHOSTUNREACH : EHOSTDOWN;
579e1ff74c5SGleb Smirnoff 
5806e6b3f7cSQing Li 	if (renew) {
581a4c69b8bSBjoern A. Zeeb 		int canceled, e;
582becba438SBjoern A. Zeeb 
5836e6b3f7cSQing Li 		LLE_ADDREF(la);
584a98c06f1SGleb Smirnoff 		la->la_expire = time_uptime;
5850447c136SAlexander V. Chernikov 		canceled = callout_reset(&la->lle_timer, hz * V_arpt_down,
586becba438SBjoern A. Zeeb 		    arptimer, la);
587becba438SBjoern A. Zeeb 		if (canceled)
588becba438SBjoern A. Zeeb 			LLE_REMREF(la);
58995ebcabeSMaxim Konovalov 		la->la_asked++;
5906e6b3f7cSQing Li 		LLE_WUNLOCK(la);
591a4c69b8bSBjoern A. Zeeb 		e = arprequest_internal(ifp, NULL, &SIN(dst)->sin_addr, NULL);
592a4c69b8bSBjoern A. Zeeb 		/*
593a4c69b8bSBjoern A. Zeeb 		 * Only overwrite 'error' in case of error; in case of success
594a4c69b8bSBjoern A. Zeeb 		 * the proper return value was already set above.
595a4c69b8bSBjoern A. Zeeb 		 */
596a4c69b8bSBjoern A. Zeeb 		if (e != 0)
597a4c69b8bSBjoern A. Zeeb 			return (e);
5986e6b3f7cSQing Li 		return (error);
5996e6b3f7cSQing Li 	}
600512e30efSAlexander V. Chernikov 
6016e6b3f7cSQing Li 	LLE_WUNLOCK(la);
602e1ff74c5SGleb Smirnoff 	return (error);
603df8bae1dSRodney W. Grimes }
604df8bae1dSRodney W. Grimes 
605df8bae1dSRodney W. Grimes /*
6064fb3a820SAlexander V. Chernikov  * Lookups link header based on an IP address.
607512e30efSAlexander V. Chernikov  * On input:
608512e30efSAlexander V. Chernikov  *    ifp is the interface we use
609512e30efSAlexander V. Chernikov  *    is_gw != 0 if @dst represents gateway to some destination
610512e30efSAlexander V. Chernikov  *    m is the mbuf. May be NULL if we don't have a packet.
611512e30efSAlexander V. Chernikov  *    dst is the next hop,
6124fb3a820SAlexander V. Chernikov  *    desten is the storage to put LL header.
613f8aee88fSAlexander V. Chernikov  *    flags returns subset of lle flags: LLE_VALID | LLE_IFADDR
614512e30efSAlexander V. Chernikov  *
6154fb3a820SAlexander V. Chernikov  * On success, full/partial link header and flags are filled in and
6164fb3a820SAlexander V. Chernikov  * the function returns 0.
617512e30efSAlexander V. Chernikov  * If the packet must be held pending resolution, we return EWOULDBLOCK
618512e30efSAlexander V. Chernikov  * On other errors, we return the corresponding error code.
619512e30efSAlexander V. Chernikov  * Note that m_freem() handles NULL.
620512e30efSAlexander V. Chernikov  */
621512e30efSAlexander V. Chernikov int
622512e30efSAlexander V. Chernikov arpresolve(struct ifnet *ifp, int is_gw, struct mbuf *m,
6236d768226SGeorge V. Neville-Neil 	const struct sockaddr *dst, u_char *desten, uint32_t *pflags,
6246d768226SGeorge V. Neville-Neil 	struct llentry **plle)
625512e30efSAlexander V. Chernikov {
62699d628d5SPedro F. Giffuni 	struct llentry *la = NULL;
627512e30efSAlexander V. Chernikov 
628*b8a6e03fSGleb Smirnoff 	NET_EPOCH_ASSERT();
629*b8a6e03fSGleb Smirnoff 
630512e30efSAlexander V. Chernikov 	if (pflags != NULL)
631512e30efSAlexander V. Chernikov 		*pflags = 0;
6326d768226SGeorge V. Neville-Neil 	if (plle != NULL)
6336d768226SGeorge V. Neville-Neil 		*plle = NULL;
634512e30efSAlexander V. Chernikov 
635512e30efSAlexander V. Chernikov 	if (m != NULL) {
636512e30efSAlexander V. Chernikov 		if (m->m_flags & M_BCAST) {
637512e30efSAlexander V. Chernikov 			/* broadcast */
638512e30efSAlexander V. Chernikov 			(void)memcpy(desten,
639512e30efSAlexander V. Chernikov 			    ifp->if_broadcastaddr, ifp->if_addrlen);
640512e30efSAlexander V. Chernikov 			return (0);
641512e30efSAlexander V. Chernikov 		}
642512e30efSAlexander V. Chernikov 		if (m->m_flags & M_MCAST) {
643512e30efSAlexander V. Chernikov 			/* multicast */
644512e30efSAlexander V. Chernikov 			ETHER_MAP_IP_MULTICAST(&SIN(dst)->sin_addr, desten);
645512e30efSAlexander V. Chernikov 			return (0);
646512e30efSAlexander V. Chernikov 		}
647512e30efSAlexander V. Chernikov 	}
648512e30efSAlexander V. Chernikov 
649ea17754cSMike Karels 	la = lla_lookup(LLTABLE(ifp), plle ? LLE_EXCLUSIVE : LLE_UNLOCKED, dst);
650f8aee88fSAlexander V. Chernikov 	if (la != NULL && (la->r_flags & RLLE_VALID) != 0) {
651f8aee88fSAlexander V. Chernikov 		/* Entry found, let's copy lle info */
6524fb3a820SAlexander V. Chernikov 		bcopy(la->r_linkdata, desten, la->r_hdrlen);
653512e30efSAlexander V. Chernikov 		if (pflags != NULL)
654f8aee88fSAlexander V. Chernikov 			*pflags = LLE_VALID | (la->r_flags & RLLE_IFADDR);
6551435dcd9SAlexander V. Chernikov 		/* Notify the LLE handling code that the entry was used. */
6561435dcd9SAlexander V. Chernikov 		llentry_mark_used(la);
657ea17754cSMike Karels 		if (plle) {
658ea17754cSMike Karels 			LLE_ADDREF(la);
659ea17754cSMike Karels 			*plle = la;
660ea17754cSMike Karels 			LLE_WUNLOCK(la);
661ea17754cSMike Karels 		}
662512e30efSAlexander V. Chernikov 		return (0);
663512e30efSAlexander V. Chernikov 	}
664ea17754cSMike Karels 	if (plle && la)
665ea17754cSMike Karels 		LLE_WUNLOCK(la);
666512e30efSAlexander V. Chernikov 
6674fb3a820SAlexander V. Chernikov 	return (arpresolve_full(ifp, is_gw, la == NULL ? LLE_CREATE : 0, m, dst,
6686d768226SGeorge V. Neville-Neil 	    desten, pflags, plle));
669512e30efSAlexander V. Chernikov }
670512e30efSAlexander V. Chernikov 
671512e30efSAlexander V. Chernikov /*
672df8bae1dSRodney W. Grimes  * Common length and type checks are done here,
673df8bae1dSRodney W. Grimes  * then the protocol-specific routine is called.
674df8bae1dSRodney W. Grimes  */
675885f1aa4SPoul-Henning Kamp static void
6761cafed39SJonathan Lemon arpintr(struct mbuf *m)
677df8bae1dSRodney W. Grimes {
6781cafed39SJonathan Lemon 	struct arphdr *ar;
679eec33ea0SAlexander V. Chernikov 	struct ifnet *ifp;
680deb6bda6SAlexander V. Chernikov 	char *layer;
681deb6bda6SAlexander V. Chernikov 	int hlen;
682df8bae1dSRodney W. Grimes 
683eec33ea0SAlexander V. Chernikov 	ifp = m->m_pkthdr.rcvif;
684eec33ea0SAlexander V. Chernikov 
68576ec7b2fSRobert Watson 	if (m->m_len < sizeof(struct arphdr) &&
68684365e2bSMatthew Dillon 	    ((m = m_pullup(m, sizeof(struct arphdr))) == NULL)) {
687eec33ea0SAlexander V. Chernikov 		ARP_LOG(LOG_NOTICE, "packet with short header received on %s\n",
688eec33ea0SAlexander V. Chernikov 		    if_name(ifp));
6891cafed39SJonathan Lemon 		return;
69076ec7b2fSRobert Watson 	}
69176ec7b2fSRobert Watson 	ar = mtod(m, struct arphdr *);
69276ec7b2fSRobert Watson 
693deb6bda6SAlexander V. Chernikov 	/* Check if length is sufficient */
69489bc0426SGleb Smirnoff 	if (m->m_len <  arphdr_len(ar)) {
69589bc0426SGleb Smirnoff 		m = m_pullup(m, arphdr_len(ar));
69689bc0426SGleb Smirnoff 		if (m == NULL) {
697eec33ea0SAlexander V. Chernikov 			ARP_LOG(LOG_NOTICE, "short packet received on %s\n",
698eec33ea0SAlexander V. Chernikov 			    if_name(ifp));
699deb6bda6SAlexander V. Chernikov 			return;
700deb6bda6SAlexander V. Chernikov 		}
701deb6bda6SAlexander V. Chernikov 		ar = mtod(m, struct arphdr *);
70289bc0426SGleb Smirnoff 	}
703deb6bda6SAlexander V. Chernikov 
704deb6bda6SAlexander V. Chernikov 	hlen = 0;
705deb6bda6SAlexander V. Chernikov 	layer = "";
706deb6bda6SAlexander V. Chernikov 	switch (ntohs(ar->ar_hrd)) {
707deb6bda6SAlexander V. Chernikov 	case ARPHRD_ETHER:
708deb6bda6SAlexander V. Chernikov 		hlen = ETHER_ADDR_LEN; /* RFC 826 */
709deb6bda6SAlexander V. Chernikov 		layer = "ethernet";
710deb6bda6SAlexander V. Chernikov 		break;
711deb6bda6SAlexander V. Chernikov 	case ARPHRD_INFINIBAND:
712deb6bda6SAlexander V. Chernikov 		hlen = 20;	/* RFC 4391, INFINIBAND_ALEN */
713deb6bda6SAlexander V. Chernikov 		layer = "infiniband";
714deb6bda6SAlexander V. Chernikov 		break;
715deb6bda6SAlexander V. Chernikov 	case ARPHRD_IEEE1394:
716deb6bda6SAlexander V. Chernikov 		hlen = 0; /* SHALL be 16 */ /* RFC 2734 */
717deb6bda6SAlexander V. Chernikov 		layer = "firewire";
718deb6bda6SAlexander V. Chernikov 
719deb6bda6SAlexander V. Chernikov 		/*
720ddb13598SKevin Lo 		 * Restrict too long hardware addresses.
721deb6bda6SAlexander V. Chernikov 		 * Currently we are capable of handling 20-byte
722deb6bda6SAlexander V. Chernikov 		 * addresses ( sizeof(lle->ll_addr) )
723deb6bda6SAlexander V. Chernikov 		 */
724deb6bda6SAlexander V. Chernikov 		if (ar->ar_hln >= 20)
725deb6bda6SAlexander V. Chernikov 			hlen = 16;
726deb6bda6SAlexander V. Chernikov 		break;
727deb6bda6SAlexander V. Chernikov 	default:
728eec33ea0SAlexander V. Chernikov 		ARP_LOG(LOG_NOTICE,
729ddb13598SKevin Lo 		    "packet with unknown hardware format 0x%02d received on "
730ddb13598SKevin Lo 		    "%s\n", ntohs(ar->ar_hrd), if_name(ifp));
73176ec7b2fSRobert Watson 		m_freem(m);
7321cafed39SJonathan Lemon 		return;
73376ec7b2fSRobert Watson 	}
73476ec7b2fSRobert Watson 
735deb6bda6SAlexander V. Chernikov 	if (hlen != 0 && hlen != ar->ar_hln) {
736eec33ea0SAlexander V. Chernikov 		ARP_LOG(LOG_NOTICE,
737eec33ea0SAlexander V. Chernikov 		    "packet with invalid %s address length %d received on %s\n",
738eec33ea0SAlexander V. Chernikov 		    layer, ar->ar_hln, if_name(ifp));
73976ec7b2fSRobert Watson 		m_freem(m);
7401cafed39SJonathan Lemon 		return;
74176ec7b2fSRobert Watson 	}
742df8bae1dSRodney W. Grimes 
74354fc657dSGeorge V. Neville-Neil 	ARPSTAT_INC(received);
744df8bae1dSRodney W. Grimes 	switch (ntohs(ar->ar_pro)) {
7451d5e9e22SEivind Eklund #ifdef INET
746df8bae1dSRodney W. Grimes 	case ETHERTYPE_IP:
747df8bae1dSRodney W. Grimes 		in_arpinput(m);
7481cafed39SJonathan Lemon 		return;
7491d5e9e22SEivind Eklund #endif
750df8bae1dSRodney W. Grimes 	}
751df8bae1dSRodney W. Grimes 	m_freem(m);
752df8bae1dSRodney W. Grimes }
753df8bae1dSRodney W. Grimes 
7541d5e9e22SEivind Eklund #ifdef INET
755df8bae1dSRodney W. Grimes /*
756df8bae1dSRodney W. Grimes  * ARP for Internet protocols on 10 Mb/s Ethernet.
757df8bae1dSRodney W. Grimes  * Algorithm is that given in RFC 826.
758df8bae1dSRodney W. Grimes  * In addition, a sanity check is performed on the sender
759df8bae1dSRodney W. Grimes  * protocol address, to catch impersonators.
760df8bae1dSRodney W. Grimes  * We no longer handle negotiations for use of trailer protocol:
761df8bae1dSRodney W. Grimes  * Formerly, ARP replied for protocol type ETHERTYPE_TRAIL sent
762df8bae1dSRodney W. Grimes  * along with IP replies if we wanted trailers sent to us,
763df8bae1dSRodney W. Grimes  * and also sent them in response to IP replies.
764df8bae1dSRodney W. Grimes  * This allowed either end to announce the desire to receive
765df8bae1dSRodney W. Grimes  * trailer packets.
766df8bae1dSRodney W. Grimes  * We no longer reply to requests for ETHERTYPE_TRAIL protocol either,
767df8bae1dSRodney W. Grimes  * but formerly didn't normally send requests.
768df8bae1dSRodney W. Grimes  */
7693269187dSAlfred Perlstein static int log_arp_wrong_iface = 1;
770e3d123d6SAlfred Perlstein static int log_arp_movements = 1;
77139393906SGleb Smirnoff static int log_arp_permanent_modify = 1;
772478df1d5SGleb Smirnoff static int allow_multicast = 0;
7733269187dSAlfred Perlstein 
7743269187dSAlfred Perlstein SYSCTL_INT(_net_link_ether_inet, OID_AUTO, log_arp_wrong_iface, CTLFLAG_RW,
7753269187dSAlfred Perlstein 	&log_arp_wrong_iface, 0,
7763269187dSAlfred Perlstein 	"log arp packets arriving on the wrong interface");
777e3d123d6SAlfred Perlstein SYSCTL_INT(_net_link_ether_inet, OID_AUTO, log_arp_movements, CTLFLAG_RW,
778e3d123d6SAlfred Perlstein 	&log_arp_movements, 0,
77975ce3221SAlfred Perlstein 	"log arp replies from MACs different than the one in the cache");
78039393906SGleb Smirnoff SYSCTL_INT(_net_link_ether_inet, OID_AUTO, log_arp_permanent_modify, CTLFLAG_RW,
78139393906SGleb Smirnoff 	&log_arp_permanent_modify, 0,
78239393906SGleb Smirnoff 	"log arp replies from MACs different than the one in the permanent arp entry");
783478df1d5SGleb Smirnoff SYSCTL_INT(_net_link_ether_inet, OID_AUTO, allow_multicast, CTLFLAG_RW,
784478df1d5SGleb Smirnoff 	&allow_multicast, 0, "accept multicast addresses");
7853269187dSAlfred Perlstein 
786df8bae1dSRodney W. Grimes static void
787f2565d68SRobert Watson in_arpinput(struct mbuf *m)
788df8bae1dSRodney W. Grimes {
789cc0a3c8cSAndrey V. Elsukov 	struct rm_priotracker in_ifa_tracker;
790e952fa39SMatthew N. Dodd 	struct arphdr *ah;
791e952fa39SMatthew N. Dodd 	struct ifnet *ifp = m->m_pkthdr.rcvif;
7925a255516SAlexander V. Chernikov 	struct llentry *la = NULL, *la_tmp;
793ca925d9cSJonathan Lemon 	struct ifaddr *ifa;
794ca925d9cSJonathan Lemon 	struct in_ifaddr *ia;
795df8bae1dSRodney W. Grimes 	struct sockaddr sa;
796df8bae1dSRodney W. Grimes 	struct in_addr isaddr, itaddr, myaddr;
797a9771948SGleb Smirnoff 	u_int8_t *enaddr = NULL;
798f3bfa7d1SAlexander V. Chernikov 	int op;
79980b11ee4SPhilip Paeps 	int bridged = 0, is_bridge = 0;
800f3bfa7d1SAlexander V. Chernikov 	int carped;
8018e7e854cSKip Macy 	struct sockaddr_in sin;
8025a255516SAlexander V. Chernikov 	struct sockaddr *dst;
8039977be4aSAlexander V. Chernikov 	struct nhop4_basic nh4;
8044fb3a820SAlexander V. Chernikov 	uint8_t linkhdr[LLE_MAX_LINKHDR];
8054fb3a820SAlexander V. Chernikov 	struct route ro;
8064fb3a820SAlexander V. Chernikov 	size_t linkhdrsize;
8074fb3a820SAlexander V. Chernikov 	int lladdr_off;
8084fb3a820SAlexander V. Chernikov 	int error;
8098144690aSEric van Gyzen 	char addrbuf[INET_ADDRSTRLEN];
810*b8a6e03fSGleb Smirnoff 
811*b8a6e03fSGleb Smirnoff 	NET_EPOCH_ASSERT();
8129977be4aSAlexander V. Chernikov 
8138e7e854cSKip Macy 	sin.sin_len = sizeof(struct sockaddr_in);
8148e7e854cSKip Macy 	sin.sin_family = AF_INET;
81529910a5aSKip Macy 	sin.sin_addr.s_addr = 0;
816df8bae1dSRodney W. Grimes 
81774948aa6SAndrew Thompson 	if (ifp->if_bridge)
8188f867517SAndrew Thompson 		bridged = 1;
81980b11ee4SPhilip Paeps 	if (ifp->if_type == IFT_BRIDGE)
82080b11ee4SPhilip Paeps 		is_bridge = 1;
8218f867517SAndrew Thompson 
822eec33ea0SAlexander V. Chernikov 	/*
823eec33ea0SAlexander V. Chernikov 	 * We already have checked that mbuf contains enough contiguous data
824eec33ea0SAlexander V. Chernikov 	 * to hold entire arp message according to the arp header.
825eec33ea0SAlexander V. Chernikov 	 */
826322dcb8dSMax Khon 	ah = mtod(m, struct arphdr *);
827eec33ea0SAlexander V. Chernikov 
82809d3f895SGeorge V. Neville-Neil 	/*
82909d3f895SGeorge V. Neville-Neil 	 * ARP is only for IPv4 so we can reject packets with
83009d3f895SGeorge V. Neville-Neil 	 * a protocol length not equal to an IPv4 address.
83109d3f895SGeorge V. Neville-Neil 	 */
83209d3f895SGeorge V. Neville-Neil 	if (ah->ar_pln != sizeof(struct in_addr)) {
8335d81d095SGleb Smirnoff 		ARP_LOG(LOG_NOTICE, "requested protocol length != %zu\n",
83409d3f895SGeorge V. Neville-Neil 		    sizeof(struct in_addr));
835414676baSGleb Smirnoff 		goto drop;
83609d3f895SGeorge V. Neville-Neil 	}
83709d3f895SGeorge V. Neville-Neil 
838478df1d5SGleb Smirnoff 	if (allow_multicast == 0 && ETHER_IS_MULTICAST(ar_sha(ah))) {
8395d81d095SGleb Smirnoff 		ARP_LOG(LOG_NOTICE, "%*D is multicast\n",
840c9168718SGleb Smirnoff 		    ifp->if_addrlen, (u_char *)ar_sha(ah), ":");
841414676baSGleb Smirnoff 		goto drop;
84209d3f895SGeorge V. Neville-Neil 	}
84309d3f895SGeorge V. Neville-Neil 
844322dcb8dSMax Khon 	op = ntohs(ah->ar_op);
845322dcb8dSMax Khon 	(void)memcpy(&isaddr, ar_spa(ah), sizeof (isaddr));
846322dcb8dSMax Khon 	(void)memcpy(&itaddr, ar_tpa(ah), sizeof (itaddr));
84732439868SGleb Smirnoff 
84854fc657dSGeorge V. Neville-Neil 	if (op == ARPOP_REPLY)
84954fc657dSGeorge V. Neville-Neil 		ARPSTAT_INC(rxreplies);
85054fc657dSGeorge V. Neville-Neil 
851ca925d9cSJonathan Lemon 	/*
852ca925d9cSJonathan Lemon 	 * For a bridge, we want to check the address irrespective
853ca925d9cSJonathan Lemon 	 * of the receive interface. (This will change slightly
854ca925d9cSJonathan Lemon 	 * when we have clusters of interfaces).
855ca925d9cSJonathan Lemon 	 */
856cc0a3c8cSAndrey V. Elsukov 	IN_IFADDR_RLOCK(&in_ifa_tracker);
8572ef4a436SGleb Smirnoff 	LIST_FOREACH(ia, INADDR_HASH(itaddr.s_addr), ia_hash) {
85896561547SAndrew Thompson 		if (((bridged && ia->ia_ifp->if_bridge == ifp->if_bridge) ||
8596e6b3f7cSQing Li 		    ia->ia_ifp == ifp) &&
86008b68b0eSGleb Smirnoff 		    itaddr.s_addr == ia->ia_addr.sin_addr.s_addr &&
86108b68b0eSGleb Smirnoff 		    (ia->ia_ifa.ifa_carp == NULL ||
86208b68b0eSGleb Smirnoff 		    (*carp_iamatch_p)(&ia->ia_ifa, &enaddr))) {
86309d54778SRobert Watson 			ifa_ref(&ia->ia_ifa);
864cc0a3c8cSAndrey V. Elsukov 			IN_IFADDR_RUNLOCK(&in_ifa_tracker);
8652ef4a436SGleb Smirnoff 			goto match;
8662ef4a436SGleb Smirnoff 		}
8672ef4a436SGleb Smirnoff 	}
868ca925d9cSJonathan Lemon 	LIST_FOREACH(ia, INADDR_HASH(isaddr.s_addr), ia_hash)
86996561547SAndrew Thompson 		if (((bridged && ia->ia_ifp->if_bridge == ifp->if_bridge) ||
8706e6b3f7cSQing Li 		    ia->ia_ifp == ifp) &&
87109d54778SRobert Watson 		    isaddr.s_addr == ia->ia_addr.sin_addr.s_addr) {
87209d54778SRobert Watson 			ifa_ref(&ia->ia_ifa);
873cc0a3c8cSAndrey V. Elsukov 			IN_IFADDR_RUNLOCK(&in_ifa_tracker);
874ca925d9cSJonathan Lemon 			goto match;
87509d54778SRobert Watson 		}
87680b11ee4SPhilip Paeps 
87780b11ee4SPhilip Paeps #define BDG_MEMBER_MATCHES_ARP(addr, ifp, ia)				\
87880b11ee4SPhilip Paeps   (ia->ia_ifp->if_bridge == ifp->if_softc &&				\
87980b11ee4SPhilip Paeps   !bcmp(IF_LLADDR(ia->ia_ifp), IF_LLADDR(ifp), ifp->if_addrlen) &&	\
88080b11ee4SPhilip Paeps   addr == ia->ia_addr.sin_addr.s_addr)
88180b11ee4SPhilip Paeps 	/*
88280b11ee4SPhilip Paeps 	 * Check the case when bridge shares its MAC address with
88380b11ee4SPhilip Paeps 	 * some of its children, so packets are claimed by bridge
88480b11ee4SPhilip Paeps 	 * itself (bridge_input() does it first), but they are really
88580b11ee4SPhilip Paeps 	 * meant to be destined to the bridge member.
88680b11ee4SPhilip Paeps 	 */
88780b11ee4SPhilip Paeps 	if (is_bridge) {
88880b11ee4SPhilip Paeps 		LIST_FOREACH(ia, INADDR_HASH(itaddr.s_addr), ia_hash) {
88980b11ee4SPhilip Paeps 			if (BDG_MEMBER_MATCHES_ARP(itaddr.s_addr, ifp, ia)) {
89009d54778SRobert Watson 				ifa_ref(&ia->ia_ifa);
89180b11ee4SPhilip Paeps 				ifp = ia->ia_ifp;
892cc0a3c8cSAndrey V. Elsukov 				IN_IFADDR_RUNLOCK(&in_ifa_tracker);
89380b11ee4SPhilip Paeps 				goto match;
89480b11ee4SPhilip Paeps 			}
89580b11ee4SPhilip Paeps 		}
89680b11ee4SPhilip Paeps 	}
89780b11ee4SPhilip Paeps #undef BDG_MEMBER_MATCHES_ARP
898cc0a3c8cSAndrey V. Elsukov 	IN_IFADDR_RUNLOCK(&in_ifa_tracker);
89980b11ee4SPhilip Paeps 
900ca925d9cSJonathan Lemon 	/*
901d8b84d9eSJonathan Lemon 	 * No match, use the first inet address on the receive interface
902ca925d9cSJonathan Lemon 	 * as a dummy address for the rest of the function.
903ca925d9cSJonathan Lemon 	 */
904d7c5a620SMatt Macy 	CK_STAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link)
9059de96e89SGleb Smirnoff 		if (ifa->ifa_addr->sa_family == AF_INET &&
9069de96e89SGleb Smirnoff 		    (ifa->ifa_carp == NULL ||
9079de96e89SGleb Smirnoff 		    (*carp_iamatch_p)(ifa, &enaddr))) {
908ec691a10SJonathan Lemon 			ia = ifatoia(ifa);
90909d54778SRobert Watson 			ifa_ref(ifa);
910ec691a10SJonathan Lemon 			goto match;
911ec691a10SJonathan Lemon 		}
91209d54778SRobert Watson 
913ec691a10SJonathan Lemon 	/*
914ec691a10SJonathan Lemon 	 * If bridging, fall back to using any inet address.
915ec691a10SJonathan Lemon 	 */
916cc0a3c8cSAndrey V. Elsukov 	IN_IFADDR_RLOCK(&in_ifa_tracker);
917d7c5a620SMatt Macy 	if (!bridged || (ia = CK_STAILQ_FIRST(&V_in_ifaddrhead)) == NULL) {
918cc0a3c8cSAndrey V. Elsukov 		IN_IFADDR_RUNLOCK(&in_ifa_tracker);
919b2a8ac7cSLuigi Rizzo 		goto drop;
9202d9cfabaSRobert Watson 	}
92109d54778SRobert Watson 	ifa_ref(&ia->ia_ifa);
922cc0a3c8cSAndrey V. Elsukov 	IN_IFADDR_RUNLOCK(&in_ifa_tracker);
923ca925d9cSJonathan Lemon match:
924a9771948SGleb Smirnoff 	if (!enaddr)
925a9771948SGleb Smirnoff 		enaddr = (u_int8_t *)IF_LLADDR(ifp);
92608b68b0eSGleb Smirnoff 	carped = (ia->ia_ifa.ifa_carp != NULL);
927ca925d9cSJonathan Lemon 	myaddr = ia->ia_addr.sin_addr;
92809d54778SRobert Watson 	ifa_free(&ia->ia_ifa);
929a9771948SGleb Smirnoff 	if (!bcmp(ar_sha(ah), enaddr, ifp->if_addrlen))
930b2a8ac7cSLuigi Rizzo 		goto drop;	/* it's from me, ignore it. */
931322dcb8dSMax Khon 	if (!bcmp(ar_sha(ah), ifp->if_broadcastaddr, ifp->if_addrlen)) {
9325d81d095SGleb Smirnoff 		ARP_LOG(LOG_NOTICE, "link address is broadcast for IP address "
9338144690aSEric van Gyzen 		    "%s!\n", inet_ntoa_r(isaddr, addrbuf));
934b2a8ac7cSLuigi Rizzo 		goto drop;
935df8bae1dSRodney W. Grimes 	}
936f3bfa7d1SAlexander V. Chernikov 
937f3bfa7d1SAlexander V. Chernikov 	if (ifp->if_addrlen != ah->ar_hln) {
938f3bfa7d1SAlexander V. Chernikov 		ARP_LOG(LOG_WARNING, "from %*D: addr len: new %d, "
939f3bfa7d1SAlexander V. Chernikov 		    "i/f %d (ignored)\n", ifp->if_addrlen,
940f3bfa7d1SAlexander V. Chernikov 		    (u_char *) ar_sha(ah), ":", ah->ar_hln,
941f3bfa7d1SAlexander V. Chernikov 		    ifp->if_addrlen);
942f3bfa7d1SAlexander V. Chernikov 		goto drop;
943f3bfa7d1SAlexander V. Chernikov 	}
944f3bfa7d1SAlexander V. Chernikov 
94500fcf9d1SRobert Watson 	/*
94600fcf9d1SRobert Watson 	 * Warn if another host is using the same IP address, but only if the
94700fcf9d1SRobert Watson 	 * IP address isn't 0.0.0.0, which is used for DHCP only, in which
94800fcf9d1SRobert Watson 	 * case we suppress the warning to avoid false positive complaints of
94900fcf9d1SRobert Watson 	 * potential misconfiguration.
95000fcf9d1SRobert Watson 	 */
95108b68b0eSGleb Smirnoff 	if (!bridged && !carped && isaddr.s_addr == myaddr.s_addr &&
95208b68b0eSGleb Smirnoff 	    myaddr.s_addr != 0) {
9535d81d095SGleb Smirnoff 		ARP_LOG(LOG_ERR, "%*D is using my IP address %s on %s!\n",
954322dcb8dSMax Khon 		   ifp->if_addrlen, (u_char *)ar_sha(ah), ":",
9558144690aSEric van Gyzen 		   inet_ntoa_r(isaddr, addrbuf), ifp->if_xname);
956df8bae1dSRodney W. Grimes 		itaddr = myaddr;
95754fc657dSGeorge V. Neville-Neil 		ARPSTAT_INC(dupips);
958df8bae1dSRodney W. Grimes 		goto reply;
959df8bae1dSRodney W. Grimes 	}
960deb62e28SRuslan Ermilov 	if (ifp->if_flags & IFF_STATICARP)
961deb62e28SRuslan Ermilov 		goto reply;
9628b07e49aSJulian Elischer 
9636e6b3f7cSQing Li 	bzero(&sin, sizeof(sin));
9646e6b3f7cSQing Li 	sin.sin_len = sizeof(struct sockaddr_in);
9656e6b3f7cSQing Li 	sin.sin_family = AF_INET;
9666e6b3f7cSQing Li 	sin.sin_addr = isaddr;
9675a255516SAlexander V. Chernikov 	dst = (struct sockaddr *)&sin;
9685a255516SAlexander V. Chernikov 	la = lla_lookup(LLTABLE(ifp), LLE_EXCLUSIVE, dst);
969f3bfa7d1SAlexander V. Chernikov 	if (la != NULL)
970f3bfa7d1SAlexander V. Chernikov 		arp_check_update_lle(ah, isaddr, ifp, bridged, la);
971f3bfa7d1SAlexander V. Chernikov 	else if (itaddr.s_addr == myaddr.s_addr) {
972e162ea60SGeorge V. Neville-Neil 		/*
973942e4b4bSAlexander V. Chernikov 		 * Request/reply to our address, but no lle exists yet.
9744fb3a820SAlexander V. Chernikov 		 * Calculate full link prepend to use in lle.
975e162ea60SGeorge V. Neville-Neil 		 */
9764fb3a820SAlexander V. Chernikov 		linkhdrsize = sizeof(linkhdr);
9774fb3a820SAlexander V. Chernikov 		if (lltable_calc_llheader(ifp, AF_INET, ar_sha(ah), linkhdr,
9784fb3a820SAlexander V. Chernikov 		    &linkhdrsize, &lladdr_off) != 0)
9794fb3a820SAlexander V. Chernikov 			goto reply;
9804fb3a820SAlexander V. Chernikov 
9814fb3a820SAlexander V. Chernikov 		/* Allocate new entry */
9825a255516SAlexander V. Chernikov 		la = lltable_alloc_entry(LLTABLE(ifp), 0, dst);
983942e4b4bSAlexander V. Chernikov 		if (la == NULL) {
984942e4b4bSAlexander V. Chernikov 
985942e4b4bSAlexander V. Chernikov 			/*
986942e4b4bSAlexander V. Chernikov 			 * lle creation may fail if source address belongs
987942e4b4bSAlexander V. Chernikov 			 * to non-directly connected subnet. However, we
988942e4b4bSAlexander V. Chernikov 			 * will try to answer the request instead of dropping
989942e4b4bSAlexander V. Chernikov 			 * frame.
990942e4b4bSAlexander V. Chernikov 			 */
991942e4b4bSAlexander V. Chernikov 			goto reply;
992942e4b4bSAlexander V. Chernikov 		}
9934fb3a820SAlexander V. Chernikov 		lltable_set_entry_addr(ifp, la, linkhdr, linkhdrsize,
9944fb3a820SAlexander V. Chernikov 		    lladdr_off);
9955a255516SAlexander V. Chernikov 
9965a255516SAlexander V. Chernikov 		IF_AFDATA_WLOCK(ifp);
9975a255516SAlexander V. Chernikov 		LLE_WLOCK(la);
9985a255516SAlexander V. Chernikov 		la_tmp = lla_lookup(LLTABLE(ifp), LLE_EXCLUSIVE, dst);
9995a255516SAlexander V. Chernikov 
10005a255516SAlexander V. Chernikov 		/*
10015a255516SAlexander V. Chernikov 		 * Check if lle still does not exists.
10025a255516SAlexander V. Chernikov 		 * If it does, that means that we either
10035a255516SAlexander V. Chernikov 		 * 1) have configured it explicitly, via
10045a255516SAlexander V. Chernikov 		 * 1a) 'arp -s' static entry or
10055a255516SAlexander V. Chernikov 		 * 1b) interface address static record
10065a255516SAlexander V. Chernikov 		 * or
10075a255516SAlexander V. Chernikov 		 * 2) it was the result of sending first packet to-host
10085a255516SAlexander V. Chernikov 		 * or
10095a255516SAlexander V. Chernikov 		 * 3) it was another arp reply packet we handled in
10105a255516SAlexander V. Chernikov 		 * different thread.
10115a255516SAlexander V. Chernikov 		 *
10125a255516SAlexander V. Chernikov 		 * In all cases except 3) we definitely need to prefer
10135a255516SAlexander V. Chernikov 		 * existing lle. For the sake of simplicity, prefer any
10145a255516SAlexander V. Chernikov 		 * existing lle over newly-create one.
10155a255516SAlexander V. Chernikov 		 */
10165a255516SAlexander V. Chernikov 		if (la_tmp == NULL)
10175a255516SAlexander V. Chernikov 			lltable_link_entry(LLTABLE(ifp), la);
1018f3bfa7d1SAlexander V. Chernikov 		IF_AFDATA_WUNLOCK(ifp);
10195a255516SAlexander V. Chernikov 
10205a255516SAlexander V. Chernikov 		if (la_tmp == NULL) {
1021f3bfa7d1SAlexander V. Chernikov 			arp_mark_lle_reachable(la);
1022e162ea60SGeorge V. Neville-Neil 			LLE_WUNLOCK(la);
10235a255516SAlexander V. Chernikov 		} else {
10245a255516SAlexander V. Chernikov 			/* Free newly-create entry and handle packet */
10255a255516SAlexander V. Chernikov 			lltable_free_entry(LLTABLE(ifp), la);
10265a255516SAlexander V. Chernikov 			la = la_tmp;
10275a255516SAlexander V. Chernikov 			la_tmp = NULL;
10285a255516SAlexander V. Chernikov 			arp_check_update_lle(ah, isaddr, ifp, bridged, la);
10295a255516SAlexander V. Chernikov 			/* arp_check_update_lle() returns @la unlocked */
1030f4048639SBjoern A. Zeeb 		}
10315a255516SAlexander V. Chernikov 		la = NULL;
1032a4141c63SAlexander V. Chernikov 	}
10336e6b3f7cSQing Li reply:
1034b2a8ac7cSLuigi Rizzo 	if (op != ARPOP_REQUEST)
1035b2a8ac7cSLuigi Rizzo 		goto drop;
103654fc657dSGeorge V. Neville-Neil 	ARPSTAT_INC(rxrequests);
10376e6b3f7cSQing Li 
1038df8bae1dSRodney W. Grimes 	if (itaddr.s_addr == myaddr.s_addr) {
10398b07e49aSJulian Elischer 		/* Shortcut.. the receiving interface is the target. */
1040322dcb8dSMax Khon 		(void)memcpy(ar_tha(ah), ar_sha(ah), ah->ar_hln);
1041a9771948SGleb Smirnoff 		(void)memcpy(ar_sha(ah), enaddr, ah->ar_hln);
1042df8bae1dSRodney W. Grimes 	} else {
1043897d75c9SQing Li 		struct llentry *lle = NULL;
1044897d75c9SQing Li 
1045cd29a779SQing Li 		sin.sin_addr = itaddr;
1046cd29a779SQing Li 		lle = lla_lookup(LLTABLE(ifp), 0, (struct sockaddr *)&sin);
1047cd29a779SQing Li 
1048cd29a779SQing Li 		if ((lle != NULL) && (lle->la_flags & LLE_PUB)) {
1049cd29a779SQing Li 			(void)memcpy(ar_tha(ah), ar_sha(ah), ah->ar_hln);
10504fb3a820SAlexander V. Chernikov 			(void)memcpy(ar_sha(ah), lle->ll_addr, ah->ar_hln);
1051cd29a779SQing Li 			LLE_RUNLOCK(lle);
1052cd29a779SQing Li 		} else {
1053cd29a779SQing Li 
1054cd29a779SQing Li 			if (lle != NULL)
1055cd29a779SQing Li 				LLE_RUNLOCK(lle);
1056cd29a779SQing Li 
1057603724d3SBjoern A. Zeeb 			if (!V_arp_proxyall)
1058b2a8ac7cSLuigi Rizzo 				goto drop;
105928e82295SGarrett Wollman 
10608b07e49aSJulian Elischer 			/* XXX MRT use table 0 for arp reply  */
10619977be4aSAlexander V. Chernikov 			if (fib4_lookup_nh_basic(0, itaddr, 0, 0, &nh4) != 0)
1062b2a8ac7cSLuigi Rizzo 				goto drop;
1063897d75c9SQing Li 
106428e82295SGarrett Wollman 			/*
106528e82295SGarrett Wollman 			 * Don't send proxies for nodes on the same interface
106628e82295SGarrett Wollman 			 * as this one came out of, or we'll get into a fight
106728e82295SGarrett Wollman 			 * over who claims what Ether address.
106828e82295SGarrett Wollman 			 */
10699977be4aSAlexander V. Chernikov 			if (nh4.nh_ifp == ifp)
1070b2a8ac7cSLuigi Rizzo 				goto drop;
1071cc728227SDavid Malone 
1072897d75c9SQing Li 			(void)memcpy(ar_tha(ah), ar_sha(ah), ah->ar_hln);
1073cd29a779SQing Li 			(void)memcpy(ar_sha(ah), enaddr, ah->ar_hln);
1074897d75c9SQing Li 
1075cc728227SDavid Malone 			/*
1076cc728227SDavid Malone 			 * Also check that the node which sent the ARP packet
10776bccea7cSRebecca Cran 			 * is on the interface we expect it to be on. This
1078cc728227SDavid Malone 			 * avoids ARP chaos if an interface is connected to the
1079cc728227SDavid Malone 			 * wrong network.
1080cc728227SDavid Malone 			 */
1081cc728227SDavid Malone 
10828b07e49aSJulian Elischer 			/* XXX MRT use table 0 for arp checks */
10839977be4aSAlexander V. Chernikov 			if (fib4_lookup_nh_basic(0, isaddr, 0, 0, &nh4) != 0)
1084b2a8ac7cSLuigi Rizzo 				goto drop;
10859977be4aSAlexander V. Chernikov 			if (nh4.nh_ifp != ifp) {
10865d81d095SGleb Smirnoff 				ARP_LOG(LOG_INFO, "proxy: ignoring request"
10879977be4aSAlexander V. Chernikov 				    " from %s via %s\n",
10888144690aSEric van Gyzen 				    inet_ntoa_r(isaddr, addrbuf),
10898144690aSEric van Gyzen 				    ifp->if_xname);
1090b2a8ac7cSLuigi Rizzo 				goto drop;
1091cc728227SDavid Malone 			}
1092cc728227SDavid Malone 
1093ac234f93SGarrett Wollman #ifdef DEBUG_PROXY
10948144690aSEric van Gyzen 			printf("arp: proxying for %s\n",
10958144690aSEric van Gyzen 			    inet_ntoa_r(itaddr, addrbuf));
1096ac234f93SGarrett Wollman #endif
1097df8bae1dSRodney W. Grimes 		}
1098cd29a779SQing Li 	}
1099df8bae1dSRodney W. Grimes 
1100d0558157SBruce M Simpson 	if (itaddr.s_addr == myaddr.s_addr &&
1101d0558157SBruce M Simpson 	    IN_LINKLOCAL(ntohl(itaddr.s_addr))) {
1102d0558157SBruce M Simpson 		/* RFC 3927 link-local IPv4; always reply by broadcast. */
1103d0558157SBruce M Simpson #ifdef DEBUG_LINKLOCAL
1104d0558157SBruce M Simpson 		printf("arp: sending reply for link-local addr %s\n",
11058144690aSEric van Gyzen 		    inet_ntoa_r(itaddr, addrbuf));
1106d0558157SBruce M Simpson #endif
1107d0558157SBruce M Simpson 		m->m_flags |= M_BCAST;
1108d0558157SBruce M Simpson 		m->m_flags &= ~M_MCAST;
1109d0558157SBruce M Simpson 	} else {
1110d0558157SBruce M Simpson 		/* default behaviour; never reply by broadcast. */
1111d0558157SBruce M Simpson 		m->m_flags &= ~(M_BCAST|M_MCAST);
1112d0558157SBruce M Simpson 	}
1113322dcb8dSMax Khon 	(void)memcpy(ar_tpa(ah), ar_spa(ah), ah->ar_pln);
1114322dcb8dSMax Khon 	(void)memcpy(ar_spa(ah), &itaddr, ah->ar_pln);
1115322dcb8dSMax Khon 	ah->ar_op = htons(ARPOP_REPLY);
1116322dcb8dSMax Khon 	ah->ar_pro = htons(ETHERTYPE_IP); /* let's be sure! */
111764bf80ceSMatthew N. Dodd 	m->m_len = sizeof(*ah) + (2 * ah->ar_pln) + (2 * ah->ar_hln);
111864bf80ceSMatthew N. Dodd 	m->m_pkthdr.len = m->m_len;
11192303570fSAndrey V. Elsukov 	m->m_pkthdr.rcvif = NULL;
112064bf80ceSMatthew N. Dodd 	sa.sa_family = AF_ARP;
112164bf80ceSMatthew N. Dodd 	sa.sa_len = 2;
11224fb3a820SAlexander V. Chernikov 
11234fb3a820SAlexander V. Chernikov 	/* Calculate link header for sending frame */
11244fb3a820SAlexander V. Chernikov 	bzero(&ro, sizeof(ro));
11254fb3a820SAlexander V. Chernikov 	linkhdrsize = sizeof(linkhdr);
11264fb3a820SAlexander V. Chernikov 	error = arp_fillheader(ifp, ah, 0, linkhdr, &linkhdrsize);
11274fb3a820SAlexander V. Chernikov 
11284fb3a820SAlexander V. Chernikov 	/*
11294fb3a820SAlexander V. Chernikov 	 * arp_fillheader() may fail due to lack of support inside encap request
11304fb3a820SAlexander V. Chernikov 	 * routing. This is not necessary an error, AF_ARP can/should be handled
11314fb3a820SAlexander V. Chernikov 	 * by if_output().
11324fb3a820SAlexander V. Chernikov 	 */
11334fb3a820SAlexander V. Chernikov 	if (error != 0 && error != EAFNOSUPPORT) {
11344fb3a820SAlexander V. Chernikov 		ARP_LOG(LOG_ERR, "Failed to calculate ARP header on %s: %d\n",
11354fb3a820SAlexander V. Chernikov 		    if_name(ifp), error);
11364fb3a820SAlexander V. Chernikov 		return;
11374fb3a820SAlexander V. Chernikov 	}
11384fb3a820SAlexander V. Chernikov 
11394fb3a820SAlexander V. Chernikov 	ro.ro_prepend = linkhdr;
11404fb3a820SAlexander V. Chernikov 	ro.ro_plen = linkhdrsize;
11414fb3a820SAlexander V. Chernikov 	ro.ro_flags = 0;
11424fb3a820SAlexander V. Chernikov 
114386bd0491SAndre Oppermann 	m_clrprotoflags(m);	/* Avoid confusing lower layers. */
11444fb3a820SAlexander V. Chernikov 	(*ifp->if_output)(ifp, m, &sa, &ro);
114554fc657dSGeorge V. Neville-Neil 	ARPSTAT_INC(txreplies);
1146df8bae1dSRodney W. Grimes 	return;
1147b2a8ac7cSLuigi Rizzo 
1148b2a8ac7cSLuigi Rizzo drop:
1149b2a8ac7cSLuigi Rizzo 	m_freem(m);
1150df8bae1dSRodney W. Grimes }
11511d5e9e22SEivind Eklund #endif
1152df8bae1dSRodney W. Grimes 
1153f3bfa7d1SAlexander V. Chernikov /*
1154f3bfa7d1SAlexander V. Chernikov  * Checks received arp data against existing @la.
1155f3bfa7d1SAlexander V. Chernikov  * Updates lle state/performs notification if necessary.
1156f3bfa7d1SAlexander V. Chernikov  */
1157f3bfa7d1SAlexander V. Chernikov static void
1158f3bfa7d1SAlexander V. Chernikov arp_check_update_lle(struct arphdr *ah, struct in_addr isaddr, struct ifnet *ifp,
1159f3bfa7d1SAlexander V. Chernikov     int bridged, struct llentry *la)
1160f3bfa7d1SAlexander V. Chernikov {
1161f3bfa7d1SAlexander V. Chernikov 	struct sockaddr sa;
1162f3bfa7d1SAlexander V. Chernikov 	struct mbuf *m_hold, *m_hold_next;
11634fb3a820SAlexander V. Chernikov 	uint8_t linkhdr[LLE_MAX_LINKHDR];
11644fb3a820SAlexander V. Chernikov 	size_t linkhdrsize;
11654fb3a820SAlexander V. Chernikov 	int lladdr_off;
11668144690aSEric van Gyzen 	char addrbuf[INET_ADDRSTRLEN];
1167f3bfa7d1SAlexander V. Chernikov 
1168f3bfa7d1SAlexander V. Chernikov 	LLE_WLOCK_ASSERT(la);
1169f3bfa7d1SAlexander V. Chernikov 
1170f3bfa7d1SAlexander V. Chernikov 	/* the following is not an error when doing bridging */
1171f3bfa7d1SAlexander V. Chernikov 	if (!bridged && la->lle_tbl->llt_ifp != ifp) {
1172f3bfa7d1SAlexander V. Chernikov 		if (log_arp_wrong_iface)
1173f3bfa7d1SAlexander V. Chernikov 			ARP_LOG(LOG_WARNING, "%s is on %s "
1174f3bfa7d1SAlexander V. Chernikov 			    "but got reply from %*D on %s\n",
11758144690aSEric van Gyzen 			    inet_ntoa_r(isaddr, addrbuf),
1176f3bfa7d1SAlexander V. Chernikov 			    la->lle_tbl->llt_ifp->if_xname,
1177f3bfa7d1SAlexander V. Chernikov 			    ifp->if_addrlen, (u_char *)ar_sha(ah), ":",
1178f3bfa7d1SAlexander V. Chernikov 			    ifp->if_xname);
1179f3bfa7d1SAlexander V. Chernikov 		LLE_WUNLOCK(la);
1180f3bfa7d1SAlexander V. Chernikov 		return;
1181f3bfa7d1SAlexander V. Chernikov 	}
1182f3bfa7d1SAlexander V. Chernikov 	if ((la->la_flags & LLE_VALID) &&
11834fb3a820SAlexander V. Chernikov 	    bcmp(ar_sha(ah), la->ll_addr, ifp->if_addrlen)) {
1184f3bfa7d1SAlexander V. Chernikov 		if (la->la_flags & LLE_STATIC) {
1185f3bfa7d1SAlexander V. Chernikov 			LLE_WUNLOCK(la);
1186f3bfa7d1SAlexander V. Chernikov 			if (log_arp_permanent_modify)
1187f3bfa7d1SAlexander V. Chernikov 				ARP_LOG(LOG_ERR,
1188f3bfa7d1SAlexander V. Chernikov 				    "%*D attempts to modify "
1189f3bfa7d1SAlexander V. Chernikov 				    "permanent entry for %s on %s\n",
1190f3bfa7d1SAlexander V. Chernikov 				    ifp->if_addrlen,
1191f3bfa7d1SAlexander V. Chernikov 				    (u_char *)ar_sha(ah), ":",
11928144690aSEric van Gyzen 				    inet_ntoa_r(isaddr, addrbuf),
11938144690aSEric van Gyzen 				    ifp->if_xname);
1194f3bfa7d1SAlexander V. Chernikov 			return;
1195f3bfa7d1SAlexander V. Chernikov 		}
1196f3bfa7d1SAlexander V. Chernikov 		if (log_arp_movements) {
1197f3bfa7d1SAlexander V. Chernikov 			ARP_LOG(LOG_INFO, "%s moved from %*D "
1198f3bfa7d1SAlexander V. Chernikov 			    "to %*D on %s\n",
11998144690aSEric van Gyzen 			    inet_ntoa_r(isaddr, addrbuf),
1200f3bfa7d1SAlexander V. Chernikov 			    ifp->if_addrlen,
120171949810SAndrey V. Elsukov 			    (u_char *)la->ll_addr, ":",
1202f3bfa7d1SAlexander V. Chernikov 			    ifp->if_addrlen, (u_char *)ar_sha(ah), ":",
1203f3bfa7d1SAlexander V. Chernikov 			    ifp->if_xname);
1204f3bfa7d1SAlexander V. Chernikov 		}
1205f3bfa7d1SAlexander V. Chernikov 	}
1206f3bfa7d1SAlexander V. Chernikov 
12074fb3a820SAlexander V. Chernikov 	/* Calculate full link prepend to use in lle */
12084fb3a820SAlexander V. Chernikov 	linkhdrsize = sizeof(linkhdr);
12094fb3a820SAlexander V. Chernikov 	if (lltable_calc_llheader(ifp, AF_INET, ar_sha(ah), linkhdr,
12104fb3a820SAlexander V. Chernikov 	    &linkhdrsize, &lladdr_off) != 0)
1211f3bfa7d1SAlexander V. Chernikov 		return;
1212f3bfa7d1SAlexander V. Chernikov 
12134fb3a820SAlexander V. Chernikov 	/* Check if something has changed */
12144fb3a820SAlexander V. Chernikov 	if (memcmp(la->r_linkdata, linkhdr, linkhdrsize) != 0 ||
12154fb3a820SAlexander V. Chernikov 	    (la->la_flags & LLE_VALID) == 0) {
12164fb3a820SAlexander V. Chernikov 		/* Try to perform LLE update */
12174fb3a820SAlexander V. Chernikov 		if (lltable_try_set_entry_addr(ifp, la, linkhdr, linkhdrsize,
12184fb3a820SAlexander V. Chernikov 		    lladdr_off) == 0)
12194fb3a820SAlexander V. Chernikov 			return;
1220f8aee88fSAlexander V. Chernikov 
1221f8aee88fSAlexander V. Chernikov 		/* Clear fast path feedback request if set */
1222f8aee88fSAlexander V. Chernikov 		la->r_skip_req = 0;
1223f3bfa7d1SAlexander V. Chernikov 	}
1224f3bfa7d1SAlexander V. Chernikov 
1225f3bfa7d1SAlexander V. Chernikov 	arp_mark_lle_reachable(la);
1226f3bfa7d1SAlexander V. Chernikov 
1227f3bfa7d1SAlexander V. Chernikov 	/*
1228f3bfa7d1SAlexander V. Chernikov 	 * The packets are all freed within the call to the output
1229f3bfa7d1SAlexander V. Chernikov 	 * routine.
1230f3bfa7d1SAlexander V. Chernikov 	 *
1231f3bfa7d1SAlexander V. Chernikov 	 * NB: The lock MUST be released before the call to the
1232f3bfa7d1SAlexander V. Chernikov 	 * output routine.
1233f3bfa7d1SAlexander V. Chernikov 	 */
1234f3bfa7d1SAlexander V. Chernikov 	if (la->la_hold != NULL) {
1235f3bfa7d1SAlexander V. Chernikov 		m_hold = la->la_hold;
1236f3bfa7d1SAlexander V. Chernikov 		la->la_hold = NULL;
1237f3bfa7d1SAlexander V. Chernikov 		la->la_numheld = 0;
1238f3bfa7d1SAlexander V. Chernikov 		lltable_fill_sa_entry(la, &sa);
1239f3bfa7d1SAlexander V. Chernikov 		LLE_WUNLOCK(la);
1240f3bfa7d1SAlexander V. Chernikov 		for (; m_hold != NULL; m_hold = m_hold_next) {
1241f3bfa7d1SAlexander V. Chernikov 			m_hold_next = m_hold->m_nextpkt;
1242f3bfa7d1SAlexander V. Chernikov 			m_hold->m_nextpkt = NULL;
1243f3bfa7d1SAlexander V. Chernikov 			/* Avoid confusing lower layers. */
1244f3bfa7d1SAlexander V. Chernikov 			m_clrprotoflags(m_hold);
1245f3bfa7d1SAlexander V. Chernikov 			(*ifp->if_output)(ifp, m_hold, &sa, NULL);
1246f3bfa7d1SAlexander V. Chernikov 		}
1247f3bfa7d1SAlexander V. Chernikov 	} else
1248f3bfa7d1SAlexander V. Chernikov 		LLE_WUNLOCK(la);
1249f3bfa7d1SAlexander V. Chernikov }
1250f3bfa7d1SAlexander V. Chernikov 
1251f3bfa7d1SAlexander V. Chernikov static void
1252f3bfa7d1SAlexander V. Chernikov arp_mark_lle_reachable(struct llentry *la)
1253f3bfa7d1SAlexander V. Chernikov {
1254f8aee88fSAlexander V. Chernikov 	int canceled, wtime;
1255f3bfa7d1SAlexander V. Chernikov 
1256f3bfa7d1SAlexander V. Chernikov 	LLE_WLOCK_ASSERT(la);
1257f3bfa7d1SAlexander V. Chernikov 
1258f8aee88fSAlexander V. Chernikov 	la->ln_state = ARP_LLINFO_REACHABLE;
1259f3bfa7d1SAlexander V. Chernikov 	EVENTHANDLER_INVOKE(lle_event, la, LLENTRY_RESOLVED);
1260f3bfa7d1SAlexander V. Chernikov 
1261f3bfa7d1SAlexander V. Chernikov 	if (!(la->la_flags & LLE_STATIC)) {
1262f3bfa7d1SAlexander V. Chernikov 		LLE_ADDREF(la);
1263f3bfa7d1SAlexander V. Chernikov 		la->la_expire = time_uptime + V_arpt_keep;
1264f8aee88fSAlexander V. Chernikov 		wtime = V_arpt_keep - V_arp_maxtries * V_arpt_rexmit;
1265f8aee88fSAlexander V. Chernikov 		if (wtime < 0)
1266f8aee88fSAlexander V. Chernikov 			wtime = V_arpt_keep;
1267f3bfa7d1SAlexander V. Chernikov 		canceled = callout_reset(&la->lle_timer,
1268f8aee88fSAlexander V. Chernikov 		    hz * wtime, arptimer, la);
1269f3bfa7d1SAlexander V. Chernikov 		if (canceled)
1270f3bfa7d1SAlexander V. Chernikov 			LLE_REMREF(la);
1271f3bfa7d1SAlexander V. Chernikov 	}
1272f3bfa7d1SAlexander V. Chernikov 	la->la_asked = 0;
1273f3bfa7d1SAlexander V. Chernikov 	la->la_preempt = V_arp_maxtries;
1274f3bfa7d1SAlexander V. Chernikov }
1275f3bfa7d1SAlexander V. Chernikov 
12761c302b58SAlexander V. Chernikov /*
1277ff21796dSOleg Bulyzhin  * Add permanent link-layer record for given interface address.
12781c302b58SAlexander V. Chernikov  */
12791c302b58SAlexander V. Chernikov static __noinline void
12801c302b58SAlexander V. Chernikov arp_add_ifa_lle(struct ifnet *ifp, const struct sockaddr *dst)
1281dd2e4102SGarrett Wollman {
12825a255516SAlexander V. Chernikov 	struct llentry *lle, *lle_tmp;
12835a255516SAlexander V. Chernikov 
12846e6b3f7cSQing Li 	/*
12855a255516SAlexander V. Chernikov 	 * Interface address LLE record is considered static
12865a255516SAlexander V. Chernikov 	 * because kernel code relies on LLE_STATIC flag to check
12875a255516SAlexander V. Chernikov 	 * if these entries can be rewriten by arp updates.
12886e6b3f7cSQing Li 	 */
12895a255516SAlexander V. Chernikov 	lle = lltable_alloc_entry(LLTABLE(ifp), LLE_IFADDR | LLE_STATIC, dst);
12905a255516SAlexander V. Chernikov 	if (lle == NULL) {
12916e6b3f7cSQing Li 		log(LOG_INFO, "arp_ifinit: cannot create arp "
12926e6b3f7cSQing Li 		    "entry for interface address\n");
12935a255516SAlexander V. Chernikov 		return;
1294ce9122fdSQing Li 	}
12955a255516SAlexander V. Chernikov 
12965a255516SAlexander V. Chernikov 	IF_AFDATA_WLOCK(ifp);
12975a255516SAlexander V. Chernikov 	LLE_WLOCK(lle);
12985a255516SAlexander V. Chernikov 	/* Unlink any entry if exists */
12995a255516SAlexander V. Chernikov 	lle_tmp = lla_lookup(LLTABLE(ifp), LLE_EXCLUSIVE, dst);
13005a255516SAlexander V. Chernikov 	if (lle_tmp != NULL)
13015a255516SAlexander V. Chernikov 		lltable_unlink_entry(LLTABLE(ifp), lle_tmp);
13025a255516SAlexander V. Chernikov 
13035a255516SAlexander V. Chernikov 	lltable_link_entry(LLTABLE(ifp), lle);
13045a255516SAlexander V. Chernikov 	IF_AFDATA_WUNLOCK(ifp);
13055a255516SAlexander V. Chernikov 
13065a255516SAlexander V. Chernikov 	if (lle_tmp != NULL)
13075a255516SAlexander V. Chernikov 		EVENTHANDLER_INVOKE(lle_event, lle_tmp, LLENTRY_EXPIRED);
13085a255516SAlexander V. Chernikov 
13095a255516SAlexander V. Chernikov 	EVENTHANDLER_INVOKE(lle_event, lle, LLENTRY_RESOLVED);
13105a255516SAlexander V. Chernikov 	LLE_WUNLOCK(lle);
13115a255516SAlexander V. Chernikov 	if (lle_tmp != NULL)
13125a255516SAlexander V. Chernikov 		lltable_free_entry(LLTABLE(ifp), lle_tmp);
1313dd2e4102SGarrett Wollman }
1314df5e1987SJonathan Lemon 
13152d9db0bcSEric van Gyzen /*
13162d9db0bcSEric van Gyzen  * Handle the garp_rexmit_count. Like sysctl_handle_int(), but limits the range
13172d9db0bcSEric van Gyzen  * of valid values.
13182d9db0bcSEric van Gyzen  */
13192d9db0bcSEric van Gyzen static int
13202d9db0bcSEric van Gyzen sysctl_garp_rexmit(SYSCTL_HANDLER_ARGS)
13212d9db0bcSEric van Gyzen {
13222d9db0bcSEric van Gyzen 	int error;
13232d9db0bcSEric van Gyzen 	int rexmit_count = *(int *)arg1;
13242d9db0bcSEric van Gyzen 
13252d9db0bcSEric van Gyzen 	error = sysctl_handle_int(oidp, &rexmit_count, 0, req);
13262d9db0bcSEric van Gyzen 
13272d9db0bcSEric van Gyzen 	/* Enforce limits on any new value that may have been set. */
13282d9db0bcSEric van Gyzen 	if (!error && req->newptr) {
13292d9db0bcSEric van Gyzen 		/* A new value was set. */
13302d9db0bcSEric van Gyzen 		if (rexmit_count < 0) {
13312d9db0bcSEric van Gyzen 			rexmit_count = 0;
13322d9db0bcSEric van Gyzen 		} else if (rexmit_count > MAX_GARP_RETRANSMITS) {
13332d9db0bcSEric van Gyzen 			rexmit_count = MAX_GARP_RETRANSMITS;
13342d9db0bcSEric van Gyzen 		}
13352d9db0bcSEric van Gyzen 		*(int *)arg1 = rexmit_count;
13362d9db0bcSEric van Gyzen 	}
13372d9db0bcSEric van Gyzen 
13382d9db0bcSEric van Gyzen 	return (error);
13392d9db0bcSEric van Gyzen }
13402d9db0bcSEric van Gyzen 
13412d9db0bcSEric van Gyzen /*
13422d9db0bcSEric van Gyzen  * Retransmit a Gratuitous ARP (GARP) and, if necessary, schedule a callout to
13432d9db0bcSEric van Gyzen  * retransmit it again. A pending callout owns a reference to the ifa.
13442d9db0bcSEric van Gyzen  */
13452d9db0bcSEric van Gyzen static void
13462d9db0bcSEric van Gyzen garp_rexmit(void *arg)
13472d9db0bcSEric van Gyzen {
13482d9db0bcSEric van Gyzen 	struct in_ifaddr *ia = arg;
13492d9db0bcSEric van Gyzen 
13502d9db0bcSEric van Gyzen 	if (callout_pending(&ia->ia_garp_timer) ||
13512d9db0bcSEric van Gyzen 	    !callout_active(&ia->ia_garp_timer)) {
13522d9db0bcSEric van Gyzen 		IF_ADDR_WUNLOCK(ia->ia_ifa.ifa_ifp);
13532d9db0bcSEric van Gyzen 		ifa_free(&ia->ia_ifa);
13542d9db0bcSEric van Gyzen 		return;
13552d9db0bcSEric van Gyzen 	}
13562d9db0bcSEric van Gyzen 
13573838c6a3SKristof Provost 	CURVNET_SET(ia->ia_ifa.ifa_ifp->if_vnet);
13583838c6a3SKristof Provost 
13592d9db0bcSEric van Gyzen 	/*
13602d9db0bcSEric van Gyzen 	 * Drop lock while the ARP request is generated.
13612d9db0bcSEric van Gyzen 	 */
13622d9db0bcSEric van Gyzen 	IF_ADDR_WUNLOCK(ia->ia_ifa.ifa_ifp);
13632d9db0bcSEric van Gyzen 
13642d9db0bcSEric van Gyzen 	arprequest(ia->ia_ifa.ifa_ifp, &IA_SIN(ia)->sin_addr,
13652d9db0bcSEric van Gyzen 	    &IA_SIN(ia)->sin_addr, IF_LLADDR(ia->ia_ifa.ifa_ifp));
13662d9db0bcSEric van Gyzen 
13672d9db0bcSEric van Gyzen 	/*
13682d9db0bcSEric van Gyzen 	 * Increment the count of retransmissions. If the count has reached the
13692d9db0bcSEric van Gyzen 	 * maximum value, stop sending the GARP packets. Otherwise, schedule
13702d9db0bcSEric van Gyzen 	 * the callout to retransmit another GARP packet.
13712d9db0bcSEric van Gyzen 	 */
13722d9db0bcSEric van Gyzen 	++ia->ia_garp_count;
13732d9db0bcSEric van Gyzen 	if (ia->ia_garp_count >= garp_rexmit_count) {
13742d9db0bcSEric van Gyzen 		ifa_free(&ia->ia_ifa);
13752d9db0bcSEric van Gyzen 	} else {
13762d9db0bcSEric van Gyzen 		int rescheduled;
13772d9db0bcSEric van Gyzen 		IF_ADDR_WLOCK(ia->ia_ifa.ifa_ifp);
13782d9db0bcSEric van Gyzen 		rescheduled = callout_reset(&ia->ia_garp_timer,
13792d9db0bcSEric van Gyzen 		    (1 << ia->ia_garp_count) * hz,
13802d9db0bcSEric van Gyzen 		    garp_rexmit, ia);
13812d9db0bcSEric van Gyzen 		IF_ADDR_WUNLOCK(ia->ia_ifa.ifa_ifp);
13822d9db0bcSEric van Gyzen 		if (rescheduled) {
13832d9db0bcSEric van Gyzen 			ifa_free(&ia->ia_ifa);
13842d9db0bcSEric van Gyzen 		}
13852d9db0bcSEric van Gyzen 	}
13863838c6a3SKristof Provost 
13873838c6a3SKristof Provost 	CURVNET_RESTORE();
13882d9db0bcSEric van Gyzen }
13892d9db0bcSEric van Gyzen 
13902d9db0bcSEric van Gyzen /*
13912d9db0bcSEric van Gyzen  * Start the GARP retransmit timer.
13922d9db0bcSEric van Gyzen  *
13932d9db0bcSEric van Gyzen  * A single GARP is always transmitted when an IPv4 address is added
13942d9db0bcSEric van Gyzen  * to an interface and that is usually sufficient. However, in some
13952d9db0bcSEric van Gyzen  * circumstances, such as when a shared address is passed between
13962d9db0bcSEric van Gyzen  * cluster nodes, this single GARP may occasionally be dropped or
13972d9db0bcSEric van Gyzen  * lost. This can lead to neighbors on the network link working with a
13982d9db0bcSEric van Gyzen  * stale ARP cache and sending packets destined for that address to
13992d9db0bcSEric van Gyzen  * the node that previously owned the address, which may not respond.
14002d9db0bcSEric van Gyzen  *
14012d9db0bcSEric van Gyzen  * To avoid this situation, GARP retransmits can be enabled by setting
14022d9db0bcSEric van Gyzen  * the net.link.ether.inet.garp_rexmit_count sysctl to a value greater
14032d9db0bcSEric van Gyzen  * than zero. The setting represents the maximum number of
14042d9db0bcSEric van Gyzen  * retransmissions. The interval between retransmissions is calculated
14052d9db0bcSEric van Gyzen  * using an exponential backoff algorithm, doubling each time, so the
14062d9db0bcSEric van Gyzen  * retransmission intervals are: {1, 2, 4, 8, 16, ...} (seconds).
14072d9db0bcSEric van Gyzen  */
14082d9db0bcSEric van Gyzen static void
14092d9db0bcSEric van Gyzen garp_timer_start(struct ifaddr *ifa)
14102d9db0bcSEric van Gyzen {
14112d9db0bcSEric van Gyzen 	struct in_ifaddr *ia = (struct in_ifaddr *) ifa;
14122d9db0bcSEric van Gyzen 
14132d9db0bcSEric van Gyzen 	IF_ADDR_WLOCK(ia->ia_ifa.ifa_ifp);
14142d9db0bcSEric van Gyzen 	ia->ia_garp_count = 0;
14152d9db0bcSEric van Gyzen 	if (callout_reset(&ia->ia_garp_timer, (1 << ia->ia_garp_count) * hz,
14162d9db0bcSEric van Gyzen 	    garp_rexmit, ia) == 0) {
14172d9db0bcSEric van Gyzen 		ifa_ref(ifa);
14182d9db0bcSEric van Gyzen 	}
14192d9db0bcSEric van Gyzen 	IF_ADDR_WUNLOCK(ia->ia_ifa.ifa_ifp);
14202d9db0bcSEric van Gyzen }
14212d9db0bcSEric van Gyzen 
1422a9771948SGleb Smirnoff void
14231c302b58SAlexander V. Chernikov arp_ifinit(struct ifnet *ifp, struct ifaddr *ifa)
1424a9771948SGleb Smirnoff {
1425*b8a6e03fSGleb Smirnoff 	struct epoch_tracker et;
14261c302b58SAlexander V. Chernikov 	const struct sockaddr_in *dst_in;
14271c302b58SAlexander V. Chernikov 	const struct sockaddr *dst;
14281c302b58SAlexander V. Chernikov 
14291c302b58SAlexander V. Chernikov 	if (ifa->ifa_carp != NULL)
14301c302b58SAlexander V. Chernikov 		return;
14311c302b58SAlexander V. Chernikov 
14321c302b58SAlexander V. Chernikov 	dst = ifa->ifa_addr;
14331c302b58SAlexander V. Chernikov 	dst_in = (const struct sockaddr_in *)dst;
14341c302b58SAlexander V. Chernikov 
14351c302b58SAlexander V. Chernikov 	if (ntohl(dst_in->sin_addr.s_addr) == INADDR_ANY)
14361c302b58SAlexander V. Chernikov 		return;
1437*b8a6e03fSGleb Smirnoff 	NET_EPOCH_ENTER(et);
1438d6e82913SSteven Hartland 	arp_announce_ifaddr(ifp, dst_in->sin_addr, IF_LLADDR(ifp));
1439*b8a6e03fSGleb Smirnoff 	NET_EPOCH_EXIT(et);
14402d9db0bcSEric van Gyzen 	if (garp_rexmit_count > 0) {
14412d9db0bcSEric van Gyzen 		garp_timer_start(ifa);
14422d9db0bcSEric van Gyzen 	}
14431c302b58SAlexander V. Chernikov 
14441c302b58SAlexander V. Chernikov 	arp_add_ifa_lle(ifp, dst);
14451c302b58SAlexander V. Chernikov }
14461c302b58SAlexander V. Chernikov 
1447d6e82913SSteven Hartland void
1448d6e82913SSteven Hartland arp_announce_ifaddr(struct ifnet *ifp, struct in_addr addr, u_char *enaddr)
14491c302b58SAlexander V. Chernikov {
14501c302b58SAlexander V. Chernikov 
1451d6e82913SSteven Hartland 	if (ntohl(addr.s_addr) != INADDR_ANY)
1452d6e82913SSteven Hartland 		arprequest(ifp, &addr, &addr, enaddr);
1453a9771948SGleb Smirnoff }
1454a9771948SGleb Smirnoff 
1455b13c5b5dSAlexander V. Chernikov /*
1456d6e82913SSteven Hartland  * Sends gratuitous ARPs for each ifaddr to notify other
1457d6e82913SSteven Hartland  * nodes about the address change.
1458b13c5b5dSAlexander V. Chernikov  */
1459d6e82913SSteven Hartland static __noinline void
1460d6e82913SSteven Hartland arp_handle_ifllchange(struct ifnet *ifp)
1461b13c5b5dSAlexander V. Chernikov {
1462b13c5b5dSAlexander V. Chernikov 	struct ifaddr *ifa;
1463b13c5b5dSAlexander V. Chernikov 
1464d7c5a620SMatt Macy 	CK_STAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
1465d6e82913SSteven Hartland 		if (ifa->ifa_addr->sa_family == AF_INET)
1466d6e82913SSteven Hartland 			arp_ifinit(ifp, ifa);
146752e53e2dSSteven Hartland 	}
1468b13c5b5dSAlexander V. Chernikov }
1469b13c5b5dSAlexander V. Chernikov 
1470b13c5b5dSAlexander V. Chernikov /*
1471d6e82913SSteven Hartland  * A handler for interface link layer address change event.
1472b13c5b5dSAlexander V. Chernikov  */
14734fb3a820SAlexander V. Chernikov static void
1474b13c5b5dSAlexander V. Chernikov arp_iflladdr(void *arg __unused, struct ifnet *ifp)
1475b13c5b5dSAlexander V. Chernikov {
1476b13c5b5dSAlexander V. Chernikov 
14774fb3a820SAlexander V. Chernikov 	lltable_update_ifaddr(LLTABLE(ifp));
14784fb3a820SAlexander V. Chernikov 
1479d6e82913SSteven Hartland 	if ((ifp->if_flags & IFF_UP) != 0)
1480d6e82913SSteven Hartland 		arp_handle_ifllchange(ifp);
1481b13c5b5dSAlexander V. Chernikov }
1482b13c5b5dSAlexander V. Chernikov 
14831ed81b73SMarko Zec static void
1484484149deSBjoern A. Zeeb vnet_arp_init(void)
14851ed81b73SMarko Zec {
14861ed81b73SMarko Zec 
1487484149deSBjoern A. Zeeb 	if (IS_DEFAULT_VNET(curvnet)) {
1488d4b5cae4SRobert Watson 		netisr_register(&arp_nh);
1489b13c5b5dSAlexander V. Chernikov 		iflladdr_tag = EVENTHANDLER_REGISTER(iflladdr_event,
1490b13c5b5dSAlexander V. Chernikov 		    arp_iflladdr, NULL, EVENTHANDLER_PRI_ANY);
1491df5e1987SJonathan Lemon 	}
1492484149deSBjoern A. Zeeb #ifdef VIMAGE
1493484149deSBjoern A. Zeeb 	else
1494484149deSBjoern A. Zeeb 		netisr_register_vnet(&arp_nh);
1495484149deSBjoern A. Zeeb #endif
1496484149deSBjoern A. Zeeb }
1497484149deSBjoern A. Zeeb VNET_SYSINIT(vnet_arp_init, SI_SUB_PROTO_DOMAIN, SI_ORDER_SECOND,
1498484149deSBjoern A. Zeeb     vnet_arp_init, 0);
1499484149deSBjoern A. Zeeb 
1500484149deSBjoern A. Zeeb #ifdef VIMAGE
1501484149deSBjoern A. Zeeb /*
1502484149deSBjoern A. Zeeb  * We have to unregister ARP along with IP otherwise we risk doing INADDR_HASH
1503484149deSBjoern A. Zeeb  * lookups after destroying the hash.  Ideally this would go on SI_ORDER_3.5.
1504484149deSBjoern A. Zeeb  */
1505484149deSBjoern A. Zeeb static void
1506484149deSBjoern A. Zeeb vnet_arp_destroy(__unused void *arg)
1507484149deSBjoern A. Zeeb {
1508484149deSBjoern A. Zeeb 
1509484149deSBjoern A. Zeeb 	netisr_unregister_vnet(&arp_nh);
1510484149deSBjoern A. Zeeb }
1511484149deSBjoern A. Zeeb VNET_SYSUNINIT(vnet_arp_uninit, SI_SUB_PROTO_DOMAIN, SI_ORDER_THIRD,
1512484149deSBjoern A. Zeeb     vnet_arp_destroy, NULL);
1513484149deSBjoern A. Zeeb #endif
1514