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