Minor changes in prefix trie.

diff --git a/filter/config.Y b/filter/config.Y
index 0140c0c5c0dde26ace6f2b98464a2e540422b7a5..0b507ff2fc466044ebd463baea8b0c81c71faf4f 100644 (file)
--- a/filter/config.Y
+++ b/filter/config.Y
@@ -284,8 +284,8 @@ fprefix:
  ;
 
 fprefix_set:
-   fprefix { $$ = f_new_trie(); trie_add_prefix($$, &($1.val.px)); }
- | fprefix_set ',' fprefix { $$ = $1; trie_add_prefix($$, &($3.val.px)); }
+   fprefix { $$ = f_new_trie(cfg_mem); trie_add_fprefix($$, &($1.val.px)); }
+ | fprefix_set ',' fprefix { $$ = $1; trie_add_fprefix($$, &($3.val.px)); }
  ;
 
 switch_body: /* EMPTY */ { $$ = NULL; }

diff --git a/filter/filter.c b/filter/filter.c
index 5492f80d04670a491549672d8cd3bb9ae599fb93..322fe0921dba85d962251e150b16e8988f2cbe28 100644 (file)
--- a/filter/filter.c
+++ b/filter/filter.c
@@ -186,7 +186,7 @@ tree_compare(const void *p1, const void *p2)
 }
 
 void
-f_prefix_get_bounds(struct f_prefix *px, int *l, int *h)
+fprefix_get_bounds(struct f_prefix *px, int *l, int *h)
 {
   *l = *h = px->len & LEN_MASK;
 
@@ -319,7 +319,7 @@ val_in_range(struct f_val v1, struct f_val v2)
     return res;
   
   if ((v1.type == T_PREFIX) && (v2.type == T_PREFIX_SET))
-    return trie_match_prefix(v2.val.ti, &v1.val.px);
+    return trie_match_fprefix(v2.val.ti, &v1.val.px);
 
   if ((v1.type == T_CLIST) && (v2.type == T_SET))
     return clist_match_set(v1.val.ad, v2.val.t);

diff --git a/filter/filter.h b/filter/filter.h
index 46dc1a23fe00a18901c1cc693bce2e6a067b0752..914851812af825ad46b01e7924933debb2fed764 100644 (file)
--- a/filter/filter.h
+++ b/filter/filter.h
@@ -70,12 +70,29 @@ struct f_tree *build_tree(struct f_tree *);
 struct f_tree *find_tree(struct f_tree *t, struct f_val val);
 int same_tree(struct f_tree *t1, struct f_tree *t2);
 
-struct f_trie *f_new_trie(void);
-void trie_add_prefix(struct f_trie *t, struct f_prefix *px);
-int trie_match_prefix(struct f_trie *t, struct f_prefix *px);
+struct f_trie *f_new_trie(linpool *lp);
+void trie_add_prefix(struct f_trie *t, ip_addr px, int plen, int l, int h);
+int trie_match_prefix(struct f_trie *t, ip_addr px, int plen);
 int trie_same(struct f_trie *t1, struct f_trie *t2);
 int trie_print(struct f_trie *t, char *buf, int blen);
 
+void fprefix_get_bounds(struct f_prefix *px, int *l, int *h);
+
+static inline void
+trie_add_fprefix(struct f_trie *t, struct f_prefix *px)
+{
+  int l, h;
+  fprefix_get_bounds(px, &l, &h);
+  trie_add_prefix(t, px->ip, px->len & LEN_MASK, l, h);
+}
+
+static inline int
+trie_match_fprefix(struct f_trie *t, struct f_prefix *px)
+{
+  return trie_match_prefix(t, px->ip, px->len & LEN_MASK);
+}
+
+
 struct ea_list;
 struct rte;
 
@@ -87,9 +104,7 @@ char *filter_name(struct filter *filter);
 int filter_same(struct filter *new, struct filter *old);
 
 int i_same(struct f_inst *f1, struct f_inst *f2);
-void f_prefix_get_bounds(struct f_prefix *px, int *l, int *h);
 
-void f_prefix_get_bounds(struct f_prefix *px, int *l, int *h);
 int val_compare(struct f_val v1, struct f_val v2);
 int tree_compare(const void *p1, const void *p2);
 void val_print(struct f_val v);
@@ -158,6 +173,7 @@ struct f_trie_node
 
 struct f_trie
 {
+  linpool *lp;
   int zero;
   struct f_trie_node root;
 };

diff --git a/filter/trie.c b/filter/trie.c
index fb405ded3c23630bc7e27c2947289f373a683864..522eb99ffe2af3be753d20d579cb9e9e5aa8b0b6 100644 (file)
--- a/filter/trie.c
+++ b/filter/trie.c
@@ -14,7 +14,7 @@
  * 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 pattern. Each prefix pattern consists of
+ * 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.
@@ -65,8 +65,8 @@
  * - 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 add_node_to_trie() and trie_match_prefix()
- * is structured according to these cases.
+ * The walking code in trie_match_prefix() is structured according to
+ * these cases.
  */
 
 #include "nest/bird.h"
@@ -80,17 +80,18 @@
  * Allocates and returns a new empty trie.
  */
 struct f_trie *
-f_new_trie(void)
+f_new_trie(linpool *lp)
 {
   struct f_trie * ret;
-  ret = cfg_allocz(sizeof(struct f_trie));
+  ret = lp_allocz(lp, sizeof(struct f_trie));
+  ret->lp = lp;
   return ret;
 }
 
 static inline struct f_trie_node *
-new_node(int plen, ip_addr paddr, ip_addr pmask, ip_addr amask)
+new_node(struct f_trie *t, int plen, ip_addr paddr, ip_addr pmask, ip_addr amask)
 {
-  struct f_trie_node *n = cfg_allocz(sizeof(struct f_trie_node));
+  struct f_trie_node *n = lp_allocz(t->lp, sizeof(struct f_trie_node));
   n->plen = plen;
   n->addr = paddr;
   n->mask = pmask;
@@ -104,11 +105,33 @@ attach_node(struct f_trie_node *parent, struct f_trie_node *child)
   parent->c[ipa_getbit(child->addr, parent->plen) ? 1 : 0] = child;
 }
 
-static void
-add_node_to_trie(struct f_trie *t, int plen, ip_addr ip, ip_addr amask)
+/**
+ * trie_add_prefix
+ * @t: trie to add to
+ * @px: prefix address
+ * @plen: prefix length
+ * @l: prefix lower bound 
+ * @h: prefix upper bound
+ *
+ * Adds prefix (prefix pattern) @px/@plen to trie @t.  @l and @h are lower
+ * and upper bounds on accepted prefix lengths, both inclusive. 0 <=
+ * l, h <= 32 (128 for IPv6).
+ */
+
+void
+trie_add_prefix(struct f_trie *t, ip_addr px, int plen, int l, int h)
 {
+  if (l == 0)
+    t->zero = 1;
+  else
+    l--;
+
+  if (h < plen)
+    plen = h;
+
+  ip_addr amask = ipa_xor(ipa_mkmask(l), ipa_mkmask(h));
   ip_addr pmask = ipa_mkmask(plen);
-  ip_addr paddr = ipa_and(ip, pmask);
+  ip_addr paddr = ipa_and(px, pmask);
   struct f_trie_node *o = NULL;
   struct f_trie_node *n = &t->root;
 
@@ -123,13 +146,13 @@ add_node_to_trie(struct f_trie *t, int plen, ip_addr ip, ip_addr amask)
             as the other child of 'b'. */
          int blen = ipa_pxlen(paddr, n->addr);
          ip_addr bmask = ipa_mkmask(blen);
-         ip_addr baddr = ipa_and(ip, bmask);
+         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, n->accept), bmask);
 
-         struct f_trie_node *a = new_node(plen, paddr, pmask, amask);
-         struct f_trie_node *b = new_node(blen, baddr, bmask, baccm);
+         struct f_trie_node *a = new_node(t, plen, paddr, pmask, amask);
+         struct f_trie_node *b = new_node(t, blen, baddr, bmask, baccm);
          attach_node(o, b);
          attach_node(b, n);
          attach_node(b, a);
@@ -140,7 +163,7 @@ add_node_to_trie(struct f_trie *t, int plen, ip_addr ip, ip_addr amask)
        {
          /* We add new node 'a' between node 'o' and node 'n' */
          amask = ipa_or(amask, ipa_and(n->accept, pmask));
-         struct f_trie_node *a = new_node(plen, paddr, pmask, amask);
+         struct f_trie_node *a = new_node(t, plen, paddr, pmask, amask);
          attach_node(o, a);
          attach_node(a, n);
          return;
@@ -156,58 +179,31 @@ add_node_to_trie(struct f_trie *t, int plen, ip_addr ip, ip_addr amask)
       /* Update accept mask part M2 and go deeper */
       n->accept = ipa_or(n->accept, ipa_and(amask, n->mask));
 
-      /* n->plen < plen and plen <= 32 */
+      /* n->plen < plen and plen <= 32 (128) */
       o = n;
       n = n->c[ipa_getbit(paddr, n->plen) ? 1 : 0];
     }
 
   /* We add new tail node 'a' after node 'o' */
-  struct f_trie_node *a = new_node(plen, paddr, pmask, amask);
+  struct f_trie_node *a = new_node(t, plen, paddr, pmask, amask);
   attach_node(o, a);
 }
 
 /**
- * trie_add_prefix
- * @t: trie to add to
- * @px: prefix to add
- *
- * Adds prefix (prefix pattern) @px to trie @t.
- */
-void
-trie_add_prefix(struct f_trie *t, struct f_prefix *px)
-{
-  int l, h;
-  int plen = px->len & LEN_MASK;
-
-  /* 'l' and 'h' are lower and upper bounds on accepted
-     prefix lengths, both inclusive. 0 <= l, h <= 32 */
-  f_prefix_get_bounds(px, &l, &h);
-
-  if (l == 0)
-    t->zero = 1;
-  else
-    l--;
-
-  ip_addr amask = ipa_xor(ipa_mkmask(l), ipa_mkmask(h));
-  /* MIN(plen, h) instead of just plen is a little trick. */
-  add_node_to_trie(t, MIN(plen, h), px->ip, amask);
-}
-
-/**
- * trie_match_prefix
+ * trie_match
  * @t: trie
- * @px: prefix
+ * @px: prefix address
+ * @plen: prefix length
  *
  * Tries to find a matching prefix pattern in the trie such that
- * prefix @px matches that prefix pattern. Returns 1 if there
+ * prefix @px/@plen matches that prefix pattern. Returns 1 if there
  * is such prefix pattern in the trie.
  */
 int
-trie_match_prefix(struct f_trie *t, struct f_prefix *px)
+trie_match_prefix(struct f_trie *t, ip_addr px, int plen)
 {
-  int plen = px->len & LEN_MASK;
   ip_addr pmask = ipa_mkmask(plen);
-  ip_addr paddr = ipa_and(px->ip, pmask);
+  ip_addr paddr = ipa_and(px, pmask);
 
   if (plen == 0)
     return t->zero;