2005-01-07 01:45:51 +00:00
|
|
|
/*-
|
1994-05-24 10:09:53 +00:00
|
|
|
* Copyright (c) 1988, 1989, 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 09:16:58 +00:00
|
|
|
* @(#)radix.c 8.5 (Berkeley) 5/19/95
|
1999-08-28 01:08:13 +00:00
|
|
|
* $FreeBSD$
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Routines to build and maintain radix trees for routing lookups.
|
|
|
|
*/
|
|
|
|
#include <sys/param.h>
|
1999-12-29 04:46:21 +00:00
|
|
|
#ifdef _KERNEL
|
2003-02-08 01:44:09 +00:00
|
|
|
#include <sys/lock.h>
|
|
|
|
#include <sys/mutex.h>
|
2008-12-07 21:15:43 +00:00
|
|
|
#include <sys/rwlock.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/systm.h>
|
|
|
|
#include <sys/malloc.h>
|
1995-04-28 23:01:37 +00:00
|
|
|
#include <sys/syslog.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <net/radix.h>
|
This patch provides the back end support for equal-cost multi-path
(ECMP) for both IPv4 and IPv6. Previously, multipath route insertion
is disallowed. For example,
route add -net 192.103.54.0/24 10.9.44.1
route add -net 192.103.54.0/24 10.9.44.2
The second route insertion will trigger an error message of
"add net 192.103.54.0/24: gateway 10.2.5.2: route already in table"
Multiple default routes can also be inserted. Here is the netstat
output:
default 10.2.5.1 UGS 0 3074 bge0 =>
default 10.2.5.2 UGS 0 0 bge0
When multipath routes exist, the "route delete" command requires
a specific gateway to be specified or else an error message would
be displayed. For example,
route delete default
would fail and trigger the following error message:
"route: writing to routing socket: No such process"
"delete net default: not in table"
On the other hand,
route delete default 10.2.5.2
would be successful: "delete net default: gateway 10.2.5.2"
One does not have to specify a gateway if there is only a single
route for a particular destination.
I need to perform more testings on address aliases and multiple
interfaces that have the same IP prefixes. This patch as it
stands today is not yet ready for prime time. Therefore, the ECMP
code fragments are fully guarded by the RADIX_MPATH macro.
Include the "options RADIX_MPATH" in the kernel configuration
to enable this feature.
Reviewed by: robert, sam, gnn, julian, kmacy
2008-04-13 05:45:14 +00:00
|
|
|
#include "opt_mpath.h"
|
|
|
|
#ifdef RADIX_MPATH
|
|
|
|
#include <net/radix_mpath.h>
|
|
|
|
#endif
|
2009-12-12 15:49:28 +00:00
|
|
|
#else /* !_KERNEL */
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <strings.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#define log(x, arg...) fprintf(stderr, ## arg)
|
|
|
|
#define panic(x) fprintf(stderr, "PANIC: %s", x), exit(1)
|
|
|
|
#define min(a, b) ((a) < (b) ? (a) : (b) )
|
|
|
|
#include <net/radix.h>
|
|
|
|
#endif /* !_KERNEL */
|
This patch provides the back end support for equal-cost multi-path
(ECMP) for both IPv4 and IPv6. Previously, multipath route insertion
is disallowed. For example,
route add -net 192.103.54.0/24 10.9.44.1
route add -net 192.103.54.0/24 10.9.44.2
The second route insertion will trigger an error message of
"add net 192.103.54.0/24: gateway 10.2.5.2: route already in table"
Multiple default routes can also be inserted. Here is the netstat
output:
default 10.2.5.1 UGS 0 3074 bge0 =>
default 10.2.5.2 UGS 0 0 bge0
When multipath routes exist, the "route delete" command requires
a specific gateway to be specified or else an error message would
be displayed. For example,
route delete default
would fail and trigger the following error message:
"route: writing to routing socket: No such process"
"delete net default: not in table"
On the other hand,
route delete default 10.2.5.2
would be successful: "delete net default: gateway 10.2.5.2"
One does not have to specify a gateway if there is only a single
route for a particular destination.
I need to perform more testings on address aliases and multiple
interfaces that have the same IP prefixes. This patch as it
stands today is not yet ready for prime time. Therefore, the ECMP
code fragments are fully guarded by the RADIX_MPATH macro.
Include the "options RADIX_MPATH" in the kernel configuration
to enable this feature.
Reviewed by: robert, sam, gnn, julian, kmacy
2008-04-13 05:45:14 +00:00
|
|
|
|
2002-03-24 09:34:04 +00:00
|
|
|
static int rn_walktree_from(struct radix_node_head *h, void *a, void *m,
|
|
|
|
walktree_f_t *f, void *w);
|
2002-03-19 21:54:18 +00:00
|
|
|
static int rn_walktree(struct radix_node_head *, walktree_f_t *, void *);
|
1995-12-14 09:55:16 +00:00
|
|
|
static struct radix_node
|
2002-03-19 21:54:18 +00:00
|
|
|
*rn_insert(void *, struct radix_node_head *, int *,
|
2002-03-24 09:34:04 +00:00
|
|
|
struct radix_node [2]),
|
2002-03-19 21:54:18 +00:00
|
|
|
*rn_newpair(void *, int, struct radix_node[2]),
|
|
|
|
*rn_search(void *, struct radix_node *),
|
|
|
|
*rn_search_m(void *, struct radix_node *, void *);
|
1995-12-14 09:55:16 +00:00
|
|
|
|
|
|
|
static int max_keylen;
|
|
|
|
static struct radix_mask *rn_mkfreelist;
|
|
|
|
static struct radix_node_head *mask_rnhead;
|
2004-04-19 17:28:39 +00:00
|
|
|
/*
|
|
|
|
* Work area -- the following point to 3 buffers of size max_keylen,
|
|
|
|
* allocated in this order in a block of memory malloc'ed by rn_init.
|
2009-12-10 10:34:30 +00:00
|
|
|
* rn_zeros, rn_ones are set in rn_init and used in readonly afterwards.
|
|
|
|
* addmask_key is used in rn_addmask in rw mode and not thread-safe.
|
2004-04-19 17:28:39 +00:00
|
|
|
*/
|
|
|
|
static char *rn_zeros, *rn_ones, *addmask_key;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2004-04-18 11:48:35 +00:00
|
|
|
#define MKGet(m) { \
|
|
|
|
if (rn_mkfreelist) { \
|
|
|
|
m = rn_mkfreelist; \
|
|
|
|
rn_mkfreelist = (m)->rm_mklist; \
|
|
|
|
} else \
|
|
|
|
R_Malloc(m, struct radix_mask *, sizeof (struct radix_mask)); }
|
|
|
|
|
|
|
|
#define MKFree(m) { (m)->rm_mklist = rn_mkfreelist; rn_mkfreelist = (m);}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
#define rn_masktop (mask_rnhead->rnh_treetop)
|
1995-12-02 19:38:06 +00:00
|
|
|
|
2002-03-19 21:54:18 +00:00
|
|
|
static int rn_lexobetter(void *m_arg, void *n_arg);
|
1995-12-02 19:38:06 +00:00
|
|
|
static struct radix_mask *
|
2002-03-19 21:54:18 +00:00
|
|
|
rn_new_radix_mask(struct radix_node *tt,
|
2002-03-24 09:34:04 +00:00
|
|
|
struct radix_mask *next);
|
2002-12-25 11:40:53 +00:00
|
|
|
static int rn_satisfies_leaf(char *trial, struct radix_node *leaf,
|
2002-03-24 09:34:04 +00:00
|
|
|
int skip);
|
1995-12-02 19:38:06 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* The data structure for the keys is a radix tree with one way
|
2000-04-23 04:00:00 +00:00
|
|
|
* branching removed. The index rn_bit at an internal node n represents a bit
|
1994-05-24 10:09:53 +00:00
|
|
|
* position to be tested. The tree is arranged so that all descendants
|
2000-04-23 04:00:00 +00:00
|
|
|
* of a node n have keys whose bits all agree up to position rn_bit - 1.
|
|
|
|
* (We say the index of n is rn_bit.)
|
1994-05-24 10:09:53 +00:00
|
|
|
*
|
2000-04-23 04:00:00 +00:00
|
|
|
* There is at least one descendant which has a one bit at position rn_bit,
|
1994-05-24 10:09:53 +00:00
|
|
|
* and at least one with a zero there.
|
|
|
|
*
|
|
|
|
* A route is determined by a pair of key and mask. We require that the
|
|
|
|
* bit-wise logical and of the key and mask to be the key.
|
|
|
|
* We define the index of a route to associated with the mask to be
|
|
|
|
* the first bit number in the mask where 0 occurs (with bit number 0
|
|
|
|
* representing the highest order bit).
|
1995-05-30 08:16:23 +00:00
|
|
|
*
|
1994-05-24 10:09:53 +00:00
|
|
|
* We say a mask is normal if every bit is 0, past the index of the mask.
|
2000-04-23 04:00:00 +00:00
|
|
|
* If a node n has a descendant (k, m) with index(m) == index(n) == rn_bit,
|
1994-05-24 10:09:53 +00:00
|
|
|
* and m is a normal mask, then the route applies to every descendant of n.
|
2000-04-23 04:00:00 +00:00
|
|
|
* If the index(m) < rn_bit, this implies the trailing last few bits of k
|
1994-05-24 10:09:53 +00:00
|
|
|
* before bit b are all 0, (and hence consequently true of every descendant
|
|
|
|
* of n), so the route applies to all descendants of the node as well.
|
1995-05-30 08:16:23 +00:00
|
|
|
*
|
1995-04-28 23:01:37 +00:00
|
|
|
* Similar logic shows that a non-normal mask m such that
|
1994-05-24 10:09:53 +00:00
|
|
|
* index(m) <= index(n) could potentially apply to many children of n.
|
|
|
|
* Thus, for each non-host route, we attach its mask to a list at an internal
|
1995-05-30 08:16:23 +00:00
|
|
|
* node as high in the tree as we can go.
|
1995-04-28 23:01:37 +00:00
|
|
|
*
|
|
|
|
* The present version of the code makes use of normal routes in short-
|
|
|
|
* circuiting an explict mask and compare operation when testing whether
|
|
|
|
* a key satisfies a normal route, and also in remembering the unique leaf
|
|
|
|
* that governs a subtree.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
|
Readability fixes:
Clearly comment the assumptions on the structure of keys (addresses)
and masks, and introduce a macro, LEN(p), to extract the size of these
objects instead of using *(u_char *)p which might be confusing.
Comment the confusion in the types used to pass around pointers
to keys and masks, as a reminder to fix that at some point.
Add a few comments on what some functions do.
Comment a probably inefficient (but still correct) section of code
in rn_walktree_from()
The object code generated after this commit is the same as before.
At some point we should also change same variable identifiers such
as "t, tt, ttt" to fancier names such as "root, left, right" (just
in case someone wants to understand the code!), replace misspelling
of NULL as 0, remove 'register' declarations that make little sense
these days.
2004-04-21 15:27:36 +00:00
|
|
|
/*
|
|
|
|
* Most of the functions in this code assume that the key/mask arguments
|
|
|
|
* are sockaddr-like structures, where the first byte is an u_char
|
|
|
|
* indicating the size of the entire structure.
|
|
|
|
*
|
|
|
|
* To make the assumption more explicit, we use the LEN() macro to access
|
|
|
|
* this field. It is safe to pass an expression with side effects
|
|
|
|
* to LEN() as the argument is evaluated only once.
|
2009-12-10 10:34:30 +00:00
|
|
|
* We cast the result to int as this is the dominant usage.
|
Readability fixes:
Clearly comment the assumptions on the structure of keys (addresses)
and masks, and introduce a macro, LEN(p), to extract the size of these
objects instead of using *(u_char *)p which might be confusing.
Comment the confusion in the types used to pass around pointers
to keys and masks, as a reminder to fix that at some point.
Add a few comments on what some functions do.
Comment a probably inefficient (but still correct) section of code
in rn_walktree_from()
The object code generated after this commit is the same as before.
At some point we should also change same variable identifiers such
as "t, tt, ttt" to fancier names such as "root, left, right" (just
in case someone wants to understand the code!), replace misspelling
of NULL as 0, remove 'register' declarations that make little sense
these days.
2004-04-21 15:27:36 +00:00
|
|
|
*/
|
2009-12-10 10:34:30 +00:00
|
|
|
#define LEN(x) ( (int) (*(const u_char *)(x)) )
|
Readability fixes:
Clearly comment the assumptions on the structure of keys (addresses)
and masks, and introduce a macro, LEN(p), to extract the size of these
objects instead of using *(u_char *)p which might be confusing.
Comment the confusion in the types used to pass around pointers
to keys and masks, as a reminder to fix that at some point.
Add a few comments on what some functions do.
Comment a probably inefficient (but still correct) section of code
in rn_walktree_from()
The object code generated after this commit is the same as before.
At some point we should also change same variable identifiers such
as "t, tt, ttt" to fancier names such as "root, left, right" (just
in case someone wants to understand the code!), replace misspelling
of NULL as 0, remove 'register' declarations that make little sense
these days.
2004-04-21 15:27:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* XXX THIS NEEDS TO BE FIXED
|
|
|
|
* In the code, pointers to keys and masks are passed as either
|
|
|
|
* 'void *' (because callers use to pass pointers of various kinds), or
|
|
|
|
* 'caddr_t' (which is fine for pointer arithmetics, but not very
|
|
|
|
* clean when you dereference it to access data). Furthermore, caddr_t
|
|
|
|
* is really 'char *', while the natural type to operate on keys and
|
|
|
|
* masks would be 'u_char'. This mismatch require a lot of casts and
|
|
|
|
* intermediate variables to adapt types that clutter the code.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Search a node in the tree matching the key.
|
|
|
|
*/
|
1995-12-14 09:55:16 +00:00
|
|
|
static struct radix_node *
|
1994-05-24 10:09:53 +00:00
|
|
|
rn_search(v_arg, head)
|
|
|
|
void *v_arg;
|
|
|
|
struct radix_node *head;
|
|
|
|
{
|
|
|
|
register struct radix_node *x;
|
|
|
|
register caddr_t v;
|
|
|
|
|
2000-04-23 04:00:00 +00:00
|
|
|
for (x = head, v = v_arg; x->rn_bit >= 0;) {
|
|
|
|
if (x->rn_bmask & v[x->rn_offset])
|
|
|
|
x = x->rn_right;
|
1994-05-24 10:09:53 +00:00
|
|
|
else
|
2000-04-23 04:00:00 +00:00
|
|
|
x = x->rn_left;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
return (x);
|
1997-11-24 13:50:24 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
|
Readability fixes:
Clearly comment the assumptions on the structure of keys (addresses)
and masks, and introduce a macro, LEN(p), to extract the size of these
objects instead of using *(u_char *)p which might be confusing.
Comment the confusion in the types used to pass around pointers
to keys and masks, as a reminder to fix that at some point.
Add a few comments on what some functions do.
Comment a probably inefficient (but still correct) section of code
in rn_walktree_from()
The object code generated after this commit is the same as before.
At some point we should also change same variable identifiers such
as "t, tt, ttt" to fancier names such as "root, left, right" (just
in case someone wants to understand the code!), replace misspelling
of NULL as 0, remove 'register' declarations that make little sense
these days.
2004-04-21 15:27:36 +00:00
|
|
|
/*
|
|
|
|
* Same as above, but with an additional mask.
|
|
|
|
* XXX note this function is used only once.
|
|
|
|
*/
|
1995-12-14 09:55:16 +00:00
|
|
|
static struct radix_node *
|
1994-05-24 10:09:53 +00:00
|
|
|
rn_search_m(v_arg, head, m_arg)
|
|
|
|
struct radix_node *head;
|
|
|
|
void *v_arg, *m_arg;
|
|
|
|
{
|
|
|
|
register struct radix_node *x;
|
|
|
|
register caddr_t v = v_arg, m = m_arg;
|
|
|
|
|
2000-04-23 04:00:00 +00:00
|
|
|
for (x = head; x->rn_bit >= 0;) {
|
|
|
|
if ((x->rn_bmask & m[x->rn_offset]) &&
|
|
|
|
(x->rn_bmask & v[x->rn_offset]))
|
|
|
|
x = x->rn_right;
|
1994-05-24 10:09:53 +00:00
|
|
|
else
|
2000-04-23 04:00:00 +00:00
|
|
|
x = x->rn_left;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
return x;
|
1997-11-24 13:50:24 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
int
|
|
|
|
rn_refines(m_arg, n_arg)
|
|
|
|
void *m_arg, *n_arg;
|
|
|
|
{
|
|
|
|
register caddr_t m = m_arg, n = n_arg;
|
Readability fixes:
Clearly comment the assumptions on the structure of keys (addresses)
and masks, and introduce a macro, LEN(p), to extract the size of these
objects instead of using *(u_char *)p which might be confusing.
Comment the confusion in the types used to pass around pointers
to keys and masks, as a reminder to fix that at some point.
Add a few comments on what some functions do.
Comment a probably inefficient (but still correct) section of code
in rn_walktree_from()
The object code generated after this commit is the same as before.
At some point we should also change same variable identifiers such
as "t, tt, ttt" to fancier names such as "root, left, right" (just
in case someone wants to understand the code!), replace misspelling
of NULL as 0, remove 'register' declarations that make little sense
these days.
2004-04-21 15:27:36 +00:00
|
|
|
register caddr_t lim, lim2 = lim = n + LEN(n);
|
2009-12-10 10:34:30 +00:00
|
|
|
int longer = LEN(n++) - LEN(m++);
|
1994-05-24 10:09:53 +00:00
|
|
|
int masks_are_equal = 1;
|
|
|
|
|
|
|
|
if (longer > 0)
|
|
|
|
lim -= longer;
|
|
|
|
while (n < lim) {
|
|
|
|
if (*n & ~(*m))
|
|
|
|
return 0;
|
|
|
|
if (*n++ != *m++)
|
|
|
|
masks_are_equal = 0;
|
|
|
|
}
|
|
|
|
while (n < lim2)
|
|
|
|
if (*n++)
|
|
|
|
return 0;
|
|
|
|
if (masks_are_equal && (longer < 0))
|
|
|
|
for (lim2 = m - longer; m < lim2; )
|
|
|
|
if (*m++)
|
|
|
|
return 1;
|
|
|
|
return (!masks_are_equal);
|
|
|
|
}
|
|
|
|
|
1995-04-28 23:01:37 +00:00
|
|
|
struct radix_node *
|
|
|
|
rn_lookup(v_arg, m_arg, head)
|
|
|
|
void *v_arg, *m_arg;
|
|
|
|
struct radix_node_head *head;
|
|
|
|
{
|
|
|
|
register struct radix_node *x;
|
|
|
|
caddr_t netmask = 0;
|
|
|
|
|
|
|
|
if (m_arg) {
|
2000-04-23 04:00:00 +00:00
|
|
|
x = rn_addmask(m_arg, 1, head->rnh_treetop->rn_offset);
|
|
|
|
if (x == 0)
|
1995-04-28 23:01:37 +00:00
|
|
|
return (0);
|
|
|
|
netmask = x->rn_key;
|
|
|
|
}
|
|
|
|
x = rn_match(v_arg, head);
|
|
|
|
if (x && netmask) {
|
|
|
|
while (x && x->rn_mask != netmask)
|
|
|
|
x = x->rn_dupedkey;
|
|
|
|
}
|
|
|
|
return x;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2002-12-25 11:40:53 +00:00
|
|
|
rn_satisfies_leaf(trial, leaf, skip)
|
1995-04-28 23:01:37 +00:00
|
|
|
char *trial;
|
|
|
|
register struct radix_node *leaf;
|
|
|
|
int skip;
|
|
|
|
{
|
|
|
|
register char *cp = trial, *cp2 = leaf->rn_key, *cp3 = leaf->rn_mask;
|
|
|
|
char *cplim;
|
Readability fixes:
Clearly comment the assumptions on the structure of keys (addresses)
and masks, and introduce a macro, LEN(p), to extract the size of these
objects instead of using *(u_char *)p which might be confusing.
Comment the confusion in the types used to pass around pointers
to keys and masks, as a reminder to fix that at some point.
Add a few comments on what some functions do.
Comment a probably inefficient (but still correct) section of code
in rn_walktree_from()
The object code generated after this commit is the same as before.
At some point we should also change same variable identifiers such
as "t, tt, ttt" to fancier names such as "root, left, right" (just
in case someone wants to understand the code!), replace misspelling
of NULL as 0, remove 'register' declarations that make little sense
these days.
2004-04-21 15:27:36 +00:00
|
|
|
int length = min(LEN(cp), LEN(cp2));
|
1995-04-28 23:01:37 +00:00
|
|
|
|
2009-12-10 10:34:30 +00:00
|
|
|
if (cp3 == NULL)
|
1995-04-28 23:01:37 +00:00
|
|
|
cp3 = rn_ones;
|
|
|
|
else
|
2009-12-10 10:34:30 +00:00
|
|
|
length = min(length, LEN(cp3));
|
1995-04-28 23:01:37 +00:00
|
|
|
cplim = cp + length; cp3 += skip; cp2 += skip;
|
|
|
|
for (cp += skip; cp < cplim; cp++, cp2++, cp3++)
|
|
|
|
if ((*cp ^ *cp2) & *cp3)
|
|
|
|
return 0;
|
|
|
|
return 1;
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
struct radix_node *
|
|
|
|
rn_match(v_arg, head)
|
|
|
|
void *v_arg;
|
|
|
|
struct radix_node_head *head;
|
|
|
|
{
|
|
|
|
caddr_t v = v_arg;
|
|
|
|
register struct radix_node *t = head->rnh_treetop, *x;
|
1995-04-28 23:01:37 +00:00
|
|
|
register caddr_t cp = v, cp2;
|
|
|
|
caddr_t cplim;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct radix_node *saved_t, *top = t;
|
Readability fixes:
Clearly comment the assumptions on the structure of keys (addresses)
and masks, and introduce a macro, LEN(p), to extract the size of these
objects instead of using *(u_char *)p which might be confusing.
Comment the confusion in the types used to pass around pointers
to keys and masks, as a reminder to fix that at some point.
Add a few comments on what some functions do.
Comment a probably inefficient (but still correct) section of code
in rn_walktree_from()
The object code generated after this commit is the same as before.
At some point we should also change same variable identifiers such
as "t, tt, ttt" to fancier names such as "root, left, right" (just
in case someone wants to understand the code!), replace misspelling
of NULL as 0, remove 'register' declarations that make little sense
these days.
2004-04-21 15:27:36 +00:00
|
|
|
int off = t->rn_offset, vlen = LEN(cp), matched_off;
|
2000-04-23 04:00:00 +00:00
|
|
|
register int test, b, rn_bit;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Open code rn_search(v, top) to avoid overhead of extra
|
|
|
|
* subroutine call.
|
|
|
|
*/
|
2000-04-23 04:00:00 +00:00
|
|
|
for (; t->rn_bit >= 0; ) {
|
|
|
|
if (t->rn_bmask & cp[t->rn_offset])
|
|
|
|
t = t->rn_right;
|
1994-05-24 10:09:53 +00:00
|
|
|
else
|
2000-04-23 04:00:00 +00:00
|
|
|
t = t->rn_left;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
/*
|
|
|
|
* See if we match exactly as a host destination
|
1995-04-28 23:01:37 +00:00
|
|
|
* or at least learn how many bits match, for normal mask finesse.
|
|
|
|
*
|
|
|
|
* It doesn't hurt us to limit how many bytes to check
|
|
|
|
* to the length of the mask, since if it matches we had a genuine
|
|
|
|
* match and the leaf we have is the most specific one anyway;
|
|
|
|
* if it didn't match with a shorter length it would fail
|
|
|
|
* with a long one. This wins big for class B&C netmasks which
|
|
|
|
* are probably the most common case...
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1995-04-28 23:01:37 +00:00
|
|
|
if (t->rn_mask)
|
|
|
|
vlen = *(u_char *)t->rn_mask;
|
1994-05-24 10:09:53 +00:00
|
|
|
cp += off; cp2 = t->rn_key + off; cplim = v + vlen;
|
|
|
|
for (; cp < cplim; cp++, cp2++)
|
|
|
|
if (*cp != *cp2)
|
|
|
|
goto on1;
|
|
|
|
/*
|
|
|
|
* This extra grot is in case we are explicitly asked
|
|
|
|
* to look up the default. Ugh!
|
1999-06-25 13:43:30 +00:00
|
|
|
*
|
|
|
|
* Never return the root node itself, it seems to cause a
|
|
|
|
* lot of confusion.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1999-06-25 13:43:30 +00:00
|
|
|
if (t->rn_flags & RNF_ROOT)
|
1994-05-24 10:09:53 +00:00
|
|
|
t = t->rn_dupedkey;
|
|
|
|
return t;
|
|
|
|
on1:
|
1995-04-28 23:01:37 +00:00
|
|
|
test = (*cp ^ *cp2) & 0xff; /* find first bit that differs */
|
|
|
|
for (b = 7; (test >>= 1) > 0;)
|
|
|
|
b--;
|
1994-05-24 10:09:53 +00:00
|
|
|
matched_off = cp - v;
|
1995-04-28 23:01:37 +00:00
|
|
|
b += matched_off << 3;
|
2000-04-23 04:00:00 +00:00
|
|
|
rn_bit = -1 - b;
|
1995-04-28 23:01:37 +00:00
|
|
|
/*
|
|
|
|
* If there is a host route in a duped-key chain, it will be first.
|
|
|
|
*/
|
|
|
|
if ((saved_t = t)->rn_mask == 0)
|
|
|
|
t = t->rn_dupedkey;
|
|
|
|
for (; t; t = t->rn_dupedkey)
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
1995-04-28 23:01:37 +00:00
|
|
|
* Even if we don't match exactly as a host,
|
1994-05-24 10:09:53 +00:00
|
|
|
* we may match if the leaf we wound up at is
|
|
|
|
* a route to a net.
|
|
|
|
*/
|
1995-04-28 23:01:37 +00:00
|
|
|
if (t->rn_flags & RNF_NORMAL) {
|
2000-04-23 04:00:00 +00:00
|
|
|
if (rn_bit <= t->rn_bit)
|
1995-04-28 23:01:37 +00:00
|
|
|
return t;
|
2002-12-25 11:40:53 +00:00
|
|
|
} else if (rn_satisfies_leaf(v, t, matched_off))
|
1995-04-28 23:01:37 +00:00
|
|
|
return t;
|
1994-05-24 10:09:53 +00:00
|
|
|
t = saved_t;
|
|
|
|
/* start searching up the tree */
|
|
|
|
do {
|
|
|
|
register struct radix_mask *m;
|
2000-04-23 04:00:00 +00:00
|
|
|
t = t->rn_parent;
|
1994-10-08 22:38:27 +00:00
|
|
|
m = t->rn_mklist;
|
2000-04-23 04:00:00 +00:00
|
|
|
/*
|
|
|
|
* If non-contiguous masks ever become important
|
|
|
|
* we can restore the masking and open coding of
|
|
|
|
* the search and satisfaction test and put the
|
|
|
|
* calculation of "off" back before the "do".
|
|
|
|
*/
|
|
|
|
while (m) {
|
|
|
|
if (m->rm_flags & RNF_NORMAL) {
|
|
|
|
if (rn_bit <= m->rm_bit)
|
|
|
|
return (m->rm_leaf);
|
|
|
|
} else {
|
|
|
|
off = min(t->rn_offset, matched_off);
|
|
|
|
x = rn_search_m(v, t, m->rm_mask);
|
|
|
|
while (x && x->rn_mask != m->rm_mask)
|
|
|
|
x = x->rn_dupedkey;
|
2002-12-25 11:40:53 +00:00
|
|
|
if (x && rn_satisfies_leaf(v, x, off))
|
2000-04-23 04:00:00 +00:00
|
|
|
return x;
|
|
|
|
}
|
|
|
|
m = m->rm_mklist;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
} while (t != top);
|
|
|
|
return 0;
|
1997-11-24 13:50:24 +00:00
|
|
|
}
|
1995-05-30 08:16:23 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
#ifdef RN_DEBUG
|
|
|
|
int rn_nodenum;
|
|
|
|
struct radix_node *rn_clist;
|
|
|
|
int rn_saveinfo;
|
|
|
|
int rn_debug = 1;
|
|
|
|
#endif
|
|
|
|
|
Readability fixes:
Clearly comment the assumptions on the structure of keys (addresses)
and masks, and introduce a macro, LEN(p), to extract the size of these
objects instead of using *(u_char *)p which might be confusing.
Comment the confusion in the types used to pass around pointers
to keys and masks, as a reminder to fix that at some point.
Add a few comments on what some functions do.
Comment a probably inefficient (but still correct) section of code
in rn_walktree_from()
The object code generated after this commit is the same as before.
At some point we should also change same variable identifiers such
as "t, tt, ttt" to fancier names such as "root, left, right" (just
in case someone wants to understand the code!), replace misspelling
of NULL as 0, remove 'register' declarations that make little sense
these days.
2004-04-21 15:27:36 +00:00
|
|
|
/*
|
|
|
|
* Whenever we add a new leaf to the tree, we also add a parent node,
|
|
|
|
* so we allocate them as an array of two elements: the first one must be
|
|
|
|
* the leaf (see RNTORT() in route.c), the second one is the parent.
|
|
|
|
* This routine initializes the relevant fields of the nodes, so that
|
|
|
|
* the leaf is the left child of the parent node, and both nodes have
|
|
|
|
* (almost) all all fields filled as appropriate.
|
|
|
|
* (XXX some fields are left unset, see the '#if 0' section).
|
|
|
|
* The function returns a pointer to the parent node.
|
|
|
|
*/
|
|
|
|
|
1995-12-14 09:55:16 +00:00
|
|
|
static struct radix_node *
|
1994-05-24 10:09:53 +00:00
|
|
|
rn_newpair(v, b, nodes)
|
|
|
|
void *v;
|
|
|
|
int b;
|
|
|
|
struct radix_node nodes[2];
|
|
|
|
{
|
|
|
|
register struct radix_node *tt = nodes, *t = tt + 1;
|
2000-04-23 04:00:00 +00:00
|
|
|
t->rn_bit = b;
|
|
|
|
t->rn_bmask = 0x80 >> (b & 7);
|
|
|
|
t->rn_left = tt;
|
|
|
|
t->rn_offset = b >> 3;
|
Readability fixes:
Clearly comment the assumptions on the structure of keys (addresses)
and masks, and introduce a macro, LEN(p), to extract the size of these
objects instead of using *(u_char *)p which might be confusing.
Comment the confusion in the types used to pass around pointers
to keys and masks, as a reminder to fix that at some point.
Add a few comments on what some functions do.
Comment a probably inefficient (but still correct) section of code
in rn_walktree_from()
The object code generated after this commit is the same as before.
At some point we should also change same variable identifiers such
as "t, tt, ttt" to fancier names such as "root, left, right" (just
in case someone wants to understand the code!), replace misspelling
of NULL as 0, remove 'register' declarations that make little sense
these days.
2004-04-21 15:27:36 +00:00
|
|
|
|
|
|
|
#if 0 /* XXX perhaps we should fill these fields as well. */
|
|
|
|
t->rn_parent = t->rn_right = NULL;
|
|
|
|
|
|
|
|
tt->rn_mask = NULL;
|
|
|
|
tt->rn_dupedkey = NULL;
|
|
|
|
tt->rn_bmask = 0;
|
|
|
|
#endif
|
2000-04-23 04:00:00 +00:00
|
|
|
tt->rn_bit = -1;
|
|
|
|
tt->rn_key = (caddr_t)v;
|
|
|
|
tt->rn_parent = t;
|
1994-05-24 10:09:53 +00:00
|
|
|
tt->rn_flags = t->rn_flags = RNF_ACTIVE;
|
2000-10-27 20:50:14 +00:00
|
|
|
tt->rn_mklist = t->rn_mklist = 0;
|
1994-05-24 10:09:53 +00:00
|
|
|
#ifdef RN_DEBUG
|
|
|
|
tt->rn_info = rn_nodenum++; t->rn_info = rn_nodenum++;
|
2000-04-23 04:00:00 +00:00
|
|
|
tt->rn_twin = t;
|
|
|
|
tt->rn_ybro = rn_clist;
|
|
|
|
rn_clist = tt;
|
1994-05-24 10:09:53 +00:00
|
|
|
#endif
|
|
|
|
return t;
|
|
|
|
}
|
|
|
|
|
1995-12-14 09:55:16 +00:00
|
|
|
static struct radix_node *
|
1994-05-24 10:09:53 +00:00
|
|
|
rn_insert(v_arg, head, dupentry, nodes)
|
|
|
|
void *v_arg;
|
|
|
|
struct radix_node_head *head;
|
|
|
|
int *dupentry;
|
|
|
|
struct radix_node nodes[2];
|
|
|
|
{
|
|
|
|
caddr_t v = v_arg;
|
|
|
|
struct radix_node *top = head->rnh_treetop;
|
2009-12-10 10:34:30 +00:00
|
|
|
int head_off = top->rn_offset, vlen = LEN(v);
|
1994-05-24 10:09:53 +00:00
|
|
|
register struct radix_node *t = rn_search(v_arg, top);
|
|
|
|
register caddr_t cp = v + head_off;
|
|
|
|
register int b;
|
|
|
|
struct radix_node *tt;
|
|
|
|
/*
|
1995-04-28 23:01:37 +00:00
|
|
|
* Find first bit at which v and t->rn_key differ
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
{
|
|
|
|
register caddr_t cp2 = t->rn_key + head_off;
|
|
|
|
register int cmp_res;
|
|
|
|
caddr_t cplim = v + vlen;
|
|
|
|
|
|
|
|
while (cp < cplim)
|
|
|
|
if (*cp2++ != *cp++)
|
|
|
|
goto on1;
|
|
|
|
*dupentry = 1;
|
|
|
|
return t;
|
|
|
|
on1:
|
|
|
|
*dupentry = 0;
|
|
|
|
cmp_res = (cp[-1] ^ cp2[-1]) & 0xff;
|
|
|
|
for (b = (cp - v) << 3; cmp_res; b--)
|
|
|
|
cmp_res >>= 1;
|
|
|
|
}
|
|
|
|
{
|
|
|
|
register struct radix_node *p, *x = top;
|
|
|
|
cp = v;
|
|
|
|
do {
|
|
|
|
p = x;
|
2000-04-23 04:00:00 +00:00
|
|
|
if (cp[x->rn_offset] & x->rn_bmask)
|
|
|
|
x = x->rn_right;
|
|
|
|
else
|
|
|
|
x = x->rn_left;
|
|
|
|
} while (b > (unsigned) x->rn_bit);
|
|
|
|
/* x->rn_bit < b && x->rn_bit >= 0 */
|
1994-05-24 10:09:53 +00:00
|
|
|
#ifdef RN_DEBUG
|
|
|
|
if (rn_debug)
|
1995-04-28 23:01:37 +00:00
|
|
|
log(LOG_DEBUG, "rn_insert: Going In:\n"), traverse(p);
|
1994-05-24 10:09:53 +00:00
|
|
|
#endif
|
2000-04-23 04:00:00 +00:00
|
|
|
t = rn_newpair(v_arg, b, nodes);
|
|
|
|
tt = t->rn_left;
|
|
|
|
if ((cp[p->rn_offset] & p->rn_bmask) == 0)
|
|
|
|
p->rn_left = t;
|
1994-05-24 10:09:53 +00:00
|
|
|
else
|
2000-04-23 04:00:00 +00:00
|
|
|
p->rn_right = t;
|
|
|
|
x->rn_parent = t;
|
|
|
|
t->rn_parent = p; /* frees x, p as temp vars below */
|
|
|
|
if ((cp[t->rn_offset] & t->rn_bmask) == 0) {
|
|
|
|
t->rn_right = x;
|
1994-05-24 10:09:53 +00:00
|
|
|
} else {
|
2000-04-23 04:00:00 +00:00
|
|
|
t->rn_right = tt;
|
|
|
|
t->rn_left = x;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
#ifdef RN_DEBUG
|
|
|
|
if (rn_debug)
|
1995-04-28 23:01:37 +00:00
|
|
|
log(LOG_DEBUG, "rn_insert: Coming Out:\n"), traverse(p);
|
1994-05-24 10:09:53 +00:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
return (tt);
|
|
|
|
}
|
|
|
|
|
|
|
|
struct radix_node *
|
|
|
|
rn_addmask(n_arg, search, skip)
|
|
|
|
int search, skip;
|
|
|
|
void *n_arg;
|
|
|
|
{
|
|
|
|
caddr_t netmask = (caddr_t)n_arg;
|
|
|
|
register struct radix_node *x;
|
|
|
|
register caddr_t cp, cplim;
|
1995-04-28 23:01:37 +00:00
|
|
|
register int b = 0, mlen, j;
|
|
|
|
int maskduplicated, m0, isnormal;
|
|
|
|
struct radix_node *saved_x;
|
|
|
|
static int last_zeroed = 0;
|
|
|
|
|
Readability fixes:
Clearly comment the assumptions on the structure of keys (addresses)
and masks, and introduce a macro, LEN(p), to extract the size of these
objects instead of using *(u_char *)p which might be confusing.
Comment the confusion in the types used to pass around pointers
to keys and masks, as a reminder to fix that at some point.
Add a few comments on what some functions do.
Comment a probably inefficient (but still correct) section of code
in rn_walktree_from()
The object code generated after this commit is the same as before.
At some point we should also change same variable identifiers such
as "t, tt, ttt" to fancier names such as "root, left, right" (just
in case someone wants to understand the code!), replace misspelling
of NULL as 0, remove 'register' declarations that make little sense
these days.
2004-04-21 15:27:36 +00:00
|
|
|
if ((mlen = LEN(netmask)) > max_keylen)
|
1995-04-28 23:01:37 +00:00
|
|
|
mlen = max_keylen;
|
|
|
|
if (skip == 0)
|
|
|
|
skip = 1;
|
|
|
|
if (mlen <= skip)
|
|
|
|
return (mask_rnhead->rnh_nodes);
|
|
|
|
if (skip > 1)
|
2004-04-18 11:48:35 +00:00
|
|
|
bcopy(rn_ones + 1, addmask_key + 1, skip - 1);
|
1995-04-28 23:01:37 +00:00
|
|
|
if ((m0 = mlen) > skip)
|
2004-04-18 11:48:35 +00:00
|
|
|
bcopy(netmask + skip, addmask_key + skip, mlen - skip);
|
1995-04-28 23:01:37 +00:00
|
|
|
/*
|
|
|
|
* Trim trailing zeroes.
|
|
|
|
*/
|
|
|
|
for (cp = addmask_key + mlen; (cp > addmask_key) && cp[-1] == 0;)
|
|
|
|
cp--;
|
|
|
|
mlen = cp - addmask_key;
|
|
|
|
if (mlen <= skip) {
|
|
|
|
if (m0 >= last_zeroed)
|
|
|
|
last_zeroed = mlen;
|
|
|
|
return (mask_rnhead->rnh_nodes);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
1995-04-28 23:01:37 +00:00
|
|
|
if (m0 < last_zeroed)
|
2004-04-18 11:48:35 +00:00
|
|
|
bzero(addmask_key + m0, last_zeroed - m0);
|
1995-04-28 23:01:37 +00:00
|
|
|
*addmask_key = last_zeroed = mlen;
|
|
|
|
x = rn_search(addmask_key, rn_masktop);
|
2004-04-18 11:48:35 +00:00
|
|
|
if (bcmp(addmask_key, x->rn_key, mlen) != 0)
|
1995-04-28 23:01:37 +00:00
|
|
|
x = 0;
|
|
|
|
if (x || search)
|
|
|
|
return (x);
|
2004-04-19 17:28:39 +00:00
|
|
|
R_Zalloc(x, struct radix_node *, max_keylen + 2 * sizeof (*x));
|
1995-04-28 23:01:37 +00:00
|
|
|
if ((saved_x = x) == 0)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (0);
|
1995-04-28 23:01:37 +00:00
|
|
|
netmask = cp = (caddr_t)(x + 2);
|
2004-04-18 11:48:35 +00:00
|
|
|
bcopy(addmask_key, cp, mlen);
|
1995-04-28 23:01:37 +00:00
|
|
|
x = rn_insert(cp, mask_rnhead, &maskduplicated, x);
|
|
|
|
if (maskduplicated) {
|
|
|
|
log(LOG_ERR, "rn_addmask: mask impossibly already in tree");
|
|
|
|
Free(saved_x);
|
|
|
|
return (x);
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
1995-04-28 23:01:37 +00:00
|
|
|
* Calculate index of mask, and check for normalcy.
|
2004-04-19 17:28:39 +00:00
|
|
|
* First find the first byte with a 0 bit, then if there are
|
|
|
|
* more bits left (remember we already trimmed the trailing 0's),
|
|
|
|
* the pattern must be one of those in normal_chars[], or we have
|
|
|
|
* a non-contiguous mask.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
2004-04-19 17:28:39 +00:00
|
|
|
cplim = netmask + mlen;
|
|
|
|
isnormal = 1;
|
1995-04-28 23:01:37 +00:00
|
|
|
for (cp = netmask + skip; (cp < cplim) && *(u_char *)cp == 0xff;)
|
|
|
|
cp++;
|
1994-05-24 10:09:53 +00:00
|
|
|
if (cp != cplim) {
|
2004-04-19 17:28:39 +00:00
|
|
|
static char normal_chars[] = {
|
|
|
|
0, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff};
|
|
|
|
|
1995-05-30 08:16:23 +00:00
|
|
|
for (j = 0x80; (j & *cp) != 0; j >>= 1)
|
1995-04-28 23:01:37 +00:00
|
|
|
b++;
|
|
|
|
if (*cp != normal_chars[b] || cp != (cplim - 1))
|
|
|
|
isnormal = 0;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
1995-04-28 23:01:37 +00:00
|
|
|
b += (cp - netmask) << 3;
|
2000-04-23 04:00:00 +00:00
|
|
|
x->rn_bit = -1 - b;
|
1995-04-28 23:01:37 +00:00
|
|
|
if (isnormal)
|
|
|
|
x->rn_flags |= RNF_NORMAL;
|
1994-05-24 10:09:53 +00:00
|
|
|
return (x);
|
|
|
|
}
|
|
|
|
|
1995-04-28 23:01:37 +00:00
|
|
|
static int /* XXX: arbitrary ordering for non-contiguous masks */
|
|
|
|
rn_lexobetter(m_arg, n_arg)
|
|
|
|
void *m_arg, *n_arg;
|
|
|
|
{
|
|
|
|
register u_char *mp = m_arg, *np = n_arg, *lim;
|
|
|
|
|
Readability fixes:
Clearly comment the assumptions on the structure of keys (addresses)
and masks, and introduce a macro, LEN(p), to extract the size of these
objects instead of using *(u_char *)p which might be confusing.
Comment the confusion in the types used to pass around pointers
to keys and masks, as a reminder to fix that at some point.
Add a few comments on what some functions do.
Comment a probably inefficient (but still correct) section of code
in rn_walktree_from()
The object code generated after this commit is the same as before.
At some point we should also change same variable identifiers such
as "t, tt, ttt" to fancier names such as "root, left, right" (just
in case someone wants to understand the code!), replace misspelling
of NULL as 0, remove 'register' declarations that make little sense
these days.
2004-04-21 15:27:36 +00:00
|
|
|
if (LEN(mp) > LEN(np))
|
1995-04-28 23:01:37 +00:00
|
|
|
return 1; /* not really, but need to check longer one first */
|
Readability fixes:
Clearly comment the assumptions on the structure of keys (addresses)
and masks, and introduce a macro, LEN(p), to extract the size of these
objects instead of using *(u_char *)p which might be confusing.
Comment the confusion in the types used to pass around pointers
to keys and masks, as a reminder to fix that at some point.
Add a few comments on what some functions do.
Comment a probably inefficient (but still correct) section of code
in rn_walktree_from()
The object code generated after this commit is the same as before.
At some point we should also change same variable identifiers such
as "t, tt, ttt" to fancier names such as "root, left, right" (just
in case someone wants to understand the code!), replace misspelling
of NULL as 0, remove 'register' declarations that make little sense
these days.
2004-04-21 15:27:36 +00:00
|
|
|
if (LEN(mp) == LEN(np))
|
|
|
|
for (lim = mp + LEN(mp); mp < lim;)
|
1995-04-28 23:01:37 +00:00
|
|
|
if (*mp++ > *np++)
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct radix_mask *
|
|
|
|
rn_new_radix_mask(tt, next)
|
|
|
|
register struct radix_node *tt;
|
|
|
|
register struct radix_mask *next;
|
|
|
|
{
|
|
|
|
register struct radix_mask *m;
|
|
|
|
|
|
|
|
MKGet(m);
|
|
|
|
if (m == 0) {
|
|
|
|
log(LOG_ERR, "Mask for route not entered\n");
|
|
|
|
return (0);
|
|
|
|
}
|
2004-04-18 11:48:35 +00:00
|
|
|
bzero(m, sizeof *m);
|
2000-04-23 04:00:00 +00:00
|
|
|
m->rm_bit = tt->rn_bit;
|
1995-04-28 23:01:37 +00:00
|
|
|
m->rm_flags = tt->rn_flags;
|
|
|
|
if (tt->rn_flags & RNF_NORMAL)
|
|
|
|
m->rm_leaf = tt;
|
|
|
|
else
|
|
|
|
m->rm_mask = tt->rn_mask;
|
|
|
|
m->rm_mklist = next;
|
|
|
|
tt->rn_mklist = m;
|
|
|
|
return m;
|
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
struct radix_node *
|
|
|
|
rn_addroute(v_arg, n_arg, head, treenodes)
|
|
|
|
void *v_arg, *n_arg;
|
|
|
|
struct radix_node_head *head;
|
|
|
|
struct radix_node treenodes[2];
|
|
|
|
{
|
|
|
|
caddr_t v = (caddr_t)v_arg, netmask = (caddr_t)n_arg;
|
1994-05-25 09:21:21 +00:00
|
|
|
register struct radix_node *t, *x = 0, *tt;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct radix_node *saved_tt, *top = head->rnh_treetop;
|
1995-04-28 23:01:37 +00:00
|
|
|
short b = 0, b_leaf = 0;
|
|
|
|
int keyduplicated;
|
|
|
|
caddr_t mmask;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct radix_mask *m, **mp;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* In dealing with non-contiguous masks, there may be
|
|
|
|
* many different routes which have the same mask.
|
|
|
|
* We will find it useful to have a unique pointer to
|
|
|
|
* the mask to speed avoiding duplicate references at
|
|
|
|
* nodes and possibly save time in calculating indices.
|
|
|
|
*/
|
|
|
|
if (netmask) {
|
2000-04-23 04:00:00 +00:00
|
|
|
if ((x = rn_addmask(netmask, 0, top->rn_offset)) == 0)
|
1995-04-28 23:01:37 +00:00
|
|
|
return (0);
|
2000-04-23 04:00:00 +00:00
|
|
|
b_leaf = x->rn_bit;
|
|
|
|
b = -1 - x->rn_bit;
|
1995-04-28 23:01:37 +00:00
|
|
|
netmask = x->rn_key;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Deal with duplicated keys: attach node to previous instance
|
|
|
|
*/
|
|
|
|
saved_tt = tt = rn_insert(v, head, &keyduplicated, treenodes);
|
|
|
|
if (keyduplicated) {
|
1995-04-28 23:01:37 +00:00
|
|
|
for (t = tt; tt; t = tt, tt = tt->rn_dupedkey) {
|
This patch provides the back end support for equal-cost multi-path
(ECMP) for both IPv4 and IPv6. Previously, multipath route insertion
is disallowed. For example,
route add -net 192.103.54.0/24 10.9.44.1
route add -net 192.103.54.0/24 10.9.44.2
The second route insertion will trigger an error message of
"add net 192.103.54.0/24: gateway 10.2.5.2: route already in table"
Multiple default routes can also be inserted. Here is the netstat
output:
default 10.2.5.1 UGS 0 3074 bge0 =>
default 10.2.5.2 UGS 0 0 bge0
When multipath routes exist, the "route delete" command requires
a specific gateway to be specified or else an error message would
be displayed. For example,
route delete default
would fail and trigger the following error message:
"route: writing to routing socket: No such process"
"delete net default: not in table"
On the other hand,
route delete default 10.2.5.2
would be successful: "delete net default: gateway 10.2.5.2"
One does not have to specify a gateway if there is only a single
route for a particular destination.
I need to perform more testings on address aliases and multiple
interfaces that have the same IP prefixes. This patch as it
stands today is not yet ready for prime time. Therefore, the ECMP
code fragments are fully guarded by the RADIX_MPATH macro.
Include the "options RADIX_MPATH" in the kernel configuration
to enable this feature.
Reviewed by: robert, sam, gnn, julian, kmacy
2008-04-13 05:45:14 +00:00
|
|
|
#ifdef RADIX_MPATH
|
|
|
|
/* permit multipath, if enabled for the family */
|
|
|
|
if (rn_mpath_capable(head) && netmask == tt->rn_mask) {
|
|
|
|
/*
|
|
|
|
* go down to the end of multipaths, so that
|
|
|
|
* new entry goes into the end of rn_dupedkey
|
|
|
|
* chain.
|
|
|
|
*/
|
|
|
|
do {
|
|
|
|
t = tt;
|
|
|
|
tt = tt->rn_dupedkey;
|
|
|
|
} while (tt && t->rn_mask == tt->rn_mask);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
if (tt->rn_mask == netmask)
|
|
|
|
return (0);
|
|
|
|
if (netmask == 0 ||
|
1995-04-28 23:01:37 +00:00
|
|
|
(tt->rn_mask &&
|
2000-04-23 04:00:00 +00:00
|
|
|
((b_leaf < tt->rn_bit) /* index(netmask) > node */
|
|
|
|
|| rn_refines(netmask, tt->rn_mask)
|
|
|
|
|| rn_lexobetter(netmask, tt->rn_mask))))
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
1995-04-28 23:01:37 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* If the mask is not duplicated, we wouldn't
|
|
|
|
* find it among possible duplicate key entries
|
|
|
|
* anyway, so the above test doesn't hurt.
|
|
|
|
*
|
|
|
|
* We sort the masks for a duplicated key the same way as
|
|
|
|
* in a masklist -- most specific to least specific.
|
|
|
|
* This may require the unfortunate nuisance of relocating
|
|
|
|
* the head of the list.
|
2002-12-25 09:16:58 +00:00
|
|
|
*
|
|
|
|
* We also reverse, or doubly link the list through the
|
|
|
|
* parent pointer.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1995-04-28 23:01:37 +00:00
|
|
|
if (tt == saved_tt) {
|
1994-05-24 10:09:53 +00:00
|
|
|
struct radix_node *xx = x;
|
|
|
|
/* link in at head of list */
|
|
|
|
(tt = treenodes)->rn_dupedkey = t;
|
|
|
|
tt->rn_flags = t->rn_flags;
|
2000-04-23 04:00:00 +00:00
|
|
|
tt->rn_parent = x = t->rn_parent;
|
|
|
|
t->rn_parent = tt; /* parent */
|
|
|
|
if (x->rn_left == t)
|
|
|
|
x->rn_left = tt;
|
|
|
|
else
|
|
|
|
x->rn_right = tt;
|
1994-05-24 10:09:53 +00:00
|
|
|
saved_tt = tt; x = xx;
|
|
|
|
} else {
|
|
|
|
(tt = treenodes)->rn_dupedkey = t->rn_dupedkey;
|
|
|
|
t->rn_dupedkey = tt;
|
2000-04-23 04:00:00 +00:00
|
|
|
tt->rn_parent = t; /* parent */
|
1995-04-28 23:01:37 +00:00
|
|
|
if (tt->rn_dupedkey) /* parent */
|
2000-04-23 04:00:00 +00:00
|
|
|
tt->rn_dupedkey->rn_parent = tt; /* parent */
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
#ifdef RN_DEBUG
|
|
|
|
t=tt+1; tt->rn_info = rn_nodenum++; t->rn_info = rn_nodenum++;
|
|
|
|
tt->rn_twin = t; tt->rn_ybro = rn_clist; rn_clist = tt;
|
|
|
|
#endif
|
|
|
|
tt->rn_key = (caddr_t) v;
|
2000-04-23 04:00:00 +00:00
|
|
|
tt->rn_bit = -1;
|
1995-04-28 23:01:37 +00:00
|
|
|
tt->rn_flags = RNF_ACTIVE;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Put mask in tree.
|
|
|
|
*/
|
|
|
|
if (netmask) {
|
|
|
|
tt->rn_mask = netmask;
|
2000-04-23 04:00:00 +00:00
|
|
|
tt->rn_bit = x->rn_bit;
|
1995-04-28 23:01:37 +00:00
|
|
|
tt->rn_flags |= x->rn_flags & RNF_NORMAL;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2000-04-23 04:00:00 +00:00
|
|
|
t = saved_tt->rn_parent;
|
1995-04-28 23:01:37 +00:00
|
|
|
if (keyduplicated)
|
|
|
|
goto on2;
|
2000-04-23 04:00:00 +00:00
|
|
|
b_leaf = -1 - t->rn_bit;
|
|
|
|
if (t->rn_right == saved_tt)
|
|
|
|
x = t->rn_left;
|
|
|
|
else
|
|
|
|
x = t->rn_right;
|
1994-05-24 10:09:53 +00:00
|
|
|
/* Promote general routes from below */
|
2000-04-23 04:00:00 +00:00
|
|
|
if (x->rn_bit < 0) {
|
1995-04-28 23:01:37 +00:00
|
|
|
for (mp = &t->rn_mklist; x; x = x->rn_dupedkey)
|
2000-04-23 04:00:00 +00:00
|
|
|
if (x->rn_mask && (x->rn_bit >= b_leaf) && x->rn_mklist == 0) {
|
1995-04-28 23:01:37 +00:00
|
|
|
*mp = m = rn_new_radix_mask(x, 0);
|
|
|
|
if (m)
|
|
|
|
mp = &m->rm_mklist;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
} else if (x->rn_mklist) {
|
|
|
|
/*
|
|
|
|
* Skip over masks whose index is > that of new node
|
|
|
|
*/
|
1995-04-28 23:01:37 +00:00
|
|
|
for (mp = &x->rn_mklist; (m = *mp); mp = &m->rm_mklist)
|
2000-04-23 04:00:00 +00:00
|
|
|
if (m->rm_bit >= b_leaf)
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
|
|
|
t->rn_mklist = m; *mp = 0;
|
|
|
|
}
|
1995-04-28 23:01:37 +00:00
|
|
|
on2:
|
1994-05-24 10:09:53 +00:00
|
|
|
/* Add new route to highest possible ancestor's list */
|
2000-04-23 04:00:00 +00:00
|
|
|
if ((netmask == 0) || (b > t->rn_bit ))
|
1994-05-24 10:09:53 +00:00
|
|
|
return tt; /* can't lift at all */
|
2000-04-23 04:00:00 +00:00
|
|
|
b_leaf = tt->rn_bit;
|
1994-05-24 10:09:53 +00:00
|
|
|
do {
|
|
|
|
x = t;
|
2000-04-23 04:00:00 +00:00
|
|
|
t = t->rn_parent;
|
|
|
|
} while (b <= t->rn_bit && x != top);
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Search through routes associated with node to
|
|
|
|
* insert new route according to index.
|
1995-04-28 23:01:37 +00:00
|
|
|
* Need same criteria as when sorting dupedkeys to avoid
|
|
|
|
* double loop on deletion.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1995-04-28 23:01:37 +00:00
|
|
|
for (mp = &x->rn_mklist; (m = *mp); mp = &m->rm_mklist) {
|
2000-04-23 04:00:00 +00:00
|
|
|
if (m->rm_bit < b_leaf)
|
1994-05-24 10:09:53 +00:00
|
|
|
continue;
|
2000-04-23 04:00:00 +00:00
|
|
|
if (m->rm_bit > b_leaf)
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
1995-04-28 23:01:37 +00:00
|
|
|
if (m->rm_flags & RNF_NORMAL) {
|
|
|
|
mmask = m->rm_leaf->rn_mask;
|
|
|
|
if (tt->rn_flags & RNF_NORMAL) {
|
2010-03-09 01:11:45 +00:00
|
|
|
#if !defined(RADIX_MPATH)
|
2000-04-23 04:00:00 +00:00
|
|
|
log(LOG_ERR,
|
2002-04-19 04:46:24 +00:00
|
|
|
"Non-unique normal route, mask not entered\n");
|
2010-03-09 01:11:45 +00:00
|
|
|
#endif
|
1995-04-28 23:01:37 +00:00
|
|
|
return tt;
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
mmask = m->rm_mask;
|
|
|
|
if (mmask == netmask) {
|
1994-05-24 10:09:53 +00:00
|
|
|
m->rm_refs++;
|
|
|
|
tt->rn_mklist = m;
|
|
|
|
return tt;
|
|
|
|
}
|
2000-04-23 04:00:00 +00:00
|
|
|
if (rn_refines(netmask, mmask)
|
|
|
|
|| rn_lexobetter(netmask, mmask))
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
|
|
|
}
|
1995-04-28 23:01:37 +00:00
|
|
|
*mp = rn_new_radix_mask(tt, *mp);
|
1994-05-24 10:09:53 +00:00
|
|
|
return tt;
|
|
|
|
}
|
|
|
|
|
1997-11-24 13:50:24 +00:00
|
|
|
struct radix_node *
|
1994-05-24 10:09:53 +00:00
|
|
|
rn_delete(v_arg, netmask_arg, head)
|
|
|
|
void *v_arg, *netmask_arg;
|
|
|
|
struct radix_node_head *head;
|
|
|
|
{
|
|
|
|
register struct radix_node *t, *p, *x, *tt;
|
|
|
|
struct radix_mask *m, *saved_m, **mp;
|
|
|
|
struct radix_node *dupedkey, *saved_tt, *top;
|
|
|
|
caddr_t v, netmask;
|
|
|
|
int b, head_off, vlen;
|
|
|
|
|
|
|
|
v = v_arg;
|
|
|
|
netmask = netmask_arg;
|
|
|
|
x = head->rnh_treetop;
|
|
|
|
tt = rn_search(v, x);
|
2000-04-23 04:00:00 +00:00
|
|
|
head_off = x->rn_offset;
|
Readability fixes:
Clearly comment the assumptions on the structure of keys (addresses)
and masks, and introduce a macro, LEN(p), to extract the size of these
objects instead of using *(u_char *)p which might be confusing.
Comment the confusion in the types used to pass around pointers
to keys and masks, as a reminder to fix that at some point.
Add a few comments on what some functions do.
Comment a probably inefficient (but still correct) section of code
in rn_walktree_from()
The object code generated after this commit is the same as before.
At some point we should also change same variable identifiers such
as "t, tt, ttt" to fancier names such as "root, left, right" (just
in case someone wants to understand the code!), replace misspelling
of NULL as 0, remove 'register' declarations that make little sense
these days.
2004-04-21 15:27:36 +00:00
|
|
|
vlen = LEN(v);
|
1994-05-24 10:09:53 +00:00
|
|
|
saved_tt = tt;
|
|
|
|
top = x;
|
|
|
|
if (tt == 0 ||
|
2004-04-18 11:48:35 +00:00
|
|
|
bcmp(v + head_off, tt->rn_key + head_off, vlen - head_off))
|
1994-05-24 10:09:53 +00:00
|
|
|
return (0);
|
|
|
|
/*
|
|
|
|
* Delete our route from mask lists.
|
|
|
|
*/
|
1995-04-28 23:01:37 +00:00
|
|
|
if (netmask) {
|
|
|
|
if ((x = rn_addmask(netmask, 1, head_off)) == 0)
|
|
|
|
return (0);
|
|
|
|
netmask = x->rn_key;
|
1994-05-24 10:09:53 +00:00
|
|
|
while (tt->rn_mask != netmask)
|
|
|
|
if ((tt = tt->rn_dupedkey) == 0)
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
if (tt->rn_mask == 0 || (saved_m = m = tt->rn_mklist) == 0)
|
|
|
|
goto on1;
|
1995-04-28 23:01:37 +00:00
|
|
|
if (tt->rn_flags & RNF_NORMAL) {
|
|
|
|
if (m->rm_leaf != tt || m->rm_refs > 0) {
|
|
|
|
log(LOG_ERR, "rn_delete: inconsistent annotation\n");
|
|
|
|
return 0; /* dangling ref could cause disaster */
|
|
|
|
}
|
1995-05-30 08:16:23 +00:00
|
|
|
} else {
|
1995-04-28 23:01:37 +00:00
|
|
|
if (m->rm_mask != tt->rn_mask) {
|
|
|
|
log(LOG_ERR, "rn_delete: inconsistent annotation\n");
|
|
|
|
goto on1;
|
|
|
|
}
|
|
|
|
if (--m->rm_refs >= 0)
|
|
|
|
goto on1;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2000-04-23 04:00:00 +00:00
|
|
|
b = -1 - tt->rn_bit;
|
|
|
|
t = saved_tt->rn_parent;
|
|
|
|
if (b > t->rn_bit)
|
1994-05-24 10:09:53 +00:00
|
|
|
goto on1; /* Wasn't lifted at all */
|
|
|
|
do {
|
|
|
|
x = t;
|
2000-04-23 04:00:00 +00:00
|
|
|
t = t->rn_parent;
|
|
|
|
} while (b <= t->rn_bit && x != top);
|
1995-04-28 23:01:37 +00:00
|
|
|
for (mp = &x->rn_mklist; (m = *mp); mp = &m->rm_mklist)
|
1994-05-24 10:09:53 +00:00
|
|
|
if (m == saved_m) {
|
|
|
|
*mp = m->rm_mklist;
|
|
|
|
MKFree(m);
|
|
|
|
break;
|
|
|
|
}
|
1995-04-28 23:01:37 +00:00
|
|
|
if (m == 0) {
|
|
|
|
log(LOG_ERR, "rn_delete: couldn't find our annotation\n");
|
|
|
|
if (tt->rn_flags & RNF_NORMAL)
|
|
|
|
return (0); /* Dangling ref to us */
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
on1:
|
|
|
|
/*
|
|
|
|
* Eliminate us from tree
|
|
|
|
*/
|
|
|
|
if (tt->rn_flags & RNF_ROOT)
|
|
|
|
return (0);
|
|
|
|
#ifdef RN_DEBUG
|
|
|
|
/* Get us out of the creation list */
|
|
|
|
for (t = rn_clist; t && t->rn_ybro != tt; t = t->rn_ybro) {}
|
|
|
|
if (t) t->rn_ybro = tt->rn_ybro;
|
|
|
|
#endif
|
2000-04-23 04:00:00 +00:00
|
|
|
t = tt->rn_parent;
|
1995-04-28 23:01:37 +00:00
|
|
|
dupedkey = saved_tt->rn_dupedkey;
|
1994-05-24 10:09:53 +00:00
|
|
|
if (dupedkey) {
|
1995-04-28 23:01:37 +00:00
|
|
|
/*
|
2002-12-25 09:16:58 +00:00
|
|
|
* Here, tt is the deletion target and
|
|
|
|
* saved_tt is the head of the dupekey chain.
|
1995-04-28 23:01:37 +00:00
|
|
|
*/
|
1994-05-24 10:09:53 +00:00
|
|
|
if (tt == saved_tt) {
|
1995-04-28 23:01:37 +00:00
|
|
|
/* remove from head of chain */
|
2000-04-23 04:00:00 +00:00
|
|
|
x = dupedkey; x->rn_parent = t;
|
|
|
|
if (t->rn_left == tt)
|
|
|
|
t->rn_left = x;
|
|
|
|
else
|
|
|
|
t->rn_right = x;
|
1994-05-24 10:09:53 +00:00
|
|
|
} else {
|
1995-04-28 23:01:37 +00:00
|
|
|
/* find node in front of tt on the chain */
|
1994-05-24 10:09:53 +00:00
|
|
|
for (x = p = saved_tt; p && p->rn_dupedkey != tt;)
|
|
|
|
p = p->rn_dupedkey;
|
1995-04-28 23:01:37 +00:00
|
|
|
if (p) {
|
|
|
|
p->rn_dupedkey = tt->rn_dupedkey;
|
2000-04-23 04:00:00 +00:00
|
|
|
if (tt->rn_dupedkey) /* parent */
|
|
|
|
tt->rn_dupedkey->rn_parent = p;
|
|
|
|
/* parent */
|
1995-04-28 23:01:37 +00:00
|
|
|
} else log(LOG_ERR, "rn_delete: couldn't find us\n");
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
t = tt + 1;
|
|
|
|
if (t->rn_flags & RNF_ACTIVE) {
|
|
|
|
#ifndef RN_DEBUG
|
2000-04-23 04:00:00 +00:00
|
|
|
*++x = *t;
|
|
|
|
p = t->rn_parent;
|
1994-05-24 10:09:53 +00:00
|
|
|
#else
|
2000-04-23 04:00:00 +00:00
|
|
|
b = t->rn_info;
|
|
|
|
*++x = *t;
|
|
|
|
t->rn_info = b;
|
|
|
|
p = t->rn_parent;
|
1994-05-24 10:09:53 +00:00
|
|
|
#endif
|
2000-04-23 04:00:00 +00:00
|
|
|
if (p->rn_left == t)
|
|
|
|
p->rn_left = x;
|
|
|
|
else
|
|
|
|
p->rn_right = x;
|
|
|
|
x->rn_left->rn_parent = x;
|
|
|
|
x->rn_right->rn_parent = x;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
goto out;
|
|
|
|
}
|
2000-04-23 04:00:00 +00:00
|
|
|
if (t->rn_left == tt)
|
|
|
|
x = t->rn_right;
|
|
|
|
else
|
|
|
|
x = t->rn_left;
|
|
|
|
p = t->rn_parent;
|
|
|
|
if (p->rn_right == t)
|
|
|
|
p->rn_right = x;
|
|
|
|
else
|
|
|
|
p->rn_left = x;
|
|
|
|
x->rn_parent = p;
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Demote routes attached to us.
|
|
|
|
*/
|
|
|
|
if (t->rn_mklist) {
|
2000-04-23 04:00:00 +00:00
|
|
|
if (x->rn_bit >= 0) {
|
1995-04-28 23:01:37 +00:00
|
|
|
for (mp = &x->rn_mklist; (m = *mp);)
|
1994-05-24 10:09:53 +00:00
|
|
|
mp = &m->rm_mklist;
|
|
|
|
*mp = t->rn_mklist;
|
|
|
|
} else {
|
1995-04-28 23:01:37 +00:00
|
|
|
/* If there are any key,mask pairs in a sibling
|
|
|
|
duped-key chain, some subset will appear sorted
|
|
|
|
in the same order attached to our mklist */
|
|
|
|
for (m = t->rn_mklist; m && x; x = x->rn_dupedkey)
|
|
|
|
if (m == x->rn_mklist) {
|
|
|
|
struct radix_mask *mm = m->rm_mklist;
|
1994-05-24 10:09:53 +00:00
|
|
|
x->rn_mklist = 0;
|
1995-04-28 23:01:37 +00:00
|
|
|
if (--(m->rm_refs) < 0)
|
|
|
|
MKFree(m);
|
|
|
|
m = mm;
|
|
|
|
}
|
|
|
|
if (m)
|
1998-07-11 10:51:01 +00:00
|
|
|
log(LOG_ERR,
|
|
|
|
"rn_delete: Orphaned Mask %p at %p\n",
|
2010-03-02 16:24:16 +00:00
|
|
|
m, x);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* We may be holding an active internal node in the tree.
|
|
|
|
*/
|
|
|
|
x = tt + 1;
|
|
|
|
if (t != x) {
|
|
|
|
#ifndef RN_DEBUG
|
|
|
|
*t = *x;
|
|
|
|
#else
|
2000-04-23 04:00:00 +00:00
|
|
|
b = t->rn_info;
|
|
|
|
*t = *x;
|
|
|
|
t->rn_info = b;
|
1994-05-24 10:09:53 +00:00
|
|
|
#endif
|
2000-04-23 04:00:00 +00:00
|
|
|
t->rn_left->rn_parent = t;
|
|
|
|
t->rn_right->rn_parent = t;
|
|
|
|
p = x->rn_parent;
|
|
|
|
if (p->rn_left == x)
|
|
|
|
p->rn_left = t;
|
|
|
|
else
|
|
|
|
p->rn_right = t;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
out:
|
|
|
|
tt->rn_flags &= ~RNF_ACTIVE;
|
|
|
|
tt[1].rn_flags &= ~RNF_ACTIVE;
|
|
|
|
return (tt);
|
|
|
|
}
|
|
|
|
|
1995-03-20 21:30:21 +00:00
|
|
|
/*
|
|
|
|
* This is the same as rn_walktree() except for the parameters and the
|
|
|
|
* exit.
|
|
|
|
*/
|
1995-12-14 09:55:16 +00:00
|
|
|
static int
|
1995-03-20 21:30:21 +00:00
|
|
|
rn_walktree_from(h, a, m, f, w)
|
|
|
|
struct radix_node_head *h;
|
|
|
|
void *a, *m;
|
1995-12-02 19:38:06 +00:00
|
|
|
walktree_f_t *f;
|
1995-03-20 21:30:21 +00:00
|
|
|
void *w;
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
struct radix_node *base, *next;
|
|
|
|
u_char *xa = (u_char *)a;
|
|
|
|
u_char *xm = (u_char *)m;
|
|
|
|
register struct radix_node *rn, *last = 0 /* shut up gcc */;
|
|
|
|
int stopping = 0;
|
|
|
|
int lastb;
|
|
|
|
|
|
|
|
/*
|
Readability fixes:
Clearly comment the assumptions on the structure of keys (addresses)
and masks, and introduce a macro, LEN(p), to extract the size of these
objects instead of using *(u_char *)p which might be confusing.
Comment the confusion in the types used to pass around pointers
to keys and masks, as a reminder to fix that at some point.
Add a few comments on what some functions do.
Comment a probably inefficient (but still correct) section of code
in rn_walktree_from()
The object code generated after this commit is the same as before.
At some point we should also change same variable identifiers such
as "t, tt, ttt" to fancier names such as "root, left, right" (just
in case someone wants to understand the code!), replace misspelling
of NULL as 0, remove 'register' declarations that make little sense
these days.
2004-04-21 15:27:36 +00:00
|
|
|
* rn_search_m is sort-of-open-coded here. We cannot use the
|
|
|
|
* function because we need to keep track of the last node seen.
|
1995-03-20 21:30:21 +00:00
|
|
|
*/
|
1995-03-23 18:07:29 +00:00
|
|
|
/* printf("about to search\n"); */
|
2000-04-23 04:00:00 +00:00
|
|
|
for (rn = h->rnh_treetop; rn->rn_bit >= 0; ) {
|
1995-03-20 21:30:21 +00:00
|
|
|
last = rn;
|
2000-04-23 04:00:00 +00:00
|
|
|
/* printf("rn_bit %d, rn_bmask %x, xm[rn_offset] %x\n",
|
|
|
|
rn->rn_bit, rn->rn_bmask, xm[rn->rn_offset]); */
|
|
|
|
if (!(rn->rn_bmask & xm[rn->rn_offset])) {
|
1995-03-20 21:30:21 +00:00
|
|
|
break;
|
1995-03-23 18:07:29 +00:00
|
|
|
}
|
2000-04-23 04:00:00 +00:00
|
|
|
if (rn->rn_bmask & xa[rn->rn_offset]) {
|
|
|
|
rn = rn->rn_right;
|
1995-03-20 21:30:21 +00:00
|
|
|
} else {
|
2000-04-23 04:00:00 +00:00
|
|
|
rn = rn->rn_left;
|
1995-03-20 21:30:21 +00:00
|
|
|
}
|
|
|
|
}
|
1995-03-23 18:07:29 +00:00
|
|
|
/* printf("done searching\n"); */
|
1995-03-20 21:30:21 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Two cases: either we stepped off the end of our mask,
|
|
|
|
* in which case last == rn, or we reached a leaf, in which
|
|
|
|
* case we want to start from the last node we looked at.
|
|
|
|
* Either way, last is the node we want to start from.
|
|
|
|
*/
|
|
|
|
rn = last;
|
2000-04-23 04:00:00 +00:00
|
|
|
lastb = rn->rn_bit;
|
1995-03-20 21:30:21 +00:00
|
|
|
|
1995-03-23 18:07:29 +00:00
|
|
|
/* printf("rn %p, lastb %d\n", rn, lastb);*/
|
|
|
|
|
1995-03-20 21:30:21 +00:00
|
|
|
/*
|
|
|
|
* This gets complicated because we may delete the node
|
|
|
|
* while applying the function f to it, so we need to calculate
|
|
|
|
* the successor node in advance.
|
|
|
|
*/
|
2000-04-23 04:00:00 +00:00
|
|
|
while (rn->rn_bit >= 0)
|
|
|
|
rn = rn->rn_left;
|
1995-03-20 21:30:21 +00:00
|
|
|
|
|
|
|
while (!stopping) {
|
2000-04-23 04:00:00 +00:00
|
|
|
/* printf("node %p (%d)\n", rn, rn->rn_bit); */
|
1995-03-20 21:30:21 +00:00
|
|
|
base = rn;
|
|
|
|
/* If at right child go back up, otherwise, go right */
|
2000-04-23 04:00:00 +00:00
|
|
|
while (rn->rn_parent->rn_right == rn
|
|
|
|
&& !(rn->rn_flags & RNF_ROOT)) {
|
|
|
|
rn = rn->rn_parent;
|
1995-03-20 21:30:21 +00:00
|
|
|
|
1995-05-30 08:16:23 +00:00
|
|
|
/* if went up beyond last, stop */
|
2006-02-07 20:25:39 +00:00
|
|
|
if (rn->rn_bit <= lastb) {
|
1995-03-20 21:30:21 +00:00
|
|
|
stopping = 1;
|
1995-03-23 18:07:29 +00:00
|
|
|
/* printf("up too far\n"); */
|
Readability fixes:
Clearly comment the assumptions on the structure of keys (addresses)
and masks, and introduce a macro, LEN(p), to extract the size of these
objects instead of using *(u_char *)p which might be confusing.
Comment the confusion in the types used to pass around pointers
to keys and masks, as a reminder to fix that at some point.
Add a few comments on what some functions do.
Comment a probably inefficient (but still correct) section of code
in rn_walktree_from()
The object code generated after this commit is the same as before.
At some point we should also change same variable identifiers such
as "t, tt, ttt" to fancier names such as "root, left, right" (just
in case someone wants to understand the code!), replace misspelling
of NULL as 0, remove 'register' declarations that make little sense
these days.
2004-04-21 15:27:36 +00:00
|
|
|
/*
|
|
|
|
* XXX we should jump to the 'Process leaves'
|
|
|
|
* part, because the values of 'rn' and 'next'
|
|
|
|
* we compute will not be used. Not a big deal
|
|
|
|
* because this loop will terminate, but it is
|
|
|
|
* inefficient and hard to understand!
|
|
|
|
*/
|
1995-03-20 21:30:21 +00:00
|
|
|
}
|
|
|
|
}
|
2006-02-07 20:25:39 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* At the top of the tree, no need to traverse the right
|
|
|
|
* half, prevent the traversal of the entire tree in the
|
|
|
|
* case of default route.
|
|
|
|
*/
|
|
|
|
if (rn->rn_parent->rn_flags & RNF_ROOT)
|
|
|
|
stopping = 1;
|
1995-03-20 21:30:21 +00:00
|
|
|
|
|
|
|
/* Find the next *leaf* since next node might vanish, too */
|
2000-04-23 04:00:00 +00:00
|
|
|
for (rn = rn->rn_parent->rn_right; rn->rn_bit >= 0;)
|
|
|
|
rn = rn->rn_left;
|
1995-03-20 21:30:21 +00:00
|
|
|
next = rn;
|
|
|
|
/* Process leaves */
|
|
|
|
while ((rn = base) != 0) {
|
|
|
|
base = rn->rn_dupedkey;
|
1995-03-23 18:07:29 +00:00
|
|
|
/* printf("leaf %p\n", rn); */
|
1995-05-30 08:16:23 +00:00
|
|
|
if (!(rn->rn_flags & RNF_ROOT)
|
1995-03-20 21:30:21 +00:00
|
|
|
&& (error = (*f)(rn, w)))
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
rn = next;
|
1995-03-23 18:07:29 +00:00
|
|
|
|
|
|
|
if (rn->rn_flags & RNF_ROOT) {
|
|
|
|
/* printf("root, stopping"); */
|
|
|
|
stopping = 1;
|
|
|
|
}
|
|
|
|
|
1995-03-20 21:30:21 +00:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
1995-12-14 09:55:16 +00:00
|
|
|
static int
|
1994-05-24 10:09:53 +00:00
|
|
|
rn_walktree(h, f, w)
|
|
|
|
struct radix_node_head *h;
|
1995-12-02 19:38:06 +00:00
|
|
|
walktree_f_t *f;
|
1994-05-24 10:09:53 +00:00
|
|
|
void *w;
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
struct radix_node *base, *next;
|
|
|
|
register struct radix_node *rn = h->rnh_treetop;
|
|
|
|
/*
|
|
|
|
* This gets complicated because we may delete the node
|
|
|
|
* while applying the function f to it, so we need to calculate
|
|
|
|
* the successor node in advance.
|
|
|
|
*/
|
2008-12-16 04:40:43 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/* First time through node, go left */
|
2000-04-23 04:00:00 +00:00
|
|
|
while (rn->rn_bit >= 0)
|
|
|
|
rn = rn->rn_left;
|
1994-05-24 10:09:53 +00:00
|
|
|
for (;;) {
|
|
|
|
base = rn;
|
|
|
|
/* If at right child go back up, otherwise, go right */
|
2000-04-23 04:00:00 +00:00
|
|
|
while (rn->rn_parent->rn_right == rn
|
|
|
|
&& (rn->rn_flags & RNF_ROOT) == 0)
|
|
|
|
rn = rn->rn_parent;
|
1994-05-24 10:09:53 +00:00
|
|
|
/* Find the next *leaf* since next node might vanish, too */
|
2000-04-23 04:00:00 +00:00
|
|
|
for (rn = rn->rn_parent->rn_right; rn->rn_bit >= 0;)
|
|
|
|
rn = rn->rn_left;
|
1994-05-24 10:09:53 +00:00
|
|
|
next = rn;
|
|
|
|
/* Process leaves */
|
1995-04-28 23:01:37 +00:00
|
|
|
while ((rn = base)) {
|
1994-05-24 10:09:53 +00:00
|
|
|
base = rn->rn_dupedkey;
|
2000-04-23 04:00:00 +00:00
|
|
|
if (!(rn->rn_flags & RNF_ROOT)
|
|
|
|
&& (error = (*f)(rn, w)))
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
rn = next;
|
|
|
|
if (rn->rn_flags & RNF_ROOT)
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
/* NOTREACHED */
|
|
|
|
}
|
|
|
|
|
Readability fixes:
Clearly comment the assumptions on the structure of keys (addresses)
and masks, and introduce a macro, LEN(p), to extract the size of these
objects instead of using *(u_char *)p which might be confusing.
Comment the confusion in the types used to pass around pointers
to keys and masks, as a reminder to fix that at some point.
Add a few comments on what some functions do.
Comment a probably inefficient (but still correct) section of code
in rn_walktree_from()
The object code generated after this commit is the same as before.
At some point we should also change same variable identifiers such
as "t, tt, ttt" to fancier names such as "root, left, right" (just
in case someone wants to understand the code!), replace misspelling
of NULL as 0, remove 'register' declarations that make little sense
these days.
2004-04-21 15:27:36 +00:00
|
|
|
/*
|
|
|
|
* Allocate and initialize an empty tree. This has 3 nodes, which are
|
|
|
|
* part of the radix_node_head (in the order <left,root,right>) and are
|
|
|
|
* marked RNF_ROOT so they cannot be freed.
|
|
|
|
* The leaves have all-zero and all-one keys, with significant
|
|
|
|
* bits starting at 'off'.
|
|
|
|
* Return 1 on success, 0 on error.
|
|
|
|
*/
|
1994-05-24 10:09:53 +00:00
|
|
|
int
|
|
|
|
rn_inithead(head, off)
|
|
|
|
void **head;
|
|
|
|
int off;
|
|
|
|
{
|
|
|
|
register struct radix_node_head *rnh;
|
|
|
|
register struct radix_node *t, *tt, *ttt;
|
|
|
|
if (*head)
|
|
|
|
return (1);
|
2004-04-19 17:28:39 +00:00
|
|
|
R_Zalloc(rnh, struct radix_node_head *, sizeof (*rnh));
|
1994-05-24 10:09:53 +00:00
|
|
|
if (rnh == 0)
|
|
|
|
return (0);
|
2003-02-08 01:44:09 +00:00
|
|
|
#ifdef _KERNEL
|
2002-12-24 03:03:39 +00:00
|
|
|
RADIX_NODE_HEAD_LOCK_INIT(rnh);
|
2003-02-08 01:44:09 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
*head = rnh;
|
|
|
|
t = rn_newpair(rn_zeros, off, rnh->rnh_nodes);
|
|
|
|
ttt = rnh->rnh_nodes + 2;
|
2000-04-23 04:00:00 +00:00
|
|
|
t->rn_right = ttt;
|
|
|
|
t->rn_parent = t;
|
Readability fixes:
Clearly comment the assumptions on the structure of keys (addresses)
and masks, and introduce a macro, LEN(p), to extract the size of these
objects instead of using *(u_char *)p which might be confusing.
Comment the confusion in the types used to pass around pointers
to keys and masks, as a reminder to fix that at some point.
Add a few comments on what some functions do.
Comment a probably inefficient (but still correct) section of code
in rn_walktree_from()
The object code generated after this commit is the same as before.
At some point we should also change same variable identifiers such
as "t, tt, ttt" to fancier names such as "root, left, right" (just
in case someone wants to understand the code!), replace misspelling
of NULL as 0, remove 'register' declarations that make little sense
these days.
2004-04-21 15:27:36 +00:00
|
|
|
tt = t->rn_left; /* ... which in turn is rnh->rnh_nodes */
|
1994-05-24 10:09:53 +00:00
|
|
|
tt->rn_flags = t->rn_flags = RNF_ROOT | RNF_ACTIVE;
|
2000-04-23 04:00:00 +00:00
|
|
|
tt->rn_bit = -1 - off;
|
1994-05-24 10:09:53 +00:00
|
|
|
*ttt = *tt;
|
|
|
|
ttt->rn_key = rn_ones;
|
|
|
|
rnh->rnh_addaddr = rn_addroute;
|
|
|
|
rnh->rnh_deladdr = rn_delete;
|
|
|
|
rnh->rnh_matchaddr = rn_match;
|
1995-04-28 23:01:37 +00:00
|
|
|
rnh->rnh_lookup = rn_lookup;
|
1994-05-24 10:09:53 +00:00
|
|
|
rnh->rnh_walktree = rn_walktree;
|
1995-03-20 21:30:21 +00:00
|
|
|
rnh->rnh_walktree_from = rn_walktree_from;
|
1994-05-24 10:09:53 +00:00
|
|
|
rnh->rnh_treetop = t;
|
|
|
|
return (1);
|
|
|
|
}
|
|
|
|
|
2010-03-06 21:27:26 +00:00
|
|
|
int
|
|
|
|
rn_detachhead(void **head)
|
|
|
|
{
|
|
|
|
struct radix_node_head *rnh;
|
|
|
|
|
|
|
|
KASSERT((head != NULL && *head != NULL),
|
|
|
|
("%s: head already freed", __func__));
|
|
|
|
rnh = *head;
|
|
|
|
|
|
|
|
/* Free <left,root,right> nodes. */
|
|
|
|
Free(rnh);
|
|
|
|
|
|
|
|
*head = NULL;
|
|
|
|
return (1);
|
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
void
|
2009-12-14 20:12:51 +00:00
|
|
|
rn_init(int maxk)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
char *cp, *cplim;
|
|
|
|
|
2009-12-14 20:12:51 +00:00
|
|
|
max_keylen = maxk;
|
1994-05-24 10:09:53 +00:00
|
|
|
if (max_keylen == 0) {
|
1995-04-28 23:01:37 +00:00
|
|
|
log(LOG_ERR,
|
|
|
|
"rn_init: radix functions require max_keylen be set\n");
|
1994-05-24 10:09:53 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
R_Malloc(rn_zeros, char *, 3 * max_keylen);
|
|
|
|
if (rn_zeros == NULL)
|
|
|
|
panic("rn_init");
|
2004-04-18 11:48:35 +00:00
|
|
|
bzero(rn_zeros, 3 * max_keylen);
|
1994-05-24 10:09:53 +00:00
|
|
|
rn_ones = cp = rn_zeros + max_keylen;
|
1995-04-28 23:01:37 +00:00
|
|
|
addmask_key = cplim = rn_ones + max_keylen;
|
1994-05-24 10:09:53 +00:00
|
|
|
while (cp < cplim)
|
|
|
|
*cp++ = -1;
|
2003-09-22 23:24:18 +00:00
|
|
|
if (rn_inithead((void **)(void *)&mask_rnhead, 0) == 0)
|
1994-05-24 10:09:53 +00:00
|
|
|
panic("rn_init 2");
|
|
|
|
}
|