aarp.c revision 1.27.12.2
1 /* $NetBSD: aarp.c,v 1.27.12.2 2012/04/21 16:03:27 riz Exp $ */ 2 3 /* 4 * Copyright (c) 1990,1991 Regents of The University of Michigan. 5 * All Rights Reserved. 6 * 7 * Permission to use, copy, modify, and distribute this software and 8 * its documentation for any purpose and without fee is hereby granted, 9 * provided that the above copyright notice appears in all copies and 10 * that both that copyright notice and this permission notice appear 11 * in supporting documentation, and that the name of The University 12 * of Michigan not be used in advertising or publicity pertaining to 13 * distribution of the software without specific, written prior 14 * permission. This software is supplied as is without expressed or 15 * implied warranties of any kind. 16 * 17 * This product includes software developed by the University of 18 * California, Berkeley and its contributors. 19 * 20 * Research Systems Unix Group 21 * The University of Michigan 22 * c/o Wesley Craig 23 * 535 W. William Street 24 * Ann Arbor, Michigan 25 * +1-313-764-2278 26 * netatalk (at) umich.edu 27 */ 28 29 #include <sys/cdefs.h> 30 __KERNEL_RCSID(0, "$NetBSD: aarp.c,v 1.27.12.2 2012/04/21 16:03:27 riz Exp $"); 31 32 #include "opt_mbuftrace.h" 33 34 #include <sys/param.h> 35 #include <sys/socket.h> 36 #include <sys/syslog.h> 37 #include <sys/systm.h> 38 #include <sys/callout.h> 39 #include <sys/proc.h> 40 #include <sys/mbuf.h> 41 #include <sys/time.h> 42 #include <sys/kernel.h> 43 #include <sys/socketvar.h> 44 #include <net/if.h> 45 #include <net/route.h> 46 #include <net/if_ether.h> 47 #include <net/if_dl.h> 48 #include <netinet/in.h> 49 #undef s_net 50 51 #include <netatalk/at.h> 52 #include <netatalk/at_var.h> 53 #include <netatalk/aarp.h> 54 #include <netatalk/ddp_var.h> 55 #include <netatalk/phase2.h> 56 #include <netatalk/at_extern.h> 57 58 static struct aarptab *aarptnew(const struct at_addr *); 59 static void aarptfree(struct aarptab *); 60 static void at_aarpinput(struct ifnet *, struct mbuf *); 61 static void aarptimer(void *); 62 static void aarpwhohas(struct ifnet *, const struct sockaddr_at *); 63 64 #define AARPTAB_BSIZ 9 65 #define AARPTAB_NB 19 66 #define AARPTAB_SIZE (AARPTAB_BSIZ * AARPTAB_NB) 67 struct aarptab aarptab[AARPTAB_SIZE]; 68 69 #define AARPTAB_HASH(a) \ 70 ((((a).s_net << 8 ) + (a).s_node ) % AARPTAB_NB ) 71 72 #define AARPTAB_LOOK(aat,addr) { \ 73 int n; \ 74 aat = &aarptab[ AARPTAB_HASH(addr) * AARPTAB_BSIZ ]; \ 75 for ( n = 0; n < AARPTAB_BSIZ; n++, aat++ ) \ 76 if ( aat->aat_ataddr.s_net == (addr).s_net && \ 77 aat->aat_ataddr.s_node == (addr).s_node ) \ 78 break; \ 79 if ( n >= AARPTAB_BSIZ ) \ 80 aat = 0; \ 81 } 82 83 #define AARPT_AGE (60 * 1) 84 #define AARPT_KILLC 20 85 #define AARPT_KILLI 3 86 87 const u_char atmulticastaddr[6] = { 88 0x09, 0x00, 0x07, 0xff, 0xff, 0xff 89 }; 90 91 const u_char at_org_code[3] = { 92 0x08, 0x00, 0x07 93 }; 94 const u_char aarp_org_code[3] = { 95 0x00, 0x00, 0x00 96 }; 97 98 struct callout aarptimer_callout; 99 #ifdef MBUFTRACE 100 struct mowner aarp_mowner = MOWNER_INIT("atalk", "arp"); 101 #endif 102 103 /*ARGSUSED*/ 104 static void 105 aarptimer(void *ignored) 106 { 107 struct aarptab *aat; 108 int i, s; 109 110 mutex_enter(softnet_lock); 111 callout_reset(&aarptimer_callout, AARPT_AGE * hz, aarptimer, NULL); 112 aat = aarptab; 113 for (i = 0; i < AARPTAB_SIZE; i++, aat++) { 114 int killtime = (aat->aat_flags & ATF_COM) ? AARPT_KILLC : 115 AARPT_KILLI; 116 if (aat->aat_flags == 0 || (aat->aat_flags & ATF_PERM)) 117 continue; 118 if (++aat->aat_timer < killtime) 119 continue; 120 s = splnet(); 121 aarptfree(aat); 122 splx(s); 123 } 124 mutex_exit(softnet_lock); 125 } 126 127 /* 128 * search through the network addresses to find one that includes the given 129 * network.. remember to take netranges into consideration. 130 */ 131 struct ifaddr * 132 at_ifawithnet(sat, ifp) 133 const struct sockaddr_at *sat; 134 struct ifnet *ifp; 135 { 136 struct ifaddr *ifa; 137 struct sockaddr_at *sat2; 138 struct netrange *nr; 139 140 IFADDR_FOREACH(ifa, ifp) { 141 if (ifa->ifa_addr->sa_family != AF_APPLETALK) 142 continue; 143 144 sat2 = satosat(ifa->ifa_addr); 145 if (sat2->sat_addr.s_net == sat->sat_addr.s_net) 146 break; 147 148 nr = (struct netrange *) (sat2->sat_zero); 149 if ((nr->nr_phase == 2) 150 && (ntohs(nr->nr_firstnet) <= ntohs(sat->sat_addr.s_net)) 151 && (ntohs(nr->nr_lastnet) >= ntohs(sat->sat_addr.s_net))) 152 break; 153 } 154 return ifa; 155 } 156 157 static void 158 aarpwhohas(ifp, sat) 159 struct ifnet *ifp; 160 const struct sockaddr_at *sat; 161 { 162 struct mbuf *m; 163 struct ether_header *eh; 164 struct ether_aarp *ea; 165 struct at_ifaddr *aa; 166 struct llc *llc; 167 struct sockaddr sa; 168 169 if ((m = m_gethdr(M_DONTWAIT, MT_DATA)) == NULL) 170 return; 171 172 MCLAIM(m, &aarp_mowner); 173 m->m_len = sizeof(*ea); 174 m->m_pkthdr.len = sizeof(*ea); 175 MH_ALIGN(m, sizeof(*ea)); 176 177 ea = mtod(m, struct ether_aarp *); 178 bzero(ea, sizeof(*ea)); 179 180 ea->aarp_hrd = htons(AARPHRD_ETHER); 181 ea->aarp_pro = htons(ETHERTYPE_ATALK); 182 ea->aarp_hln = sizeof(ea->aarp_sha); 183 ea->aarp_pln = sizeof(ea->aarp_spu); 184 ea->aarp_op = htons(AARPOP_REQUEST); 185 bcopy(CLLADDR(ifp->if_sadl), ea->aarp_sha, sizeof(ea->aarp_sha)); 186 187 /* 188 * We need to check whether the output ethernet type should 189 * be phase 1 or 2. We have the interface that we'll be sending 190 * the aarp out. We need to find an AppleTalk network on that 191 * interface with the same address as we're looking for. If the 192 * net is phase 2, generate an 802.2 and SNAP header. 193 */ 194 if ((aa = (struct at_ifaddr *) at_ifawithnet(sat, ifp)) == NULL) { 195 m_freem(m); 196 return; 197 } 198 eh = (struct ether_header *) sa.sa_data; 199 200 if (aa->aa_flags & AFA_PHASE2) { 201 bcopy(atmulticastaddr, eh->ether_dhost, 202 sizeof(eh->ether_dhost)); 203 eh->ether_type = 0; /* if_output will treat as 802 */ 204 M_PREPEND(m, sizeof(struct llc), M_DONTWAIT); 205 if (!m) 206 return; 207 208 llc = mtod(m, struct llc *); 209 llc->llc_dsap = llc->llc_ssap = LLC_SNAP_LSAP; 210 llc->llc_control = LLC_UI; 211 bcopy(aarp_org_code, llc->llc_org_code, sizeof(aarp_org_code)); 212 llc->llc_ether_type = htons(ETHERTYPE_AARP); 213 214 bcopy(&AA_SAT(aa)->sat_addr.s_net, ea->aarp_spnet, 215 sizeof(ea->aarp_spnet)); 216 bcopy(&sat->sat_addr.s_net, ea->aarp_tpnet, 217 sizeof(ea->aarp_tpnet)); 218 ea->aarp_spnode = AA_SAT(aa)->sat_addr.s_node; 219 ea->aarp_tpnode = sat->sat_addr.s_node; 220 } else { 221 bcopy(etherbroadcastaddr, eh->ether_dhost, 222 sizeof(eh->ether_dhost)); 223 eh->ether_type = htons(ETHERTYPE_AARP); 224 225 ea->aarp_spa = AA_SAT(aa)->sat_addr.s_node; 226 ea->aarp_tpa = sat->sat_addr.s_node; 227 } 228 229 /* If we are talking to ourselves, use the loopback interface. */ 230 if (AA_SAT(aa)->sat_addr.s_net == sat->sat_addr.s_net && 231 AA_SAT(aa)->sat_addr.s_node == sat->sat_addr.s_node) 232 ifp = lo0ifp; 233 234 #ifdef NETATALKDEBUG 235 printf("aarp: sending request via %u.%u through %s seeking %u.%u\n", 236 ntohs(AA_SAT(aa)->sat_addr.s_net), 237 AA_SAT(aa)->sat_addr.s_node, 238 ifp->if_xname, 239 ntohs(sat->sat_addr.s_net), 240 sat->sat_addr.s_node); 241 #endif /* NETATALKDEBUG */ 242 243 sa.sa_len = sizeof(struct sockaddr); 244 sa.sa_family = AF_UNSPEC; 245 (*ifp->if_output) (ifp, m, &sa, NULL); /* XXX NULL should be routing */ 246 /* information */ 247 } 248 249 int 250 aarpresolve(struct ifnet *ifp, struct mbuf *m, 251 const struct sockaddr_at *destsat, u_char *desten) 252 { 253 struct at_ifaddr *aa; 254 struct aarptab *aat; 255 int s; 256 257 if (at_broadcast(destsat)) { 258 aa = (struct at_ifaddr *) at_ifawithnet(destsat, ifp); 259 if (aa == NULL) { 260 m_freem(m); 261 return (0); 262 } 263 if (aa->aa_flags & AFA_PHASE2) 264 bcopy(atmulticastaddr, desten, 265 sizeof(atmulticastaddr)); 266 else 267 bcopy(etherbroadcastaddr, desten, 268 sizeof(etherbroadcastaddr)); 269 return 1; 270 } 271 s = splnet(); 272 AARPTAB_LOOK(aat, destsat->sat_addr); 273 if (aat == 0) { /* No entry */ 274 aat = aarptnew(&destsat->sat_addr); 275 if (aat == 0) 276 panic("aarpresolve: no free entry"); 277 278 aat->aat_hold = m; 279 aarpwhohas(ifp, destsat); 280 splx(s); 281 return 0; 282 } 283 284 /* found an entry */ 285 aat->aat_timer = 0; 286 if (aat->aat_flags & ATF_COM) { /* entry is COMplete */ 287 bcopy(aat->aat_enaddr, desten, sizeof(aat->aat_enaddr)); 288 splx(s); 289 return 1; 290 } 291 292 /* entry has not completed */ 293 if (aat->aat_hold) 294 m_freem(aat->aat_hold); 295 aat->aat_hold = m; 296 aarpwhohas(ifp, destsat); 297 splx(s); 298 299 return 0; 300 } 301 302 void 303 aarpinput(ifp, m) 304 struct ifnet *ifp; 305 struct mbuf *m; 306 { 307 struct arphdr *ar; 308 309 if (ifp->if_flags & IFF_NOARP) 310 goto out; 311 312 if (m->m_len < sizeof(struct arphdr)) 313 goto out; 314 315 ar = mtod(m, struct arphdr *); 316 if (ntohs(ar->ar_hrd) != AARPHRD_ETHER) 317 goto out; 318 319 if (m->m_len < sizeof(struct arphdr) + 2 * ar->ar_hln + 2 * ar->ar_pln) 320 goto out; 321 322 switch (ntohs(ar->ar_pro)) { 323 case ETHERTYPE_ATALK: 324 at_aarpinput(ifp, m); 325 return; 326 327 default: 328 break; 329 } 330 331 out: 332 m_freem(m); 333 } 334 335 static void 336 at_aarpinput(ifp, m) 337 struct ifnet *ifp; 338 struct mbuf *m; 339 { 340 struct ether_aarp *ea; 341 struct at_ifaddr *aa; 342 struct ifaddr *ia; 343 struct aarptab *aat; 344 struct ether_header *eh; 345 struct llc *llc; 346 struct sockaddr_at sat; 347 struct sockaddr sa; 348 struct at_addr spa, tpa, ma; 349 int op; 350 u_int16_t net; 351 352 ea = mtod(m, struct ether_aarp *); 353 354 /* Check to see if from my hardware address */ 355 if (!bcmp(ea->aarp_sha, CLLADDR(ifp->if_sadl), sizeof(ea->aarp_sha))) { 356 m_freem(m); 357 return; 358 } 359 op = ntohs(ea->aarp_op); 360 bcopy(ea->aarp_tpnet, &net, sizeof(net)); 361 362 if (net != 0) { /* should be ATADDR_ANYNET? */ 363 sat.sat_len = sizeof(struct sockaddr_at); 364 sat.sat_family = AF_APPLETALK; 365 sat.sat_addr.s_net = net; 366 aa = (struct at_ifaddr *) at_ifawithnet(&sat, ifp); 367 if (aa == NULL) { 368 m_freem(m); 369 return; 370 } 371 bcopy(ea->aarp_spnet, &spa.s_net, sizeof(spa.s_net)); 372 bcopy(ea->aarp_tpnet, &tpa.s_net, sizeof(tpa.s_net)); 373 } else { 374 /* 375 * Since we don't know the net, we just look for the first 376 * phase 1 address on the interface. 377 */ 378 IFADDR_FOREACH(ia, ifp) { 379 aa = (struct at_ifaddr *)ia; 380 if (AA_SAT(aa)->sat_family == AF_APPLETALK && 381 (aa->aa_flags & AFA_PHASE2) == 0) 382 break; 383 } 384 if (ia == NULL) { 385 m_freem(m); 386 return; 387 } 388 tpa.s_net = spa.s_net = AA_SAT(aa)->sat_addr.s_net; 389 } 390 391 spa.s_node = ea->aarp_spnode; 392 tpa.s_node = ea->aarp_tpnode; 393 ma.s_net = AA_SAT(aa)->sat_addr.s_net; 394 ma.s_node = AA_SAT(aa)->sat_addr.s_node; 395 396 /* 397 * This looks like it's from us. 398 */ 399 if (spa.s_net == ma.s_net && spa.s_node == ma.s_node) { 400 if (aa->aa_flags & AFA_PROBING) { 401 /* 402 * We're probing, someone either responded to our 403 * probe, or probed for the same address we'd like 404 * to use. Change the address we're probing for. 405 */ 406 callout_stop(&aa->aa_probe_ch); 407 wakeup(aa); 408 m_freem(m); 409 return; 410 } else if (op != AARPOP_PROBE) { 411 /* 412 * This is not a probe, and we're not probing. 413 * This means that someone's saying they have the same 414 * source address as the one we're using. Get upset... 415 */ 416 log(LOG_ERR, "aarp: duplicate AT address!! %s\n", 417 ether_sprintf(ea->aarp_sha)); 418 m_freem(m); 419 return; 420 } 421 } 422 AARPTAB_LOOK(aat, spa); 423 if (aat) { 424 if (op == AARPOP_PROBE) { 425 /* 426 * Someone's probing for spa, deallocate the one we've 427 * got, so that if the prober keeps the address, we'll 428 * be able to arp for him. 429 */ 430 aarptfree(aat); 431 m_freem(m); 432 return; 433 } 434 bcopy(ea->aarp_sha, aat->aat_enaddr, sizeof(ea->aarp_sha)); 435 aat->aat_flags |= ATF_COM; 436 if (aat->aat_hold) { 437 sat.sat_len = sizeof(struct sockaddr_at); 438 sat.sat_family = AF_APPLETALK; 439 sat.sat_addr = spa; 440 (*ifp->if_output)(ifp, aat->aat_hold, 441 (struct sockaddr *) & sat, NULL); /* XXX */ 442 aat->aat_hold = 0; 443 } 444 } 445 if (aat == 0 && tpa.s_net == ma.s_net && tpa.s_node == ma.s_node 446 && op != AARPOP_PROBE) { 447 if ((aat = aarptnew(&spa)) != NULL) { 448 bcopy(ea->aarp_sha, aat->aat_enaddr, 449 sizeof(ea->aarp_sha)); 450 aat->aat_flags |= ATF_COM; 451 } 452 } 453 /* 454 * Don't respond to responses, and never respond if we're 455 * still probing. 456 */ 457 if (tpa.s_net != ma.s_net || tpa.s_node != ma.s_node || 458 op == AARPOP_RESPONSE || (aa->aa_flags & AFA_PROBING)) { 459 m_freem(m); 460 return; 461 } 462 bcopy(ea->aarp_sha, ea->aarp_tha, sizeof(ea->aarp_sha)); 463 bcopy(CLLADDR(ifp->if_sadl), ea->aarp_sha, sizeof(ea->aarp_sha)); 464 465 /* XXX */ 466 eh = (struct ether_header *) sa.sa_data; 467 bcopy(ea->aarp_tha, eh->ether_dhost, sizeof(eh->ether_dhost)); 468 469 if (aa->aa_flags & AFA_PHASE2) { 470 M_PREPEND(m, sizeof(struct llc), M_DONTWAIT); 471 if (m == NULL) 472 return; 473 474 llc = mtod(m, struct llc *); 475 llc->llc_dsap = llc->llc_ssap = LLC_SNAP_LSAP; 476 llc->llc_control = LLC_UI; 477 bcopy(aarp_org_code, llc->llc_org_code, sizeof(aarp_org_code)); 478 llc->llc_ether_type = htons(ETHERTYPE_AARP); 479 480 bcopy(ea->aarp_spnet, ea->aarp_tpnet, sizeof(ea->aarp_tpnet)); 481 bcopy(&ma.s_net, ea->aarp_spnet, sizeof(ea->aarp_spnet)); 482 eh->ether_type = 0; /* if_output will treat as 802 */ 483 } else { 484 eh->ether_type = htons(ETHERTYPE_AARP); 485 } 486 487 ea->aarp_tpnode = ea->aarp_spnode; 488 ea->aarp_spnode = ma.s_node; 489 ea->aarp_op = htons(AARPOP_RESPONSE); 490 491 sa.sa_len = sizeof(struct sockaddr); 492 sa.sa_family = AF_UNSPEC; 493 (*ifp->if_output) (ifp, m, &sa, NULL); /* XXX */ 494 return; 495 } 496 497 static void 498 aarptfree(aat) 499 struct aarptab *aat; 500 { 501 502 if (aat->aat_hold) 503 m_freem(aat->aat_hold); 504 aat->aat_hold = 0; 505 aat->aat_timer = aat->aat_flags = 0; 506 aat->aat_ataddr.s_net = 0; 507 aat->aat_ataddr.s_node = 0; 508 } 509 510 static struct aarptab * 511 aarptnew(const struct at_addr *addr) 512 { 513 int n; 514 int oldest = -1; 515 struct aarptab *aat, *aato = NULL; 516 static int first = 1; 517 518 if (first) { 519 first = 0; 520 callout_init(&aarptimer_callout, 0); 521 callout_reset(&aarptimer_callout, hz, aarptimer, NULL); 522 } 523 aat = &aarptab[AARPTAB_HASH(*addr) * AARPTAB_BSIZ]; 524 for (n = 0; n < AARPTAB_BSIZ; n++, aat++) { 525 if (aat->aat_flags == 0) 526 goto out; 527 if (aat->aat_flags & ATF_PERM) 528 continue; 529 if ((int) aat->aat_timer > oldest) { 530 oldest = aat->aat_timer; 531 aato = aat; 532 } 533 } 534 if (aato == NULL) 535 return (NULL); 536 aat = aato; 537 aarptfree(aat); 538 out: 539 aat->aat_ataddr = *addr; 540 aat->aat_flags = ATF_INUSE; 541 return (aat); 542 } 543 544 545 void 546 aarpprobe(arp) 547 void *arp; 548 { 549 struct mbuf *m; 550 struct ether_header *eh; 551 struct ether_aarp *ea; 552 struct ifaddr *ia; 553 struct at_ifaddr *aa; 554 struct llc *llc; 555 struct sockaddr sa; 556 struct ifnet *ifp = arp; 557 558 mutex_enter(softnet_lock); 559 560 /* 561 * We need to check whether the output ethernet type should 562 * be phase 1 or 2. We have the interface that we'll be sending 563 * the aarp out. We need to find an AppleTalk network on that 564 * interface with the same address as we're looking for. If the 565 * net is phase 2, generate an 802.2 and SNAP header. 566 */ 567 IFADDR_FOREACH(ia, ifp) { 568 aa = (struct at_ifaddr *)ia; 569 if (AA_SAT(aa)->sat_family == AF_APPLETALK && 570 (aa->aa_flags & AFA_PROBING)) 571 break; 572 } 573 if (ia == NULL) { /* serious error XXX */ 574 printf("aarpprobe why did this happen?!\n"); 575 mutex_exit(softnet_lock); 576 return; 577 } 578 if (aa->aa_probcnt <= 0) { 579 aa->aa_flags &= ~AFA_PROBING; 580 wakeup(aa); 581 mutex_exit(softnet_lock); 582 return; 583 } else { 584 callout_reset(&aa->aa_probe_ch, hz / 5, aarpprobe, arp); 585 } 586 587 if ((m = m_gethdr(M_DONTWAIT, MT_DATA)) == NULL) { 588 mutex_exit(softnet_lock); 589 return; 590 } 591 592 MCLAIM(m, &aarp_mowner); 593 m->m_len = sizeof(*ea); 594 m->m_pkthdr.len = sizeof(*ea); 595 MH_ALIGN(m, sizeof(*ea)); 596 597 ea = mtod(m, struct ether_aarp *); 598 bzero(ea, sizeof(*ea)); 599 600 ea->aarp_hrd = htons(AARPHRD_ETHER); 601 ea->aarp_pro = htons(ETHERTYPE_ATALK); 602 ea->aarp_hln = sizeof(ea->aarp_sha); 603 ea->aarp_pln = sizeof(ea->aarp_spu); 604 ea->aarp_op = htons(AARPOP_PROBE); 605 bcopy(CLLADDR(ifp->if_sadl), ea->aarp_sha, sizeof(ea->aarp_sha)); 606 607 eh = (struct ether_header *) sa.sa_data; 608 609 if (aa->aa_flags & AFA_PHASE2) { 610 bcopy(atmulticastaddr, eh->ether_dhost, 611 sizeof(eh->ether_dhost)); 612 eh->ether_type = 0; /* if_output will treat as 802 */ 613 M_PREPEND(m, sizeof(struct llc), M_DONTWAIT); 614 if (!m) { 615 mutex_exit(softnet_lock); 616 return; 617 } 618 619 llc = mtod(m, struct llc *); 620 llc->llc_dsap = llc->llc_ssap = LLC_SNAP_LSAP; 621 llc->llc_control = LLC_UI; 622 bcopy(aarp_org_code, llc->llc_org_code, sizeof(aarp_org_code)); 623 llc->llc_ether_type = htons(ETHERTYPE_AARP); 624 625 bcopy(&AA_SAT(aa)->sat_addr.s_net, ea->aarp_spnet, 626 sizeof(ea->aarp_spnet)); 627 bcopy(&AA_SAT(aa)->sat_addr.s_net, ea->aarp_tpnet, 628 sizeof(ea->aarp_tpnet)); 629 ea->aarp_spnode = ea->aarp_tpnode = 630 AA_SAT(aa)->sat_addr.s_node; 631 } else { 632 bcopy(etherbroadcastaddr, eh->ether_dhost, 633 sizeof(eh->ether_dhost)); 634 eh->ether_type = htons(ETHERTYPE_AARP); 635 ea->aarp_spa = ea->aarp_tpa = AA_SAT(aa)->sat_addr.s_node; 636 } 637 638 #ifdef NETATALKDEBUG 639 printf("aarp: sending probe for %u.%u\n", 640 ntohs(AA_SAT(aa)->sat_addr.s_net), 641 AA_SAT(aa)->sat_addr.s_node); 642 #endif /* NETATALKDEBUG */ 643 644 sa.sa_len = sizeof(struct sockaddr); 645 sa.sa_family = AF_UNSPEC; 646 (*ifp->if_output) (ifp, m, &sa, NULL); /* XXX */ 647 aa->aa_probcnt--; 648 mutex_exit(softnet_lock); 649 } 650 651 void 652 aarp_clean() 653 { 654 struct aarptab *aat; 655 int i; 656 657 callout_stop(&aarptimer_callout); 658 for (i = 0, aat = aarptab; i < AARPTAB_SIZE; i++, aat++) 659 if (aat->aat_hold) 660 m_freem(aat->aat_hold); 661 } 662
Indexes created Tue Oct 14 15:09:51 GMT 2025