mirrors/bird
mirrors/bird
0
0
Fork 0
mirror of https://gitlab.nic.cz/labs/bird.git synced 2024-12-22 17:51:53 +00:00
Code Releases Activity

Filter: Improve prefix trie tests

Browse Source 
Add tests explicitly matching insides and outsides of trie and update
tests to do testing of both IPv4 and IPv6 tries.
This commit is contained in:
Ondrej Zajicek (work) 2020-04-21 13:49:29 +02:00
parent dd61278c9d
commit e709dc09e6
3 changed files with 323 additions and 87 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

402
filter/trie_test.c
View File

@ -14,7 +14,7 @@
#include "conf/conf.h" #include "conf/conf.h"
#define TESTS_NUM 10 #define TESTS_NUM 10
#define PREFIXES_NUM 10 #define PREFIXES_NUM 32
#define PREFIX_TESTS_NUM 10000 #define PREFIX_TESTS_NUM 10000
#define BIG_BUFFER_SIZE 10000 #define BIG_BUFFER_SIZE 10000
@ -31,145 +31,371 @@ xrandom(u32 max)
return (bt_random() % max); return (bt_random() % max);
} }
static inline uint
get_exp_random(void)
{
uint r, n = 0;
for (r = bt_random(); r & 1; r = r >> 1)
n++;
return n;
}
static inline int
matching_ip4_nets(const net_addr_ip4 *a, const net_addr_ip4 *b)
{
ip4_addr cmask = ip4_mkmask(MIN(a->pxlen, b->pxlen));
return ip4_compare(ip4_and(a->prefix, cmask), ip4_and(b->prefix, cmask)) == 0;
}
static inline int
matching_ip6_nets(const net_addr_ip6 *a, const net_addr_ip6 *b)
{
ip6_addr cmask = ip6_mkmask(MIN(a->pxlen, b->pxlen));
return ip6_compare(ip6_and(a->prefix, cmask), ip6_and(b->prefix, cmask)) == 0;
}
static inline int
matching_nets(const net_addr *a, const net_addr *b)
{
if (a->type != b->type)
return 0;
return (a->type == NET_IP4) ?
matching_ip4_nets((const net_addr_ip4 *) a, (const net_addr_ip4 *) b) :
matching_ip6_nets((const net_addr_ip6 *) a, (const net_addr_ip6 *) b);
}
static int static int
is_prefix_included(list *prefixes, struct f_prefix *needle) is_prefix_included(list *prefixes, const net_addr *needle)
{ {
struct f_prefix_node *n; struct f_prefix_node *n;
WALK_LIST(n, *prefixes) WALK_LIST(n, *prefixes)
{ if (matching_nets(&n->prefix.net, needle) &&
ip6_addr cmask = ip6_mkmask(MIN(n->prefix.net.pxlen, needle->net.pxlen)); (n->prefix.lo <= needle->pxlen) && (needle->pxlen <= n->prefix.hi))
ip6_addr ip = net6_prefix(&n->prefix.net);
ip6_addr needle_ip = net6_prefix(&needle->net);
if ((ipa_compare(ipa_and(ip, cmask), ipa_and(needle_ip, cmask)) == 0) &&
(n->prefix.lo <= needle->net.pxlen) && (needle->net.pxlen <= n->prefix.hi))
{ {
bt_debug("FOUND\t" PRIip6 "/%d %d-%d\n", ARGip6(net6_prefix(&n->prefix.net)), n->prefix.net.pxlen, n->prefix.lo, n->prefix.hi); char buf[64];
bt_format_net(buf, 64, &n->prefix.net);
bt_debug("FOUND %s %d-%d\n", buf, n->prefix.lo, n->prefix.hi);
return 1; /* OK */ return 1; /* OK */
} }
}
return 0; /* FAIL */ return 0; /* FAIL */
} }
static struct f_prefix static void
get_random_ip6_prefix(void) get_random_net(net_addr *net, int v6)
{ {
struct f_prefix p; if (!v6)
u8 pxlen = xrandom(120)+8;
ip6_addr ip6 = ip6_build(bt_random(),bt_random(),bt_random(),bt_random());
ip6_addr mask = ip6_mkmask(pxlen);
net_addr_ip6 net6 = NET_ADDR_IP6(ip6_and(ip6, mask), pxlen);
p.net = *((net_addr*) &net6);
if (bt_random() % 2)
{ {
p.lo = 0; uint pxlen = xrandom(24)+8;
p.hi = p.net.pxlen; ip4_addr ip4 = ip4_from_u32((u32) bt_random());
net_fill_ip4(net, ip4_and(ip4, ip4_mkmask(pxlen)), pxlen);
} }
else else
{ {
p.lo = p.net.pxlen; uint pxlen = xrandom(120)+8;
p.hi = net_max_prefix_length[p.net.type]; ip6_addr ip6 = ip6_build(bt_random(), bt_random(), bt_random(), bt_random());
net_fill_ip6(net, ip6_and(ip6, ip6_mkmask(pxlen)), pxlen);
} }
return p;
} }
static void static void
generate_random_ipv6_prefixes(list *prefixes) get_random_prefix(struct f_prefix *px, int v6)
{ {
int i; get_random_net(&px->net, v6);
for (i = 0; i < PREFIXES_NUM; i++)
if (bt_random() % 2)
{ {
struct f_prefix f = get_random_ip6_prefix(); px->lo = 0;
px->hi = px->net.pxlen;
struct f_prefix_node *px = calloc(1, sizeof(struct f_prefix_node)); }
px->prefix = f; else
{
bt_debug("ADD\t" PRIip6 "/%d{%d,%d}\n", ARGip6(net6_prefix(&px->prefix.net)), px->prefix.net.pxlen, px->prefix.lo, px->prefix.hi); px->lo = px->net.pxlen;
add_tail(prefixes, &px->n); px->hi = net_max_prefix_length[px->net.type];
} }
} }
static void
get_random_ip4_subnet(net_addr_ip4 *net, const net_addr_ip4 *src, int pxlen)
{
*net = NET_ADDR_IP4(ip4_and(src->prefix, ip4_mkmask(pxlen)), pxlen);
if (pxlen > src->pxlen)
{
ip4_addr rnd = ip4_from_u32((u32) bt_random());
ip4_addr mask = ip4_xor(ip4_mkmask(src->pxlen), ip4_mkmask(pxlen));
net->prefix = ip4_or(net->prefix, ip4_and(rnd, mask));
}
}
static void
get_random_ip6_subnet(net_addr_ip6 *net, const net_addr_ip6 *src, int pxlen)
{
*net = NET_ADDR_IP6(ip6_and(src->prefix, ip6_mkmask(pxlen)), pxlen);
if (pxlen > src->pxlen)
{
ip6_addr rnd = ip6_build(bt_random(), bt_random(), bt_random(), bt_random());
ip6_addr mask = ip6_xor(ip6_mkmask(src->pxlen), ip6_mkmask(pxlen));
net->prefix = ip6_or(net->prefix, ip6_and(rnd, mask));
}
}
static void
get_random_subnet(net_addr *net, const net_addr *src, int pxlen)
{
if (src->type == NET_IP4)
get_random_ip4_subnet((net_addr_ip4 *) net, (const net_addr_ip4 *) src, pxlen);
else
get_random_ip6_subnet((net_addr_ip6 *) net, (const net_addr_ip6 *) src, pxlen);
}
static void
get_inner_net(net_addr *net, const struct f_prefix *src)
{
int pxlen, step;
if (bt_random() % 2)
{
step = get_exp_random();
step = MIN(step, src->hi - src->lo);
pxlen = (bt_random() % 2) ? (src->lo + step) : (src->hi - step);
}
else
pxlen = src->lo + bt_random() % (src->hi - src->lo + 1);
get_random_subnet(net, &src->net, pxlen);
}
static void
swap_random_bits_ip4(net_addr_ip4 *net, int num)
{
for (int i = 0; i < num; i++)
{
ip4_addr swap = IP4_NONE;
ip4_setbit(&swap, bt_random() % net->pxlen);
net->prefix = ip4_xor(net->prefix, swap);
}
}
static void
swap_random_bits_ip6(net_addr_ip6 *net, int num)
{
for (int i = 0; i < num; i++)
{
ip6_addr swap = IP6_NONE;
ip6_setbit(&swap, bt_random() % net->pxlen);
net->prefix = ip6_xor(net->prefix, swap);
}
}
static void
swap_random_bits(net_addr *net, int num)
{
if (net->type == NET_IP4)
swap_random_bits_ip4((net_addr_ip4 *) net, num);
else
swap_random_bits_ip6((net_addr_ip6 *) net, num);
}
static void
get_outer_net(net_addr *net, const struct f_prefix *src)
{
int pxlen, step;
int inside = 0;
int max = net_max_prefix_length[src->net.type];
if ((src->lo > 0) && (bt_random() % 3))
{
step = 1 + get_exp_random();
step = MIN(step, src->lo);
pxlen = src->lo - step;
}
else if ((src->hi < max) && (bt_random() % 2))
{
step = 1 + get_exp_random();
step = MIN(step, max - src->hi);
pxlen = src->hi + step;
}
else
{
pxlen = src->lo + bt_random() % (src->hi - src->lo + 1);
inside = 1;
}
get_random_subnet(net, &src->net, pxlen);
/* Perhaps swap some bits in prefix */
if ((net->pxlen > 0) && (inside || (bt_random() % 4)))
swap_random_bits(net, 1 + get_exp_random());
}
static list *
make_random_prefix_list(linpool *lp, int num, int v6)
{
list *prefixes = lp_allocz(lp, sizeof(struct f_prefix_node));
init_list(prefixes);
for (int i = 0; i < num; i++)
{
struct f_prefix_node *px = lp_allocz(lp, sizeof(struct f_prefix_node));
get_random_prefix(&px->prefix, v6);
add_tail(prefixes, &px->n);
char buf[64];
bt_format_net(buf, 64, &px->prefix.net);
bt_debug("ADD %s{%d,%d}\n", buf, px->prefix.lo, px->prefix.hi);
}
return prefixes;
}
static struct f_trie *
make_trie_from_prefix_list(linpool *lp, list *prefixes)
{
struct f_trie *trie = f_new_trie(lp, 0);
struct f_prefix_node *n;
WALK_LIST(n, *prefixes)
trie_add_prefix(trie, &n->prefix.net, n->prefix.lo, n->prefix.hi);
return trie;
}
static void
test_match_net(list *prefixes, struct f_trie *trie, const net_addr *net)
{
char buf[64];
bt_format_net(buf, 64, net);
bt_debug("TEST %s\n", buf);
int should_be = is_prefix_included(prefixes, net);
int is_there = trie_match_net(trie, net);
bt_assert_msg(should_be == is_there, "Prefix %s %s match", buf,
(should_be ? "should" : "should not"));
}
static int static int
t_match_net(void) t_match_random_net(void)
{ {
bt_bird_init(); bt_bird_init();
bt_config_parse(BT_CONFIG_SIMPLE); bt_config_parse(BT_CONFIG_SIMPLE);
uint round; int v6 = 0;
for (round = 0; round < TESTS_NUM; round++) linpool *lp = lp_new_default(&root_pool);
for (int round = 0; round < TESTS_NUM; round++)
{ {
list prefixes; /* of structs f_extended_prefix */ list *prefixes = make_random_prefix_list(lp, PREFIXES_NUM, v6);
init_list(&prefixes); struct f_trie *trie = make_trie_from_prefix_list(lp, prefixes);
struct f_trie *trie = f_new_trie(config->mem, 0);
generate_random_ipv6_prefixes(&prefixes); for (int i = 0; i < PREFIX_TESTS_NUM; i++)
struct f_prefix_node *n;
WALK_LIST(n, prefixes)
{ {
trie_add_prefix(trie, &n->prefix.net, n->prefix.lo, n->prefix.hi); net_addr net;
get_random_net(&net, v6);
test_match_net(prefixes, trie, &net);
} }
int i; v6 = !v6;
for (i = 0; i < PREFIX_TESTS_NUM; i++) lp_flush(lp);
{
struct f_prefix f = get_random_ip6_prefix();
bt_debug("TEST\t" PRIip6 "/%d\n", ARGip6(net6_prefix(&f.net)), f.net.pxlen);
int should_be = is_prefix_included(&prefixes, &f);
int is_there = trie_match_net(trie, &f.net);
bt_assert_msg(should_be == is_there, "Prefix " PRIip6 "/%d %s", ARGip6(net6_prefix(&f.net)), f.net.pxlen, (should_be ? "should be found in trie" : "should not be found in trie"));
}
struct f_prefix_node *nxt;
WALK_LIST_DELSAFE(n, nxt, prefixes)
{
free(n);
}
} }
bt_bird_cleanup(); bt_bird_cleanup();
return 1; return 1;
} }
static int
t_match_inner_net(void)
{
bt_bird_init();
bt_config_parse(BT_CONFIG_SIMPLE);
int v6 = 0;
linpool *lp = lp_new_default(&root_pool);
for (int round = 0; round < TESTS_NUM; round++)
{
list *prefixes = make_random_prefix_list(lp, PREFIXES_NUM, v6);
struct f_trie *trie = make_trie_from_prefix_list(lp, prefixes);
struct f_prefix_node *n = HEAD(*prefixes);
for (int i = 0; i < PREFIX_TESTS_NUM; i++)
{
net_addr net;
get_inner_net(&net, &n->prefix);
test_match_net(prefixes, trie, &net);
n = NODE_VALID(NODE_NEXT(n)) ? NODE_NEXT(n) : HEAD(*prefixes);
}
v6 = !v6;
lp_flush(lp);
}
bt_bird_cleanup();
return 1;
}
static int
t_match_outer_net(void)
{
bt_bird_init();
bt_config_parse(BT_CONFIG_SIMPLE);
int v6 = 0;
linpool *lp = lp_new_default(&root_pool);
for (int round = 0; round < TESTS_NUM; round++)
{
list *prefixes = make_random_prefix_list(lp, PREFIXES_NUM, v6);
struct f_trie *trie = make_trie_from_prefix_list(lp, prefixes);
struct f_prefix_node *n = HEAD(*prefixes);
for (int i = 0; i < PREFIX_TESTS_NUM; i++)
{
net_addr net;
get_outer_net(&net, &n->prefix);
test_match_net(prefixes, trie, &net);
n = NODE_VALID(NODE_NEXT(n)) ? NODE_NEXT(n) : HEAD(*prefixes);
}
v6 = !v6;
lp_flush(lp);
}
v6 = !v6;
bt_bird_cleanup();
return 1;
}
static int static int
t_trie_same(void) t_trie_same(void)
{ {
bt_bird_init(); bt_bird_init();
bt_config_parse(BT_CONFIG_SIMPLE); bt_config_parse(BT_CONFIG_SIMPLE);
int round; int v6 = 0;
for (round = 0; round < TESTS_NUM*4; round++) linpool *lp = lp_new_default(&root_pool);
for (int round = 0; round < TESTS_NUM*4; round++)
{ {
struct f_trie * trie1 = f_new_trie(config->mem, 0); list *prefixes = make_random_prefix_list(lp, 100 * PREFIXES_NUM, v6);
struct f_trie * trie2 = f_new_trie(config->mem, 0); struct f_trie *trie1 = f_new_trie(lp, 0);
struct f_trie *trie2 = f_new_trie(lp, 0);
list prefixes; /* a list of f_extended_prefix structures */
init_list(&prefixes);
int i;
for (i = 0; i < 100; i++)
generate_random_ipv6_prefixes(&prefixes);
struct f_prefix_node *n; struct f_prefix_node *n;
WALK_LIST(n, prefixes) WALK_LIST(n, *prefixes)
{
trie_add_prefix(trie1, &n->prefix.net, n->prefix.lo, n->prefix.hi); trie_add_prefix(trie1, &n->prefix.net, n->prefix.lo, n->prefix.hi);
}
WALK_LIST_BACKWARDS(n, prefixes) WALK_LIST_BACKWARDS(n, *prefixes)
{
trie_add_prefix(trie2, &n->prefix.net, n->prefix.lo, n->prefix.hi); trie_add_prefix(trie2, &n->prefix.net, n->prefix.lo, n->prefix.hi);
}
bt_assert(trie_same(trie1, trie2)); bt_assert(trie_same(trie1, trie2));
struct f_prefix_node *nxt; v6 = !v6;
WALK_LIST_DELSAFE(n, nxt, prefixes) lp_flush(lp);
{
free(n);
}
} }
return 1; return 1;
@ -180,7 +406,9 @@ main(int argc, char *argv[])
{ {
bt_init(argc, argv); bt_init(argc, argv);
bt_test_suite(t_match_net, "Testing random prefix matching"); bt_test_suite(t_match_random_net, "Testing random prefix matching");
bt_test_suite(t_match_inner_net, "Testing random inner prefix matching");
bt_test_suite(t_match_outer_net, "Testing random outer prefix matching");
bt_test_suite(t_trie_same, "A trie filled forward should be same with a trie filled backward."); bt_test_suite(t_trie_same, "A trie filled forward should be same with a trie filled backward.");
return bt_exit_value(); return bt_exit_value();

6
test/birdtest.c
View File

@ -501,6 +501,12 @@ bt_fmt_ipa(char *buf, size_t size, const void *data)
bsnprintf(buf, size, "(null)"); bsnprintf(buf, size, "(null)");
} }
void
bt_format_net(char *buf, size_t size, const void *data)
{
bsnprintf(buf, size, "%N", (const net_addr *) data);
}
int int
bt_is_char(byte c) bt_is_char(byte c)
{ {

2
test/birdtest.h
View File

@ -165,6 +165,8 @@ struct bt_batch {
void bt_fmt_str(char *buf, size_t size, const void *data); void bt_fmt_str(char *buf, size_t size, const void *data);
void bt_fmt_unsigned(char *buf, size_t size, const void *data); void bt_fmt_unsigned(char *buf, size_t size, const void *data);
void bt_fmt_ipa(char *buf, size_t size, const void *data); void bt_fmt_ipa(char *buf, size_t size, const void *data);
void bt_format_net(char *buf, size_t size, const void *data);
int bt_assert_batch__(struct bt_batch *opts); int bt_assert_batch__(struct bt_batch *opts);
int bt_is_char(byte c); int bt_is_char(byte c);