Attachment #44337 for bug #68692

View | Details | Raw Unified | Return to bug 68692
Collapse All | Expand All

Lines 42-47 Link Here

(-)src/sys/net/route.c (-1 / +21 lines)
42	#include <sys/kernel.h>	42	#include <sys/kernel.h>
43		43
44	#include <net/if.h>	44	#include <net/if.h>
		45	#include <net/if_dl.h> /* for sockaddr_dl */
45	#include <net/route.h>	46	#include <net/route.h>
46		47
47	#include <netinet/in.h>	48	#include <netinet/in.h>
Lines 1105-1113 Link Here
1105	bzero((caddr_t)cp2, (unsigned)(cplim2 - cp2));	1106	bzero((caddr_t)cp2, (unsigned)(cplim2 - cp2));
1106	}	1107	}
1107		1108
		1109	void arp_ifscrub(struct ifnet *ifp, uint32_t addr);
		1110
1108	/*	1111	/*
1109	* Set up a routing table entry, normally	1112	* Set up a routing table entry, normally
1110	* for an interface.	1113	* for an interface.
		1114	* Instead of the destination address, use a sockaddr_dl for the
		1115	* gateway, using the index and type of the interface.
1111	*/	1116	*/
1112	int	1117	int
1113	rtinit(struct ifaddr *ifa, int cmd, int flags)	1118	rtinit(struct ifaddr *ifa, int cmd, int flags)
Lines 1118-1123 Link Here
1118	struct rtentry *rt = NULL;	1123	struct rtentry *rt = NULL;
1119	struct rt_addrinfo info;	1124	struct rt_addrinfo info;
1120	int error;	1125	int error;
		1126	static struct sockaddr_dl null_sdl = {sizeof(null_sdl), AF_LINK};
1121		1127
1122	if (flags & RTF_HOST) {	1128	if (flags & RTF_HOST) {
1123	dst = ifa->ifa_dstaddr;	1129	dst = ifa->ifa_dstaddr;
Lines 1126-1131 Link Here
1126	dst = ifa->ifa_addr;	1132	dst = ifa->ifa_addr;
1127	netmask = ifa->ifa_netmask;	1133	netmask = ifa->ifa_netmask;
1128	}	1134	}
		1135	printf("rtinit cmd %d flags 0x%x, ifa_ifp %p dst %d:0x%x gw %d:0x%x\n",
		1136	cmd, flags, ifa->ifa_ifp,
		1137	dst->sa_family,
		1138	ntohl(((struct sockaddr_in *)dst)->sin_addr.s_addr),
		1139	ifa->ifa_addr->sa_family,
		1140	ntohl(((struct sockaddr_in *)ifa->ifa_addr)->sin_addr.s_addr));
		1141
1129	/*	1142	/*
1130	* If it's a delete, check that if it exists, it's on the correct	1143	* If it's a delete, check that if it exists, it's on the correct
1131	* interface or we might scrub a route to another ifa which would	1144	* interface or we might scrub a route to another ifa which would
Lines 1136-1141 Link Here
1136	struct radix_node_head *rnh;	1149	struct radix_node_head *rnh;
1137	struct radix_node *rn;	1150	struct radix_node *rn;
1138		1151
		1152	if (dst->sa_family == AF_INET)
		1153	arp_ifscrub(ifa->ifa_ifp,
		1154	((struct sockaddr_in *)dst)->sin_addr.s_addr);
1139	/*	1155	/*
1140	* It's a delete, so it should already exist..	1156	* It's a delete, so it should already exist..
1141	* If it's a net, mask off the host bits	1157	* If it's a net, mask off the host bits
Lines 1175-1184 Link Here
1175	info.rti_ifa = ifa;	1191	info.rti_ifa = ifa;
1176	info.rti_flags = flags \| ifa->ifa_flags;	1192	info.rti_flags = flags \| ifa->ifa_flags;
1177	info.rti_info[RTAX_DST] = dst;	1193	info.rti_info[RTAX_DST] = dst;
1178	info.rti_info[RTAX_GATEWAY] = ifa->ifa_addr;	1194	info.rti_info[RTAX_GATEWAY] = (struct sockaddr *)&null_sdl;
1179	info.rti_info[RTAX_NETMASK] = netmask;	1195	info.rti_info[RTAX_NETMASK] = netmask;
1180	error = rtrequest1(cmd, &info, &rt);	1196	error = rtrequest1(cmd, &info, &rt);
1181	if (error == 0 && rt != NULL) {	1197	if (error == 0 && rt != NULL) {
		1198	((struct sockaddr_dl *)rt->rt_gateway)->sdl_type =
		1199	rt->rt_ifp->if_type;
		1200	((struct sockaddr_dl *)rt->rt_gateway)->sdl_index =
		1201	rt->rt_ifp->if_index;
1182	/*	1202	/*
1183	* notify any listening routing agents of the change	1203	* notify any listening routing agents of the change
1184	*/	1204	*/

Lines 93-98 Link Here

(-)src/sys/net/rtsock.c (-2 / +28 lines)
93	struct rt_metrics *out);	93	struct rt_metrics *out);
94	static void rt_dispatch(struct mbuf , const struct sockaddr );	94	static void rt_dispatch(struct mbuf , const struct sockaddr );
95		95
		96	/* support new arp code */
		97	int arp_rt_output(struct rt_msghdr rtm, struct rt_addrinfo info);
		98	int sysctl_dumparp(int af, struct sysctl_req *wr);
		99
96	/*	100	/*
97	* It really doesn't make any sense at all for this code to share much	101	* It really doesn't make any sense at all for this code to share much
98	* with raw_usrreq.c, since its functionality is so restricted. XXX	102	* with raw_usrreq.c, since its functionality is so restricted. XXX
Lines 277-282 Link Here
277	sosend, soreceive, sopoll, pru_sosetlabel_null	281	sosend, soreceive, sopoll, pru_sosetlabel_null
278	};	282	};
279		283
		284
		285
280	/ARGSUSED/	286	/ARGSUSED/
281	static int	287	static int
282	route_output(struct mbuf m, struct socket so)	288	route_output(struct mbuf m, struct socket so)
Lines 353-358 Link Here
353	if (info.rti_info[RTAX_GATEWAY] == NULL)	359	if (info.rti_info[RTAX_GATEWAY] == NULL)
354	senderr(EINVAL);	360	senderr(EINVAL);
355	saved_nrt = NULL;	361	saved_nrt = NULL;
		362	if (info.rti_info[RTAX_GATEWAY]->sa_family == AF_LINK) {
		363	/* support for new ARP code */
		364	arp_rt_output(rtm, &info);
		365	break;
		366	}
356	error = rtrequest1(RTM_ADD, &info, &saved_nrt);	367	error = rtrequest1(RTM_ADD, &info, &saved_nrt);
357	if (error == 0 && saved_nrt) {	368	if (error == 0 && saved_nrt) {
358	RT_LOCK(saved_nrt);	369	RT_LOCK(saved_nrt);
Lines 366-371 Link Here
366		377
367	case RTM_DELETE:	378	case RTM_DELETE:
368	saved_nrt = NULL;	379	saved_nrt = NULL;
		380	if (info.rti_info[RTAX_GATEWAY]->sa_family == AF_LINK) {
		381	/* support for new ARP code */
		382	arp_rt_output(rtm, &info);
		383	break;
		384	}
369	error = rtrequest1(RTM_DELETE, &info, &saved_nrt);	385	error = rtrequest1(RTM_DELETE, &info, &saved_nrt);
370	if (error == 0) {	386	if (error == 0) {
371	RT_LOCK(saved_nrt);	387	RT_LOCK(saved_nrt);
Lines 1081-1086 Link Here
1081	int i, lim, s, error = EINVAL;	1097	int i, lim, s, error = EINVAL;
1082	u_char af;	1098	u_char af;
1083	struct walkarg w;	1099	struct walkarg w;
		1100	int found = 0;
1084		1101
1085	name ++;	1102	name ++;
1086	namelen--;	1103	namelen--;
Lines 1112-1119 Link Here
1112	error = rnh->rnh_walktree(rnh,	1129	error = rnh->rnh_walktree(rnh,
1113	sysctl_dumpentry, &w);/* could sleep XXX */	1130	sysctl_dumpentry, &w);/* could sleep XXX */
1114	/* RADIX_NODE_HEAD_UNLOCK(rnh); */	1131	/* RADIX_NODE_HEAD_UNLOCK(rnh); */
1115	} else if (af != 0)	1132	if (error)
1116	error = EAFNOSUPPORT;	1133	break;
		1134	found = 1;
		1135	}
		1136	/*
		1137	* take care of llinfo entries. XXX check AF_INET ?
		1138	*/
		1139	if (w.w_op == NET_RT_FLAGS && (RTF_LLINFO & w.w_arg))
		1140	error = sysctl_dumparp(af, w.w_req);
		1141	else if (af != 0 && found == 0)
		1142	error = EAFNOSUPPORT;
1117	break;	1143	break;
1118		1144
1119	case NET_RT_IFLIST:	1145	case NET_RT_IFLIST:




 * SUCH DAMAGE.
 *
 *	@(#)if_ether.c	8.1 (Berkeley) 6/10/93
 * $FreeBSD$
 */

/*

static	LIST_HEAD(, llinfo_arp) llinfo_arp;

static struct	ifqueue arpintrq;
static int	arp_allocated;

static int	arp_maxtries = 5;
static int	useloopback = 1; /* use loopback interface for local traffic */

	   &arp_proxyall, 0, "");

static void	arp_init(void);
static void	arp_rtrequest(int, struct rtentry *, struct rt_addrinfo *);
static void	arprequest(struct ifnet *,
			struct in_addr *, struct in_addr *, u_char *);
static void	arpintr(struct mbuf *);
static void	arptfree(struct llinfo_arp *);
static void	arptimer(void *);
struct llentry *arplookup(struct ifnet *ifp, uint32_t addr, uint32_t flags);
		*arplookup(u_long, int, int);
#ifdef INET
static void	in_arpinput(struct mbuf *);
#endif

/***
 ***
 *** Start of new arp support routines which should go to a separate file.
 ***
 ***/
#define DEB(x)
#define	DDB(x)	x

struct llentry {
	struct llentry *lle_next;
	struct mbuf	*la_hold;
	uint16_t	flags; /* see values in if_ether.h */
	uint8_t		la_preempt;
	uint8_t		la_asked;
	time_t		expire;
	struct in_addr	l3_addr;
	union {
		uint64_t	mac_aligned;
		uint16_t	mac16[3];
	} ll_addr;
};

MALLOC_DEFINE(M_ARP, "arp", "arp entries");	/* XXX will move to UMA */

int arp_rt_output(struct rt_msghdr *rtm, struct rt_addrinfo *info);
int sysctl_dumparp(int af, struct sysctl_req *wr);
void arp_ifscrub(struct ifnet *ifp, uint32_t addr);

/*
 * called by in_ifscrub to remove entry from the table when
 * the interface goes away
 */
void
arp_ifscrub(struct ifnet *ifp, uint32_t addr)
{
	arplookup(ifp, addr, LLE_DELETE | LLE_IFADDR);
}

/*
 * Find an interface address matching the ifp-addr pair.
 * This may replicate some of the functions of ifa_ifwithnet()
 */
static struct ifaddr *
find_ifa(struct ifnet *ifp, uint32_t addr)
{
	struct ifaddr *ifa;

	if (ifp == NULL)
		return NULL;
	TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
		if (ifa->ifa_addr->sa_family != AF_INET)
			continue;
		if (ifp->if_flags & IFF_POINTOPOINT)
			break;
		if (((addr ^ SIN(ifa->ifa_addr)->sin_addr.s_addr) &
		    SIN(ifa->ifa_netmask)->sin_addr.s_addr ) == 0)
			break; /* found! */
	}
	return ifa;
}

static void
llentry_free(struct llentry **e)
{
	struct llentry *x;

	if (e == 0)
		panic("llentry_free: null ptr");
	x = *e;
	*e = x->lle_next;
	if (x->la_hold)
		m_freem(x->la_hold);
	free(x, M_ARP);
}

/*
 * Add a new table at the head of the list for interface ifp
 */
struct lltable *
lltable_new(struct ifnet *ifp, int af)
{
	struct lltable *t;

	t = malloc(sizeof (struct lltable), M_ARP, M_DONTWAIT | M_ZERO);
	if (t != NULL) {
		t->llt_next = ifp->lltables;
		t->llt_af = af;
		ifp->lltables = t;
	}
	return t;
}

struct lltable **
lltable_free(struct lltable **t)
{
	struct lltable *x;

	if (t == NULL)
		panic("lltable_free: null ptr");
	x = *t;
	*t = x->llt_next;
	free(x, M_ARP);
	return t;
}

static void
newarptimer(__unused void *ignored_arg)
{
	struct lltable *t;
	struct llentry **e;
	struct ifnet *ifp;

	IFNET_RLOCK();
	printf("arptimer!\n");
	TAILQ_FOREACH(ifp, &ifnet, if_link) {
		for (t = ifp->lltables; t ; t = t->llt_next) {
			if (t->llt_af != AF_INET)
				continue;
			for (e = (struct llentry **)&t->lle_head; *e; ) {
				int kill;

				if ((*e)->flags & LLE_DELETED)
					kill = 1;
				else if ((*e)->flags & LLE_STATIC)
					kill = 0;
				else
					kill = time_second >= (*e)->expire;
				if (kill)
					llentry_free(e);
				else
					e = &((*e)->lle_next);
			}
		}
	}
	IFNET_RUNLOCK();
	callout_reset(&arp_callout, arpt_prune * hz, newarptimer, NULL);
}

static int
inet_dumparp(struct ifnet *ifp, void *head, struct sysctl_req *wr)
{
	struct llentry *e;
	int error = 0;

	for (e = head; e; e = e->lle_next) {
		struct {
			struct rt_msghdr        rtm;
			struct sockaddr_inarp   sin2;
			struct sockaddr_dl      sdl;
			//struct sockaddr_inarp addr2;
		} d;

		DEB(printf("ifp %p index %d flags 0x%x ip %x %s\n",
		    ifp, ifp->if_index,
		    e->flags,
		    ntohl(e->l3_addr.s_addr),
		    (e->flags & LLA_VALID) ? "valid" : "incomplete");)
		if (e->flags & LLE_DELETED) /* skip deleted entries */
			continue;
		/*
		 * produce a msg made of:
		 *  struct rt_msghdr;
		 *  struct sockaddr_inarp;
		 *  struct sockaddr_dl;
		 */
		bzero(&d, sizeof (d));
		d.rtm.rtm_msglen = sizeof(d);
		d.sin2.sin_family = AF_INET;
		d.sin2.sin_len = sizeof(d.sin2);
		d.sin2.sin_addr.s_addr = e->l3_addr.s_addr;

		if (e->flags & LLA_VALID) { /* valid MAC */
			d.sdl.sdl_family = AF_LINK;
			d.sdl.sdl_len = sizeof(d.sdl);
			d.sdl.sdl_alen = ifp->if_addrlen;
			d.sdl.sdl_index = ifp->if_index;
			d.sdl.sdl_type = ifp->if_type;
			bcopy(&e->ll_addr, LLADDR(&d.sdl), ifp->if_addrlen);
		}
		d.rtm.rtm_rmx.rmx_expire =
		    e->flags & LLE_STATIC ? 0 : e->expire;
		d.rtm.rtm_flags = RTF_LLINFO;
		if (e->flags & LLE_STATIC)
			d.rtm.rtm_flags |= RTF_STATIC;
		d.rtm.rtm_index = ifp->if_index;
		error = SYSCTL_OUT(wr, &d, sizeof(d));
		if (error)
			break;
	}
	return error;
}

/*
 * glue to dump arp tables
 */
int
sysctl_dumparp(int af, struct sysctl_req *wr)
{
	struct lltable *t;
	struct ifnet *ifp;
	int error = 0;

	IFNET_RLOCK();
	TAILQ_FOREACH(ifp, &ifnet, if_link) {
		for (t = ifp->lltables; t ; t = t->llt_next) {
			if (af != 0 && t->llt_af != af)
				continue;
			switch (af) {
			case AF_INET:
				error = inet_dumparp(ifp, t->lle_head, wr);
				break;
			/* other handlers, if any */
			}
			if (error)
				goto done;
		}
	 }
done:
	IFNET_RUNLOCK();
	return (error);
}

/*
 * Called in route_output when adding/deleting a route to an interface.
 */
int
arp_rt_output(struct rt_msghdr *rtm, struct rt_addrinfo *info)
{
	struct sockaddr_dl *dl =
		(struct sockaddr_dl *)info->rti_info[RTAX_GATEWAY];
	struct sockaddr_in *dst =
		(struct sockaddr_in *)info->rti_info[RTAX_DST];
	struct ifnet *ifp;
	struct llentry *la;
	u_int flags;

	printf("arp_rt_output type %d af: gw %d dst %d:%x if_index %d\n",
	    rtm->rtm_type,
	    dl ? dl->sdl_family : 0,
	    dst ? dst->sin_family : 0,
	    dst && dst->sin_family == AF_INET ?
	    ntohl(dst->sin_addr.s_addr) : 0,
	    dl ? dl->sdl_index : 0);
	if (dl == NULL || dl->sdl_family != AF_LINK) {
		/* XXX should also check (dl->sdl_index < if_indexlim) */
		printf("invalid gateway/index\n");
		return EINVAL;
	}
	ifp = ifnet_byindex(dl->sdl_index);
	if (ifp == NULL) {
		printf("invalid ifp\n");
		return EINVAL;
	}

	switch (rtm->rtm_type) {
	case RTM_ADD:
		flags = LLE_CREATE;
		break;

	case RTM_CHANGE:
	default:
		return EINVAL; /* XXX not implemented yet */

	case RTM_DELETE:
		flags = LLE_DELETE;
		break;
	}
	la = arplookup(ifp, dst->sin_addr.s_addr, flags);
	if (la == NULL) {
		bcopy(LLADDR(dl), &la->ll_addr, ifp->if_addrlen);
		la->flags |= LLA_VALID;
		if (rtm->rtm_flags & RTF_STATIC)
			la->flags |= LLE_STATIC;
		else
			la->expire = time_second + arpt_keep;
	}
	return 0;
}



/***
 ***
 *** End of new arp support routines which should go to a separate file.
 ***
 ***/

/*
 * Timeout routine.  Age arp_tab entries periodically.
 */

	callout_reset(&arp_callout, arpt_prune * hz, arptimer, NULL);
}

#if 0 /* this is unused */
static int	arp_allocated;

/*
 * Parallel to llc_rtrequest.
 */

		Free((caddr_t)la);
	}
}
#endif /* arp_rtrequest unused */

/*
 * Broadcast an ARP request. Caller specifies:

	struct arphdr *ah;
	struct sockaddr sa;

	if (sip == NULL) {
		/*
		 * The caller did not supply a source address, try to find
		 * a compatible one among those assigned to this interface.
		 */
		struct ifaddr *ifa;

		TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
			if (!ifa->ifa_addr ||
			    ifa->ifa_addr->sa_family != AF_INET)
				continue;
			sip = &SIN(ifa->ifa_addr)->sin_addr;
			if (0 == ((sip->s_addr ^ tip->s_addr) &
			    SIN(ifa->ifa_netmask)->sin_addr.s_addr) )
				break;	/* found it. */
		}
	}
	if (sip == NULL) {
		printf(" cannot find matching address, no arprequest\n");
		return;
	}

	if ((m = m_gethdr(M_DONTWAIT, MT_DATA)) == NULL)
		return;
	m->m_len = sizeof(*ah) + 2*sizeof(struct in_addr) +

arpresolve(struct ifnet *ifp, struct rtentry *rt0, struct mbuf *m,
	struct sockaddr *dst, u_char *desten)
{
	struct llentry *la = 0;
	struct sockaddr_dl *sdl;
	int error;
	struct rtentry *rt;
	u_int flags = (ifp->if_flags & (IFF_NOARP | IFF_STATICARP)) ?
			0 : LLE_CREATE;
	if (error) {
		m_freem(m);
		return error;
	}

	if (m->m_flags & M_BCAST) {	/* broadcast */
		(void)memcpy(desten, ifp->if_broadcastaddr, ifp->if_addrlen);

		ETHER_MAP_IP_MULTICAST(&SIN(dst)->sin_addr, desten);
		return (0);
	}
	la = arplookup(ifp, SIN(dst)->sin_addr.s_addr, flags);
	if (la == NULL) {
	        if (flags & LLE_CREATE)
		        log(LOG_DEBUG,
				"arpresolve: can't allocate llinfo for %s\n",
				inet_ntoa(SIN(dst)->sin_addr));
	}
	if (la == 0 || rt == 0) {
		log(LOG_DEBUG, "arpresolve: can't allocate llinfo for %s%s%s\n",
			inet_ntoa(SIN(dst)->sin_addr), la ? "la" : "",
				rt ? "rt" : "");
		m_freem(m);
		return (EINVAL); /* XXX */
	}
	sdl = SDL(rt->rt_gateway);
	/*
	 * If the entry is valid and not expired, use it.
	 * is resolved; otherwise, try to resolve.
	 */
	if (la->flags & LLA_VALID &&
	    (la->flags & LLE_STATIC || la->expire > time_second)) {
	        bcopy(&la->ll_addr, desten, ifp->if_addrlen);
		/*
		 * If entry has an expiry time and it is approaching,
		 * see if we need to send an ARP request within this
		 * arpt_down interval.
		 */
		if (!(la->flags & LLE_STATIC) &&
		    time_second + la->la_preempt > la->expire) {
		        arprequest(ifp, NULL,
				&SIN(dst)->sin_addr, IF_LLADDR(ifp));
				   &SIN(dst)->sin_addr,
				   IF_LLADDR(ifp));
			la->la_preempt--;
		} 

		bcopy(LLADDR(sdl), desten, sdl->sdl_alen);
		return (0);
	}
	if (la->flags & LLE_STATIC) {   /* should not happen! */
	        log(LOG_DEBUG, "arpresolve: ouch, empty static llinfo for %s\n",
				inet_ntoa(SIN(dst)->sin_addr));
	 * Probably should not allocate empty llinfo struct if we are
	 * not going to be sending out an arp request.
	 */
	if (ifp->if_flags & (IFF_NOARP | IFF_STATICARP)) {
		m_freem(m);
		return (EINVAL);
	}

	if (la->la_hold)
		m_freem(la->la_hold);
	la->la_hold = m;
	/*
	 * Now implement the logic to issue requests -- we can send up
	 * to arp_maxtries with a 1-sec spacing, followed by a pause
	 * of arpt_down seconds if no replies are coming back.
	 * Take the chance to enforce limits on arp_maxtries and arpt_down
	 */
	if (la->expire <= time_second) { /* ok, expired */
		if (arp_maxtries > 100) /* enforce a sane limit */
			arp_maxtries = 100;
		else if (arp_maxtries < 3)
			arp_maxtries = 3;
		if (la->la_asked++ < arp_maxtries)
			la->expire = time_second + 1;
		else {
			la->la_asked = 0;
			la->expire = time_second + arpt_down;
			la->la_preempt = arp_maxtries;
		}
		arprequest(ifp, NULL, &SIN(dst)->sin_addr, IF_LLADDR(ifp));
        }
	return (EWOULDBLOCK);
}


{
	struct arphdr *ah;
	struct ifnet *ifp = m->m_pkthdr.rcvif;
	struct llentry *la = 0;
	struct iso88025_sockaddr_dl_data *trld;
	struct llinfo_arp *la = 0;
	struct rtentry *rt;
	struct ifaddr *ifa;
	struct in_ifaddr *ia;
	struct sockaddr_dl *sdl;
	struct sockaddr sa;
	struct in_addr isaddr, itaddr, myaddr;
	int op;
	int req_len;

	req_len = arphdr_len2(ifp->if_addrlen, sizeof(struct in_addr));

	op = ntohs(ah->ar_op);
	(void)memcpy(&isaddr, ar_spa(ah), sizeof (isaddr));
	(void)memcpy(&itaddr, ar_tpa(ah), sizeof (itaddr));
	/*
	 * sanity check for the address length.
	 * XXX this does not work for protocols with variable address
	 * length. -is
	 */
	if (ifp->if_addrlen != ah->ar_hln) {
		log(LOG_WARNING,
		    "arp from %*D: addr len: new %d, i/f %d (ignored)",
		    ifp->if_addrlen, (u_char *) ar_sha(ah), ":",
		    ah->ar_hln, ifp->if_addrlen);
		goto drop;
	}

#ifdef BRIDGE
#define BRIDGE_TEST (do_bridge)
#else

	}
	if (ifp->if_flags & IFF_STATICARP)
		goto reply;
	/* Look up the source. If I am the target, create an entry for it. */
	la = arplookup(ifp, isaddr.s_addr,
	    (itaddr.s_addr == myaddr.s_addr) ? LLE_CREATE : 0);
	if (la != NULL) {
		/* We have a valid entry. Check and store the MAC. */
		if (la->flags & LLA_VALID &&
		    bcmp(ar_sha(ah), &la->ll_addr, ifp->if_addrlen)) {
			if (la->flags & LLE_STATIC) {
				    ifp->if_addrlen, (u_char *)ar_sha(ah), ":",
				    ifp->if_xname);
			goto reply;
		}
		if (sdl->sdl_alen &&
		    bcmp(ar_sha(ah), LLADDR(sdl), sdl->sdl_alen)) {
			if (rt->rt_expire) {
			    if (log_arp_movements)
			        log(LOG_INFO, "arp: %s moved from %*D to %*D on %s\n",
				    inet_ntoa(isaddr),
				    ifp->if_addrlen, (u_char *)LLADDR(sdl), ":",
				    ifp->if_addrlen, (u_char *)ar_sha(ah), ":",
				    ifp->if_xname);
			} else {
			    log(LOG_ERR,
				"arp: %*D attempts to modify permanent entry for %s on %s\n",
				ifp->if_addrlen, (u_char *)ar_sha(ah), ":",
				inet_ntoa(isaddr), ifp->if_xname);
			    goto reply;
			}
			if (log_arp_movements)
			        log(LOG_INFO, "arp: %s moved from %*D to %*D on %s\n",
				    inet_ntoa(isaddr),
				    ifp->if_addrlen, (u_char *)&la->ll_addr, ":",
				    ifp->if_addrlen, (u_char *)ar_sha(ah), ":",
				    ifp->if_xname);
		}
		bcopy(ar_sha(ah), &la->ll_addr, ifp->if_addrlen);
		la->flags |= LLA_VALID;
#if 0 /* XXX this needs to be fixed */
		 * length. -is
		 */
		if (sdl->sdl_alen &&
		    sdl->sdl_alen != ah->ar_hln) {
			log(LOG_WARNING,
			    "arp from %*D: new addr len %d, was %d",
			    ifp->if_addrlen, (u_char *) ar_sha(ah), ":",
			    ah->ar_hln, sdl->sdl_alen);
		}
		if (ifp->if_addrlen != ah->ar_hln) {
			log(LOG_WARNING,
			    "arp from %*D: addr len: new %d, i/f %d (ignored)",
			    ifp->if_addrlen, (u_char *) ar_sha(ah), ":",
			    ah->ar_hln, ifp->if_addrlen);
			goto reply;
		}
		(void)memcpy(LLADDR(sdl), ar_sha(ah),
		    sdl->sdl_alen = ah->ar_hln);
		/*
		 * If we receive an arp from a token-ring station over
		 * a token-ring nic then try to save the source
		 * routing info.
		 */
		if (ifp->if_type == IFT_ISO88025) {
			struct iso88025_header *th;
			struct iso88025_sockaddr_dl_data *trld;
			struct sockaddr_dl *sdl;
			int rif_len;

			th = (struct iso88025_header *)m->m_pkthdr.header;
			trld = SDL_ISO88025(sdl);
			rif_len = TR_RCF_RIFLEN(th->rcf);

			m->m_pkthdr.len += 8;
			th->rcf = trld->trld_rcf;
		}
#endif
		if (!(la->flags & LLE_STATIC))
			la->expire = time_second + arpt_keep;
		rt->rt_flags &= ~RTF_REJECT;
		RT_UNLOCK(rt);
		la->la_asked = 0;
		la->la_preempt = arp_maxtries;
		if (la->la_hold) {
			struct sockaddr_in sin;

			bzero(&sin, sizeof(sin));
			sin.sin_len = sizeof(struct sockaddr_in);
			sin.sin_family = AF_INET;
			sin.sin_addr.s_addr = la->l3_addr.s_addr;
			ifp->if_output(ifp, la->la_hold,
				(struct sockaddr *)&sin, NULL);
			la->la_hold = 0;
		}
	}

		(void)memcpy(ar_tha(ah), ar_sha(ah), ah->ar_hln);
		(void)memcpy(ar_sha(ah), IF_LLADDR(ifp), ah->ar_hln);
	} else {
		la = arplookup(ifp, itaddr.s_addr, LLE_PROXY);
		if (la == NULL) {
			struct sockaddr_in sin;
			struct rtentry *rt;

			if (!arp_proxyall)
				goto drop;

			       inet_ntoa(itaddr));
#endif
		} else {
			rt = la->la_rt;
			(void)memcpy(ar_tha(ah), ar_sha(ah), ah->ar_hln);
			(void)memcpy(ar_sha(ah),  &la->ll_addr, ah->ar_hln);
			(void)memcpy(ar_sha(ah), LLADDR(sdl), ah->ar_hln);
		}
	}


/*
 * Lookup or enter a new address in arptab.
 */
struct llentry *
arplookup(struct ifnet *ifp, uint32_t l3addr, u_int flags)
	u_long addr;
	int create, proxy;
{
	struct llentry *e;
	struct lltable *t;
	// uint proxy = flags & LLE_PROXY;

	if (ifp == NULL)
		return NULL;
	/* LOCK_IFNET */
	for (t = ifp->lltables; t && t->llt_af != AF_INET; t = t->llt_next)
		;
	if (t == NULL && flags & LLE_CREATE)
		t = lltable_new(ifp, AF_INET);
	if (t == NULL) {
		/* UNLOCK_ALL_TABLES */
		return NULL;    /* failed! */
	}
	/* LOCK_TABLE(t) */
	/* UNLOCK_ALL_TABLES */
	for (e = (struct llentry *)t->lle_head; e ; e = e->lle_next) {
		if (e->flags & LLE_DELETED)
			continue;
		if (l3addr == e->l3_addr.s_addr)
			break;
        }
	if (e == NULL) {        /* entry not found */
		if (!(flags & LLE_CREATE))
			goto done;
		if (find_ifa(ifp, l3addr) == NULL) {
			printf("host is not on local network\n");
			goto done;
		}
		e = malloc(sizeof (struct llentry), M_ARP, M_DONTWAIT | M_ZERO);
		if (e == NULL) {
			printf("arp malloc failed\n");
			goto done;
		}
		e->expire = time_second; /* mark expired */
		e->l3_addr.s_addr = l3addr;
		e->lle_next = t->lle_head;
		t->lle_head = e;
	}
	if (flags & LLE_DELETE &&
	    (e->flags & LLE_IFADDR) == (flags & LLE_IFADDR))
		e->flags = LLE_DELETED;
done:
	/* UNLOCK(t) */
	return e;
}


void
arp_ifinit(ifp, ifa)
	struct ifnet *ifp;
	struct ifaddr *ifa;
{
	struct llentry *la;

	printf("arp_ifinit ifp %p addr 0x%x\n",
	    ifp, ntohl(IA_SIN(ifa)->sin_addr.s_addr));

	if (ntohl(IA_SIN(ifa)->sin_addr.s_addr) != INADDR_ANY)
		arprequest(ifp, &IA_SIN(ifa)->sin_addr,
				&IA_SIN(ifa)->sin_addr, IF_LLADDR(ifp));
	la = arplookup(ifp, IA_SIN(ifa)->sin_addr.s_addr, LLE_CREATE);
	if (la) {	/* store our address */
		bcopy(IF_LLADDR(ifp), &la->ll_addr, ifp->if_addrlen);
		la->flags |= LLA_VALID | LLE_STATIC | LLE_IFADDR;
	}
	ifa->ifa_rtrequest = NULL;
}

static void


	arpintrq.ifq_maxlen = 50;
	mtx_init(&arpintrq.ifq_mtx, "arp_inq", NULL, MTX_DEF);
	LIST_INIT(&llinfo_arp);
	callout_init(&arp_callout, CALLOUT_MPSAFE);
	netisr_register(NETISR_ARP, arpintr, &arpintrq, NETISR_MPSAFE);
	callout_reset(&arp_callout, hz, newarptimer, NULL);
}
SYSINIT(arp, SI_SUB_PROTO_DOMAIN, SI_ORDER_ANY, arp_init, 0);




int	arpresolve(struct ifnet *ifp, struct rtentry *rt,
		struct mbuf *m, struct sockaddr *dst, u_char *desten);
void	arp_ifinit(struct ifnet *, struct ifaddr *);

/*
 * Support routines for the new arp table
 */
struct lltable *lltable_new(struct ifnet *ifp, int af);
struct lltable **lltable_free(struct lltable **t);
#endif

struct lltable {
	struct lltable	*llt_next;
	void	*lle_head;	/* pointer to the list of address entries */
	int	llt_af;		/* address family */
};

/*
 * flags to be passed to arplookup.
 */
#define LLE_DELETED     0x0001  /* entry must be deleted        */
#define LLE_STATIC      0x0002  /* entry is static              */
#define LLE_IFADDR      0x0004  /* entry is interface addr      */
#define LLA_VALID       0x0008  /* ll_addr is valid             */
#define LLE_PROXY       0x0010  /* proxy entry ???              */
#define LLE_PUB         0x0020  /* publish entry ???            */
#define LLE_CREATE      0x8000  /* create on a lookup miss      */
#define LLE_DELETE      0x4000  /* delete on a lookup - match LLE_IFADDR */

/*
 * End of support code for the new arp table
 */
#endif




		    !(rtm->rtm_flags & RTF_GATEWAY) &&
		    valid_type(sdl->sdl_type) )
			break;	/* found it */
		/* check the new arp interface */
		if (sdl->sdl_family == AF_LINK &&
		    !(rtm->rtm_flags & RTF_GATEWAY) &&
		    valid_type(sdl->sdl_type) ) {
			/*
			 * found it. But overwrite the address to make
			 * sure that we really get it.
			 */
			addr->sin_addr.s_addr = dst->sin_addr.s_addr;
			break;
		}
		if (dst->sin_other & SIN_PROXY) {
			fprintf(stderr, "delete: cannot locate %s\n",host);
			return (1);

Return to bug 68692

Lines 112-117 Link Here

(-)src/sys/netinet/if_ether.h (+27 lines)
112	int arpresolve(struct ifnet ifp, struct rtentry rt,	112	int arpresolve(struct ifnet ifp, struct rtentry rt,
113	struct mbuf m, struct sockaddr dst, u_char *desten);	113	struct mbuf m, struct sockaddr dst, u_char *desten);
114	void arp_ifinit(struct ifnet , struct ifaddr );	114	void arp_ifinit(struct ifnet , struct ifaddr );
		115
		116	/*
		117	* Support routines for the new arp table
		118	*/
		119	struct lltable lltable_new(struct ifnet ifp, int af);
		120	struct lltable lltable_free(struct lltable t);
115	#endif	121	#endif
116		122
		123	struct lltable {
		124	struct lltable *llt_next;
		125	void lle_head; / pointer to the list of address entries */
		126	int llt_af; /* address family */
		127	};
		128
		129	/*
		130	* flags to be passed to arplookup.
		131	*/
		132	#define LLE_DELETED 0x0001 /* entry must be deleted */
		133	#define LLE_STATIC 0x0002 /* entry is static */
		134	#define LLE_IFADDR 0x0004 /* entry is interface addr */
		135	#define LLA_VALID 0x0008 /* ll_addr is valid */
		136	#define LLE_PROXY 0x0010 /* proxy entry ??? */
		137	#define LLE_PUB 0x0020 /* publish entry ??? */
		138	#define LLE_CREATE 0x8000 /* create on a lookup miss */
		139	#define LLE_DELETE 0x4000 /* delete on a lookup - match LLE_IFADDR */
		140
		141	/*
		142	* End of support code for the new arp table
		143	*/
117	#endif	144	#endif

Lines 439-444 Link Here

(-)src/usr.sbin/arp/arp.c (+11 lines)
439	!(rtm->rtm_flags & RTF_GATEWAY) &&	439	!(rtm->rtm_flags & RTF_GATEWAY) &&
440	valid_type(sdl->sdl_type) )	440	valid_type(sdl->sdl_type) )
441	break; /* found it */	441	break; /* found it */
		442	/* check the new arp interface */
		443	if (sdl->sdl_family == AF_LINK &&
		444	!(rtm->rtm_flags & RTF_GATEWAY) &&
		445	valid_type(sdl->sdl_type) ) {
		446	/*
		447	* found it. But overwrite the address to make
		448	* sure that we really get it.
		449	*/
		450	addr->sin_addr.s_addr = dst->sin_addr.s_addr;
		451	break;
		452	}
442	if (dst->sin_other & SIN_PROXY) {	453	if (dst->sin_other & SIN_PROXY) {
443	fprintf(stderr, "delete: cannot locate %s\n",host);	454	fprintf(stderr, "delete: cannot locate %s\n",host);
444	return (1);	455	return (1);