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