mirrors/bird
mirrors/bird
0
0
Fork 0
mirror of https://gitlab.nic.cz/labs/bird.git synced 2025-01-03 15:41:54 +00:00
Code Releases Activity

tests pass (several times)

Browse Source
This commit is contained in:
Vojtech Vilimek 2023-07-05 11:59:10 +02:00
parent 70ec873ebe
commit b290284769
2 changed files with 128 additions and 261 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

277
filter/trie.c
View File

@ -784,42 +784,10 @@ done:
#define SAME_PREFIX(A,B,X,L) ((X) ? ip4_prefix_equal((A)->v4.addr, net4_prefix(B), (L)) : ip6_prefix_equal((A)->v6.addr, net6_prefix(B), (L))) #define SAME_PREFIX(A,B,X,L) ((X) ? ip4_prefix_equal((A)->v4.addr, net4_prefix(B), (L)) : ip6_prefix_equal((A)->v6.addr, net6_prefix(B), (L)))
#define GET_NET_BITS(N,X,A,B) ((X) ? ip4_getbits(net4_prefix(N), (A), (B)) : ip6_getbits(net6_prefix(N), (A), (B))) #define GET_NET_BITS(N,X,A,B) ((X) ? ip4_getbits(net4_prefix(N), (A), (B)) : ip6_getbits(net6_prefix(N), (A), (B)))
#define GET_NODE_BITS(N,X,A,B) ((X) ? ip4_getbits((N)->v4.addr, (A), (B)) : ip6_getbits((N)->v6.addr, (A), (B))) #define GET_NODE_BITS(N,X,A,B) ((X) ? ip4_getbits((N)->v4.addr, (A), (B)) : ip6_getbits((N)->v6.addr, (A), (B)))
//#define GET_ACCEPT_BITS(N,X,B) ((X) ? ip4_getbits((N)->v4.accept, (B), TRIE_STEP) : ip6_getbits((N)->v6.accept, (B), TRIE_STEP))
#define NEXT_PREFIX(A,B,X) ((X) ? ip4_compare((A)->v4.addr, net4_prefix(B)) < 0 : ip6_compare((A)->v6.addr, net6_prefix(B)) < 0) #define NEXT_PREFIX(A,B,X) ((X) ? ip4_compare((A)->v4.addr, net4_prefix(B)) < 0 : ip6_compare((A)->v6.addr, net6_prefix(B)) < 0)
#define MATCH_LOCAL_MASK(A,B,L,X) \ #define MATCH_LOCAL_MASK(A,B,L,X) \
((X) ? (A)->v4.local >= trie_local_mask4(net4_prefix(B), (B)->pxlen, (L)) : (A)->v6.local >= trie_local_mask6(net6_prefix(B), (B)->pxlen, (L))) ((X) ? (A)->v4.local >= trie_local_mask4(net4_prefix(B), (B)->pxlen, (L)) : (A)->v6.local >= trie_local_mask6(net6_prefix(B), (B)->pxlen, (L)))
void
_print_net(const net_addr *net, int v4)
{
char buf[64];
net_format(net, buf, 64);
log("net: %s", buf);
}
void
_print_node(const struct f_trie_node *n, int v4)
{
if (n == NULL)
{
log("node: (null)");
return;
}
int nlen = v4 ? n->v4.plen : n->v6.plen;
char buf[64];
net_addr curr;
if (v4)
net_fill_ip4(&curr, ip4_and(n->v4.addr, ip4_mkmask(nlen)), nlen);
else
net_fill_ip6(&curr, ip6_and(n->v6.addr, ip6_mkmask(nlen)), nlen);
net_format(&curr, buf, 64);
log("node: %s", buf);
}
/** /**
* trie_walk_init * trie_walk_init
* @s: walk state * @s: walk state
@ -885,9 +853,6 @@ trie_walk_init(struct f_trie_walk_state *s, const struct f_trie *t, const net_ad
s->local_pos = 1; s->local_pos = 1;
s->accept_length = plen; s->accept_length = plen;
//if (include_successors && (GET_LOCAL(n, v4) < TRIE_LOCAL_MASK(net, nlen, v4)))
//goto find_successor;
if (include_successors) if (include_successors)
{ {
if (GET_LOCAL(n, v4) != 0 && !MATCH_LOCAL_MASK(n, net, nlen, v4)) if (GET_LOCAL(n, v4) != 0 && !MATCH_LOCAL_MASK(n, net, nlen, v4))
@ -904,64 +869,10 @@ trie_walk_init(struct f_trie_walk_state *s, const struct f_trie *t, const net_ad
pos = 2 * pos; pos = 2 * pos;
} }
//if (GET_CHILD(n, v4, bits) != NULL) s->local_pos = pos;
//{ return 0;
s->local_pos = pos;
return 0;
//}
} }
// if (v4)
// {
// struct net_addr_ip4 *net4 = &((net_addr_union *) net)->ip4;
// /* succesor is not in current node */
// if (include_successors && (GET_LOCAL(n, v4) < trie_local_mask4(net4->prefix, net4->pxlen, nlen)))
// goto find_successor;
//
// /* successor could be in current node */
// if (include_successors)
// {
// int pos = 1;
// u32 bits = ip4_getbits(net4->prefix, nlen, TRIE_STEP);
//
// /* calculate pos for local bitmap */
// for (int i = 0; i < net4->pxlen - plen; i++)
// {
// if (bits & (1u << (TRIE_STEP - i - 1)))
// pos = 2 * pos + 1;
// else
// pos = 2 * pos;
// }
//
// if (n->v4.c[bits] != NULL)
// {
// s->local_pos = pos;
// return 1;
// }
//
// /* if the prefix on position pos is present, go one step back */
// if (GET_LOCAL(n, v4) & (1u << pos))
// if (pos == 1)
// {}
// else
// s->local_pos = pos / 2;
// else
// s->local_pos = pos;
//
// return 1;
// }
// }
// else
// {
// struct net_addr_ip6 *net6 = &((net_addr_union *) net)->ip6;
// if (include_successors && (GET_LOCAL(n, v4) < trie_local_mask6(net6->prefix, net6->pxlen, nlen)))
// goto find_successor;
//
// if (include_successors)
// {
// return 1;
// }
// }
} }
else else
{ {
@ -988,61 +899,15 @@ trie_walk_init(struct f_trie_walk_state *s, const struct f_trie *t, const net_ad
{ {
if (s->stack_pos == 0) if (s->stack_pos == 0)
return 0; return 0;
// if (s->stack_pos == 0)
// {
// if (s->stack[0] == NULL)
// { /* no elements, -> invalid state */ log(" return 4 invalid"); return 0; }
//
// /* empty trie with only root node !? */
// bug("couldn't happen");
// }
/* /*
* If we end up on node that has compressed path, we need to step up node * If we end up on node that has compressed path, we need to step up node
* for better decision making * for better decision making
*/ */
// if (n == NULL || (v4 ? n->v4.plen < s->stack[s->stack_pos - 1]->v4.plen :
// n->v6.plen < s->stack[s->stack_pos - 1]->v6.plen && NEXT_PREFIX(n, net, v4)))
// {
// s->stack_pos--;
// n = s->stack[s->stack_pos];
// }
s->stack_pos--; s->stack_pos--;
n = s->stack[s->stack_pos]; n = s->stack[s->stack_pos];
ASSERT(n != NULL); ASSERT(n != NULL);
//u32 nlen = v4 ? n->v4.plen : n->v6.plen;
//s->accept_length = nlen;
//u32 bits = GET_NET_BITS(net, v4, nlen, TRIE_STEP);
//uint nlen = v4 ? n->v4.plen : n->v6.plen;
//u32 bits = GET_NET_BITS(net, v4, nlen, TRIE_STEP);
//const struct f_trie_node *child = GET_CHILD(n, v4, bits);
//if (child != NULL)
//{
// u32 clen; /* child prefix length */
// do
// {
// clen = v4 ? child->v4.plen : child->v6.plen;
// s->stack_pos++;
// s->stack[s->stack_pos] = child;
// s->local_pos = 0x1f;
// n = child;
// nlen = clen;
// bits = GET_NET_BITS(net, v4, nlen, TRIE_STEP);
// child = GET_CHILD(n, v4, bits);
// }
// while (child != NULL && clen > nlen && NEXT_PREFIX(child, net, v4));
//}
//s->accept_length = nlen;
///* the while cycle above wasn't entered */
//if (s->local_pos != 0x1f)
// s->local_pos = 0x10 | bits;
/* We find the nearest successor in subsequent trie_walk_next() */ /* We find the nearest successor in subsequent trie_walk_next() */
int nlen = v4 ? n->v4.plen : n->v6.plen; int nlen = v4 ? n->v4.plen : n->v6.plen;
@ -1050,8 +915,53 @@ trie_walk_init(struct f_trie_walk_state *s, const struct f_trie *t, const net_ad
const struct f_trie_node *child = GET_CHILD(n, v4, bits); const struct f_trie_node *child = GET_CHILD(n, v4, bits);
if (child != NULL) if (child != NULL)
{ {
int clen = v4 ? child->v4.plen : child->v6.plen; /* child prefix length */ s->accept_length = nlen;
/* Performs basically more granular net_comapre_ip{4,6}() */
struct net_addr_ip4 *net4 = NULL;
struct net_addr_ip6 *net6 = NULL;
if (v4) net4 = (struct net_addr_ip4 *) net;
else net6 = (struct net_addr_ip6 *) net;
int cmp = v4 ? ip4_compare(child->v4.addr, net4->prefix)
: ip6_compare(child->v6.addr, net6->prefix);
if (cmp < 0)
{
s->stack_pos++;
s->stack[s->stack_pos] = child;
s->local_pos = 0x1f;
}
else if (cmp > 0)
{
/* We continue in child node */
if (bits % 2 == 0)
s->local_pos = 0x08 + (bits >> 1);
else
s->local_pos = MIN(0x10 + bits, 0x1f);
}
else
{
if (v4 ? child->v4.plen <= net4->pxlen : child->v6.plen < net6->pxlen)
{
/* We continue in child node */
if (bits % 2 == 0)
s->local_pos = 0x08 + (bits >> 1);
else
s->local_pos = MIN(0x10 + bits, 0x1f);
}
else
{
s->stack_pos++;
s->stack[s->stack_pos] = child;
s->local_pos = 0x01;
}
}
return 0;
// TODO handle properly search with short prefix length
int clen =0;
/* We are dealing with a compressed child */ /* We are dealing with a compressed child */
if (clen > nlen + TRIE_STEP) if (clen > nlen + TRIE_STEP)
{ {
@ -1067,63 +977,47 @@ trie_walk_init(struct f_trie_walk_state *s, const struct f_trie *t, const net_ad
s->stack_pos++; s->stack_pos++;
s->stack[s->stack_pos] = child; s->stack[s->stack_pos] = child;
} }
else
die("hidden");
/* successive siblings walk */ /* successive siblings walk */
const struct f_trie_node *ns = NULL; const struct f_trie_node *ns = NULL;
for (u32 i = bits + 1; i < (1u << TRIE_STEP); i++) for (u32 i = bits + 1; i < (1u << TRIE_STEP); i++)
{ {
/* n is parent and ns is older sibling of child */ /* The node n is parent and the node ns is older sibling of the node child */
if ((ns = v4 ? (struct f_trie_node *) n->v4.c[i] : (struct f_trie_node *) n->v6.c[i]) == NULL) if ((ns = v4 ? (struct f_trie_node *) n->v4.c[i] : (struct f_trie_node *) n->v6.c[i]) == NULL)
continue; continue;
//if (GET_NODE_BITS(ns, v4, len, TRIE_STEP) < bits) // TODO
// break; if (!SAME_PREFIX(ns, net, v4, len - TRIE_STEP))
if (GET_NET_BITS(net, v4, len, TRIE_STEP) < bits)
break; break;
if (bits < GET_NODE_BITS(ns, v4, len, TRIE_STEP))
//if (GET_NET_BITS(net, v4, len, TRIE_STEP) < bits)
break;
s->stack[s->stack_pos] = ns;
} }
if (ns == NULL) s->accept_length = len + TRIE_STEP;
ns = child;
//if (GET_NODE_BITS(ns, v4, len, TRIE_STEP) < bits) // if (ns && !SAME_PREFIX(ns, net, v4, len))
// s->local_pos = 0x1f; // {
if (GET_NET_BITS(net, v4, len, TRIE_STEP) < bits) // //s->local_pos = 0x10 + (bits - 1);
s->local_pos = 0x1f; // s->local_pos = 0x1f;
// return 0;
// }
if (GET_NET_BITS(net, v4, len, TRIE_STEP) > GET_NODE_BITS(child, v4, len, TRIE_STEP))
s->local_pos = 0x1f; // + GET_NET_BITS(net, v4, nlen, TRIE_STEP);
else else
s->local_pos = 1; s->local_pos = 0x01; //0x10 + GET_NET_BITS(net, v4, nlen, TRIE_STEP);
s->accept_length = len;
return 0; return 0;
} }
// if (clen > nlen && NEXT_PREFIX(child, net, v4))
// {
// //clen = v4 ? child->v4.plen : child->v6.plen;
//
// s->stack_pos++;
// s->stack[s->stack_pos] = child;
// s->local_pos = 0x1f;
//
// n = child;
// nlen = clen;
//
// bits = GET_NET_BITS(net, v4, nlen, TRIE_STEP);
// child = GET_CHILD(n, v4, bits);
// }
else else
s->local_pos = 0x10 + bits; s->local_pos = 0x10 + bits;
// if (plen > nlen && NEXT_PREFIX(child, net, v4))
// {
// s->stack_pos++;
// s->stack[s->stack_pos] = child;
// s->local_pos = 0x1f;
// }
// if (s->local_pos != 0x1f)
// {
// s->local_pos = 0x10 + bits;
// }
} }
else else
{ {
@ -1132,45 +1026,16 @@ trie_walk_init(struct f_trie_walk_state *s, const struct f_trie *t, const net_ad
nlen = v4 ? n->v4.plen : n->v6.plen; nlen = v4 ? n->v4.plen : n->v6.plen;
s->accept_length = nlen; s->accept_length = nlen;
// if (k4)
// /* compressed child */
// if (n->v4.c[bits] != NULL && n->v4.c[bits]->plen > nlen + TRIE_STEP &&
// ip4_getbits((n->v4.c[bits]->addr), nlen + TRIE_STEP, TRIE_STEP) < ip4_getbits(((net_addr_ip4 *)net)->prefix, nlen + TRIE_STEP, TRIE_STEP))
// {
// s->stack_pos++;
// s->stack[s->stack_pos] = (const struct f_trie_node *) n->v4.c[bits];
// s->local_pos = 0x1f;
// }
// else
// s->local_pos = 0x10 + bits;
// else
// {}
} }
return 0; return 0;
find_successor:; find_successor:;
log("find_successor");
ASSERT(n != NULL); ASSERT(n != NULL);
u32 nlen = v4 ? n->v4.plen : n->v6.plen; u32 nlen = v4 ? n->v4.plen : n->v6.plen;
{
_print_node(n, v4);
}
u32 bits = GET_NET_BITS(net, v4, nlen, TRIE_STEP); u32 bits = GET_NET_BITS(net, v4, nlen, TRIE_STEP);
s->local_pos = 0x10 + bits; s->local_pos = 0x10 + bits;
// //const struct f_trie_node *old = n;
// if (v4)
// {
// struct net_addr_ip4 *addr = &((union net_addr_union *) &local)->ip4;
// u32 bits = ip4_getbits(addr->prefix, nlen, TRIE_STEP);
// /* what about compress nodes ?!? TODO */
// s->local_pos = 0x10 + bits;
// }
// else
// {
// }
return 0; return 0;
} }
@ -1208,7 +1073,7 @@ trie_walk_next(struct f_trie_walk_state *s, net_addr *net)
* 1 * 1
* 2 3 * 2 3
* 4 5 6 7 * 4 5 6 7
* 8 9 A B C D E e * 8 9 A B C D E F
* *
* We walk them depth-first, including virtual positions 10-1F that are * We walk them depth-first, including virtual positions 10-1F that are
* equivalent of position 1 in child nodes 0-F. * equivalent of position 1 in child nodes 0-F.

112
filter/trie_test.c
View File

@ -260,9 +260,10 @@ make_random_prefix_list(int num, int v6, int tight)
get_random_prefix(&px->prefix, v6, tight); get_random_prefix(&px->prefix, v6, tight);
add_tail(prefixes, &px->n); add_tail(prefixes, &px->n);
char buf[64]; //char buf[64];
bt_format_net(buf, 64, &px->prefix.net); //bt_format_net(buf, 64, &px->prefix.net);
bt_debug("ADD %s{%d,%d}\n", buf, px->prefix.lo, px->prefix.hi); //bt_debug("ADD %s{%d,%d}\n", buf, px->prefix.lo, px->prefix.hi);
//log("ADD %s{%d,%d}", buf, px->prefix.lo, px->prefix.hi);
} }
return prefixes; return prefixes;
@ -314,9 +315,9 @@ read_prefix_list(FILE *f, int v6, int plus)
px->prefix.hi = plus ? IP4_MAX_PREFIX_LENGTH : pl; px->prefix.hi = plus ? IP4_MAX_PREFIX_LENGTH : pl;
add_tail(pxlist, &px->n); add_tail(pxlist, &px->n);
char buf[64]; //char buf[64];
bt_format_net(buf, 64, &px->prefix.net); //bt_format_net(buf, 64, &px->prefix.net);
bt_debug("ADD %s{%d,%d}\n", buf, px->prefix.lo, px->prefix.hi); //bt_debug("ADD %s{%d,%d}\n", buf, px->prefix.lo, px->prefix.hi);
} }
bt_syscall(errno, "fgets()"); bt_syscall(errno, "fgets()");
@ -885,6 +886,10 @@ t_trie_walk_inclusive(void)
{ {
bt_bird_init(); bt_bird_init();
bt_config_parse(BT_CONFIG_SIMPLE); bt_config_parse(BT_CONFIG_SIMPLE);
//unsigned int r = rand();
//printf("random seed %u\n", r);
//srandom(r);
//srandom(1985510202);
for (int round = 0; round < TESTS_NUM*8; round++) for (int round = 0; round < TESTS_NUM*8; round++)
{ {
@ -904,39 +909,6 @@ t_trie_walk_inclusive(void)
qsort(pxset, num, sizeof(struct f_prefix), compare_prefixes); qsort(pxset, num, sizeof(struct f_prefix), compare_prefixes);
// print sorted prefixes
bt_debug("sorted prefixes\n");
for (struct f_prefix *px = pxset; px < pxset + num; px++)
{
char buf[64];
bt_format_net(buf, 64, &px->net);
bt_debug("%s{%d,%d}\n", buf, px->lo, px->hi);
}
/* Full walk */
bt_debug("Full walk inclusive (round %d, %d nets)\n", round, num);
pos = 0;
uint pxc = 0;
/* Last argument should have no effect on the walk */
TRIE_WALK2(trie, net, NULL, 1)
{
log_networks(&net, &pxset[pos].net);
bt_assert(net_equal(&net, &pxset[pos].net));
/* Skip possible duplicates */
while (net_equal(&pxset[pos].net, &pxset[pos + 1].net))
pos++;
pos++;
pxc++;
}
TRIE_WALK2_END;
bt_assert(pos == num);
bt_assert(pxc == trie->prefix_count);
bt_debug("Full walk inclusive done\n");
/* Prepare net for subnet walk - start with random prefix from trie */ /* Prepare net for subnet walk - start with random prefix from trie */
if (num) if (num)
@ -994,20 +966,43 @@ t_trie_walk_inclusive(void)
/* Subnet walk */ /* Subnet walk */
TRIE_WALK2(trie, net, &from.net, 1) TRIE_WALK2(trie, net, &from.net, 1)
{ {
log_networks(&net, &pxset[pos].net); bt_assert(net_compare(&net, &pxset[pos].net) >= 0);
//bt_assert(net_compare(&net, &pxset[pos].net) >= 0);
bt_assert(net_compare(&net, &from.net) >= 0); bt_assert(net_compare(&net, &from.net) >= 0);
if (!net_equal(&net, &pxset[pos + 1].net) || !(net_compare(&net, &from.net) >= 0))
{
/* Make sure that net is from inserted prefixes */
bt_format_net(buf0, 64, &net);
bt_debug("got: %s", buf0);
bt_format_net(buf0, 64, &pxset[pos].net);
bt_debug(" expected %s", buf0);
if (pos + 1 < num)
{
bt_format_net(buf0, 64, &pxset[pos + 1].net);
bt_debug(" (next: %s)\n", buf0);
}
else
bt_debug("\n");
}
bt_assert(net_equal(&net, &pxset[pos].net));
bt_assert(net_compare(&net, &from.net) >= 0);
/* Skip possible duplicates */ /* Skip possible duplicates */
while (net_equal(&pxset[pos].net, &pxset[pos + 1].net)) while (net_equal(&pxset[pos].net, &pxset[pos + 1].net))
pos++; pos++;
pos++; pos++;
} }
TRIE_WALK2_END; TRIE_WALK2_END;
bt_assert(pos == num);
bt_debug("pos == num %u %u; p0 %u \n", pos, num, p0);
bt_debug("Subnet walk done inclusive for %s (found %d nets)\n", buf0, pos - p0); bt_debug("Subnet walk done inclusive for %s (found %d nets)\n", buf0, pos - p0);
bt_assert(pos == num);
/* Prepare net for subnet walk - start with random prefix (likely not from trie) */ /* Prepare net for subnet walk - start with random prefix (likely not from trie) */
get_random_prefix(&from, v6, 1); get_random_prefix(&from, v6, 1);
@ -1015,14 +1010,14 @@ t_trie_walk_inclusive(void)
for (pos = 0; pos < num; pos++) for (pos = 0; pos < num; pos++)
{ {
bt_format_net(buf0, 64, &pxset[pos].net); bt_format_net(buf0, 64, &pxset[pos].net);
bt_debug(" -> %s ", buf0); //bt_debug(" -> %s ", buf0);
if (net_compare(&pxset[pos].net, &from.net) >= 0) if (net_compare(&pxset[pos].net, &from.net) >= 0)
{ {
bt_debug("true, breaking\n"); //bt_debug("true, breaking\n");
break; break;
} }
else else
bt_debug("false\n"); {} //bt_debug("false\n");
} }
p0 = pos; p0 = pos;
@ -1032,18 +1027,25 @@ t_trie_walk_inclusive(void)
/* Subnet walk */ /* Subnet walk */
TRIE_WALK2(trie, net, &from.net, 1) TRIE_WALK2(trie, net, &from.net, 1)
{ {
/* Make sure that net is from inserted prefixes */ if (!net_equal(&net, &pxset[pos].net) || !(net_compare(&net, &from.net) >= 0))
bt_format_net(buf0, 64, &net);
bt_debug("got: %s", buf0);
bt_format_net(buf0, 64, &pxset[pos].net);
bt_debug(" expected %s", buf0);
if (pos + 1 < num)
{ {
bt_format_net(buf0, 64, &pxset[pos + 1].net); if (pos < num)
bt_debug(" (next: %s)\n", buf0); {
bt_format_net(buf0, 64, &net);
bt_debug("got: %s", buf0);
bt_format_net(buf0, 64, &pxset[pos].net);
bt_debug(" expected %s", buf0);
}
/* Make sure that net is from inserted prefixes */
if (pos + 1 < num)
{
bt_format_net(buf0, 64, &pxset[pos + 1].net);
bt_debug(" (next: %s)\n", buf0);
}
else
bt_debug("\n");
} }
else
bt_debug("\n");
bt_assert(net_equal(&net, &pxset[pos].net)); bt_assert(net_equal(&net, &pxset[pos].net));
bt_assert(net_compare(&net, &from.net) >= 0); bt_assert(net_compare(&net, &from.net) >= 0);