X-Git-Url: https://git.subgeniuskitty.com/unix-history/.git/blobdiff_plain/1a259c14f0b151b0d480db8a1ceb6fc69ee1dd82..d0461c724668ffddd1d106cccde57f7a41631355:/usr/src/sys/netinet/if_ether.c diff --git a/usr/src/sys/netinet/if_ether.c b/usr/src/sys/netinet/if_ether.c index eedc8bc827..28dd53dcd3 100644 --- a/usr/src/sys/netinet/if_ether.c +++ b/usr/src/sys/netinet/if_ether.c @@ -1,43 +1,67 @@ -/* if_ether.c 6.2 83/08/28 */ +/* + * Copyright (c) 1982, 1986, 1988 Regents of the University of California. + * All rights reserved. + * + * Redistribution and use in source and binary forms are permitted + * provided that the above copyright notice and this paragraph are + * duplicated in all such forms and that any documentation, + * advertising materials, and other materials related to such + * distribution and use acknowledge that the software was developed + * by the University of California, Berkeley. The name of the + * University may not be used to endorse or promote products derived + * from this software without specific prior written permission. + * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED + * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. + * + * @(#)if_ether.c 7.10 (Berkeley) %G% + */ /* * Ethernet address resolution protocol. + * TODO: + * run at splnet (add ARP protocol intr.) + * link entries onto hash chains, keep free list + * add "inuse/lock" bit (or ref. count) along with valid bit */ -#include "../h/param.h" -#include "../h/systm.h" -#include "../h/mbuf.h" -#include "../h/socket.h" -#include "../h/time.h" -#include "../h/kernel.h" -#include "../h/errno.h" +#include "param.h" +#include "systm.h" +#include "malloc.h" +#include "mbuf.h" +#include "socket.h" +#include "time.h" +#include "kernel.h" +#include "errno.h" +#include "ioctl.h" +#include "syslog.h" #include "../net/if.h" -#include "../netinet/in.h" -#include "../netinet/if_ether.h" +#include "in.h" +#include "in_systm.h" +#include "in_var.h" +#include "ip.h" +#include "if_ether.h" - -/* - * Internet to ethernet address resolution table. - */ -struct arptab { - struct in_addr at_iaddr; /* internet address */ - u_char at_enaddr[6]; /* ethernet address */ - struct mbuf *at_hold; /* last packet until resolved/timeout */ - u_char at_timer; /* minutes since last reference */ - u_char at_flags; /* flags */ -}; -/* at_flags field values */ -#define ATF_INUSE 1 /* entry in use */ -#define ATF_COM 2 /* completed entry (enaddr valid) */ - -#define ARPTAB_BSIZ 5 /* bucket size */ +#ifdef GATEWAY +#define ARPTAB_BSIZ 16 /* bucket size */ +#define ARPTAB_NB 37 /* number of buckets */ +#else +#define ARPTAB_BSIZ 9 /* bucket size */ #define ARPTAB_NB 19 /* number of buckets */ +#endif #define ARPTAB_SIZE (ARPTAB_BSIZ * ARPTAB_NB) struct arptab arptab[ARPTAB_SIZE]; +int arptab_size = ARPTAB_SIZE; /* for arp command */ + +/* + * ARP trailer negotiation. Trailer protocol is not IP specific, + * but ARP request/response use IP addresses. + */ +#define ETHERTYPE_IPTRAILERS ETHERTYPE_TRAIL #define ARPTAB_HASH(a) \ - ((short)((((a) >> 16) ^ (a)) & 0x7fff) % ARPTAB_NB) + ((u_long)(a) % ARPTAB_NB) #define ARPTAB_LOOK(at,addr) { \ register n; \ @@ -46,53 +70,16 @@ struct arptab arptab[ARPTAB_SIZE]; if (at->at_iaddr.s_addr == addr) \ break; \ if (n >= ARPTAB_BSIZ) \ - at = 0; } - -struct arpcom *arpcom; /* chain of active ether interfaces */ -int arpt_age; /* aging timer */ + at = 0; \ +} /* timer values */ #define ARPT_AGE (60*1) /* aging timer, 1 min. */ #define ARPT_KILLC 20 /* kill completed entry in 20 mins. */ #define ARPT_KILLI 3 /* kill incomplete entry in 3 minutes */ -u_char etherbroadcastaddr[6] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; extern struct ifnet loif; -/* - * Local addresses in the range oldmap to infinity are - * mapped according to the old mapping scheme. That is, - * mapping of Internet to Ethernet addresses is performed - * by taking the high three bytes of the network interface's - * address and the low three bytes of the local address part. - * This only allows boards from the same manufacturer to - * communicate unless the on-board address is overridden - * (not possible in many manufacture's hardware). - * - * NB: setting oldmap to zero completely disables ARP - * (i.e. identical to setting IFF_NOARP with an ioctl). - */ -int oldmap = 1024; - -/* - * Attach an ethernet interface to the list "arpcom" where - * arptimer() can find it. If first time - * initialization, start arptimer(). - */ -arpattach(ac) - register struct arpcom *ac; -{ - register struct arpcom *acp; - - for (acp = arpcom; acp != (struct arpcom *)0; acp = acp->ac_ac) - if (acp == ac) /* if already on list */ - return; - ac->ac_ac = arpcom; - arpcom = ac; - if (arpcom->ac_ac == 0) /* very first time */ - arptimer(); -} - /* * Timeout routine. Age arp_tab entries once a minute. */ @@ -101,34 +88,16 @@ arptimer() register struct arptab *at; register i; - timeout(arptimer, (caddr_t)0, hz); -#ifdef notdef - if (++arpt_sanity > ARPT_SANITY) { - register struct arpcom *ac; - - /* - * Randomize sanity timer based on my host address. - * Ask who has my own address; if someone else replies, - * then they are impersonating me. - */ - arpt_sanity = arpcom->ac_enaddr[5] & 0x3f; - for (ac = arpcom; ac != (struct arpcom *)-1; ac = ac->ac_ac) - arpwhohas(ac, &((struct sockaddr_in *) - &ac->ac_if.if_addr)->sin_addr); - } -#endif - if (++arpt_age > ARPT_AGE) { - arpt_age = 0; - at = &arptab[0]; - for (i = 0; i < ARPTAB_SIZE; i++, at++) { - if (at->at_flags == 0) - continue; - if (++at->at_timer < ((at->at_flags&ATF_COM) ? - ARPT_KILLC : ARPT_KILLI)) - continue; - /* timer has expired, clear entry */ - arptfree(at); - } + timeout(arptimer, (caddr_t)0, ARPT_AGE * hz); + at = &arptab[0]; + for (i = 0; i < ARPTAB_SIZE; i++, at++) { + if (at->at_flags == 0 || (at->at_flags & ATF_PERM)) + continue; + if (++at->at_timer < ((at->at_flags&ATF_COM) ? + ARPT_KILLC : ARPT_KILLI)) + continue; + /* timer has expired, clear entry */ + arptfree(at); } } @@ -144,85 +113,124 @@ arpwhohas(ac, addr) register struct ether_arp *ea; struct sockaddr sa; - if ((m = m_get(M_DONTWAIT, MT_DATA)) == NULL) + if ((m = m_gethdr(M_DONTWAIT, MT_DATA)) == NULL) return; - m->m_len = sizeof *ea + sizeof *eh; - m->m_off = MMAXOFF - m->m_len; + m->m_len = sizeof(*ea); + m->m_pkthdr.len = sizeof(*ea); + MH_ALIGN(m, sizeof(*ea)); ea = mtod(m, struct ether_arp *); eh = (struct ether_header *)sa.sa_data; bzero((caddr_t)ea, sizeof (*ea)); bcopy((caddr_t)etherbroadcastaddr, (caddr_t)eh->ether_dhost, - sizeof (etherbroadcastaddr)); - eh->ether_type = ETHERPUP_ARPTYPE; /* if_output will swap */ + sizeof(eh->ether_dhost)); + eh->ether_type = ETHERTYPE_ARP; /* if_output will swap */ ea->arp_hrd = htons(ARPHRD_ETHER); - ea->arp_pro = htons(ETHERPUP_IPTYPE); - ea->arp_hln = sizeof ea->arp_sha; /* hardware address length */ - ea->arp_pln = sizeof ea->arp_spa; /* protocol address length */ + ea->arp_pro = htons(ETHERTYPE_IP); + ea->arp_hln = sizeof(ea->arp_sha); /* hardware address length */ + ea->arp_pln = sizeof(ea->arp_spa); /* protocol address length */ ea->arp_op = htons(ARPOP_REQUEST); bcopy((caddr_t)ac->ac_enaddr, (caddr_t)ea->arp_sha, - sizeof (ea->arp_sha)); - bcopy((caddr_t)&((struct sockaddr_in *)&ac->ac_if.if_addr)->sin_addr, - (caddr_t)ea->arp_spa, sizeof (ea->arp_spa)); - bcopy((caddr_t)addr, (caddr_t)ea->arp_tpa, sizeof (ea->arp_tpa)); + sizeof(ea->arp_sha)); + bcopy((caddr_t)&ac->ac_ipaddr, (caddr_t)ea->arp_spa, + sizeof(ea->arp_spa)); + bcopy((caddr_t)addr, (caddr_t)ea->arp_tpa, sizeof(ea->arp_tpa)); sa.sa_family = AF_UNSPEC; - (void) (*ac->ac_if.if_output)(&ac->ac_if, m, &sa); + sa.sa_len = sizeof(sa); + (*ac->ac_if.if_output)(&ac->ac_if, m, &sa); } +int useloopback = 1; /* use loopback interface for local traffic */ + +int useloopback = 1; /* use loopback interface for local traffic */ + /* * Resolve an IP address into an ethernet address. If success, - * desten is filled in and 1 is returned. If there is no entry - * in arptab, set one up and broadcast a request - * for the IP address; return 0. Hold onto this mbuf and - * resend it once the address is finally resolved. + * desten is filled in. If there is no entry in arptab, + * set one up and broadcast a request for the IP address. + * Hold onto this mbuf and resend it once the address + * is finally resolved. A return value of 1 indicates + * that desten has been filled in and the packet should be sent + * normally; a 0 return indicates that the packet has been + * taken over here, either now or for later transmission. * * We do some (conservative) locking here at splimp, since * arptab is also altered from input interrupt service (ecintr/ilintr - * calls arpinput when ETHERPUP_ARPTYPE packets come in). + * calls arpinput when ETHERTYPE_ARP packets come in). */ -arpresolve(ac, m, destip, desten) +arpresolve(ac, m, destip, desten, usetrailers) register struct arpcom *ac; struct mbuf *m; register struct in_addr *destip; register u_char *desten; + int *usetrailers; { register struct arptab *at; - register struct ifnet *ifp; struct sockaddr_in sin; - int s, lna; + register struct in_ifaddr *ia; + u_long lna; + int s; - lna = in_lnaof(*destip); - if (lna == INADDR_ANY) { /* broadcast address */ + *usetrailers = 0; + if (m->m_flags & M_BCAST) { /* broadcast */ bcopy((caddr_t)etherbroadcastaddr, (caddr_t)desten, - sizeof (etherbroadcastaddr)); + sizeof(etherbroadcastaddr)); return (1); } - ifp = &ac->ac_if; - /* if for us, then use software loopback driver */ - if (destip->s_addr == - ((struct sockaddr_in *)&ifp->if_addr)-> sin_addr.s_addr) { - sin.sin_family = AF_INET; - sin.sin_addr = *destip; - return (looutput(&loif, m, (struct sockaddr *)&sin)); - } - if ((ifp->if_flags & IFF_NOARP) || lna >= oldmap) { - bcopy((caddr_t)ac->ac_enaddr, (caddr_t)desten, 3); - desten[3] = (lna >> 16) & 0x7f; - desten[4] = (lna >> 8) & 0xff; - desten[5] = lna & 0xff; - return (1); + lna = in_lnaof(*destip); + /* if for us, use software loopback driver if up */ + for (ia = in_ifaddr; ia; ia = ia->ia_next) + if ((ia->ia_ifp == &ac->ac_if) && + (destip->s_addr == ia->ia_addr.sin_addr.s_addr)) { + /* + * This test used to be + * if (loif.if_flags & IFF_UP) + * It allowed local traffic to be forced + * through the hardware by configuring the loopback down. + * However, it causes problems during network configuration + * for boards that can't receive packets they send. + * It is now necessary to clear "useloopback" + * to force traffic out to the hardware. + */ + if (useloopback) { + sin.sin_family = AF_INET; + sin.sin_addr = *destip; + (void) looutput(&loif, m, (struct sockaddr *)&sin); + /* + * The packet has already been sent and freed. + */ + return (0); + } else { + bcopy((caddr_t)ac->ac_enaddr, (caddr_t)desten, + sizeof(ac->ac_enaddr)); + return (1); + } } s = splimp(); ARPTAB_LOOK(at, destip->s_addr); if (at == 0) { /* not found */ - at = arptnew(destip); - at->at_hold = m; - arpwhohas(ac, destip); - splx(s); - return (0); + if (ac->ac_if.if_flags & IFF_NOARP) { + bcopy((caddr_t)ac->ac_enaddr, (caddr_t)desten, 3); + desten[3] = (lna >> 16) & 0x7f; + desten[4] = (lna >> 8) & 0xff; + desten[5] = lna & 0xff; + splx(s); + return (1); + } else { + at = arptnew(destip); + if (at == 0) + panic("arpresolve: no free entry"); + at->at_hold = m; + arpwhohas(ac, destip); + splx(s); + return (0); + } } at->at_timer = 0; /* restart the timer */ if (at->at_flags & ATF_COM) { /* entry IS complete */ - bcopy((caddr_t)at->at_enaddr, (caddr_t)desten, 6); + bcopy((caddr_t)at->at_enaddr, (caddr_t)desten, + sizeof(at->at_enaddr)); + if (at->at_flags & ATF_USETRAILERS) + *usetrailers = 1; splx(s); return (1); } @@ -240,105 +248,202 @@ arpresolve(ac, m, destip, desten) } /* - * Find my own IP address. It will either be waiting for us in - * monitor RAM, or can be obtained via broadcast to the file/boot - * server (not necessarily using the ARP packet format). - * - * Unimplemented at present, return 0 and assume that the host - * will set his own IP address via the SIOCSIFADDR ioctl. + * Called from 10 Mb/s Ethernet interrupt handlers + * when ether packet type ETHERTYPE_ARP + * is received. Common length and type checks are done here, + * then the protocol-specific routine is called. */ -/*ARGSUSED*/ -struct in_addr -arpmyaddr(ac) - register struct arpcom *ac; +arpinput(ac, m) + struct arpcom *ac; + struct mbuf *m; { - static struct in_addr addr; + register struct arphdr *ar; -#ifdef lint - ac = ac; -#endif - addr.s_addr = 0; - return (addr); + if (ac->ac_if.if_flags & IFF_NOARP) + goto out; + if (m->m_len < sizeof(struct arphdr)) + goto out; + ar = mtod(m, struct arphdr *); + if (ntohs(ar->ar_hrd) != ARPHRD_ETHER) + goto out; + if (m->m_len < sizeof(struct arphdr) + 2 * ar->ar_hln + 2 * ar->ar_pln) + goto out; + + switch (ntohs(ar->ar_pro)) { + + case ETHERTYPE_IP: + case ETHERTYPE_IPTRAILERS: + in_arpinput(ac, m); + return; + + default: + break; + } +out: + m_freem(m); } /* - * Called from ecintr/ilintr when ether packet type ETHERPUP_ARP - * is received. Algorithm is exactly that given in RFC 826. + * ARP for Internet protocols on 10 Mb/s Ethernet. + * Algorithm is that given in RFC 826. * In addition, a sanity check is performed on the sender * protocol address, to catch impersonators. + * We also handle negotiations for use of trailer protocol: + * ARP replies for protocol type ETHERTYPE_TRAIL are sent + * along with IP replies if we want trailers sent to us, + * and also send them in response to IP replies. + * This allows either end to announce the desire to receive + * trailer packets. + * We reply to requests for ETHERTYPE_TRAIL protocol as well, + * but don't normally send requests. */ -arpinput(ac, m) +in_arpinput(ac, m) register struct arpcom *ac; struct mbuf *m; { register struct ether_arp *ea; struct ether_header *eh; - register struct arptab *at = 0; /* same as "merge" flag */ + register struct arptab *at; /* same as "merge" flag */ + register struct in_ifaddr *ia; + struct in_ifaddr *maybe_ia = 0; + struct mbuf *mcopy = 0; struct sockaddr_in sin; struct sockaddr sa; - struct mbuf *mhold; - struct in_addr isaddr,itaddr,myaddr; + struct in_addr isaddr, itaddr, myaddr; + int proto, op, s, completed = 0; - if (m->m_len < sizeof *ea) - goto out; - myaddr = ((struct sockaddr_in *)&ac->ac_if.if_addr)->sin_addr; ea = mtod(m, struct ether_arp *); - if (ntohs(ea->arp_pro) != ETHERPUP_IPTYPE) + proto = ntohs(ea->arp_pro); + op = ntohs(ea->arp_op); + bcopy((caddr_t)ea->arp_spa, (caddr_t)&isaddr, sizeof (isaddr)); + bcopy((caddr_t)ea->arp_tpa, (caddr_t)&itaddr, sizeof (itaddr)); + for (ia = in_ifaddr; ia; ia = ia->ia_next) + if (ia->ia_ifp == &ac->ac_if) { + maybe_ia = ia; + if ((itaddr.s_addr == ia->ia_addr.sin_addr.s_addr) || + (isaddr.s_addr == ia->ia_addr.sin_addr.s_addr)) + break; + } + if (maybe_ia == 0) goto out; - isaddr.s_addr = ((struct in_addr *)ea->arp_spa)->s_addr; - itaddr.s_addr = ((struct in_addr *)ea->arp_tpa)->s_addr; + myaddr = ia ? ia->ia_addr.sin_addr : maybe_ia->ia_addr.sin_addr; if (!bcmp((caddr_t)ea->arp_sha, (caddr_t)ac->ac_enaddr, - sizeof (ac->ac_enaddr))) + sizeof (ea->arp_sha))) goto out; /* it's from me, ignore it. */ + if (!bcmp((caddr_t)ea->arp_sha, (caddr_t)etherbroadcastaddr, + sizeof (ea->arp_sha))) { + log(LOG_ERR, + "arp: ether address is broadcast for IP address %x!\n", + ntohl(isaddr.s_addr)); + goto out; + } if (isaddr.s_addr == myaddr.s_addr) { - printf("duplicate IP address!! sent from ethernet address: "); - printf("%x %x %x %x %x %x\n", ea->arp_sha[0], ea->arp_sha[1], - ea->arp_sha[2], ea->arp_sha[3], - ea->arp_sha[4], ea->arp_sha[5]); - if (ntohs(ea->arp_op) == ARPOP_REQUEST) + log(LOG_ERR, + "duplicate IP address %x!! sent from ethernet address: %s\n", + ntohl(isaddr.s_addr), ether_sprintf(ea->arp_sha)); + itaddr = myaddr; + if (op == ARPOP_REQUEST) goto reply; goto out; } + s = splimp(); + s = splimp(); ARPTAB_LOOK(at, isaddr.s_addr); if (at) { bcopy((caddr_t)ea->arp_sha, (caddr_t)at->at_enaddr, - sizeof (ea->arp_sha)); + sizeof(ea->arp_sha)); + if ((at->at_flags & ATF_COM) == 0) + completed = 1; at->at_flags |= ATF_COM; if (at->at_hold) { - mhold = at->at_hold; - at->at_hold = 0; sin.sin_family = AF_INET; sin.sin_addr = isaddr; (*ac->ac_if.if_output)(&ac->ac_if, - mhold, (struct sockaddr *)&sin); + at->at_hold, (struct sockaddr *)&sin); + at->at_hold = 0; } } - if (itaddr.s_addr != myaddr.s_addr) - goto out; /* if I am not the target */ - if (at == 0) { /* ensure we have a table entry */ - at = arptnew(&isaddr); - bcopy((caddr_t)ea->arp_sha, (caddr_t)at->at_enaddr, - sizeof (ea->arp_sha)); - at->at_flags |= ATF_COM; + if (at == 0 && itaddr.s_addr == myaddr.s_addr) { + /* ensure we have a table entry */ + if (at = arptnew(&isaddr)) { + bcopy((caddr_t)ea->arp_sha, (caddr_t)at->at_enaddr, + sizeof(ea->arp_sha)); + completed = 1; + at->at_flags |= ATF_COM; + } } - if (ntohs(ea->arp_op) != ARPOP_REQUEST) - goto out; + splx(s); + splx(s); reply: - bcopy((caddr_t)ea->arp_sha, (caddr_t)ea->arp_tha, - sizeof (ea->arp_sha)); + switch (proto) { + + case ETHERTYPE_IPTRAILERS: + /* partner says trailers are OK */ + if (at) + at->at_flags |= ATF_USETRAILERS; + /* + * Reply to request iff we want trailers. + */ + if (op != ARPOP_REQUEST || ac->ac_if.if_flags & IFF_NOTRAILERS) + goto out; + break; + + case ETHERTYPE_IP: + /* + * Reply if this is an IP request, + * or if we want to send a trailer response. + * Send the latter only to the IP response + * that completes the current ARP entry. + */ + if (op != ARPOP_REQUEST && + (completed == 0 || ac->ac_if.if_flags & IFF_NOTRAILERS)) + goto out; + } + if (itaddr.s_addr == myaddr.s_addr) { + /* I am the target */ + bcopy((caddr_t)ea->arp_sha, (caddr_t)ea->arp_tha, + sizeof(ea->arp_sha)); + bcopy((caddr_t)ac->ac_enaddr, (caddr_t)ea->arp_sha, + sizeof(ea->arp_sha)); + } else { + ARPTAB_LOOK(at, itaddr.s_addr); + if (at == NULL || (at->at_flags & ATF_PUBL) == 0) + goto out; + bcopy((caddr_t)ea->arp_sha, (caddr_t)ea->arp_tha, + sizeof(ea->arp_sha)); + bcopy((caddr_t)at->at_enaddr, (caddr_t)ea->arp_sha, + sizeof(ea->arp_sha)); + } + bcopy((caddr_t)ea->arp_spa, (caddr_t)ea->arp_tpa, - sizeof (ea->arp_spa)); - bcopy((caddr_t)ac->ac_enaddr, (caddr_t)ea->arp_sha, - sizeof (ea->arp_sha)); - bcopy((caddr_t)&myaddr, (caddr_t)ea->arp_spa, - sizeof (ea->arp_spa)); - ea->arp_op = htons(ARPOP_REPLY); + sizeof(ea->arp_spa)); + bcopy((caddr_t)&itaddr, (caddr_t)ea->arp_spa, + sizeof(ea->arp_spa)); + ea->arp_op = htons(ARPOP_REPLY); + /* + * If incoming packet was an IP reply, + * we are sending a reply for type IPTRAILERS. + * If we are sending a reply for type IP + * and we want to receive trailers, + * send a trailer reply as well. + */ + if (op == ARPOP_REPLY) + ea->arp_pro = htons(ETHERTYPE_IPTRAILERS); + else if (proto == ETHERTYPE_IP && + (ac->ac_if.if_flags & IFF_NOTRAILERS) == 0) + mcopy = m_copy(m, 0, (int)M_COPYALL); eh = (struct ether_header *)sa.sa_data; bcopy((caddr_t)ea->arp_tha, (caddr_t)eh->ether_dhost, - sizeof (eh->ether_dhost)); - eh->ether_type = ETHERPUP_ARPTYPE; + sizeof(eh->ether_dhost)); + eh->ether_type = ETHERTYPE_ARP; sa.sa_family = AF_UNSPEC; + sa.sa_len = sizeof(sa); (*ac->ac_if.if_output)(&ac->ac_if, m, &sa); + if (mcopy) { + ea = mtod(mcopy, struct ether_arp *); + ea->arp_pro = htons(ETHERTYPE_IPTRAILERS); + (*ac->ac_if.if_output)(&ac->ac_if, mcopy, &sa); + } return; out: m_freem(m); @@ -364,24 +469,37 @@ arptfree(at) /* * Enter a new address in arptab, pushing out the oldest entry * from the bucket if there is no room. + * This always succeeds since no bucket can be completely filled + * with permanent entries (except from arpioctl when testing whether + * another permanent entry will fit). + * MUST BE CALLED AT SPLIMP. */ struct arptab * arptnew(addr) struct in_addr *addr; { register n; - int oldest = 0; - register struct arptab *at, *ato; + int oldest = -1; + register struct arptab *at, *ato = NULL; + static int first = 1; - ato = at = &arptab[ARPTAB_HASH(addr->s_addr) * ARPTAB_BSIZ]; - for (n = 0 ; n < ARPTAB_BSIZ ; n++,at++) { + if (first) { + first = 0; + timeout(arptimer, (caddr_t)0, hz); + } + at = &arptab[ARPTAB_HASH(addr->s_addr) * ARPTAB_BSIZ]; + for (n = 0; n < ARPTAB_BSIZ; n++,at++) { if (at->at_flags == 0) goto out; /* found an empty entry */ - if (at->at_timer > oldest) { + if (at->at_flags & ATF_PERM) + continue; + if ((int) at->at_timer > oldest) { oldest = at->at_timer; ato = at; } } + if (ato == NULL) + return (NULL); at = ato; arptfree(at); out: @@ -389,3 +507,88 @@ out: at->at_flags = ATF_INUSE; return (at); } + +arpioctl(cmd, data) + int cmd; + caddr_t data; +{ + register struct arpreq *ar = (struct arpreq *)data; + register struct arptab *at; + register struct sockaddr_in *sin; + int s; + + sin = (struct sockaddr_in *)&ar->arp_ha; +#if defined(COMPAT_43) && BYTE_ORDER != BIG_ENDIAN + if (sin->sin_family == 0 && sin->sin_len < 16) + sin->sin_family = sin->sin_len; +#endif + sin->sin_len = sizeof(ar->arp_ha); + sin = (struct sockaddr_in *)&ar->arp_pa; +#if defined(COMPAT_43) && BYTE_ORDER != BIG_ENDIAN + if (sin->sin_family == 0 && sin->sin_len < 16) + sin->sin_family = sin->sin_len; +#endif + sin->sin_len = sizeof(ar->arp_pa); + if (ar->arp_pa.sa_family != AF_INET || + ar->arp_ha.sa_family != AF_UNSPEC) + return (EAFNOSUPPORT); + s = splimp(); + ARPTAB_LOOK(at, sin->sin_addr.s_addr); + if (at == NULL) { /* not found */ + if (cmd != SIOCSARP) { + splx(s); + return (ENXIO); + } + if (ifa_ifwithnet(&ar->arp_pa) == NULL) { + splx(s); + return (ENETUNREACH); + } + } + switch (cmd) { + + case SIOCSARP: /* set entry */ + if (at == NULL) { + at = arptnew(&sin->sin_addr); + if (at == NULL) { + splx(s); + return (EADDRNOTAVAIL); + } + if (ar->arp_flags & ATF_PERM) { + /* never make all entries in a bucket permanent */ + register struct arptab *tat; + + /* try to re-allocate */ + tat = arptnew(&sin->sin_addr); + if (tat == NULL) { + arptfree(at); + splx(s); + return (EADDRNOTAVAIL); + } + arptfree(tat); + } + } + bcopy((caddr_t)ar->arp_ha.sa_data, (caddr_t)at->at_enaddr, + sizeof(at->at_enaddr)); + at->at_flags = ATF_COM | ATF_INUSE | + (ar->arp_flags & (ATF_PERM|ATF_PUBL|ATF_USETRAILERS)); + at->at_timer = 0; + break; + + case SIOCDARP: /* delete entry */ + arptfree(at); + break; + + case SIOCGARP: /* get entry */ + case OSIOCGARP: + bcopy((caddr_t)at->at_enaddr, (caddr_t)ar->arp_ha.sa_data, + sizeof(at->at_enaddr)); +#ifdef COMPAT_43 + if (cmd == OSIOCGARP) + *(u_short *)&ar->arp_ha = ar->arp_ha.sa_family; +#endif + ar->arp_flags = at->at_flags; + break; + } + splx(s); + return (0); +}