? sys/net/old
? sys/net/old2
? sys/netinet/tcpsign
Index: sys/net/route.c
===================================================================
RCS file: /cvsroot/src/sys/net/route.c,v
retrieving revision 1.98
diff -u -p -r1.98 route.c
--- sys/net/route.c	10 Oct 2007 22:14:38 -0000	1.98
+++ sys/net/route.c	12 Nov 2007 17:14:39 -0000
@@ -147,6 +147,7 @@ struct callout rt_timer_ch; /* callout f
 static int _rtcache_debug = 0;
 #endif /* RTFLUSH_DEBUG */
 
+struct rtentry *rtgethead(const struct sockaddr *, const struct sockaddr *);
 static int rtdeletemsg(struct rtentry *);
 static int rtflushclone1(struct rtentry *, void *);
 static void rtflushclone(sa_family_t family, struct rtentry *);
@@ -304,6 +305,34 @@ rtalloc(struct route *ro)
 	rtcache(ro);
 }
 
+/*
+ * Returns rtentry in a RR fashion
+ * rt should be the first path
+ */
+struct rtentry *
+rtchoosepath_rr(struct rtentry *rt)
+{
+	rt->rt_last = rtnext(rt->rt_last);
+	return rt->rt_last;
+}
+
+/*
+ * Next rtentry that it's UP (in case there is such thing)
+ * If none is found return the feeded rtentry
+ */
+struct rtentry *
+rtnext(struct rtentry *rt)
+{
+	struct rtentry *retrt, *sentinel;
+
+	KASSERT(rt != NULL);
+	CLIST_FOREACH(retrt, CLIST_NEXT(rt, rt_list), sentinel, rt_list)
+	    if (retrt->rt_flags & RTF_UP)
+		return retrt;
+
+	return rt;
+}
+
 struct rtentry *
 rtalloc1(const struct sockaddr *dst, int report)
 {
@@ -355,28 +384,81 @@ rtalloc1(const struct sockaddr *dst, int
 	return newrt;
 }
 
+/*
+ * returns head of the list
+ * just a rnh_lookup wrapper
+ */
+struct rtentry *
+rtgethead(const struct sockaddr *dst, const struct sockaddr *netmask)
+{
+	struct radix_node_head *rnh = rt_tables[dst->sa_family];
+	struct rtentry *rt = NULL;
+	struct radix_node *rn;
+	int  s = splsoftnet();
+
+	if (rnh && (rn = rnh->rnh_lookup(dst, netmask, rnh)) &&
+	    ((rn->rn_flags & RNF_ROOT) == 0))
+		rt = (struct rtentry *)rn;
+		else
+		rtstat.rts_unreach++;
+
+	splx(s);
+	return rt;
+}
+
 void
 rtfree(struct rtentry *rt)
 {
-	struct ifaddr *ifa;
+	struct rtentry *rthead;
 
 	if (rt == NULL)
 		panic("rtfree");
 	rt->rt_refcnt--;
 	if (rt->rt_refcnt <= 0 && (rt->rt_flags & RTF_UP) == 0) {
-		if (rt->rt_nodes->rn_flags & (RNF_ACTIVE | RNF_ROOT))
-			panic ("rtfree 2");
 		rttrash--;
 		if (rt->rt_refcnt < 0) {
 			printf("rtfree: %p not freed (neg refs)\n", rt);
 			return;
 		}
+		rthead = RTFIRST(rt);
+		rthead->rt_total--;
+		if (rthead->rt_total == 0 &&
+		    (rt->rt_nodes->rn_flags & (RNF_ACTIVE | RNF_ROOT)))
+			panic("rtfree 2");
 		rt_timer_remove_all(rt, 0);
-		ifa = rt->rt_ifa;
-		rt->rt_ifa = NULL;
-		IFAFREE(ifa);
-		rt->rt_ifp = NULL;
-		rt_destroy(rt);
+		IFAFREE(rt->rt_ifa);
+		if (rthead->rt_total == 0) {
+			/* No other paths */
+			rt_destroy(rt);
+		} else if (rthead == rt) {
+			/* First GW to delete from more */
+			struct radix_node_head *rnh;
+			struct rtentry *srt = CLIST_NEXT(rthead, rt_list),
+				*sen, *rtin;
+			KASSERT(rt != srt);
+			srt->rt_total = rt->rt_total;
+			srt->rt_last = srt;
+			CLIST_REMOVE(rt, rt_list);
+			if ((rnh = rt_tables[rt_getkey(rt)->sa_family]) == NULL)
+				panic("rtfree: rt_tables");
+			if (rnh->rnh_deladdr(rt_getkey(rt), rt_mask(rt), rnh) == NULL)
+				panic("rtfree: deladdr");
+			if (rnh->rnh_addaddr(rt_getkey(srt), rt_mask(srt), rnh,
+			    srt->rt_nodes) == NULL)
+				panic("rtfree: addaddr");
+			CLIST_FOREACH(rtin, srt, sen, rt_list)
+				RTFIRST(rtin) = srt;
+		} else {
+			/* Delete a non-first path */
+			CLIST_REMOVE(rt, rt_list);
+			if (rthead->rt_last == rt)
+				rthead->rt_last = rthead;
+		}
+
+		if (rt->rt_gateway != NULL)
+			sockaddr_free(rt->rt_gateway);
+		/* do I really need this ? I also Bzero at pool_get */
+		Bzero(rt, sizeof(*rt));
 		pool_put(&rtentry_pool, rt);
 	}
 }
@@ -427,20 +509,33 @@ rtredirect(const struct sockaddr *dst, c
 		error = ENETUNREACH;
 		goto out;
 	}
-	rt = rtalloc1(dst, 0);
 	/*
-	 * If the redirect isn't from our current router for this dst,
-	 * it's either old or wrong.  If it redirects us to ourselves,
-	 * we have a routing loop, perhaps as a result of an interface
-	 * going down recently.
+	 * If it redirects us to ourselves we have a routing loop,
+	 * perhaps as a result of an interface going down recently.
 	 */
-	if (!(flags & RTF_DONE) && rt &&
-	     (!equal(src, rt->rt_gateway) || rt->rt_ifa != ifa))
-		error = EINVAL;
-	else if (ifa_ifwithaddr(gateway))
+	if (ifa_ifwithaddr(gateway)) {
 		error = EHOSTUNREACH;
-	if (error)
-		goto done;
+		goto out;
+	}
+	rt = rtalloc1(dst, 0);
+	if (rt && !(flags & RTF_DONE)) {
+		/*
+	 	 * If the redirect isn't from our current router for this dst,
+	 	 * it's either old or wrong. Also calibrate rt.
+	 	 */
+		struct rtentry *sentinel, *nrt;
+		CLIST_FOREACH(nrt, rt, sentinel, rt_list)
+		    if(equal(src, nrt->rt_gateway) && (nrt->rt_ifa == ifa))
+			break;
+		if(nrt == NULL) {
+			error = EINVAL;
+			goto done;
+		}
+		rt->rt_refcnt--;
+		nrt->rt_refcnt++;
+		rt = nrt;
+	}
+
 	/*
 	 * Create a new entry if we just got back a wildcard entry
 	 * or the lookup failed.  This is necessary for hosts
@@ -485,6 +580,7 @@ rtredirect(const struct sockaddr *dst, c
 		}
 	} else
 		error = EHOSTUNREACH;
+
 done:
 	if (rt) {
 		if (rtp != NULL && !error)
@@ -674,7 +770,7 @@ rtrequest1(int req, struct rt_addrinfo *
 {
 	int s = splsoftnet();
 	int error = 0;
-	struct rtentry *rt, *crt;
+	struct rtentry *rt, *crt = NULL, *sentinel, *nrt;
 	struct radix_node *rn;
 	struct radix_node_head *rnh;
 	struct ifaddr *ifa;
@@ -698,16 +794,45 @@ rtrequest1(int req, struct rt_addrinfo *
 		}
 		if ((rn = rnh->rnh_lookup(dst, netmask, rnh)) == NULL)
 			senderr(ESRCH);
-		rt = (struct rtentry *)rn;
+		crt = rt = (struct rtentry *)rn;
+		/* Calibrate */
+		if (gateway != NULL && !(crt->rt_flags & RTF_CLONING)) {
+			/*
+			 * XXX: we can have a gateway on cloning route
+			 */
+			CLIST_FOREACH(rt, crt, sentinel, rt_list)
+			    if (sockaddr_cmp(gateway, rt->rt_gateway) == 0)
+				break;
+			if (rt == NULL)
+				senderr(ESRCH);
+		} else
+			if (! CLIST_SINGULAR(crt, rt_list)) {
+				/*
+				 * If gateway is not provided when
+				 * multiple paths exist check if it's a cloning
+				 * route and try to match ifp
+				 */
+				if ( (crt->rt_flags & RTF_CLONING) == 0 ||
+				    !(info->rti_ifa)) 
+				    senderr(EINVAL);
+				CLIST_FOREACH(rt, crt, sentinel, rt_list)
+				    if (rt->rt_ifp == info->rti_ifa->ifa_ifp)
+					break;
+				if (rt == NULL)
+				    senderr(EINVAL);
+			}
+		if (CLIST_SINGULAR(rt, rt_list)) {
+			if ((rn = rnh->rnh_deladdr(dst, netmask, rnh)) == NULL)
+				senderr(ESRCH);
+			if (rn->rn_flags & (RNF_ACTIVE | RNF_ROOT))
+				panic("rtrequest delete");
+		}
 		if ((rt->rt_flags & RTF_CLONING) != 0) {
 			/* clean up any cloned children */
 			rtflushclone(dst->sa_family, rt);
 		}
-		if ((rn = rnh->rnh_deladdr(dst, netmask, rnh)) == NULL)
-			senderr(ESRCH);
-		if (rn->rn_flags & (RNF_ACTIVE | RNF_ROOT))
-			panic ("rtrequest delete");
-		rt = (struct rtentry *)rn;
+		if (rt->rt_nodes->rn_flags & RNF_ROOT)
+			panic("rtrequest delete 2");
 		if (rt->rt_gwroute) {
 			RTFREE(rt->rt_gwroute);
 			rt->rt_gwroute = NULL;
@@ -781,26 +906,60 @@ rtrequest1(int req, struct rt_addrinfo *
 			rt->rt_parent = *ret_nrt;
 			rt->rt_parent->rt_refcnt++;
 		}
+		rt->rt_total = 1;
+		rt->rt_first = rt;
+		rt->rt_last = rt;
+		CLIST_INIT(rt, rt_list);
 		RT_DPRINTF("%s l.%d: rt->_rt_key = %p\n", __func__,
 		    __LINE__, (void *)rt->_rt_key);
 		rn = rnh->rnh_addaddr(rt_getkey(rt), netmask, rnh,
 		    rt->rt_nodes);
 		RT_DPRINTF("%s l.%d: rt->_rt_key = %p\n", __func__,
 		    __LINE__, (void *)rt->_rt_key);
-		if (rn == NULL && (crt = rtalloc1(rt_getkey(rt), 0)) != NULL) {
+		if (rn == NULL &&
+		    ((crt = rtgethead(rt_getkey(rt), NULL)) != NULL) &&
 			/* overwrite cloned route */
-			if ((crt->rt_flags & RTF_CLONED) != 0) {
-				rtdeletemsg(crt);
-				rn = rnh->rnh_addaddr(rt_getkey(rt),
-				    netmask, rnh, rt->rt_nodes);
+		    ((crt->rt_flags & RTF_CLONED) != 0)) {
+			rtdeletemsg(crt);
+			rn = rnh->rnh_addaddr(rt_getkey(rt),
+			    netmask, rnh, rt->rt_nodes);
+			crt = NULL;
+			if (rn == NULL) {
+				error = ENOMEM;
+				goto eexist;
 			}
-			RTFREE(crt);
 			RT_DPRINTF("%s l.%d: rt->_rt_key = %p\n", __func__,
-			    __LINE__, (void *)rt->_rt_key);
+		    	    __LINE__, (void *)rt->_rt_key);
 		}
-		RT_DPRINTF("%s l.%d: rt->_rt_key = %p\n", __func__,
-		    __LINE__, (void *)rt->_rt_key);
-		if (rn == NULL) {
+		else if (req == RTM_ADD && rn == NULL &&
+		    ((crt = rtgethead(rt_getkey(rt), netmask)) != NULL)) {
+			/* New route for the same destination */
+			if (crt->rt_total >= MAX_PATHS) {
+				error = E2BIG;
+				goto eexist;
+			}
+			if (gateway) {
+			    CLIST_FOREACH(nrt, crt, sentinel, rt_list)
+				if (sockaddr_cmp(nrt->rt_gateway, gateway) == 0)
+				    goto eexist;
+			} else if((rt->rt_flags & RTF_CLONING) &&
+				    (info->rti_ifa)) {
+			    CLIST_FOREACH(nrt, crt, sentinel, rt_list)
+				if (nrt->rt_ifp == info->rti_ifa->ifa_ifp)
+				    goto eexist;
+			} else if(rt->rt_flags & RTF_CLONING)
+			    CLIST_FOREACH(nrt, crt, sentinel, rt_list)
+				if (nrt->rt_ifp == rt->rt_ifp)
+				    goto eexist;
+			sockaddr_free(rt->_rt_key);
+			rt->rt_nodes->rn_mask = crt->rt_nodes->rn_mask;
+			rt->_rt_key = crt->_rt_key;
+			rt->rt_first = crt;
+			CLIST_INSERT_AFTER(crt, rt, rt_list);
+			crt->rt_total++;
+			crt = NULL;
+		} else if (rn == NULL) {
+eexist:
 			IFAFREE(ifa);
 			if ((rt->rt_flags & RTF_CLONED) != 0 && rt->rt_parent)
 				rtfree(rt->rt_parent);
@@ -808,7 +967,10 @@ rtrequest1(int req, struct rt_addrinfo *
 				rtfree(rt->rt_gwroute);
 			rt_destroy(rt);
 			pool_put(&rtentry_pool, rt);
-			senderr(EEXIST);
+			if (error)
+				senderr(error)
+			else
+				senderr(EEXIST);
 		}
 		RT_DPRINTF("%s l.%d: rt->_rt_key = %p\n", __func__,
 		    __LINE__, (void *)rt->_rt_key);
@@ -824,7 +986,8 @@ rtrequest1(int req, struct rt_addrinfo *
 			/* clean up any cloned children */
 			rtflushclone(dst->sa_family, rt);
 		}
-		rtflushall(dst->sa_family);
+		if (crt == NULL)
+			rtflushall(dst->sa_family);
 		break;
 	case RTM_GET:
 		if (netmask != NULL) {
@@ -837,6 +1000,7 @@ rtrequest1(int req, struct rt_addrinfo *
 			senderr(ESRCH);
 		if (ret_nrt != NULL) {
 			rt = (struct rtentry *)rn;
+			rt = rtchoosepath_rr(rt);
 			*ret_nrt = rt;
 			rt->rt_refcnt++;
 		}
@@ -944,8 +1108,12 @@ rtinit(struct ifaddr *ifa, int cmd, int 
 			rt_maskedcopy(odst, dst, ifa->ifa_netmask);
 		}
 		if ((rt = rtalloc1(dst, 0)) != NULL) {
+			struct rtentry *sentinel;
 			rt->rt_refcnt--;
-			if (rt->rt_ifa != ifa)
+			CLIST_FOREACH(rt, rt, sentinel, rt_list)
+				if (rt->rt_ifa->ifa_ifp == ifa->ifa_ifp)
+					break;
+			if (rt == NULL)
 				return (flags & RTF_HOST) ? EHOSTUNREACH
 							: ENETUNREACH;
 		}
Index: sys/net/route.h
===================================================================
RCS file: /cvsroot/src/sys/net/route.h,v
retrieving revision 1.58
diff -u -p -r1.58 route.h
--- sys/net/route.h	27 Aug 2007 00:34:01 -0000	1.58
+++ sys/net/route.h	12 Nov 2007 17:14:39 -0000
@@ -93,6 +93,10 @@ struct rt_metrics {
 #ifndef RNF_NORMAL
 #include <net/radix.h>
 #endif
+
+/* XXX: sysctl maybe ? */
+#define MAX_PATHS 64
+
 struct rtentry {
 	struct	radix_node rt_nodes[2];	/* tree glue, and other values */
 #define	rt_mask(r)	((const struct sockaddr *)((r)->rt_nodes->rn_mask))
@@ -108,7 +112,13 @@ struct rtentry {
 	struct	rtentry *rt_gwroute;	/* implied entry for gatewayed routes */
 	LIST_HEAD(, rttimer) rt_timer;  /* queue of timeouts for misc funcs */
 	struct	rtentry *rt_parent;	/* parent of cloned route */
-	struct sockaddr *_rt_key;
+	struct	sockaddr *_rt_key;
+	/* load-sharing */
+	CLIST_ENTRY(rtentry) rt_list;
+	struct	rtentry *rt_first;	/* First entry in list */
+#define	RTFIRST(r)	((r)->rt_first)
+	struct	rtentry *rt_last;	/* For round robin */
+	uint8_t	rt_total;		/* Number of paths */
 };
 
 static inline const struct sockaddr *
@@ -366,6 +376,7 @@ out:
 }
 
 struct rtentry *rtfindparent(struct radix_node_head *, struct route *);
+struct rtentry *rtnext(struct rtentry *);
 
 #ifdef RTCACHE_DEBUG
 #define	rtcache_init(ro)		rtcache_init_debug(__func__, ro)
@@ -386,6 +397,7 @@ void	rtcache_clear(struct route *);
 void	rtcache_update(struct route *, int);
 void	rtcache_free(struct route *);
 int	rtcache_setdst(struct route *, const struct sockaddr *);
+struct rtentry* rtchoosepath_rr(struct rtentry *);
 
 static inline struct rtentry *
 rtcache_lookup1(struct route *ro, const struct sockaddr *dst, int clone)
Index: sys/net/rtsock.c
===================================================================
RCS file: /cvsroot/src/sys/net/rtsock.c,v
retrieving revision 1.95
diff -u -p -r1.95 rtsock.c
--- sys/net/rtsock.c	19 Jul 2007 20:48:53 -0000	1.95
+++ sys/net/rtsock.c	12 Nov 2007 17:14:39 -0000
@@ -306,7 +306,7 @@ route_output(struct mbuf *m, ...)
 		if (rtm->rtm_type != RTM_GET) {/* XXX: too grotty */
 			struct radix_node *rn;
 
-			if (memcmp(dst, rt_getkey(rt), dst->sa_len) != 0)
+			if (sockaddr_cmp(dst, rt_getkey(rt)) != 0)
 				senderr(ESRCH);
 			netmask = intern_netmask(netmask);
 			for (rn = rt->rt_nodes; rn; rn = rn->rn_dupedkey)
@@ -923,6 +923,8 @@ sysctl_dumpentry(struct rtentry *rt, voi
 	int error = 0, size;
 	struct rt_addrinfo info;
 
+	if (CLIST_NEXT(rt, rt_list) != RTFIRST(rt))
+		sysctl_dumpentry(CLIST_NEXT(rt, rt_list), v);
 	if (w->w_op == NET_RT_FLAGS && !(rt->rt_flags & w->w_arg))
 		return 0;
 	memset(&info, 0, sizeof(info));
Index: sys/netinet/if_arp.c
===================================================================
RCS file: /cvsroot/src/sys/netinet/if_arp.c,v
retrieving revision 1.128
diff -u -p -r1.128 if_arp.c
--- sys/netinet/if_arp.c	2 Sep 2007 19:42:22 -0000	1.128
+++ sys/netinet/if_arp.c	12 Nov 2007 17:14:39 -0000
@@ -768,16 +768,18 @@ arpresolve(struct ifnet *ifp, struct rte
 	if (rt->rt_expire) {
 		rt->rt_flags &= ~RTF_REJECT;
 		if (la->la_asked == 0 || rt->rt_expire != time_second) {
+			struct rtentry *nrt, *sentinel;
 			rt->rt_expire = time_second;
 			if (la->la_asked++ < arp_maxtries)
-				arprequest(ifp,
-				    &satocsin(rt->rt_ifa->ifa_addr)->sin_addr,
+			    CLIST_FOREACH(nrt, rt->rt_parent, sentinel, rt_list)
+				arprequest(nrt->rt_ifp,
+				    &satocsin(nrt->rt_ifa->ifa_addr)->sin_addr,
 				    &satocsin(dst)->sin_addr,
 #if NCARP > 0
 				    (rt->rt_ifp->if_type == IFT_CARP) ?
 				    CLLADDR(rt->rt_ifp->if_sadl):
 #endif
-				    CLLADDR(ifp->if_sadl));
+				    CLLADDR(nrt->rt_ifp->if_sadl));
 			else {
 				rt->rt_flags |= RTF_REJECT;
 				rt->rt_expire += arpt_down;
@@ -1097,6 +1099,19 @@ in_arpinput(struct mbuf *m)
 		if (rt->rt_expire)
 			rt->rt_expire = time_second + arpt_keep;
 		rt->rt_flags &= ~RTF_REJECT;
+		if(rt->rt_ifp != ifp) {
+			/*
+			 * Reply came on different interface. Check
+			 * if we have a rt_parent with this ifp
+			 */
+			struct rtentry *nrt, *sentinel;
+			CLIST_FOREACH(nrt, rt->rt_parent, sentinel, rt_list)
+				if(nrt->rt_ifp == ifp) {
+					rt_replace_ifa(rt, nrt->rt_ifa);
+					rt->rt_ifp = nrt->rt_ifp;
+					break;
+				}
+		}
 		la->la_asked = 0;
 
 		s = splnet();
Index: sys/netinet/in.c
===================================================================
RCS file: /cvsroot/src/sys/netinet/in.c,v
retrieving revision 1.118
diff -u -p -r1.118 in.c
--- sys/netinet/in.c	1 Sep 2007 04:32:51 -0000	1.118
+++ sys/netinet/in.c	12 Nov 2007 17:14:39 -0000
@@ -987,7 +987,7 @@ bad:
 
 /*
  * add a route to prefix ("connected route" in cisco terminology).
- * does nothing if there's some interface address with the same prefix already.
+ * does nothing if there's same prefix already assigned to the same interface.
  */
 static int
 in_addprefix(struct in_ifaddr *target, int flags)
@@ -1012,14 +1012,11 @@ in_addprefix(struct in_ifaddr *target, i
 			p.s_addr &= ia->ia_sockmask.sin_addr.s_addr;
 		}
 
-		if (prefix.s_addr != p.s_addr)
+		if (prefix.s_addr != p.s_addr || target->ia_ifp != ia->ia_ifp)
 			continue;
-
 		/*
-		 * if we got a matching prefix route inserted by other
-		 * interface address, we don't need to bother
-		 *
-		 * XXX RADIX_MPATH implications here? -dyoung
+		 * if we got a matching prefix route inserted on the same
+		 * interface, we don't need to bother
 		 */
 		if (ia->ia_flags & IFA_ROUTE)
 			return 0;
Index: sys/netinet/in.h
===================================================================
RCS file: /cvsroot/src/sys/netinet/in.h,v
retrieving revision 1.81
diff -u -p -r1.81 in.h
--- sys/netinet/in.h	19 Sep 2007 04:33:43 -0000	1.81
+++ sys/netinet/in.h	12 Nov 2007 17:14:39 -0000
@@ -450,8 +450,9 @@ struct ip_mreq {
 #define	IPCTL_IFQ	       21	/* ipintrq node */
 #define	IPCTL_RANDOMID	       22	/* use random IP ids (if configured) */
 #define	IPCTL_LOOPBACKCKSUM    23	/* do IP checksum on loopback */
-#define	IPCTL_STATS		24	/* IP statistics */
-#define	IPCTL_MAXID	       25
+#define	IPCTL_STATS	       24	/* IP statistics */
+#define IPCTL_LOAD_SHARING     25	/* Load sharing */
+#define	IPCTL_MAXID	       26
 
 #define	IPCTL_NAMES { \
 	{ 0, 0 }, \
@@ -479,7 +480,13 @@ struct ip_mreq {
 	{ "random_id", CTLTYPE_INT }, \
 	{ "do_loopback_cksum", CTLTYPE_INT }, \
 	{ "stats", CTLTYPE_STRUCT }, \
+	{ "load-sharing", CTLTYPE_NODE }, \
 }
+
+/* Load sharing */
+#define	IPCTL_LS_SELECTED	1
+#define	IPCTL_LS_AVAILABLE	2
+
 #endif /* _NETBSD_SOURCE */
 
 /* INET6 stuff */
Index: sys/netinet/ip_input.c
===================================================================
RCS file: /cvsroot/src/sys/netinet/ip_input.c,v
retrieving revision 1.254
diff -u -p -r1.254 ip_input.c
--- sys/netinet/ip_input.c	2 Oct 2007 20:35:04 -0000	1.254
+++ sys/netinet/ip_input.c	12 Nov 2007 17:14:39 -0000
@@ -218,6 +218,13 @@ int	ip_do_randomid = 0;
  */
 int	ip_checkinterface = 0;
 
+#define INITIAL_LS 2
+#define MAX_LS_STRING 20
+
+/* See also defines in ip_output.c if you want to change these */
+const char* load_sharing_strings[] = { "first-only", "round-robin",
+		"simple-sum", NULL };
+int	load_sharing_index = INITIAL_LS;
 
 struct rttimer_queue *ip_mtudisc_timeout_q = NULL;
 
@@ -2163,6 +2170,45 @@ sysctl_net_inet_ip_hashsize(SYSCTLFN_ARG
 }
 #endif /* GATEWAY */
 
+static int
+sysctl_load_sharing(SYSCTLFN_ARGS)
+{
+	int error, i;
+	struct sysctlnode node = *rnode;
+	char lsc[MAX_LS_STRING];
+
+	strlcpy(lsc, load_sharing_strings[load_sharing_index], MAX_LS_STRING);
+	node.sysctl_data = lsc;
+	error = sysctl_lookup(SYSCTLFN_CALL(&node));
+	if (error || newp == NULL)
+		return error;
+	for (i=0; load_sharing_strings[i] != NULL; i++)
+		if (strncmp(load_sharing_strings[i], lsc, MAX_LS_STRING) == 0)
+			break;
+
+	if (load_sharing_strings[i] == NULL)
+		return EINVAL;
+	load_sharing_index = i;
+	return 0;
+}
+
+static int
+sysctl_ls_types(SYSCTLFN_ARGS)
+{
+	struct sysctlnode node = *rnode;
+	int i;
+	char rt[255];
+
+	rt[0]=0;
+	/* XXX: slow and ugly */
+	for (i=0; load_sharing_strings[i] != NULL; i++) {
+		strlcat(rt, load_sharing_strings[i], 255);
+		if (load_sharing_strings[i+1] != NULL)
+			strlcat(rt, " ", 255);
+		}
+	node.sysctl_data = rt;
+	return sysctl_lookup(SYSCTLFN_CALL(&node));
+}
 
 SYSCTL_SETUP(sysctl_net_inet_ip_setup, "sysctl net.inet.ip subtree setup")
 {
@@ -2370,4 +2416,24 @@ SYSCTL_SETUP(sysctl_net_inet_ip_setup, "
 		       NULL, 0, &ipstat, sizeof(ipstat),
 		       CTL_NET, PF_INET, IPPROTO_IP, IPCTL_STATS,
 		       CTL_EOL);
+	sysctl_createv(clog, 0, NULL, NULL,
+		       CTLFLAG_PERMANENT, CTLTYPE_NODE, "load-sharing",
+		       SYSCTL_DESCR("IP load sharing"),
+		       NULL, 0, NULL, 0, CTL_NET, PF_INET, IPPROTO_IP,
+		       IPCTL_LOAD_SHARING, CTL_EOL);
+	sysctl_createv(clog, 0, NULL, NULL,
+		       CTLFLAG_PERMANENT | CTLFLAG_READWRITE,
+		       CTLTYPE_STRING, "selected",
+		       SYSCTL_DESCR("IP load sharing algorithm"),
+		       sysctl_load_sharing, 0,
+		       &load_sharing_strings[INITIAL_LS],
+		       MAX_LS_STRING - 1,
+		       CTL_NET, PF_INET, IPPROTO_IP,
+		       IPCTL_LOAD_SHARING, IPCTL_LS_SELECTED, CTL_EOL);
+	sysctl_createv(clog, 0, NULL, NULL,
+		       CTLFLAG_PERMANENT, CTLTYPE_STRING, "available",
+		       SYSCTL_DESCR("IP load sharing supported algorithms"),
+		       sysctl_ls_types, 0, NULL, 255, CTL_NET,
+		       PF_INET, IPPROTO_IP, IPCTL_LOAD_SHARING, IPCTL_LS_AVAILABLE,
+		       CTL_EOL);
 }
Index: sys/netinet/ip_output.c
===================================================================
RCS file: /cvsroot/src/sys/netinet/ip_output.c,v
retrieving revision 1.184
diff -u -p -r1.184 ip_output.c
--- sys/netinet/ip_output.c	19 Sep 2007 04:33:43 -0000	1.184
+++ sys/netinet/ip_output.c	12 Nov 2007 17:14:39 -0000
@@ -171,6 +171,16 @@ int	ip_do_loopback_cksum = 0;
 	(((csum_flags) & M_CSUM_TCPv4) != 0 && tcp_do_loopback_cksum) || \
 	(((csum_flags) & M_CSUM_IPv4) != 0 && ip_do_loopback_cksum)))
 
+/* See also string associations in ip_input.c if you want to change these */
+#define LS_NONE 0
+#define LS_RR   1
+#define LS_SS   2
+
+extern int load_sharing_index;
+
+#define tiny_sum(ip4a) ((ip4a >> 24) + (ip4a << 8 >> 24) + \
+			(ip4a << 16 >> 24) + (ip4a << 24 >> 24))
+
 /*
  * IP output.  The packet in mbuf chain m contains a skeletal IP
  * header (with len, off, ttl, proto, tos, src, dst).
@@ -338,13 +348,43 @@ ip_output(struct mbuf *m0, ...)
 		mtu = ifp->if_mtu;
 		IFP_TO_IA(ifp, ia);
 	} else {
-		if (ro->ro_rt == NULL)
+		int ro_cached = 1;
+		if (ro->ro_rt == NULL) {
 			rtcache_init(ro);
+			ro_cached = 0;
+		}
 		if (ro->ro_rt == NULL) {
 			ipstat.ips_noroute++;
 			error = EHOSTUNREACH;
 			goto bad;
 		}
+		/* Load-sharing */
+		if (ro->ro_rt->rt_total > 1 &&
+		    load_sharing_index != LS_NONE &&
+		    !(load_sharing_index == LS_SS && ro_cached)) {
+			ro->ro_rt->rt_refcnt--;
+			switch(load_sharing_index) {
+			    case LS_RR:
+				ro->ro_rt = rtchoosepath_rr(ro->ro_rt);
+				break;
+			    case LS_SS:
+				{
+				uint8_t i, hsh;
+				/* I'm not that happy with this "sum" */
+				hsh = ( tiny_sum(ip->ip_src.s_addr) +
+					tiny_sum(ip->ip_dst.s_addr) +
+					ip->ip_p + ip->ip_tos) %
+						ro->ro_rt->rt_total;
+				/* XXX: Normally it should be up... */
+				if (hsh == 0 && !(ro->ro_rt->rt_flags & RTF_UP))
+					ro->ro_rt = rtnext(ro->ro_rt);
+				else for (i = 0; i < hsh; i++)
+					ro->ro_rt = rtnext(ro->ro_rt);
+				}
+				break;
+			}
+			ro->ro_rt->rt_refcnt++;
+		}
 		ia = ifatoia(ro->ro_rt->rt_ifa);
 		ifp = ro->ro_rt->rt_ifp;
 		if ((mtu = ro->ro_rt->rt_rmx.rmx_mtu) == 0)
Index: sys/sys/queue.h
===================================================================
RCS file: /cvsroot/src/sys/sys/queue.h,v
retrieving revision 1.47
diff -u -p -r1.47 queue.h
--- sys/sys/queue.h	18 Jul 2007 12:07:35 -0000	1.47
+++ sys/sys/queue.h	12 Nov 2007 17:14:39 -0000
@@ -674,4 +674,57 @@ struct {								\
 	    ? ((head)->cqh_last)					\
 	    : (elm->field.cqe_prev))
 
+/*
+ * Circular lists definitions
+ */
+#define	CLIST_ENTRY(__type)		\
+	struct {			\
+		struct __type *cl_next;	\
+		struct __type *cl_prev;	\
+	}
+
+/*
+ * Circular lists functions
+ */
+#define	CLIST_FOREACH1(__elm, __first, __sentinel, __field)	\
+	for ((__elm) = (__sentinel) = (__first); (__elm) != NULL;\
+	     (__elm) = ((__elm)->__field == (__sentinel))	\
+	        ?  NULL						\
+		: (__elm)->__field)
+
+#define	CLIST_FOREACH(__elm, __first, __sentinel, __field)		\
+	CLIST_FOREACH1((__elm), (__first), __sentinel, __field.cl_next)
+
+#define	CLIST_FOREACH_REVERSE(__elm, __first, __sentinel, __field)	\
+	CLIST_FOREACH1((__elm), (__first), __sentinel, __field.cl_prev)
+
+#define	CLIST_INIT(__elm, __field)					\
+	do {								\
+		(__elm)->__field.cl_prev = (__elm)->__field.cl_next =	\
+		    (__elm);		\
+	} while (/*CONSTCOND*/0)
+
+#define	CLIST_SINGULAR(__elm, __field)	((__elm)->__field.cl_prev == (__elm))
+
+#define	CLIST_REMOVE(__elm, __field)				\
+	do {							\
+		(__elm)->__field.cl_prev->__field.cl_next =	\
+		    (__elm)->__field.cl_next;			\
+		(__elm)->__field.cl_next->__field.cl_prev =	\
+		    (__elm)->__field.cl_prev;			\
+		CLIST_INIT((__elm), __field);			\
+	} while (/*CONSTCOND*/0)
+
+#define	CLIST_INSERT_AFTER(__listelm, __elm, __field)			\
+	do {								\
+		assert(__listelm != __elm);				\
+		(__elm)->__field.cl_prev = (__listelm);			\
+		(__elm)->__field.cl_next = (__listelm)->__field.cl_next;\
+		(__listelm)->__field.cl_next = (__elm);			\
+		(__elm)->__field.cl_next->__field.cl_prev = (__elm);	\
+	} while (/*CONSTCOND*/0)
+
+#define	CLIST_NEXT(__elm, __field)	((__elm)->__field.cl_next)
+#define	CLIST_PREV(__elm, __field)	((__elm)->__field.cl_prev)
+
 #endif	/* !_SYS_QUEUE_H_ */
Index: usr.bin/netstat/route.c
===================================================================
RCS file: /cvsroot/src/usr.bin/netstat/route.c,v
retrieving revision 1.69
diff -u -p -r1.69 route.c
--- usr.bin/netstat/route.c	19 Jul 2007 20:51:04 -0000	1.69
+++ usr.bin/netstat/route.c	12 Nov 2007 17:14:39 -0000
@@ -171,6 +171,11 @@ again:
 		} else if (do_rtent) {
 			kget(rn, rtentry);
 			p_krtentry(&rtentry);
+			while ( CLIST_NEXT(&rtentry, rt_list) !=
+			    (struct rtentry*)rn ) {
+				kget(CLIST_NEXT(&rtentry, rt_list), rtentry);
+				p_krtentry(&rtentry);
+			}
 			if (Aflag)
 				p_rtnode();
 		} else {