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