123172Smckusick /* 235794Skarels * Copyright (c) 1982, 1986, 1988 Regents of the University of California. 332787Sbostic * All rights reserved. 423172Smckusick * 544471Sbostic * %sccs.include.redist.c% 632787Sbostic * 7*54716Ssklower * @(#)if_ether.c 7.24 (Berkeley) 07/06/92 823172Smckusick */ 911570Ssam 1011570Ssam /* 1111570Ssam * Ethernet address resolution protocol. 1232346Skarels * TODO: 1332346Skarels * add "inuse/lock" bit (or ref. count) along with valid bit 1411570Ssam */ 1511570Ssam 1617057Sbloom #include "param.h" 1717057Sbloom #include "systm.h" 1835794Skarels #include "malloc.h" 1917057Sbloom #include "mbuf.h" 2017057Sbloom #include "socket.h" 2117057Sbloom #include "time.h" 2217057Sbloom #include "kernel.h" 2317057Sbloom #include "errno.h" 2417057Sbloom #include "ioctl.h" 2525890Skarels #include "syslog.h" 2611570Ssam 2711570Ssam #include "../net/if.h" 2850135Ssklower #include "../net/if_dl.h" 2950135Ssklower #include "../net/route.h" 3050135Ssklower 3117057Sbloom #include "in.h" 3217057Sbloom #include "in_systm.h" 3337471Ssklower #include "in_var.h" 3417057Sbloom #include "ip.h" 3517057Sbloom #include "if_ether.h" 3611570Ssam 3750135Ssklower #define SIN(s) ((struct sockaddr_in *)s) 3850135Ssklower #define SDL(s) ((struct sockaddr_dl *)s) 3950135Ssklower #define SRP(s) ((struct sockaddr_inarp *)s) 4011570Ssam 4125890Skarels /* 4225890Skarels * ARP trailer negotiation. Trailer protocol is not IP specific, 4325890Skarels * but ARP request/response use IP addresses. 4425890Skarels */ 4525890Skarels #define ETHERTYPE_IPTRAILERS ETHERTYPE_TRAIL 4625890Skarels 4711570Ssam 4811570Ssam /* timer values */ 4950135Ssklower int arpt_prune = (5*60*1); /* walk list every 5 minutes */ 5050135Ssklower int arpt_keep = (20*60); /* once resolved, good for 20 more minutes */ 5150135Ssklower int arpt_down = 20; /* once declared down, don't send for 20 secs */ 52*54716Ssklower #define rt_expire rt_rmx.rmx_expire 5311570Ssam 54*54716Ssklower static void arprequest __P((struct arpcom *, u_long *, u_long *, u_char *)); 55*54716Ssklower static void arptfree __P((struct llinfo_arp *)); 56*54716Ssklower static struct llinfo_arp *arplookup __P((u_long, int, int)); 57*54716Ssklower static void arpcatchme __P(()); 58*54716Ssklower 59*54716Ssklower extern struct ifnet loif; 60*54716Ssklower extern struct timeval time; 61*54716Ssklower struct llinfo_arp llinfo_arp = {&llinfo_arp, &llinfo_arp}; 62*54716Ssklower struct ifqueue arpintrq = {0, 0, 0, 50}; 6350135Ssklower int arp_inuse, arp_allocated, arp_intimer; 6450135Ssklower int arp_maxtries = 5; 6550135Ssklower int useloopback = 1; /* use loopback interface for local traffic */ 6650135Ssklower int arpinit_done = 0; 6711570Ssam 6814867Ssam /* 6950135Ssklower * Timeout routine. Age arp_tab entries periodically. 7011570Ssam */ 71*54716Ssklower void 7211570Ssam arptimer() 7311570Ssam { 7450135Ssklower int s = splnet(); 7550135Ssklower register struct llinfo_arp *la = llinfo_arp.la_next; 7611570Ssam 7750135Ssklower timeout(arptimer, (caddr_t)0, arpt_prune * hz); 7850135Ssklower while (la != &llinfo_arp) { 7950135Ssklower register struct rtentry *rt = la->la_rt; 8050135Ssklower la = la->la_next; 8150135Ssklower if (rt->rt_expire && rt->rt_expire <= time.tv_sec) 8250135Ssklower arptfree(la->la_prev); /* timer has expired, clear */ 8311570Ssam } 8450135Ssklower splx(s); 8511570Ssam } 8611570Ssam 8711570Ssam /* 88*54716Ssklower * Parallel to llc_rtrequest. 8950135Ssklower */ 90*54716Ssklower void 9150135Ssklower arp_rtrequest(req, rt, sa) 9250135Ssklower int req; 9350135Ssklower register struct rtentry *rt; 9450135Ssklower struct sockaddr *sa; 9550135Ssklower { 9650135Ssklower register struct sockaddr *gate = rt->rt_gateway; 9750135Ssklower register struct llinfo_arp *la = (struct llinfo_arp *)rt->rt_llinfo; 9850135Ssklower static struct sockaddr_dl null_sdl = {sizeof(null_sdl), AF_LINK}; 9950135Ssklower 10050135Ssklower if (!arpinit_done) { 10150135Ssklower arpinit_done = 1; 10250135Ssklower timeout(arptimer, (caddr_t)0, hz); 10350135Ssklower } 10450135Ssklower if (rt->rt_flags & RTF_GATEWAY) 10550135Ssklower return; 10650135Ssklower switch (req) { 107*54716Ssklower 10850135Ssklower case RTM_ADD: 109*54716Ssklower /* 110*54716Ssklower * XXX: If this is a manually added route to interface 111*54716Ssklower * such as older version of routed or gated might provide, 112*54716Ssklower * restore cloning bit. 113*54716Ssklower */ 11452657Ssklower if ((rt->rt_flags & RTF_HOST) == 0 && 11552657Ssklower SIN(rt_mask(rt))->sin_addr.s_addr != 0xffffffff) 116*54716Ssklower rt->rt_flags |= RTF_CLONING; 11750135Ssklower if (rt->rt_flags & RTF_CLONING) { 11850135Ssklower /* 11950135Ssklower * Case 1: This route should come from a route to iface. 12050135Ssklower */ 12150135Ssklower rt_setgate(rt, rt_key(rt), &null_sdl); 12250135Ssklower gate = rt->rt_gateway; 12350135Ssklower SDL(gate)->sdl_type = rt->rt_ifp->if_type; 12450135Ssklower SDL(gate)->sdl_index = rt->rt_ifp->if_index; 12550135Ssklower rt->rt_expire = time.tv_sec; 12650135Ssklower break; 12750135Ssklower } 128*54716Ssklower /* Announce a new entry if requested. */ 129*54716Ssklower if (rt->rt_flags & RTF_ANNOUNCE) 130*54716Ssklower arprequest((struct arpcom *)rt->rt_ifp, 131*54716Ssklower &SIN(rt_key(rt))->sin_addr.s_addr, 132*54716Ssklower &SIN(rt_key(rt))->sin_addr.s_addr, 133*54716Ssklower (u_char *)LLADDR(SDL(gate))); 134*54716Ssklower /*FALLTHROUGH*/ 135*54716Ssklower case RTM_RESOLVE: 13650135Ssklower if (gate->sa_family != AF_LINK || 13750135Ssklower gate->sa_len < sizeof(null_sdl)) { 13850135Ssklower log(LOG_DEBUG, "arp_rtrequest: bad gateway value"); 13950135Ssklower break; 14050135Ssklower } 14150135Ssklower SDL(gate)->sdl_type = rt->rt_ifp->if_type; 14250135Ssklower SDL(gate)->sdl_index = rt->rt_ifp->if_index; 14350135Ssklower if (la != 0) 14450135Ssklower break; /* This happens on a route change */ 14550135Ssklower /* 14650135Ssklower * Case 2: This route may come from cloning, or a manual route 14750135Ssklower * add with a LL address. 14850135Ssklower */ 14950135Ssklower R_Malloc(la, struct llinfo_arp *, sizeof(*la)); 15050135Ssklower rt->rt_llinfo = (caddr_t)la; 15150135Ssklower if (la == 0) { 15250135Ssklower log(LOG_DEBUG, "arp_rtrequest: malloc failed\n"); 15350135Ssklower break; 15450135Ssklower } 15550135Ssklower arp_inuse++, arp_allocated++; 15650135Ssklower Bzero(la, sizeof(*la)); 15750135Ssklower la->la_rt = rt; 15850135Ssklower rt->rt_flags |= RTF_LLINFO; 15950135Ssklower insque(la, &llinfo_arp); 16050135Ssklower if (SIN(rt_key(rt))->sin_addr.s_addr == 16150135Ssklower (IA_SIN(rt->rt_ifa))->sin_addr.s_addr) { 16250135Ssklower /* 16350135Ssklower * This test used to be 16450135Ssklower * if (loif.if_flags & IFF_UP) 16550135Ssklower * It allowed local traffic to be forced 16650135Ssklower * through the hardware by configuring the loopback down. 16750135Ssklower * However, it causes problems during network configuration 16850135Ssklower * for boards that can't receive packets they send. 16950135Ssklower * It is now necessary to clear "useloopback" and remove 17050135Ssklower * the route to force traffic out to the hardware. 17150135Ssklower */ 17250135Ssklower rt->rt_expire = 0; 17350135Ssklower Bcopy(((struct arpcom *)rt->rt_ifp)->ac_enaddr, 17450135Ssklower LLADDR(SDL(gate)), SDL(gate)->sdl_alen = 6); 17550135Ssklower if (useloopback) 17650135Ssklower rt->rt_ifp = &loif; 177*54716Ssklower 17850135Ssklower } 17950135Ssklower break; 18050135Ssklower 18150135Ssklower case RTM_DELETE: 18250135Ssklower if (la == 0) 18350135Ssklower break; 18450135Ssklower arp_inuse--; 18550135Ssklower remque(la); 18650135Ssklower rt->rt_llinfo = 0; 18750135Ssklower rt->rt_flags &= ~RTF_LLINFO; 18850135Ssklower if (la->la_hold) 18950135Ssklower m_freem(la->la_hold); 19050135Ssklower Free((caddr_t)la); 19150135Ssklower } 19250135Ssklower } 19350135Ssklower 19450135Ssklower /* 19511570Ssam * Broadcast an ARP packet, asking who has addr on interface ac. 19611570Ssam */ 19752276Ssklower void 19811570Ssam arpwhohas(ac, addr) 19911570Ssam register struct arpcom *ac; 200*54716Ssklower register struct in_addr *addr; 20111570Ssam { 202*54716Ssklower arprequest(ac, &ac->ac_ipaddr.s_addr, &addr->s_addr, ac->ac_enaddr); 203*54716Ssklower } 204*54716Ssklower 205*54716Ssklower /* 206*54716Ssklower * Broadcast an ARP request. Caller specifies: 207*54716Ssklower * - arp header source ip address 208*54716Ssklower * - arp header target ip address 209*54716Ssklower * - arp header source ethernet address 210*54716Ssklower */ 211*54716Ssklower static void 212*54716Ssklower arprequest(ac, sip, tip, enaddr) 213*54716Ssklower register struct arpcom *ac; 214*54716Ssklower register u_long *sip, *tip; 215*54716Ssklower register u_char *enaddr; 216*54716Ssklower { 21711570Ssam register struct mbuf *m; 21811570Ssam register struct ether_header *eh; 21911570Ssam register struct ether_arp *ea; 22011570Ssam struct sockaddr sa; 22111570Ssam 22235794Skarels if ((m = m_gethdr(M_DONTWAIT, MT_DATA)) == NULL) 22326380Skarels return; 22435794Skarels m->m_len = sizeof(*ea); 22535794Skarels m->m_pkthdr.len = sizeof(*ea); 22635794Skarels MH_ALIGN(m, sizeof(*ea)); 22711570Ssam ea = mtod(m, struct ether_arp *); 22811570Ssam eh = (struct ether_header *)sa.sa_data; 22912763Ssam bzero((caddr_t)ea, sizeof (*ea)); 23018640Skarels bcopy((caddr_t)etherbroadcastaddr, (caddr_t)eh->ether_dhost, 23118640Skarels sizeof(eh->ether_dhost)); 23218378Skarels eh->ether_type = ETHERTYPE_ARP; /* if_output will swap */ 23311570Ssam ea->arp_hrd = htons(ARPHRD_ETHER); 23418378Skarels ea->arp_pro = htons(ETHERTYPE_IP); 23518640Skarels ea->arp_hln = sizeof(ea->arp_sha); /* hardware address length */ 23618640Skarels ea->arp_pln = sizeof(ea->arp_spa); /* protocol address length */ 23711570Ssam ea->arp_op = htons(ARPOP_REQUEST); 238*54716Ssklower bcopy((caddr_t)enaddr, (caddr_t)ea->arp_sha, sizeof(ea->arp_sha)); 239*54716Ssklower bcopy((caddr_t)sip, (caddr_t)ea->arp_spa, sizeof(ea->arp_spa)); 240*54716Ssklower bcopy((caddr_t)tip, (caddr_t)ea->arp_tpa, sizeof(ea->arp_tpa)); 24111570Ssam sa.sa_family = AF_UNSPEC; 24236819Skarels sa.sa_len = sizeof(sa); 24340796Ssklower (*ac->ac_if.if_output)(&ac->ac_if, m, &sa, (struct rtentry *)0); 24411570Ssam } 24511570Ssam 24611570Ssam /* 247*54716Ssklower * Resolve an IP address into an ethernet address. If success, 24825890Skarels * desten is filled in. If there is no entry in arptab, 24925890Skarels * set one up and broadcast a request for the IP address. 25025890Skarels * Hold onto this mbuf and resend it once the address 25125890Skarels * is finally resolved. A return value of 1 indicates 25225890Skarels * that desten has been filled in and the packet should be sent 25325890Skarels * normally; a 0 return indicates that the packet has been 25425890Skarels * taken over here, either now or for later transmission. 25511570Ssam */ 256*54716Ssklower int 257*54716Ssklower arpresolve(ac, rt, m, dst, desten) 25811570Ssam register struct arpcom *ac; 25950135Ssklower register struct rtentry *rt; 26011570Ssam struct mbuf *m; 26150135Ssklower register struct sockaddr *dst; 26218640Skarels register u_char *desten; 26311570Ssam { 26450135Ssklower register struct llinfo_arp *la; 26550135Ssklower struct sockaddr_dl *sdl; 26611570Ssam 26735794Skarels if (m->m_flags & M_BCAST) { /* broadcast */ 26818640Skarels bcopy((caddr_t)etherbroadcastaddr, (caddr_t)desten, 26918640Skarels sizeof(etherbroadcastaddr)); 27011570Ssam return (1); 27111570Ssam } 272*54716Ssklower #ifdef MULTICAST 273*54716Ssklower if (m->m_flags & M_MCAST) { /* multicast */ 274*54716Ssklower ETHER_MAP_IP_MULTICAST(&SIN(dst)->sin_addr, desten); 275*54716Ssklower return(1); 276*54716Ssklower } 277*54716Ssklower #endif 27850135Ssklower if (rt) 27950135Ssklower la = (struct llinfo_arp *)rt->rt_llinfo; 28050135Ssklower else { 281*54716Ssklower if (la = arplookup(SIN(dst)->sin_addr.s_addr, 1, 0)) 28250135Ssklower rt = la->la_rt; 28311570Ssam } 28450135Ssklower if (la == 0 || rt == 0) { 28550135Ssklower log(LOG_DEBUG, "arpresolve: can't allocate llinfo"); 28650135Ssklower m_freem(m); 28750135Ssklower return (0); 28811570Ssam } 28950135Ssklower sdl = SDL(rt->rt_gateway); 29050135Ssklower /* 29150135Ssklower * Check the address family and length is valid, the address 29250135Ssklower * is resolved; otherwise, try to resolve. 29350135Ssklower */ 29450135Ssklower if ((rt->rt_expire == 0 || rt->rt_expire > time.tv_sec) && 29550135Ssklower sdl->sdl_family == AF_LINK && sdl->sdl_alen != 0) { 29650135Ssklower bcopy(LLADDR(sdl), desten, sdl->sdl_alen); 29750135Ssklower return 1; 29811570Ssam } 29911570Ssam /* 30011570Ssam * There is an arptab entry, but no ethernet address 30111570Ssam * response yet. Replace the held mbuf with this 30211570Ssam * latest one. 30311570Ssam */ 30450135Ssklower if (la->la_hold) 30550135Ssklower m_freem(la->la_hold); 30650135Ssklower la->la_hold = m; 30750135Ssklower if (rt->rt_expire) { 30850135Ssklower rt->rt_flags &= ~RTF_REJECT; 30950135Ssklower if (la->la_asked == 0 || rt->rt_expire != time.tv_sec) { 31050135Ssklower rt->rt_expire = time.tv_sec; 31150135Ssklower if (la->la_asked++ < arp_maxtries) 31250135Ssklower arpwhohas(ac, &(SIN(dst)->sin_addr)); 31350135Ssklower else { 31450135Ssklower rt->rt_flags |= RTF_REJECT; 31550135Ssklower rt->rt_expire += arpt_down; 31650135Ssklower la->la_asked = 0; 31750135Ssklower } 31850135Ssklower 31950135Ssklower } 32050135Ssklower } 32111570Ssam return (0); 32211570Ssam } 32311570Ssam 32411570Ssam /* 32550135Ssklower * Common length and type checks are done here, 32625890Skarels * then the protocol-specific routine is called. 32725890Skarels */ 328*54716Ssklower void 32950135Ssklower arpintr() 33025890Skarels { 33150135Ssklower register struct mbuf *m; 33225890Skarels register struct arphdr *ar; 33350135Ssklower int s; 33425890Skarels 33550135Ssklower while (arpintrq.ifq_head) { 33650135Ssklower s = splimp(); 33750135Ssklower IF_DEQUEUE(&arpintrq, m); 33850135Ssklower splx(s); 33950135Ssklower if (m == 0 || (m->m_flags & M_PKTHDR) == 0) 34050135Ssklower panic("arpintr"); 34150135Ssklower if (m->m_len >= sizeof(struct arphdr) && 34250135Ssklower (ar = mtod(m, struct arphdr *)) && 34350135Ssklower ntohs(ar->ar_hrd) == ARPHRD_ETHER && 34450135Ssklower m->m_len >= 34550135Ssklower sizeof(struct arphdr) + 2 * ar->ar_hln + 2 * ar->ar_pln) 34625890Skarels 34750135Ssklower switch (ntohs(ar->ar_pro)) { 34825890Skarels 34950135Ssklower case ETHERTYPE_IP: 35050135Ssklower case ETHERTYPE_IPTRAILERS: 35150135Ssklower in_arpinput(m); 35250135Ssklower continue; 35350135Ssklower } 35450135Ssklower m_freem(m); 35525890Skarels } 35625890Skarels } 35725890Skarels 35825890Skarels /* 35925890Skarels * ARP for Internet protocols on 10 Mb/s Ethernet. 36025890Skarels * Algorithm is that given in RFC 826. 36111570Ssam * In addition, a sanity check is performed on the sender 36211570Ssam * protocol address, to catch impersonators. 363*54716Ssklower * We no longer handle negotiations for use of trailer protocol: 364*54716Ssklower * Formerly, ARP replied for protocol type ETHERTYPE_TRAIL sent 365*54716Ssklower * along with IP replies if we wanted trailers sent to us, 366*54716Ssklower * and also sent them in response to IP replies. 367*54716Ssklower * This allowed either end to announce the desire to receive 36825890Skarels * trailer packets. 369*54716Ssklower * We no longer reply to requests for ETHERTYPE_TRAIL protocol either, 370*54716Ssklower * but formerly didn't normally send requests. 37111570Ssam */ 37252275Storek void 37350135Ssklower in_arpinput(m) 37411570Ssam struct mbuf *m; 37511570Ssam { 37611570Ssam register struct ether_arp *ea; 37750135Ssklower register struct arpcom *ac = (struct arpcom *)m->m_pkthdr.rcvif; 37811570Ssam struct ether_header *eh; 37951272Ssklower register struct llinfo_arp *la = 0; 38050135Ssklower register struct rtentry *rt; 38150135Ssklower struct in_ifaddr *ia, *maybe_ia = 0; 38225890Skarels struct mbuf *mcopy = 0; 38350135Ssklower struct sockaddr_dl *sdl; 38411570Ssam struct sockaddr sa; 38525890Skarels struct in_addr isaddr, itaddr, myaddr; 386*54716Ssklower int op; 38711570Ssam 38811570Ssam ea = mtod(m, struct ether_arp *); 38925890Skarels op = ntohs(ea->arp_op); 39032346Skarels bcopy((caddr_t)ea->arp_spa, (caddr_t)&isaddr, sizeof (isaddr)); 39132346Skarels bcopy((caddr_t)ea->arp_tpa, (caddr_t)&itaddr, sizeof (itaddr)); 39237471Ssklower for (ia = in_ifaddr; ia; ia = ia->ia_next) 39337471Ssklower if (ia->ia_ifp == &ac->ac_if) { 39437471Ssklower maybe_ia = ia; 39537471Ssklower if ((itaddr.s_addr == ia->ia_addr.sin_addr.s_addr) || 39637471Ssklower (isaddr.s_addr == ia->ia_addr.sin_addr.s_addr)) 39737471Ssklower break; 39837471Ssklower } 39937471Ssklower if (maybe_ia == 0) 40037471Ssklower goto out; 40137471Ssklower myaddr = ia ? ia->ia_addr.sin_addr : maybe_ia->ia_addr.sin_addr; 40218640Skarels if (!bcmp((caddr_t)ea->arp_sha, (caddr_t)ac->ac_enaddr, 40335794Skarels sizeof (ea->arp_sha))) 40411570Ssam goto out; /* it's from me, ignore it. */ 40525890Skarels if (!bcmp((caddr_t)ea->arp_sha, (caddr_t)etherbroadcastaddr, 40625890Skarels sizeof (ea->arp_sha))) { 40725890Skarels log(LOG_ERR, 40825890Skarels "arp: ether address is broadcast for IP address %x!\n", 40925890Skarels ntohl(isaddr.s_addr)); 41025890Skarels goto out; 41125890Skarels } 41211570Ssam if (isaddr.s_addr == myaddr.s_addr) { 41336819Skarels log(LOG_ERR, 41436819Skarels "duplicate IP address %x!! sent from ethernet address: %s\n", 41536819Skarels ntohl(isaddr.s_addr), ether_sprintf(ea->arp_sha)); 41616221Skarels itaddr = myaddr; 417*54716Ssklower goto reply; 41811570Ssam } 41950135Ssklower la = arplookup(isaddr.s_addr, itaddr.s_addr == myaddr.s_addr, 0); 42050135Ssklower if (la && (rt = la->la_rt) && (sdl = SDL(rt->rt_gateway))) { 42150135Ssklower if (sdl->sdl_alen && 42250135Ssklower bcmp((caddr_t)ea->arp_sha, LLADDR(sdl), sdl->sdl_alen)) 42350135Ssklower log(LOG_INFO, "arp info overwritten for %x by %s\n", 42450135Ssklower isaddr.s_addr, ether_sprintf(ea->arp_sha)); 42550135Ssklower bcopy((caddr_t)ea->arp_sha, LLADDR(sdl), 42650135Ssklower sdl->sdl_alen = sizeof(ea->arp_sha)); 42750135Ssklower if (rt->rt_expire) 42850135Ssklower rt->rt_expire = time.tv_sec + arpt_keep; 42950135Ssklower rt->rt_flags &= ~RTF_REJECT; 43050135Ssklower la->la_asked = 0; 43150135Ssklower if (la->la_hold) { 43250135Ssklower (*ac->ac_if.if_output)(&ac->ac_if, la->la_hold, 43350135Ssklower rt_key(rt), rt); 43450135Ssklower la->la_hold = 0; 43511570Ssam } 43618759Skarels } 43711570Ssam reply: 438*54716Ssklower if (op != ARPOP_REQUEST) { 439*54716Ssklower out: 440*54716Ssklower m_freem(m); 441*54716Ssklower return; 44225890Skarels } 44325890Skarels if (itaddr.s_addr == myaddr.s_addr) { 44425890Skarels /* I am the target */ 44525890Skarels bcopy((caddr_t)ea->arp_sha, (caddr_t)ea->arp_tha, 44625890Skarels sizeof(ea->arp_sha)); 44725890Skarels bcopy((caddr_t)ac->ac_enaddr, (caddr_t)ea->arp_sha, 44825890Skarels sizeof(ea->arp_sha)); 44925890Skarels } else { 45050135Ssklower la = arplookup(itaddr.s_addr, 0, SIN_PROXY); 45150135Ssklower if (la == NULL) 45225890Skarels goto out; 45354029Smckusick rt = la->la_rt; 45425890Skarels bcopy((caddr_t)ea->arp_sha, (caddr_t)ea->arp_tha, 45525890Skarels sizeof(ea->arp_sha)); 45654029Smckusick sdl = SDL(rt->rt_gateway); 45750135Ssklower bcopy(LLADDR(sdl), (caddr_t)ea->arp_sha, sizeof(ea->arp_sha)); 45825890Skarels } 45925890Skarels 460*54716Ssklower bcopy((caddr_t)ea->arp_spa, (caddr_t)ea->arp_tpa, sizeof(ea->arp_spa)); 461*54716Ssklower bcopy((caddr_t)&itaddr, (caddr_t)ea->arp_spa, sizeof(ea->arp_spa)); 462*54716Ssklower ea->arp_op = htons(ARPOP_REPLY); 463*54716Ssklower ea->arp_pro = htons(ETHERTYPE_IP); /* let's be sure! */ 46411570Ssam eh = (struct ether_header *)sa.sa_data; 46518640Skarels bcopy((caddr_t)ea->arp_tha, (caddr_t)eh->ether_dhost, 46618640Skarels sizeof(eh->ether_dhost)); 46718378Skarels eh->ether_type = ETHERTYPE_ARP; 46811570Ssam sa.sa_family = AF_UNSPEC; 46936819Skarels sa.sa_len = sizeof(sa); 47040796Ssklower (*ac->ac_if.if_output)(&ac->ac_if, m, &sa, (struct rtentry *)0); 47111570Ssam return; 47211570Ssam } 47311570Ssam 47411570Ssam /* 47550135Ssklower * Free an arp entry. 47611570Ssam */ 477*54716Ssklower static void 47850135Ssklower arptfree(la) 47950135Ssklower register struct llinfo_arp *la; 48011570Ssam { 48150135Ssklower register struct rtentry *rt = la->la_rt; 48250135Ssklower register struct sockaddr_dl *sdl; 48350135Ssklower if (rt == 0) 48450135Ssklower panic("arptfree"); 48550135Ssklower if (rt->rt_refcnt > 0 && (sdl = SDL(rt->rt_gateway)) && 48650135Ssklower sdl->sdl_family == AF_LINK) { 48750135Ssklower sdl->sdl_alen = 0; 48850135Ssklower la->la_asked = 0; 48950135Ssklower rt->rt_flags &= ~RTF_REJECT; 49050135Ssklower return; 49150135Ssklower } 49250135Ssklower rtrequest(RTM_DELETE, rt_key(rt), (struct sockaddr *)0, rt_mask(rt), 49350135Ssklower 0, (struct rtentry **)0); 49411570Ssam } 49511570Ssam /* 49650135Ssklower * Lookup or enter a new address in arptab. 49711570Ssam */ 498*54716Ssklower static struct llinfo_arp * 49950135Ssklower arplookup(addr, create, proxy) 50050135Ssklower u_long addr; 50152948Storek int create, proxy; 50211570Ssam { 50350135Ssklower register struct rtentry *rt; 50450135Ssklower static struct sockaddr_inarp sin = {sizeof(sin), AF_INET }; 50511570Ssam 50650135Ssklower sin.sin_addr.s_addr = addr; 50750135Ssklower sin.sin_other = proxy ? SIN_PROXY : 0; 50850135Ssklower rt = rtalloc1((struct sockaddr *)&sin, create); 50950135Ssklower if (rt == 0) 51050135Ssklower return (0); 51150135Ssklower rt->rt_refcnt--; 512*54716Ssklower if ((rt->rt_flags & RTF_GATEWAY) || (rt->rt_flags & RTF_LLINFO) == 0 || 513*54716Ssklower rt->rt_gateway->sa_family != AF_LINK) { 514*54716Ssklower if (create) 51550135Ssklower log(LOG_DEBUG, "arptnew failed on %x\n", ntohl(addr)); 51650135Ssklower return (0); 51716221Skarels } 51850135Ssklower return ((struct llinfo_arp *)rt->rt_llinfo); 51911570Ssam } 52016221Skarels 521*54716Ssklower int 52216221Skarels arpioctl(cmd, data) 52316221Skarels int cmd; 52416221Skarels caddr_t data; 52516221Skarels { 52650135Ssklower return (EOPNOTSUPP); 52716221Skarels } 528