Merge branch 'oz-trie-table'

4 files changed, 1716 insertions, 215 deletions

diff --git a/filter/data.h b/filter/data.h
index bb815c34..4cb6b7a8 100644
--- a/filter/data.h
+++ b/filter/data.h
@@ -140,18 +140,23 @@ struct f_tree {
   void *data;
 };
 
+#define TRIE_STEP		4
+#define TRIE_STACK_LENGTH	33
+
 struct f_trie_node4
 {
   ip4_addr addr, mask, accept;
-  uint plen;
-  struct f_trie_node4 *c[2];
+  u16 plen;
+  u16 local;
+  struct f_trie_node4 *c[1 << TRIE_STEP];
 };
 
 struct f_trie_node6
 {
   ip6_addr addr, mask, accept;
-  uint plen;
-  struct f_trie_node6 *c[2];
+  u16 plen;
+  u16 local;
+  struct f_trie_node6 *c[1 << TRIE_STEP];
 };
 
 struct f_trie_node
@@ -168,9 +173,20 @@ struct f_trie
   u8 zero;
   s8 ipv4;				/* -1 for undefined / empty */
   u16 data_size;			/* Additional data for each trie node */
+  u32 prefix_count;			/* Works only for restricted tries (pxlen == l == h) */
   struct f_trie_node root;		/* Root trie node */
 };
 
+struct f_trie_walk_state
+{
+  u8 ipv4;
+  u8 accept_length;			/* Current inter-node prefix position */
+  u8 start_pos;				/* Initial prefix position in stack[0] */
+  u8 local_pos;				/* Current intra-node prefix position */
+  u8 stack_pos;				/* Current node in stack below */
+  const struct f_trie_node *stack[TRIE_STACK_LENGTH];
+};
+
 struct f_tree *f_new_tree(void);
 struct f_tree *build_tree(struct f_tree *);
 const struct f_tree *find_tree(const struct f_tree *t, const struct f_val *val);
@@ -181,9 +197,70 @@ void tree_walk(const struct f_tree *t, void (*hook)(const struct f_tree *, void
 struct f_trie *f_new_trie(linpool *lp, uint data_size);
 void *trie_add_prefix(struct f_trie *t, const net_addr *n, uint l, uint h);
 int trie_match_net(const struct f_trie *t, const net_addr *n);
+int trie_match_longest_ip4(const struct f_trie *t, const net_addr_ip4 *net, net_addr_ip4 *dst, ip4_addr *found0);
+int trie_match_longest_ip6(const struct f_trie *t, const net_addr_ip6 *net, net_addr_ip6 *dst, ip6_addr *found0);
+void trie_walk_init(struct f_trie_walk_state *s, const struct f_trie *t, const net_addr *from);
+int trie_walk_next(struct f_trie_walk_state *s, net_addr *net);
 int trie_same(const struct f_trie *t1, const struct f_trie *t2);
 void trie_format(const struct f_trie *t, buffer *buf);
 
+static inline int
+trie_match_next_longest_ip4(net_addr_ip4 *n, ip4_addr *found)
+{
+  while (n->pxlen)
+  {
+    n->pxlen--;
+    ip4_clrbit(&n->prefix, n->pxlen);
+
+    if (ip4_getbit(*found, n->pxlen))
+      return 1;
+  }
+
+  return 0;
+}
+
+static inline int
+trie_match_next_longest_ip6(net_addr_ip6 *n, ip6_addr *found)
+{
+  while (n->pxlen)
+  {
+    n->pxlen--;
+    ip6_clrbit(&n->prefix, n->pxlen);
+
+    if (ip6_getbit(*found, n->pxlen))
+      return 1;
+  }
+
+  return 0;
+}
+
+
+#define TRIE_WALK_TO_ROOT_IP4(trie, net, dst) ({		\
+  net_addr_ip4 dst;						\
+  ip4_addr _found;						\
+  for (int _n = trie_match_longest_ip4(trie, net, &dst, &_found); \
+       _n;							\
+       _n = trie_match_next_longest_ip4(&dst, &_found))
+
+#define TRIE_WALK_TO_ROOT_IP6(trie, net, dst) ({		\
+  net_addr_ip6 dst;						\
+  ip6_addr _found;						\
+  for (int _n = trie_match_longest_ip6(trie, net, &dst, &_found); \
+       _n;							\
+       _n = trie_match_next_longest_ip6(&dst, &_found))
+
+#define TRIE_WALK_TO_ROOT_END })
+
+
+#define TRIE_WALK(trie, net, from) ({				\
+  net_addr net;							\
+  struct f_trie_walk_state tws_;				\
+  trie_walk_init(&tws_, trie, from);				\
+  while (trie_walk_next(&tws_, &net))
+
+#define TRIE_WALK_END })
+
+
 #define F_CMP_ERROR 999
 
 const char *f_type_name(enum f_type t);
diff --git a/filter/test.conf b/filter/test.conf
index f902f99f..484628e5 100644
--- a/filter/test.conf
+++ b/filter/test.conf
@@ -499,6 +499,33 @@ prefix set pxs;
 
 	bt_assert(1.2.0.0/16 ~ [ 1.0.0.0/8{ 15 , 17 } ]);
 	bt_assert([ 10.0.0.0/8{ 15 , 17 } ] != [ 11.0.0.0/8{ 15 , 17 } ]);
+
+	/* Formatting of prefix sets, some cases are a bit strange */
+	bt_assert(format([ 0.0.0.0/0 ]) = "[0.0.0.0/0]");
+	bt_assert(format([ 10.10.0.0/32 ]) = "[10.10.0.0/32{0.0.0.1}]");
+	bt_assert(format([ 10.10.0.0/17 ]) = "[10.10.0.0/17{0.0.128.0}]");
+	bt_assert(format([ 10.10.0.0/17{17,19} ]) = "[10.10.0.0/17{0.0.224.0}]"); # 224 = 128+64+32
+	bt_assert(format([ 10.10.128.0/17{18,19} ]) = "[10.10.128.0/18{0.0.96.0}, 10.10.192.0/18{0.0.96.0}]"); # 96 = 64+32
+	bt_assert(format([ 10.10.64.0/18- ]) = "[0.0.0.0/0, 0.0.0.0/1{128.0.0.0}, 0.0.0.0/2{64.0.0.0}, 0.0.0.0/3{32.0.0.0}, 10.10.0.0/16{255.255.0.0}, 10.10.0.0/17{0.0.128.0}, 10.10.64.0/18{0.0.64.0}]");
+	bt_assert(format([ 10.10.64.0/18+ ]) = "[10.10.64.0/18{0.0.96.0}, 10.10.64.0/20{0.0.31.255}, 10.10.80.0/20{0.0.31.255}, 10.10.96.0/20{0.0.31.255}, 10.10.112.0/20{0.0.31.255}]");
+
+	bt_assert(format([ 10.10.160.0/19 ]) = "[10.10.160.0/19{0.0.32.0}]");
+	bt_assert(format([ 10.10.160.0/19{19,22} ]) = "[10.10.160.0/19{0.0.32.0}, 10.10.160.0/20{0.0.28.0}, 10.10.176.0/20{0.0.28.0}]"); # 28 = 16+8+4
+	bt_assert(format([ 10.10.160.0/19+ ]) = "[10.10.160.0/19{0.0.32.0}, 10.10.160.0/20{0.0.31.255}, 10.10.176.0/20{0.0.31.255}]");
+
+	bt_assert(format([ ::/0 ]) = "[::/0]");
+	bt_assert(format([ 11:22:33:44:55:66:77:88/128 ]) = "[11:22:33:44:55:66:77:88/128{::1}]");
+	bt_assert(format([ 11:22:33:44::/64 ]) = "[11:22:33:44::/64{0:0:0:1::}]");
+	bt_assert(format([ 11:22:33:44::/64+ ]) = "[11:22:33:44::/64{::1:ffff:ffff:ffff:ffff}]");
+
+	bt_assert(format([ 11:22:33:44::/65 ]) = "[11:22:33:44::/65{::8000:0:0:0}]");
+	bt_assert(format([ 11:22:33:44::/65{65,67} ]) = "[11:22:33:44::/65{::e000:0:0:0}]"); # e = 8+4+2
+	bt_assert(format([ 11:22:33:44:8000::/65{66,67} ]) = "[11:22:33:44:8000::/66{::6000:0:0:0}, 11:22:33:44:c000::/66{::6000:0:0:0}]"); # 6 = 4+2
+	bt_assert(format([ 11:22:33:44:4000::/66- ]) = "[::/0, ::/1{8000::}, ::/2{4000::}, ::/3{2000::}, 11:22:33:44::/64{ffff:ffff:ffff:ffff::}, 11:22:33:44::/65{::8000:0:0:0}, 11:22:33:44:4000::/66{::4000:0:0:0}]");
+	bt_assert(format([ 11:22:33:44:4000::/66+ ]) = "[11:22:33:44:4000::/66{::6000:0:0:0}, 11:22:33:44:4000::/68{::1fff:ffff:ffff:ffff}, 11:22:33:44:5000::/68{::1fff:ffff:ffff:ffff}, 11:22:33:44:6000::/68{::1fff:ffff:ffff:ffff}, 11:22:33:44:7000::/68{::1fff:ffff:ffff:ffff}]");
+	bt_assert(format([ 11:22:33:44:c000::/67 ]) = "[11:22:33:44:c000::/67{::2000:0:0:0}]");
+	bt_assert(format([ 11:22:33:44:c000::/67{67,71} ]) = "[11:22:33:44:c000::/67{::2000:0:0:0}, 11:22:33:44:c000::/68{::1e00:0:0:0}, 11:22:33:44:d000::/68{::1e00:0:0:0}]");
+	bt_assert(format([ 11:22:33:44:c000::/67+ ]) = "[11:22:33:44:c000::/67{::2000:0:0:0}, 11:22:33:44:c000::/68{::1fff:ffff:ffff:ffff}, 11:22:33:44:d000::/68{::1fff:ffff:ffff:ffff}]");
 }
 
 bt_test_suite(t_prefix_set, "Testing prefix sets");
@@ -578,6 +605,12 @@ prefix set pxs;
 	bt_assert(2000::/29 !~ pxs);
 	bt_assert(1100::/10 !~ pxs);
 	bt_assert(2010::/26 !~ pxs);
+
+	pxs = [ 52E0::/13{13,128} ];
+	bt_assert(52E7:BE81:379B:E6FD:541F:B0D0::/93 ~ pxs);
+
+	pxs = [ 41D8:8718::/30{0,30}, 413A:99A8:6C00::/38{38,128} ];
+	bt_assert(4180::/9 ~ pxs);
 }
 
 bt_test_suite(t_prefix6_set, "Testing prefix IPv6 sets");
diff --git a/filter/trie.c b/filter/trie.c
index 1a4e1ac3..12ba0b82 100644
--- a/filter/trie.c
+++ b/filter/trie.c
@@ -1,7 +1,8 @@
 /*
  *	Filters: Trie for prefix sets
  *
- *	Copyright 2009 Ondrej Zajicek <santiago@crfreenet.org>
+ *	(c) 2009--2021 Ondrej Zajicek <santiago@crfreenet.org>
+ *	(c) 2009--2021 CZ.NIC z.s.p.o.
  *
  *	Can be freely distributed and used under the terms of the GNU GPL.
  */
@@ -9,53 +10,68 @@
 /**
  * DOC: Trie for prefix sets
  *
- * We use a (compressed) trie to represent prefix sets. Every node
- * in the trie represents one prefix (&addr/&plen) and &plen also
- * indicates the index of the bit in the address that is used to
- * branch at the node. If we need to represent just a set of
- * prefixes, it would be simple, but we have to represent a
- * set of prefix patterns. Each prefix pattern consists of
- * &ppaddr/&pplen and two integers: &low and &high, and a prefix
- * &paddr/&plen matches that pattern if the first MIN(&plen, &pplen)
- * bits of &paddr and &ppaddr are the same and &low <= &plen <= &high.
- *
- * We use a bitmask (&accept) to represent accepted prefix lengths
- * at a node. As there are 33 prefix lengths (0..32 for IPv4), but
- * there is just one prefix of zero length in the whole trie so we
- * have &zero flag in &f_trie (indicating whether the trie accepts
- * prefix 0.0.0.0/0) as a special case, and &accept bitmask
+ * We use a (compressed) trie to represent prefix sets. Every node in the trie
+ * represents one prefix (&addr/&plen) and &plen also indicates the index of
+ * bits in the address that are used to branch at the node. Note that such
+ * prefix is not necessary a member of the prefix set, it is just a canonical
+ * prefix associated with a node. Prefix lengths of nodes are aligned to
+ * multiples of &TRIE_STEP (4) and there is 16-way branching in each
+ * node. Therefore, we say that a node is associated with a range of prefix
+ * lengths (&plen .. &plen + TRIE_STEP - 1).
+ *
+ * The prefix set is not just a set of prefixes, it is defined by a set of
+ * prefix patterns. Each prefix pattern consists of &ppaddr/&pplen and two
+ * integers: &low and &high. The tested prefix &paddr/&plen matches that pattern
+ * if the first MIN(&plen, &pplen) bits of &paddr and &ppaddr are the same and
+ * &low <= &plen <= &high.
+ *
+ * There are two ways to represent accepted prefixes for a node. First, there is
+ * a bitmask &local, which represents independently all 15 prefixes that extend
+ * the canonical prefix of the node and are within a range of prefix lengths
+ * associated with the node. E.g., for node 10.0.0.0/8 they are 10.0.0.0/8,
+ * 10.0.0.0/9, 10.128.0.0/9, .. 10.224.0.0/11. This order (first by length, then
+ * lexicographically) is used for indexing the bitmask &local, starting at
+ * position 1. I.e., index is 2^(plen - base) + offset within the same length,
+ * see function trie_local_mask6() for details.
+ *
+ * Second, we use a bitmask &accept to represent accepted prefix lengths at a
+ * node. The bit is set means that all prefixes of given length that are either
+ * subprefixes or superprefixes of the canonical prefix are accepted. As there
+ * are 33 prefix lengths (0..32 for IPv4), but there is just one prefix of zero
+ * length in the whole trie so we have &zero flag in &f_trie (indicating whether
+ * the trie accepts prefix 0.0.0.0/0) as a special case, and &accept bitmask
  * represents accepted prefix lengths from 1 to 32.
  *
- * There are two cases in prefix matching - a match when the length
- * of the prefix is smaller that the length of the prefix pattern,
- * (&plen < &pplen) and otherwise. The second case is simple - we
- * just walk through the trie and look at every visited node
- * whether that prefix accepts our prefix length (&plen). The
- * first case is tricky - we don't want to examine every descendant
- * of a final node, so (when we create the trie) we have to propagate
- * that information from nodes to their ascendants.
- *
- * Suppose that we have two masks (M1 and M2) for a node. Mask M1
- * represents accepted prefix lengths by just the node and mask M2
- * represents accepted prefix lengths by the node or any of its
- * descendants. Therefore M2 is a bitwise or of M1 and children's
- * M2 and this is a maintained invariant during trie building.
- * Basically, when we want to match a prefix, we walk through the trie,
- * check mask M1 for our prefix length and when we came to
- * final node, we check mask M2.
- *
- * There are two differences in the real implementation. First,
- * we use a compressed trie so there is a case that we skip our
- * final node (if it is not in the trie) and we came to node that
- * is either extension of our prefix, or completely out of path
- * In the first case, we also have to check M2.
- *
- * Second, we really need not to maintain two separate bitmasks.
- * Checks for mask M1 are always larger than &applen and we need
- * just the first &pplen bits of mask M2 (if trie compression
- * hadn't been used it would suffice to know just $applen-th bit),
- * so we have to store them together in &accept mask - the first
- * &pplen bits of mask M2 and then mask M1.
+ * One complication is handling of prefix patterns with unaligned prefix length.
+ * When such pattern is to be added, we add a primary node above (with rounded
+ * down prefix length &nlen) and a set of secondary nodes below (with rounded up
+ * prefix lengths &slen). Accepted prefix lengths of the original prefix pattern
+ * are then represented in different places based on their lengths. For prefixes
+ * shorter than &nlen, it is &accept bitmask of the primary node, for prefixes
+ * between &nlen and &slen - 1 it is &local bitmask of the primary node, and for
+ * prefixes longer of equal &slen it is &accept bitmasks of secondary nodes.
+ *
+ * There are two cases in prefix matching - a match when the length of the
+ * prefix is smaller that the length of the prefix pattern, (&plen < &pplen) and
+ * otherwise. The second case is simple - we just walk through the trie and look
+ * at every visited node whether that prefix accepts our prefix length (&plen).
+ * The first case is tricky - we do not want to examine every descendant of a
+ * final node, so (when we create the trie) we have to propagate that
+ * information from nodes to their ascendants.
+ *
+ * There are two kinds of propagations - propagation from child's &accept
+ * bitmask to parent's &accept bitmask, and propagation from child's &accept
+ * bitmask to parent's &local bitmask. The first kind is simple - as all
+ * superprefixes of a parent are also all superprefixes of appropriate length of
+ * a child, then we can just add (by bitwise or) a child &accept mask masked by
+ * parent prefix length mask to the parent &accept mask. This handles prefixes
+ * shorter than node &plen.
+ *
+ * The second kind of propagation is necessary to handle superprefixes of a
+ * child that are represented by parent &local mask - that are in the range of
+ * prefix lengths associated with the parent. For each accepted (by child
+ * &accept mask) prefix length from that range, we need to set appropriate bit
+ * in &local mask. See function trie_amask_to_local() for details.
  *
  * There are four cases when we walk through a trie:
  *
@@ -65,8 +81,32 @@
  * - we are beyond the end of path (node length > &plen)
  * - we are still on path and keep walking (node length < &plen)
  *
- * The walking code in trie_match_prefix() is structured according to
- * these cases.
+ * The walking code in trie_match_net() is structured according to these cases.
+ *
+ * Iteration over prefixes in a trie can be done using TRIE_WALK() macro, or
+ * directly using trie_walk_init() and trie_walk_next() functions. The second
+ * approach allows suspending the iteration and continuing in it later.
+ * Prefixes are enumerated in the usual lexicographic order and may be
+ * restricted to a subset of the trie (all subnets of a specified prefix).
+ *
+ * Note that the trie walk does not reliably enumerate `implicit' prefixes
+ * defined by &low and &high fields in prefix patterns, it is supposed to be
+ * used on tries constructed from `explicit' prefixes (&low == &plen == &high
+ * in call to trie_add_prefix()).
+ *
+ * The trie walk has three basic state variables stored in the struct
+ * &f_trie_walk_state -- the current node in &stack[stack_pos], &accept_length
+ * for iteration over inter-node prefixes (non-branching prefixes on compressed
+ * path between the current node and its parent node, stored in the bitmap
+ * &accept of the current node) and &local_pos for iteration over intra-node
+ * prefixes (stored in the bitmap &local).
+ *
+ * The trie also supports longest-prefix-match query by trie_match_longest_ip4()
+ * and it can be extended to iteration over all covering prefixes for a given
+ * prefix (from longest to shortest) using TRIE_WALK_TO_ROOT_IP4() macro. There
+ * are also IPv6 versions (for practical reasons, these functions and macros are
+ * separate for IPv4 and IPv6). There is the same limitation to enumeration of
+ * `implicit' prefixes like with the previous TRIE_WALK() macro.
  */
 
 #include "nest/bird.h"
@@ -86,7 +126,10 @@
 #define ipa_mkmask(x) ip6_mkmask(x)
 #define ipa_masklen(x) ip6_masklen(&x)
 #define ipa_pxlen(x,y) ip6_pxlen(x,y)
-#define ipa_getbit(x,n) ip6_getbit(x,n)
+#define ipa_getbit(a,p) ip6_getbit(a,p)
+#define ipa_getbits(a,p,n) ip6_getbits(a,p,n)
+#define ipa_setbits(a,p,n) ip6_setbits(a,p,n)
+#define trie_local_mask(a,b,c) trie_local_mask6(a,b,c)
 
 #define ipt_from_ip4(x) _MI6(_I(x), 0, 0, 0)
 #define ipt_to_ip4(x) _MI4(_I0(x))
@@ -109,10 +152,11 @@ f_new_trie(linpool *lp, uint data_size)
 }
 
 static inline struct f_trie_node4 *
-new_node4(struct f_trie *t, int plen, ip4_addr paddr, ip4_addr pmask, ip4_addr amask)
+new_node4(struct f_trie *t, uint plen, uint local, ip4_addr paddr, ip4_addr pmask, ip4_addr amask)
 {
   struct f_trie_node4 *n = lp_allocz(t->lp, sizeof(struct f_trie_node4) + t->data_size);
   n->plen = plen;
+  n->local = local;
   n->addr = paddr;
   n->mask = pmask;
   n->accept = amask;
@@ -120,10 +164,11 @@ new_node4(struct f_trie *t, int plen, ip4_addr paddr, ip4_addr pmask, ip4_addr a
 }
 
 static inline struct f_trie_node6 *
-new_node6(struct f_trie *t, int plen, ip6_addr paddr, ip6_addr pmask, ip6_addr amask)
+new_node6(struct f_trie *t, uint plen, uint local, ip6_addr paddr, ip6_addr pmask, ip6_addr amask)
 {
   struct f_trie_node6 *n = lp_allocz(t->lp, sizeof(struct f_trie_node6) + t->data_size);
   n->plen = plen;
+  n->local = local;
   n->addr = paddr;
   n->mask = pmask;
   n->accept = amask;
@@ -131,24 +176,24 @@ new_node6(struct f_trie *t, int plen, ip6_addr paddr, ip6_addr pmask, ip6_addr a
 }
 
 static inline struct f_trie_node *
-new_node(struct f_trie *t, int plen, ip_addr paddr, ip_addr pmask, ip_addr amask)
+new_node(struct f_trie *t, uint plen, uint local, ip_addr paddr, ip_addr pmask, ip_addr amask)
 {
   if (t->ipv4)
-    return (struct f_trie_node *) new_node4(t, plen, ipt_to_ip4(paddr), ipt_to_ip4(pmask), ipt_to_ip4(amask));
+    return (struct f_trie_node *) new_node4(t, plen, local, ipt_to_ip4(paddr), ipt_to_ip4(pmask), ipt_to_ip4(amask));
   else
-    return (struct f_trie_node *) new_node6(t, plen, ipa_to_ip6(paddr), ipa_to_ip6(pmask), ipa_to_ip6(amask));
+    return (struct f_trie_node *) new_node6(t, plen, local, ipa_to_ip6(paddr), ipa_to_ip6(pmask), ipa_to_ip6(amask));
 }
 
 static inline void
 attach_node4(struct f_trie_node4 *parent, struct f_trie_node4 *child)
 {
-  parent->c[ip4_getbit(child->addr, parent->plen) ? 1 : 0] = child;
+  parent->c[ip4_getbits(child->addr, parent->plen, TRIE_STEP)] = child;
 }
 
 static inline void
 attach_node6(struct f_trie_node6 *parent, struct f_trie_node6 *child)
 {
-  parent->c[ip6_getbit(child->addr, parent->plen) ? 1 : 0] = child;
+  parent->c[ip6_getbits(child->addr, parent->plen, TRIE_STEP)] = child;
 }
 
 static inline void
@@ -160,63 +205,96 @@ attach_node(struct f_trie_node *parent, struct f_trie_node *child, int v4)
     attach_node6(&parent->v6, &child->v6);
 }
 
-#define GET_ADDR(N,F,X) ((X) ? ipt_from_ip4((N)->v4.F) : ipa_from_ip6((N)->v6.F))
-#define SET_ADDR(N,F,X,V) ({ if (X) (N)->v4.F =ipt_to_ip4(V); else (N)->v6.F =ipa_to_ip6(V); })
 
-#define GET_CHILD(N,F,X,I) ((X) ? (struct f_trie_node *) (N)->v4.c[I] : (struct f_trie_node *) (N)->v6.c[I])
-/**
- * trie_add_prefix
- * @t: trie to add to
- * @net: IP network prefix
- * @l: prefix lower bound
- * @h: prefix upper bound
+/*
+ * Internal prefixes of a node a represented by the local bitmask, each bit for
+ * one prefix. Bit 0 is unused, Bit 1 is for the main prefix of the node,
+ * remaining bits correspond to subprefixes by this pattern:
  *
- * Adds prefix (prefix pattern) @n to trie @t.  @l and @h are lower
- * and upper bounds on accepted prefix lengths, both inclusive.
- * 0 <= l, h <= 32 (128 for IPv6).
+ *          1
+ *      2       3
+ *    4   5   6   7
+ *   8 9 A B C D E F
  *
- * Returns a pointer to the allocated node. The function can return a pointer to
- * an existing node if @px and @plen are the same. If px/plen == 0/0 (or ::/0),
- * a pointer to the root node is returned. Returns NULL when called with
- * mismatched IPv4/IPv6 net type.
+ * E.g. for 10.0.0.0/8 node, the 10.64.0.0/10 would be position 5.
  */
 
-void *
-trie_add_prefix(struct f_trie *t, const net_addr *net, uint l, uint h)
+/*
+ * Compute appropriate mask representing prefix px/plen in local bitmask of node
+ * with prefix length nlen. Assuming that nlen <= plen < (nlen + TRIE_STEP).
+ */
+static inline uint
+trie_local_mask4(ip4_addr px, uint plen, uint nlen)
 {
-  uint plen = net_pxlen(net);
-  ip_addr px;
-  int v4;
+  uint step = plen - nlen;
+  uint pos = (1u << step) + ip4_getbits(px, nlen, step);
+  return 1u << pos;
+}
 
-  switch (net->type)
-  {
-  case NET_IP4: px = ipt_from_ip4(net4_prefix(net)); v4 = 1; break;
-  case NET_IP6: px = ipa_from_ip6(net6_prefix(net)); v4 = 0; break;
-  default: bug("invalid type");
-  }
+static inline uint
+trie_local_mask6(ip6_addr px, uint plen, uint nlen)
+{
+  uint step = plen - nlen;
+  uint pos = (1u << step) + ip6_getbits(px, nlen, step);
+  return 1u << pos;
+}
 
-  if (t->ipv4 != v4)
-  {
-    if (t->ipv4 < 0)
-      t->ipv4 = v4;
-    else
-      return NULL;
-  }
+/*
+ * Compute an appropriate local mask (for a node with prefix length nlen)
+ * representing prefixes of px that are accepted by amask and fall within the
+ * range associated with that node. Used for propagation of child accept mask
+ * to parent local mask.
+ */
+static inline uint
+trie_amask_to_local(ip_addr px, ip_addr amask, uint nlen)
+{
+  uint local = 0;
 
-  if (l == 0)
-    t->zero = 1;
-  else
-    l--;
+  for (uint plen = MAX(nlen, 1); plen < (nlen + TRIE_STEP); plen++)
+    if (ipa_getbit(amask, plen - 1))
+      local |= trie_local_mask(px, plen, nlen);
 
-  if (h < plen)
-    plen = h;
+  return local;
+}
+
+/*
+ * Compute a bitmask representing a level of subprefixes (of the same length),
+ * using specified position as a root. E.g., level 2 from root position 3 would
+ * be bit positions C-F, returned as bitmask 0xf000.
+ */
+static inline uint
+trie_level_mask(uint pos, uint level)
+{
+  return ((1u << (1u << level)) - 1) << (pos << level);
+}
 
-  ip_addr amask = ipa_xor(ipa_mkmask(l), ipa_mkmask(h));
+
+#define GET_ADDR(N,F,X) ((X) ? ipt_from_ip4((N)->v4.F) : ipa_from_ip6((N)->v6.F))
+#define SET_ADDR(N,F,X,V) ({ if (X) (N)->v4.F =ipt_to_ip4(V); else (N)->v6.F =ipa_to_ip6(V); })
+
+#define GET_LOCAL(N,X) ((X) ? (N)->v4.local : (N)->v6.local)
+#define ADD_LOCAL(N,X,V) ({ uint v_ = (V); if (X) (N)->v4.local |= v_; else (N)->v6.local |= v_; })
+
+#define GET_CHILD(N,X,I) ((X) ? (struct f_trie_node *) (N)->v4.c[I] : (struct f_trie_node *) (N)->v6.c[I])
+
+
+static void *
+trie_add_node(struct f_trie *t, uint plen, ip_addr px, uint local, uint l, uint h)
+{
+  uint l_ = l ? (l - 1) : 0;
+  ip_addr amask = (l_ < h) ? ipa_xor(ipa_mkmask(l_), ipa_mkmask(h)) : IPA_NONE;
   ip_addr pmask = ipa_mkmask(plen);
   ip_addr paddr = ipa_and(px, pmask);
   struct f_trie_node *o = NULL;
   struct f_trie_node *n = &t->root;
+  int v4 = t->ipv4;
 
+  /* Add all bits for each active level (0x0002 0x000c 0x00f0 0xff00) */
+  for (uint i = 0; i < TRIE_STEP; i++)
+    if ((l <= (plen + i)) && ((plen + i) <= h))
+      local |= trie_level_mask(1, i);
+
+  DBG("Insert node %I/%u (%I %x)\n", paddr, plen, amask, local);
   while (n)
     {
       ip_addr naddr = GET_ADDR(n, addr, v4);
@@ -225,23 +303,31 @@ trie_add_prefix(struct f_trie *t, const net_addr *net, uint l, uint h)
       ip_addr cmask = ipa_and(nmask, pmask);
       uint nlen = v4 ? n->v4.plen : n->v6.plen;
 
+      DBG("Found node %I/%u (%I %x)\n",
+	  naddr, nlen, accept, v4 ? n->v4.local : n->v6.local);
+
       if (ipa_compare(ipa_and(paddr, cmask), ipa_and(naddr, cmask)))
         {
 	  /* We are out of path - we have to add branching node 'b'
 	     between node 'o' and node 'n', and attach new node 'a'
 	     as the other child of 'b'. */
-	  int blen = ipa_pxlen(paddr, naddr);
+	  int blen = ROUND_DOWN_POW2(ipa_pxlen(paddr, naddr), TRIE_STEP);
 	  ip_addr bmask = ipa_mkmask(blen);
 	  ip_addr baddr = ipa_and(px, bmask);
 
 	  /* Merge accept masks from children to get accept mask for node 'b' */
 	  ip_addr baccm = ipa_and(ipa_or(amask, accept), bmask);
+	  uint bloc = trie_amask_to_local(naddr, accept, blen) |
+	              trie_amask_to_local(paddr, amask, blen);
 
-	  struct f_trie_node *a = new_node(t, plen, paddr, pmask, amask);
-	  struct f_trie_node *b = new_node(t, blen, baddr, bmask, baccm);
+	  struct f_trie_node *a = new_node(t, plen, local, paddr, pmask, amask);
+	  struct f_trie_node *b = new_node(t, blen, bloc, baddr, bmask, baccm);
 	  attach_node(o, b, v4);
 	  attach_node(b, n, v4);
 	  attach_node(b, a, v4);
+	  t->prefix_count++;
+
+	  DBG("Case 1\n");
 	  return a;
 	}
 
@@ -249,66 +335,195 @@ trie_add_prefix(struct f_trie *t, const net_addr *net, uint l, uint h)
 	{
 	  /* We add new node 'a' between node 'o' and node 'n' */
 	  amask = ipa_or(amask, ipa_and(accept, pmask));
-	  struct f_trie_node *a = new_node(t, plen, paddr, pmask, amask);
+	  local |= trie_amask_to_local(naddr, accept, plen);
+	  struct f_trie_node *a = new_node(t, plen, local, paddr, pmask, amask);
 	  attach_node(o, a, v4);
 	  attach_node(a, n, v4);
+	  t->prefix_count++;
+
+	  DBG("Case 2\n");
 	  return a;
 	}
 
       if (plen == nlen)
 	{
-	  /* We already found added node in trie. Just update accept mask */
+	  /* We already found added node in trie. Just update accept and local mask */
 	  accept = ipa_or(accept, amask);
 	  SET_ADDR(n, accept, v4, accept);
+
+	  if ((GET_LOCAL(n, v4) & local) != local)
+	    t->prefix_count++;
+
+	  ADD_LOCAL(n, v4, local);
+
+	  DBG("Case 3\n");
 	  return n;
 	}
 
       /* Update accept mask part M2 and go deeper */
       accept = ipa_or(accept, ipa_and(amask, nmask));
       SET_ADDR(n, accept, v4, accept);
+      ADD_LOCAL(n, v4, trie_amask_to_local(paddr, amask, nlen));
+
+      DBG("Step %u\n", ipa_getbits(paddr, nlen));
 
       /* n->plen < plen and plen <= 32 (128) */
       o = n;
-      n = GET_CHILD(n, c, v4, ipa_getbit(paddr, nlen) ? 1 : 0);
+      n = GET_CHILD(n, v4, ipa_getbits(paddr, nlen, TRIE_STEP));
     }
 
   /* We add new tail node 'a' after node 'o' */
-  struct f_trie_node *a = new_node(t, plen, paddr, pmask, amask);
+  struct f_trie_node *a = new_node(t, plen, local, paddr, pmask, amask);
   attach_node(o, a, v4);
+  t->prefix_count++;
 
+  DBG("Case 4\n");
   return a;
 }
 
+/**
+ * trie_add_prefix
+ * @t: trie to add to
+ * @net: IP network prefix
+ * @l: prefix lower bound
+ * @h: prefix upper bound
+ *
+ * Adds prefix (prefix pattern) @n to trie @t.  @l and @h are lower
+ * and upper bounds on accepted prefix lengths, both inclusive.
+ * 0 <= l, h <= 32 (128 for IPv6).
+ *
+ * Returns a pointer to the allocated node. The function can return a pointer to
+ * an existing node if @px and @plen are the same. If px/plen == 0/0 (or ::/0),
+ * a pointer to the root node is returned. Returns NULL when called with
+ * mismatched IPv4/IPv6 net type.
+ */
+void *
+trie_add_prefix(struct f_trie *t, const net_addr *net, uint l, uint h)
+{
+  uint plen = net_pxlen(net);
+  ip_addr px;
+  int v4;
+
+  switch (net->type)
+  {
+  case NET_IP4:
+  case NET_VPN4:
+  case NET_ROA4:
+    px = ipt_from_ip4(net4_prefix(net));
+    v4 = 1;
+    break;
+
+  case NET_IP6:
+  case NET_VPN6:
+  case NET_ROA6:
+  case NET_IP6_SADR:
+    px = ipa_from_ip6(net6_prefix(net));
+    v4 = 0;
+    break;
+
+  default:
+    bug("invalid type");
+  }
+
+  if (t->ipv4 != v4)
+  {
+    if (t->ipv4 < 0)
+      t->ipv4 = v4;
+    else
+      return NULL;
+  }
+
+  DBG("\nInsert net %N (%u-%u)\n", net, l, h);
+
+  if (l == 0)
+    t->zero = 1;
+
+  if (h < plen)
+    plen = h;
+
+  /* Primary node length, plen rounded down */
+  uint nlen = ROUND_DOWN_POW2(plen, TRIE_STEP);
+
+  if (plen == nlen)
+    return trie_add_node(t, nlen, px, 0, l,  h);
+
+  /* Secondary node length, plen rouned up */
+  uint slen = nlen + TRIE_STEP;
+  void *node = NULL;
+
+  /*
+   * For unaligned prefix lengths it is more complicated. We need to encode
+   * matching prefixes of lengths from l to h. There are three cases of lengths:
+   *
+   * 1) 0..nlen are encoded by the accept mask of the primary node
+   * 2) nlen..(slen-1) are encoded by the local mask of the primary node
+   * 3) slen..max are encoded in secondary nodes
+   */
+
+  if (l < slen)
+  {
+    uint local = 0;
+
+    /* Compute local bits for accepted nlen..(slen-1) prefixes */
+    for (uint i = 0; i < TRIE_STEP; i++)
+      if ((l <= (nlen + i)) && ((nlen + i) <= h))
+      {
+	uint pos = (1u << i) + ipa_getbits(px, nlen, i);
+	uint len = ((nlen + i) <= plen) ? 1 : (1u << (nlen + i - plen));
+
+	/* We need to fill 'len' bits starting at 'pos' position */
+	local |= ((1u << len) - 1) << pos;
+      }
+
+    /* Add the primary node */
+    node = trie_add_node(t, nlen, px, local, l,  nlen);
+  }
+
+  if (slen <= h)
+  {
+    uint l2 = MAX(l, slen);
+    uint max = (1u << (slen - plen));
+
+    /* Add secondary nodes */
+    for (uint i = 0; i < max; i++)
+      node = trie_add_node(t, slen, ipa_setbits(px,  slen - 1, i), 0, l2,  h);
+  }
+
+  return node;
+}
+
+
 static int
 trie_match_net4(const struct f_trie *t, ip4_addr px, uint plen)
 {
-  ip4_addr pmask = ip4_mkmask(plen);
-  ip4_addr paddr = ip4_and(px, pmask);
-
   if (plen == 0)
     return t->zero;
 
   int plentest = plen - 1;
+  uint nlen = ROUND_DOWN_POW2(plen, TRIE_STEP);
+  uint local = trie_local_mask4(px, plen, nlen);
   const struct f_trie_node4 *n = &t->root.v4;
 
   while (n)
   {
-    ip4_addr cmask = ip4_and(n->mask, pmask);
-
     /* We are out of path */
-    if (ip4_compare(ip4_and(paddr, cmask), ip4_and(n->addr, cmask)))
+    if (!ip4_prefix_equal(px, n->addr, MIN(plen, n->plen)))
       return 0;
 
+    /* Check local mask */
+    if ((n->plen == nlen) && (n->local & local))
+      return 1;
+
     /* Check accept mask */
     if (ip4_getbit(n->accept, plentest))
       return 1;
 
     /* We finished trie walk and still no match */
-    if (plen <= n->plen)
+    if (nlen <= n->plen)
       return 0;
 
     /* Choose children */
-    n =  n->c[(ip4_getbit(paddr, n->plen)) ? 1 : 0];
+    n =  n->c[ip4_getbits(px, n->plen, TRIE_STEP)];
   }
 
   return 0;
@@ -317,33 +532,34 @@ trie_match_net4(const struct f_trie *t, ip4_addr px, uint plen)
 static int
 trie_match_net6(const struct f_trie *t, ip6_addr px, uint plen)
 {
-  ip6_addr pmask = ip6_mkmask(plen);
-  ip6_addr paddr = ip6_and(px, pmask);
-
   if (plen == 0)
     return t->zero;
 
   int plentest = plen - 1;
+  uint nlen = ROUND_DOWN_POW2(plen, TRIE_STEP);
+  uint local = trie_local_mask6(px, plen, nlen);
   const struct f_trie_node6 *n = &t->root.v6;
 
   while (n)
   {
-    ip6_addr cmask = ip6_and(n->mask, pmask);
-
     /* We are out of path */
-    if (ip6_compare(ip6_and(paddr, cmask), ip6_and(n->addr, cmask)))
+    if (!ip6_prefix_equal(px, n->addr, MIN(plen, n->plen)))
       return 0;
 
+    /* Check local mask */
+    if ((n->plen == nlen) && (n->local & local))
+      return 1;
+
     /* Check accept mask */
     if (ip6_getbit(n->accept, plentest))
       return 1;
 
     /* We finished trie walk and still no match */
-    if (plen <= n->plen)
+    if (nlen <= n->plen)
       return 0;
 
     /* Choose children */
-    n =  n->c[(ip6_getbit(paddr, n->plen)) ? 1 : 0];
+    n =  n->c[ip6_getbits(px, n->plen, TRIE_STEP)];
   }
 
   return 0;
@@ -378,6 +594,412 @@ trie_match_net(const struct f_trie *t, const net_addr *n)
   }
 }
 
+
+/**
+ * trie_match_longest_ip4
+ * @t: trie
+ * @net: net address
+ * @dst: return value
+ * @found0: optional returned bitmask of found nodes
+ *
+ * Perform longest prefix match for the address @net and return the resulting
+ * prefix in the buffer @dst. The bitmask @found0 is used to report lengths of
+ * prefixes on the path from the root to the resulting prefix. E.g., if there is
+ * also a /20 shorter matching prefix, then 20-th bit is set in @found0. This
+ * can be used to enumerate all matching prefixes for the network @net using
+ * function trie_match_next_longest_ip4() or macro TRIE_WALK_TO_ROOT_IP4().
+ *
+ * This function assumes IPv4 trie, there is also an IPv6 variant. The @net
+ * argument is typed as net_addr_ip4, but would accept any IPv4-based net_addr,
+ * like net4_prefix(). Anyway, returned @dst is always net_addr_ip4.
+ *
+ * Result: 1 if a matching prefix was found, 0 if not.
+ */
+int
+trie_match_longest_ip4(const struct f_trie *t, const net_addr_ip4 *net, net_addr_ip4 *dst, ip4_addr *found0)
+{
+  ASSERT(t->ipv4);
+
+  const ip4_addr prefix = net->prefix;
+  const int pxlen = net->pxlen;
+
+  const struct f_trie_node4 *n = &t->root.v4;
+  int len = 0;
+
+  ip4_addr found = IP4_NONE;
+  int last = -1;
+
+  while (n)
+  {
+    /* We are out of path */
+    if (!ip4_prefix_equal(prefix, n->addr, MIN(pxlen, n->plen)))
+      goto done;
+
+    /* Check accept mask */
+    for (; len < n->plen; len++)
+    {
+      if (len > pxlen)
+	goto done;
+
+      if (ip4_getbit(n->accept, len - 1))
+      {
+	/* len is always < 32 due to len < n->plen */
+	ip4_setbit(&found, len);
+	last = len;
+      }
+    }
+
+    /* Special case for max length, there is only one valid local position */
+    if (len == IP4_MAX_PREFIX_LENGTH)
+    {
+      if (n->local & (1u << 1))
+	last = len;
+
+      goto done;
+    }
+
+    /* Check local mask */
+    for (int pos = 1; pos < (1 << TRIE_STEP); pos = 2 * pos + ip4_getbit(prefix, len), len++)
+    {
+      if (len > pxlen)
+	goto done;
+
+      if (n->local & (1u << pos))
+      {
+	/* len is always < 32 due to special case above */
+	ip4_setbit(&found, len);
+	last = len;
+      }
+    }
+
+    /* Choose child */
+    n = n->c[ip4_getbits(prefix, n->plen, TRIE_STEP)];
+  }
+
+done:
+  if (last < 0)
+    return 0;
+
+  *dst = NET_ADDR_IP4(ip4_and(prefix, ip4_mkmask(last)), last);
+
+  if (found0)
+    *found0 = found;
+
+  return 1;
+}
+
+
+/**
+ * trie_match_longest_ip6
+ * @t: trie
+ * @net: net address
+ * @dst: return value
+ * @found0: optional returned bitmask of found nodes
+ *
+ * Perform longest prefix match for the address @net and return the resulting
+ * prefix in the buffer @dst. The bitmask @found0 is used to report lengths of
+ * prefixes on the path from the root to the resulting prefix. E.g., if there is
+ * also a /20 shorter matching prefix, then 20-th bit is set in @found0. This
+ * can be used to enumerate all matching prefixes for the network @net using
+ * function trie_match_next_longest_ip6() or macro TRIE_WALK_TO_ROOT_IP6().
+ *
+ * This function assumes IPv6 trie, there is also an IPv4 variant. The @net
+ * argument is typed as net_addr_ip6, but would accept any IPv6-based net_addr,
+ * like net6_prefix(). Anyway, returned @dst is always net_addr_ip6.
+ *
+ * Result: 1 if a matching prefix was found, 0 if not.
+ */
+int
+trie_match_longest_ip6(const struct f_trie *t, const net_addr_ip6 *net, net_addr_ip6 *dst, ip6_addr *found0)
+{
+  ASSERT(!t->ipv4);
+
+  const ip6_addr prefix = net->prefix;
+  const int pxlen = net->pxlen;
+
+  const struct f_trie_node6 *n = &t->root.v6;
+  int len = 0;
+
+  ip6_addr found = IP6_NONE;
+  int last = -1;
+
+  while (n)
+  {
+    /* We are out of path */
+    if (!ip6_prefix_equal(prefix, n->addr, MIN(pxlen, n->plen)))
+      goto done;
+
+    /* Check accept mask */
+    for (; len < n->plen; len++)
+    {
+      if (len > pxlen)
+	goto done;
+
+      if (ip6_getbit(n->accept, len - 1))
+      {
+	/* len is always < 128 due to len < n->plen */
+	ip6_setbit(&found, len);
+	last = len;
+      }
+    }
+
+    /* Special case for max length, there is only one valid local position */
+    if (len == IP6_MAX_PREFIX_LENGTH)
+    {
+      if (n->local & (1u << 1))
+	last = len;
+
+      goto done;
+    }
+
+    /* Check local mask */
+    for (int pos = 1; pos < (1 << TRIE_STEP); pos = 2 * pos + ip6_getbit(prefix, len), len++)
+    {
+      if (len > pxlen)
+	goto done;
+
+      if (n->local & (1u << pos))
+      {
+	/* len is always < 128 due to special case above */
+	ip6_setbit(&found, len);
+	last = len;
+      }
+    }
+
+    /* Choose child */
+    n = n->c[ip6_getbits(prefix, n->plen, TRIE_STEP)];
+  }
+
+done:
+  if (last < 0)
+    return 0;
+
+  *dst = NET_ADDR_IP6(ip6_and(prefix, ip6_mkmask(last)), last);
+
+  if (found0)
+    *found0 = found;
+
+  return 1;
+}
+
+#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)))
+
+/**
+ * trie_walk_init
+ * @s: walk state
+ * @t: trie
+ * @net: optional subnet for walk
+ *
+ * Initialize walk state for subsequent walk through nodes of the trie @t by
+ * trie_walk_next(). The argument @net allows to restrict walk to given subnet,
+ * otherwise full walk over all nodes is used. This is done by finding node at
+ * or below @net and starting position in it.
+ */
+void
+trie_walk_init(struct f_trie_walk_state *s, const struct f_trie *t, const net_addr *net)
+{
+  *s = (struct f_trie_walk_state) {
+    .ipv4 = t->ipv4,
+    .accept_length = 0,
+    .start_pos = 1,
+    .local_pos = 1,
+    .stack_pos = 0,
+    .stack[0] = &t->root
+  };
+
+  if (!net)
+    return;
+
+  /* We want to find node of level at least plen */
+  int plen = ROUND_DOWN_POW2(net->pxlen, TRIE_STEP);
+  const struct f_trie_node *n = &t->root;
+  const int v4 = t->ipv4;
+
+  while (n)
+  {
+    int nlen = v4 ? n->v4.plen : n->v6.plen;
+
+    /* We are out of path */
+    if (!SAME_PREFIX(n, net, v4, MIN(net->pxlen, nlen)))
+      break;
+
+    /* We found final node */
+    if (nlen >= plen)
+    {
+      if (nlen == plen)
+      {
+	/* Find proper local_pos, while accept_length is not used */
+	int step = net->pxlen - plen;
+	s->start_pos = s->local_pos = (1u << step) + GET_NET_BITS(net, v4, plen, step);
+	s->accept_length = plen;
+      }
+      else
+      {
+	/* Start from pos 1 in local node, but first try accept mask */
+	s->accept_length = net->pxlen;
+      }
+
+      s->stack[0] = n;
+      return;
+    }
+
+    /* Choose child */
+    n = GET_CHILD(n, v4, GET_NET_BITS(net, v4, nlen, TRIE_STEP));
+  }
+
+  s->stack[0] = NULL;
+  return;
+}
+
+#define GET_ACCEPT_BIT(N,X,B) ((X) ? ip4_getbit((N)->v4.accept, (B)) : ip6_getbit((N)->v6.accept, (B)))
+#define GET_LOCAL_BIT(N,X,B) (((X) ? (N)->v4.local : (N)->v6.local) & (1u << (B)))
+
+/**
+ * trie_walk_next
+ * @s: walk state
+ * @net: return value
+ *
+ * Find the next prefix in the trie walk and return it in the buffer @net.
+ * Prefixes are walked in the usual lexicographic order and may be restricted
+ * to a subset of the trie during walk setup by trie_walk_init(). Note that the
+ * trie walk does not iterate reliably over 'implicit' prefixes defined by &low
+ * and &high fields in prefix patterns, it is supposed to be used on tries
+ * constructed from 'explicit' prefixes (&low == &plen == &high in call to
+ * trie_add_prefix()).
+ *
+ * Result: 1 if the next prefix was found, 0 for the end of walk.
+ */
+int
+trie_walk_next(struct f_trie_walk_state *s, net_addr *net)
+{
+  const struct f_trie_node *n = s->stack[s->stack_pos];
+  int len = s->accept_length;
+  int pos = s->local_pos;
+  int v4 = s->ipv4;
+
+  /*
+   * The walk has three basic state variables -- n, len and pos. In each node n,
+   * we first walk superprefixes (by len in &accept bitmask), and then we walk
+   * internal positions (by pos in &local bitmask). These positions are:
+   *
+   *          1
+   *      2       3
+   *    4   5   6   7
+   *   8 9 A B C D E F
+   *
+   * We walk them depth-first, including virtual positions 10-1F that are
+   * equivalent of position 1 in child nodes 0-F.
+   */
+
+  if (!n)
+  {
+    memset(net, 0, v4 ? sizeof(net_addr_ip4) : sizeof(net_addr_ip6));
+    return 0;
+  }
+
+next_node:;
+  /* Current node prefix length */
+  int nlen = v4 ? n->v4.plen : n->v6.plen;
+
+  /* First, check for accept prefix */
+  for (; len < nlen; len++)
+    if (GET_ACCEPT_BIT(n, v4, len - 1))
+    {
+      if (v4)
+	net_fill_ip4(net, ip4_and(n->v4.addr, ip4_mkmask(len)), len);
+      else
+	net_fill_ip6(net, ip6_and(n->v6.addr, ip6_mkmask(len)), len);
+
+      s->local_pos = pos;
+      s->accept_length = len + 1;
+      return 1;
+    }
+
+next_pos:
+  /* Bottom of this node */
+  if (pos >= (1 << TRIE_STEP))
+  {
+    const struct f_trie_node *child = GET_CHILD(n, v4, pos - (1 << TRIE_STEP));
+    int dir = 0;
+
+    /* No child node */
+    if (!child)
+    {
+      /* Step up until return from left child (pos is even) */
+      do
+      {
+	/* Step up from start node */
+	if ((s->stack_pos == 0) && (pos == s->start_pos))
+	{
+	  s->stack[0] = NULL;
+	  memset(net, 0, v4 ? sizeof(net_addr_ip4) : sizeof(net_addr_ip6));
+	  return 0;
+	}
+
+	/* Top of this node */
+	if (pos == 1)
+	{
+	  ASSERT(s->stack_pos);
+	  const struct f_trie_node *old = n;
+
+	  /* Move to parent node */
+	  s->stack_pos--;
+	  n = s->stack[s->stack_pos];
+	  nlen = v4 ? n->v4.plen : n->v6.plen;
+
+	  pos = v4 ?
+	    ip4_getbits(old->v4.addr, nlen, TRIE_STEP) :
+	    ip6_getbits(old->v6.addr, nlen, TRIE_STEP);
+	  pos += (1 << TRIE_STEP);
+	  len = nlen;
+
+	  ASSERT(GET_CHILD(n, v4, pos - (1 << TRIE_STEP)) == old);
+	}
+
+	/* Step up */
+	dir = pos % 2;
+	pos = pos / 2;
+      }
+      while (dir);
+
+      /* Continue with step down to the right child */
+      pos = 2 * pos + 1;
+      goto next_pos;
+    }
+
+    /* Move to child node */
+    pos = 1;
+    len = nlen + TRIE_STEP;
+
+    s->stack_pos++;
+    n = s->stack[s->stack_pos] = child;
+    goto next_node;
+  }
+
+  /* Check for local prefix */
+  if (GET_LOCAL_BIT(n, v4, pos))
+  {
+    /* Convert pos to address of local network */
+    int x = (pos >= 2) + (pos >= 4) + (pos >= 8);
+    int y = pos & ((1u << x) - 1);
+
+    if (v4)
+      net_fill_ip4(net, !x ? n->v4.addr : ip4_setbits(n->v4.addr, nlen + x - 1, y), nlen + x);
+    else
+      net_fill_ip6(net, !x ? n->v6.addr : ip6_setbits(n->v6.addr, nlen + x - 1, y), nlen + x);
+
+    s->local_pos = 2 * pos;
+    s->accept_length = len;
+    return 1;
+  }
+
+  /* Step down */
+  pos = 2 * pos;
+  goto next_pos;
+}
+
+
 static int
 trie_node_same4(const struct f_trie_node4 *t1, const struct f_trie_node4 *t2)
 {
@@ -392,7 +1014,11 @@ trie_node_same4(const struct f_trie_node4 *t1, const struct f_trie_node4 *t2)
       (! ip4_equal(t1->accept, t2->accept)))
     return 0;
 
-  return trie_node_same4(t1->c[0], t2->c[0]) && trie_node_same4(t1->c[1], t2->c[1]);
+  for (uint i = 0; i < (1 << TRIE_STEP); i++)
+    if (! trie_node_same4(t1->c[i], t2->c[i]))
+      return 0;
+
+  return 1;
 }
 
 static int
@@ -409,7 +1035,11 @@ trie_node_same6(const struct f_trie_node6 *t1, const struct f_trie_node6 *t2)
       (! ip6_equal(t1->accept, t2->accept)))
     return 0;
 
-  return trie_node_same6(t1->c[0], t2->c[0]) && trie_node_same6(t1->c[1], t2->c[1]);
+  for (uint i = 0; i < (1 << TRIE_STEP); i++)
+    if (! trie_node_same6(t1->c[i], t2->c[i]))
+      return 0;
+
+  return 1;
 }
 
 /**
@@ -431,30 +1061,70 @@ trie_same(const struct f_trie *t1, const struct f_trie *t2)
     return trie_node_same6(&t1->root.v6, &t2->root.v6);
 }
 
+
+static const u8 log2[16] = {0, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3};
+
 static void
-trie_node_format4(const struct f_trie_node4 *t, buffer *buf)
+trie_node_format(const struct f_trie_node *n, buffer *buf, int v4)
 {
-  if (t == NULL)
+  if (n == NULL)
     return;
 
-  if (ip4_nonzero(t->accept))
-    buffer_print(buf, "%I4/%d{%I4}, ", t->addr, t->plen, t->accept);
+  if (v4)
+  {
+    if (ip4_nonzero(n->v4.accept))
+      buffer_print(buf, "%I4/%d{%I4}, ", n->v4.addr, n->v4.plen, n->v4.accept);
+  }
+  else
+  {
+    if (ip6_nonzero(n->v6.accept))
+      buffer_print(buf, "%I6/%d{%I6}, ", n->v6.addr, n->v6.plen, n->v6.accept);
+  }
 
-  trie_node_format4(t->c[0], buf);
-  trie_node_format4(t->c[1], buf);
-}
+  int nlen = v4 ? n->v4.plen : n->v6.plen;
+  uint local = v4 ? n->v4.local : n->v6.local;
 
-static void
-trie_node_format6(const struct f_trie_node6 *t, buffer *buf)
-{
-  if (t == NULL)
-    return;
+  for (int i = (nlen ? 0 : 1); i < TRIE_STEP; i++)
+    if (GET_ACCEPT_BIT(n, v4, nlen + i - 1))
+      local &= ~trie_level_mask(1, i);
 
-  if (ip6_nonzero(t->accept))
-    buffer_print(buf, "%I6/%d{%I6}, ", t->addr, t->plen, t->accept);
+  for (int pos = 2; local && (pos < (1 << TRIE_STEP)); pos++)
+    if (local & (1u << pos))
+    {
+      int lvl = log2[pos];
+      int plen = nlen + lvl;
+
+      int i;
+      for (i = 0; lvl + i < TRIE_STEP; i++)
+      {
+	uint lmask = trie_level_mask(pos, i);
+
+	if ((local & lmask) != lmask)
+	  break;
+
+	local &= ~lmask;
+      }
+
+      uint addr_bits = pos & ((1u << lvl) - 1);
+      uint accept_bits = (1u << i) - 1;
+      int h = plen + i - 1;
+
+      if (v4)
+      {
+	ip4_addr addr = ip4_setbits(n->v4.addr, plen - 1, addr_bits);
+	ip4_addr mask = ip4_setbits(IP4_NONE, h - 1, accept_bits);
+	buffer_print(buf, "%I4/%d{%I4}, ", addr, plen, mask);
+      }
+      else
+      {
+	ip6_addr addr = ip6_setbits(n->v6.addr, plen - 1, addr_bits);
+	ip6_addr mask = ip6_setbits(IP6_NONE, h - 1, accept_bits);
+	buffer_print(buf, "%I6/%d{%I6}, ", addr, plen, mask);
+      }
+    }
 
-  trie_node_format6(t->c[0], buf);
-  trie_node_format6(t->c[1], buf);
+  for (int i = 0; i < (1 << TRIE_STEP); i++)
+    trie_node_format(GET_CHILD(n, v4, i), buf, v4);
 }
 
 /**
@@ -472,10 +1142,7 @@ trie_format(const struct f_trie *t, buffer *buf)
   if (t->zero)
     buffer_print(buf, "%I/%d, ", t->ipv4 ? IPA_NONE4 : IPA_NONE6, 0);
 
-  if (t->ipv4)
-    trie_node_format4(&t->root.v4, buf);
-  else
-    trie_node_format6(&t->root.v6, buf);
+  trie_node_format(&t->root, buf, t->ipv4);
 
   if (buf->pos == buf->end)
     return;
diff --git a/filter/trie_test.c b/filter/trie_test.c
index b2b36716..cae86995 100644
--- a/filter/trie_test.c
+++ b/filter/trie_test.c
@@ -14,9 +14,12 @@
 #include "conf/conf.h"
 
 #define TESTS_NUM		10
-#define PREFIXES_NUM 		10
+#define PREFIXES_NUM 		32
 #define PREFIX_TESTS_NUM 	10000
+#define PREFIX_BENCH_NUM 	100000000
 
+#define TRIE_BUFFER_SIZE	1024
+#define TEST_BUFFER_SIZE	(1024*1024)
 #define BIG_BUFFER_SIZE		10000
 
 /* Wrapping structure for storing f_prefixes structures in list */
@@ -31,146 +34,860 @@ 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 int
-is_prefix_included(list *prefixes, struct f_prefix *needle)
+compare_prefixes(const void *a, const void *b)
 {
-  struct f_prefix_node *n;
-  WALK_LIST(n, *prefixes)
-  {
-    ip6_addr cmask = ip6_mkmask(MIN(n->prefix.net.pxlen, needle->net.pxlen));
+  return net_compare(&((const struct f_prefix *) a)->net,
+		     &((const struct f_prefix *) b)->net);
+}
+
+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;
+}
 
-    ip6_addr ip = net6_prefix(&n->prefix.net);
-    ip6_addr needle_ip = net6_prefix(&needle->net);
+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);
+}
 
-    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))
+static int
+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) &&
+	(n->prefix.lo <= needle->pxlen) && (needle->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
-get_random_ip6_prefix(void)
+static void
+get_random_net(net_addr *net, int v6)
 {
-  struct f_prefix p;
-  u8 pxlen = xrandom(120)+8;
-  ip6_addr ip6 = ip6_build(bt_random(),bt_random(),bt_random(),bt_random());
-  net_addr_ip6 net6 = NET_ADDR_IP6(ip6, pxlen);
+  if (!v6)
+  {
+    uint pxlen = xrandom(24)+8;
+    ip4_addr ip4 = ip4_from_u32((u32) bt_random());
+    net_fill_ip4(net, ip4_and(ip4, ip4_mkmask(pxlen)), pxlen);
+  }
+  else
+  {
+    uint pxlen = xrandom(120)+8;
+    ip6_addr ip6 = ip6_build(bt_random(), bt_random(), bt_random(), bt_random());
+    net_fill_ip6(net, ip6_and(ip6, ip6_mkmask(pxlen)), pxlen);
+  }
+}
 
-  p.net = *((net_addr*) &net6);
+static void
+get_random_prefix(struct f_prefix *px, int v6, int tight)
+{
+  get_random_net(&px->net, v6);
+
+  if (tight)
+  {
+    px->lo = px->hi = px->net.pxlen;
+  }
+  else if (bt_random() % 2)
+  {
+    px->lo = 0;
+    px->hi = px->net.pxlen;
+  }
+  else
+  {
+    px->lo = px->net.pxlen;
+    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)
   {
-    p.lo = 0;
-    p.hi = p.net.pxlen;
+    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++)
   {
-    p.lo = p.net.pxlen;
-    p.hi = net_max_prefix_length[p.net.type];
+    ip4_addr swap = IP4_NONE;
+    ip4_setbit(&swap, bt_random() % net->pxlen);
+    net->prefix = ip4_xor(net->prefix, swap);
   }
+}
 
-  return p;
+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
-generate_random_ipv6_prefixes(list *prefixes)
+swap_random_bits(net_addr *net, int num)
 {
-  int i;
-  for (i = 0; i < PREFIXES_NUM; i++)
+  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))
   {
-    struct f_prefix f = get_random_ip6_prefix();
+    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;
+  }
 
-    struct f_prefix_node *px = calloc(1, sizeof(struct f_prefix_node));
-    px->prefix = f;
+  get_random_subnet(net, &src->net, pxlen);
 
-    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);
+  /* 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, int tight)
+{
+  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, tight);
     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;
+}
+
+/*
+ * Read sequence of prefixes from file handle and return prefix list.
+ * Each prefix is on one line, sequence terminated by empty line or eof.
+ * Arg @plus means prefix should include all longer ones.
+ */
+static list *
+read_prefix_list(linpool *lp, FILE *f, int v6, int plus)
+{
+  ASSERT(!v6);
+
+  uint a0, a1, a2, a3, pl;
+  char s[32];
+  int n;
+
+  list *pxlist = lp_allocz(lp, sizeof(struct f_prefix_node));
+  init_list(pxlist);
+
+  errno = 0;
+  while (fgets(s, 32, f))
+  {
+    if (s[0] == '\n')
+      return pxlist;
+
+    n = sscanf(s, "%u.%u.%u.%u/%u", &a0, &a1, &a2, &a3, &pl);
+
+    if (n != 5)
+      bt_abort_msg("Invalid content of trie_data");
+
+    struct f_prefix_node *px = lp_allocz(lp, sizeof(struct f_prefix_node));
+    net_fill_ip4(&px->prefix.net, ip4_build(a0, a1, a2, a3), pl);
+    px->prefix.lo = pl;
+    px->prefix.hi = plus ? IP4_MAX_PREFIX_LENGTH : pl;
+    add_tail(pxlist, &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);
   }
+
+  bt_syscall(errno, "fgets()");
+  return EMPTY_LIST(*pxlist) ? NULL : pxlist;
+}
+
+/*
+ * Open file, read multiple sequences of prefixes from it. Fill @data with
+ * prefix lists and @trie with generated tries. Return number of sequences /
+ * tries. Use separate linpool @lp0 for prefix lists and @lp1 for tries.
+ * Arg @plus means prefix should include all longer ones.
+ */
+static int
+read_prefix_file(const char *filename, int plus,
+		 linpool *lp0, linpool *lp1,
+		 list *data[], struct f_trie *trie[])
+{
+  FILE *f = fopen(filename, "r");
+  bt_syscall(!f, "fopen(%s)", filename);
+
+  int n = 0;
+  list *pxlist;
+  while (pxlist = read_prefix_list(lp0, f, 0, plus))
+  {
+    data[n] = pxlist;
+    trie[n] = make_trie_from_prefix_list(lp1, pxlist);
+    bt_debug("NEXT\n");
+    n++;
+  }
+
+  fclose(f);
+  bt_debug("DONE reading %d tries\n", n);
+
+  return n;
+}
+
+/*
+ * Select random subset of @dn prefixes from prefix list @src of length @sn,
+ * and store them to buffer @dst (of size @dn). Prefixes may be chosen multiple
+ * times. Randomize order of prefixes in @dst buffer.
+ */
+static void
+select_random_prefix_subset(list *src[], net_addr dst[], int sn, int dn)
+{
+  int pn = 0;
+
+  if (!dn)
+    return;
+
+  /* Compute total prefix number */
+  for (int i = 0; i < sn; i++)
+    pn += list_length(src[i]);
+
+  /* Change of selecting a prefix */
+  int rnd = (pn / dn) + 10;
+  int n = 0;
+
+  /* Iterate indefinitely over src array */
+  for (int i = 0; 1; i++, i = (i < sn) ? i : 0)
+  {
+    struct f_prefix_node *px;
+    WALK_LIST(px, *src[i])
+    {
+      if (xrandom(rnd) != 0)
+	continue;
+
+      net_copy(&dst[n], &px->prefix.net);
+      n++;
+
+      /* We have enough */
+      if (n == dn)
+	goto done;
+    }
+  }
+
+done:
+  /* Shuffle networks */
+  for (int i = 0; i < dn; i++)
+  {
+    int j = xrandom(dn);
+
+    if (i == j)
+      continue;
+
+    net_addr tmp;
+    net_copy(&tmp, &dst[i]);
+    net_copy(&dst[i], &dst[j]);
+    net_copy(&dst[j], &tmp);
+  }
+}
+
+/* Fill @dst buffer with @dn randomly generated /32 prefixes */
+static void
+make_random_addresses(net_addr dst[], int dn)
+{
+  for (int i = 0; i < dn; i++)
+    net_fill_ip4(&dst[i], ip4_from_u32((u32) bt_random()), IP4_MAX_PREFIX_LENGTH);
+}
+
+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;
-  for (round = 0; round < TESTS_NUM; round++)
+  int v6 = 0;
+  linpool *lp = lp_new_default(&root_pool);
+  for (int round = 0; round < TESTS_NUM; round++)
   {
-    list prefixes; /* of structs f_extended_prefix */
-    init_list(&prefixes);
-    struct f_trie *trie = f_new_trie(config->mem, 0);
+    list *prefixes = make_random_prefix_list(lp, PREFIXES_NUM, v6, 0);
+    struct f_trie *trie = make_trie_from_prefix_list(lp, prefixes);
 
-    generate_random_ipv6_prefixes(&prefixes);
-    struct f_prefix_node *n;
-    WALK_LIST(n, prefixes)
+    for (int i = 0; i < PREFIX_TESTS_NUM; i++)
     {
-      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;
-    for (i = 0; i < PREFIX_TESTS_NUM; i++)
+    v6 = !v6;
+    lp_flush(lp);
+  }
+
+  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, 0);
+    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++)
     {
-      struct f_prefix f = get_random_ip6_prefix();
-      bt_debug("TEST\t" PRIip6 "/%d\n", ARGip6(net6_prefix(&f.net)), f.net.pxlen);
+      net_addr net;
+      get_inner_net(&net, &n->prefix);
+      test_match_net(prefixes, trie, &net);
 
-      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"));
+      n = NODE_VALID(NODE_NEXT(n)) ? NODE_NEXT(n) : HEAD(*prefixes);
     }
 
-    struct f_prefix_node *nxt;
-    WALK_LIST_DELSAFE(n, nxt, 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, 0);
+    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++)
     {
-      free(n);
+      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;
 }
 
+/*
+ * Read prefixes from @filename, build set of tries, prepare test data and do
+ * PREFIX_BENCH_NUM trie lookups. With @plus = 0, use random subset of known
+ * prefixes as test data, with @plus = 1, use randomly generated /32 prefixes
+ * as test data.
+ */
+static int
+benchmark_trie_dataset(const char *filename, int plus)
+{
+  int n = 0;
+  linpool *lp0 = lp_new_default(&root_pool);
+  linpool *lp1 = lp_new_default(&root_pool);
+  list *data[TRIE_BUFFER_SIZE];
+  struct f_trie *trie[TRIE_BUFFER_SIZE];
+  net_addr *nets;
+
+  bt_reset_suite_case_timer();
+  bt_log_suite_case_result(1, "Reading %s", filename, n);
+  n = read_prefix_file(filename, plus, lp0, lp1, data, trie);
+  bt_log_suite_case_result(1, "Read prefix data, %d lists, ", n);
+
+  size_t trie_size = rmemsize(lp1).effective * 1000 / (1024*1024);
+  bt_log_suite_case_result(1, "Trie size %u.%03u MB",
+			   (uint) (trie_size / 1000), (uint) (trie_size % 1000));
+
+  int t = PREFIX_BENCH_NUM / n;
+  int tb = MIN(t, TEST_BUFFER_SIZE);
+  nets = lp_alloc(lp0, tb * sizeof(net_addr));
+
+  if (!plus)
+    select_random_prefix_subset(data, nets, n, tb);
+  else
+    make_random_addresses(nets, tb);
+
+  bt_log_suite_case_result(1, "Make test data, %d (%d) tests", t, tb);
+  bt_reset_suite_case_timer();
+
+  /*
+  int match = 0;
+  for (int i = 0; i < t; i++)
+    for (int j = 0; j < n; j++)
+      test_match_net(data[j], trie[j], &nets[i]);
+  */
+
+  int match = 0;
+  for (int i = 0; i < t; i++)
+    for (int j = 0; j < n; j++)
+      if (trie_match_net(trie[j], &nets[i % TEST_BUFFER_SIZE]))
+	match++;
+
+  bt_log_suite_case_result(1, "Matching done, %d / %d matches", match, t * n);
+
+  rfree(lp0);
+  rfree(lp1);
+
+  return 1;
+}
+
+static int UNUSED
+t_bench_trie_datasets_subset(void)
+{
+  bt_bird_init();
+  bt_config_parse(BT_CONFIG_SIMPLE);
+
+  /* Specific datasets, not included */
+  benchmark_trie_dataset("trie-data-bgp-1", 0);
+  benchmark_trie_dataset("trie-data-bgp-10", 0);
+  benchmark_trie_dataset("trie-data-bgp-100", 0);
+  benchmark_trie_dataset("trie-data-bgp-1000", 0);
+
+  bt_bird_cleanup();
+
+  return 1;
+}
+
+static int UNUSED
+t_bench_trie_datasets_random(void)
+{
+  bt_bird_init();
+  bt_config_parse(BT_CONFIG_SIMPLE);
+
+  /* Specific datasets, not included */
+  benchmark_trie_dataset("trie-data-bgp-1", 1);
+  benchmark_trie_dataset("trie-data-bgp-10", 1);
+  benchmark_trie_dataset("trie-data-bgp-100", 1);
+  benchmark_trie_dataset("trie-data-bgp-1000", 1);
+
+  bt_bird_cleanup();
+
+  return 1;
+}
+
+
 static int
 t_trie_same(void)
 {
   bt_bird_init();
   bt_config_parse(BT_CONFIG_SIMPLE);
 
-  int round;
-  for (round = 0; round < TESTS_NUM*4; round++)
+  int v6 = 0;
+  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);
-    struct f_trie * trie2 = f_new_trie(config->mem, 0);
+    list *prefixes = make_random_prefix_list(lp, 100 * PREFIXES_NUM, v6, 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)
+      trie_add_prefix(trie1, &n->prefix.net, n->prefix.lo, n->prefix.hi);
+
+    WALK_LIST_BACKWARDS(n, *prefixes)
+      trie_add_prefix(trie2, &n->prefix.net, n->prefix.lo, n->prefix.hi);
+
+    bt_assert(trie_same(trie1, trie2));
+
+    v6 = !v6;
+    lp_flush(lp);
+  }
+
+  bt_bird_cleanup();
+  return 1;
+}
+
+static inline void
+log_networks(const net_addr *a, const net_addr *b)
+{
+  if (bt_verbose >= BT_VERBOSE_ABSOLUTELY_ALL)
+  {
+    char buf0[64];
+    char buf1[64];
+    bt_format_net(buf0, 64, a);
+    bt_format_net(buf1, 64, b);
+    bt_debug("Found %s expected %s\n", buf0, buf1);
+  }
+}
+
+static int
+t_trie_walk(void)
+{
+  bt_bird_init();
+  bt_config_parse(BT_CONFIG_SIMPLE);
+
+  linpool *lp = lp_new_default(&root_pool);
+  for (int round = 0; round < TESTS_NUM*8; round++)
+  {
+    int level = round / TESTS_NUM;
+    int v6 = level % 2;
+    int num = PREFIXES_NUM * (int[]){1, 10, 100, 1000}[level / 2];
+    int pos = 0, end = 0;
+    list *prefixes = make_random_prefix_list(lp, num, v6, 1);
+    struct f_trie *trie = make_trie_from_prefix_list(lp, prefixes);
+    struct f_prefix *pxset = malloc((num + 1) * sizeof(struct f_prefix));
 
     struct f_prefix_node *n;
-    WALK_LIST(n, prefixes)
+    WALK_LIST(n, *prefixes)
+      pxset[pos++] = n->prefix;
+    memset(&pxset[pos], 0, sizeof (struct f_prefix));
+
+    qsort(pxset, num, sizeof(struct f_prefix), compare_prefixes);
+
+
+    /* Full walk */
+    bt_debug("Full walk (round %d, %d nets)\n", round, num);
+
+    pos = 0;
+    uint pxc = 0;
+    TRIE_WALK(trie, net, NULL)
     {
-      trie_add_prefix(trie1, &n->prefix.net, n->prefix.lo, n->prefix.hi);
+      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++;
     }
-    WALK_LIST_BACKWARDS(n, prefixes)
+    TRIE_WALK_END;
+
+    bt_assert(pos == num);
+    bt_assert(pxc == trie->prefix_count);
+    bt_debug("Full walk done\n");
+
+
+    /* Prepare net for subnet walk - start with random prefix */
+    pos = bt_random() % num;
+    end = pos + (int[]){2, 2, 3, 4}[level / 2];
+    end = MIN(end, num);
+
+    struct f_prefix from = pxset[pos];
+
+    /* Find a common superprefix to several subsequent prefixes */
+    for (; pos < end; pos++)
     {
-      trie_add_prefix(trie2, &n->prefix.net, n->prefix.lo, n->prefix.hi);
+      if (net_equal(&from.net, &pxset[pos].net))
+	continue;
+
+      int common = !v6 ?
+	ip4_pxlen(net4_prefix(&from.net), net4_prefix(&pxset[pos].net)) :
+	ip6_pxlen(net6_prefix(&from.net), net6_prefix(&pxset[pos].net));
+      from.net.pxlen = MIN(from.net.pxlen, common);
+
+      if (!v6)
+	((net_addr_ip4 *) &from.net)->prefix =
+	  ip4_and(net4_prefix(&from.net), net4_prefix(&pxset[pos].net));
+      else
+	((net_addr_ip6 *) &from.net)->prefix =
+	  ip6_and(net6_prefix(&from.net), net6_prefix(&pxset[pos].net));
     }
 
-    bt_assert(trie_same(trie1, trie2));
+    /* Fix irrelevant bits */
+    if (!v6)
+      ((net_addr_ip4 *) &from.net)->prefix =
+	ip4_and(net4_prefix(&from.net), ip4_mkmask(net4_pxlen(&from.net)));
+    else
+      ((net_addr_ip6 *) &from.net)->prefix =
+	ip6_and(net6_prefix(&from.net), ip6_mkmask(net6_pxlen(&from.net)));
+
+
+    /* Find initial position for final prefix */
+    for (pos = 0; pos < num; pos++)
+      if (compare_prefixes(&pxset[pos], &from) >= 0)
+	break;
+
+    int p0 = pos;
+    char buf0[64];
+    bt_format_net(buf0, 64, &from.net);
+    bt_debug("Subnet walk for %s (round %d, %d nets)\n", buf0, round, num);
+
+    /* Subnet walk */
+    TRIE_WALK(trie, net, &from.net)
+    {
+      log_networks(&net, &pxset[pos].net);
+      bt_assert(net_equal(&net, &pxset[pos].net));
+      bt_assert(net_in_netX(&net, &from.net));
+
+      /* Skip possible duplicates */
+      while (net_equal(&pxset[pos].net, &pxset[pos + 1].net))
+	pos++;
 
-    struct f_prefix_node *nxt;
-    WALK_LIST_DELSAFE(n, nxt, prefixes)
+      pos++;
+    }
+    TRIE_WALK_END;
+
+    bt_assert((pos == num) || !net_in_netX(&pxset[pos].net, &from.net));
+    bt_debug("Subnet walk done for %s (found %d nets)\n", buf0, pos - p0);
+
+    lp_flush(lp);
+  }
+
+  bt_bird_cleanup();
+  return 1;
+}
+
+static int
+find_covering_nets(struct f_prefix *prefixes, int num, const net_addr *net, net_addr *found)
+{
+  struct f_prefix key;
+  net_addr *n = &key.net;
+  int found_num = 0;
+
+  net_copy(n, net);
+
+  while (1)
+  {
+    struct f_prefix *px =
+      bsearch(&key, prefixes, num, sizeof(struct f_prefix), compare_prefixes);
+
+    if (px)
+    {
+      net_copy(&found[found_num], n);
+      found_num++;
+    }
+
+    if (n->pxlen == 0)
+      return found_num;
+
+    n->pxlen--;
+
+    if (n->type == NET_IP4)
+      ip4_clrbit(&((net_addr_ip4 *) n)->prefix, n->pxlen);
+    else
+      ip6_clrbit(&((net_addr_ip6 *) n)->prefix, n->pxlen);
+  }
+}
+
+static int
+t_trie_walk_to_root(void)
+{
+  bt_bird_init();
+  bt_config_parse(BT_CONFIG_SIMPLE);
+
+  linpool *lp = lp_new_default(&root_pool);
+  for (int round = 0; round < TESTS_NUM * 4; round++)
+  {
+    int level = round / TESTS_NUM;
+    int v6 = level % 2;
+    int num = PREFIXES_NUM  * (int[]){32, 512}[level / 2];
+    int pos = 0;
+    int st = 0, sn = 0, sm = 0;
+
+    list *prefixes = make_random_prefix_list(lp, num, v6, 1);
+    struct f_trie *trie = make_trie_from_prefix_list(lp, prefixes);
+    struct f_prefix *pxset = malloc((num + 1) * sizeof(struct f_prefix));
+
+    struct f_prefix_node *pxn;
+    WALK_LIST(pxn, *prefixes)
+      pxset[pos++] = pxn->prefix;
+    memset(&pxset[pos], 0, sizeof (struct f_prefix));
+
+    qsort(pxset, num, sizeof(struct f_prefix), compare_prefixes);
+
+    int i;
+    for (i = 0; i < (PREFIX_TESTS_NUM / 10); i++)
     {
-      free(n);
+      net_addr from;
+      get_random_net(&from, v6);
+
+      net_addr found[129];
+      int found_num = find_covering_nets(pxset, num, &from, found);
+      int n = 0;
+
+      if (bt_verbose >= BT_VERBOSE_ABSOLUTELY_ALL)
+      {
+	char buf[64];
+	bt_format_net(buf, 64, &from);
+	bt_debug("Lookup for %s (expect %d)\n", buf, found_num);
+      }
+
+      /* Walk to root, separate for IPv4 and IPv6 */
+      if (!v6)
+      {
+	TRIE_WALK_TO_ROOT_IP4(trie, (net_addr_ip4 *) &from, net)
+	{
+	  log_networks((net_addr *) &net, &found[n]);
+	  bt_assert((n < found_num) && net_equal((net_addr *) &net, &found[n]));
+	  n++;
+	}
+	TRIE_WALK_TO_ROOT_END;
+      }
+      else
+      {
+	TRIE_WALK_TO_ROOT_IP6(trie, (net_addr_ip6 *) &from, net)
+	{
+	  log_networks((net_addr *) &net, &found[n]);
+	  bt_assert((n < found_num) && net_equal((net_addr *) &net, &found[n]));
+	  n++;
+	}
+	TRIE_WALK_TO_ROOT_END;
+      }
+
+      bt_assert(n == found_num);
+
+      /* Stats */
+      st += n;
+      sn += !!n;
+      sm = MAX(sm, n);
     }
+
+    bt_debug("Success in %d / %d, sum %d, max %d\n", sn, i, st, sm);
+
+    lp_flush(lp);
   }
 
+  bt_bird_cleanup();
   return 1;
 }
 
@@ -179,8 +896,15 @@ 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.");
+  bt_test_suite(t_trie_walk, "Testing TRIE_WALK() on random tries");
+  bt_test_suite(t_trie_walk_to_root, "Testing TRIE_WALK_TO_ROOT() on random tries");
+
+  // bt_test_suite(t_bench_trie_datasets_subset, "Benchmark tries from datasets by random subset of nets");
+  // bt_test_suite(t_bench_trie_datasets_random, "Benchmark tries from datasets by generated addresses");
 
   return bt_exit_value();
 }