filter/trie.c

   1 /*
   2  *      Filters: Trie for prefix sets
   3  *
   4  *      Copyright 2009 Ondrej Zajicek <santiago@crfreenet.org>
   5  *
   6  *      Can be freely distributed and used under the terms of the GNU GPL.
   7  */
   8
   9 /**
  10  * DOC: Trie for prefix sets
  11  *
  12  * We use a (compressed) trie to represent prefix sets. Every node
  13  * in the trie represents one prefix (&addr/&plen) and &plen also
  14  * indicates the index of the bit in the address that is used to
  15  * branch at the node. If we need to represent just a set of
  16  * prefixes, it would be simple, but we have to represent a
  17  * set of prefix patterns. Each prefix pattern consists of
  18  * &ppaddr/&pplen and two integers: &low and &high, and a prefix
  19  * &paddr/&plen matches that pattern if the first MIN(&plen, &pplen)
  20  * bits of &paddr and &ppaddr are the same and &low <= &plen <= &high.
  21  *
  22  * We use a bitmask (&accept) to represent accepted prefix lengths
  23  * at a node. As there are 33 prefix lengths (0..32 for IPv4), but
  24  * there is just one prefix of zero length in the whole trie so we
  25  * have &zero flag in &f_trie (indicating whether the trie accepts
  26  * prefix 0.0.0.0/0) as a special case, and &accept bitmask
  27  * represents accepted prefix lengths from 1 to 32.
  28  *
  29  * There are two cases in prefix matching - a match when the length
  30  * of the prefix is smaller that the length of the prefix pattern,
  31  * (&plen < &pplen) and otherwise. The second case is simple - we
  32  * just walk through the trie and look at every visited node
  33  * whether that prefix accepts our prefix length (&plen). The
  34  * first case is tricky - we don't want to examine every descendant
  35  * of a final node, so (when we create the trie) we have to propagate
  36  * that information from nodes to their ascendants.
  37  *
  38  * Suppose that we have two masks (M1 and M2) for a node. Mask M1
  39  * represents accepted prefix lengths by just the node and mask M2
  40  * represents accepted prefix lengths by the node or any of its
  41  * descendants. Therefore M2 is a bitwise or of M1 and children's
  42  * M2 and this is a maintained invariant during trie building.
  43  * Basically, when we want to match a prefix, we walk through the trie,
  44  * check mask M1 for our prefix length and when we came to
  45  * final node, we check mask M2.
  46  *
  47  * There are two differences in the real implementation. First,
  48  * we use a compressed trie so there is a case that we skip our
  49  * final node (if it is not in the trie) and we came to node that
  50  * is either extension of our prefix, or completely out of path
  51  * In the first case, we also have to check M2.
  52  *
  53  * Second, we really need not to maintain two separate bitmasks.
  54  * Checks for mask M1 are always larger than &applen and we need
  55  * just the first &pplen bits of mask M2 (if trie compression
  56  * hadn't been used it would suffice to know just $applen-th bit),
  57  * so we have to store them together in &accept mask - the first
  58  * &pplen bits of mask M2 and then mask M1.
  59  *
  60  * There are four cases when we walk through a trie:
  61  *
  62  * - we are in NULL
  63  * - we are out of path (prefixes are inconsistent)
  64  * - we are in the wanted (final) node (node length == &plen)
  65  * - we are beyond the end of path (node length > &plen)
  66  * - we are still on path and keep walking (node length < &plen)
  67  *
  68  * The walking code in trie_match_prefix() is structured according to
  69  * these cases.
  70  */
  71
  72 #include "nest/bird.h"
  73 #include "lib/string.h"
  74 #include "conf/conf.h"
  75 #include "filter/filter.h"
  76
  77
  78 /*
  79  * In the trie code, the prefix length is internally treated as for the whole
  80  * ip_addr, regardless whether it contains an IPv4 or IPv6 address. Therefore,
  81  * remaining definitions make sense.
  82  */
  83
  84 #define ipa_mkmask(x) ip6_mkmask(x)
  85 #define ipa_masklen(x) ip6_masklen(&x)
  86 #define ipa_pxlen(x,y) ip6_pxlen(x,y)
  87 #define ipa_getbit(x,n) ip6_getbit(x,n)
  88
  89
  90 /**
  91  * f_new_trie - allocates and returns a new empty trie
  92  * @lp: linear pool to allocate items from
  93  * @node_size: node size to be used (&f_trie_node and user data)
  94  */
  95 struct f_trie *
  96 f_new_trie(linpool *lp, uint node_size)
  97 {
  98   struct f_trie * ret;
  99   ret = lp_allocz(lp, sizeof(struct f_trie) + node_size);
 100   ret->lp = lp;
 101   ret->node_size = node_size;
 102   return ret;
 103 }
 104
 105 static inline struct f_trie_node *
 106 new_node(struct f_trie *t, int plen, ip_addr paddr, ip_addr pmask, ip_addr amask)
 107 {
 108   struct f_trie_node *n = lp_allocz(t->lp, t->node_size);
 109   n->plen = plen;
 110   n->addr = paddr;
 111   n->mask = pmask;
 112   n->accept = amask;
 113   return n;
 114 }
 115
 116 static inline void
 117 attach_node(struct f_trie_node *parent, struct f_trie_node *child)
 118 {
 119   parent->c[ipa_getbit(child->addr, parent->plen) ? 1 : 0] = child;
 120 }
 121
 122 /**
 123  * trie_add_prefix
 124  * @t: trie to add to
 125  * @net: IP network prefix
 126  * @l: prefix lower bound
 127  * @h: prefix upper bound
 128  *
 129  * Adds prefix (prefix pattern) @n to trie @t.  @l and @h are lower
 130  * and upper bounds on accepted prefix lengths, both inclusive.
 131  * 0 <= l, h <= 32 (128 for IPv6).
 132  *
 133  * Returns a pointer to the allocated node. The function can return a pointer to
 134  * an existing node if @px and @plen are the same. If px/plen == 0/0 (or ::/0),
 135  * a pointer to the root node is returned.
 136  */
 137
 138 void *
 139 trie_add_prefix(struct f_trie *t, const net_addr *net, uint l, uint h)
 140 {
 141   ip_addr px = net_prefix(net);
 142   uint plen = net_pxlen(net);
 143
 144   if (net->type == NET_IP4)
 145   {
 146     const uint delta = IP6_MAX_PREFIX_LENGTH - IP4_MAX_PREFIX_LENGTH;
 147     plen += delta;
 148     l += delta;
 149     h += delta;
 150   }
 151
 152   if (l == 0)
 153     t->zero = 1;
 154   else
 155     l--;
 156
 157   if (h < plen)
 158     plen = h;
 159
 160   ip_addr amask = ipa_xor(ipa_mkmask(l), ipa_mkmask(h));
 161   ip_addr pmask = ipa_mkmask(plen);
 162   ip_addr paddr = ipa_and(px, pmask);
 163   struct f_trie_node *o = NULL;
 164   struct f_trie_node *n = t->root;
 165
 166   while (n)
 167     {
 168       ip_addr cmask = ipa_and(n->mask, pmask);
 169
 170       if (ipa_compare(ipa_and(paddr, cmask), ipa_and(n->addr, cmask)))
 171         {
 172           /* We are out of path - we have to add branching node 'b'
 173              between node 'o' and node 'n', and attach new node 'a'
 174              as the other child of 'b'. */
 175           int blen = ipa_pxlen(paddr, n->addr);
 176           ip_addr bmask = ipa_mkmask(blen);
 177           ip_addr baddr = ipa_and(px, bmask);
 178
 179           /* Merge accept masks from children to get accept mask for node 'b' */
 180           ip_addr baccm = ipa_and(ipa_or(amask, n->accept), bmask);
 181
 182           struct f_trie_node *a = new_node(t, plen, paddr, pmask, amask);
 183           struct f_trie_node *b = new_node(t, blen, baddr, bmask, baccm);
 184           attach_node(o, b);
 185           attach_node(b, n);
 186           attach_node(b, a);
 187           return a;
 188         }
 189
 190       if (plen < n->plen)
 191         {
 192           /* We add new node 'a' between node 'o' and node 'n' */
 193           amask = ipa_or(amask, ipa_and(n->accept, pmask));
 194           struct f_trie_node *a = new_node(t, plen, paddr, pmask, amask);
 195           attach_node(o, a);
 196           attach_node(a, n);
 197           return a;
 198         }
 199
 200       if (plen == n->plen)
 201         {
 202           /* We already found added node in trie. Just update accept mask */
 203           n->accept = ipa_or(n->accept, amask);
 204           return n;
 205         }
 206
 207       /* Update accept mask part M2 and go deeper */
 208       n->accept = ipa_or(n->accept, ipa_and(amask, n->mask));
 209
 210       /* n->plen < plen and plen <= 32 (128) */
 211       o = n;
 212       n = n->c[ipa_getbit(paddr, n->plen) ? 1 : 0];
 213     }
 214
 215   /* We add new tail node 'a' after node 'o' */
 216   struct f_trie_node *a = new_node(t, plen, paddr, pmask, amask);
 217   attach_node(o, a);
 218
 219   return a;
 220 }
 221
 222 static int
 223 trie_match_prefix(struct f_trie *t, ip_addr px, int plen)
 224 {
 225   ip_addr pmask = ipa_mkmask(plen);
 226   ip_addr paddr = ipa_and(px, pmask);
 227
 228   if (plen == 0)
 229     return t->zero;
 230
 231   int plentest = plen - 1;
 232   struct f_trie_node *n = t->root;
 233
 234   while(n)
 235     {
 236       ip_addr cmask = ipa_and(n->mask, pmask);
 237
 238       /* We are out of path */
 239       if (ipa_compare(ipa_and(paddr, cmask), ipa_and(n->addr, cmask)))
 240         return 0;
 241
 242       /* Check accept mask */
 243       if (ipa_getbit(n->accept, plentest))
 244         return 1;
 245
 246       /* We finished trie walk and still no match */
 247       if (plen <= n->plen)
 248         return 0;
 249
 250       /* Choose children */
 251       n =  n->c[(ipa_getbit(paddr, n->plen)) ? 1 : 0];
 252     }
 253
 254   return 0;
 255 }
 256
 257 /**
 258  * trie_match_net
 259  * @t: trie
 260  * @n: net address
 261  *
 262  * Tries to find a matching net in the trie such that
 263  * prefix @n matches that prefix pattern. Returns 1 if there
 264  * is such prefix pattern in the trie.
 265  */
 266 int
 267 trie_match_net(struct f_trie *t, const net_addr *n)
 268 {
 269   int add = 0;
 270   switch (n->type) {
 271     case NET_IP4:
 272     case NET_VPN4:
 273     case NET_ROA4:
 274       add = IP6_MAX_PREFIX_LENGTH - IP4_MAX_PREFIX_LENGTH;
 275   }
 276
 277   return trie_match_prefix(t, net_prefix(n), net_pxlen(n) + add);
 278 }
 279
 280 static int
 281 trie_node_same(struct f_trie_node *t1, struct f_trie_node *t2)
 282 {
 283   if ((t1 == NULL) && (t2 == NULL))
 284     return 1;
 285
 286   if ((t1 == NULL) || (t2 == NULL))
 287     return 0;
 288
 289   if ((t1->plen != t2->plen) ||
 290       (! ipa_equal(t1->addr, t2->addr)) ||
 291       (! ipa_equal(t1->accept, t2->accept)))
 292     return 0;
 293
 294   return trie_node_same(t1->c[0], t2->c[0]) && trie_node_same(t1->c[1], t2->c[1]);
 295 }
 296
 297 /**
 298  * trie_same
 299  * @t1: first trie to be compared
 300  * @t2: second one
 301  *
 302  * Compares two tries and returns 1 if they are same
 303  */
 304 int
 305 trie_same(struct f_trie *t1, struct f_trie *t2)
 306 {
 307   return (t1->zero == t2->zero) && trie_node_same(t1->root, t2->root);
 308 }
 309
 310 static void
 311 trie_node_format(struct f_trie_node *t, buffer *buf)
 312 {
 313   if (t == NULL)
 314     return;
 315
 316   if (ipa_nonzero(t->accept))
 317     buffer_print(buf, "%I/%d{%I}, ", t->addr, t->plen, t->accept);
 318
 319   trie_node_format(t->c[0], buf);
 320   trie_node_format(t->c[1], buf);
 321 }
 322
 323 /**
 324  * trie_format
 325  * @t: trie to be formatted
 326  * @buf: destination buffer
 327  *
 328  * Prints the trie to the supplied buffer.
 329  */
 330 void
 331 trie_format(struct f_trie *t, buffer *buf)
 332 {
 333   buffer_puts(buf, "[");
 334
 335   if (t->zero)
 336     buffer_print(buf, "%I/%d", IPA_NONE, 0);
 337   trie_node_format(t->root, buf);
 338
 339   /* Undo last separator */
 340   if (buf->pos[-1] != '[')
 341     buf->pos -= 2;
 342
 343   buffer_puts(buf, "]");
 344 }