/*
- * $Id: radix.h,v 1.11 2001/10/17 17:55:23 hno Exp $
+ * $Id: radix.h,v 1.12 2001/11/13 19:24:34 hno Exp $
*/
#ifndef SQUID_RADIX_H
* Radix search tree node layout.
*/
-struct radix_node {
- struct radix_mask *rn_mklist; /* list of masks contained in subtree */
- struct radix_node *rn_p; /* parent */
+struct squid_radix_node {
+ struct squid_radix_mask *rn_mklist; /* list of masks contained in subtree */
+ struct squid_radix_node *rn_p; /* parent */
short rn_b; /* bit offset; -1-index(netmask) */
char rn_bmask; /* node: mask for bit test */
unsigned char rn_flags; /* enumerated next */
struct { /* leaf only data: */
char *rn_Key; /* object of search */
char *rn_Mask; /* netmask, if present */
- struct radix_node *rn_Dupedkey;
+ struct squid_radix_node *rn_Dupedkey;
} rn_leaf;
struct { /* node only data: */
int rn_Off; /* where to start compare */
- struct radix_node *rn_L; /* progeny */
- struct radix_node *rn_R; /* progeny */
+ struct squid_radix_node *rn_L; /* progeny */
+ struct squid_radix_node *rn_R; /* progeny */
} rn_node;
} rn_u;
#ifdef RN_DEBUG
int rn_info;
- struct radix_node *rn_twin;
- struct radix_node *rn_ybro;
+ struct squid_radix_node *rn_twin;
+ struct squid_radix_node *rn_ybro;
#endif
};
* Annotations to tree concerning potential routes applying to subtrees.
*/
-extern struct radix_mask {
+extern struct squid_radix_mask {
short rm_b; /* bit offset; -1-index(netmask) */
char rm_unused; /* cf. rn_bmask */
unsigned char rm_flags; /* cf. rn_flags */
- struct radix_mask *rm_mklist; /* more masks to try */
+ struct squid_radix_mask *rm_mklist; /* more masks to try */
union {
char *rmu_mask; /* the mask */
- struct radix_node *rmu_leaf; /* for normal routes */
+ struct squid_radix_node *rmu_leaf; /* for normal routes */
} rm_rmu;
int rm_refs; /* # of references to this struct */
-} *rn_mkfreelist;
+} *squid_rn_mkfreelist;
#define rm_mask rm_rmu.rmu_mask
#define rm_leaf rm_rmu.rmu_leaf /* extra field would make 32 bytes */
-#define MKGet(m) {\
- if (rn_mkfreelist) {\
- m = rn_mkfreelist; \
- rn_mkfreelist = (m)->rm_mklist; \
+#define squid_MKGet(m) {\
+ if (squid_rn_mkfreelist) {\
+ m = squid_rn_mkfreelist; \
+ squid_rn_mkfreelist = (m)->rm_mklist; \
} else \
- R_Malloc(m, struct radix_mask *, sizeof (*(m))); }\
+ squid_R_Malloc(m, struct squid_radix_mask *, sizeof (*(m))); }\
-#define MKFree(m) { (m)->rm_mklist = rn_mkfreelist; rn_mkfreelist = (m);}
+#define squid_MKFree(m) { (m)->rm_mklist = squid_rn_mkfreelist; squid_rn_mkfreelist = (m);}
-struct radix_node_head {
- struct radix_node *rnh_treetop;
+struct squid_radix_node_head {
+ struct squid_radix_node *rnh_treetop;
int rnh_addrsize; /* permit, but not require fixed keys */
int rnh_pktsize; /* permit, but not require fixed keys */
- struct radix_node *(*rnh_addaddr) /* add based on sockaddr */
+ struct squid_radix_node *(*rnh_addaddr) /* add based on sockaddr */
(void *v, void *mask,
- struct radix_node_head * head, struct radix_node nodes[]);
- struct radix_node *(*rnh_addpkt) /* add based on packet hdr */
+ struct squid_radix_node_head * head, struct squid_radix_node nodes[]);
+ struct squid_radix_node *(*rnh_addpkt) /* add based on packet hdr */
(void *v, void *mask,
- struct radix_node_head * head, struct radix_node nodes[]);
- struct radix_node *(*rnh_deladdr) /* remove based on sockaddr */
- (void *v, void *mask, struct radix_node_head * head);
- struct radix_node *(*rnh_delpkt) /* remove based on packet hdr */
- (void *v, void *mask, struct radix_node_head * head);
- struct radix_node *(*rnh_matchaddr) /* locate based on sockaddr */
- (void *v, struct radix_node_head * head);
- struct radix_node *(*rnh_lookup) /* locate based on sockaddr */
- (void *v, void *mask, struct radix_node_head * head);
- struct radix_node *(*rnh_matchpkt) /* locate based on packet hdr */
- (void *v, struct radix_node_head * head);
+ struct squid_radix_node_head * head, struct squid_radix_node nodes[]);
+ struct squid_radix_node *(*rnh_deladdr) /* remove based on sockaddr */
+ (void *v, void *mask, struct squid_radix_node_head * head);
+ struct squid_radix_node *(*rnh_delpkt) /* remove based on packet hdr */
+ (void *v, void *mask, struct squid_radix_node_head * head);
+ struct squid_radix_node *(*rnh_matchaddr) /* locate based on sockaddr */
+ (void *v, struct squid_radix_node_head * head);
+ struct squid_radix_node *(*rnh_lookup) /* locate based on sockaddr */
+ (void *v, void *mask, struct squid_radix_node_head * head);
+ struct squid_radix_node *(*rnh_matchpkt) /* locate based on packet hdr */
+ (void *v, struct squid_radix_node_head * head);
int (*rnh_walktree) /* traverse tree */
- (struct radix_node_head * head, int (*f) (struct radix_node *, void *), void *w);
- struct radix_node rnh_nodes[3]; /* empty tree for common case */
+ (struct squid_radix_node_head * head, int (*f) (struct squid_radix_node *, void *), void *w);
+ struct squid_radix_node rnh_nodes[3]; /* empty tree for common case */
};
-#define Bcmp(a, b, n) memcmp(((char *)(a)), ((char *)(b)), (n))
-#define Bcopy(a, b, n) memcpy(((char *)(b)), ((char *)(a)), (unsigned)(n))
-#define Bzero(p, n) memset((char *)(p),'\0', (int)(n))
-#define R_Malloc(p, t, n) (p = (t) xmalloc((unsigned int)(n)))
-#define Free(p) xfree((char *)p)
+#define squid_Bcmp(a, b, n) memcmp(((char *)(a)), ((char *)(b)), (n))
+#define squid_Bcopy(a, b, n) memcpy(((char *)(b)), ((char *)(a)), (unsigned)(n))
+#define squid_Bzero(p, n) memset((char *)(p),'\0', (int)(n))
+#define squid_R_Malloc(p, t, n) (p = (t) xmalloc((unsigned int)(n)))
+#define squid_Free(p) xfree((char *)p)
-extern void rn_init (void);
-extern int rn_inithead(void **, int);
-extern int rn_refines(void *, void *);
-extern int rn_walktree(struct radix_node_head *, int (*)(struct radix_node *, void *), void *);
-extern struct radix_node *rn_addmask(void *, int, int);
-extern struct radix_node *rn_addroute(void *, void *, struct radix_node_head *, struct radix_node[2]);
-extern struct radix_node *rn_delete(void *, void *, struct radix_node_head *);
-extern struct radix_node *rn_insert(void *, struct radix_node_head *, int *, struct radix_node[2]);
-extern struct radix_node *rn_match(void *, struct radix_node_head *);
-extern struct radix_node *rn_newpair(void *, int, struct radix_node[2]);
-extern struct radix_node *rn_search(void *, struct radix_node *);
-extern struct radix_node *rn_search_m(void *, struct radix_node *, void *);
-extern struct radix_node *rn_lookup(void *, void *, struct radix_node_head *);
+extern void squid_rn_init (void);
+extern int squid_rn_inithead(void **, int);
+extern int squid_rn_refines(void *, void *);
+extern int squid_rn_walktree(struct squid_radix_node_head *, int (*)(struct squid_radix_node *, void *), void *);
+extern struct squid_radix_node *squid_rn_addmask(void *, int, int);
+extern struct squid_radix_node *squid_rn_addroute(void *, void *, struct squid_radix_node_head *, struct squid_radix_node[2]);
+extern struct squid_radix_node *squid_rn_delete(void *, void *, struct squid_radix_node_head *);
+extern struct squid_radix_node *squid_rn_insert(void *, struct squid_radix_node_head *, int *, struct squid_radix_node[2]);
+extern struct squid_radix_node *squid_rn_match(void *, struct squid_radix_node_head *);
+extern struct squid_radix_node *squid_rn_newpair(void *, int, struct squid_radix_node[2]);
+extern struct squid_radix_node *squid_rn_search(void *, struct squid_radix_node *);
+extern struct squid_radix_node *squid_rn_search_m(void *, struct squid_radix_node *, void *);
+extern struct squid_radix_node *squid_rn_lookup(void *, void *, struct squid_radix_node_head *);
#define min(x,y) ((x)<(y)? (x) : (y))
#endif /* SQUID_RADIX_H */
/*
- * $Id: radix.c,v 1.15 2001/10/17 17:55:23 hno Exp $
+ * $Id: radix.c,v 1.16 2001/11/13 19:24:34 hno Exp $
*
* DEBUG: section 53 Radix tree data structure implementation
* AUTHOR: NetBSD Derived
#include "radix.h"
-int max_keylen;
-struct radix_mask *rn_mkfreelist;
-struct radix_node_head *mask_rnhead;
+int squid_max_keylen;
+struct squid_radix_mask *squid_rn_mkfreelist;
+struct squid_radix_node_head *squid_mask_rnhead;
static char *addmask_key;
static unsigned char normal_chars[] =
{0, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xFF};
static char *rn_zeros, *rn_ones;
-#define rn_masktop (mask_rnhead->rnh_treetop)
-#undef Bcmp
-#define Bcmp(a, b, l) (l == 0 ? 0 : memcmp((caddr_t)(a), (caddr_t)(b), (u_long)l))
+#define rn_masktop (squid_mask_rnhead->rnh_treetop)
+#undef squid_Bcmp
+#define squid_Bcmp(a, b, l) (l == 0 ? 0 : memcmp((caddr_t)(a), (caddr_t)(b), (u_long)l))
/*
* The data structure for the keys is a radix tree with one way
* branching removed. The index rn_b at an internal node n represents a bit
* that governs a subtree.
*/
-struct radix_node *
-rn_search(void *v_arg, struct radix_node *head)
+struct squid_radix_node *
+squid_rn_search(void *v_arg, struct squid_radix_node *head)
{
- register struct radix_node *x;
+ register struct squid_radix_node *x;
register caddr_t v;
for (x = head, v = v_arg; x->rn_b >= 0;) {
return (x);
}
-struct radix_node *
-rn_search_m(void *v_arg, struct radix_node *head, void *m_arg)
+struct squid_radix_node *
+squid_rn_search_m(void *v_arg, struct squid_radix_node *head, void *m_arg)
{
- register struct radix_node *x;
+ register struct squid_radix_node *x;
register caddr_t v = v_arg, m = m_arg;
for (x = head; x->rn_b >= 0;) {
}
int
-rn_refines(void *m_arg, void *n_arg)
+squid_rn_refines(void *m_arg, void *n_arg)
{
register caddr_t m = m_arg, n = n_arg;
register caddr_t lim, lim2 = lim = n + *(u_char *) n;
return (!masks_are_equal);
}
-struct radix_node *
-rn_lookup(void *v_arg, void *m_arg, struct radix_node_head *head)
+struct squid_radix_node *
+squid_rn_lookup(void *v_arg, void *m_arg, struct squid_radix_node_head *head)
{
- register struct radix_node *x;
+ register struct squid_radix_node *x;
caddr_t netmask = 0;
if (m_arg) {
- if ((x = rn_addmask(m_arg, 1, head->rnh_treetop->rn_off)) == 0)
+ if ((x = squid_rn_addmask(m_arg, 1, head->rnh_treetop->rn_off)) == 0)
return (0);
netmask = x->rn_key;
}
- x = rn_match(v_arg, head);
+ x = squid_rn_match(v_arg, head);
if (x && netmask) {
while (x && x->rn_mask != netmask)
x = x->rn_dupedkey;
}
static int
-rn_satsifies_leaf (char *trial, register struct radix_node *leaf, int skip)
+rn_satsifies_leaf (char *trial, register struct squid_radix_node *leaf, int skip)
{
register char *cp = trial, *cp2 = leaf->rn_key, *cp3 = leaf->rn_mask;
char *cplim;
return 1;
}
-struct radix_node *
-rn_match(void *v_arg, struct radix_node_head *head)
+struct squid_radix_node *
+squid_rn_match(void *v_arg, struct squid_radix_node_head *head)
{
caddr_t v = v_arg;
- register struct radix_node *t = head->rnh_treetop, *x;
+ register struct squid_radix_node *t = head->rnh_treetop, *x;
register caddr_t cp = v, cp2;
caddr_t cplim;
- struct radix_node *saved_t, *top = t;
+ struct squid_radix_node *saved_t, *top = t;
int off = t->rn_off, vlen = *(u_char *) cp, matched_off;
register int test, b, rn_b;
/*
- * Open code rn_search(v, top) to avoid overhead of extra
+ * Open code squid_rn_search(v, top) to avoid overhead of extra
* subroutine call.
*/
for (; t->rn_b >= 0;) {
t = saved_t;
/* start searching up the tree */
do {
- register struct radix_mask *m;
+ register struct squid_radix_mask *m;
t = t->rn_p;
if ((m = t->rn_mklist)) {
/*
return (m->rm_leaf);
} else {
off = min(t->rn_off, matched_off);
- x = rn_search_m(v, t, m->rm_mask);
+ x = squid_rn_search_m(v, t, m->rm_mask);
while (x && x->rn_mask != m->rm_mask)
x = x->rn_dupedkey;
if (x && rn_satsifies_leaf(v, x, off))
#ifdef RN_DEBUG
int rn_nodenum;
-struct radix_node *rn_clist;
+struct squid_radix_node *rn_clist;
int rn_saveinfo;
int rn_debug = 1;
#endif
-struct radix_node *
-rn_newpair(void *v, int b, struct radix_node nodes[2])
+struct squid_radix_node *
+squid_rn_newpair(void *v, int b, struct squid_radix_node nodes[2])
{
- register struct radix_node *tt = nodes, *t = tt + 1;
+ register struct squid_radix_node *tt = nodes, *t = tt + 1;
t->rn_b = b;
t->rn_bmask = 0x80 >> (b & 7);
t->rn_l = tt;
return t;
}
-struct radix_node *
-rn_insert(void *v_arg, struct radix_node_head *head, int *dupentry, struct radix_node nodes[2])
+struct squid_radix_node *
+squid_rn_insert(void *v_arg, struct squid_radix_node_head *head, int *dupentry, struct squid_radix_node nodes[2])
{
caddr_t v = v_arg;
- struct radix_node *top = head->rnh_treetop;
+ struct squid_radix_node *top = head->rnh_treetop;
int head_off = top->rn_off, vlen = (int) *((u_char *) v);
- register struct radix_node *t = rn_search(v_arg, top);
+ register struct squid_radix_node *t = squid_rn_search(v_arg, top);
register caddr_t cp = v + head_off;
register int b;
- struct radix_node *tt;
+ struct squid_radix_node *tt;
/*
* Find first bit at which v and t->rn_key differ
*/
cmp_res >>= 1;
}
{
- register struct radix_node *p, *x = top;
+ register struct squid_radix_node *p, *x = top;
cp = v;
do {
p = x;
} while (b > (unsigned) x->rn_b); /* x->rn_b < b && x->rn_b >= 0 */
#ifdef RN_DEBUG
if (rn_debug)
- fprintf(stderr, "rn_insert: Going In:\n");
+ fprintf(stderr, "squid_rn_insert: Going In:\n");
traverse(p);
#endif
- t = rn_newpair(v_arg, b, nodes);
+ t = squid_rn_newpair(v_arg, b, nodes);
tt = t->rn_l;
if ((cp[p->rn_off] & p->rn_bmask) == 0)
p->rn_l = t;
}
#ifdef RN_DEBUG
if (rn_debug)
- log(LOG_DEBUG, "rn_insert: Coming Out:\n"), traverse(p);
+ log(LOG_DEBUG, "squid_rn_insert: Coming Out:\n"), traverse(p);
#endif
}
return (tt);
}
-struct radix_node *
-rn_addmask(void *n_arg, int search, int skip)
+struct squid_radix_node *
+squid_rn_addmask(void *n_arg, int search, int skip)
{
caddr_t netmask = (caddr_t) n_arg;
- register struct radix_node *x;
+ register struct squid_radix_node *x;
register caddr_t cp, cplim;
register int b = 0, mlen, j;
int maskduplicated, m0, isnormal;
- struct radix_node *saved_x;
+ struct squid_radix_node *saved_x;
static int last_zeroed = 0;
- if ((mlen = *(u_char *) netmask) > max_keylen)
- mlen = max_keylen;
+ if ((mlen = *(u_char *) netmask) > squid_max_keylen)
+ mlen = squid_max_keylen;
if (skip == 0)
skip = 1;
if (mlen <= skip)
- return (mask_rnhead->rnh_nodes);
+ return (squid_mask_rnhead->rnh_nodes);
if (skip > 1)
memcpy(addmask_key + 1, rn_ones + 1, skip - 1);
if ((m0 = mlen) > skip)
if (mlen <= skip) {
if (m0 >= last_zeroed)
last_zeroed = mlen;
- return (mask_rnhead->rnh_nodes);
+ return (squid_mask_rnhead->rnh_nodes);
}
if (m0 < last_zeroed)
memset(addmask_key + m0, '\0', last_zeroed - m0);
*addmask_key = last_zeroed = mlen;
- x = rn_search(addmask_key, rn_masktop);
+ x = squid_rn_search(addmask_key, rn_masktop);
if (memcmp(addmask_key, x->rn_key, mlen) != 0)
x = 0;
if (x || search)
return (x);
- R_Malloc(x, struct radix_node *, max_keylen + 2 * sizeof(*x));
+ squid_R_Malloc(x, struct squid_radix_node *, squid_max_keylen + 2 * sizeof(*x));
if ((saved_x = x) == 0)
return (0);
- memset(x, '\0', max_keylen + 2 * sizeof(*x));
+ memset(x, '\0', squid_max_keylen + 2 * sizeof(*x));
netmask = cp = (caddr_t) (x + 2);
memcpy(cp, addmask_key, mlen);
- x = rn_insert(cp, mask_rnhead, &maskduplicated, x);
+ x = squid_rn_insert(cp, squid_mask_rnhead, &maskduplicated, x);
if (maskduplicated) {
- fprintf(stderr, "rn_addmask: mask impossibly already in tree");
- Free(saved_x);
+ fprintf(stderr, "squid_rn_addmask: mask impossibly already in tree");
+ squid_Free(saved_x);
return (x);
}
/*
return 0;
}
-static struct radix_mask *
-rn_new_radix_mask(struct radix_node *tt, struct radix_mask *next)
+static struct squid_radix_mask *
+rn_new_radix_mask(struct squid_radix_node *tt, struct squid_radix_mask *next)
{
- register struct radix_mask *m;
+ register struct squid_radix_mask *m;
- MKGet(m);
+ squid_MKGet(m);
if (m == 0) {
fprintf(stderr, "Mask for route not entered\n");
return (0);
return m;
}
-struct radix_node *
-rn_addroute(void *v_arg, void *n_arg, struct radix_node_head *head, struct radix_node treenodes[2])
+struct squid_radix_node *
+squid_rn_addroute(void *v_arg, void *n_arg, struct squid_radix_node_head *head, struct squid_radix_node treenodes[2])
{
caddr_t v = (caddr_t) v_arg, netmask = (caddr_t) n_arg;
- register struct radix_node *t, *x = NULL, *tt;
- struct radix_node *saved_tt, *top = head->rnh_treetop;
+ register struct squid_radix_node *t, *x = NULL, *tt;
+ struct squid_radix_node *saved_tt, *top = head->rnh_treetop;
short b = 0, b_leaf = 0;
int keyduplicated;
caddr_t mmask;
- struct radix_mask *m, **mp;
+ struct squid_radix_mask *m, **mp;
/*
* In dealing with non-contiguous masks, there may be
* nodes and possibly save time in calculating indices.
*/
if (netmask) {
- if ((x = rn_addmask(netmask, 0, top->rn_off)) == 0)
+ if ((x = squid_rn_addmask(netmask, 0, top->rn_off)) == 0)
return (0);
b_leaf = x->rn_b;
b = -1 - x->rn_b;
/*
* Deal with duplicated keys: attach node to previous instance
*/
- saved_tt = tt = rn_insert(v, head, &keyduplicated, treenodes);
+ saved_tt = tt = squid_rn_insert(v, head, &keyduplicated, treenodes);
if (keyduplicated) {
for (t = tt; tt; t = tt, tt = tt->rn_dupedkey) {
if (tt->rn_mask == netmask)
if (netmask == 0 ||
(tt->rn_mask &&
((b_leaf < tt->rn_b) || /* index(netmask) > node */
- rn_refines(netmask, tt->rn_mask) ||
+ squid_rn_refines(netmask, tt->rn_mask) ||
rn_lexobetter(netmask, tt->rn_mask))))
break;
}
* the head of the list.
*/
if (tt == saved_tt) {
- struct radix_node *xx = x;
+ struct squid_radix_node *xx = x;
/* link in at head of list */
(tt = treenodes)->rn_dupedkey = t;
tt->rn_flags = t->rn_flags;
tt->rn_mklist = m;
return tt;
}
- if (rn_refines(netmask, mmask) || rn_lexobetter(netmask, mmask))
+ if (squid_rn_refines(netmask, mmask) || rn_lexobetter(netmask, mmask))
break;
}
*mp = rn_new_radix_mask(tt, *mp);
return tt;
}
-struct radix_node *
-rn_delete(void *v_arg, void *netmask_arg, struct radix_node_head *head)
+struct squid_radix_node *
+squid_rn_delete(void *v_arg, void *netmask_arg, struct squid_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;
+ register struct squid_radix_node *t, *p, *x, *tt;
+ struct squid_radix_mask *m, *saved_m, **mp;
+ struct squid_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);
+ tt = squid_rn_search(v, x);
head_off = x->rn_off;
vlen = *(u_char *) v;
saved_tt = tt;
* Delete our route from mask lists.
*/
if (netmask) {
- if ((x = rn_addmask(netmask, 1, head_off)) == 0)
+ if ((x = squid_rn_addmask(netmask, 1, head_off)) == 0)
return (0);
netmask = x->rn_key;
while (tt->rn_mask != netmask)
goto on1;
if (tt->rn_flags & RNF_NORMAL) {
if (m->rm_leaf != tt || m->rm_refs > 0) {
- fprintf(stderr, "rn_delete: inconsistent annotation\n");
+ fprintf(stderr, "squid_rn_delete: inconsistent annotation\n");
return 0; /* dangling ref could cause disaster */
}
} else {
if (m->rm_mask != tt->rn_mask) {
- fprintf(stderr, "rn_delete: inconsistent annotation\n");
+ fprintf(stderr, "squid_rn_delete: inconsistent annotation\n");
goto on1;
}
if (--m->rm_refs >= 0)
for (mp = &x->rn_mklist; (m = *mp); mp = &m->rm_mklist)
if (m == saved_m) {
*mp = m->rm_mklist;
- MKFree(m);
+ squid_MKFree(m);
break;
}
if (m == 0) {
- fprintf(stderr, "rn_delete: couldn't find our annotation\n");
+ fprintf(stderr, "squid_rn_delete: couldn't find our annotation\n");
if (tt->rn_flags & RNF_NORMAL)
return (0); /* Dangling ref to us */
}
if (p)
p->rn_dupedkey = tt->rn_dupedkey;
else
- fprintf(stderr, "rn_delete: couldn't find us\n");
+ fprintf(stderr, "squid_rn_delete: couldn't find us\n");
}
t = tt + 1;
if (t->rn_flags & RNF_ACTIVE) {
* 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;
+ struct squid_radix_mask *mm = m->rm_mklist;
x->rn_mklist = 0;
if (--(m->rm_refs) < 0)
- MKFree(m);
+ squid_MKFree(m);
m = mm;
}
#if RN_DEBUG
if (m)
fprintf(stderr, "%s %x at %x\n",
- "rn_delete: Orphaned Mask", (int) m, (int) x);
+ "squid_rn_delete: Orphaned Mask", (int) m, (int) x);
#else
assert(m == NULL);
#endif
}
int
-rn_walktree(struct radix_node_head *h, int (*f)(struct radix_node *, void *), void *w)
+squid_rn_walktree(struct squid_radix_node_head *h, int (*f)(struct squid_radix_node *, void *), void *w)
{
int error;
- struct radix_node *base, *next;
- register struct radix_node *rn = h->rnh_treetop;
+ struct squid_radix_node *base, *next;
+ register struct squid_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
}
int
-rn_inithead(void **head, int off)
+squid_rn_inithead(void **head, int off)
{
- register struct radix_node_head *rnh;
- register struct radix_node *t, *tt, *ttt;
+ register struct squid_radix_node_head *rnh;
+ register struct squid_radix_node *t, *tt, *ttt;
if (*head)
return (1);
- R_Malloc(rnh, struct radix_node_head *, sizeof(*rnh));
+ squid_R_Malloc(rnh, struct squid_radix_node_head *, sizeof(*rnh));
if (rnh == 0)
return (0);
memset(rnh, '\0', sizeof(*rnh));
*head = rnh;
- t = rn_newpair(rn_zeros, off, rnh->rnh_nodes);
+ t = squid_rn_newpair(rn_zeros, off, rnh->rnh_nodes);
ttt = rnh->rnh_nodes + 2;
t->rn_r = ttt;
t->rn_p = t;
tt->rn_b = -1 - off;
*ttt = *tt;
ttt->rn_key = rn_ones;
- rnh->rnh_addaddr = rn_addroute;
- rnh->rnh_deladdr = rn_delete;
- rnh->rnh_matchaddr = rn_match;
- rnh->rnh_lookup = rn_lookup;
- rnh->rnh_walktree = rn_walktree;
+ rnh->rnh_addaddr = squid_rn_addroute;
+ rnh->rnh_deladdr = squid_rn_delete;
+ rnh->rnh_matchaddr = squid_rn_match;
+ rnh->rnh_lookup = squid_rn_lookup;
+ rnh->rnh_walktree = squid_rn_walktree;
rnh->rnh_treetop = t;
return (1);
}
void
-rn_init(void)
+squid_rn_init(void)
{
char *cp, *cplim;
#ifdef KERNEL
struct domain *dom;
for (dom = domains; dom; dom = dom->dom_next)
- if (dom->dom_maxrtkey > max_keylen)
- max_keylen = dom->dom_maxrtkey;
+ if (dom->dom_maxrtkey > squid_max_keylen)
+ squid_max_keylen = dom->dom_maxrtkey;
#endif
- if (max_keylen == 0) {
+ if (squid_max_keylen == 0) {
fprintf(stderr,
- "rn_init: radix functions require max_keylen be set\n");
+ "squid_rn_init: radix functions require squid_max_keylen be set\n");
return;
}
- R_Malloc(rn_zeros, char *, 3 * max_keylen);
+ squid_R_Malloc(rn_zeros, char *, 3 * squid_max_keylen);
if (rn_zeros == NULL) {
- fprintf(stderr, "rn_init failed.\n");
+ fprintf(stderr, "squid_rn_init failed.\n");
exit(-1);
}
- memset(rn_zeros, '\0', 3 * max_keylen);
- rn_ones = cp = rn_zeros + max_keylen;
- addmask_key = cplim = rn_ones + max_keylen;
+ memset(rn_zeros, '\0', 3 * squid_max_keylen);
+ rn_ones = cp = rn_zeros + squid_max_keylen;
+ addmask_key = cplim = rn_ones + squid_max_keylen;
while (cp < cplim)
*cp++ = -1;
- if (rn_inithead((void **) &mask_rnhead, 0) == 0) {
+ if (squid_rn_inithead((void **) &squid_mask_rnhead, 0) == 0) {
fprintf(stderr, "rn_init2 failed.\n");
exit(-1);
}
/*
- * $Id: asn.cc,v 1.77 2001/10/24 07:45:33 hno Exp $
+ * $Id: asn.cc,v 1.78 2001/11/13 19:24:35 hno Exp $
*
* DEBUG: section 53 AS Number handling
* AUTHOR: Duane Wessels, Kostas Anagnostakis
*/
#include "squid.h"
+#include "radix.h"
#define WHOIS_PORT 43
/* END of definitions for radix tree entries */
/* Head for ip to asn radix tree */
-struct radix_node_head *AS_tree_head;
+struct squid_radix_node_head *AS_tree_head;
/*
* Structure for as number information. it could be simply
/* entry into the radix tree */
struct _rtentry {
- struct radix_node e_nodes[2];
+ struct squid_radix_node e_nodes[2];
as_info *e_info;
m_int e_addr;
m_int e_mask;
static int asnAddNet(char *, int);
static void asnCacheStart(int as);
static STCB asHandleReply;
-static int destroyRadixNode(struct radix_node *rn, void *w);
-static int printRadixNode(struct radix_node *rn, void *w);
+static int destroyRadixNode(struct squid_radix_node *rn, void *w);
+static int printRadixNode(struct squid_radix_node *rn, void *w);
static void asnAclInitialize(acl * acls);
static void asStateFree(void *data);
static void destroyRadixNodeInfo(as_info *);
asnMatchIp(void *data, struct in_addr addr)
{
unsigned long lh;
- struct radix_node *rn;
+ struct squid_radix_node *rn;
as_info *e;
m_int m_addr;
intlist *a = NULL;
if (addr.s_addr == any_addr.s_addr)
return 0;
store_m_int(lh, m_addr);
- rn = rn_match(m_addr, AS_tree_head);
+ rn = squid_rn_match(m_addr, AS_tree_head);
if (rn == NULL) {
debug(53, 3) ("asnMatchIp: Address not in as db.\n");
return 0;
/* initialize the radix tree structure */
-extern int max_keylen; /* yuck.. this is in lib/radix.c */
+extern int squid_max_keylen; /* yuck.. this is in lib/radix.c */
CBDATA_TYPE(ASState);
void
asnInit(void)
{
static int inited = 0;
- max_keylen = 40;
+ squid_max_keylen = 40;
CBDATA_INIT_TYPE(ASState);
if (0 == inited++)
- rn_init();
- rn_inithead((void **) &AS_tree_head, 8);
+ squid_rn_init();
+ squid_rn_inithead((void **) &AS_tree_head, 8);
asnAclInitialize(Config.aclList);
cachemgrRegister("asndb", "AS Number Database", asnStats, 0, 1);
}
void
asnFreeMemory(void)
{
- rn_walktree(AS_tree_head, destroyRadixNode, AS_tree_head);
- destroyRadixNode((struct radix_node *) 0, (void *) AS_tree_head);
+ squid_rn_walktree(AS_tree_head, destroyRadixNode, AS_tree_head);
+ destroyRadixNode((struct squid_radix_node *) 0, (void *) AS_tree_head);
}
static void
asnStats(StoreEntry * sentry)
{
storeAppendPrintf(sentry, "Address \tAS Numbers\n");
- rn_walktree(AS_tree_head, printRadixNode, sentry);
+ squid_rn_walktree(AS_tree_head, printRadixNode, sentry);
}
/* PRIVATE */
asnAddNet(char *as_string, int as_number)
{
rtentry *e = xmalloc(sizeof(rtentry));
- struct radix_node *rn;
+ struct squid_radix_node *rn;
char dbg1[32], dbg2[32];
intlist **Tail = NULL;
intlist *q = NULL;
memset(e, '\0', sizeof(rtentry));
store_m_int(addr, e->e_addr);
store_m_int(mask, e->e_mask);
- rn = rn_lookup(e->e_addr, e->e_mask, AS_tree_head);
+ rn = squid_rn_lookup(e->e_addr, e->e_mask, AS_tree_head);
if (rn != NULL) {
asinfo = ((rtentry *) rn)->e_info;
if (intlistFind(asinfo->as_number, as_number)) {
q->i = as_number;
asinfo = xmalloc(sizeof(asinfo));
asinfo->as_number = q;
- rn = rn_addroute(e->e_addr, e->e_mask, AS_tree_head, e->e_nodes);
- rn = rn_match(e->e_addr, AS_tree_head);
+ rn = squid_rn_addroute(e->e_addr, e->e_mask, AS_tree_head, e->e_nodes);
+ rn = squid_rn_match(e->e_addr, AS_tree_head);
assert(rn != NULL);
e->e_info = asinfo;
}
}
static int
-destroyRadixNode(struct radix_node *rn, void *w)
+destroyRadixNode(struct squid_radix_node *rn, void *w)
{
- struct radix_node_head *rnh = (struct radix_node_head *) w;
+ struct squid_radix_node_head *rnh = (struct squid_radix_node_head *) w;
if (rn && !(rn->rn_flags & RNF_ROOT)) {
rtentry *e = (rtentry *) rn;
- rn = rn_delete(rn->rn_key, rn->rn_mask, rnh);
+ rn = squid_rn_delete(rn->rn_key, rn->rn_mask, rnh);
if (rn == 0)
debug(53, 3) ("destroyRadixNode: internal screwup\n");
destroyRadixNodeInfo(e->e_info);
}
static int
-printRadixNode(struct radix_node *rn, void *w)
+printRadixNode(struct squid_radix_node *rn, void *w)
{
StoreEntry *sentry = w;
rtentry *e = (rtentry *) rn;
projects / thirdparty / squid.git / commitdiff
