Filter: Improve prefix trie tests

Add tests explicitly matching insides and outsides of trie and update
tests to do testing of both IPv4 and IPv6 tries.

filter/trie_test.c

@@ -14,7 +14,7 @@
 #include "conf/conf.h"
 
 #define TESTS_NUM		10
-#define PREFIXES_NUM 		10
+#define PREFIXES_NUM 		32
 #define PREFIX_TESTS_NUM 	10000
 
 #define BIG_BUFFER_SIZE		10000
@@ -31,145 +31,371 @@ xrandom(u32 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
-is_prefix_included(list *prefixes, struct f_prefix *needle)
+is_prefix_included(list *prefixes, const net_addr *needle)
 {
   struct f_prefix_node *n;
   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 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
   {
-    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
-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
-t_match_net(void)
+t_match_random_net(void)
 {
   bt_bird_init();
   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();
   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
 t_trie_same(void)
 {
   bt_bird_init();
   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;
-    WALK_LIST(n, prefixes)
+    WALK_LIST(n, *prefixes)
-    {
       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);
-    }
 
     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;
@@ -180,7 +406,9 @@ main(int argc, char *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.");
 
   return bt_exit_value();

test/birdtest.c

@@ -501,6 +501,12 @@ bt_fmt_ipa(char *buf, size_t size, const void *data)
     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
 bt_is_char(byte c)
 {

test/birdtest.h

@@ -165,6 +165,8 @@ struct bt_batch {
 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_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_is_char(byte c);