2005-01-07 01:45:51 +00:00
|
|
|
/*-
|
1994-05-24 10:09:53 +00:00
|
|
|
* Copyright (c) 1980, 1986, 1991, 1993
|
|
|
|
* The Regents of the University of California. All rights reserved.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
* 4. Neither the name of the University nor the names of its contributors
|
|
|
|
* may be used to endorse or promote products derived from this software
|
|
|
|
* without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
|
|
* SUCH DAMAGE.
|
|
|
|
*
|
2002-12-25 10:50:08 +00:00
|
|
|
* @(#)route.c 8.3.1.1 (Berkeley) 2/23/95
|
1999-08-28 01:08:13 +00:00
|
|
|
* $FreeBSD$
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
|
1998-01-08 23:42:31 +00:00
|
|
|
#include "opt_inet.h"
|
1996-03-02 18:24:13 +00:00
|
|
|
#include "opt_mrouting.h"
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/systm.h>
|
1997-09-02 01:19:47 +00:00
|
|
|
#include <sys/malloc.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/mbuf.h>
|
|
|
|
#include <sys/socket.h>
|
|
|
|
#include <sys/domain.h>
|
1999-04-29 03:22:19 +00:00
|
|
|
#include <sys/kernel.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
#include <net/if.h>
|
|
|
|
#include <net/route.h>
|
|
|
|
|
|
|
|
#include <netinet/in.h>
|
1995-03-16 18:17:34 +00:00
|
|
|
#include <netinet/ip_mroute.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2004-08-11 17:26:56 +00:00
|
|
|
#include <vm/uma.h>
|
|
|
|
|
1995-12-14 09:55:16 +00:00
|
|
|
static struct rtstat rtstat;
|
1995-07-29 11:44:31 +00:00
|
|
|
struct radix_node_head *rt_tables[AF_MAX+1];
|
|
|
|
|
1995-12-14 09:55:16 +00:00
|
|
|
static int rttrash; /* routes not in table but not freed */
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2002-03-19 21:54:18 +00:00
|
|
|
static void rt_maskedcopy(struct sockaddr *,
|
|
|
|
struct sockaddr *, struct sockaddr *);
|
|
|
|
static void rtable_init(void **);
|
1995-12-14 09:55:16 +00:00
|
|
|
|
2004-04-21 15:16:08 +00:00
|
|
|
/* compare two sockaddr structures */
|
|
|
|
#define sa_equal(a1, a2) (bcmp((a1), (a2), (a1)->sa_len) == 0)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Convert a 'struct radix_node *' to a 'struct rtentry *'.
|
|
|
|
* The operation can be done safely (in this code) because a
|
|
|
|
* 'struct rtentry' starts with two 'struct radix_node''s, the first
|
|
|
|
* one representing leaf nodes in the routing tree, which is
|
|
|
|
* what the code in radix.c passes us as a 'struct radix_node'.
|
|
|
|
*
|
|
|
|
* But because there are a lot of assumptions in this conversion,
|
|
|
|
* do not cast explicitly, but always use the macro below.
|
|
|
|
*/
|
|
|
|
#define RNTORT(p) ((struct rtentry *)(p))
|
|
|
|
|
1995-12-14 09:55:16 +00:00
|
|
|
static void
|
2003-10-04 03:44:50 +00:00
|
|
|
rtable_init(void **table)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
struct domain *dom;
|
|
|
|
for (dom = domains; dom; dom = dom->dom_next)
|
|
|
|
if (dom->dom_rtattach)
|
|
|
|
dom->dom_rtattach(&table[dom->dom_family],
|
|
|
|
dom->dom_rtoffset);
|
|
|
|
}
|
|
|
|
|
2004-08-11 17:26:56 +00:00
|
|
|
static uma_zone_t rtzone; /* Routing table UMA zone. */
|
|
|
|
|
2004-04-17 15:10:20 +00:00
|
|
|
static void
|
|
|
|
route_init(void)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2004-08-11 17:26:56 +00:00
|
|
|
rtzone = uma_zcreate("rtentry", sizeof(struct rtentry), NULL, NULL,
|
|
|
|
NULL, NULL, UMA_ALIGN_PTR, 0);
|
1994-05-24 10:09:53 +00:00
|
|
|
rn_init(); /* initialize all zeroes, all ones, mask table */
|
|
|
|
rtable_init((void **)rt_tables);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Packet routing routines.
|
|
|
|
*/
|
|
|
|
void
|
2003-10-04 03:44:50 +00:00
|
|
|
rtalloc(struct route *ro)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
1999-12-09 17:09:37 +00:00
|
|
|
rtalloc_ign(ro, 0UL);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
1994-12-13 23:07:03 +00:00
|
|
|
void
|
2003-10-04 03:44:50 +00:00
|
|
|
rtalloc_ign(struct route *ro, u_long ignore)
|
1994-12-13 23:07:03 +00:00
|
|
|
{
|
1999-12-09 17:09:37 +00:00
|
|
|
struct rtentry *rt;
|
|
|
|
|
|
|
|
if ((rt = ro->ro_rt) != NULL) {
|
|
|
|
if (rt->rt_ifp != NULL && rt->rt_flags & RTF_UP)
|
|
|
|
return;
|
|
|
|
RTFREE(rt);
|
2000-01-15 07:27:12 +00:00
|
|
|
ro->ro_rt = NULL;
|
1999-12-09 17:09:37 +00:00
|
|
|
}
|
1994-12-13 23:07:03 +00:00
|
|
|
ro->ro_rt = rtalloc1(&ro->ro_dst, 1, ignore);
|
2003-10-04 03:44:50 +00:00
|
|
|
if (ro->ro_rt)
|
|
|
|
RT_UNLOCK(ro->ro_rt);
|
1994-12-13 23:07:03 +00:00
|
|
|
}
|
|
|
|
|
1996-09-10 07:10:05 +00:00
|
|
|
/*
|
|
|
|
* Look up the route that matches the address given
|
|
|
|
* Or, at least try.. Create a cloned route if needed.
|
2003-10-04 03:44:50 +00:00
|
|
|
*
|
|
|
|
* The returned route, if any, is locked.
|
1996-09-10 07:10:05 +00:00
|
|
|
*/
|
1994-05-24 10:09:53 +00:00
|
|
|
struct rtentry *
|
2003-10-04 03:44:50 +00:00
|
|
|
rtalloc1(struct sockaddr *dst, int report, u_long ignflags)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2003-10-04 03:44:50 +00:00
|
|
|
struct radix_node_head *rnh = rt_tables[dst->sa_family];
|
|
|
|
struct rtentry *rt;
|
|
|
|
struct radix_node *rn;
|
|
|
|
struct rtentry *newrt;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct rt_addrinfo info;
|
1994-12-13 22:31:49 +00:00
|
|
|
u_long nflags;
|
2003-10-04 03:44:50 +00:00
|
|
|
int err = 0, msgtype = RTM_MISS;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2004-04-20 07:04:47 +00:00
|
|
|
newrt = NULL;
|
1999-11-22 02:45:11 +00:00
|
|
|
/*
|
1996-09-10 07:10:05 +00:00
|
|
|
* Look up the address in the table for that Address Family
|
|
|
|
*/
|
2002-12-24 03:03:39 +00:00
|
|
|
if (rnh == NULL) {
|
|
|
|
rtstat.rts_unreach++;
|
|
|
|
goto miss2;
|
|
|
|
}
|
|
|
|
RADIX_NODE_HEAD_LOCK(rnh);
|
2003-10-04 03:44:50 +00:00
|
|
|
if ((rn = rnh->rnh_matchaddr(dst, rnh)) &&
|
|
|
|
(rn->rn_flags & RNF_ROOT) == 0) {
|
1996-09-10 07:10:05 +00:00
|
|
|
/*
|
|
|
|
* If we find it and it's not the root node, then
|
2007-05-22 16:17:31 +00:00
|
|
|
* get a reference on the rtentry associated.
|
1996-09-10 07:10:05 +00:00
|
|
|
*/
|
2004-04-21 15:16:08 +00:00
|
|
|
newrt = rt = RNTORT(rn);
|
1994-12-13 22:31:49 +00:00
|
|
|
nflags = rt->rt_flags & ~ignflags;
|
2003-11-20 19:47:31 +00:00
|
|
|
if (report && (nflags & RTF_CLONING)) {
|
1996-09-10 07:10:05 +00:00
|
|
|
/*
|
|
|
|
* We are apparently adding (report = 0 in delete).
|
|
|
|
* If it requires that it be cloned, do so.
|
|
|
|
* (This implies it wasn't a HOST route.)
|
|
|
|
*/
|
2004-04-20 07:04:47 +00:00
|
|
|
err = rtrequest(RTM_RESOLVE, dst, NULL,
|
|
|
|
NULL, 0, &newrt);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (err) {
|
1996-09-10 07:10:05 +00:00
|
|
|
/*
|
|
|
|
* If the cloning didn't succeed, maybe
|
|
|
|
* what we have will do. Return that.
|
|
|
|
*/
|
2003-10-04 03:44:50 +00:00
|
|
|
newrt = rt; /* existing route */
|
|
|
|
RT_LOCK(newrt);
|
2003-11-08 23:36:32 +00:00
|
|
|
RT_ADDREF(newrt);
|
1994-05-24 10:09:53 +00:00
|
|
|
goto miss;
|
|
|
|
}
|
2003-10-04 03:44:50 +00:00
|
|
|
KASSERT(newrt, ("no route and no error"));
|
|
|
|
RT_LOCK(newrt);
|
|
|
|
if (newrt->rt_flags & RTF_XRESOLVE) {
|
1996-09-10 07:10:05 +00:00
|
|
|
/*
|
1999-11-22 02:45:11 +00:00
|
|
|
* If the new route specifies it be
|
1996-09-10 07:10:05 +00:00
|
|
|
* externally resolved, then go do that.
|
|
|
|
*/
|
1994-05-24 10:09:53 +00:00
|
|
|
msgtype = RTM_RESOLVE;
|
|
|
|
goto miss;
|
|
|
|
}
|
2001-10-17 18:07:05 +00:00
|
|
|
/* Inform listeners of the new route. */
|
2006-11-23 05:57:15 +00:00
|
|
|
bzero(&info, sizeof(info));
|
2003-10-04 03:44:50 +00:00
|
|
|
info.rti_info[RTAX_DST] = rt_key(newrt);
|
|
|
|
info.rti_info[RTAX_NETMASK] = rt_mask(newrt);
|
|
|
|
info.rti_info[RTAX_GATEWAY] = newrt->rt_gateway;
|
|
|
|
if (newrt->rt_ifp != NULL) {
|
2001-10-17 18:07:05 +00:00
|
|
|
info.rti_info[RTAX_IFP] =
|
2005-11-11 16:04:59 +00:00
|
|
|
newrt->rt_ifp->if_addr->ifa_addr;
|
2003-10-04 03:44:50 +00:00
|
|
|
info.rti_info[RTAX_IFA] = newrt->rt_ifa->ifa_addr;
|
2001-10-17 18:07:05 +00:00
|
|
|
}
|
2003-10-04 03:44:50 +00:00
|
|
|
rt_missmsg(RTM_ADD, &info, newrt->rt_flags, 0);
|
|
|
|
} else {
|
|
|
|
RT_LOCK(newrt);
|
2003-11-08 23:36:32 +00:00
|
|
|
RT_ADDREF(newrt);
|
2003-10-04 03:44:50 +00:00
|
|
|
}
|
2002-12-24 03:03:39 +00:00
|
|
|
RADIX_NODE_HEAD_UNLOCK(rnh);
|
1994-05-24 10:09:53 +00:00
|
|
|
} else {
|
1996-09-10 07:10:05 +00:00
|
|
|
/*
|
|
|
|
* Either we hit the root or couldn't find any match,
|
|
|
|
* Which basically means
|
|
|
|
* "caint get there frm here"
|
|
|
|
*/
|
1994-05-24 10:09:53 +00:00
|
|
|
rtstat.rts_unreach++;
|
2002-12-24 03:03:39 +00:00
|
|
|
miss:
|
|
|
|
RADIX_NODE_HEAD_UNLOCK(rnh);
|
|
|
|
miss2: if (report) {
|
1996-09-10 07:10:05 +00:00
|
|
|
/*
|
|
|
|
* If required, report the failure to the supervising
|
|
|
|
* Authorities.
|
|
|
|
* For a delete, this is not an error. (report == 0)
|
|
|
|
*/
|
2006-11-23 05:57:15 +00:00
|
|
|
bzero(&info, sizeof(info));
|
1994-05-24 10:09:53 +00:00
|
|
|
info.rti_info[RTAX_DST] = dst;
|
|
|
|
rt_missmsg(msgtype, &info, 0, err);
|
|
|
|
}
|
|
|
|
}
|
2003-10-04 03:44:50 +00:00
|
|
|
if (newrt)
|
|
|
|
RT_LOCK_ASSERT(newrt);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (newrt);
|
|
|
|
}
|
|
|
|
|
1997-03-05 08:01:28 +00:00
|
|
|
/*
|
|
|
|
* Remove a reference count from an rtentry.
|
|
|
|
* If the count gets low enough, take it out of the routing table
|
|
|
|
*/
|
1994-05-24 10:09:53 +00:00
|
|
|
void
|
2003-10-04 03:44:50 +00:00
|
|
|
rtfree(struct rtentry *rt)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2004-04-20 07:04:47 +00:00
|
|
|
struct radix_node_head *rnh;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2007-05-22 16:17:31 +00:00
|
|
|
KASSERT(rt != NULL,("%s: NULL rt", __func__));
|
2004-04-20 07:04:47 +00:00
|
|
|
rnh = rt_tables[rt_key(rt)->sa_family];
|
2007-05-22 16:17:31 +00:00
|
|
|
KASSERT(rnh != NULL,("%s: NULL rnh", __func__));
|
1997-03-05 08:01:28 +00:00
|
|
|
|
2003-10-04 03:44:50 +00:00
|
|
|
RT_LOCK_ASSERT(rt);
|
|
|
|
|
1997-03-05 08:01:28 +00:00
|
|
|
/*
|
2007-05-22 16:17:31 +00:00
|
|
|
* The callers should use RTFREE_LOCKED() or RTFREE(), so
|
|
|
|
* we should come here exactly with the last reference.
|
1997-03-05 08:01:28 +00:00
|
|
|
*/
|
2003-11-08 23:36:32 +00:00
|
|
|
RT_REMREF(rt);
|
2007-05-22 16:17:31 +00:00
|
|
|
if (rt->rt_refcnt > 0) {
|
2007-06-11 12:19:34 +00:00
|
|
|
printf("%s: %p has %lu refs\n", __func__, rt, rt->rt_refcnt);
|
2003-10-04 03:44:50 +00:00
|
|
|
goto done;
|
2007-05-22 16:17:31 +00:00
|
|
|
}
|
2003-10-30 23:02:51 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* On last reference give the "close method" a chance
|
|
|
|
* to cleanup private state. This also permits (for
|
|
|
|
* IPv4 and IPv6) a chance to decide if the routing table
|
|
|
|
* entry should be purged immediately or at a later time.
|
|
|
|
* When an immediate purge is to happen the close routine
|
|
|
|
* typically calls rtexpunge which clears the RTF_UP flag
|
|
|
|
* on the entry so that the code below reclaims the storage.
|
|
|
|
*/
|
2003-10-04 03:44:50 +00:00
|
|
|
if (rt->rt_refcnt == 0 && rnh->rnh_close)
|
1994-11-02 04:41:39 +00:00
|
|
|
rnh->rnh_close((struct radix_node *)rt, rnh);
|
1997-03-05 08:01:28 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If we are no longer "up" (and ref == 0)
|
|
|
|
* then we can free the resources associated
|
|
|
|
* with the route.
|
|
|
|
*/
|
2003-10-04 03:44:50 +00:00
|
|
|
if ((rt->rt_flags & RTF_UP) == 0) {
|
1994-05-24 10:09:53 +00:00
|
|
|
if (rt->rt_nodes->rn_flags & (RNF_ACTIVE | RNF_ROOT))
|
2007-05-22 16:17:31 +00:00
|
|
|
panic("rtfree 2");
|
1999-11-22 02:45:11 +00:00
|
|
|
/*
|
1997-03-05 08:01:28 +00:00
|
|
|
* the rtentry must have been removed from the routing table
|
|
|
|
* so it is represented in rttrash.. remove that now.
|
|
|
|
*/
|
1994-05-24 10:09:53 +00:00
|
|
|
rttrash--;
|
1997-03-05 08:01:28 +00:00
|
|
|
#ifdef DIAGNOSTIC
|
1994-05-24 10:09:53 +00:00
|
|
|
if (rt->rt_refcnt < 0) {
|
1994-10-02 17:48:58 +00:00
|
|
|
printf("rtfree: %p not freed (neg refs)\n", rt);
|
2003-10-04 03:44:50 +00:00
|
|
|
goto done;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
1997-03-05 08:01:28 +00:00
|
|
|
#endif
|
1999-11-22 02:45:11 +00:00
|
|
|
/*
|
1997-03-05 08:01:28 +00:00
|
|
|
* release references on items we hold them on..
|
|
|
|
* e.g other routes and ifaddrs.
|
|
|
|
*/
|
2002-12-18 11:46:59 +00:00
|
|
|
if (rt->rt_ifa)
|
|
|
|
IFAFREE(rt->rt_ifa);
|
2003-10-04 03:44:50 +00:00
|
|
|
rt->rt_parent = NULL; /* NB: no refcnt on parent */
|
1997-03-05 08:01:28 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The key is separatly alloc'd so free it (see rt_setgate()).
|
|
|
|
* This also frees the gateway, as they are always malloc'd
|
|
|
|
* together.
|
|
|
|
*/
|
1994-05-24 10:09:53 +00:00
|
|
|
Free(rt_key(rt));
|
1997-03-05 08:01:28 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* and the rtentry itself of course
|
|
|
|
*/
|
2003-10-04 03:44:50 +00:00
|
|
|
RT_LOCK_DESTROY(rt);
|
2004-08-11 17:26:56 +00:00
|
|
|
uma_zfree(rtzone, rt);
|
2003-10-04 03:44:50 +00:00
|
|
|
return;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2003-10-04 03:44:50 +00:00
|
|
|
done:
|
|
|
|
RT_UNLOCK(rt);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Force a routing table entry to the specified
|
|
|
|
* destination to go through the given gateway.
|
|
|
|
* Normally called as a result of a routing redirect
|
|
|
|
* message from the network layer.
|
|
|
|
*/
|
1994-05-25 09:21:21 +00:00
|
|
|
void
|
2003-10-04 03:44:50 +00:00
|
|
|
rtredirect(struct sockaddr *dst,
|
|
|
|
struct sockaddr *gateway,
|
|
|
|
struct sockaddr *netmask,
|
|
|
|
int flags,
|
|
|
|
struct sockaddr *src)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2001-10-17 18:07:05 +00:00
|
|
|
struct rtentry *rt;
|
1994-05-24 10:09:53 +00:00
|
|
|
int error = 0;
|
2004-04-20 07:04:47 +00:00
|
|
|
short *stat = NULL;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct rt_addrinfo info;
|
|
|
|
struct ifaddr *ifa;
|
|
|
|
|
|
|
|
/* verify the gateway is directly reachable */
|
2004-04-20 07:04:47 +00:00
|
|
|
if ((ifa = ifa_ifwithnet(gateway)) == NULL) {
|
1994-05-24 10:09:53 +00:00
|
|
|
error = ENETUNREACH;
|
|
|
|
goto out;
|
|
|
|
}
|
2003-10-04 03:44:50 +00:00
|
|
|
rt = rtalloc1(dst, 0, 0UL); /* NB: rt is locked */
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* 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 (!(flags & RTF_DONE) && rt &&
|
2002-12-24 03:03:39 +00:00
|
|
|
(!sa_equal(src, rt->rt_gateway) || rt->rt_ifa != ifa))
|
1994-05-24 10:09:53 +00:00
|
|
|
error = EINVAL;
|
|
|
|
else if (ifa_ifwithaddr(gateway))
|
|
|
|
error = EHOSTUNREACH;
|
|
|
|
if (error)
|
|
|
|
goto done;
|
|
|
|
/*
|
|
|
|
* Create a new entry if we just got back a wildcard entry
|
|
|
|
* or the the lookup failed. This is necessary for hosts
|
|
|
|
* which use routing redirects generated by smart gateways
|
|
|
|
* to dynamically build the routing tables.
|
|
|
|
*/
|
2004-04-20 07:04:47 +00:00
|
|
|
if (rt == NULL || (rt_mask(rt) && rt_mask(rt)->sa_len < 2))
|
1994-05-24 10:09:53 +00:00
|
|
|
goto create;
|
|
|
|
/*
|
|
|
|
* Don't listen to the redirect if it's
|
1995-05-30 08:16:23 +00:00
|
|
|
* for a route to an interface.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
if (rt->rt_flags & RTF_GATEWAY) {
|
|
|
|
if (((rt->rt_flags & RTF_HOST) == 0) && (flags & RTF_HOST)) {
|
|
|
|
/*
|
|
|
|
* Changing from route to net => route to host.
|
|
|
|
* Create new route, rather than smashing route to net.
|
|
|
|
*/
|
|
|
|
create:
|
2001-10-17 18:07:05 +00:00
|
|
|
if (rt)
|
|
|
|
rtfree(rt);
|
1994-05-24 10:09:53 +00:00
|
|
|
flags |= RTF_GATEWAY | RTF_DYNAMIC;
|
2001-10-17 18:07:05 +00:00
|
|
|
bzero((caddr_t)&info, sizeof(info));
|
|
|
|
info.rti_info[RTAX_DST] = dst;
|
|
|
|
info.rti_info[RTAX_GATEWAY] = gateway;
|
|
|
|
info.rti_info[RTAX_NETMASK] = netmask;
|
|
|
|
info.rti_ifa = ifa;
|
|
|
|
info.rti_flags = flags;
|
|
|
|
rt = NULL;
|
|
|
|
error = rtrequest1(RTM_ADD, &info, &rt);
|
2003-10-04 03:44:50 +00:00
|
|
|
if (rt != NULL) {
|
2003-10-05 19:05:53 +00:00
|
|
|
RT_LOCK(rt);
|
2001-10-17 18:07:05 +00:00
|
|
|
flags = rt->rt_flags;
|
2003-10-04 03:44:50 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
stat = &rtstat.rts_dynamic;
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* Smash the current notion of the gateway to
|
|
|
|
* this destination. Should check about netmask!!!
|
|
|
|
*/
|
|
|
|
rt->rt_flags |= RTF_MODIFIED;
|
|
|
|
flags |= RTF_MODIFIED;
|
|
|
|
stat = &rtstat.rts_newgateway;
|
1997-03-05 08:01:28 +00:00
|
|
|
/*
|
|
|
|
* add the key and gateway (in one malloc'd chunk).
|
|
|
|
*/
|
1994-05-24 10:09:53 +00:00
|
|
|
rt_setgate(rt, rt_key(rt), gateway);
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
error = EHOSTUNREACH;
|
|
|
|
done:
|
2003-10-04 03:44:50 +00:00
|
|
|
if (rt)
|
|
|
|
rtfree(rt);
|
1994-05-24 10:09:53 +00:00
|
|
|
out:
|
|
|
|
if (error)
|
|
|
|
rtstat.rts_badredirect++;
|
|
|
|
else if (stat != NULL)
|
|
|
|
(*stat)++;
|
|
|
|
bzero((caddr_t)&info, sizeof(info));
|
|
|
|
info.rti_info[RTAX_DST] = dst;
|
|
|
|
info.rti_info[RTAX_GATEWAY] = gateway;
|
|
|
|
info.rti_info[RTAX_NETMASK] = netmask;
|
|
|
|
info.rti_info[RTAX_AUTHOR] = src;
|
|
|
|
rt_missmsg(RTM_REDIRECT, &info, flags, error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2002-12-18 11:46:59 +00:00
|
|
|
* Routing table ioctl interface.
|
|
|
|
*/
|
1994-05-24 10:09:53 +00:00
|
|
|
int
|
2003-10-04 03:44:50 +00:00
|
|
|
rtioctl(u_long req, caddr_t data)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2004-08-21 17:38:57 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If more ioctl commands are added here, make sure the proper
|
|
|
|
* super-user checks are being performed because it is possible for
|
|
|
|
* prison-root to make it this far if raw sockets have been enabled
|
|
|
|
* in jails.
|
|
|
|
*/
|
1994-10-02 17:48:58 +00:00
|
|
|
#ifdef INET
|
1994-09-06 22:42:31 +00:00
|
|
|
/* Multicast goop, grrr... */
|
Massive cleanup of the ip_mroute code.
No functional changes, but:
+ the mrouting module now should behave the same as the compiled-in
version (it did not before, some of the rsvp code was not loaded
properly);
+ netinet/ip_mroute.c is now truly optional;
+ removed some redundant/unused code;
+ changed many instances of '0' to NULL and INADDR_ANY as appropriate;
+ removed several static variables to make the code more SMP-friendly;
+ fixed some minor bugs in the mrouting code (mostly, incorrect return
values from functions).
This commit is also a prerequisite to the addition of support for PIM,
which i would like to put in before DP2 (it does not change any of
the existing APIs, anyways).
Note, in the process we found out that some device drivers fail to
properly handle changes in IFF_ALLMULTI, leading to interesting
behaviour when a multicast router is started. This bug is not
corrected by this commit, and will be fixed with a separate commit.
Detailed changes:
--------------------
netinet/ip_mroute.c all the above.
conf/files make ip_mroute.c optional
net/route.c fix mrt_ioctl hook
netinet/ip_input.c fix ip_mforward hook, move rsvp_input() here
together with other rsvp code, and a couple
of indentation fixes.
netinet/ip_output.c fix ip_mforward and ip_mcast_src hooks
netinet/ip_var.h rsvp function hooks
netinet/raw_ip.c hooks for mrouting and rsvp functions, plus
interface cleanup.
netinet/ip_mroute.h remove an unused and optional field from a struct
Most of the code is from Pavlin Radoslavov and the XORP project
Reviewed by: sam
MFC after: 1 week
2002-11-15 22:53:53 +00:00
|
|
|
return mrt_ioctl ? mrt_ioctl(req, data) : EOPNOTSUPP;
|
1994-10-02 17:48:58 +00:00
|
|
|
#else /* INET */
|
|
|
|
return ENXIO;
|
|
|
|
#endif /* INET */
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
struct ifaddr *
|
2003-10-04 03:44:50 +00:00
|
|
|
ifa_ifwithroute(int flags, struct sockaddr *dst, struct sockaddr *gateway)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
register struct ifaddr *ifa;
|
The current routing code allows insertion of indirect routes that have
gateways which are unreachable except through the default router. For
example, assuming there is a default route configured, and inserting
a route
"route add 64.102.54.0/24 60.80.1.1"
is currently allowed even when 60.80.1.1 is only reachable through
the default route. However, an error is thrown when this route is
utilized, say,
"ping 64.102.54.1" will return an error
This type of route insertion should be disallowed becasue:
1) Let's say that somehow our code allowed this packet to flow to
the default router, and the default router knows the next hop is
60.80.1.1, then the question is why bother inserting this route in
the 1st place, just simply use the default route.
2) Since we're not talking about source routing here, the default
router could very well choose a different path than using 60.80.1.1
for the next hop, again it defeats the purpose of adding this route.
Reviewed by: ru, gnn, bz
Approved by: andre
2006-05-16 19:11:11 +00:00
|
|
|
int not_found = 0;
|
2003-10-04 03:44:50 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
if ((flags & RTF_GATEWAY) == 0) {
|
|
|
|
/*
|
|
|
|
* If we are adding a route to an interface,
|
|
|
|
* and the interface is a pt to pt link
|
|
|
|
* we should search for the destination
|
|
|
|
* as our clue to the interface. Otherwise
|
|
|
|
* we can use the local address.
|
|
|
|
*/
|
2004-04-20 07:04:47 +00:00
|
|
|
ifa = NULL;
|
|
|
|
if (flags & RTF_HOST)
|
1994-05-24 10:09:53 +00:00
|
|
|
ifa = ifa_ifwithdstaddr(dst);
|
2004-04-20 07:04:47 +00:00
|
|
|
if (ifa == NULL)
|
1994-05-24 10:09:53 +00:00
|
|
|
ifa = ifa_ifwithaddr(gateway);
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* If we are adding a route to a remote net
|
|
|
|
* or host, the gateway may still be on the
|
|
|
|
* other end of a pt to pt link.
|
|
|
|
*/
|
|
|
|
ifa = ifa_ifwithdstaddr(gateway);
|
|
|
|
}
|
2004-04-20 07:04:47 +00:00
|
|
|
if (ifa == NULL)
|
1994-05-24 10:09:53 +00:00
|
|
|
ifa = ifa_ifwithnet(gateway);
|
2004-04-20 07:04:47 +00:00
|
|
|
if (ifa == NULL) {
|
2001-06-04 14:13:15 +00:00
|
|
|
struct rtentry *rt = rtalloc1(gateway, 0, 0UL);
|
2004-04-20 07:04:47 +00:00
|
|
|
if (rt == NULL)
|
|
|
|
return (NULL);
|
The current routing code allows insertion of indirect routes that have
gateways which are unreachable except through the default router. For
example, assuming there is a default route configured, and inserting
a route
"route add 64.102.54.0/24 60.80.1.1"
is currently allowed even when 60.80.1.1 is only reachable through
the default route. However, an error is thrown when this route is
utilized, say,
"ping 64.102.54.1" will return an error
This type of route insertion should be disallowed becasue:
1) Let's say that somehow our code allowed this packet to flow to
the default router, and the default router knows the next hop is
60.80.1.1, then the question is why bother inserting this route in
the 1st place, just simply use the default route.
2) Since we're not talking about source routing here, the default
router could very well choose a different path than using 60.80.1.1
for the next hop, again it defeats the purpose of adding this route.
Reviewed by: ru, gnn, bz
Approved by: andre
2006-05-16 19:11:11 +00:00
|
|
|
/*
|
|
|
|
* dismiss a gateway that is reachable only
|
|
|
|
* through the default router
|
|
|
|
*/
|
|
|
|
switch (gateway->sa_family) {
|
|
|
|
case AF_INET:
|
|
|
|
if (satosin(rt_key(rt))->sin_addr.s_addr == INADDR_ANY)
|
|
|
|
not_found = 1;
|
|
|
|
break;
|
|
|
|
case AF_INET6:
|
|
|
|
if (IN6_IS_ADDR_UNSPECIFIED(&satosin6(rt_key(rt))->sin6_addr))
|
|
|
|
not_found = 1;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2003-11-08 23:36:32 +00:00
|
|
|
RT_REMREF(rt);
|
2003-10-04 03:44:50 +00:00
|
|
|
RT_UNLOCK(rt);
|
The current routing code allows insertion of indirect routes that have
gateways which are unreachable except through the default router. For
example, assuming there is a default route configured, and inserting
a route
"route add 64.102.54.0/24 60.80.1.1"
is currently allowed even when 60.80.1.1 is only reachable through
the default route. However, an error is thrown when this route is
utilized, say,
"ping 64.102.54.1" will return an error
This type of route insertion should be disallowed becasue:
1) Let's say that somehow our code allowed this packet to flow to
the default router, and the default router knows the next hop is
60.80.1.1, then the question is why bother inserting this route in
the 1st place, just simply use the default route.
2) Since we're not talking about source routing here, the default
router could very well choose a different path than using 60.80.1.1
for the next hop, again it defeats the purpose of adding this route.
Reviewed by: ru, gnn, bz
Approved by: andre
2006-05-16 19:11:11 +00:00
|
|
|
if (not_found)
|
|
|
|
return (NULL);
|
2004-04-20 07:04:47 +00:00
|
|
|
if ((ifa = rt->rt_ifa) == NULL)
|
|
|
|
return (NULL);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
if (ifa->ifa_addr->sa_family != dst->sa_family) {
|
|
|
|
struct ifaddr *oifa = ifa;
|
|
|
|
ifa = ifaof_ifpforaddr(dst, ifa->ifa_ifp);
|
2004-04-20 07:04:47 +00:00
|
|
|
if (ifa == NULL)
|
1994-05-24 10:09:53 +00:00
|
|
|
ifa = oifa;
|
|
|
|
}
|
|
|
|
return (ifa);
|
|
|
|
}
|
|
|
|
|
2004-04-20 07:04:47 +00:00
|
|
|
static walktree_f_t rt_fixdelete;
|
|
|
|
static walktree_f_t rt_fixchange;
|
1995-04-25 19:12:07 +00:00
|
|
|
|
|
|
|
struct rtfc_arg {
|
|
|
|
struct rtentry *rt0;
|
|
|
|
struct radix_node_head *rnh;
|
|
|
|
};
|
1995-01-23 02:00:35 +00:00
|
|
|
|
1996-09-10 07:10:05 +00:00
|
|
|
/*
|
|
|
|
* Do appropriate manipulations of a routing tree given
|
|
|
|
* all the bits of info needed
|
|
|
|
*/
|
1994-05-24 10:09:53 +00:00
|
|
|
int
|
2003-10-04 03:44:50 +00:00
|
|
|
rtrequest(int req,
|
|
|
|
struct sockaddr *dst,
|
|
|
|
struct sockaddr *gateway,
|
|
|
|
struct sockaddr *netmask,
|
|
|
|
int flags,
|
|
|
|
struct rtentry **ret_nrt)
|
2001-10-17 18:07:05 +00:00
|
|
|
{
|
|
|
|
struct rt_addrinfo info;
|
|
|
|
|
2006-05-04 18:33:37 +00:00
|
|
|
if (dst->sa_len == 0)
|
|
|
|
return(EINVAL);
|
|
|
|
|
2001-10-17 18:07:05 +00:00
|
|
|
bzero((caddr_t)&info, sizeof(info));
|
|
|
|
info.rti_flags = flags;
|
|
|
|
info.rti_info[RTAX_DST] = dst;
|
|
|
|
info.rti_info[RTAX_GATEWAY] = gateway;
|
|
|
|
info.rti_info[RTAX_NETMASK] = netmask;
|
|
|
|
return rtrequest1(req, &info, ret_nrt);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* These (questionable) definitions of apparent local variables apply
|
|
|
|
* to the next two functions. XXXXXX!!!
|
|
|
|
*/
|
|
|
|
#define dst info->rti_info[RTAX_DST]
|
|
|
|
#define gateway info->rti_info[RTAX_GATEWAY]
|
|
|
|
#define netmask info->rti_info[RTAX_NETMASK]
|
|
|
|
#define ifaaddr info->rti_info[RTAX_IFA]
|
|
|
|
#define ifpaddr info->rti_info[RTAX_IFP]
|
|
|
|
#define flags info->rti_flags
|
|
|
|
|
|
|
|
int
|
2003-10-04 03:44:50 +00:00
|
|
|
rt_getifa(struct rt_addrinfo *info)
|
2001-10-17 18:07:05 +00:00
|
|
|
{
|
|
|
|
struct ifaddr *ifa;
|
|
|
|
int error = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* ifp may be specified by sockaddr_dl
|
|
|
|
* when protocol address is ambiguous.
|
|
|
|
*/
|
|
|
|
if (info->rti_ifp == NULL && ifpaddr != NULL &&
|
|
|
|
ifpaddr->sa_family == AF_LINK &&
|
|
|
|
(ifa = ifa_ifwithnet(ifpaddr)) != NULL)
|
|
|
|
info->rti_ifp = ifa->ifa_ifp;
|
|
|
|
if (info->rti_ifa == NULL && ifaaddr != NULL)
|
|
|
|
info->rti_ifa = ifa_ifwithaddr(ifaaddr);
|
|
|
|
if (info->rti_ifa == NULL) {
|
|
|
|
struct sockaddr *sa;
|
|
|
|
|
|
|
|
sa = ifaaddr != NULL ? ifaaddr :
|
|
|
|
(gateway != NULL ? gateway : dst);
|
|
|
|
if (sa != NULL && info->rti_ifp != NULL)
|
|
|
|
info->rti_ifa = ifaof_ifpforaddr(sa, info->rti_ifp);
|
|
|
|
else if (dst != NULL && gateway != NULL)
|
|
|
|
info->rti_ifa = ifa_ifwithroute(flags, dst, gateway);
|
|
|
|
else if (sa != NULL)
|
|
|
|
info->rti_ifa = ifa_ifwithroute(flags, sa, sa);
|
|
|
|
}
|
|
|
|
if ((ifa = info->rti_ifa) != NULL) {
|
|
|
|
if (info->rti_ifp == NULL)
|
|
|
|
info->rti_ifp = ifa->ifa_ifp;
|
|
|
|
} else
|
|
|
|
error = ENETUNREACH;
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
2003-10-30 23:02:51 +00:00
|
|
|
/*
|
|
|
|
* Expunges references to a route that's about to be reclaimed.
|
|
|
|
* The route must be locked.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
rtexpunge(struct rtentry *rt)
|
|
|
|
{
|
|
|
|
struct radix_node *rn;
|
|
|
|
struct radix_node_head *rnh;
|
|
|
|
struct ifaddr *ifa;
|
|
|
|
int error = 0;
|
|
|
|
|
|
|
|
RT_LOCK_ASSERT(rt);
|
|
|
|
#if 0
|
|
|
|
/*
|
|
|
|
* We cannot assume anything about the reference count
|
|
|
|
* because protocols call us in many situations; often
|
|
|
|
* before unwinding references to the table entry.
|
|
|
|
*/
|
|
|
|
KASSERT(rt->rt_refcnt <= 1, ("bogus refcnt %ld", rt->rt_refcnt));
|
|
|
|
#endif
|
|
|
|
/*
|
|
|
|
* Find the correct routing tree to use for this Address Family
|
|
|
|
*/
|
|
|
|
rnh = rt_tables[rt_key(rt)->sa_family];
|
2004-04-20 07:04:47 +00:00
|
|
|
if (rnh == NULL)
|
2003-10-30 23:02:51 +00:00
|
|
|
return (EAFNOSUPPORT);
|
|
|
|
|
|
|
|
RADIX_NODE_HEAD_LOCK(rnh);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Remove the item from the tree; it should be there,
|
|
|
|
* but when callers invoke us blindly it may not (sigh).
|
|
|
|
*/
|
|
|
|
rn = rnh->rnh_deladdr(rt_key(rt), rt_mask(rt), rnh);
|
2004-04-20 07:04:47 +00:00
|
|
|
if (rn == NULL) {
|
2003-10-30 23:02:51 +00:00
|
|
|
error = ESRCH;
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
KASSERT((rn->rn_flags & (RNF_ACTIVE | RNF_ROOT)) == 0,
|
|
|
|
("unexpected flags 0x%x", rn->rn_flags));
|
2004-04-21 15:16:08 +00:00
|
|
|
KASSERT(rt == RNTORT(rn),
|
2003-10-30 23:02:51 +00:00
|
|
|
("lookup mismatch, rt %p rn %p", rt, rn));
|
|
|
|
|
|
|
|
rt->rt_flags &= ~RTF_UP;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Now search what's left of the subtree for any cloned
|
|
|
|
* routes which might have been formed from this node.
|
|
|
|
*/
|
2003-11-20 19:47:31 +00:00
|
|
|
if ((rt->rt_flags & RTF_CLONING) && rt_mask(rt))
|
2003-10-30 23:02:51 +00:00
|
|
|
rnh->rnh_walktree_from(rnh, rt_key(rt), rt_mask(rt),
|
|
|
|
rt_fixdelete, rt);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Remove any external references we may have.
|
|
|
|
* This might result in another rtentry being freed if
|
|
|
|
* we held its last reference.
|
|
|
|
*/
|
|
|
|
if (rt->rt_gwroute) {
|
2004-04-21 15:16:08 +00:00
|
|
|
RTFREE(rt->rt_gwroute);
|
2004-04-20 07:04:47 +00:00
|
|
|
rt->rt_gwroute = NULL;
|
2003-10-30 23:02:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Give the protocol a chance to keep things in sync.
|
|
|
|
*/
|
|
|
|
if ((ifa = rt->rt_ifa) && ifa->ifa_rtrequest) {
|
|
|
|
struct rt_addrinfo info;
|
|
|
|
|
|
|
|
bzero((caddr_t)&info, sizeof(info));
|
|
|
|
info.rti_flags = rt->rt_flags;
|
|
|
|
info.rti_info[RTAX_DST] = rt_key(rt);
|
|
|
|
info.rti_info[RTAX_GATEWAY] = rt->rt_gateway;
|
|
|
|
info.rti_info[RTAX_NETMASK] = rt_mask(rt);
|
|
|
|
ifa->ifa_rtrequest(RTM_DELETE, rt, &info);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* one more rtentry floating around that is not
|
|
|
|
* linked to the routing table.
|
|
|
|
*/
|
|
|
|
rttrash++;
|
|
|
|
bad:
|
|
|
|
RADIX_NODE_HEAD_UNLOCK(rnh);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
2001-10-17 18:07:05 +00:00
|
|
|
int
|
2003-10-04 03:44:50 +00:00
|
|
|
rtrequest1(int req, struct rt_addrinfo *info, struct rtentry **ret_nrt)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2003-10-04 03:44:50 +00:00
|
|
|
int error = 0;
|
1994-05-24 10:09:53 +00:00
|
|
|
register struct rtentry *rt;
|
|
|
|
register struct radix_node *rn;
|
|
|
|
register struct radix_node_head *rnh;
|
|
|
|
struct ifaddr *ifa;
|
|
|
|
struct sockaddr *ndst;
|
|
|
|
#define senderr(x) { error = x ; goto bad; }
|
|
|
|
|
1996-09-10 07:10:05 +00:00
|
|
|
/*
|
|
|
|
* Find the correct routing tree to use for this Address Family
|
|
|
|
*/
|
2003-10-04 03:44:50 +00:00
|
|
|
rnh = rt_tables[dst->sa_family];
|
2004-04-20 07:04:47 +00:00
|
|
|
if (rnh == NULL)
|
2003-04-13 06:21:02 +00:00
|
|
|
return (EAFNOSUPPORT);
|
2002-12-24 03:03:39 +00:00
|
|
|
RADIX_NODE_HEAD_LOCK(rnh);
|
1996-09-10 07:10:05 +00:00
|
|
|
/*
|
|
|
|
* If we are adding a host route then we don't want to put
|
2001-10-15 09:46:48 +00:00
|
|
|
* a netmask in the tree, nor do we want to clone it.
|
1996-09-10 07:10:05 +00:00
|
|
|
*/
|
2001-10-15 09:46:48 +00:00
|
|
|
if (flags & RTF_HOST) {
|
2004-04-20 07:04:47 +00:00
|
|
|
netmask = NULL;
|
2003-11-20 19:47:31 +00:00
|
|
|
flags &= ~RTF_CLONING;
|
2001-10-15 09:46:48 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
switch (req) {
|
|
|
|
case RTM_DELETE:
|
1996-09-10 07:10:05 +00:00
|
|
|
/*
|
|
|
|
* Remove the item from the tree and return it.
|
|
|
|
* Complain if it is not there and do no more processing.
|
|
|
|
*/
|
2003-10-04 03:44:50 +00:00
|
|
|
rn = rnh->rnh_deladdr(dst, netmask, rnh);
|
2004-04-20 07:04:47 +00:00
|
|
|
if (rn == NULL)
|
1994-05-24 10:09:53 +00:00
|
|
|
senderr(ESRCH);
|
|
|
|
if (rn->rn_flags & (RNF_ACTIVE | RNF_ROOT))
|
|
|
|
panic ("rtrequest delete");
|
2004-04-21 15:16:08 +00:00
|
|
|
rt = RNTORT(rn);
|
2003-10-04 03:44:50 +00:00
|
|
|
RT_LOCK(rt);
|
2003-11-08 23:36:32 +00:00
|
|
|
RT_ADDREF(rt);
|
2002-12-25 10:21:02 +00:00
|
|
|
rt->rt_flags &= ~RTF_UP;
|
1995-03-20 21:30:21 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Now search what's left of the subtree for any cloned
|
|
|
|
* routes which might have been formed from this node.
|
|
|
|
*/
|
2003-11-20 19:47:31 +00:00
|
|
|
if ((rt->rt_flags & RTF_CLONING) &&
|
net/route.c:
A route generated from an RTF_CLONING route had the RTF_WASCLONED flag
set but did not have a reference to the parent route, as documented in
the rtentry(9) manpage. This prevented such routes from being deleted
when their parent route is deleted.
Now, for example, if you delete an IP address from a network interface,
all ARP entries that were cloned from this interface route are flushed.
This also has an impact on netstat(1) output. Previously, dynamically
created ARP cache entries (RTF_STATIC flag is unset) were displayed as
part of the routing table display (-r). Now, they are only printed if
the -a option is given.
netinet/in.c, netinet/in_rmx.c:
When address is removed from an interface, also delete all routes that
point to this interface and address. Previously, for example, if you
changed the address on an interface, outgoing IP datagrams might still
use the old address. The only solution was to delete and re-add some
routes. (The problem is easily observed with the route(8) command.)
Note, that if the socket was already bound to the local address before
this address is removed, new datagrams generated from this socket will
still be sent from the old address.
PR: kern/20785, kern/21914
Reviewed by: wollman (the idea)
2001-03-15 14:52:12 +00:00
|
|
|
rt_mask(rt)) {
|
|
|
|
rnh->rnh_walktree_from(rnh, dst, rt_mask(rt),
|
1995-03-20 21:30:21 +00:00
|
|
|
rt_fixdelete, rt);
|
|
|
|
}
|
1995-03-23 18:07:29 +00:00
|
|
|
|
1996-09-10 07:10:05 +00:00
|
|
|
/*
|
|
|
|
* Remove any external references we may have.
|
|
|
|
* This might result in another rtentry being freed if
|
1998-04-17 22:37:19 +00:00
|
|
|
* we held its last reference.
|
1996-09-10 07:10:05 +00:00
|
|
|
*/
|
1996-03-29 08:02:30 +00:00
|
|
|
if (rt->rt_gwroute) {
|
2004-04-21 15:16:08 +00:00
|
|
|
RTFREE(rt->rt_gwroute);
|
2004-04-20 07:04:47 +00:00
|
|
|
rt->rt_gwroute = NULL;
|
1996-03-29 08:02:30 +00:00
|
|
|
}
|
|
|
|
|
1999-11-22 02:45:11 +00:00
|
|
|
/*
|
1997-03-05 08:01:28 +00:00
|
|
|
* give the protocol a chance to keep things in sync.
|
1996-09-10 07:10:05 +00:00
|
|
|
*/
|
1994-05-24 10:09:53 +00:00
|
|
|
if ((ifa = rt->rt_ifa) && ifa->ifa_rtrequest)
|
2001-10-17 18:07:05 +00:00
|
|
|
ifa->ifa_rtrequest(RTM_DELETE, rt, info);
|
1997-03-05 08:01:28 +00:00
|
|
|
|
|
|
|
/*
|
2004-04-21 15:16:08 +00:00
|
|
|
* One more rtentry floating around that is not
|
|
|
|
* linked to the routing table. rttrash will be decremented
|
|
|
|
* when RTFREE(rt) is eventually called.
|
1997-03-05 08:01:28 +00:00
|
|
|
*/
|
1994-05-24 10:09:53 +00:00
|
|
|
rttrash++;
|
1997-03-05 08:01:28 +00:00
|
|
|
|
1996-09-10 07:10:05 +00:00
|
|
|
/*
|
1997-03-05 08:01:28 +00:00
|
|
|
* If the caller wants it, then it can have it,
|
|
|
|
* but it's up to it to free the rtentry as we won't be
|
|
|
|
* doing it.
|
1996-09-10 07:10:05 +00:00
|
|
|
*/
|
2003-10-04 03:44:50 +00:00
|
|
|
if (ret_nrt) {
|
1994-05-24 10:09:53 +00:00
|
|
|
*ret_nrt = rt;
|
2003-10-04 03:44:50 +00:00
|
|
|
RT_UNLOCK(rt);
|
|
|
|
} else
|
|
|
|
RTFREE_LOCKED(rt);
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case RTM_RESOLVE:
|
2004-04-20 07:04:47 +00:00
|
|
|
if (ret_nrt == NULL || (rt = *ret_nrt) == NULL)
|
1994-05-24 10:09:53 +00:00
|
|
|
senderr(EINVAL);
|
|
|
|
ifa = rt->rt_ifa;
|
2003-10-04 03:44:50 +00:00
|
|
|
/* XXX locking? */
|
1995-03-20 23:00:57 +00:00
|
|
|
flags = rt->rt_flags &
|
2003-11-20 19:47:31 +00:00
|
|
|
~(RTF_CLONING | RTF_STATIC);
|
1994-12-13 22:31:49 +00:00
|
|
|
flags |= RTF_WASCLONED;
|
1994-05-24 10:09:53 +00:00
|
|
|
gateway = rt->rt_gateway;
|
2004-04-20 07:04:47 +00:00
|
|
|
if ((netmask = rt->rt_genmask) == NULL)
|
1994-05-24 10:09:53 +00:00
|
|
|
flags |= RTF_HOST;
|
|
|
|
goto makeroute;
|
|
|
|
|
|
|
|
case RTM_ADD:
|
1994-10-11 23:16:38 +00:00
|
|
|
if ((flags & RTF_GATEWAY) && !gateway)
|
2005-06-28 23:32:22 +00:00
|
|
|
senderr(EINVAL);
|
|
|
|
if (dst && gateway && (dst->sa_family != gateway->sa_family) &&
|
|
|
|
(gateway->sa_family != AF_UNSPEC) && (gateway->sa_family != AF_LINK))
|
|
|
|
senderr(EINVAL);
|
1994-10-11 23:16:38 +00:00
|
|
|
|
2001-10-17 18:07:05 +00:00
|
|
|
if (info->rti_ifa == NULL && (error = rt_getifa(info)))
|
|
|
|
senderr(error);
|
|
|
|
ifa = info->rti_ifa;
|
1994-10-11 23:16:38 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
makeroute:
|
2004-08-11 17:26:56 +00:00
|
|
|
rt = uma_zalloc(rtzone, M_NOWAIT | M_ZERO);
|
2004-04-20 07:04:47 +00:00
|
|
|
if (rt == NULL)
|
1994-05-24 10:09:53 +00:00
|
|
|
senderr(ENOBUFS);
|
2003-10-04 03:44:50 +00:00
|
|
|
RT_LOCK_INIT(rt);
|
1994-05-24 10:09:53 +00:00
|
|
|
rt->rt_flags = RTF_UP | flags;
|
1997-03-05 08:01:28 +00:00
|
|
|
/*
|
|
|
|
* Add the gateway. Possibly re-malloc-ing the storage for it
|
|
|
|
* also add the rt_gwroute if possible.
|
|
|
|
*/
|
2003-10-04 03:44:50 +00:00
|
|
|
RT_LOCK(rt);
|
1999-01-27 22:42:27 +00:00
|
|
|
if ((error = rt_setgate(rt, dst, gateway)) != 0) {
|
2003-10-04 03:44:50 +00:00
|
|
|
RT_LOCK_DESTROY(rt);
|
2004-08-11 17:26:56 +00:00
|
|
|
uma_zfree(rtzone, rt);
|
1996-09-02 02:49:40 +00:00
|
|
|
senderr(error);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
1997-03-05 08:01:28 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* point to the (possibly newly malloc'd) dest address.
|
|
|
|
*/
|
2003-10-04 03:44:50 +00:00
|
|
|
ndst = (struct sockaddr *)rt_key(rt);
|
1997-03-05 08:01:28 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* make sure it contains the value we want (masked if needed).
|
|
|
|
*/
|
1994-05-24 10:09:53 +00:00
|
|
|
if (netmask) {
|
|
|
|
rt_maskedcopy(dst, ndst, netmask);
|
|
|
|
} else
|
2004-04-18 11:46:29 +00:00
|
|
|
bcopy(dst, ndst, dst->sa_len);
|
1995-07-10 15:22:37 +00:00
|
|
|
|
|
|
|
/*
|
1997-03-05 08:01:28 +00:00
|
|
|
* Note that we now have a reference to the ifa.
|
1995-07-10 15:22:37 +00:00
|
|
|
* This moved from below so that rnh->rnh_addaddr() can
|
1997-03-05 08:01:28 +00:00
|
|
|
* examine the ifa and ifa->ifa_ifp if it so desires.
|
1995-07-10 15:22:37 +00:00
|
|
|
*/
|
2002-12-18 11:46:59 +00:00
|
|
|
IFAREF(ifa);
|
1995-07-10 15:22:37 +00:00
|
|
|
rt->rt_ifa = ifa;
|
|
|
|
rt->rt_ifp = ifa->ifa_ifp;
|
|
|
|
|
2003-10-04 03:44:50 +00:00
|
|
|
/* XXX mtu manipulation will be done in rnh_addaddr -- itojun */
|
|
|
|
rn = rnh->rnh_addaddr(ndst, netmask, rnh, rt->rt_nodes);
|
2004-04-20 07:04:47 +00:00
|
|
|
if (rn == NULL) {
|
1995-10-16 19:09:40 +00:00
|
|
|
struct rtentry *rt2;
|
|
|
|
/*
|
|
|
|
* Uh-oh, we already have one of these in the tree.
|
|
|
|
* We do a special hack: if the route that's already
|
2003-11-20 19:47:31 +00:00
|
|
|
* there was generated by the cloning mechanism
|
|
|
|
* then we just blow it away and retry the insertion
|
|
|
|
* of the new one.
|
1995-10-16 19:09:40 +00:00
|
|
|
*/
|
2003-11-20 19:47:31 +00:00
|
|
|
rt2 = rtalloc1(dst, 0, 0);
|
1995-10-16 19:09:40 +00:00
|
|
|
if (rt2 && rt2->rt_parent) {
|
2003-10-30 23:02:51 +00:00
|
|
|
rtexpunge(rt2);
|
|
|
|
RT_UNLOCK(rt2);
|
2003-10-04 03:44:50 +00:00
|
|
|
rn = rnh->rnh_addaddr(ndst, netmask,
|
1995-10-16 19:09:40 +00:00
|
|
|
rnh, rt->rt_nodes);
|
1996-01-24 20:27:19 +00:00
|
|
|
} else if (rt2) {
|
1997-03-05 08:01:28 +00:00
|
|
|
/* undo the extra ref we got */
|
2003-10-04 03:44:50 +00:00
|
|
|
RTFREE_LOCKED(rt2);
|
1995-10-16 19:09:40 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1997-03-05 08:01:28 +00:00
|
|
|
/*
|
|
|
|
* If it still failed to go into the tree,
|
|
|
|
* then un-make it (this should be a function)
|
|
|
|
*/
|
2004-04-20 07:04:47 +00:00
|
|
|
if (rn == NULL) {
|
1994-05-24 10:09:53 +00:00
|
|
|
if (rt->rt_gwroute)
|
2003-10-04 03:44:50 +00:00
|
|
|
RTFREE(rt->rt_gwroute);
|
|
|
|
if (rt->rt_ifa)
|
1995-07-10 15:22:37 +00:00
|
|
|
IFAFREE(rt->rt_ifa);
|
1994-05-24 10:09:53 +00:00
|
|
|
Free(rt_key(rt));
|
2003-10-04 03:44:50 +00:00
|
|
|
RT_LOCK_DESTROY(rt);
|
2004-08-11 17:26:56 +00:00
|
|
|
uma_zfree(rtzone, rt);
|
1994-05-24 10:09:53 +00:00
|
|
|
senderr(EEXIST);
|
|
|
|
}
|
1997-03-05 08:01:28 +00:00
|
|
|
|
2004-04-20 07:04:47 +00:00
|
|
|
rt->rt_parent = NULL;
|
1995-03-21 19:50:34 +00:00
|
|
|
|
1999-11-22 02:45:11 +00:00
|
|
|
/*
|
1997-03-05 08:01:28 +00:00
|
|
|
* If we got here from RESOLVE, then we are cloning
|
1999-11-22 02:45:11 +00:00
|
|
|
* so clone the rest, and note that we
|
1997-03-05 08:01:28 +00:00
|
|
|
* are a clone (and increment the parent's references)
|
|
|
|
*/
|
1995-03-20 21:30:21 +00:00
|
|
|
if (req == RTM_RESOLVE) {
|
2003-10-04 03:44:50 +00:00
|
|
|
KASSERT(ret_nrt && *ret_nrt,
|
|
|
|
("no route to clone from"));
|
1994-05-24 10:09:53 +00:00
|
|
|
rt->rt_rmx = (*ret_nrt)->rt_rmx; /* copy metrics */
|
2002-05-31 04:27:51 +00:00
|
|
|
rt->rt_rmx.rmx_pksent = 0; /* reset packet counter */
|
2003-11-20 19:47:31 +00:00
|
|
|
if ((*ret_nrt)->rt_flags & RTF_CLONING) {
|
2003-10-04 03:44:50 +00:00
|
|
|
/*
|
|
|
|
* NB: We do not bump the refcnt on the parent
|
|
|
|
* entry under the assumption that it will
|
|
|
|
* remain so long as we do. This is
|
|
|
|
* important when deleting the parent route
|
|
|
|
* as this operation requires traversing
|
|
|
|
* the tree to delete all clones and futzing
|
|
|
|
* with refcnts requires us to double-lock
|
|
|
|
* parent through this back reference.
|
|
|
|
*/
|
|
|
|
rt->rt_parent = *ret_nrt;
|
1995-03-21 19:50:34 +00:00
|
|
|
}
|
1995-01-23 02:00:35 +00:00
|
|
|
}
|
1997-03-05 08:01:28 +00:00
|
|
|
|
|
|
|
/*
|
2007-05-22 16:17:31 +00:00
|
|
|
* If this protocol has something to add to this then
|
1997-03-05 08:01:28 +00:00
|
|
|
* allow it to do that as well.
|
|
|
|
*/
|
1994-05-24 10:09:53 +00:00
|
|
|
if (ifa->ifa_rtrequest)
|
2001-10-17 18:07:05 +00:00
|
|
|
ifa->ifa_rtrequest(req, rt, info);
|
1997-03-05 08:01:28 +00:00
|
|
|
|
1995-04-25 19:12:07 +00:00
|
|
|
/*
|
|
|
|
* We repeat the same procedure from rt_setgate() here because
|
|
|
|
* it doesn't fire when we call it there because the node
|
|
|
|
* hasn't been added to the tree yet.
|
|
|
|
*/
|
2002-12-23 13:12:41 +00:00
|
|
|
if (req == RTM_ADD &&
|
2004-04-20 07:04:47 +00:00
|
|
|
!(rt->rt_flags & RTF_HOST) && rt_mask(rt) != NULL) {
|
1995-04-25 19:12:07 +00:00
|
|
|
struct rtfc_arg arg;
|
|
|
|
arg.rnh = rnh;
|
|
|
|
arg.rt0 = rt;
|
|
|
|
rnh->rnh_walktree_from(rnh, rt_key(rt), rt_mask(rt),
|
|
|
|
rt_fixchange, &arg);
|
|
|
|
}
|
|
|
|
|
1997-03-05 08:01:28 +00:00
|
|
|
/*
|
|
|
|
* actually return a resultant rtentry and
|
|
|
|
* give the caller a single reference.
|
|
|
|
*/
|
1994-05-24 10:09:53 +00:00
|
|
|
if (ret_nrt) {
|
|
|
|
*ret_nrt = rt;
|
2003-11-08 23:36:32 +00:00
|
|
|
RT_ADDREF(rt);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2003-10-04 03:44:50 +00:00
|
|
|
RT_UNLOCK(rt);
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
2001-10-17 18:07:05 +00:00
|
|
|
default:
|
|
|
|
error = EOPNOTSUPP;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
bad:
|
2002-12-24 03:03:39 +00:00
|
|
|
RADIX_NODE_HEAD_UNLOCK(rnh);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
2003-10-04 03:44:50 +00:00
|
|
|
#undef senderr
|
|
|
|
}
|
|
|
|
|
2001-10-17 18:07:05 +00:00
|
|
|
#undef dst
|
|
|
|
#undef gateway
|
|
|
|
#undef netmask
|
|
|
|
#undef ifaaddr
|
|
|
|
#undef ifpaddr
|
|
|
|
#undef flags
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1995-01-23 02:00:35 +00:00
|
|
|
/*
|
|
|
|
* Called from rtrequest(RTM_DELETE, ...) to fix up the route's ``family''
|
|
|
|
* (i.e., the routes related to it by the operation of cloning). This
|
1995-03-20 21:30:21 +00:00
|
|
|
* routine is iterated over all potential former-child-routes by way of
|
|
|
|
* rnh->rnh_walktree_from() above, and those that actually are children of
|
|
|
|
* the late parent (passed in as VP here) are themselves deleted.
|
1995-01-23 02:00:35 +00:00
|
|
|
*/
|
1995-03-20 21:30:21 +00:00
|
|
|
static int
|
2003-10-04 03:44:50 +00:00
|
|
|
rt_fixdelete(struct radix_node *rn, void *vp)
|
1995-01-23 02:00:35 +00:00
|
|
|
{
|
2004-04-21 15:16:08 +00:00
|
|
|
struct rtentry *rt = RNTORT(rn);
|
1995-03-20 21:30:21 +00:00
|
|
|
struct rtentry *rt0 = vp;
|
|
|
|
|
2002-12-23 13:12:41 +00:00
|
|
|
if (rt->rt_parent == rt0 &&
|
2003-11-20 19:47:31 +00:00
|
|
|
!(rt->rt_flags & (RTF_PINNED | RTF_CLONING))) {
|
2004-04-20 07:04:47 +00:00
|
|
|
return rtrequest(RTM_DELETE, rt_key(rt), NULL, rt_mask(rt),
|
|
|
|
rt->rt_flags, NULL);
|
1995-01-23 02:00:35 +00:00
|
|
|
}
|
1995-03-20 21:30:21 +00:00
|
|
|
return 0;
|
1995-01-23 02:00:35 +00:00
|
|
|
}
|
|
|
|
|
1995-04-25 19:12:07 +00:00
|
|
|
/*
|
|
|
|
* This routine is called from rt_setgate() to do the analogous thing for
|
1995-05-30 08:16:23 +00:00
|
|
|
* adds and changes. There is the added complication in this case of a
|
1995-04-25 19:12:07 +00:00
|
|
|
* middle insert; i.e., insertion of a new network route between an older
|
|
|
|
* network route and (cloned) host routes. For this reason, a simple check
|
|
|
|
* of rt->rt_parent is insufficient; each candidate route must be tested
|
|
|
|
* against the (mask, value) of the new route (passed as before in vp)
|
As commented in defined in sys/net/route.c, rt_fixchange() has a bad
effect, which would cause unnecessary route deletion:
* Unfortunately, this has the obnoxious
* property of also triggering for insertion /above/ a pre-existing network
* route and clones. Sigh. This may be fixed some day.
The effect has been even worse, because recent versions of route.c set
the parent rtentry for cloned routes from an interface-direct route.
For example, suppose that we have an interface "ne0" that has an IPv4
subnet "10.0.0.0/24". Then we may have a cloned route like 10.0.0.1
on the interface, whose parent route is 10.0.0.0/24 (to the interface
ne0). Now, when we add the default route (i.e. 0.0.0.0/0),
rt_fixchange() will remove the cloned route 10.0.0.1. The (bad) effect
also prevents rt_setgate from configuring rt_gwroute, which would not
be an intended behavior.
As suggested in the comments to rt_fixchange(), we need stricter check
in the function, to prevent unintentional route deletion.
This fix also solve the "IPV6 panic?" problem in nd6_timer().
Submitted by: JINMEI Tatuya <jinmei@isl.rdc.toshiba.co.jp>
MFC after: 4 days
2001-07-25 19:31:43 +00:00
|
|
|
* to see if the new route matches it.
|
1995-04-25 19:12:07 +00:00
|
|
|
*
|
|
|
|
* XXX - it may be possible to do fixdelete() for changes and reserve this
|
|
|
|
* routine just for adds. I'm not sure why I thought it was necessary to do
|
|
|
|
* changes this way.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int
|
2003-10-04 03:44:50 +00:00
|
|
|
rt_fixchange(struct radix_node *rn, void *vp)
|
1995-04-25 19:12:07 +00:00
|
|
|
{
|
2004-04-21 15:16:08 +00:00
|
|
|
struct rtentry *rt = RNTORT(rn);
|
1995-04-25 19:12:07 +00:00
|
|
|
struct rtfc_arg *ap = vp;
|
|
|
|
struct rtentry *rt0 = ap->rt0;
|
|
|
|
struct radix_node_head *rnh = ap->rnh;
|
As commented in defined in sys/net/route.c, rt_fixchange() has a bad
effect, which would cause unnecessary route deletion:
* Unfortunately, this has the obnoxious
* property of also triggering for insertion /above/ a pre-existing network
* route and clones. Sigh. This may be fixed some day.
The effect has been even worse, because recent versions of route.c set
the parent rtentry for cloned routes from an interface-direct route.
For example, suppose that we have an interface "ne0" that has an IPv4
subnet "10.0.0.0/24". Then we may have a cloned route like 10.0.0.1
on the interface, whose parent route is 10.0.0.0/24 (to the interface
ne0). Now, when we add the default route (i.e. 0.0.0.0/0),
rt_fixchange() will remove the cloned route 10.0.0.1. The (bad) effect
also prevents rt_setgate from configuring rt_gwroute, which would not
be an intended behavior.
As suggested in the comments to rt_fixchange(), we need stricter check
in the function, to prevent unintentional route deletion.
This fix also solve the "IPV6 panic?" problem in nd6_timer().
Submitted by: JINMEI Tatuya <jinmei@isl.rdc.toshiba.co.jp>
MFC after: 4 days
2001-07-25 19:31:43 +00:00
|
|
|
u_char *xk1, *xm1, *xk2, *xmp;
|
|
|
|
int i, len, mlen;
|
1995-04-25 19:12:07 +00:00
|
|
|
|
2004-04-20 07:04:47 +00:00
|
|
|
/* make sure we have a parent, and route is not pinned or cloning */
|
2002-12-23 13:12:41 +00:00
|
|
|
if (!rt->rt_parent ||
|
2004-04-20 07:04:47 +00:00
|
|
|
(rt->rt_flags & (RTF_PINNED | RTF_CLONING)))
|
1995-04-25 19:12:07 +00:00
|
|
|
return 0;
|
|
|
|
|
2004-04-20 07:04:47 +00:00
|
|
|
if (rt->rt_parent == rt0) /* parent match */
|
|
|
|
goto delete_rt;
|
1995-04-25 19:12:07 +00:00
|
|
|
/*
|
|
|
|
* There probably is a function somewhere which does this...
|
|
|
|
* if not, there should be.
|
1995-05-30 08:16:23 +00:00
|
|
|
*/
|
2003-10-04 03:44:50 +00:00
|
|
|
len = imin(rt_key(rt0)->sa_len, rt_key(rt)->sa_len);
|
1995-04-25 19:12:07 +00:00
|
|
|
|
|
|
|
xk1 = (u_char *)rt_key(rt0);
|
|
|
|
xm1 = (u_char *)rt_mask(rt0);
|
|
|
|
xk2 = (u_char *)rt_key(rt);
|
|
|
|
|
As commented in defined in sys/net/route.c, rt_fixchange() has a bad
effect, which would cause unnecessary route deletion:
* Unfortunately, this has the obnoxious
* property of also triggering for insertion /above/ a pre-existing network
* route and clones. Sigh. This may be fixed some day.
The effect has been even worse, because recent versions of route.c set
the parent rtentry for cloned routes from an interface-direct route.
For example, suppose that we have an interface "ne0" that has an IPv4
subnet "10.0.0.0/24". Then we may have a cloned route like 10.0.0.1
on the interface, whose parent route is 10.0.0.0/24 (to the interface
ne0). Now, when we add the default route (i.e. 0.0.0.0/0),
rt_fixchange() will remove the cloned route 10.0.0.1. The (bad) effect
also prevents rt_setgate from configuring rt_gwroute, which would not
be an intended behavior.
As suggested in the comments to rt_fixchange(), we need stricter check
in the function, to prevent unintentional route deletion.
This fix also solve the "IPV6 panic?" problem in nd6_timer().
Submitted by: JINMEI Tatuya <jinmei@isl.rdc.toshiba.co.jp>
MFC after: 4 days
2001-07-25 19:31:43 +00:00
|
|
|
/* avoid applying a less specific route */
|
|
|
|
xmp = (u_char *)rt_mask(rt->rt_parent);
|
2003-10-04 03:44:50 +00:00
|
|
|
mlen = rt_key(rt->rt_parent)->sa_len;
|
2004-04-20 07:04:47 +00:00
|
|
|
if (mlen > rt_key(rt0)->sa_len) /* less specific route */
|
As commented in defined in sys/net/route.c, rt_fixchange() has a bad
effect, which would cause unnecessary route deletion:
* Unfortunately, this has the obnoxious
* property of also triggering for insertion /above/ a pre-existing network
* route and clones. Sigh. This may be fixed some day.
The effect has been even worse, because recent versions of route.c set
the parent rtentry for cloned routes from an interface-direct route.
For example, suppose that we have an interface "ne0" that has an IPv4
subnet "10.0.0.0/24". Then we may have a cloned route like 10.0.0.1
on the interface, whose parent route is 10.0.0.0/24 (to the interface
ne0). Now, when we add the default route (i.e. 0.0.0.0/0),
rt_fixchange() will remove the cloned route 10.0.0.1. The (bad) effect
also prevents rt_setgate from configuring rt_gwroute, which would not
be an intended behavior.
As suggested in the comments to rt_fixchange(), we need stricter check
in the function, to prevent unintentional route deletion.
This fix also solve the "IPV6 panic?" problem in nd6_timer().
Submitted by: JINMEI Tatuya <jinmei@isl.rdc.toshiba.co.jp>
MFC after: 4 days
2001-07-25 19:31:43 +00:00
|
|
|
return 0;
|
2004-04-20 07:04:47 +00:00
|
|
|
for (i = rnh->rnh_treetop->rn_offset; i < mlen; i++)
|
|
|
|
if ((xmp[i] & ~(xmp[i] ^ xm1[i])) != xmp[i])
|
|
|
|
return 0; /* less specific route */
|
As commented in defined in sys/net/route.c, rt_fixchange() has a bad
effect, which would cause unnecessary route deletion:
* Unfortunately, this has the obnoxious
* property of also triggering for insertion /above/ a pre-existing network
* route and clones. Sigh. This may be fixed some day.
The effect has been even worse, because recent versions of route.c set
the parent rtentry for cloned routes from an interface-direct route.
For example, suppose that we have an interface "ne0" that has an IPv4
subnet "10.0.0.0/24". Then we may have a cloned route like 10.0.0.1
on the interface, whose parent route is 10.0.0.0/24 (to the interface
ne0). Now, when we add the default route (i.e. 0.0.0.0/0),
rt_fixchange() will remove the cloned route 10.0.0.1. The (bad) effect
also prevents rt_setgate from configuring rt_gwroute, which would not
be an intended behavior.
As suggested in the comments to rt_fixchange(), we need stricter check
in the function, to prevent unintentional route deletion.
This fix also solve the "IPV6 panic?" problem in nd6_timer().
Submitted by: JINMEI Tatuya <jinmei@isl.rdc.toshiba.co.jp>
MFC after: 4 days
2001-07-25 19:31:43 +00:00
|
|
|
|
2004-04-20 07:04:47 +00:00
|
|
|
for (i = rnh->rnh_treetop->rn_offset; i < len; i++)
|
|
|
|
if ((xk2[i] & xm1[i]) != xk1[i])
|
|
|
|
return 0; /* no match */
|
1995-04-25 19:12:07 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* OK, this node is a clone, and matches the node currently being
|
|
|
|
* changed/added under the node's mask. So, get rid of it.
|
|
|
|
*/
|
2004-04-20 07:04:47 +00:00
|
|
|
delete_rt:
|
|
|
|
return rtrequest(RTM_DELETE, rt_key(rt), NULL,
|
|
|
|
rt_mask(rt), rt->rt_flags, NULL);
|
1995-04-25 19:12:07 +00:00
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
int
|
2003-10-04 03:44:50 +00:00
|
|
|
rt_setgate(struct rtentry *rt, struct sockaddr *dst, struct sockaddr *gate)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2003-10-04 03:44:50 +00:00
|
|
|
/* XXX dst may be overwritten, can we move this to below */
|
|
|
|
struct radix_node_head *rnh = rt_tables[dst->sa_family];
|
2004-04-13 11:22:22 +00:00
|
|
|
int dlen = SA_SIZE(dst), glen = SA_SIZE(gate);
|
2003-10-04 03:44:50 +00:00
|
|
|
|
|
|
|
RT_LOCK_ASSERT(rt);
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1996-07-10 01:34:36 +00:00
|
|
|
/*
|
|
|
|
* A host route with the destination equal to the gateway
|
|
|
|
* will interfere with keeping LLINFO in the routing
|
|
|
|
* table, so disallow it.
|
|
|
|
*/
|
2003-10-04 03:44:50 +00:00
|
|
|
if (((rt->rt_flags & (RTF_HOST|RTF_GATEWAY|RTF_LLINFO)) ==
|
1996-07-10 01:34:36 +00:00
|
|
|
(RTF_HOST|RTF_GATEWAY)) &&
|
2003-10-04 03:44:50 +00:00
|
|
|
dst->sa_len == gate->sa_len &&
|
|
|
|
bcmp(dst, gate, dst->sa_len) == 0) {
|
1996-07-10 01:34:36 +00:00
|
|
|
/*
|
|
|
|
* The route might already exist if this is an RTM_CHANGE
|
|
|
|
* or a routing redirect, so try to delete it.
|
|
|
|
*/
|
2003-10-04 03:44:50 +00:00
|
|
|
if (rt_key(rt))
|
2003-10-30 23:02:51 +00:00
|
|
|
rtexpunge(rt);
|
1996-07-10 01:34:36 +00:00
|
|
|
return EADDRNOTAVAIL;
|
|
|
|
}
|
|
|
|
|
2005-09-21 11:58:10 +00:00
|
|
|
/*
|
|
|
|
* Cloning loop avoidance in case of bad configuration.
|
|
|
|
*/
|
|
|
|
if (rt->rt_flags & RTF_GATEWAY) {
|
|
|
|
struct rtentry *gwrt;
|
|
|
|
|
|
|
|
RT_UNLOCK(rt); /* XXX workaround LOR */
|
|
|
|
gwrt = rtalloc1(gate, 1, 0);
|
|
|
|
if (gwrt == rt) {
|
|
|
|
RT_REMREF(rt);
|
|
|
|
return (EADDRINUSE); /* failure */
|
|
|
|
}
|
|
|
|
RT_LOCK(rt);
|
|
|
|
/*
|
|
|
|
* If there is already a gwroute, then drop it. If we
|
|
|
|
* are asked to replace route with itself, then do
|
|
|
|
* not leak its refcounter.
|
|
|
|
*/
|
|
|
|
if (rt->rt_gwroute != NULL) {
|
|
|
|
if (rt->rt_gwroute == gwrt) {
|
|
|
|
RT_REMREF(rt->rt_gwroute);
|
|
|
|
} else
|
|
|
|
RTFREE(rt->rt_gwroute);
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((rt->rt_gwroute = gwrt) != NULL)
|
|
|
|
RT_UNLOCK(rt->rt_gwroute);
|
|
|
|
}
|
|
|
|
|
1997-03-05 08:01:28 +00:00
|
|
|
/*
|
2004-04-20 07:04:47 +00:00
|
|
|
* Prepare to store the gateway in rt->rt_gateway.
|
|
|
|
* Both dst and gateway are stored one after the other in the same
|
|
|
|
* malloc'd chunk. If we have room, we can reuse the old buffer,
|
|
|
|
* rt_gateway already points to the right place.
|
|
|
|
* Otherwise, malloc a new block and update the 'dst' address.
|
1997-03-05 08:01:28 +00:00
|
|
|
*/
|
2004-04-20 07:04:47 +00:00
|
|
|
if (rt->rt_gateway == NULL || glen > SA_SIZE(rt->rt_gateway)) {
|
|
|
|
caddr_t new;
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
R_Malloc(new, caddr_t, dlen + glen);
|
2004-04-20 07:04:47 +00:00
|
|
|
if (new == NULL)
|
1996-07-10 01:34:36 +00:00
|
|
|
return ENOBUFS;
|
1997-03-05 08:01:28 +00:00
|
|
|
/*
|
2004-04-20 07:04:47 +00:00
|
|
|
* XXX note, we copy from *dst and not *rt_key(rt) because
|
|
|
|
* rt_setgate() can be called to initialize a newly
|
|
|
|
* allocated route entry, in which case rt_key(rt) == NULL
|
|
|
|
* (and also rt->rt_gateway == NULL).
|
|
|
|
* Free()/free() handle a NULL argument just fine.
|
1997-03-05 08:01:28 +00:00
|
|
|
*/
|
2004-04-20 07:04:47 +00:00
|
|
|
bcopy(dst, new, dlen);
|
|
|
|
Free(rt_key(rt)); /* free old block, if any */
|
2004-07-28 06:59:55 +00:00
|
|
|
rt_key(rt) = (struct sockaddr *)new;
|
2004-04-20 07:04:47 +00:00
|
|
|
rt->rt_gateway = (struct sockaddr *)(new + dlen);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
1997-03-05 08:01:28 +00:00
|
|
|
|
|
|
|
/*
|
2004-04-20 07:04:47 +00:00
|
|
|
* Copy the new gateway value into the memory chunk.
|
1997-03-05 08:01:28 +00:00
|
|
|
*/
|
2004-04-20 07:04:47 +00:00
|
|
|
bcopy(gate, rt->rt_gateway, glen);
|
1997-03-05 08:01:28 +00:00
|
|
|
|
1995-04-25 19:12:07 +00:00
|
|
|
/*
|
|
|
|
* This isn't going to do anything useful for host routes, so
|
|
|
|
* don't bother. Also make sure we have a reasonable mask
|
|
|
|
* (we don't yet have one during adds).
|
|
|
|
*/
|
|
|
|
if (!(rt->rt_flags & RTF_HOST) && rt_mask(rt) != 0) {
|
|
|
|
struct rtfc_arg arg;
|
2003-10-04 03:44:50 +00:00
|
|
|
|
1995-04-25 19:12:07 +00:00
|
|
|
arg.rnh = rnh;
|
|
|
|
arg.rt0 = rt;
|
2003-12-07 21:44:14 +00:00
|
|
|
RT_UNLOCK(rt); /* XXX workaround LOR */
|
2002-12-24 03:03:39 +00:00
|
|
|
RADIX_NODE_HEAD_LOCK(rnh);
|
2003-11-25 19:52:12 +00:00
|
|
|
RT_LOCK(rt);
|
1995-05-30 08:16:23 +00:00
|
|
|
rnh->rnh_walktree_from(rnh, rt_key(rt), rt_mask(rt),
|
1995-04-25 19:12:07 +00:00
|
|
|
rt_fixchange, &arg);
|
2002-12-24 03:03:39 +00:00
|
|
|
RADIX_NODE_HEAD_UNLOCK(rnh);
|
1995-04-25 19:12:07 +00:00
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
1995-12-14 09:55:16 +00:00
|
|
|
static void
|
2003-10-04 03:44:50 +00:00
|
|
|
rt_maskedcopy(struct sockaddr *src, struct sockaddr *dst, struct sockaddr *netmask)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
register u_char *cp1 = (u_char *)src;
|
|
|
|
register u_char *cp2 = (u_char *)dst;
|
|
|
|
register u_char *cp3 = (u_char *)netmask;
|
|
|
|
u_char *cplim = cp2 + *cp3;
|
|
|
|
u_char *cplim2 = cp2 + *cp1;
|
|
|
|
|
|
|
|
*cp2++ = *cp1++; *cp2++ = *cp1++; /* copies sa_len & sa_family */
|
|
|
|
cp3 += 2;
|
|
|
|
if (cplim > cplim2)
|
|
|
|
cplim = cplim2;
|
|
|
|
while (cp2 < cplim)
|
|
|
|
*cp2++ = *cp1++ & *cp3++;
|
|
|
|
if (cp2 < cplim2)
|
|
|
|
bzero((caddr_t)cp2, (unsigned)(cplim2 - cp2));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set up a routing table entry, normally
|
|
|
|
* for an interface.
|
|
|
|
*/
|
|
|
|
int
|
2003-10-04 03:44:50 +00:00
|
|
|
rtinit(struct ifaddr *ifa, int cmd, int flags)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2004-04-12 20:24:30 +00:00
|
|
|
struct sockaddr *dst;
|
2001-10-17 18:07:05 +00:00
|
|
|
struct sockaddr *netmask;
|
2004-04-20 07:04:47 +00:00
|
|
|
struct mbuf *m = NULL;
|
|
|
|
struct rtentry *rt = NULL;
|
2001-10-17 18:07:05 +00:00
|
|
|
struct rt_addrinfo info;
|
2004-04-12 20:24:30 +00:00
|
|
|
int error;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2001-10-17 18:07:05 +00:00
|
|
|
if (flags & RTF_HOST) {
|
|
|
|
dst = ifa->ifa_dstaddr;
|
|
|
|
netmask = NULL;
|
|
|
|
} else {
|
|
|
|
dst = ifa->ifa_addr;
|
|
|
|
netmask = ifa->ifa_netmask;
|
|
|
|
}
|
2006-05-04 18:33:37 +00:00
|
|
|
if (dst->sa_len == 0)
|
|
|
|
return(EINVAL);
|
|
|
|
|
1996-09-10 07:10:05 +00:00
|
|
|
/*
|
|
|
|
* If it's a delete, check that if it exists, it's on the correct
|
|
|
|
* interface or we might scrub a route to another ifa which would
|
|
|
|
* be confusing at best and possibly worse.
|
|
|
|
*/
|
1994-05-24 10:09:53 +00:00
|
|
|
if (cmd == RTM_DELETE) {
|
2004-04-12 20:24:30 +00:00
|
|
|
struct sockaddr *deldst;
|
|
|
|
struct radix_node_head *rnh;
|
|
|
|
struct radix_node *rn;
|
|
|
|
|
1999-11-22 02:45:11 +00:00
|
|
|
/*
|
1996-09-10 07:10:05 +00:00
|
|
|
* It's a delete, so it should already exist..
|
|
|
|
* If it's a net, mask off the host bits
|
|
|
|
* (Assuming we have a mask)
|
|
|
|
*/
|
2001-10-17 18:07:05 +00:00
|
|
|
if (netmask != NULL) {
|
2003-02-19 05:47:46 +00:00
|
|
|
m = m_get(M_DONTWAIT, MT_SONAME);
|
1999-11-22 02:45:11 +00:00
|
|
|
if (m == NULL)
|
|
|
|
return(ENOBUFS);
|
1994-05-24 10:09:53 +00:00
|
|
|
deldst = mtod(m, struct sockaddr *);
|
2001-10-17 18:07:05 +00:00
|
|
|
rt_maskedcopy(dst, deldst, netmask);
|
1994-05-24 10:09:53 +00:00
|
|
|
dst = deldst;
|
|
|
|
}
|
1996-09-10 07:10:05 +00:00
|
|
|
/*
|
2001-10-17 18:07:05 +00:00
|
|
|
* Look up an rtentry that is in the routing tree and
|
|
|
|
* contains the correct info.
|
1996-09-10 07:10:05 +00:00
|
|
|
*/
|
2002-12-24 03:03:39 +00:00
|
|
|
if ((rnh = rt_tables[dst->sa_family]) == NULL)
|
|
|
|
goto bad;
|
|
|
|
RADIX_NODE_HEAD_LOCK(rnh);
|
|
|
|
error = ((rn = rnh->rnh_lookup(dst, netmask, rnh)) == NULL ||
|
2001-10-17 18:07:05 +00:00
|
|
|
(rn->rn_flags & RNF_ROOT) ||
|
2004-04-21 15:16:08 +00:00
|
|
|
RNTORT(rn)->rt_ifa != ifa ||
|
2004-04-20 07:04:47 +00:00
|
|
|
!sa_equal((struct sockaddr *)rn->rn_key, dst));
|
2002-12-24 03:03:39 +00:00
|
|
|
RADIX_NODE_HEAD_UNLOCK(rnh);
|
|
|
|
if (error) {
|
|
|
|
bad:
|
2001-10-17 18:07:05 +00:00
|
|
|
if (m)
|
|
|
|
(void) m_free(m);
|
|
|
|
return (flags & RTF_HOST ? EHOSTUNREACH : ENETUNREACH);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
}
|
1996-09-10 07:10:05 +00:00
|
|
|
/*
|
|
|
|
* Do the actual request
|
|
|
|
*/
|
2001-10-17 18:07:05 +00:00
|
|
|
bzero((caddr_t)&info, sizeof(info));
|
|
|
|
info.rti_ifa = ifa;
|
|
|
|
info.rti_flags = flags | ifa->ifa_flags;
|
|
|
|
info.rti_info[RTAX_DST] = dst;
|
|
|
|
info.rti_info[RTAX_GATEWAY] = ifa->ifa_addr;
|
|
|
|
info.rti_info[RTAX_NETMASK] = netmask;
|
2004-04-12 20:24:30 +00:00
|
|
|
error = rtrequest1(cmd, &info, &rt);
|
|
|
|
if (error == 0 && rt != NULL) {
|
1996-09-10 07:10:05 +00:00
|
|
|
/*
|
2001-11-28 16:15:52 +00:00
|
|
|
* notify any listening routing agents of the change
|
1996-09-10 07:10:05 +00:00
|
|
|
*/
|
2003-10-04 03:44:50 +00:00
|
|
|
RT_LOCK(rt);
|
2001-10-17 18:07:05 +00:00
|
|
|
rt_newaddrmsg(cmd, ifa, error, rt);
|
|
|
|
if (cmd == RTM_DELETE) {
|
1999-11-22 02:45:11 +00:00
|
|
|
/*
|
2001-10-17 18:07:05 +00:00
|
|
|
* If we are deleting, and we found an entry, then
|
|
|
|
* it's been removed from the tree.. now throw it away.
|
1996-09-10 07:10:05 +00:00
|
|
|
*/
|
2003-10-04 03:44:50 +00:00
|
|
|
RTFREE_LOCKED(rt);
|
|
|
|
} else {
|
|
|
|
if (cmd == RTM_ADD) {
|
|
|
|
/*
|
|
|
|
* We just wanted to add it.. we don't actually
|
|
|
|
* need a reference.
|
|
|
|
*/
|
2003-11-08 23:36:32 +00:00
|
|
|
RT_REMREF(rt);
|
2003-10-04 03:44:50 +00:00
|
|
|
}
|
|
|
|
RT_UNLOCK(rt);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
}
|
2001-10-17 18:07:05 +00:00
|
|
|
if (m)
|
|
|
|
(void) m_free(m);
|
1995-01-23 17:53:21 +00:00
|
|
|
return (error);
|
|
|
|
}
|
1999-04-29 03:22:19 +00:00
|
|
|
|
2003-10-04 03:44:50 +00:00
|
|
|
/*
|
2004-04-24 23:34:56 +00:00
|
|
|
* rt_check() is invoked on each layer 2 output path, prior to
|
|
|
|
* encapsulating outbound packets.
|
|
|
|
*
|
|
|
|
* The function is mostly used to find a routing entry for the gateway,
|
|
|
|
* which in some protocol families could also point to the link-level
|
|
|
|
* address for the gateway itself (the side effect of revalidating the
|
|
|
|
* route to the destination is rather pointless at this stage, we did it
|
|
|
|
* already a moment before in the pr_output() routine to locate the ifp
|
|
|
|
* and gateway to use).
|
|
|
|
*
|
|
|
|
* When we remove the layer-3 to layer-2 mapping tables from the
|
|
|
|
* routing table, this function can be removed.
|
|
|
|
*
|
|
|
|
* === On input ===
|
|
|
|
* *dst is the address of the NEXT HOP (which coincides with the
|
|
|
|
* final destination if directly reachable);
|
|
|
|
* *lrt0 points to the cached route to the final destination;
|
|
|
|
* *lrt is not meaningful;
|
|
|
|
*
|
|
|
|
* === Operation ===
|
|
|
|
* If the route is marked down try to find a new route. If the route
|
2003-10-04 03:44:50 +00:00
|
|
|
* to the gateway is gone, try to setup a new route. Otherwise,
|
|
|
|
* if the route is marked for packets to be rejected, enforce that.
|
|
|
|
*
|
2004-04-24 23:34:56 +00:00
|
|
|
* === On return ===
|
|
|
|
* *dst is unchanged;
|
|
|
|
* *lrt0 points to the (possibly new) route to the final destination
|
|
|
|
* *lrt points to the route to the next hop
|
2003-10-04 03:44:50 +00:00
|
|
|
*
|
2004-04-25 01:39:00 +00:00
|
|
|
* Their values are meaningful ONLY if no error is returned.
|
2003-10-04 03:44:50 +00:00
|
|
|
*/
|
2003-03-02 21:34:37 +00:00
|
|
|
int
|
2003-10-04 03:44:50 +00:00
|
|
|
rt_check(struct rtentry **lrt, struct rtentry **lrt0, struct sockaddr *dst)
|
2003-03-02 21:34:37 +00:00
|
|
|
{
|
|
|
|
struct rtentry *rt;
|
|
|
|
struct rtentry *rt0;
|
|
|
|
int error;
|
|
|
|
|
2005-08-11 08:14:53 +00:00
|
|
|
KASSERT(*lrt0 != NULL, ("rt_check"));
|
|
|
|
rt = rt0 = *lrt0;
|
|
|
|
|
|
|
|
/* NB: the locking here is tortuous... */
|
|
|
|
RT_LOCK(rt);
|
|
|
|
if ((rt->rt_flags & RTF_UP) == 0) {
|
|
|
|
RT_UNLOCK(rt);
|
|
|
|
rt = rtalloc1(dst, 1, 0UL);
|
|
|
|
if (rt != NULL) {
|
|
|
|
RT_REMREF(rt);
|
|
|
|
/* XXX what about if change? */
|
|
|
|
} else
|
2007-05-22 16:17:31 +00:00
|
|
|
return (EHOSTUNREACH);
|
2005-08-11 08:14:53 +00:00
|
|
|
rt0 = rt;
|
|
|
|
}
|
|
|
|
/* XXX BSD/OS checks dst->sa_family != AF_NS */
|
|
|
|
if (rt->rt_flags & RTF_GATEWAY) {
|
|
|
|
if (rt->rt_gwroute == NULL)
|
|
|
|
goto lookup;
|
|
|
|
rt = rt->rt_gwroute;
|
|
|
|
RT_LOCK(rt); /* NB: gwroute */
|
2003-03-02 21:34:37 +00:00
|
|
|
if ((rt->rt_flags & RTF_UP) == 0) {
|
2007-05-22 16:17:31 +00:00
|
|
|
RTFREE_LOCKED(rt); /* unlock gwroute */
|
2005-08-11 08:14:53 +00:00
|
|
|
rt = rt0;
|
2007-10-22 19:01:26 +00:00
|
|
|
rt0->rt_gwroute = NULL;
|
2005-08-11 08:14:53 +00:00
|
|
|
lookup:
|
|
|
|
RT_UNLOCK(rt0);
|
|
|
|
rt = rtalloc1(rt->rt_gateway, 1, 0UL);
|
Assuming the interface has an address of x.x.x.195, a mask of
255.255.255.0, and a default route with gateway x.x.x.1. Now if
the address mask is changed to something more specific, e.g.,
255.255.255.128, then after the mask change the default gateway
is no longer reachable.
Since the default route is still present in the routing table,
when the output code tries to resolve the address of the default
gateway in function rt_check(), again, the default route will be
returned by rtalloc1(). Because the lock is currently held on the
rtentry structure, one more attempt to hold the lock will trigger
a crash due to "lock recursed on non-recursive mutex ..."
This is a general problem. The fix checks for the above condition
so that an existing route entry is not mistaken for a new cloned
route. Approriately, an ENETUNREACH error is returned back to the
caller
Approved by: andre
2006-06-05 21:20:21 +00:00
|
|
|
if (rt == rt0) {
|
|
|
|
RT_REMREF(rt0);
|
|
|
|
RT_UNLOCK(rt0);
|
2007-05-22 16:17:31 +00:00
|
|
|
return (ENETUNREACH);
|
Assuming the interface has an address of x.x.x.195, a mask of
255.255.255.0, and a default route with gateway x.x.x.1. Now if
the address mask is changed to something more specific, e.g.,
255.255.255.128, then after the mask change the default gateway
is no longer reachable.
Since the default route is still present in the routing table,
when the output code tries to resolve the address of the default
gateway in function rt_check(), again, the default route will be
returned by rtalloc1(). Because the lock is currently held on the
rtentry structure, one more attempt to hold the lock will trigger
a crash due to "lock recursed on non-recursive mutex ..."
This is a general problem. The fix checks for the above condition
so that an existing route entry is not mistaken for a new cloned
route. Approriately, an ENETUNREACH error is returned back to the
caller
Approved by: andre
2006-06-05 21:20:21 +00:00
|
|
|
}
|
2005-08-11 08:14:53 +00:00
|
|
|
RT_LOCK(rt0);
|
2007-10-22 19:01:26 +00:00
|
|
|
if (rt0->rt_gwroute != NULL)
|
|
|
|
RTFREE(rt0->rt_gwroute);
|
2005-08-11 08:14:53 +00:00
|
|
|
rt0->rt_gwroute = rt;
|
|
|
|
if (rt == NULL) {
|
2003-10-04 03:44:50 +00:00
|
|
|
RT_UNLOCK(rt0);
|
2007-05-22 16:17:31 +00:00
|
|
|
return (EHOSTUNREACH);
|
2003-03-02 21:34:37 +00:00
|
|
|
}
|
2005-08-09 08:39:56 +00:00
|
|
|
}
|
2005-08-11 08:14:53 +00:00
|
|
|
RT_UNLOCK(rt0);
|
2003-03-02 21:34:37 +00:00
|
|
|
}
|
2005-08-11 08:14:53 +00:00
|
|
|
/* XXX why are we inspecting rmx_expire? */
|
|
|
|
error = (rt->rt_flags & RTF_REJECT) &&
|
|
|
|
(rt->rt_rmx.rmx_expire == 0 ||
|
2005-09-19 22:54:55 +00:00
|
|
|
time_uptime < rt->rt_rmx.rmx_expire);
|
2005-08-11 08:14:53 +00:00
|
|
|
if (error) {
|
|
|
|
RT_UNLOCK(rt);
|
2007-05-22 16:17:31 +00:00
|
|
|
return (rt == rt0 ? EHOSTDOWN : EHOSTUNREACH);
|
2005-08-11 08:14:53 +00:00
|
|
|
}
|
|
|
|
|
2005-08-09 08:39:56 +00:00
|
|
|
*lrt = rt;
|
2003-03-02 21:34:37 +00:00
|
|
|
*lrt0 = rt0;
|
2003-10-04 03:44:50 +00:00
|
|
|
return (0);
|
2003-03-02 21:34:37 +00:00
|
|
|
}
|
|
|
|
|
1999-12-22 19:13:38 +00:00
|
|
|
/* This must be before ip6_init2(), which is now SI_ORDER_MIDDLE */
|
|
|
|
SYSINIT(route, SI_SUB_PROTO_DOMAIN, SI_ORDER_THIRD, route_init, 0);
|