if_ether.c

<B>Digital的Unix操作系统VAX 4.2源码</B>

 * 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.
 */
in_arpinput(ac, m)
	register struct arpcom *ac;
	struct mbuf *m;
{
	register struct ether_arp *ea;
	struct ether_header *eh;
	register struct arptab *at;  /* same as "merge" flag */
	struct mbuf *mcopy = 0;
	struct sockaddr_in sin;
	struct sockaddr sa;
	struct in_addr isaddr, itaddr, myaddr;
	int proto, op, s, completed = 0;
	int saveaffinity;

	myaddr = ac->ac_ipaddr;
	ea = mtod(m, struct ether_arp *);
	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));
#ifdef RARP
        if (op == RARPOP_REQUEST)
                {
                rarp_reply(ac, m);
                return;
                }
#endif RARP
#ifdef mips
        bcopy(&((struct in_addr *)ea->arp_spa)->s_addr, &isaddr.s_addr,
                sizeof(struct in_addr));
        bcopy(&((struct in_addr *)ea->arp_tpa)->s_addr, &itaddr.s_addr,
                sizeof(struct in_addr));
#endif mips
	if (!bcmp((caddr_t)ea->arp_sha, (caddr_t)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))) {
		mprintf("arp: ether address is broadcast for IP address %x!\n",
		    ntohl(isaddr.s_addr));
		goto out;
	}
	if (isaddr.s_addr == myaddr.s_addr) {
		mprintf("%s: %s\n",
			"duplicate IP address!! sent from ethernet address",
			ether_sprintf(ea->arp_sha));
		itaddr = myaddr;
		if (op == ARPOP_REQUEST)
			goto reply;
		goto out;
	}
	s = splimp();
	smp_lock(&lk_arptab, LK_RETRY);
	ARPTAB_LOOK(at, isaddr.s_addr);
	if (at) {
		bcopy((caddr_t)ea->arp_sha, (caddr_t)at->at_enaddr,
		    sizeof(ea->arp_sha));
		if ((at->at_flags & ATF_COM) == 0)
			completed = 1;
		at->at_flags |= ATF_COM;
		if (at->at_hold) {
			sin.sin_family = AF_INET;
			sin.sin_addr = isaddr;
			/* cannot hold smp lock when calling driver output */
			smp_unlock(&lk_arptab);
			CALL_TO_NONSMP_DRIVER( ac->ac_if, saveaffinity);
			(*ac->ac_if.if_output)(&ac->ac_if, 
			    at->at_hold, (struct sockaddr *)&sin);
			RETURN_FROM_NONSMP_DRIVER( ac->ac_if, saveaffinity);
			smp_lock(&lk_arptab, LK_RETRY);
			at->at_hold = 0;
		}
	}
	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;
		}
	}
	smp_unlock(&lk_arptab);
	splx(s);
reply:
	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 defined(GATEWAY) && defined(mips)
        /*
         *      Do "promiscuous arp".  Ie., reply with my hardware address for
         *      any machine not on the requestor's net, but on one of mine.
         *      I will then deal with delivery of the packet.
         */
        if (in_netof(itaddr) != in_netof(ea->arp_spa))
                if (arp_cangate(itaddr) && arp_do_prom) {
                        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));
                        goto send;
                }
#endif GATEWAY && mips
	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 {
		s = splimp(); /* SMP */
		smp_lock(&lk_arptab, LK_RETRY);
		ARPTAB_LOOK(at, itaddr.s_addr);
		if (at == NULL || (at->at_flags & ATF_PUBL) == 0) {
			smp_unlock(&lk_arptab);
			splx(s); /* SMP */
			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));
		smp_unlock(&lk_arptab);
		splx(s); /* SMP */
	}

	bcopy((caddr_t)ea->arp_spa, (caddr_t)ea->arp_tpa,
	    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 = ETHERTYPE_ARP;
	sa.sa_family = AF_UNSPEC;
	CALL_TO_NONSMP_DRIVER( ac->ac_if, saveaffinity);
	(*ac->ac_if.if_output)(&ac->ac_if, m, &sa);
	RETURN_FROM_NONSMP_DRIVER( ac->ac_if, saveaffinity);
	if (mcopy) {
		ea = mtod(mcopy, struct ether_arp *);
		ea->arp_pro = htons(ETHERTYPE_IPTRAILERS);
		CALL_TO_NONSMP_DRIVER( ac->ac_if, saveaffinity);
		(*ac->ac_if.if_output)(&ac->ac_if, mcopy, &sa);
		RETURN_FROM_NONSMP_DRIVER( ac->ac_if, saveaffinity);
	}
	return;
out:
	m_freem(m);
	return;
}

/*
 * Free an arptab entry.
 * SMP: arptfree must be called with arptab lock asserted
 */
arptfree(at)
	register struct arptab *at;
{
	int s = splimp();

	if (at->at_hold)
		m_freem(at->at_hold);
	at->at_hold = 0;
	at->at_timer = at->at_flags = 0;
	at->at_iaddr.s_addr = 0;
	splx(s);
}

/*
 * 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.
 * SMP: arptnew must be called with arptab lock asserted
 */
struct arptab *
arptnew(addr)
	struct in_addr *addr;
{
	register int n;
	int oldest = -1;
	register struct arptab *at, *ato = NULL;
	static int first = 1;

	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_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:
	at->at_iaddr = *addr;
	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;

	if (ar->arp_pa.sa_family != AF_INET ||
	    ar->arp_ha.sa_family != AF_UNSPEC)
		return (EAFNOSUPPORT);
	sin = (struct sockaddr_in *)&ar->arp_pa;
	s = splimp();
	smp_lock(&lk_arptab, LK_RETRY);
	ARPTAB_LOOK(at, sin->sin_addr.s_addr);
	if (at == NULL) {		/* not found */
		if (cmd != SIOCSARP) {
			smp_unlock(&lk_arptab);
			splx(s);
			return (ENXIO);
		}
		smp_unlock(&lk_arptab);		
		if (ifa_ifwithnet(&ar->arp_pa) == NULL) {
			splx(s);
			return (ENETUNREACH);
		}
		smp_lock(&lk_arptab, LK_RETRY);
	}
	switch (cmd) {

	case SIOCSARP:		/* set entry */
		if (at == NULL) {
			at = arptnew(&sin->sin_addr);
			if (at == NULL) {
				smp_unlock(&lk_arptab);
				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);
					smp_unlock(&lk_arptab);
					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 */
		bcopy((caddr_t)at->at_enaddr, (caddr_t)ar->arp_ha.sa_data,
		    sizeof(at->at_enaddr));
		ar->arp_flags = at->at_flags;
		break;
	}
	smp_unlock(&lk_arptab);
	splx(s);
	return (0);
}

/*
 * Convert Ethernet address to printable (loggable) representation.
 */
char *
ether_sprintf(ap)
	register u_char *ap;
{
	register int i;
	static char etherbuf[18];
	register char *cp = etherbuf;
	static char digits[] = "0123456789abcdef";

	for (i = 0; i < 6; i++) {
		*cp++ = digits[*ap >> 4];
		*cp++ = digits[*ap++ & 0xf];
		*cp++ = ':';
	}
	*--cp = 0;
	return (etherbuf);
}
#ifdef RARP
/*
 * When the rarp packet is a request (arp_op = RARPOP_REQUEST = 3), then
 *      arp_sha is the ethernet address of the sender of the request;
 *      arp_spa is undefined;
 *      arp_tha is the 'target' hardware address, i.e. the sender's address,
 *      arp_tpa is undefined.
 * The rarp reply (arp_op = RARPOP_REPLY = 4) looks like:
 *      arp_sha is the responder's (our) ethernet address;
 *      arp_spa is the responder's (our) IP address;
 *      arp_tha is identical to the request packet;
 *      arp_tpa is the request's desired IP address.
 */

rarp_reply(ac, m)
        register struct arpcom *ac;
        register struct mbuf *m;
{
        register struct ether_arp *ea;
        register struct arptab *him;  /* same as "merge" flag */
        struct ether_header *eh;
        struct sockaddr sa;

        ea = mtod(m, struct ether_arp *);
        RARPTAB_LOOK(him, ea->arp_tha);
        if (him)
                {
                bcopy((caddr_t)&ac->ac_ipaddr,ea->arp_spa,sizeof(ea->arp_spa));
                bcopy(ac->ac_enaddr, ea->arp_sha, sizeof(ea->arp_sha));
                bcopy((caddr_t)&him->at_iaddr,ea->arp_tpa,sizeof(ea->arp_tpa));
                ea->arp_op = htons(RARPOP_REPLY);
                eh = (struct ether_header *)sa.sa_data;
                bcopy((caddr_t)ea->arp_tha, (caddr_t)eh->ether_dhost,
                    sizeof(eh->ether_dhost));
                bcopy((caddr_t)ea->arp_sha, (caddr_t)eh->ether_shost,
                    sizeof(eh->ether_shost));
                eh->ether_type = ETHERTYPE_RARP;
                sa.sa_family = AF_UNSPEC;
                (*ac->ac_if.if_output)(&ac->ac_if, m, &sa);
                } /* if at, ie. can reply */
        return;
} /* rarp_reply() */
#endif RARP
#if defined(GATEWAY) && defined(mips)
/*
 *      Can we gateway to this network?  We already know that this
 *      target is not on the network that the ARP request was made on,
 *      so if we can talk to this network, we can gateway between the
 *      two.
 */

arp_cangate(target)
        struct in_addr target;
{
        register struct in_ifaddr *ia;
	int s;
        
	s = splimp();
        for (ia = in_ifaddr; ia; ia = ia->ia_next)
                if (in_netof(target) == ia->ia_net){
			splx(s);
                        return (1);
		}
	splx(s);
        return (0);
}
#endif GATEWAY && mips