161{
162 register struct sockaddr *gate = rt->rt_gateway;
163 register struct llinfo_arp *la = (struct llinfo_arp *)rt->rt_llinfo;
164 static struct sockaddr_dl null_sdl = {sizeof(null_sdl), AF_LINK};
165 static int arpinit_done;
166
167 if (!arpinit_done) {
168 arpinit_done = 1;
169 LIST_INIT(&llinfo_arp);
170 timeout(arptimer, (caddr_t)0, hz);
171 register_netisr(NETISR_ARP, arpintr);
172 }
173 if (rt->rt_flags & RTF_GATEWAY)
174 return;
175 switch (req) {
176
177 case RTM_ADD:
178 /*
179 * XXX: If this is a manually added route to interface
180 * such as older version of routed or gated might provide,
181 * restore cloning bit.
182 */
183 if ((rt->rt_flags & RTF_HOST) == 0 &&
184 SIN(rt_mask(rt))->sin_addr.s_addr != 0xffffffff)
185 rt->rt_flags |= RTF_CLONING;
186 if (rt->rt_flags & RTF_CLONING) {
187 /*
188 * Case 1: This route should come from a route to iface.
189 */
190 rt_setgate(rt, rt_key(rt),
191 (struct sockaddr *)&null_sdl);
192 gate = rt->rt_gateway;
193 SDL(gate)->sdl_type = rt->rt_ifp->if_type;
194 SDL(gate)->sdl_index = rt->rt_ifp->if_index;
195 rt->rt_expire = time_second;
196 break;
197 }
198 /* Announce a new entry if requested. */
199 if (rt->rt_flags & RTF_ANNOUNCE)
200 arprequest(rt->rt_ifp,
201 &SIN(rt_key(rt))->sin_addr,
202 &SIN(rt_key(rt))->sin_addr,
203 (u_char *)LLADDR(SDL(gate)));
204 /*FALLTHROUGH*/
205 case RTM_RESOLVE:
206 if (gate->sa_family != AF_LINK ||
207 gate->sa_len < sizeof(null_sdl)) {
208 log(LOG_DEBUG, "arp_rtrequest: bad gateway value\n");
209 break;
210 }
211 SDL(gate)->sdl_type = rt->rt_ifp->if_type;
212 SDL(gate)->sdl_index = rt->rt_ifp->if_index;
213 if (la != 0)
214 break; /* This happens on a route change */
215 /*
216 * Case 2: This route may come from cloning, or a manual route
217 * add with a LL address.
218 */
219 R_Malloc(la, struct llinfo_arp *, sizeof(*la));
220 rt->rt_llinfo = (caddr_t)la;
221 if (la == 0) {
222 log(LOG_DEBUG, "arp_rtrequest: malloc failed\n");
223 break;
224 }
225 arp_inuse++, arp_allocated++;
226 Bzero(la, sizeof(*la));
227 la->la_rt = rt;
228 rt->rt_flags |= RTF_LLINFO;
229 LIST_INSERT_HEAD(&llinfo_arp, la, la_le);
230
231#ifdef INET
232 /*
233 * This keeps the multicast addresses from showing up
234 * in `arp -a' listings as unresolved. It's not actually
235 * functional. Then the same for broadcast.
236 */
237 if (IN_MULTICAST(ntohl(SIN(rt_key(rt))->sin_addr.s_addr))
238 && rt->rt_ifp->if_type != IFT_ARCNET) {
239 ETHER_MAP_IP_MULTICAST(&SIN(rt_key(rt))->sin_addr,
240 LLADDR(SDL(gate)));
241 SDL(gate)->sdl_alen = 6;
242 rt->rt_expire = 0;
243 }
244 if (in_broadcast(SIN(rt_key(rt))->sin_addr, rt->rt_ifp)) {
245 memcpy(LLADDR(SDL(gate)), rt->rt_ifp->if_broadcastaddr,
246 rt->rt_ifp->if_addrlen);
247 SDL(gate)->sdl_alen = rt->rt_ifp->if_addrlen;
248 rt->rt_expire = 0;
249 }
250#endif
251
252 if (SIN(rt_key(rt))->sin_addr.s_addr ==
253 (IA_SIN(rt->rt_ifa))->sin_addr.s_addr) {
254 /*
255 * This test used to be
256 * if (loif.if_flags & IFF_UP)
257 * It allowed local traffic to be forced
258 * through the hardware by configuring the loopback down.
259 * However, it causes problems during network configuration
260 * for boards that can't receive packets they send.
261 * It is now necessary to clear "useloopback" and remove
262 * the route to force traffic out to the hardware.
263 */
264 rt->rt_expire = 0;
265 Bcopy(IF_LLADDR(rt->rt_ifp), LLADDR(SDL(gate)),
266 SDL(gate)->sdl_alen = rt->rt_ifp->if_addrlen);
267 if (useloopback)
268 rt->rt_ifp = loif;
269
270 }
271 break;
272
273 case RTM_DELETE:
274 if (la == 0)
275 break;
276 arp_inuse--;
277 LIST_REMOVE(la, la_le);
278 rt->rt_llinfo = 0;
279 rt->rt_flags &= ~RTF_LLINFO;
280 if (la->la_hold)
281 m_freem(la->la_hold);
282 Free((caddr_t)la);
283 }
284}
285
286/*
287 * Broadcast an ARP request. Caller specifies:
288 * - arp header source ip address
289 * - arp header target ip address
290 * - arp header source ethernet address
291 */
292static void
293arprequest(ifp, sip, tip, enaddr)
294 register struct ifnet *ifp;
295 register struct in_addr *sip, *tip;
296 register u_char *enaddr;
297{
298 register struct mbuf *m;
299 register struct ether_header *eh;
300 register struct arc_header *arh;
301 register struct arphdr *ah;
302 struct sockaddr sa;
303 static u_char llcx[] = { 0x82, 0x40, LLC_SNAP_LSAP, LLC_SNAP_LSAP,
304 LLC_UI, 0x00, 0x00, 0x00, 0x08, 0x06 };
305 u_short ar_hrd;
306
307 if ((m = m_gethdr(M_DONTWAIT, MT_DATA)) == NULL)
308 return;
309 m->m_pkthdr.rcvif = (struct ifnet *)0;
310 switch (ifp->if_type) {
311 case IFT_ARCNET:
312 ar_hrd = htons(ARPHRD_ARCNET);
313
314 m->m_len = arphdr_len2(ifp->if_addrlen, sizeof(struct in_addr));
315 m->m_pkthdr.len = m->m_len;
316 MH_ALIGN(m, m->m_len);
317
318 arh = (struct arc_header *)sa.sa_data;
319 arh->arc_dhost = *ifp->if_broadcastaddr;
320 arh->arc_type = ARCTYPE_ARP;
321
322 ah = mtod(m, struct arphdr *);
323 break;
324
325 case IFT_ISO88025:
326 ar_hrd = htons(ARPHRD_IEEE802);
327
328 m->m_len = sizeof(llcx) +
329 arphdr_len2(ifp->if_addrlen, sizeof(struct in_addr));
330 m->m_pkthdr.len = m->m_len;
331 MH_ALIGN(m, m->m_len);
332
333 (void)memcpy(mtod(m, caddr_t), llcx, sizeof(llcx));
334 (void)memcpy(sa.sa_data, ifp->if_broadcastaddr, 6);
335 (void)memcpy(sa.sa_data + 6, enaddr, 6);
336 sa.sa_data[6] |= TR_RII;
337 sa.sa_data[12] = TR_AC;
338 sa.sa_data[13] = TR_LLC_FRAME;
339
340 ah = (struct arphdr *)(mtod(m, char *) + sizeof(llcx));
341 break;
342 case IFT_FDDI:
343 case IFT_ETHER:
344 /*
345 * This may not be correct for types not explicitly
346 * listed, but this is our best guess
347 */
348 default:
349 ar_hrd = htons(ARPHRD_ETHER);
350
351 m->m_len = arphdr_len2(ifp->if_addrlen, sizeof(struct in_addr));
352 m->m_pkthdr.len = m->m_len;
353 MH_ALIGN(m, m->m_len);
354
355 eh = (struct ether_header *)sa.sa_data;
356 /* if_output will not swap */
357 eh->ether_type = htons(ETHERTYPE_ARP);
358 (void)memcpy(eh->ether_dhost, ifp->if_broadcastaddr,
359 sizeof(eh->ether_dhost));
360
361 ah = mtod(m, struct arphdr *);
362 break;
363 }
364
365 ah->ar_hrd = ar_hrd;
366 ah->ar_pro = htons(ETHERTYPE_IP);
367 ah->ar_hln = ifp->if_addrlen; /* hardware address length */
368 ah->ar_pln = sizeof(struct in_addr); /* protocol address length */
369 ah->ar_op = htons(ARPOP_REQUEST);
370 (void)memcpy(ar_sha(ah), enaddr, ah->ar_hln);
371 (void)memcpy(ar_spa(ah), sip, ah->ar_pln);
372 (void)memcpy(ar_tpa(ah), tip, ah->ar_pln);
373
374 sa.sa_family = AF_UNSPEC;
375 sa.sa_len = sizeof(sa);
376 (*ifp->if_output)(ifp, m, &sa, (struct rtentry *)0);
377}
378
379/*
380 * Resolve an IP address into an ethernet address. If success,
381 * desten is filled in. If there is no entry in arptab,
382 * set one up and broadcast a request for the IP address.
383 * Hold onto this mbuf and resend it once the address
384 * is finally resolved. A return value of 1 indicates
385 * that desten has been filled in and the packet should be sent
386 * normally; a 0 return indicates that the packet has been
387 * taken over here, either now or for later transmission.
388 */
389int
390arpresolve(ifp, rt, m, dst, desten, rt0)
391 register struct ifnet *ifp;
392 register struct rtentry *rt;
393 struct mbuf *m;
394 register struct sockaddr *dst;
395 register u_char *desten;
396 struct rtentry *rt0;
397{
398 struct llinfo_arp *la = 0;
399 struct sockaddr_dl *sdl;
400
401 if (m->m_flags & M_BCAST) { /* broadcast */
402 (void)memcpy(desten, ifp->if_broadcastaddr, ifp->if_addrlen);
403 return (1);
404 }
405 if (m->m_flags & M_MCAST && ifp->if_type != IFT_ARCNET) {/* multicast */
406 ETHER_MAP_IP_MULTICAST(&SIN(dst)->sin_addr, desten);
407 return(1);
408 }
409 if (rt)
410 la = (struct llinfo_arp *)rt->rt_llinfo;
411 if (la == 0) {
412 la = arplookup(SIN(dst)->sin_addr.s_addr, 1, 0);
413 if (la)
414 rt = la->la_rt;
415 }
416 if (la == 0 || rt == 0) {
417 log(LOG_DEBUG, "arpresolve: can't allocate llinfo for %s%s%s\n",
418 inet_ntoa(SIN(dst)->sin_addr), la ? "la" : "",
419 rt ? "rt" : "");
420 m_freem(m);
421 return (0);
422 }
423 sdl = SDL(rt->rt_gateway);
424 /*
425 * Check the address family and length is valid, the address
426 * is resolved; otherwise, try to resolve.
427 */
428 if ((rt->rt_expire == 0 || rt->rt_expire > time_second) &&
429 sdl->sdl_family == AF_LINK && sdl->sdl_alen != 0) {
430 bcopy(LLADDR(sdl), desten, sdl->sdl_alen);
431 return 1;
432 }
433 /*
434 * If ARP is disabled on this interface, stop.
435 * XXX
436 * Probably should not allocate empty llinfo struct if we are
437 * not going to be sending out an arp request.
438 */
439 if (ifp->if_flags & IFF_NOARP)
440 return (0);
441 /*
442 * There is an arptab entry, but no ethernet address
443 * response yet. Replace the held mbuf with this
444 * latest one.
445 */
446 if (la->la_hold)
447 m_freem(la->la_hold);
448 la->la_hold = m;
449 if (rt->rt_expire) {
450 rt->rt_flags &= ~RTF_REJECT;
451 if (la->la_asked == 0 || rt->rt_expire != time_second) {
452 rt->rt_expire = time_second;
453 if (la->la_asked++ < arp_maxtries)
454 arprequest(ifp,
455 &SIN(rt->rt_ifa->ifa_addr)->sin_addr,
456 &SIN(dst)->sin_addr,
457 IF_LLADDR(ifp));
458 else {
459 rt->rt_flags |= RTF_REJECT;
460 rt->rt_expire += arpt_down;
461 la->la_asked = 0;
462 }
463
464 }
465 }
466 return (0);
467}
468
469/*
470 * Common length and type checks are done here,
471 * then the protocol-specific routine is called.
472 */
473static void
474arpintr()
475{
476 register struct mbuf *m;
477 register struct arphdr *ar;
478 int s;
479
480 while (arpintrq.ifq_head) {
481 s = splimp();
482 IF_DEQUEUE(&arpintrq, m);
483 splx(s);
484 if (m == 0 || (m->m_flags & M_PKTHDR) == 0)
485 panic("arpintr");
486
487 if (m->m_len < sizeof(struct arphdr) &&
488 ((m = m_pullup(m, sizeof(struct arphdr))) == NULL)) {
489 log(LOG_ERR, "arp: runt packet -- m_pullup failed\n");
490 continue;
491 }
492 ar = mtod(m, struct arphdr *);
493
494 if (ntohs(ar->ar_hrd) != ARPHRD_ETHER
495 && ntohs(ar->ar_hrd) != ARPHRD_IEEE802
496 && ntohs(ar->ar_hrd) != ARPHRD_ARCNET) {
497 log(LOG_ERR,
498 "arp: unknown hardware address format (0x%2D)\n",
499 (unsigned char *)&ar->ar_hrd, "");
500 m_freem(m);
501 continue;
502 }
503
504 if (m->m_pkthdr.len < arphdr_len(ar) &&
505 (m = m_pullup(m, arphdr_len(ar))) == NULL) {
506 log(LOG_ERR, "arp: runt packet\n");
507 m_freem(m);
508 continue;
509 }
510
511 switch (ntohs(ar->ar_pro)) {
512#ifdef INET
513 case ETHERTYPE_IP:
514 in_arpinput(m);
515 continue;
516#endif
517 }
518 m_freem(m);
519 }
520}
521
522#ifdef INET
523/*
524 * ARP for Internet protocols on 10 Mb/s Ethernet.
525 * Algorithm is that given in RFC 826.
526 * In addition, a sanity check is performed on the sender
527 * protocol address, to catch impersonators.
528 * We no longer handle negotiations for use of trailer protocol:
529 * Formerly, ARP replied for protocol type ETHERTYPE_TRAIL sent
530 * along with IP replies if we wanted trailers sent to us,
531 * and also sent them in response to IP replies.
532 * This allowed either end to announce the desire to receive
533 * trailer packets.
534 * We no longer reply to requests for ETHERTYPE_TRAIL protocol either,
535 * but formerly didn't normally send requests.
536 */
537static int log_arp_wrong_iface = 1;
538static int log_arp_movements = 1;
539
540SYSCTL_INT(_net_link_ether_inet, OID_AUTO, log_arp_wrong_iface, CTLFLAG_RW,
541 &log_arp_wrong_iface, 0,
542 "log arp packets arriving on the wrong interface");
543SYSCTL_INT(_net_link_ether_inet, OID_AUTO, log_arp_movements, CTLFLAG_RW,
544 &log_arp_movements, 0,
545 "log arp replies from MACs different than the one in the cache");
546
547
548static void
549in_arpinput(m)
550 struct mbuf *m;
551{
552 register struct arphdr *ah;
553 register struct ifnet *ifp = m->m_pkthdr.rcvif;
554 struct ether_header *eh;
555 struct arc_header *arh;
556 struct iso88025_header *th = (struct iso88025_header *)0;
557 register struct llinfo_arp *la = 0;
558 register struct rtentry *rt;
559 struct ifaddr *ifa;
560 struct in_ifaddr *ia;
561 struct sockaddr_dl *sdl;
562 struct sockaddr sa;
563 struct in_addr isaddr, itaddr, myaddr;
564 int op, rif_len;
565 int req_len;
566
567 req_len = arphdr_len2(ifp->if_addrlen, sizeof(struct in_addr));
568 if (m->m_len < req_len && (m = m_pullup(m, req_len)) == NULL) {
569 log(LOG_ERR, "in_arp: runt packet -- m_pullup failed\n");
570 return;
571 }
572
573 ah = mtod(m, struct arphdr *);
574 op = ntohs(ah->ar_op);
575 (void)memcpy(&isaddr, ar_spa(ah), sizeof (isaddr));
576 (void)memcpy(&itaddr, ar_tpa(ah), sizeof (itaddr));
577#ifdef BRIDGE
578#define BRIDGE_TEST (do_bridge)
579#else
580#define BRIDGE_TEST (0) /* cc will optimise the test away */
581#endif
582 /*
583 * For a bridge, we want to check the address irrespective
584 * of the receive interface. (This will change slightly
585 * when we have clusters of interfaces).
586 */
587 LIST_FOREACH(ia, INADDR_HASH(itaddr.s_addr), ia_hash)
588 if ((BRIDGE_TEST || (ia->ia_ifp == ifp)) &&
589 itaddr.s_addr == ia->ia_addr.sin_addr.s_addr)
590 goto match;
591 LIST_FOREACH(ia, INADDR_HASH(isaddr.s_addr), ia_hash)
592 if ((BRIDGE_TEST || (ia->ia_ifp == ifp)) &&
593 isaddr.s_addr == ia->ia_addr.sin_addr.s_addr)
594 goto match;
595 /*
596 * No match, use the first address on the receive interface
597 * as a dummy address for the rest of the function.
598 */
599 ifa = TAILQ_FIRST(&ifp->if_addrhead);
600 if (ifa == NULL) {
601 m_freem(m);
602 return;
603 }
604 ia = ifatoia(ifa);
605match:
606 myaddr = ia->ia_addr.sin_addr;
607 if (!bcmp(ar_sha(ah), IF_LLADDR(ifp), ifp->if_addrlen)) {
608 m_freem(m); /* it's from me, ignore it. */
609 return;
610 }
611 if (!bcmp(ar_sha(ah), ifp->if_broadcastaddr, ifp->if_addrlen)) {
612 log(LOG_ERR,
613 "arp: link address is broadcast for IP address %s!\n",
614 inet_ntoa(isaddr));
615 m_freem(m);
616 return;
617 }
618 if (isaddr.s_addr == myaddr.s_addr) {
619 log(LOG_ERR,
620 "arp: %*D is using my IP address %s!\n",
621 ifp->if_addrlen, (u_char *)ar_sha(ah), ":",
622 inet_ntoa(isaddr));
623 itaddr = myaddr;
624 goto reply;
625 }
626 la = arplookup(isaddr.s_addr, itaddr.s_addr == myaddr.s_addr, 0);
627 if (la && (rt = la->la_rt) && (sdl = SDL(rt->rt_gateway))) {
628 /* the following is not an error when doing bridging */
629 if (!BRIDGE_TEST && rt->rt_ifp != ifp) {
630 if (log_arp_wrong_iface)
631 log(LOG_ERR, "arp: %s is on %s%d but got reply from %*D on %s%d\n",
632 inet_ntoa(isaddr),
633 rt->rt_ifp->if_name, rt->rt_ifp->if_unit,
634 ifp->if_addrlen, (u_char *)ar_sha(ah), ":",
635 ifp->if_name, ifp->if_unit);
636 goto reply;
637 }
638 if (sdl->sdl_alen &&
639 bcmp(ar_sha(ah), LLADDR(sdl), sdl->sdl_alen)) {
640 if (rt->rt_expire) {
641 if (log_arp_movements)
642 log(LOG_INFO, "arp: %s moved from %*D to %*D on %s%d\n",
643 inet_ntoa(isaddr),
644 ifp->if_addrlen, (u_char *)LLADDR(sdl), ":",
645 ifp->if_addrlen, (u_char *)ar_sha(ah), ":",
646 ifp->if_name, ifp->if_unit);
647 } else {
648 log(LOG_ERR,
649 "arp: %*D attempts to modify permanent entry for %s on %s%d\n",
650 ifp->if_addrlen, (u_char *)ar_sha(ah), ":",
651 inet_ntoa(isaddr), ifp->if_name, ifp->if_unit);
652 goto reply;
653 }
654 }
655 /*
656 * sanity check for the address length.
657 * XXX this does not work for protocols with variable address
658 * length. -is
659 */
660 if (sdl->sdl_alen &&
661 sdl->sdl_alen != ah->ar_hln) {
662 log(LOG_WARNING,
663 "arp from %*D: new addr len %d, was %d",
664 ifp->if_addrlen, (u_char *) ar_sha(ah), ":",
665 ah->ar_hln, sdl->sdl_alen);
666 }
667 if (ifp->if_addrlen != ah->ar_hln) {
668 log(LOG_WARNING,
669 "arp from %*D: addr len: new %d, i/f %d (ignored)",
670 ifp->if_addrlen, (u_char *) ar_sha(ah), ":",
671 ah->ar_hln, ifp->if_addrlen);
672 goto reply;
673 }
674 (void)memcpy(LLADDR(sdl), ar_sha(ah),
675 sdl->sdl_alen = ah->ar_hln);
676 sdl->sdl_rcf = (u_short)0;
677 /*
678 * If we receive an arp from a token-ring station over
679 * a token-ring nic then try to save the source
680 * routing info.
681 */
682 if (ifp->if_type == IFT_ISO88025) {
683 th = (struct iso88025_header *)m->m_pkthdr.header;
684 rif_len = TR_RCF_RIFLEN(th->rcf);
685 if ((th->iso88025_shost[0] & TR_RII) &&
686 (rif_len > 2)) {
687 sdl->sdl_rcf = th->rcf;
688 sdl->sdl_rcf ^= htons(TR_RCF_DIR);
689 memcpy(sdl->sdl_route, th->rd, rif_len - 2);
690 sdl->sdl_rcf &= ~htons(TR_RCF_BCST_MASK);
691 /*
692 * Set up source routing information for
693 * reply packet (XXX)
694 */
695 m->m_data -= rif_len;
696 m->m_len += rif_len;
697 m->m_pkthdr.len += rif_len;
698 } else {
699 th->iso88025_shost[0] &= ~TR_RII;
700 }
701 m->m_data -= 8;
702 m->m_len += 8;
703 m->m_pkthdr.len += 8;
704 th->rcf = sdl->sdl_rcf;
705 } else {
706 sdl->sdl_rcf = (u_short)0;
707 }
708 if (rt->rt_expire)
709 rt->rt_expire = time_second + arpt_keep;
710 rt->rt_flags &= ~RTF_REJECT;
711 la->la_asked = 0;
712 if (la->la_hold) {
713 (*ifp->if_output)(ifp, la->la_hold,
714 rt_key(rt), rt);
715 la->la_hold = 0;
716 }
717 }
718reply:
719 if (op != ARPOP_REQUEST) {
720 m_freem(m);
721 return;
722 }
723 if (itaddr.s_addr == myaddr.s_addr) {
724 /* I am the target */
725 (void)memcpy(ar_tha(ah), ar_sha(ah), ah->ar_hln);
726 (void)memcpy(ar_sha(ah), IF_LLADDR(ifp), ah->ar_hln);
727 } else {
728 la = arplookup(itaddr.s_addr, 0, SIN_PROXY);
729 if (la == NULL) {
730 struct sockaddr_in sin;
731
732 if (!arp_proxyall) {
733 m_freem(m);
734 return;
735 }
736
737 bzero(&sin, sizeof sin);
738 sin.sin_family = AF_INET;
739 sin.sin_len = sizeof sin;
740 sin.sin_addr = itaddr;
741
742 rt = rtalloc1((struct sockaddr *)&sin, 0, 0UL);
743 if (!rt) {
744 m_freem(m);
745 return;
746 }
747 /*
748 * Don't send proxies for nodes on the same interface
749 * as this one came out of, or we'll get into a fight
750 * over who claims what Ether address.
751 */
752 if (rt->rt_ifp == ifp) {
753 rtfree(rt);
754 m_freem(m);
755 return;
756 }
757 (void)memcpy(ar_tha(ah), ar_sha(ah), ah->ar_hln);
758 (void)memcpy(ar_sha(ah), IF_LLADDR(ifp), ah->ar_hln);
759 rtfree(rt);
760
761 /*
762 * Also check that the node which sent the ARP packet
763 * is on the the interface we expect it to be on. This
764 * avoids ARP chaos if an interface is connected to the
765 * wrong network.
766 */
767 sin.sin_addr = isaddr;
768
769 rt = rtalloc1((struct sockaddr *)&sin, 0, 0UL);
770 if (!rt) {
771 m_freem(m);
772 return;
773 }
774 if (rt->rt_ifp != ifp) {
775 log(LOG_INFO, "arp_proxy: ignoring request"
776 " from %s via %s%d, expecting %s%d\n",
777 inet_ntoa(isaddr), ifp->if_name,
778 ifp->if_unit, rt->rt_ifp->if_name,
779 rt->rt_ifp->if_unit);
780 rtfree(rt);
781 m_freem(m);
782 return;
783 }
784 rtfree(rt);
785
786#ifdef DEBUG_PROXY
787 printf("arp: proxying for %s\n",
788 inet_ntoa(itaddr));
789#endif
790 } else {
791 rt = la->la_rt;
792 (void)memcpy(ar_tha(ah), ar_sha(ah), ah->ar_hln);
793 sdl = SDL(rt->rt_gateway);
794 (void)memcpy(ar_sha(ah), LLADDR(sdl), ah->ar_hln);
795 }
796 }
797
798 (void)memcpy(ar_tpa(ah), ar_spa(ah), ah->ar_pln);
799 (void)memcpy(ar_spa(ah), &itaddr, ah->ar_pln);
800 ah->ar_op = htons(ARPOP_REPLY);
801 ah->ar_pro = htons(ETHERTYPE_IP); /* let's be sure! */
802 switch (ifp->if_type) {
803 case IFT_ARCNET:
804 arh = (struct arc_header *)sa.sa_data;
805 arh->arc_dhost = *ar_tha(ah);
806 arh->arc_type = ARCTYPE_ARP;
807 break;
808
809 case IFT_ISO88025:
810 /* Re-arrange the source/dest address */
811 memcpy(th->iso88025_dhost, th->iso88025_shost,
812 sizeof(th->iso88025_dhost));
813 memcpy(th->iso88025_shost, IF_LLADDR(ifp),
814 sizeof(th->iso88025_shost));
815 /* Set the source routing bit if neccesary */
816 if (th->iso88025_dhost[0] & TR_RII) {
817 th->iso88025_dhost[0] &= ~TR_RII;
818 if (TR_RCF_RIFLEN(th->rcf) > 2)
819 th->iso88025_shost[0] |= TR_RII;
820 }
821 /* Copy the addresses, ac and fc into sa_data */
822 memcpy(sa.sa_data, th->iso88025_dhost,
823 sizeof(th->iso88025_dhost) * 2);
824 sa.sa_data[(sizeof(th->iso88025_dhost) * 2)] = TR_AC;
825 sa.sa_data[(sizeof(th->iso88025_dhost) * 2) + 1] = TR_LLC_FRAME;
826 break;
827 case IFT_ETHER:
828 case IFT_FDDI:
829 /*
830 * May not be correct for types not explictly
831 * listed, but it is our best guess.
832 */
833 default:
834 eh = (struct ether_header *)sa.sa_data;
835 (void)memcpy(eh->ether_dhost, ar_tha(ah),
836 sizeof(eh->ether_dhost));
837 eh->ether_type = htons(ETHERTYPE_ARP);
838 break;
839 }
840 sa.sa_family = AF_UNSPEC;
841 sa.sa_len = sizeof(sa);
842 (*ifp->if_output)(ifp, m, &sa, (struct rtentry *)0);
843 return;
844}
845#endif
846
847/*
848 * Free an arp entry.
849 */
850static void
851arptfree(la)
852 register struct llinfo_arp *la;
853{
854 register struct rtentry *rt = la->la_rt;
855 register struct sockaddr_dl *sdl;
856 if (rt == 0)
857 panic("arptfree");
858 if (rt->rt_refcnt > 0 && (sdl = SDL(rt->rt_gateway)) &&
859 sdl->sdl_family == AF_LINK) {
860 sdl->sdl_alen = 0;
861 la->la_asked = 0;
862 rt->rt_flags &= ~RTF_REJECT;
863 return;
864 }
865 rtrequest(RTM_DELETE, rt_key(rt), (struct sockaddr *)0, rt_mask(rt),
866 0, (struct rtentry **)0);
867}
868/*
869 * Lookup or enter a new address in arptab.
870 */
871static struct llinfo_arp *
872arplookup(addr, create, proxy)
873 u_long addr;
874 int create, proxy;
875{
876 register struct rtentry *rt;
877 static struct sockaddr_inarp sin = {sizeof(sin), AF_INET };
878 const char *why = 0;
879
880 sin.sin_addr.s_addr = addr;
881 sin.sin_other = proxy ? SIN_PROXY : 0;
882 rt = rtalloc1((struct sockaddr *)&sin, create, 0UL);
883 if (rt == 0)
884 return (0);
885 rt->rt_refcnt--;
886
887 if (rt->rt_flags & RTF_GATEWAY)
888 why = "host is not on local network";
889 else if ((rt->rt_flags & RTF_LLINFO) == 0)
890 why = "could not allocate llinfo";
891 else if (rt->rt_gateway->sa_family != AF_LINK)
892 why = "gateway route is not ours";
893
894 if (why && create) {
895 log(LOG_DEBUG, "arplookup %s failed: %s\n",
896 inet_ntoa(sin.sin_addr), why);
897 return 0;
898 } else if (why) {
899 return 0;
900 }
901 return ((struct llinfo_arp *)rt->rt_llinfo);
902}
903
904void
905arp_ifinit(ifp, ifa)
906 struct ifnet *ifp;
907 struct ifaddr *ifa;
908{
909 if (ntohl(IA_SIN(ifa)->sin_addr.s_addr) != INADDR_ANY)
910 arprequest(ifp, &IA_SIN(ifa)->sin_addr,
911 &IA_SIN(ifa)->sin_addr, IF_LLADDR(ifp));
912 ifa->ifa_rtrequest = arp_rtrequest;
913 ifa->ifa_flags |= RTF_CLONING;
914}
915
916static void
917arp_init(void)
918{
919
920 arpintrq.ifq_maxlen = 50;
921 mtx_init(&arpintrq.ifq_mtx, "arp_inq", MTX_DEF);
922}
923
924SYSINIT(arp, SI_SUB_PROTO_DOMAIN, SI_ORDER_ANY, arp_init, 0);
|