From 77edab640925e8d1131f0d00b41de055129ff99f Mon Sep 17 00:00:00 2001
From: Ondrej Zajicek <santiago@crfreenet.org>
Date: Fri, 1 May 2015 14:40:56 +0200
Subject: [PATCH 001/165] OSPF: Redesign LSA checksumming

New LSA checksumming code separates generic Fletcher-16 and OSPF-specific
code and avoids back and forth endianity conversions, making it much more
readable and also several times faster.
---
 lib/fletcher16.h      | 196 ++++++++++++++++++++++++++++++++++++++++++
 proto/ospf/lsalib.c   | 149 +++++---------------------------
 proto/ospf/lsalib.h   |   4 +-
 proto/ospf/lsupd.c    |   4 +-
 proto/ospf/topology.c |   6 +-
 5 files changed, 226 insertions(+), 133 deletions(-)
 create mode 100644 lib/fletcher16.h

diff --git a/lib/fletcher16.h b/lib/fletcher16.h
new file mode 100644
index 00000000..0b245a71
--- /dev/null
+++ b/lib/fletcher16.h
@@ -0,0 +1,196 @@
+/*
+ *	BIRD Library -- Fletcher-16 checksum
+ *
+ *	(c) 2015 Ondrej Zajicek <santiago@crfreenet.org>
+ *	(c) 2015 CZ.NIC z.s.p.o.
+ *
+ *	Can be freely distributed and used under the terms of the GNU GPL.
+ */
+
+/**
+ * DOC: Fletcher-16 checksum
+ *
+ * Fletcher-16 checksum is a position-dependent checksum algorithm used for
+ * error-detection e.g. in OSPF LSAs.
+ *
+ * To generate Fletcher-16 checksum, zero the checksum field in data, initialize
+ * the context by fletcher16_init(), process the data by fletcher16_update(),
+ * compute the checksum value by fletcher16_final() and store it to the checksum
+ * field in data by put_u16() (or other means involving htons() conversion).
+ *
+ * To verify Fletcher-16 checksum, initialize the context by fletcher16_init(),
+ * process the data by fletcher16_update(), compute a passing checksum by
+ * fletcher16_compute() and check if it is zero.
+ */
+
+#ifndef _BIRD_FLETCHER16_H_
+#define _BIRD_FLETCHER16_H_
+
+#include "nest/bird.h"
+
+
+struct fletcher16_context
+{
+  int c0, c1;
+};
+
+
+/**
+ * fletcher16_init - initialize Fletcher-16 context
+ * @ctx: the context
+ */
+static inline void
+fletcher16_init(struct fletcher16_context *ctx)
+{
+  ctx->c0 = ctx->c1 = 0;
+}
+
+/**
+ * fletcher16_update - process data to Fletcher-16 context
+ * @ctx: the context
+ * @buf: data buffer
+ * @len: data length
+ *
+ * fletcher16_update() reads data from the buffer @buf and updates passing sums
+ * in the context @ctx. It may be used multiple times for multiple blocks of
+ * checksummed data.
+ */
+static inline void
+fletcher16_update(struct fletcher16_context *ctx, const u8* buf, int len)
+{
+  /*
+   * The Fletcher-16 sum is essentially a sequence of
+   * ctx->c1 += ctx->c0 += *buf++, modulo 255.
+   *
+   * In the inner loop, we eliminate modulo operation and we do some loop
+   * unrolling. MODX is the maximal number of steps that can be done without
+   * modulo before overflow, see RFC 1008 for details. We use a bit smaller
+   * value to cover for initial steps due to loop unrolling.
+   */
+
+#define MODX 4096
+
+  int blen, i;
+
+  blen = len % 4;
+  len -= blen;
+
+  for (i = 0; i < blen; i++)
+    ctx->c1 += ctx->c0 += *buf++;
+
+  do {
+    blen = MIN(len, MODX);
+    len -= blen;
+
+    for (i = 0; i < blen; i += 4)
+    {
+      ctx->c1 += ctx->c0 += *buf++;
+      ctx->c1 += ctx->c0 += *buf++;
+      ctx->c1 += ctx->c0 += *buf++;
+      ctx->c1 += ctx->c0 += *buf++;
+    }
+
+    ctx->c0 %= 255;
+    ctx->c1 %= 255;
+
+  } while (len);
+}
+
+
+/**
+ * fletcher16_update_n32 - process data to Fletcher-16 context, with endianity adjustment
+ * @ctx: the context
+ * @buf: data buffer
+ * @len: data length
+ *
+ * fletcher16_update_n32() works like fletcher16_update(), except it applies
+ * 32-bit host/network endianity swap to the data before they are processed.
+ * I.e., it assumes that the data is a sequence of u32 that must be converted by
+ * ntohl() or htonl() before processing. The @buf need not to be aligned, but
+ * its length (@len) must be multiple of 4. Note that on big endian systems the
+ * host endianity is the same as the network endianity, therefore there is no
+ * endianity swap.
+ */
+static inline void
+fletcher16_update_n32(struct fletcher16_context *ctx, const u8* buf, int len)
+{
+  /* See fletcher16_update() for details */
+
+  int blen, i;
+
+  do {
+    blen = MIN(len, MODX);
+    len -= blen;
+
+    for (i = 0; i < blen; i += 4)
+    {
+#ifdef CPU_BIG_ENDIAN
+      ctx->c1 += ctx->c0 += *buf++;
+      ctx->c1 += ctx->c0 += *buf++;
+      ctx->c1 += ctx->c0 += *buf++;
+      ctx->c1 += ctx->c0 += *buf++;
+#else
+      ctx->c1 += ctx->c0 += buf[3];
+      ctx->c1 += ctx->c0 += buf[2];
+      ctx->c1 += ctx->c0 += buf[1];
+      ctx->c1 += ctx->c0 += buf[0];
+      buf += 4;
+#endif
+    }
+
+    ctx->c0 %= 255;
+    ctx->c1 %= 255;
+
+  } while (len);
+}
+
+/**
+ * fletcher16_final - compute final Fletcher-16 checksum value
+ * @ctx: the context
+ * @len: total data length
+ * @pos: offset in data where the checksum will be stored
+ *
+ * fletcher16_final() computes the final checksum value and returns it.
+ * The caller is responsible for storing it in the appropriate position.
+ * The checksum value depends on @len and @pos, but only their difference
+ * (i.e. the offset from the end) is significant.
+ *
+ * The checksum value is represented as u16, although it is defined as two
+ * consecutive bytes. We treat them as one u16 in big endian / network order.
+ * I.e., the returned value is in the form that would be returned by get_u16()
+ * from the checksum field in the data buffer, therefore the caller should use
+ * put_u16() or an explicit host-to-network conversion when storing it to the
+ * checksum field in the data buffer.
+ *
+ * Note that the returned checksum value is always nonzero.
+ */
+static inline u16
+fletcher16_final(struct fletcher16_context *ctx, int len, int pos)
+{
+  int x = ((len - pos - 1) * ctx->c0 - ctx->c1) % 255;
+  if (x <= 0)
+    x += 255;
+
+  int y = 510 - ctx->c0 - x;
+  if (y > 255)
+    y -= 255;
+
+  return (x << 8) | y;
+}
+
+
+/**
+ * fletcher16_compute - compute Fletcher-16 sum for verification
+ * @ctx: the context
+ *
+ * fletcher16_compute() returns a passing Fletcher-16 sum for processed data.
+ * If the data contains the proper Fletcher-16 checksum value, the returned
+ * value is zero.
+ */
+static inline u16
+fletcher16_compute(struct fletcher16_context *ctx)
+{
+  return (ctx->c0 << 8) | ctx->c1;
+}
+
+#endif
diff --git a/proto/ospf/lsalib.c b/proto/ospf/lsalib.c
index ce6fb178..66a3a23d 100644
--- a/proto/ospf/lsalib.c
+++ b/proto/ospf/lsalib.c
@@ -2,14 +2,15 @@
  *	BIRD -- OSPF
  *
  *	(c) 1999--2004 Ondrej Filip <feela@network.cz>
- *	(c) 2009--2014 Ondrej Zajicek <santiago@crfreenet.org>
- *	(c) 2009--2014 CZ.NIC z.s.p.o.
+ *	(c) 2009--2015 Ondrej Zajicek <santiago@crfreenet.org>
+ *	(c) 2009--2015 CZ.NIC z.s.p.o.
  *
  *	Can be freely distributed and used under the terms of the GNU GPL.
  */
 
 #include "ospf.h"
 
+#include "lib/fletcher16.h"
 
 #ifndef CPU_BIG_ENDIAN
 void
@@ -150,145 +151,41 @@ lsa_get_type_domain_(u32 itype, struct ospf_iface *ifa, u32 *otype, u32 *domain)
 }
 
 
-
-/*
 void
-buf_dump(const char *hdr, const byte *buf, int blen)
+lsa_generate_checksum(struct ospf_lsa_header *lsa, const u8 *body)
 {
-  char b2[1024];
-  char *bp;
-  int first = 1;
-  int i;
-
-  const char *lhdr = hdr;
-
-  bp = b2;
-  for(i = 0; i < blen; i++)
-    {
-      if ((i > 0) && ((i % 16) == 0))
-	{
-	      *bp = 0;
-	      log(L_WARN "%s\t%s", lhdr, b2);
-	      lhdr = "";
-	      bp = b2;
-	}
-
-      bp += snprintf(bp, 1022, "%02x ", buf[i]);
-
-    }
-
-  *bp = 0;
-  log(L_WARN "%s\t%s", lhdr, b2);
-}
-*/
-
-#define MODX 4102		/* larges signed value without overflow */
-
-/* Fletcher Checksum -- Refer to RFC1008. */
-#define MODX                 4102
-#define LSA_CHECKSUM_OFFSET    15
-
-/* FIXME This is VERY uneficient, I have huge endianity problems */
-void
-lsasum_calculate(struct ospf_lsa_header *h, void *body)
-{
-  u16 length = h->length;
-
-  //  log(L_WARN "Checksum %R %R %d start (len %d)", h->id, h->rt, h->type, length);
-  lsa_hton_hdr(h, h);
-  lsa_hton_body1(body, length - sizeof(struct ospf_lsa_header));
+  struct fletcher16_context ctx;
+  struct ospf_lsa_header hdr;
+  u16 len = lsa->length;
 
   /*
-  char buf[1024];
-  memcpy(buf, h, sizeof(struct ospf_lsa_header));
-  memcpy(buf + sizeof(struct ospf_lsa_header), body, length - sizeof(struct ospf_lsa_header));
-  buf_dump("CALC", buf, length);
-  */
+   * lsa and body are in the host order, we need to compute Fletcher-16 checksum
+   * for data in the network order. We also skip the initial age field.
+   */
 
-  (void) lsasum_check(h, body, 1);
+  lsa_hton_hdr(lsa, &hdr);
+  hdr.checksum = 0;
 
-  //  log(L_WARN "Checksum result %4x", h->checksum);
-
-  lsa_ntoh_hdr(h, h);
-  lsa_ntoh_body1(body, length - sizeof(struct ospf_lsa_header));
+  fletcher16_init(&ctx);
+  fletcher16_update(&ctx, (u8 *) &hdr + 2, sizeof(struct ospf_lsa_header) - 2);
+  fletcher16_update_n32(&ctx, body, len - sizeof(struct ospf_lsa_header));
+  lsa->checksum = fletcher16_final(&ctx, len, OFFSETOF(struct ospf_lsa_header, checksum));
 }
 
-/*
- * Calculates the Fletcher checksum of an OSPF LSA.
- *
- * If 'update' is non-zero, the checkbytes (X and Y in RFC905) are calculated
- * and the checksum field in the header is updated. The return value is the
- * checksum as placed in the header (in network byte order).
- *
- * If 'update' is zero, only C0 and C1 are calculated and the header is kept
- * intact. The return value is a combination of C0 and C1; if the return value
- * is exactly zero the checksum is considered valid, any non-zero value is
- * invalid.
- *
- * Note that this function expects the input LSA to be in network byte order.
- */
 u16
-lsasum_check(struct ospf_lsa_header *h, void *body, int update)
+lsa_verify_checksum(const void *lsa_n, int lsa_len)
 {
-  u8 *sp, *ep, *p, *q, *b;
-  int c0 = 0, c1 = 0;
-  int x, y;
-  u16 length;
-
-  b = body;
-  sp = (char *) h;
-  sp += 2; /* Skip Age field */
-  length = ntohs(h->length) - 2;
-  if (update) h->checksum = 0;
-
-  for (ep = sp + length; sp < ep; sp = q)
-  {				/* Actually MODX is very large, do we need the for-cyclus? */
-    q = sp + MODX;
-    if (q > ep)
-      q = ep;
-    for (p = sp; p < q; p++)
-    {
-      /*
-       * I count with bytes from header and than from body
-       * but if there is no body, it's appended to header
-       * (probably checksum in update receiving) and I go on
-       * after header
-       */
-      if ((b == NULL) || (p < (u8 *) (h + 1)))
-      {
-	c0 += *p;
-      }
-      else
-      {
-	c0 += *(b + (p - (u8 *) (h + 1)));
-      }
-
-      c1 += c0;
-    }
-    c0 %= 255;
-    c1 %= 255;
-  }
+  struct fletcher16_context ctx;
 
-  if (!update) {
-    /*
-     * When testing the checksum, we don't need to calculate x and y. The
-     * checksum passes if c0 and c1 are both 0.
-     */
-    return (c0 << 8) | (c1 & 0xff);
-  }
+  /* The whole LSA is at lsa_n in net order, we just skip initial age field */
 
-  x = (int)((length - LSA_CHECKSUM_OFFSET) * c0 - c1) % 255;
-  if (x <= 0)
-    x += 255;
-  y = 510 - c0 - x;
-  if (y > 255)
-    y -= 255;
+  fletcher16_init(&ctx);
+  fletcher16_update(&ctx, (u8 *) lsa_n + 2, lsa_len - 2);
 
-  ((u8 *) & h->checksum)[0] = x;
-  ((u8 *) & h->checksum)[1] = y;
-  return h->checksum;
+  return fletcher16_compute(&ctx) == 0;
 }
 
+
 int
 lsa_comp(struct ospf_lsa_header *l1, struct ospf_lsa_header *l2)
 			/* Return codes from point of view of l1 */
diff --git a/proto/ospf/lsalib.h b/proto/ospf/lsalib.h
index 4ad770e8..ae6af044 100644
--- a/proto/ospf/lsalib.h
+++ b/proto/ospf/lsalib.h
@@ -46,9 +46,9 @@ static inline u32 lsa_get_etype(struct ospf_lsa_header *h, struct ospf_proto *p)
 
 
 int lsa_flooding_allowed(u32 type, u32 domain, struct ospf_iface *ifa);
+void lsa_generate_checksum(struct ospf_lsa_header *lsa, const u8 *body);
+u16 lsa_verify_checksum(const void *lsa_n, int lsa_len);
 
-void lsasum_calculate(struct ospf_lsa_header *header, void *body);
-u16 lsasum_check(struct ospf_lsa_header *h, void *body, int update);
 #define CMP_NEWER 1
 #define CMP_SAME 0
 #define CMP_OLDER -1
diff --git a/proto/ospf/lsupd.c b/proto/ospf/lsupd.c
index 6e7dce26..c6a734ca 100644
--- a/proto/ospf/lsupd.c
+++ b/proto/ospf/lsupd.c
@@ -530,8 +530,8 @@ ospf_receive_lsupd(struct ospf_packet *pkt, struct ospf_iface *ifa,
     DBG("Update Type: %04x, Id: %R, Rt: %R, Sn: 0x%08x, Age: %u, Sum: %u\n",
 	lsa_type, lsa.id, lsa.rt, lsa.sn, lsa.age, lsa.checksum);
 
-    /* RFC 2328 13. (1) - validate LSA checksum */
-    if ((lsa_n->checksum == 0) || (lsasum_check(lsa_n, NULL, 0) != 0))
+    /* RFC 2328 13. (1) - verify LSA checksum */
+    if ((lsa_n->checksum == 0) || !lsa_verify_checksum(lsa_n, lsa_len))
       SKIP("invalid checksum");
 
     /* RFC 2328 13. (2) */
diff --git a/proto/ospf/topology.c b/proto/ospf/topology.c
index 0613d34d..8119cfa6 100644
--- a/proto/ospf/topology.c
+++ b/proto/ospf/topology.c
@@ -129,7 +129,7 @@ ospf_advance_lsa(struct ospf_proto *p, struct top_hash_entry *en, struct ospf_ls
       en->lsa.age = 0;
       en->init_age = 0;
       en->inst_time = now;
-      lsasum_calculate(&en->lsa, en->lsa_body);
+      lsa_generate_checksum(&en->lsa, en->lsa_body);
 
       OSPF_TRACE(D_EVENTS, "Advancing LSA: Type: %04x, Id: %R, Rt: %R, Seq: %08x",
 		 en->lsa_type, en->lsa.id, en->lsa.rt, en->lsa.sn);
@@ -238,7 +238,7 @@ ospf_do_originate_lsa(struct ospf_proto *p, struct top_hash_entry *en, void *lsa
   en->lsa.age = 0;
   en->init_age = 0;
   en->inst_time = now;
-  lsasum_calculate(&en->lsa, en->lsa_body);
+  lsa_generate_checksum(&en->lsa, en->lsa_body);
 
   OSPF_TRACE(D_EVENTS, "Originating LSA: Type: %04x, Id: %R, Rt: %R, Seq: %08x",
 	     en->lsa_type, en->lsa.id, en->lsa.rt, en->lsa.sn);
@@ -382,7 +382,7 @@ ospf_refresh_lsa(struct ospf_proto *p, struct top_hash_entry *en)
   en->lsa.age = 0;
   en->init_age = 0;
   en->inst_time = now;
-  lsasum_calculate(&en->lsa, en->lsa_body);
+  lsa_generate_checksum(&en->lsa, en->lsa_body);
   ospf_flood_lsa(p, en, NULL);
 }
 

From 315f23a0470112ced04badbb117bc7854ee53e06 Mon Sep 17 00:00:00 2001
From: Ondrej Zajicek <santiago@crfreenet.org>
Date: Sat, 9 May 2015 18:50:15 +0200
Subject: [PATCH 002/165] Add bitfield route attribute type

---
 filter/filter.c | 82 ++++++++++++++++++++++++++++++++++---------------
 nest/route.h    |  5 ++-
 nest/rt-attr.c  | 29 +++++++++++++++++
 3 files changed, 90 insertions(+), 26 deletions(-)

diff --git a/filter/filter.c b/filter/filter.c
index a4f12330..3b14fc0c 100644
--- a/filter/filter.c
+++ b/filter/filter.c
@@ -462,7 +462,7 @@ static int f_flags;
 
 static inline void f_rte_cow(void)
 {
-  *f_rte = rte_cow(*f_rte); 
+  *f_rte = rte_cow(*f_rte);
 }
 
 /*
@@ -479,7 +479,7 @@ f_rta_cow(void)
     /* Store old rta to free it later */
     f_old_rta = (*f_rte)->attrs;
 
-    /* 
+    /*
      * Alloc new rta, do shallow copy and update rte. Fields eattrs
      * and nexthops of rta are shared with f_old_rta (they will be
      * copied when the cached rta will be obtained at the end of
@@ -516,6 +516,9 @@ static struct tbf rl_runtime_err = TBF_DEFAULT_LOG_LIMITS;
 #define ACCESS_RTE \
   do { if (!f_rte) runtime("No route to access"); } while (0)
 
+#define BITFIELD_MASK(what) \
+  (1u << (what->a2.i >> 24))
+
 /**
  * interpret
  * @what: filter to interpret
@@ -526,7 +529,7 @@ static struct tbf rl_runtime_err = TBF_DEFAULT_LOG_LIMITS;
  * Each instruction has 4 fields: code (which is instruction code),
  * aux (which is extension to instruction code, typically type),
  * arg1 and arg2 - arguments. Depending on instruction, arguments
- * are either integers, or pointers to instruction trees. Common 
+ * are either integers, or pointers to instruction trees. Common
  * instructions like +, that have two expressions as arguments use
  * TWOARGS macro to get both of them evaluated.
  *
@@ -585,7 +588,7 @@ interpret(struct f_inst *what)
     default: runtime( "Usage of unknown type" );
     }
     break;
-    
+
   case '&':
   case '|':
     ARG(v1, a1.p);
@@ -625,7 +628,7 @@ interpret(struct f_inst *what)
 
       if (v1.type == T_INT) {
 	ipv4_used = 0; key = v1.val.i;
-      } 
+      }
       else if (v1.type == T_QUAD) {
 	ipv4_used = 1; key = v1.val.i;
       }
@@ -724,7 +727,7 @@ interpret(struct f_inst *what)
 #endif
       runtime( "Assigning to variable of incompatible type" );
     }
-    *vp = v2; 
+    *vp = v2;
     break;
 
     /* some constants have value in a2, some in *a1.p, strange. */
@@ -864,12 +867,14 @@ interpret(struct f_inst *what)
     ACCESS_RTE;
     {
       eattr *e = NULL;
+      u16 code = what->a2.i;
+
       if (!(f_flags & FF_FORCE_TMPATTR))
-	e = ea_find( (*f_rte)->attrs->eattrs, what->a2.i );
-      if (!e) 
-	e = ea_find( (*f_tmp_attrs), what->a2.i );
+	e = ea_find((*f_rte)->attrs->eattrs, code);
+      if (!e)
+	e = ea_find((*f_tmp_attrs), code);
       if ((!e) && (f_flags & FF_FORCE_TMPATTR))
-	e = ea_find( (*f_rte)->attrs->eattrs, what->a2.i );
+	e = ea_find((*f_rte)->attrs->eattrs, code);
 
       if (!e) {
 	/* A special case: undefined int_set looks like empty int_set */
@@ -878,8 +883,9 @@ interpret(struct f_inst *what)
 	  res.val.ad = adata_empty(f_pool, 0);
 	  break;
 	}
+
 	/* The same special case for ec_set */
-	else if ((what->aux & EAF_TYPE_MASK) == EAF_TYPE_EC_SET) {
+	if ((what->aux & EAF_TYPE_MASK) == EAF_TYPE_EC_SET) {
 	  res.type = T_ECLIST;
 	  res.val.ad = adata_empty(f_pool, 0);
 	  break;
@@ -912,6 +918,10 @@ interpret(struct f_inst *what)
         res.type = T_PATH;
 	res.val.ad = e->u.ptr;
 	break;
+      case EAF_TYPE_BITFIELD:
+	res.type = T_BOOL;
+	res.val.i = !!(e->u.data & BITFIELD_MASK(what));
+	break;
       case EAF_TYPE_INT_SET:
 	res.type = T_CLIST;
 	res.val.ad = e->u.ptr;
@@ -933,13 +943,15 @@ interpret(struct f_inst *what)
     ONEARG;
     {
       struct ea_list *l = lp_alloc(f_pool, sizeof(struct ea_list) + sizeof(eattr));
+      u16 code = what->a2.i;
 
       l->next = NULL;
       l->flags = EALF_SORTED;
       l->count = 1;
-      l->attrs[0].id = what->a2.i;
+      l->attrs[0].id = code;
       l->attrs[0].flags = 0;
       l->attrs[0].type = what->aux | EAF_ORIGINATED;
+
       switch (what->aux & EAF_TYPE_MASK) {
       case EAF_TYPE_INT:
 	if (v1.type != T_INT)
@@ -978,6 +990,26 @@ interpret(struct f_inst *what)
 	  runtime( "Setting path attribute to non-path value" );
 	l->attrs[0].u.ptr = v1.val.ad;
 	break;
+      case EAF_TYPE_BITFIELD:
+	if (v1.type != T_BOOL)
+	  runtime( "Setting bit in bitfield attribute to non-bool value" );
+	{
+	  /* First, we have to find the old value */
+	  eattr *e = NULL;
+	  if (!(f_flags & FF_FORCE_TMPATTR))
+	    e = ea_find((*f_rte)->attrs->eattrs, code);
+	  if (!e)
+	    e = ea_find((*f_tmp_attrs), code);
+	  if ((!e) && (f_flags & FF_FORCE_TMPATTR))
+	    e = ea_find((*f_rte)->attrs->eattrs, code);
+	  u32 data = e ? e->u.data : 0;
+
+	  if (v1.val.i)
+	    l->attrs[0].u.data = data | BITFIELD_MASK(what);
+	  else
+	    l->attrs[0].u.data = data & ~BITFIELD_MASK(what);;
+	}
+	break;
       case EAF_TYPE_INT_SET:
 	if (v1.type != T_CLIST)
 	  runtime( "Setting clist attribute to non-clist value" );
@@ -1073,7 +1105,7 @@ interpret(struct f_inst *what)
     res = interpret(what->a2.p);
     if (res.type == T_RETURN)
       return res;
-    res.type &= ~T_RETURN;    
+    res.type &= ~T_RETURN;
     break;
   case P('c','v'):	/* Clear local variables */
     for (sym = what->a1.p; sym != NULL; sym = sym->aux2)
@@ -1090,7 +1122,7 @@ interpret(struct f_inst *what)
 	  debug( "No else statement?\n");
 	  break;
 	}
-      }	
+      }
       /* It is actually possible to have t->data NULL */
 
       res = interpret(t->data);
@@ -1184,10 +1216,10 @@ interpret(struct f_inst *what)
 	  runtime("Can't add set");
 	else if (!arg_set)
 	  res.val.ad = int_set_add(f_pool, v1.val.ad, n);
-	else 
+	else
 	  res.val.ad = int_set_union(f_pool, v1.val.ad, v2.val.ad);
 	break;
-      
+
       case 'd':
 	if (!arg_set)
 	  res.val.ad = int_set_del(f_pool, v1.val.ad, n);
@@ -1209,7 +1241,7 @@ interpret(struct f_inst *what)
     {
       /* Extended community list */
       int arg_set = 0;
-      
+
       /* v2.val is either EC or EC-set */
       if ((v2.type == T_SET) && eclist_set_type(v2.val.t))
 	arg_set = 1;
@@ -1226,10 +1258,10 @@ interpret(struct f_inst *what)
 	  runtime("Can't add set");
 	else if (!arg_set)
 	  res.val.ad = ec_set_add(f_pool, v1.val.ad, v2.val.ec);
-	else 
+	else
 	  res.val.ad = ec_set_union(f_pool, v1.val.ad, v2.val.ad);
 	break;
-      
+
       case 'd':
 	if (!arg_set)
 	  res.val.ad = ec_set_del(f_pool, v1.val.ad, v2.val.ec);
@@ -1353,7 +1385,7 @@ i_same(struct f_inst *f1, struct f_inst *f2)
     }
     break;
 
-  case 'c': 
+  case 'c':
     switch (f1->aux) {
 
     case T_PREFIX_SET:
@@ -1381,7 +1413,7 @@ i_same(struct f_inst *f1, struct f_inst *f2)
       return 0;
     break;
 
-  case 'V': 
+  case 'V':
     if (strcmp((char *) f1->a2.p, (char *) f2->a2.p))
       return 0;
     break;
@@ -1399,12 +1431,12 @@ i_same(struct f_inst *f1, struct f_inst *f2)
   case 'r': ONEARG; break;
   case P('c','p'): ONEARG; break;
   case P('c','a'): /* Call rewriting trickery to avoid exponential behaviour */
-             ONEARG; 
+             ONEARG;
 	     if (!i_same(f1->a2.p, f2->a2.p))
-	       return 0; 
+	       return 0;
 	     f2->a2.p = f1->a2.p;
 	     break;
-  case P('c','v'): break; /* internal instruction */ 
+  case P('c','v'): break; /* internal instruction */
   case P('S','W'): ONEARG; if (!same_tree(f1->a2.p, f2->a2.p)) return 0; break;
   case P('i','M'): TWOARGS; break;
   case P('A','p'): TWOARGS; break;
@@ -1414,7 +1446,7 @@ i_same(struct f_inst *f1, struct f_inst *f2)
   case P('R','C'):
     TWOARGS;
     /* Does not really make sense - ROA check resuls may change anyway */
-    if (strcmp(((struct f_inst_roa_check *) f1)->rtc->name, 
+    if (strcmp(((struct f_inst_roa_check *) f1)->rtc->name,
 	       ((struct f_inst_roa_check *) f2)->rtc->name))
       return 0;
     break;
diff --git a/nest/route.h b/nest/route.h
index 5ee04a30..fccc571b 100644
--- a/nest/route.h
+++ b/nest/route.h
@@ -417,13 +417,15 @@ typedef struct eattr {
 
 #define EA_CODE_MASK 0xffff
 #define EA_ALLOW_UNDEF 0x10000		/* ea_find: allow EAF_TYPE_UNDEF */
+#define EA_BIT(n) ((n) << 24)		/* Used in bitfield accessors */
 
 #define EAF_TYPE_MASK 0x0f		/* Mask with this to get type */
-#define EAF_TYPE_INT 0x01		/* 32-bit signed integer number */
+#define EAF_TYPE_INT 0x01		/* 32-bit unsigned integer number */
 #define EAF_TYPE_OPAQUE 0x02		/* Opaque byte string (not filterable) */
 #define EAF_TYPE_IP_ADDRESS 0x04	/* IP address */
 #define EAF_TYPE_ROUTER_ID 0x05		/* Router ID (IPv4 address) */
 #define EAF_TYPE_AS_PATH 0x06		/* BGP AS path (encoding per RFC 1771:4.3) */
+#define EAF_TYPE_BITFIELD 0x09		/* 32-bit embedded bitfield */
 #define EAF_TYPE_INT_SET 0x0a		/* Set of u32's (e.g., a community list) */
 #define EAF_TYPE_EC_SET 0x0e		/* Set of pairs of u32's - ext. community list */
 #define EAF_TYPE_UNDEF 0x0f		/* `force undefined' entry */
@@ -469,6 +471,7 @@ void ea_merge(ea_list *from, ea_list *to); /* Merge sub-lists to allocated buffe
 int ea_same(ea_list *x, ea_list *y);	/* Test whether two ea_lists are identical */
 unsigned int ea_hash(ea_list *e);	/* Calculate 16-bit hash value */
 ea_list *ea_append(ea_list *to, ea_list *what);
+void ea_format_bitfield(struct eattr *a, byte *buf, int bufsize, const char **names, int min, int max);
 
 int mpnh__same(struct mpnh *x, struct mpnh *y); /* Compare multipath nexthops */
 static inline int mpnh_same(struct mpnh *x, struct mpnh *y)
diff --git a/nest/rt-attr.c b/nest/rt-attr.c
index 09691bf1..938b2b44 100644
--- a/nest/rt-attr.c
+++ b/nest/rt-attr.c
@@ -563,6 +563,32 @@ get_generic_attr(eattr *a, byte **buf, int buflen UNUSED)
   return GA_UNKNOWN;
 }
 
+void
+ea_format_bitfield(struct eattr *a, byte *buf, int bufsize, const char **names, int min, int max)
+{
+  byte *bound = buf + bufsize - 32;
+  u32 data = a->u.data;
+  int i;
+
+  for (i = min; i < max; i++)
+    if ((data & (1u << i)) && names[i])
+    {
+      if (buf > bound)
+      {
+	strcpy(buf, " ...");
+	return;
+      }
+
+      buf += bsprintf(buf, " %s", names[i]);
+      data &= ~(1u << i);
+    }
+
+  if (data)
+    bsprintf(buf, " %08x", data);
+
+  return;
+}
+
 static inline void
 opaque_format(struct adata *ad, byte *buf, unsigned int size)
 {
@@ -665,6 +691,9 @@ ea_show(struct cli *c, eattr *e)
 	case EAF_TYPE_AS_PATH:
 	  as_path_format(ad, pos, end - pos);
 	  break;
+	case EAF_TYPE_BITFIELD:
+	  bsprintf(pos, "%08x", e->u.data);
+	  break;
 	case EAF_TYPE_INT_SET:
 	  ea_show_int_set(c, ad, 1, pos, buf, end);
 	  return;

From 9fdf9d29b6b570205c36934aab7e50539e042102 Mon Sep 17 00:00:00 2001
From: Ondrej Zajicek <santiago@crfreenet.org>
Date: Tue, 12 May 2015 16:42:22 +0200
Subject: [PATCH 003/165] KRT: Add support for plenty of kernel route metrics

Linux kernel route metrics (RTA_METRICS netlink route attribute) are
represented and accessible as new route attributes:

krt_mtu, krt_window, krt_rtt, krt_rttvar, krt_sstresh, krt_cwnd, krt_advmss,
krt_reordering, krt_hoplimit, krt_initcwnd, krt_rto_min, krt_initrwnd,
krt_quickack, krt_lock_mtu, krt_lock_window, krt_lock_rtt, krt_lock_rttvar,
krt_lock_sstresh, krt_lock_cwnd, krt_lock_advmss, krt_lock_reordering,
krt_lock_hoplimit, krt_lock_rto_min, krt_feature_ecn, krt_feature_allfrag
---
 doc/bird.sgml          |   2 +-
 nest/route.h           |   6 ++
 nest/rt-attr.c         |  76 +++++++++++++
 sysdep/bsd/krt-sys.h   |   2 +
 sysdep/linux/krt-sys.h |  53 ++++++++++
 sysdep/linux/netlink.Y |  40 ++++++-
 sysdep/linux/netlink.c | 235 ++++++++++++++++++++++++++++++++---------
 sysdep/unix/krt.c      |  12 +--
 sysdep/unix/krt.h      |   3 +-
 9 files changed, 366 insertions(+), 63 deletions(-)

diff --git a/doc/bird.sgml b/doc/bird.sgml
index fc5fc9ae..1c2dda4b 100644
--- a/doc/bird.sgml
+++ b/doc/bird.sgml
@@ -2248,7 +2248,7 @@ these attributes:
 
 	<tag>ip <cf/krt_prefsrc/</tag> (Linux)
 	The preferred source address. Used in source address selection for
- 	outgoing packets. Have to be one of IP addresses of the router.
+ 	outgoing packets. Has to be one of the IP addresses of the router.
 
 	<tag>int <cf/krt_realm/</tag> (Linux)
 	The realm of the route. Can be used for traffic classification.
diff --git a/nest/route.h b/nest/route.h
index fccc571b..87f10ae3 100644
--- a/nest/route.h
+++ b/nest/route.h
@@ -461,8 +461,14 @@ static inline void rt_lock_source(struct rte_src *src) { src->uc++; }
 static inline void rt_unlock_source(struct rte_src *src) { src->uc--; }
 void rt_prune_sources(void);
 
+struct ea_walk_state {
+  ea_list *eattrs;			/* Ccurrent ea_list, initially set by caller */
+  eattr *ea;				/* Current eattr, initially NULL */
+  u32 visited[4];			/* Bitfield, limiting max to 128 */
+};
 
 eattr *ea_find(ea_list *, unsigned ea);
+eattr *ea_walk(struct ea_walk_state *s, uint id, uint max);
 int ea_get_int(ea_list *, unsigned ea, int def);
 void ea_dump(ea_list *);
 void ea_sort(ea_list *);		/* Sort entries in all sub-lists */
diff --git a/nest/rt-attr.c b/nest/rt-attr.c
index 938b2b44..c5537208 100644
--- a/nest/rt-attr.c
+++ b/nest/rt-attr.c
@@ -307,6 +307,82 @@ ea_find(ea_list *e, unsigned id)
   return a;
 }
 
+/**
+ * ea_walk - walk through extended attributes
+ * @s: walk state structure
+ * @id: start of attribute ID interval
+ * @max: length of attribute ID interval
+ *
+ * Given an extended attribute list, ea_walk() walks through the list looking
+ * for first occurrences of attributes with ID in specified interval from @id to
+ * (@id + @max - 1), returning pointers to found &eattr structures, storing its
+ * walk state in @s for subsequent calls.
+
+ * The function ea_walk() is supposed to be called in a loop, with initially
+ * zeroed walk state structure @s with filled the initial extended attribute
+ * list, returning one found attribute in each call or %NULL when no other
+ * attribute exists. The extended attribute list or the arguments should not be
+ * modified between calls. The maximum value of @max is 128.
+ */
+eattr *
+ea_walk(struct ea_walk_state *s, uint id, uint max)
+{
+  ea_list *e = s->eattrs;
+  eattr *a = s->ea;
+  eattr *a_max;
+
+  max = id + max;
+
+  if (a)
+    goto step;
+
+  for (; e; e = e->next)
+  {
+    if (e->flags & EALF_BISECT)
+    {
+      int l, r, m;
+
+      l = 0;
+      r = e->count - 1;
+      while (l < r)
+      {
+	m = (l+r) / 2;
+	if (e->attrs[m].id < id)
+	  l = m + 1;
+	else
+	  r = m;
+      }
+      a = e->attrs + l;
+    }
+    else
+      a = e->attrs;
+
+  step:
+    a_max = e->attrs + e->count;
+    for (; a < a_max; a++)
+      if ((a->id >= id) && (a->id < max))
+      {
+	int n = a->id - id;
+
+	if (BIT32_TEST(s->visited, n))
+	  continue;
+
+	BIT32_SET(s->visited, n);
+
+	if ((a->type & EAF_TYPE_MASK) == EAF_TYPE_UNDEF)
+	  continue;
+
+	s->eattrs = e;
+	s->ea = a;
+	return a;
+      }
+      else if (e->flags & EALF_BISECT)
+	break;
+  }
+
+  return NULL;
+}
+
 /**
  * ea_get_int - fetch an integer attribute
  * @e: attribute list
diff --git a/sysdep/bsd/krt-sys.h b/sysdep/bsd/krt-sys.h
index 9c0d4972..2c6e35c5 100644
--- a/sysdep/bsd/krt-sys.h
+++ b/sysdep/bsd/krt-sys.h
@@ -44,5 +44,7 @@ struct krt_state {
 
 static inline void krt_sys_init(struct krt_proto *p UNUSED) { }
 
+static inline int krt_sys_get_attr(eattr *a UNUSED, byte *buf UNUSED, int buflen UNUSED) { }
+
 
 #endif
diff --git a/sysdep/linux/krt-sys.h b/sysdep/linux/krt-sys.h
index 7e97968a..e32e4fe1 100644
--- a/sysdep/linux/krt-sys.h
+++ b/sysdep/linux/krt-sys.h
@@ -32,6 +32,59 @@ static inline struct ifa * kif_get_primary_ip(struct iface *i) { return NULL; }
 
 /* Kernel routes */
 
+#define EA_KRT_PREFSRC		EA_CODE(EAP_KRT, 0x10)
+#define EA_KRT_REALM		EA_CODE(EAP_KRT, 0x11)
+
+
+#define KRT_METRICS_MAX		0x10	/* RTAX_QUICKACK+1 */
+#define KRT_METRICS_OFFSET	0x20	/* Offset of EA_KRT_* vs RTAX_* */
+
+#define KRT_FEATURES_MAX	4
+
+/*
+ * Following attributes are parts of RTA_METRICS kernel route attribute, their
+ * ids must be consistent with their RTAX_* constants (+ KRT_METRICS_OFFSET)
+ */
+#define EA_KRT_METRICS		EA_CODE(EAP_KRT, 0x20)	/* Dummy one */
+#define EA_KRT_LOCK		EA_CODE(EAP_KRT, 0x21)
+#define EA_KRT_MTU		EA_CODE(EAP_KRT, 0x22)
+#define EA_KRT_WINDOW		EA_CODE(EAP_KRT, 0x23)
+#define EA_KRT_RTT		EA_CODE(EAP_KRT, 0x24)
+#define EA_KRT_RTTVAR		EA_CODE(EAP_KRT, 0x25)
+#define EA_KRT_SSTRESH		EA_CODE(EAP_KRT, 0x26)
+#define EA_KRT_CWND		EA_CODE(EAP_KRT, 0x27)
+#define EA_KRT_ADVMSS		EA_CODE(EAP_KRT, 0x28)
+#define EA_KRT_REORDERING 	EA_CODE(EAP_KRT, 0x29)
+#define EA_KRT_HOPLIMIT		EA_CODE(EAP_KRT, 0x2a)
+#define EA_KRT_INITCWND		EA_CODE(EAP_KRT, 0x2b)
+#define EA_KRT_FEATURES		EA_CODE(EAP_KRT, 0x2c)
+#define EA_KRT_RTO_MIN		EA_CODE(EAP_KRT, 0x2d)
+#define EA_KRT_INITRWND		EA_CODE(EAP_KRT, 0x2e)
+#define EA_KRT_QUICKACK		EA_CODE(EAP_KRT, 0x2f)
+
+/* Bits of EA_KRT_LOCK, also based on RTAX_* constants */
+#define EA_KRT_LOCK_MTU		EA_KRT_LOCK | EA_BIT(0x2)
+#define EA_KRT_LOCK_WINDOW	EA_KRT_LOCK | EA_BIT(0x3)
+#define EA_KRT_LOCK_RTT		EA_KRT_LOCK | EA_BIT(0x4)
+#define EA_KRT_LOCK_RTTVAR	EA_KRT_LOCK | EA_BIT(0x5)
+#define EA_KRT_LOCK_SSTHRESH	EA_KRT_LOCK | EA_BIT(0x6)
+#define EA_KRT_LOCK_CWND	EA_KRT_LOCK | EA_BIT(0x7)
+#define EA_KRT_LOCK_ADVMSS	EA_KRT_LOCK | EA_BIT(0x8)
+#define EA_KRT_LOCK_REORDERING 	EA_KRT_LOCK | EA_BIT(0x9)
+#define EA_KRT_LOCK_HOPLIMIT	EA_KRT_LOCK | EA_BIT(0xa)
+// define EA_KRT_LOCK_INITCWND	EA_KRT_LOCK | EA_BIT(0xb)
+// define EA_KRT_LOCK_FEATURES	EA_KRT_LOCK | EA_BIT(0xc)
+#define EA_KRT_LOCK_RTO_MIN	EA_KRT_LOCK | EA_BIT(0xd)
+// define EA_KRT_LOCK_INITRWND	EA_KRT_LOCK | EA_BIT(0xe)
+
+/* Bits of EA_KRT_FEATURES, based on RTAX_FEATURE_* constants */
+#define EA_KRT_FEATURE_ECN	EA_KRT_FEATURES | EA_BIT(0x0)
+// define EA_KRT_FEATURE_SACK	EA_KRT_FEATURES | EA_BIT(0x1)
+// define EA_KRT_FEATURE_TSTAMP	EA_KRT_FEATURES | EA_BIT(0x2)
+#define EA_KRT_FEATURE_ALLFRAG	EA_KRT_FEATURES | EA_BIT(0x3)
+
+
+
 #define NL_NUM_TABLES 256
 
 struct krt_params {
diff --git a/sysdep/linux/netlink.Y b/sysdep/linux/netlink.Y
index b0e35151..f8137e23 100644
--- a/sysdep/linux/netlink.Y
+++ b/sysdep/linux/netlink.Y
@@ -10,7 +10,12 @@ CF_HDR
 
 CF_DECLS
 
-CF_KEYWORDS(KERNEL, TABLE, KRT_PREFSRC, KRT_REALM)
+CF_KEYWORDS(KERNEL, TABLE, KRT_PREFSRC, KRT_REALM, KRT_MTU, KRT_WINDOW, KRT_RTT,
+	    KRT_RTTVAR, KRT_SSTRESH, KRT_CWND, KRT_ADVMSS, KRT_REORDERING,
+	    KRT_HOPLIMIT, KRT_INITCWND, KRT_RTO_MIN, KRT_INITRWND, KRT_QUICKACK,
+	    KRT_LOCK_MTU, KRT_LOCK_WINDOW, KRT_LOCK_RTT, KRT_LOCK_RTTVAR,
+	    KRT_LOCK_SSTRESH, KRT_LOCK_CWND, KRT_LOCK_ADVMSS, KRT_LOCK_REORDERING,
+	    KRT_LOCK_HOPLIMIT, KRT_LOCK_RTO_MIN, KRT_FEATURE_ECN, KRT_FEATURE_ALLFRAG)
 
 CF_GRAMMAR
 
@@ -24,8 +29,37 @@ kern_sys_item:
    }
  ;
 
-CF_ADDTO(dynamic_attr, KRT_PREFSRC { $$ = f_new_dynamic_attr(EAF_TYPE_IP_ADDRESS, T_IP, EA_KRT_PREFSRC); })
-CF_ADDTO(dynamic_attr, KRT_REALM { $$ = f_new_dynamic_attr(EAF_TYPE_INT, T_INT, EA_KRT_REALM); })
+CF_ADDTO(dynamic_attr, KRT_PREFSRC	{ $$ = f_new_dynamic_attr(EAF_TYPE_IP_ADDRESS, T_IP, EA_KRT_PREFSRC); })
+CF_ADDTO(dynamic_attr, KRT_REALM	{ $$ = f_new_dynamic_attr(EAF_TYPE_INT, T_INT, EA_KRT_REALM); })
+
+CF_ADDTO(dynamic_attr, KRT_MTU		{ $$ = f_new_dynamic_attr(EAF_TYPE_INT, T_INT, EA_KRT_MTU); })
+CF_ADDTO(dynamic_attr, KRT_WINDOW	{ $$ = f_new_dynamic_attr(EAF_TYPE_INT, T_INT, EA_KRT_WINDOW); })
+CF_ADDTO(dynamic_attr, KRT_RTT		{ $$ = f_new_dynamic_attr(EAF_TYPE_INT, T_INT, EA_KRT_RTT); })
+CF_ADDTO(dynamic_attr, KRT_RTTVAR	{ $$ = f_new_dynamic_attr(EAF_TYPE_INT, T_INT, EA_KRT_RTTVAR); })
+CF_ADDTO(dynamic_attr, KRT_SSTRESH	{ $$ = f_new_dynamic_attr(EAF_TYPE_INT, T_INT, EA_KRT_SSTRESH); })
+CF_ADDTO(dynamic_attr, KRT_CWND		{ $$ = f_new_dynamic_attr(EAF_TYPE_INT, T_INT, EA_KRT_CWND); })
+CF_ADDTO(dynamic_attr, KRT_ADVMSS	{ $$ = f_new_dynamic_attr(EAF_TYPE_INT, T_INT, EA_KRT_ADVMSS); })
+CF_ADDTO(dynamic_attr, KRT_REORDERING	{ $$ = f_new_dynamic_attr(EAF_TYPE_INT, T_INT, EA_KRT_REORDERING); })
+CF_ADDTO(dynamic_attr, KRT_HOPLIMIT	{ $$ = f_new_dynamic_attr(EAF_TYPE_INT, T_INT, EA_KRT_HOPLIMIT); })
+CF_ADDTO(dynamic_attr, KRT_INITCWND	{ $$ = f_new_dynamic_attr(EAF_TYPE_INT, T_INT, EA_KRT_INITCWND); })
+CF_ADDTO(dynamic_attr, KRT_RTO_MIN	{ $$ = f_new_dynamic_attr(EAF_TYPE_INT, T_INT, EA_KRT_RTO_MIN); })
+CF_ADDTO(dynamic_attr, KRT_INITRWND	{ $$ = f_new_dynamic_attr(EAF_TYPE_INT, T_INT, EA_KRT_INITRWND); })
+CF_ADDTO(dynamic_attr, KRT_QUICKACK	{ $$ = f_new_dynamic_attr(EAF_TYPE_INT, T_INT, EA_KRT_QUICKACK); })
+
+CF_ADDTO(dynamic_attr, KRT_LOCK_MTU	{ $$ = f_new_dynamic_attr(EAF_TYPE_BITFIELD, T_BOOL, EA_KRT_LOCK_MTU); })
+CF_ADDTO(dynamic_attr, KRT_LOCK_WINDOW	{ $$ = f_new_dynamic_attr(EAF_TYPE_BITFIELD, T_BOOL, EA_KRT_LOCK_WINDOW); })
+CF_ADDTO(dynamic_attr, KRT_LOCK_RTT	{ $$ = f_new_dynamic_attr(EAF_TYPE_BITFIELD, T_BOOL, EA_KRT_LOCK_RTT); })
+CF_ADDTO(dynamic_attr, KRT_LOCK_RTTVAR	{ $$ = f_new_dynamic_attr(EAF_TYPE_BITFIELD, T_BOOL, EA_KRT_LOCK_RTTVAR); })
+CF_ADDTO(dynamic_attr, KRT_LOCK_SSTRESH	{ $$ = f_new_dynamic_attr(EAF_TYPE_BITFIELD, T_BOOL, EA_KRT_LOCK_SSTHRESH); })
+CF_ADDTO(dynamic_attr, KRT_LOCK_CWND	{ $$ = f_new_dynamic_attr(EAF_TYPE_BITFIELD, T_BOOL, EA_KRT_LOCK_CWND); })
+CF_ADDTO(dynamic_attr, KRT_LOCK_ADVMSS	{ $$ = f_new_dynamic_attr(EAF_TYPE_BITFIELD, T_BOOL, EA_KRT_LOCK_ADVMSS); })
+CF_ADDTO(dynamic_attr, KRT_LOCK_REORDERING { $$ = f_new_dynamic_attr(EAF_TYPE_BITFIELD, T_BOOL, EA_KRT_LOCK_REORDERING); })
+CF_ADDTO(dynamic_attr, KRT_LOCK_HOPLIMIT { $$ = f_new_dynamic_attr(EAF_TYPE_BITFIELD, T_BOOL, EA_KRT_LOCK_HOPLIMIT); })
+CF_ADDTO(dynamic_attr, KRT_LOCK_RTO_MIN { $$ = f_new_dynamic_attr(EAF_TYPE_BITFIELD, T_BOOL, EA_KRT_LOCK_RTO_MIN); })
+
+CF_ADDTO(dynamic_attr, KRT_FEATURE_ECN	{ $$ = f_new_dynamic_attr(EAF_TYPE_BITFIELD, T_BOOL, EA_KRT_FEATURE_ECN); })
+CF_ADDTO(dynamic_attr, KRT_FEATURE_ALLFRAG { $$ = f_new_dynamic_attr(EAF_TYPE_BITFIELD, T_BOOL, EA_KRT_FEATURE_ALLFRAG); })
+
 
 CF_CODE
 
diff --git a/sysdep/linux/netlink.c b/sysdep/linux/netlink.c
index 48dd8bab..72837ce0 100644
--- a/sysdep/linux/netlink.c
+++ b/sysdep/linux/netlink.c
@@ -238,21 +238,24 @@ nl_parse_attrs(struct rtattr *a, struct rtattr **k, int ksize)
     return 1;
 }
 
-void
-nl_add_attr(struct nlmsghdr *h, unsigned bufsize, unsigned code,
-	    void *data, unsigned dlen)
+struct rtattr *
+nl_add_attr(struct nlmsghdr *h, uint bufsize, uint code, const void *data, uint dlen)
 {
-  unsigned len = RTA_LENGTH(dlen);
-  unsigned pos = NLMSG_ALIGN(h->nlmsg_len);
-  struct rtattr *a;
+  uint pos = NLMSG_ALIGN(h->nlmsg_len);
+  uint len = RTA_LENGTH(dlen);
 
   if (pos + len > bufsize)
     bug("nl_add_attr: packet buffer overflow");
-  a = (struct rtattr *)((char *)h + pos);
+
+  struct rtattr *a = (struct rtattr *)((char *)h + pos);
   a->rta_type = code;
   a->rta_len = len;
   h->nlmsg_len = pos + len;
-  memcpy(RTA_DATA(a), data, dlen);
+
+  if (dlen > 0)
+    memcpy(RTA_DATA(a), data, dlen);
+
+  return a;
 }
 
 static inline void
@@ -268,48 +271,58 @@ nl_add_attr_ipa(struct nlmsghdr *h, unsigned bufsize, int code, ip_addr ipa)
   nl_add_attr(h, bufsize, code, &ipa, sizeof(ipa));
 }
 
-#define RTNH_SIZE (sizeof(struct rtnexthop) + sizeof(struct rtattr) + sizeof(ip_addr))
+static inline struct rtattr *
+nl_open_attr(struct nlmsghdr *h, uint bufsize, uint code)
+{
+  return nl_add_attr(h, bufsize, code, NULL, 0);
+}
 
 static inline void
-add_mpnexthop(char *buf, ip_addr ipa, unsigned iface, unsigned char weight)
+nl_close_attr(struct nlmsghdr *h, struct rtattr *a)
 {
-  struct rtnexthop *nh = (void *) buf;
-  struct rtattr *rt = (void *) (buf + sizeof(*nh));
-  nh->rtnh_len = RTNH_SIZE;
-  nh->rtnh_flags = 0;
-  nh->rtnh_hops = weight;
-  nh->rtnh_ifindex = iface;
-  rt->rta_len = sizeof(*rt) + sizeof(ipa);
-  rt->rta_type = RTA_GATEWAY;
-  ipa_hton(ipa);
-  memcpy(buf + sizeof(*nh) + sizeof(*rt), &ipa, sizeof(ipa));
+  a->rta_len = (void *)h + NLMSG_ALIGN(h->nlmsg_len) - (void *)a;
 }
 
+static inline struct rtnexthop *
+nl_open_nexthop(struct nlmsghdr *h, uint bufsize)
+{
+  uint pos = NLMSG_ALIGN(h->nlmsg_len);
+  uint len = RTNH_LENGTH(0);
+
+  if (pos + len > bufsize)
+    bug("nl_open_nexthop: packet buffer overflow");
+
+  h->nlmsg_len = pos + len;
+
+  return (void *)h + pos;
+}
+
+static inline void
+nl_close_nexthop(struct nlmsghdr *h, struct rtnexthop *nh)
+{
+  nh->rtnh_len = (void *)h + NLMSG_ALIGN(h->nlmsg_len) - (void *)nh;
+}
 
 static void
 nl_add_multipath(struct nlmsghdr *h, unsigned bufsize, struct mpnh *nh)
 {
-  unsigned len = sizeof(struct rtattr);
-  unsigned pos = NLMSG_ALIGN(h->nlmsg_len);
-  char *buf = (char *)h + pos;
-  struct rtattr *rt = (void *) buf;
-  buf += len;
-  
+  struct rtattr *a = nl_open_attr(h, bufsize, RTA_MULTIPATH);
+
   for (; nh; nh = nh->next)
-    {
-      len += RTNH_SIZE;
-      if (pos + len > bufsize)
-	bug("nl_add_multipath: packet buffer overflow");
+  {
+    struct rtnexthop *rtnh = nl_open_nexthop(h, bufsize);
 
-      add_mpnexthop(buf, nh->gw, nh->iface->index, nh->weight);
-      buf += RTNH_SIZE;
-    }
+    rtnh->rtnh_flags = 0;
+    rtnh->rtnh_hops = nh->weight;
+    rtnh->rtnh_ifindex = nh->iface->index;
 
-  rt->rta_type = RTA_MULTIPATH;
-  rt->rta_len = len;
-  h->nlmsg_len = pos + len;
-}
+    nl_add_attr_u32(h, bufsize, RTA_GATEWAY, nh->gw);
 
+    nl_close_nexthop(h, rtnh);
+  }
+
+  nl_close_attr(h, a);
+}
 
 static struct mpnh *
 nl_parse_multipath(struct krt_proto *p, struct rtattr *ra)
@@ -374,6 +387,47 @@ nl_parse_multipath(struct krt_proto *p, struct rtattr *ra)
   return first;
 }
 
+static void
+nl_add_metrics(struct nlmsghdr *h, uint bufsize, u32 *metrics, int max)
+{
+  struct rtattr *a = nl_open_attr(h, bufsize, RTA_METRICS);
+  int t;
+
+  for (t = 1; t < max; t++)
+    if (metrics[0] & (1 << t))
+      nl_add_attr_u32(h, bufsize, t, metrics[t]);
+
+  nl_close_attr(h, a);
+}
+
+static int
+nl_parse_metrics(struct rtattr *hdr, u32 *metrics, int max)
+{
+  struct rtattr *a = RTA_DATA(hdr);
+  int len = RTA_PAYLOAD(hdr);
+
+  metrics[0] = 0;
+  for (; RTA_OK(a, len); a = RTA_NEXT(a, len))
+  {
+    if (a->rta_type == RTA_UNSPEC)
+      continue;
+
+    if (a->rta_type >= max)
+      continue;
+
+    if (RTA_PAYLOAD(a) != 4)
+      return -1;
+
+    metrics[0] |= 1 << a->rta_type;
+    metrics[a->rta_type] = *(u32 *)RTA_DATA(a);
+  }
+
+  if (len > 0)
+    return -1;
+
+  return 0;
+}
+
 
 /*
  *	Scanning of interfaces
@@ -617,7 +671,7 @@ nh_bufsize(struct mpnh *nh)
 {
   int rv = 0;
   for (; nh != NULL; nh = nh->next)
-    rv += RTNH_SIZE;
+    rv += RTNH_LENGTH(RTA_LENGTH(sizeof(ip_addr)));
   return rv;
 }
 
@@ -630,7 +684,7 @@ nl_send_route(struct krt_proto *p, rte *e, struct ea_list *eattrs, int new)
   struct {
     struct nlmsghdr h;
     struct rtmsg r;
-    char buf[128 + nh_bufsize(a->nexthops)];
+    char buf[128 + KRT_METRICS_MAX*8 + nh_bufsize(a->nexthops)];
   } r;
 
   DBG("nl_send_route(%I/%d,new=%d)\n", net->n.prefix, net->n.pxlen, new);
@@ -649,13 +703,8 @@ nl_send_route(struct krt_proto *p, rte *e, struct ea_list *eattrs, int new)
   r.r.rtm_scope = RT_SCOPE_UNIVERSE;
   nl_add_attr_ipa(&r.h, sizeof(r), RTA_DST, net->n.prefix);
 
-  u32 metric = 0;
-  if (new && e->attrs->source == RTS_INHERIT)
-    metric = e->u.krt.metric;
   if (ea = ea_find(eattrs, EA_KRT_METRIC))
-    metric = ea->u.data;
-  if (metric != 0)
-    nl_add_attr_u32(&r.h, sizeof(r), RTA_PRIORITY, metric);
+    nl_add_attr_u32(&r.h, sizeof(r), RTA_PRIORITY, ea->u.data);
 
   if (ea = ea_find(eattrs, EA_KRT_PREFSRC))
     nl_add_attr_ipa(&r.h, sizeof(r), RTA_PREFSRC, *(ip_addr *)ea->u.ptr->data);
@@ -663,6 +712,22 @@ nl_send_route(struct krt_proto *p, rte *e, struct ea_list *eattrs, int new)
   if (ea = ea_find(eattrs, EA_KRT_REALM))
     nl_add_attr_u32(&r.h, sizeof(r), RTA_FLOW, ea->u.data);
 
+
+  u32 metrics[KRT_METRICS_MAX];
+  metrics[0] = 0;
+
+  struct ea_walk_state ews = { .eattrs = eattrs };
+  while (ea = ea_walk(&ews, EA_KRT_METRICS, KRT_METRICS_MAX))
+  {
+    int id = ea->id - EA_KRT_METRICS;
+    metrics[0] |= 1 << id;
+    metrics[id] = ea->u.data;
+  }
+
+  if (metrics[0])
+    nl_add_metrics(&r.h, sizeof(r), metrics, KRT_METRICS_MAX);
+
+
   /* a->iface != NULL checked in krt_capable() for router and device routes */
 
   switch (a->dest)
@@ -834,7 +899,7 @@ nl_parse_route(struct nlmsghdr *h, int scan)
 		  net->n.prefix, net->n.pxlen);
 	      return;
 	    }
-	    
+
 	  break;
 	}
 
@@ -896,7 +961,7 @@ nl_parse_route(struct nlmsghdr *h, int scan)
   e->u.krt.type = i->rtm_type;
 
   if (a[RTA_PRIORITY])
-    memcpy(&e->u.krt.metric, RTA_DATA(a[RTA_PRIORITY]), sizeof(e->u.krt.metric)); 
+    memcpy(&e->u.krt.metric, RTA_DATA(a[RTA_PRIORITY]), sizeof(e->u.krt.metric));
   else
     e->u.krt.metric = 0;
 
@@ -932,6 +997,38 @@ nl_parse_route(struct nlmsghdr *h, int scan)
       memcpy(&ea->attrs[0].u.data, RTA_DATA(a[RTA_FLOW]), 4);
     }
 
+  if (a[RTA_METRICS])
+    {
+      u32 metrics[KRT_METRICS_MAX];
+      ea_list *ea = alloca(sizeof(ea_list) + KRT_METRICS_MAX * sizeof(eattr));
+      int t, n = 0;
+
+      if (nl_parse_metrics(a[RTA_METRICS], metrics, ARRAY_SIZE(metrics)) < 0)
+        {
+	  log(L_ERR "KRT: Received route %I/%d with strange RTA_METRICS attribute",
+	      net->n.prefix, net->n.pxlen);
+	  return;
+	}
+
+      for (t = 1; t < KRT_METRICS_MAX; t++)
+	if (metrics[0] & (1 << t))
+	  {
+	    ea->attrs[n].id = EA_CODE(EAP_KRT, KRT_METRICS_OFFSET + t);
+	    ea->attrs[n].flags = 0;
+	    ea->attrs[n].type = EAF_TYPE_INT; /* FIXME: Some are EAF_TYPE_BITFIELD */
+	    ea->attrs[n].u.data = metrics[t];
+	    n++;
+	  }
+
+      if (n > 0)
+        {
+	  ea->next = ra.eattrs;
+	  ea->flags = EALF_SORTED;
+	  ea->count = n;
+	  ra.eattrs = ea;
+	}
+    }
+
   if (scan)
     krt_got_route(p, e);
   else
@@ -1130,6 +1227,50 @@ krt_sys_copy_config(struct krt_config *d, struct krt_config *s)
   d->sys.table_id = s->sys.table_id;
 }
 
+static const char *krt_metrics_names[KRT_METRICS_MAX] = {
+  NULL, "lock", "mtu", "window", "rtt", "rttvar", "sstresh", "cwnd", "advmss",
+  "reordering", "hoplimit", "initcwnd", "features", "rto_min", "initrwnd", "quickack"
+};
+
+static const char *krt_features_names[KRT_FEATURES_MAX] = {
+  "ecn", NULL, NULL, "allfrag"
+};
+
+int
+krt_sys_get_attr(eattr *a, byte *buf, int buflen UNUSED)
+{
+  switch (a->id)
+  {
+  case EA_KRT_PREFSRC:
+    bsprintf(buf, "prefsrc");
+    return GA_NAME;
+
+  case EA_KRT_REALM:
+    bsprintf(buf, "realm");
+    return GA_NAME;
+
+  case EA_KRT_LOCK:
+    buf += bsprintf(buf, "lock:");
+    ea_format_bitfield(a, buf, buflen, krt_metrics_names, 2, KRT_METRICS_MAX);
+    return GA_FULL;
+
+  case EA_KRT_FEATURES:
+    buf += bsprintf(buf, "features:");
+    ea_format_bitfield(a, buf, buflen, krt_features_names, 0, KRT_FEATURES_MAX);
+    return GA_FULL;
+
+  default:;
+    int id = (int)EA_ID(a->id) - KRT_METRICS_OFFSET;
+    if (id > 0 && id < KRT_METRICS_MAX)
+    {
+      bsprintf(buf, "%s", krt_metrics_names[id]);
+      return GA_NAME;
+    }
+
+    return GA_UNKNOWN;
+  }
+}
+
 
 
 void
diff --git a/sysdep/unix/krt.c b/sysdep/unix/krt.c
index efdf4bdd..cfb623ce 100644
--- a/sysdep/unix/krt.c
+++ b/sysdep/unix/krt.c
@@ -1191,7 +1191,7 @@ krt_copy_config(struct proto_config *dest, struct proto_config *src)
 }
 
 static int
-krt_get_attr(eattr * a, byte * buf, int buflen UNUSED)
+krt_get_attr(eattr *a, byte *buf, int buflen)
 {
   switch (a->id)
   {
@@ -1203,16 +1203,8 @@ krt_get_attr(eattr * a, byte * buf, int buflen UNUSED)
     bsprintf(buf, "metric");
     return GA_NAME;
 
-  case EA_KRT_PREFSRC:
-    bsprintf(buf, "prefsrc");
-    return GA_NAME;
-
-  case EA_KRT_REALM:
-    bsprintf(buf, "realm");
-    return GA_NAME;
-
   default:
-    return GA_UNKNOWN;
+    return krt_sys_get_attr(a, buf, buflen);
   }
 }
 
diff --git a/sysdep/unix/krt.h b/sysdep/unix/krt.h
index f0fd6261..1940cbcd 100644
--- a/sysdep/unix/krt.h
+++ b/sysdep/unix/krt.h
@@ -28,8 +28,6 @@ struct kif_proto;
 
 #define EA_KRT_SOURCE	EA_CODE(EAP_KRT, 0)
 #define EA_KRT_METRIC	EA_CODE(EAP_KRT, 1)
-#define EA_KRT_PREFSRC	EA_CODE(EAP_KRT, 2)
-#define EA_KRT_REALM	EA_CODE(EAP_KRT, 3)
 
 /* Whenever we recognize our own routes, we allow learing of foreign routes */
 
@@ -131,6 +129,7 @@ void krt_sys_copy_config(struct krt_config *, struct krt_config *);
 int  krt_capable(rte *e);
 void krt_do_scan(struct krt_proto *);
 void krt_replace_rte(struct krt_proto *p, net *n, rte *new, rte *old, struct ea_list *eattrs);
+int krt_sys_get_attr(eattr *a, byte *buf, int buflen);
 
 
 /* kif sysdep */

From 38e835dede88158d97c3039ed22faabed79c7181 Mon Sep 17 00:00:00 2001
From: Ondrej Zajicek <santiago@crfreenet.org>
Date: Wed, 13 May 2015 13:19:26 +0200
Subject: [PATCH 004/165] Fix in the last commit

---
 sysdep/linux/netlink.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sysdep/linux/netlink.c b/sysdep/linux/netlink.c
index 72837ce0..71f58554 100644
--- a/sysdep/linux/netlink.c
+++ b/sysdep/linux/netlink.c
@@ -316,7 +316,7 @@ nl_add_multipath(struct nlmsghdr *h, unsigned bufsize, struct mpnh *nh)
     rtnh->rtnh_hops = nh->weight;
     rtnh->rtnh_ifindex = nh->iface->index;
 
-    nl_add_attr_u32(h, bufsize, RTA_GATEWAY, nh->gw);
+    nl_add_attr_ipa(h, bufsize, RTA_GATEWAY, nh->gw);
 
     nl_close_nexthop(h, rtnh);
   }

From 86f567e13c2202fc3c3a1ce49f9a35220a50f117 Mon Sep 17 00:00:00 2001
From: Ondrej Zajicek <santiago@crfreenet.org>
Date: Sat, 16 May 2015 20:17:59 +0200
Subject: [PATCH 005/165] Fix minor issue in pipe route propagation

In some circumstances during reconfiguration, routes propagated by pipes
to other tables may hang there even after the primary routes are removed.

There is already a workaround for this issue in the code which removes
these stale routes by flush process when source protocols are shut down.

This patch is a cleaner fix and allows to simplify the flush process
---
 nest/rt-table.c | 27 +++++++++++++++++++++++----
 1 file changed, 23 insertions(+), 4 deletions(-)

diff --git a/nest/rt-table.c b/nest/rt-table.c
index dbe0c50d..a8fe137c 100644
--- a/nest/rt-table.c
+++ b/nest/rt-table.c
@@ -347,11 +347,13 @@ do_rt_notify(struct announce_hook *ah, net *net, rte *new, rte *old, ea_list *tm
 }
 
 static void
-rt_notify_basic(struct announce_hook *ah, net *net, rte *new, rte *old, ea_list *tmpa, int refeed)
+rt_notify_basic(struct announce_hook *ah, net *net, rte *new0, rte *old0, ea_list *tmpa, int refeed)
 {
-  // struct proto *p = ah->proto;
+  struct proto *p = ah->proto;
   struct proto_stats *stats = ah->stats;
 
+  rte *new = new0;
+  rte *old = old0;
   rte *new_free = NULL;
   rte *old_free = NULL;
 
@@ -369,7 +371,7 @@ rt_notify_basic(struct announce_hook *ah, net *net, rte *new, rte *old, ea_list
    * FIXME - this is broken because 'configure soft' may change
    * filters but keep routes. Refeed is expected to be called after
    * change of the filters and with old == new, therefore we do not
-   * even try to run the filter on an old route, This may lead to 
+   * even try to run the filter on an old route, This may lead to
    * 'spurious withdraws' but ensure that there are no 'missing
    * withdraws'.
    *
@@ -386,9 +388,26 @@ rt_notify_basic(struct announce_hook *ah, net *net, rte *new, rte *old, ea_list
   if (old && !refeed)
     old = export_filter(ah, old, &old_free, NULL, 1);
 
-  /* FIXME - This is broken because of incorrect 'old' value (see above) */
   if (!new && !old)
+  {
+    /*
+     * As mentioned above, 'old' value may be incorrect in some race conditions.
+     * We generally ignore it with the exception of withdraw to pipe protocol.
+     * In that case we rather propagate unfiltered withdraws regardless of
+     * export filters to ensure that when a protocol is flushed, its routes are
+     * removed from all tables. Possible spurious unfiltered withdraws are not
+     * problem here as they are ignored if there is no corresponding route at
+     * the other end of the pipe. We directly call rt_notify() hook instead of
+     * do_rt_notify() to avoid logging and stat counters.
+     */
+
+#ifdef CONFIG_PIPE
+    if ((p->proto == &proto_pipe) && !new0 && (p != old0->sender->proto))
+      p->rt_notify(p, ah->table, net, NULL, old0, NULL);
+#endif
+
     return;
+  }
 
   do_rt_notify(ah, net, new, old, tmpa, refeed);
 

From d0e23d42de133de706151411d8d4091d07904d29 Mon Sep 17 00:00:00 2001
From: Ondrej Zajicek <santiago@crfreenet.org>
Date: Sun, 17 May 2015 00:54:33 +0200
Subject: [PATCH 006/165] Simplify flushing process

Related to changes from previous patch.
---
 nest/rt-table.c | 35 ++++-------------------------------
 1 file changed, 4 insertions(+), 31 deletions(-)

diff --git a/nest/rt-table.c b/nest/rt-table.c
index a8fe137c..24517e2c 100644
--- a/nest/rt-table.c
+++ b/nest/rt-table.c
@@ -1384,9 +1384,8 @@ rt_init(void)
 
 
 static int
-rt_prune_step(rtable *tab, int step, int *limit)
+rt_prune_step(rtable *tab, int *limit)
 {
-  static struct tbf rl_flush = TBF_DEFAULT_LOG_LIMITS;
   struct fib_iterator *fit = &tab->prune_fit;
 
   DBG("Pruning route table %s\n", tab->name);
@@ -1411,9 +1410,7 @@ rt_prune_step(rtable *tab, int step, int *limit)
 
     rescan:
       for (e=n->routes; e; e=e->next)
-	if (e->sender->proto->flushing ||
-	    (e->flags & REF_DISCARD) ||
-	    (step && e->attrs->src->proto->flushing))
+	if (e->sender->proto->flushing || (e->flags & REF_DISCARD))
 	  {
 	    if (*limit <= 0)
 	      {
@@ -1421,10 +1418,6 @@ rt_prune_step(rtable *tab, int step, int *limit)
 		return 0;
 	      }
 
-	    if (step)
-	      log_rl(&rl_flush, L_WARN "Route %I/%d from %s still in %s after flush",
-		  n->n.prefix, n->n.pxlen, e->attrs->src->proto->name, tab->name);
-
 	    rte_discard(tab, e);
 	    (*limit)--;
 
@@ -1464,7 +1457,7 @@ static inline int
 rt_prune_table(rtable *tab)
 {
   int limit = 512;
-  return rt_prune_step(tab, 0, &limit);
+  return rt_prune_step(tab, &limit);
 }
 
 /**
@@ -1473,37 +1466,17 @@ rt_prune_table(rtable *tab)
  * The prune loop scans routing tables and removes routes belonging to flushing
  * protocols, discarded routes and also stale network entries. Returns 1 when
  * all such routes are pruned. It is a part of the protocol flushing loop.
- *
- * The prune loop runs in two steps. In the first step it prunes just the routes
- * with flushing senders (in explicitly marked tables) so the route removal is
- * propagated as usual. In the second step, all remaining relevant routes are
- * removed. Ideally, there shouldn't be any, but it happens when pipe filters
- * are changed.
  */
 int
 rt_prune_loop(void)
 {
-  static int step = 0;
   int limit = 512;
   rtable *t;
 
- again:
   WALK_LIST(t, routing_tables)
-    if (! rt_prune_step(t, step, &limit))
+    if (! rt_prune_step(t, &limit))
       return 0;
 
-  if (step == 0)
-    {
-      /* Prepare for the second step */
-      WALK_LIST(t, routing_tables)
-	t->prune_state = RPS_SCHEDULED;
-
-      step = 1;
-      goto again;
-    }
-
-  /* Done */
-  step = 0;
   return 1;
 }
 

From 9fe1d3ca8a6420b4bdaf15a54ab7b13be6cc07eb Mon Sep 17 00:00:00 2001
From: Ondrej Zajicek <santiago@crfreenet.org>
Date: Fri, 22 May 2015 11:12:48 +0200
Subject: [PATCH 007/165] Fixes unnamed protocols from templates

---
 nest/config.Y | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/nest/config.Y b/nest/config.Y
index 939bed6a..37551802 100644
--- a/nest/config.Y
+++ b/nest/config.Y
@@ -183,16 +183,18 @@ proto_name:
    }
  | FROM SYM {
      struct symbol *s = cf_default_name(this_proto->protocol->template, &this_proto->protocol->name_counter);
+     s->class = this_proto->class;
+     s->def = this_proto;
      this_proto->name = s->name;
+
      if (($2->class != SYM_TEMPLATE) && ($2->class != SYM_PROTO)) cf_error("Template or protocol name expected");
      proto_copy_config(this_proto, $2->def);
    }
  | SYM FROM SYM {
-     if (($3->class != SYM_TEMPLATE) && ($3->class != SYM_PROTO)) cf_error("Template or protocol name expected");
-
      cf_define_symbol($1, this_proto->class, this_proto);
      this_proto->name = $1->name;
 
+     if (($3->class != SYM_TEMPLATE) && ($3->class != SYM_PROTO)) cf_error("Template or protocol name expected");
      proto_copy_config(this_proto, $3->def);
    }
  ;

From 398f92253186d70eb3f2e910c7f8dd2636ee5fa1 Mon Sep 17 00:00:00 2001
From: Ondrej Filip <feela@network.cz>
Date: Mon, 1 Jun 2015 10:41:17 +0200
Subject: [PATCH 008/165] Typo fix by Hans van Kranenburg

---
 proto/ospf/iface.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/proto/ospf/iface.c b/proto/ospf/iface.c
index 656184c6..9b0f7797 100644
--- a/proto/ospf/iface.c
+++ b/proto/ospf/iface.c
@@ -1344,9 +1344,9 @@ ospf_iface_info(struct ospf_iface *ifa)
   cli_msg(-1015, "\tRetransmit timer: %u", ifa->rxmtint);
   if ((ifa->type == OSPF_IT_BCAST) || (ifa->type == OSPF_IT_NBMA))
   {
-    cli_msg(-1015, "\tDesigned router (ID): %R", ifa->drid);
-    cli_msg(-1015, "\tDesigned router (IP): %I", ifa->drip);
-    cli_msg(-1015, "\tBackup designed router (ID): %R", ifa->bdrid);
-    cli_msg(-1015, "\tBackup designed router (IP): %I", ifa->bdrip);
+    cli_msg(-1015, "\tDesignated router (ID): %R", ifa->drid);
+    cli_msg(-1015, "\tDesignated router (IP): %I", ifa->drip);
+    cli_msg(-1015, "\tBackup designated router (ID): %R", ifa->bdrid);
+    cli_msg(-1015, "\tBackup designated router (IP): %I", ifa->bdrip);
   }
 }

From e348ef01b433e06888310c1098a05291034a856c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pavel=20Tvrd=C3=ADk?= <pawel.tvrdik@gmail.cz>
Date: Tue, 19 May 2015 08:14:04 +0200
Subject: [PATCH 009/165] unsgined char -> byte

---
 lib/printf.c       | 2 +-
 nest/route.h       | 2 +-
 proto/ospf/rt.c    | 2 +-
 sysdep/bsd/sysio.h | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/lib/printf.c b/lib/printf.c
index 3eb988fa..a1c36129 100644
--- a/lib/printf.c
+++ b/lib/printf.c
@@ -215,7 +215,7 @@ int bvsnprintf(char *buf, int size, const char *fmt, va_list args)
 			if (!(flags & LEFT))
 				while (--field_width > 0)
 					*str++ = ' ';
-			*str++ = (unsigned char) va_arg(args, int);
+			*str++ = (byte) va_arg(args, int);
 			while (--field_width > 0)
 				*str++ = ' ';
 			continue;
diff --git a/nest/route.h b/nest/route.h
index 87f10ae3..2e6bf741 100644
--- a/nest/route.h
+++ b/nest/route.h
@@ -320,7 +320,7 @@ struct mpnh {
   ip_addr gw;				/* Next hop */
   struct iface *iface;			/* Outgoing interface */
   struct mpnh *next;
-  unsigned char weight;
+  byte weight;
 };
 
 struct rte_src {
diff --git a/proto/ospf/rt.c b/proto/ospf/rt.c
index 74d10c7b..e74bcae6 100644
--- a/proto/ospf/rt.c
+++ b/proto/ospf/rt.c
@@ -43,7 +43,7 @@ unresolved_vlink(ort *ort)
 }
 
 static inline struct mpnh *
-new_nexthop(struct ospf_proto *p, ip_addr gw, struct iface *iface, unsigned char weight)
+new_nexthop(struct ospf_proto *p, ip_addr gw, struct iface *iface, byte weight)
 {
   struct mpnh *nh = lp_alloc(p->nhpool, sizeof(struct mpnh));
   nh->gw = gw;
diff --git a/sysdep/bsd/sysio.h b/sysdep/bsd/sysio.h
index df5e0236..c82d7a1e 100644
--- a/sysdep/bsd/sysio.h
+++ b/sysdep/bsd/sysio.h
@@ -130,7 +130,7 @@ static inline void
 sk_process_cmsg4_ttl(sock *s, struct cmsghdr *cm)
 {
   if (cm->cmsg_type == IP_RECVTTL)
-    s->rcv_ttl = * (unsigned char *) CMSG_DATA(cm);
+    s->rcv_ttl = * (byte *) CMSG_DATA(cm);
 }
 
 static inline void

From ae80a2de95d3d3c153ce20b90c9d8757d02cb33d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pavel=20Tvrd=C3=ADk?= <pawel.tvrdik@gmail.cz>
Date: Tue, 19 May 2015 08:53:34 +0200
Subject: [PATCH 010/165] unsigned [int] -> uint

---
 client/commands.c      |  2 +-
 conf/conf.h            |  2 +-
 lib/bitops.c           |  2 +-
 lib/bitops.h           |  2 +-
 lib/checksum.c         | 10 +++++-----
 lib/checksum.h         |  4 ++--
 lib/ip.h               |  4 ++--
 lib/mempool.c          | 12 ++++++------
 lib/printf.c           |  2 +-
 lib/slab.c             | 12 ++++++------
 lib/socket.h           | 14 +++++++-------
 lib/xmalloc.c          |  4 ++--
 misc/ips.c             |  4 ++--
 nest/a-path.c          |  2 +-
 nest/a-set.c           |  4 ++--
 nest/attrs.h           |  6 +++---
 nest/cli.c             | 10 +++++-----
 nest/cli.h             | 12 ++++++------
 nest/neighbor.c        |  4 ++--
 nest/proto.c           | 22 +++++++++++-----------
 nest/protocol.h        | 18 +++++++++---------
 nest/route.h           | 22 +++++++++++-----------
 nest/rt-attr.c         | 30 +++++++++++++++---------------
 nest/rt-fib.c          | 10 +++++-----
 nest/rt-table.c        | 10 +++++-----
 proto/bgp/attrs.c      | 14 +++++++-------
 proto/bgp/bgp.h        |  8 ++++----
 proto/bgp/packets.c    |  8 ++++----
 sysdep/bsd/krt-sock.c  |  4 ++--
 sysdep/linux/netlink.c |  6 +++---
 sysdep/unix/main.c     |  2 +-
 sysdep/unix/unix.h     |  2 +-
 32 files changed, 134 insertions(+), 134 deletions(-)

diff --git a/client/commands.c b/client/commands.c
index 08e7949a..50fcba40 100644
--- a/client/commands.c
+++ b/client/commands.c
@@ -38,7 +38,7 @@ static struct cmd_node cmd_root;
 void
 cmd_build_tree(void)
 {
-  unsigned int i;
+  uint i;
 
   cmd_root.plastson = &cmd_root.son;
 
diff --git a/conf/conf.h b/conf/conf.h
index 6ab53e25..515efbb3 100644
--- a/conf/conf.h
+++ b/conf/conf.h
@@ -100,7 +100,7 @@ void cfg_copy_list(list *dest, list *src, unsigned node_size);
 
 /* Lexer */
 
-extern int (*cf_read_hook)(byte *buf, unsigned int max, int fd);
+extern int (*cf_read_hook)(byte *buf, uint max, int fd);
 
 struct symbol {
   struct symbol *next;
diff --git a/lib/bitops.c b/lib/bitops.c
index b63274b8..81586e87 100644
--- a/lib/bitops.c
+++ b/lib/bitops.c
@@ -17,7 +17,7 @@
  * representation consists of @n ones followed by zeroes.
  */
 u32
-u32_mkmask(unsigned n)
+u32_mkmask(uint n)
 {
   return n ? ~((1 << (32 - n)) - 1) : 0;
 }
diff --git a/lib/bitops.h b/lib/bitops.h
index a12f6b60..c0ad1a70 100644
--- a/lib/bitops.h
+++ b/lib/bitops.h
@@ -18,7 +18,7 @@
  *	u32_masklen	Inverse operation to u32_mkmask, -1 if not a bitmask.
  */
 
-u32 u32_mkmask(unsigned n);
+u32 u32_mkmask(uint n);
 int u32_masklen(u32 x);
 
 u32 u32_log2(u32 v);
diff --git a/lib/checksum.c b/lib/checksum.c
index 18b1f92c..b61306b3 100644
--- a/lib/checksum.c
+++ b/lib/checksum.c
@@ -28,7 +28,7 @@ add32(u32 sum, u32 x)
 }
 
 static u16
-ipsum_calc_block(u32 *buf, unsigned len, u16 isum)
+ipsum_calc_block(u32 *buf, uint len, u16 isum)
 {
   /*
    *  A few simple facts about the IP checksum (see RFC 1071 for detailed
@@ -57,7 +57,7 @@ ipsum_calc_block(u32 *buf, unsigned len, u16 isum)
 }
 
 static u16
-ipsum_calc(void *frag, unsigned len, va_list args)
+ipsum_calc(void *frag, uint len, va_list args)
 {
   u16 sum = 0;
 
@@ -67,7 +67,7 @@ ipsum_calc(void *frag, unsigned len, va_list args)
       frag = va_arg(args, void *);
       if (!frag)
 	break;
-      len = va_arg(args, unsigned);
+      len = va_arg(args, uint);
     }
   return sum;
 }
@@ -87,7 +87,7 @@ ipsum_calc(void *frag, unsigned len, va_list args)
  * Result: 1 if the checksum is correct, 0 else.
  */
 int
-ipsum_verify(void *frag, unsigned len, ...)
+ipsum_verify(void *frag, uint len, ...)
 {
   va_list args;
   u16 sum;
@@ -110,7 +110,7 @@ ipsum_verify(void *frag, unsigned len, ...)
  * up checksum calculation as much as possible.
  */
 u16
-ipsum_calculate(void *frag, unsigned len, ...)
+ipsum_calculate(void *frag, uint len, ...)
 {
   va_list args;
   u16 sum;
diff --git a/lib/checksum.h b/lib/checksum.h
index 81515543..16cbcce5 100644
--- a/lib/checksum.h
+++ b/lib/checksum.h
@@ -14,7 +14,7 @@
  *	fragments finished by NULL pointer.
  */
 
-int ipsum_verify(void *frag, unsigned len, ...);
-u16 ipsum_calculate(void *frag, unsigned len, ...);
+int ipsum_verify(void *frag, uint len, ...);
+u16 ipsum_calculate(void *frag, uint len, ...);
 
 #endif
diff --git a/lib/ip.h b/lib/ip.h
index 45e073d9..90bb7f8a 100644
--- a/lib/ip.h
+++ b/lib/ip.h
@@ -471,11 +471,11 @@ int ip6_pton(char *a, ip6_addr *o);
 #define ipa_in_net(x,n,p) (ipa_zero(ipa_and(ipa_xor((n),(x)),ipa_mkmask(p))))
 #define net_in_net(n1,l1,n2,l2) (((l1) >= (l2)) && (ipa_zero(ipa_and(ipa_xor((n1),(n2)),ipa_mkmask(l2)))))
 
-char *ip_scope_text(unsigned);
+char *ip_scope_text(uint);
 
 struct prefix {
   ip_addr addr;
-  unsigned int len;
+  uint len;
 };
 
 
diff --git a/lib/mempool.c b/lib/mempool.c
index ec9854a9..a8281041 100644
--- a/lib/mempool.c
+++ b/lib/mempool.c
@@ -27,7 +27,7 @@
 
 struct lp_chunk {
   struct lp_chunk *next;
-  unsigned int size;
+  uint size;
   uintptr_t data_align[0];
   byte data[0];
 };
@@ -37,7 +37,7 @@ struct linpool {
   byte *ptr, *end;
   struct lp_chunk *first, *current, **plast;	/* Normal (reusable) chunks */
   struct lp_chunk *first_large;			/* Large chunks */
-  unsigned chunk_size, threshold, total, total_large;
+  uint chunk_size, threshold, total, total_large;
 };
 
 static void lp_free(resource *);
@@ -64,7 +64,7 @@ static struct resclass lp_class = {
  * @blk.
  */
 linpool
-*lp_new(pool *p, unsigned blk)
+*lp_new(pool *p, uint blk)
 {
   linpool *m = ralloc(p, &lp_class);
   m->plast = &m->first;
@@ -88,7 +88,7 @@ linpool
  * size chunk, an "overflow" chunk is created for it instead.
  */
 void *
-lp_alloc(linpool *m, unsigned size)
+lp_alloc(linpool *m, uint size)
 {
   byte *a = (byte *) BIRD_ALIGN((unsigned long) m->ptr, CPU_STRUCT_ALIGN);
   byte *e = a + size;
@@ -146,7 +146,7 @@ lp_alloc(linpool *m, unsigned size)
  * how to allocate strings without any space overhead.
  */
 void *
-lp_allocu(linpool *m, unsigned size)
+lp_allocu(linpool *m, uint size)
 {
   byte *a = m->ptr;
   byte *e = a + size;
@@ -168,7 +168,7 @@ lp_allocu(linpool *m, unsigned size)
  * clears the allocated memory block.
  */
 void *
-lp_allocz(linpool *m, unsigned size)
+lp_allocz(linpool *m, uint size)
 {
   void *z = lp_alloc(m, size);
 
diff --git a/lib/printf.c b/lib/printf.c
index a1c36129..e4cc3006 100644
--- a/lib/printf.c
+++ b/lib/printf.c
@@ -355,7 +355,7 @@ int bvsnprintf(char *buf, int size, const char *fmt, va_list args)
 		} else if (flags & SIGN)
 			num = va_arg(args, int);
 		else
-			num = va_arg(args, unsigned int);
+			num = va_arg(args, uint);
 		str = number(str, num, base, field_width, precision, flags, size);
 		if (!str)
 			return -1;
diff --git a/lib/slab.c b/lib/slab.c
index 31529c30..5c414f9e 100644
--- a/lib/slab.c
+++ b/lib/slab.c
@@ -51,7 +51,7 @@ static size_t slab_memsize(resource *r);
 
 struct slab {
   resource r;
-  unsigned size;
+  uint size;
   list objs;
 };
 
@@ -71,7 +71,7 @@ struct sl_obj {
 };
 
 slab *
-sl_new(pool *p, unsigned size)
+sl_new(pool *p, uint size)
 {
   slab *s = ralloc(p, &sl_class);
   s->size = size;
@@ -144,7 +144,7 @@ slab_memsize(resource *r)
 
 struct slab {
   resource r;
-  unsigned obj_size, head_size, objs_per_slab, num_empty_heads, data_size;
+  uint obj_size, head_size, objs_per_slab, num_empty_heads, data_size;
   list empty_heads, partial_heads, full_heads;
 };
 
@@ -185,10 +185,10 @@ struct sl_alignment {			/* Magic structure for testing of alignment */
  * objects of size @size can be allocated.
  */
 slab *
-sl_new(pool *p, unsigned size)
+sl_new(pool *p, uint size)
 {
   slab *s = ralloc(p, &sl_class);
-  unsigned int align = sizeof(struct sl_alignment);
+  uint align = sizeof(struct sl_alignment);
   if (align < sizeof(int))
     align = sizeof(int);
   s->data_size = size;
@@ -214,7 +214,7 @@ sl_new_head(slab *s)
   struct sl_head *h = xmalloc(SLAB_SIZE);
   struct sl_obj *o = (struct sl_obj *)((byte *)h+s->head_size);
   struct sl_obj *no;
-  unsigned int n = s->objs_per_slab;
+  uint n = s->objs_per_slab;
 
   h->first_free = o;
   h->num_full = 0;
diff --git a/lib/socket.h b/lib/socket.h
index 683cdde3..fbea92aa 100644
--- a/lib/socket.h
+++ b/lib/socket.h
@@ -20,7 +20,7 @@ typedef struct birdsock {
   int type;				/* Socket type */
   void *data;				/* User data */
   ip_addr saddr, daddr;			/* IPA_NONE = unspecified */
-  unsigned sport, dport;		/* 0 = unspecified (for IP: protocol type) */
+  uint sport, dport;			/* 0 = unspecified (for IP: protocol type) */
   int tos;				/* TOS / traffic class, -1 = default */
   int priority;				/* Local socket priority, -1 = default */
   int ttl;				/* Time To Live, -1 = default */
@@ -28,20 +28,20 @@ typedef struct birdsock {
   struct iface *iface;			/* Interface; specify this for broad/multicast sockets */
 
   byte *rbuf, *rpos;			/* NULL=allocate automatically */
-  unsigned rbsize;
+  uint rbsize;
   int (*rx_hook)(struct birdsock *, int size); /* NULL=receiving turned off, returns 1 to clear rx buffer */
 
   byte *tbuf, *tpos;			/* NULL=allocate automatically */
   byte *ttx;				/* Internal */
-  unsigned tbsize;
+  uint tbsize;
   void (*tx_hook)(struct birdsock *);
 
   void (*err_hook)(struct birdsock *, int); /* errno or zero if EOF */
 
   /* Information about received datagrams (UDP, RAW), valid in rx_hook */
   ip_addr faddr, laddr;			/* src (From) and dst (Local) address of the datagram */
-  unsigned fport;			/* src port of the datagram */
-  unsigned lifindex;			/* local interface that received the datagram */
+  uint fport;				/* src port of the datagram */
+  uint lifindex;			/* local interface that received the datagram */
   /* laddr and lifindex are valid only if SKF_LADDR_RX flag is set to request it */
 
   int af;				/* Address family (AF_INET, AF_INET6 or 0 for non-IP) of fd */
@@ -59,8 +59,8 @@ sock *sock_new(pool *);			/* Allocate new socket */
 
 int sk_open(sock *);			/* Open socket */
 int sk_rx_ready(sock *s);
-int sk_send(sock *, unsigned len);	/* Send data, <0=err, >0=ok, 0=sleep */
-int sk_send_to(sock *, unsigned len, ip_addr to, unsigned port); /* sk_send to given destination */
+int sk_send(sock *, uint len);		/* Send data, <0=err, >0=ok, 0=sleep */
+int sk_send_to(sock *, uint len, ip_addr to, uint port); /* sk_send to given destination */
 void sk_reallocate(sock *);		/* Free and allocate tbuf & rbuf */
 void sk_set_rbsize(sock *s, uint val);	/* Resize RX buffer */
 void sk_set_tbsize(sock *s, uint val);	/* Resize TX buffer, keeping content */
diff --git a/lib/xmalloc.c b/lib/xmalloc.c
index da2f0941..10bf28cf 100644
--- a/lib/xmalloc.c
+++ b/lib/xmalloc.c
@@ -24,7 +24,7 @@
  * Wherever possible, please use the memory resources instead.
  */
 void *
-xmalloc(unsigned size)
+xmalloc(uint size)
 {
   void *p = malloc(size);
   if (p)
@@ -44,7 +44,7 @@ xmalloc(unsigned size)
  * Wherever possible, please use the memory resources instead.
  */
 void *
-xrealloc(void *ptr, unsigned size)
+xrealloc(void *ptr, uint size)
 {
   void *p = realloc(ptr, size);
   if (p)
diff --git a/misc/ips.c b/misc/ips.c
index 7ea6c71b..467cc25d 100644
--- a/misc/ips.c
+++ b/misc/ips.c
@@ -23,7 +23,7 @@ int h[65536];
  *	= ((1-1/k)^k)^a which we can approximate by e^-a.
  */
 
-unsigned int hf(unsigned int n)
+uint hf(uint n)
 {
 #if 0
 	n = (n ^ (n >> 16)) & 0xffff;
@@ -58,7 +58,7 @@ main(int argc, char **argv)
 
 	while (max--)
 	  {
-	    unsigned int i, e;
+	    uint i, e;
 	    if (scanf("%x/%d", &i, &e) != 2)
 	      if (feof(stdin))
 		break;
diff --git a/nest/a-path.c b/nest/a-path.c
index dc36e653..c9c5aefb 100644
--- a/nest/a-path.c
+++ b/nest/a-path.c
@@ -124,7 +124,7 @@ as_path_convert_to_new(struct adata *path, byte *dst, int req_as)
 }
 
 void
-as_path_format(struct adata *path, byte *buf, unsigned int size)
+as_path_format(struct adata *path, byte *buf, uint size)
 {
   byte *p = path->data;
   byte *e = p + path->length;
diff --git a/nest/a-set.c b/nest/a-set.c
index 42ef9b06..a6116022 100644
--- a/nest/a-set.c
+++ b/nest/a-set.c
@@ -32,7 +32,7 @@
  * the buffer to indicate truncation.
  */
 int
-int_set_format(struct adata *set, int way, int from, byte *buf, unsigned int size)
+int_set_format(struct adata *set, int way, int from, byte *buf, uint size)
 {
   u32 *z = (u32 *) set->data;
   byte *end = buf + size - 24;
@@ -113,7 +113,7 @@ ec_format(byte *buf, u64 ec)
 }
 
 int
-ec_set_format(struct adata *set, int from, byte *buf, unsigned int size)
+ec_set_format(struct adata *set, int from, byte *buf, uint size)
 {
   u32 *z = int_set_get_data(set);
   byte *end = buf + size - 24;
diff --git a/nest/attrs.h b/nest/attrs.h
index b6e067cb..1d005a6a 100644
--- a/nest/attrs.h
+++ b/nest/attrs.h
@@ -30,7 +30,7 @@ struct f_tree;
 struct adata *as_path_prepend(struct linpool *pool, struct adata *olda, u32 as);
 int as_path_convert_to_old(struct adata *path, byte *dst, int *new_used);
 int as_path_convert_to_new(struct adata *path, byte *dst, int req_as);
-void as_path_format(struct adata *path, byte *buf, unsigned int size);
+void as_path_format(struct adata *path, byte *buf, uint size);
 int as_path_getlen(struct adata *path);
 int as_path_getlen_int(struct adata *path, int bs);
 int as_path_get_first(struct adata *path, u32 *orig_as);
@@ -95,9 +95,9 @@ static inline u64 ec_ip4(u64 kind, u64 key, u64 val)
 static inline u64 ec_generic(u64 key, u64 val)
 { return (key << 32) | val; }
 
-int int_set_format(struct adata *set, int way, int from, byte *buf, unsigned int size);
+int int_set_format(struct adata *set, int way, int from, byte *buf, uint size);
 int ec_format(byte *buf, u64 ec);
-int ec_set_format(struct adata *set, int from, byte *buf, unsigned int size);
+int ec_set_format(struct adata *set, int from, byte *buf, uint size);
 int int_set_contains(struct adata *list, u32 val);
 int ec_set_contains(struct adata *list, u64 val);
 struct adata *int_set_add(struct linpool *pool, struct adata *list, u32 val);
diff --git a/nest/cli.c b/nest/cli.c
index 11f98794..83e79616 100644
--- a/nest/cli.c
+++ b/nest/cli.c
@@ -163,7 +163,7 @@ static void
 cli_copy_message(cli *c)
 {
   byte *p, *q;
-  unsigned int cnt = 2;
+  uint cnt = 2;
 
   if (c->ring_overflow)
     {
@@ -230,12 +230,12 @@ cli_written(cli *c)
 
 
 static byte *cli_rh_pos;
-static unsigned int cli_rh_len;
+static uint cli_rh_len;
 static int cli_rh_trick_flag;
 struct cli *this_cli;
 
 static int
-cli_cmd_read_hook(byte *buf, unsigned int max, UNUSED int fd)
+cli_cmd_read_hook(byte *buf, uint max, UNUSED int fd)
 {
   if (!cli_rh_trick_flag)
     {
@@ -330,7 +330,7 @@ static list cli_log_hooks;
 static int cli_log_inited;
 
 void
-cli_set_log_echo(cli *c, unsigned int mask, unsigned int size)
+cli_set_log_echo(cli *c, uint mask, uint size)
 {
   if (c->ring_buf)
     {
@@ -351,7 +351,7 @@ cli_set_log_echo(cli *c, unsigned int mask, unsigned int size)
 }
 
 void
-cli_echo(unsigned int class, byte *msg)
+cli_echo(uint class, byte *msg)
 {
   unsigned len, free, i, l;
   cli *c;
diff --git a/nest/cli.h b/nest/cli.h
index 396656e8..92f3c3d7 100644
--- a/nest/cli.h
+++ b/nest/cli.h
@@ -40,10 +40,10 @@ typedef struct cli {
   struct linpool *parser_pool;		/* Pool used during parsing */
   byte *ring_buf;			/* Ring buffer for asynchronous messages */
   byte *ring_end, *ring_read, *ring_write;	/* Pointers to the ring buffer */
-  unsigned int ring_overflow;		/* Counter of ring overflows */
-  unsigned int log_mask;		/* Mask of allowed message levels */
-  unsigned int log_threshold;		/* When free < log_threshold, store only important messages */
-  unsigned int async_msg_size;		/* Total size of async messages queued in tx_buf */
+  uint ring_overflow;			/* Counter of ring overflows */
+  uint log_mask;			/* Mask of allowed message levels */
+  uint log_threshold;			/* When free < log_threshold, store only important messages */
+  uint async_msg_size;			/* Total size of async messages queued in tx_buf */
 } cli;
 
 extern pool *cli_pool;
@@ -55,7 +55,7 @@ extern struct cli *this_cli;		/* Used during parsing */
 
 void cli_printf(cli *, int, char *, ...);
 #define cli_msg(x...) cli_printf(this_cli, x)
-void cli_set_log_echo(cli *, unsigned int mask, unsigned int size);
+void cli_set_log_echo(cli *, uint mask, uint size);
 
 /* Functions provided to sysdep layer */
 
@@ -64,7 +64,7 @@ void cli_init(void);
 void cli_free(cli *);
 void cli_kick(cli *);
 void cli_written(cli *);
-void cli_echo(unsigned int class, byte *msg);
+void cli_echo(uint class, byte *msg);
 
 static inline int cli_access_restricted(void)
 {
diff --git a/nest/neighbor.c b/nest/neighbor.c
index 48b6b6ac..1685d67e 100644
--- a/nest/neighbor.c
+++ b/nest/neighbor.c
@@ -49,7 +49,7 @@
 static slab *neigh_slab;
 static list sticky_neigh_list, neigh_hash_table[NEIGH_HASH_SIZE];
 
-static inline unsigned int
+static inline uint
 neigh_hash(struct proto *p, ip_addr *a)
 {
   return (p->hash_key ^ ipa_hash(*a)) & (NEIGH_HASH_SIZE-1);
@@ -126,7 +126,7 @@ neigh_find2(struct proto *p, ip_addr *a, struct iface *ifa, unsigned flags)
 {
   neighbor *n;
   int class, scope = -1;
-  unsigned int h = neigh_hash(p, a);
+  uint h = neigh_hash(p, a);
   struct iface *i;
   struct ifa *addr;
 
diff --git a/nest/proto.c b/nest/proto.c
index 44cfb637..6531083c 100644
--- a/nest/proto.c
+++ b/nest/proto.c
@@ -1488,7 +1488,7 @@ proto_show_basic_info(struct proto *p)
 }
 
 void
-proto_cmd_show(struct proto *p, unsigned int verbose, int cnt)
+proto_cmd_show(struct proto *p, uint verbose, int cnt)
 {
   byte buf[256], tbuf[TM_DATETIME_BUFFER_SIZE];
 
@@ -1524,7 +1524,7 @@ proto_cmd_show(struct proto *p, unsigned int verbose, int cnt)
 }
 
 void
-proto_cmd_disable(struct proto *p, unsigned int arg UNUSED, int cnt UNUSED)
+proto_cmd_disable(struct proto *p, uint arg UNUSED, int cnt UNUSED)
 {
   if (p->disabled)
     {
@@ -1540,7 +1540,7 @@ proto_cmd_disable(struct proto *p, unsigned int arg UNUSED, int cnt UNUSED)
 }
 
 void
-proto_cmd_enable(struct proto *p, unsigned int arg UNUSED, int cnt UNUSED)
+proto_cmd_enable(struct proto *p, uint arg UNUSED, int cnt UNUSED)
 {
   if (!p->disabled)
     {
@@ -1555,7 +1555,7 @@ proto_cmd_enable(struct proto *p, unsigned int arg UNUSED, int cnt UNUSED)
 }
 
 void
-proto_cmd_restart(struct proto *p, unsigned int arg UNUSED, int cnt UNUSED)
+proto_cmd_restart(struct proto *p, uint arg UNUSED, int cnt UNUSED)
 {
   if (p->disabled)
     {
@@ -1573,7 +1573,7 @@ proto_cmd_restart(struct proto *p, unsigned int arg UNUSED, int cnt UNUSED)
 }
 
 void
-proto_cmd_reload(struct proto *p, unsigned int dir, int cnt UNUSED)
+proto_cmd_reload(struct proto *p, uint dir, int cnt UNUSED)
 {
   if (p->disabled)
     {
@@ -1615,19 +1615,19 @@ proto_cmd_reload(struct proto *p, unsigned int dir, int cnt UNUSED)
 }
 
 void
-proto_cmd_debug(struct proto *p, unsigned int mask, int cnt UNUSED)
+proto_cmd_debug(struct proto *p, uint mask, int cnt UNUSED)
 {
   p->debug = mask;
 }
 
 void
-proto_cmd_mrtdump(struct proto *p, unsigned int mask, int cnt UNUSED)
+proto_cmd_mrtdump(struct proto *p, uint mask, int cnt UNUSED)
 {
   p->mrtdump = mask;
 }
 
 static void
-proto_apply_cmd_symbol(struct symbol *s, void (* cmd)(struct proto *, unsigned int, int), unsigned int arg)
+proto_apply_cmd_symbol(struct symbol *s, void (* cmd)(struct proto *, uint, int), uint arg)
 {
   if (s->class != SYM_PROTO)
     {
@@ -1640,7 +1640,7 @@ proto_apply_cmd_symbol(struct symbol *s, void (* cmd)(struct proto *, unsigned i
 }
 
 static void
-proto_apply_cmd_patt(char *patt, void (* cmd)(struct proto *, unsigned int, int), unsigned int arg)
+proto_apply_cmd_patt(char *patt, void (* cmd)(struct proto *, uint, int), uint arg)
 {
   int cnt = 0;
 
@@ -1660,8 +1660,8 @@ proto_apply_cmd_patt(char *patt, void (* cmd)(struct proto *, unsigned int, int)
 }
 
 void
-proto_apply_cmd(struct proto_spec ps, void (* cmd)(struct proto *, unsigned int, int),
-		int restricted, unsigned int arg)
+proto_apply_cmd(struct proto_spec ps, void (* cmd)(struct proto *, uint, int),
+		int restricted, uint arg)
 {
   if (restricted && cli_access_restricted())
     return;
diff --git a/nest/protocol.h b/nest/protocol.h
index 8660cc2c..a51e9afd 100644
--- a/nest/protocol.h
+++ b/nest/protocol.h
@@ -261,15 +261,15 @@ void proto_graceful_restart_unlock(struct proto *p);
 void proto_show_limit(struct proto_limit *l, const char *dsc);
 void proto_show_basic_info(struct proto *p);
 
-void proto_cmd_show(struct proto *, unsigned int, int);
-void proto_cmd_disable(struct proto *, unsigned int, int);
-void proto_cmd_enable(struct proto *, unsigned int, int);
-void proto_cmd_restart(struct proto *, unsigned int, int);
-void proto_cmd_reload(struct proto *, unsigned int, int);
-void proto_cmd_debug(struct proto *, unsigned int, int);
-void proto_cmd_mrtdump(struct proto *, unsigned int, int);
-
-void proto_apply_cmd(struct proto_spec ps, void (* cmd)(struct proto *, unsigned int, int), int restricted, unsigned int arg);
+void proto_cmd_show(struct proto *, uint, int);
+void proto_cmd_disable(struct proto *, uint, int);
+void proto_cmd_enable(struct proto *, uint, int);
+void proto_cmd_restart(struct proto *, uint, int);
+void proto_cmd_reload(struct proto *, uint, int);
+void proto_cmd_debug(struct proto *, uint, int);
+void proto_cmd_mrtdump(struct proto *, uint, int);
+
+void proto_apply_cmd(struct proto_spec ps, void (* cmd)(struct proto *, uint, int), int restricted, uint arg);
 struct proto *proto_get_named(struct symbol *, struct protocol *);
 
 #define CMD_RELOAD	0
diff --git a/nest/route.h b/nest/route.h
index 2e6bf741..8f3c7c9a 100644
--- a/nest/route.h
+++ b/nest/route.h
@@ -47,7 +47,7 @@ struct fib_iterator {			/* See lib/slists.h for an explanation */
   byte efef;				/* 0xff to distinguish between iterator and node */
   byte pad[3];
   struct fib_node *node;		/* Or NULL if freshly merged */
-  unsigned int hash;
+  uint hash;
 };
 
 typedef void (*fib_init_func)(struct fib_node *);
@@ -56,11 +56,11 @@ struct fib {
   pool *fib_pool;			/* Pool holding all our data */
   slab *fib_slab;			/* Slab holding all fib nodes */
   struct fib_node **hash_table;		/* Node hash table */
-  unsigned int hash_size;		/* Number of hash table entries (a power of two) */
-  unsigned int hash_order;		/* Binary logarithm of hash_size */
-  unsigned int hash_shift;		/* 16 - hash_log */
-  unsigned int entries;			/* Number of entries */
-  unsigned int entries_min, entries_max;/* Entry count limits (else start rehashing) */
+  uint hash_size;			/* Number of hash table entries (a power of two) */
+  uint hash_order;			/* Binary logarithm of hash_size */
+  uint hash_shift;			/* 16 - hash_log */
+  uint entries;				/* Number of entries */
+  uint entries_min, entries_max;	/* Entry count limits (else start rehashing) */
   fib_init_func init;			/* Constructor */
 };
 
@@ -78,7 +78,7 @@ void fit_put(struct fib_iterator *, struct fib_node *);
 
 #define FIB_WALK(fib, z) do {					\
 	struct fib_node *z, **ff = (fib)->hash_table;		\
-	unsigned int count = (fib)->hash_size;			\
+	uint count = (fib)->hash_size;				\
 	while (count--)						\
 	  for(z = *ff++; z; z=z->next)
 
@@ -88,8 +88,8 @@ void fit_put(struct fib_iterator *, struct fib_node *);
 
 #define FIB_ITERATE_START(fib, it, z) do {			\
 	struct fib_node *z = fit_get(fib, it);			\
-	unsigned int count = (fib)->hash_size;			\
-	unsigned int hpos = (it)->hash;				\
+	uint count = (fib)->hash_size;				\
+	uint hpos = (it)->hash;					\
 	for(;;) {						\
 	  if (!z)						\
             {							\
@@ -435,7 +435,7 @@ typedef struct eattr {
 #define EAF_TEMP 0x80			/* A temporary attribute (the one stored in the tmp attr list) */
 
 struct adata {
-  unsigned int length;			/* Length of data */
+  uint length;				/* Length of data */
   byte data[0];
 };
 
@@ -475,7 +475,7 @@ void ea_sort(ea_list *);		/* Sort entries in all sub-lists */
 unsigned ea_scan(ea_list *);		/* How many bytes do we need for merged ea_list */
 void ea_merge(ea_list *from, ea_list *to); /* Merge sub-lists to allocated buffer */
 int ea_same(ea_list *x, ea_list *y);	/* Test whether two ea_lists are identical */
-unsigned int ea_hash(ea_list *e);	/* Calculate 16-bit hash value */
+uint ea_hash(ea_list *e);	/* Calculate 16-bit hash value */
 ea_list *ea_append(ea_list *to, ea_list *what);
 void ea_format_bitfield(struct eattr *a, byte *buf, int bufsize, const char **names, int min, int max);
 
diff --git a/nest/rt-attr.c b/nest/rt-attr.c
index c5537208..85a192c8 100644
--- a/nest/rt-attr.c
+++ b/nest/rt-attr.c
@@ -98,7 +98,7 @@ rte_src_init(void)
   HASH_INIT(src_hash, rta_pool, RSH_INIT_ORDER);
 }
 
-static inline int u32_cto(unsigned int x) { return ffs(~x) - 1; }
+static inline int u32_cto(uint x) { return ffs(~x) - 1; }
 
 static inline u32
 rte_src_alloc_id(void)
@@ -195,10 +195,10 @@ rt_prune_sources(void)
  *	Multipath Next Hop
  */
 
-static inline unsigned int
+static inline uint
 mpnh_hash(struct mpnh *x)
 {
-  unsigned int h = 0;
+  uint h = 0;
   for (; x; x = x->next)
     h ^= ipa_hash(x->gw);
 
@@ -666,7 +666,7 @@ ea_format_bitfield(struct eattr *a, byte *buf, int bufsize, const char **names,
 }
 
 static inline void
-opaque_format(struct adata *ad, byte *buf, unsigned int size)
+opaque_format(struct adata *ad, byte *buf, uint size)
 {
   byte *bound = buf + size - 10;
   int i;
@@ -838,7 +838,7 @@ ea_dump(ea_list *e)
  * ea_hash() takes an extended attribute list and calculated a hopefully
  * uniformly distributed hash value from its contents.
  */
-inline unsigned int
+inline uint
 ea_hash(ea_list *e)
 {
   u32 h = 0;
@@ -900,10 +900,10 @@ ea_append(ea_list *to, ea_list *what)
  *	rta's
  */
 
-static unsigned int rta_cache_count;
-static unsigned int rta_cache_size = 32;
-static unsigned int rta_cache_limit;
-static unsigned int rta_cache_mask;
+static uint rta_cache_count;
+static uint rta_cache_size = 32;
+static uint rta_cache_limit;
+static uint rta_cache_mask;
 static rta **rta_hash_table;
 
 static void
@@ -917,7 +917,7 @@ rta_alloc_hash(void)
   rta_cache_mask = rta_cache_size - 1;
 }
 
-static inline unsigned int
+static inline uint
 rta_hash(rta *a)
 {
   return (((uint) (uintptr_t) a->src) ^ ipa_hash(a->gw) ^
@@ -957,7 +957,7 @@ rta_copy(rta *o)
 static inline void
 rta_insert(rta *r)
 {
-  unsigned int h = r->hash_key & rta_cache_mask;
+  uint h = r->hash_key & rta_cache_mask;
   r->next = rta_hash_table[h];
   if (r->next)
     r->next->pprev = &r->next;
@@ -968,8 +968,8 @@ rta_insert(rta *r)
 static void
 rta_rehash(void)
 {
-  unsigned int ohs = rta_cache_size;
-  unsigned int h;
+  uint ohs = rta_cache_size;
+  uint h;
   rta *r, *n;
   rta **oht = rta_hash_table;
 
@@ -1002,7 +1002,7 @@ rta *
 rta_lookup(rta *o)
 {
   rta *r;
-  unsigned int h;
+  uint h;
 
   ASSERT(!(o->aflags & RTAF_CACHED));
   if (o->eattrs)
@@ -1093,7 +1093,7 @@ void
 rta_dump_all(void)
 {
   rta *a;
-  unsigned int h;
+  uint h;
 
   debug("Route attribute cache (%d entries, rehash at %d):\n", rta_cache_count, rta_cache_limit);
   for(h=0; h<rta_cache_size; h++)
diff --git a/nest/rt-fib.c b/nest/rt-fib.c
index b9c7d2a2..aa5e2357 100644
--- a/nest/rt-fib.c
+++ b/nest/rt-fib.c
@@ -206,7 +206,7 @@ fib_histogram(struct fib *f)
 void *
 fib_get(struct fib *f, ip_addr *a, int len)
 {
-  unsigned int h = ipa_hash(*a);
+  uint h = ipa_hash(*a);
   struct fib_node **ee = f->hash_table + (h >> f->hash_shift);
   struct fib_node *g, *e = *ee;
   u32 uid = h << 16;
@@ -321,7 +321,7 @@ void
 fib_delete(struct fib *f, void *E)
 {
   struct fib_node *e = E;
-  unsigned int h = fib_hash(f, &e->prefix);
+  uint h = fib_hash(f, &e->prefix);
   struct fib_node **ee = f->hash_table + h;
   struct fib_iterator *it;
 
@@ -442,7 +442,7 @@ fit_put(struct fib_iterator *i, struct fib_node *n)
 void
 fib_check(struct fib *f)
 {
-  unsigned int i, ec, lo, nulls;
+  uint i, ec, lo, nulls;
 
   ec = 0;
   for(i=0; i<f->hash_size; i++)
@@ -452,7 +452,7 @@ fib_check(struct fib *f)
       for(n=f->hash_table[i]; n; n=n->next)
 	{
 	  struct fib_iterator *j, *j0;
-	  unsigned int h0 = ipa_hash(n->prefix);
+	  uint h0 = ipa_hash(n->prefix);
 	  if (h0 < lo)
 	    bug("fib_check: discord in hash chains");
 	  lo = h0;
@@ -489,7 +489,7 @@ struct fib f;
 
 void dump(char *m)
 {
-  unsigned int i;
+  uint i;
 
   debug("%s ... order=%d, size=%d, entries=%d\n", m, f.hash_order, f.hash_size, f.hash_size);
   for(i=0; i<f.hash_size; i++)
diff --git a/nest/rt-table.c b/nest/rt-table.c
index 24517e2c..d5af41c7 100644
--- a/nest/rt-table.c
+++ b/nest/rt-table.c
@@ -182,14 +182,14 @@ rte_trace(struct proto *p, rte *e, int dir, char *msg)
 }
 
 static inline void
-rte_trace_in(unsigned int flag, struct proto *p, rte *e, char *msg)
+rte_trace_in(uint flag, struct proto *p, rte *e, char *msg)
 {
   if (p->debug & flag)
     rte_trace(p, e, '>', msg);
 }
 
 static inline void
-rte_trace_out(unsigned int flag, struct proto *p, rte *e, char *msg)
+rte_trace_out(uint flag, struct proto *p, rte *e, char *msg)
 {
   if (p->debug & flag)
     rte_trace(p, e, '<', msg);
@@ -1880,7 +1880,7 @@ hc_hash(ip_addr a, rtable *dep)
 static inline void
 hc_insert(struct hostcache *hc, struct hostentry *he)
 {
-  unsigned int k = he->hash_key >> hc->hash_shift;
+  uint k = he->hash_key >> hc->hash_shift;
   he->next = hc->hash_table[k];
   hc->hash_table[k] = he;
 }
@@ -1889,7 +1889,7 @@ static inline void
 hc_remove(struct hostcache *hc, struct hostentry *he)
 {
   struct hostentry **hep;
-  unsigned int k = he->hash_key >> hc->hash_shift;
+  uint k = he->hash_key >> hc->hash_shift;
 
   for (hep = &hc->hash_table[k]; *hep != he; hep = &(*hep)->next);
   *hep = he->next;
@@ -2154,7 +2154,7 @@ rt_get_hostentry(rtable *tab, ip_addr a, ip_addr ll, rtable *dep)
   if (!tab->hostcache)
     rt_init_hostcache(tab);
 
-  unsigned int k = hc_hash(a, dep);
+  uint k = hc_hash(a, dep);
   struct hostcache *hc = tab->hostcache;
   for (he = hc->hash_table[k >> hc->hash_shift]; he != NULL; he = he->next)
     if (ipa_equal(he->addr, a) && (he->tab == dep))
diff --git a/proto/bgp/attrs.c b/proto/bgp/attrs.c
index 72b45d47..d56c017d 100644
--- a/proto/bgp/attrs.c
+++ b/proto/bgp/attrs.c
@@ -114,7 +114,7 @@ path_segment_contains(byte *p, int bs, u32 asn)
 
 /* Validates path attribute, removes AS_CONFED_* segments, and also returns path length */
 static int
-validate_path(struct bgp_proto *p, int as_path, int bs, byte *idata, unsigned int *ilength)
+validate_path(struct bgp_proto *p, int as_path, int bs, byte *idata, uint *ilength)
 {
   int res = 0;
   u8 *a, *dst;
@@ -381,7 +381,7 @@ bgp_attach_attr_wa(ea_list **to, struct linpool *pool, unsigned attr, unsigned l
 }
 
 static int
-bgp_encode_attr_hdr(byte *dst, unsigned int flags, unsigned code, int len)
+bgp_encode_attr_hdr(byte *dst, uint flags, unsigned code, int len)
 {
   int wlen;
 
@@ -473,10 +473,10 @@ bgp_get_attr_len(eattr *a)
  *
  * Result: Length of the attribute block generated or -1 if not enough space.
  */
-unsigned int
+uint
 bgp_encode_attrs(struct bgp_proto *p, byte *w, ea_list *attrs, int remains)
 {
-  unsigned int i, code, type, flags;
+  uint i, code, type, flags;
   byte *start = w;
   int len, rv;
 
@@ -1593,11 +1593,11 @@ bgp_remove_as4_attrs(struct bgp_proto *p, rta *a)
  * by a &rta.
  */
 struct rta *
-bgp_decode_attrs(struct bgp_conn *conn, byte *attr, unsigned int len, struct linpool *pool, int mandatory)
+bgp_decode_attrs(struct bgp_conn *conn, byte *attr, uint len, struct linpool *pool, int mandatory)
 {
   struct bgp_proto *bgp = conn->bgp;
   rta *a = lp_alloc(pool, sizeof(struct rta));
-  unsigned int flags, code, l, i, type;
+  uint flags, code, l, i, type;
   int errcode;
   byte *z, *attr_start;
   byte seen[256/8];
@@ -1791,7 +1791,7 @@ bgp_decode_attrs(struct bgp_conn *conn, byte *attr, unsigned int len, struct lin
 int
 bgp_get_attr(eattr *a, byte *buf, int buflen)
 {
-  unsigned int i = EA_ID(a->id);
+  uint i = EA_ID(a->id);
   struct attr_desc *d;
   int len;
 
diff --git a/proto/bgp/bgp.h b/proto/bgp/bgp.h
index f4f21226..446fc857 100644
--- a/proto/bgp/bgp.h
+++ b/proto/bgp/bgp.h
@@ -90,7 +90,7 @@ struct bgp_config {
 struct bgp_conn {
   struct bgp_proto *bgp;
   struct birdsock *sk;
-  unsigned int state;			/* State of connection state machine */
+  uint state;				/* State of connection state machine */
   struct timer *connect_retry_timer;
   struct timer *hold_timer;
   struct timer *keepalive_timer;
@@ -142,7 +142,7 @@ struct bgp_proto {
   struct timer *startup_timer;		/* Timer used to delay protocol startup due to previous errors (startup_delay) */
   struct timer *gr_timer;		/* Timer waiting for reestablishment after graceful restart */
   struct bgp_bucket **bucket_hash;	/* Hash table of attribute buckets */
-  unsigned int hash_size, hash_count, hash_limit;
+  uint hash_size, hash_count, hash_limit;
   HASH(struct bgp_prefix) prefix_hash;	/* Prefixes to be sent */
   slab *prefix_slab;			/* Slab holding prefix nodes */
   list bucket_queue;			/* Queue of buckets to send */
@@ -235,7 +235,7 @@ static inline void set_next_hop(byte *b, ip_addr addr) { ((ip_addr *) b)[0] = ad
 
 void bgp_attach_attr(struct ea_list **to, struct linpool *pool, unsigned attr, uintptr_t val);
 byte *bgp_attach_attr_wa(struct ea_list **to, struct linpool *pool, unsigned attr, unsigned len);
-struct rta *bgp_decode_attrs(struct bgp_conn *conn, byte *a, unsigned int len, struct linpool *pool, int mandatory);
+struct rta *bgp_decode_attrs(struct bgp_conn *conn, byte *a, uint len, struct linpool *pool, int mandatory);
 int bgp_get_attr(struct eattr *e, byte *buf, int buflen);
 int bgp_rte_better(struct rte *, struct rte *);
 int bgp_rte_recalculate(rtable *table, net *net, rte *new, rte *old, rte *old_best);
@@ -245,7 +245,7 @@ void bgp_init_bucket_table(struct bgp_proto *);
 void bgp_free_bucket(struct bgp_proto *p, struct bgp_bucket *buck);
 void bgp_init_prefix_table(struct bgp_proto *p, u32 order);
 void bgp_free_prefix(struct bgp_proto *p, struct bgp_prefix *bp);
-unsigned int bgp_encode_attrs(struct bgp_proto *p, byte *w, ea_list *attrs, int remains);
+uint bgp_encode_attrs(struct bgp_proto *p, byte *w, ea_list *attrs, int remains);
 void bgp_get_route_info(struct rte *, byte *buf, struct ea_list *attrs);
 
 inline static void bgp_attach_attr_ip(struct ea_list **to, struct linpool *pool, unsigned attr, ip_addr a)
diff --git a/proto/bgp/packets.c b/proto/bgp/packets.c
index 4bd68f52..378f5ab1 100644
--- a/proto/bgp/packets.c
+++ b/proto/bgp/packets.c
@@ -289,8 +289,8 @@ bgp_create_open(struct bgp_conn *conn, byte *buf)
     }
 }
 
-static unsigned int
-bgp_encode_prefixes(struct bgp_proto *p, byte *w, struct bgp_bucket *buck, unsigned int remains)
+static uint
+bgp_encode_prefixes(struct bgp_proto *p, byte *w, struct bgp_bucket *buck, uint remains)
 {
   byte *start = w;
   ip_addr a;
@@ -648,7 +648,7 @@ bgp_create_end_refresh(struct bgp_conn *conn, byte *buf)
 
 
 static void
-bgp_create_header(byte *buf, unsigned int len, unsigned int type)
+bgp_create_header(byte *buf, uint len, uint type)
 {
   memset(buf, 0xff, 16);		/* Marker */
   put_u16(buf+16, len);
@@ -669,7 +669,7 @@ static int
 bgp_fire_tx(struct bgp_conn *conn)
 {
   struct bgp_proto *p = conn->bgp;
-  unsigned int s = conn->packets_to_send;
+  uint s = conn->packets_to_send;
   sock *sk = conn->sk;
   byte *buf, *pkt, *end;
   int type;
diff --git a/sysdep/bsd/krt-sock.c b/sysdep/bsd/krt-sock.c
index aaf3b23c..064bae18 100644
--- a/sysdep/bsd/krt-sock.c
+++ b/sysdep/bsd/krt-sock.c
@@ -181,7 +181,7 @@ struct ks_msg
 #define GETADDR(p, F) \
   bzero(p, sizeof(*p));\
   if ((addrs & (F)) && ((struct sockaddr *)body)->sa_len) {\
-    unsigned int l = ROUNDUP(((struct sockaddr *)body)->sa_len);\
+    uint l = ROUNDUP(((struct sockaddr *)body)->sa_len);\
     memcpy(p, body, (l > sizeof(*p) ? sizeof(*p) : l));\
     body += l;}
 
@@ -537,7 +537,7 @@ krt_read_ifinfo(struct ks_msg *msg, int scan)
   struct if_msghdr *ifm = (struct if_msghdr *)&msg->rtm;
   void *body = (void *)(ifm + 1);
   struct sockaddr_dl *dl = NULL;
-  unsigned int i;
+  uint i;
   struct iface *iface = NULL, f = {};
   int fl = ifm->ifm_flags;
   int nlen = 0;
diff --git a/sysdep/linux/netlink.c b/sysdep/linux/netlink.c
index 71f58554..c4d52255 100644
--- a/sysdep/linux/netlink.c
+++ b/sysdep/linux/netlink.c
@@ -50,7 +50,7 @@ struct nl_sock
   u32 seq;
   byte *rx_buffer;			/* Receive buffer */
   struct nlmsghdr *last_hdr;		/* Recently received packet */
-  unsigned int last_size;
+  uint last_size;
 };
 
 #define NL_RX_SIZE 8192
@@ -443,7 +443,7 @@ nl_parse_link(struct nlmsghdr *h, int scan)
   struct iface *ifi;
   char *name;
   u32 mtu;
-  unsigned int fl;
+  uint fl;
 
   if (!(i = nl_checkin(h, sizeof(*i))) || !nl_parse_attrs(IFLA_RTA(i), a, sizeof(a)))
     return;
@@ -1088,7 +1088,7 @@ nl_async_hook(sock *sk, int size UNUSED)
   struct msghdr m = { (struct sockaddr *) &sa, sizeof(sa), &iov, 1, NULL, 0, 0 };
   struct nlmsghdr *h;
   int x;
-  unsigned int len;
+  uint len;
 
   x = recvmsg(sk->fd, &m, 0);
   if (x < 0)
diff --git a/sysdep/unix/main.c b/sysdep/unix/main.c
index 05f7560d..e31471da 100644
--- a/sysdep/unix/main.c
+++ b/sysdep/unix/main.c
@@ -155,7 +155,7 @@ read_iproute_table(char *file, char *prefix, int max)
 static char *config_name = PATH_CONFIG_FILE;
 
 static int
-cf_read(byte *dest, unsigned int len, int fd)
+cf_read(byte *dest, uint len, int fd)
 {
   int l = read(fd, dest, len);
   if (l < 0)
diff --git a/sysdep/unix/unix.h b/sysdep/unix/unix.h
index 593978cc..4e0ff841 100644
--- a/sysdep/unix/unix.h
+++ b/sysdep/unix/unix.h
@@ -119,7 +119,7 @@ void log_switch(int debug, list *l, char *); /* Use l=NULL for initial switch */
 
 struct log_config {
   node n;
-  unsigned int mask;			/* Classes to log */
+  uint mask;				/* Classes to log */
   void *fh;				/* FILE to log to, NULL=syslog */
   int terminal_flag;
 };

From ca34698ca62d979c281ed517f040619e31c3ada3 Mon Sep 17 00:00:00 2001
From: Ondrej Zajicek <santiago@crfreenet.org>
Date: Sun, 31 May 2015 11:29:53 +0200
Subject: [PATCH 011/165] Fixes bug in pipe feeding when filtered routes are
 kept in table

---
 nest/rt-table.c | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/nest/rt-table.c b/nest/rt-table.c
index d5af41c7..27c6cb76 100644
--- a/nest/rt-table.c
+++ b/nest/rt-table.c
@@ -1816,15 +1816,20 @@ rt_feed_baby(struct proto *p)
 	  {
 	    if (p->export_state != ES_FEEDING)
 	      return 1;  /* In the meantime, the protocol fell down. */
+
 	    do_feed_baby(p, p->accept_ra_types, h, n, e);
 	    max_feed--;
 	  }
 
       if (p->accept_ra_types == RA_ANY)
-	for(e = n->routes; rte_is_valid(e); e = e->next)
+	for(e = n->routes; e; e = e->next)
 	  {
 	    if (p->export_state != ES_FEEDING)
 	      return 1;  /* In the meantime, the protocol fell down. */
+
+	    if (!rte_is_valid(e))
+	      continue;
+
 	    do_feed_baby(p, RA_ANY, h, n, e);
 	    max_feed--;
 	  }

From d217ba5111a80a629e408961b902d7759c4b46f5 Mon Sep 17 00:00:00 2001
From: Ondrej Zajicek <santiago@crfreenet.org>
Date: Sun, 31 May 2015 23:25:33 +0200
Subject: [PATCH 012/165] Moving of mulipath merging code from OSPF to nest

---
 nest/route.h          |   1 +
 nest/rt-attr.c        |  94 ++++++++++++++++++++++++++++++++++++--
 proto/ospf/rt.c       | 104 ++++++------------------------------------
 proto/ospf/rt.h       |   3 +-
 proto/ospf/topology.h |   2 +-
 5 files changed, 110 insertions(+), 94 deletions(-)

diff --git a/nest/route.h b/nest/route.h
index 8f3c7c9a..e22f950b 100644
--- a/nest/route.h
+++ b/nest/route.h
@@ -482,6 +482,7 @@ void ea_format_bitfield(struct eattr *a, byte *buf, int bufsize, const char **na
 int mpnh__same(struct mpnh *x, struct mpnh *y); /* Compare multipath nexthops */
 static inline int mpnh_same(struct mpnh *x, struct mpnh *y)
 { return (x == y) || mpnh__same(x, y); }
+struct mpnh *mpnh_merge(struct mpnh *x, struct mpnh *y, int rx, int ry, int max, linpool *lp);
 
 void rta_init(void);
 rta *rta_lookup(rta *);			/* Get rta equivalent to this one, uc++ */
diff --git a/nest/rt-attr.c b/nest/rt-attr.c
index 85a192c8..32090b52 100644
--- a/nest/rt-attr.c
+++ b/nest/rt-attr.c
@@ -167,7 +167,7 @@ rt_get_source(struct proto *p, u32 id)
   src->private_id = id;
   src->global_id = rte_src_alloc_id();
   src->uc = 0;
-  
+
   HASH_INSERT2(src_hash, RSH, rta_pool, src);
 
   return src;
@@ -215,6 +215,94 @@ mpnh__same(struct mpnh *x, struct mpnh *y)
   return x == y;
 }
 
+static int
+mpnh_compare_node(struct mpnh *x, struct mpnh *y)
+{
+  int r;
+
+  if (!x)
+    return 1;
+
+  if (!y)
+    return -1;
+
+  r = ((int) y->weight) - ((int) x->weight);
+  if (r)
+    return r;
+
+  r = ipa_compare(x->gw, y->gw);
+  if (r)
+    return r;
+
+  return ((int) x->iface->index) - ((int) y->iface->index);
+}
+
+static inline struct mpnh *
+mpnh_copy_node(const struct mpnh *src, linpool *lp)
+{
+  struct mpnh *n = lp_alloc(lp, sizeof(struct mpnh));
+  n->gw = src->gw;
+  n->iface = src->iface;
+  n->next = NULL;
+  n->weight = src->weight;
+  return n;
+}
+
+/**
+ * mpnh_merge - merge nexthop lists
+ * @x: list 1
+ * @y: list 2
+ * @rx: reusability of list @x
+ * @ry: reusability of list @y
+ * @max: max number of nexthops
+ * @lp: linpool for allocating nexthops
+ *
+ * The mpnh_merge() function takes two nexthop lists @x and @y and merges them,
+ * eliminating possible duplicates. The input lists must be sorted and the
+ * result is sorted too. The number of nexthops in result is limited by @max.
+ * New nodes are allocated from linpool @lp.
+ *
+ * The arguments @rx and @ry specify whether corresponding input lists may be
+ * consumed by the function (i.e. their nodes reused in the resulting list), in
+ * that case the caller should not access these lists after that. To eliminate
+ * issues with deallocation of these lists, the caller should use some form of
+ * bulk deallocation (e.g. stack or linpool) to free these nodes when the
+ * resulting list is no longer needed. When reusability is not set, the
+ * corresponding lists are not modified nor linked from the resulting list.
+ */
+struct mpnh *
+mpnh_merge(struct mpnh *x, struct mpnh *y, int rx, int ry, int max, linpool *lp)
+{
+  struct mpnh *root = NULL;
+  struct mpnh **n = &root;
+
+  while ((x || y) && max--)
+  {
+    int cmp = mpnh_compare_node(x, y);
+    if (cmp < 0)
+    {
+      *n = rx ? x : mpnh_copy_node(x, lp);
+      x = x->next;
+    }
+    else if (cmp > 0)
+    {
+      *n = ry ? y : mpnh_copy_node(y, lp);
+      y = y->next;
+    }
+    else
+    {
+      *n = rx ? x : (ry ? y : mpnh_copy_node(x, lp));
+      x = x->next;
+      y = y->next;
+    }
+    n = &((*n)->next);
+  }
+  *n = NULL;
+
+  return root;
+}
+
+
 static struct mpnh *
 mpnh_copy(struct mpnh *o)
 {
@@ -635,7 +723,7 @@ get_generic_attr(eattr *a, byte **buf, int buflen UNUSED)
       *buf += bsprintf(*buf, "igp_metric");
       return GA_NAME;
     }
- 
+
   return GA_UNKNOWN;
 }
 
@@ -741,7 +829,7 @@ ea_show(struct cli *c, eattr *e)
     }
   else if (EA_PROTO(e->id))
     pos += bsprintf(pos, "%02x.", EA_PROTO(e->id));
-  else 
+  else
     status = get_generic_attr(e, &pos, end - pos);
 
   if (status < GA_NAME)
diff --git a/proto/ospf/rt.c b/proto/ospf/rt.c
index e74bcae6..cdf8012a 100644
--- a/proto/ospf/rt.c
+++ b/proto/ospf/rt.c
@@ -53,88 +53,6 @@ new_nexthop(struct ospf_proto *p, ip_addr gw, struct iface *iface, byte weight)
   return nh;
 }
 
-static inline struct mpnh *
-copy_nexthop(struct ospf_proto *p, const struct mpnh *src)
-{
-  struct mpnh *nh = lp_alloc(p->nhpool, sizeof(struct mpnh));
-  nh->gw = src->gw;
-  nh->iface = src->iface;
-  nh->next = NULL;
-  nh->weight = src->weight;
-  return nh;
-}
-
-/* Compare nexthops during merge.
-   We need to maintain nhs sorted to eliminate duplicities */
-static int
-cmp_nhs(struct mpnh *s1, struct mpnh *s2)
-{
-  int r;
-
-  if (!s1)
-    return 1;
-
-  if (!s2)
-    return -1;
-
-  r = ((int) s2->weight) - ((int) s1->weight);
-  if (r)
-    return r;
-
-  r = ipa_compare(s1->gw, s2->gw);
-  if (r)
-    return r;
-
-  return ((int) s1->iface->index) - ((int) s2->iface->index);
-}
-
-static struct mpnh *
-merge_nexthops(struct ospf_proto *p, struct mpnh *s1, struct mpnh *s2, int r1, int r2)
-{
-  struct mpnh *root = NULL;
-  struct mpnh **n = &root;
-  int count = p->ecmp;
-
-  ASSERT(p->ecmp);
-
-  /*
-   * r1, r2 signalize whether we can reuse nexthops from s1, s2.
-   * New nexthops (s2, new) can be reused if they are not inherited
-   * from the parent (i.e. it is allocated in calc_next_hop()).
-   * Current nexthops (s1, en->nhs) can be reused if they weren't
-   * inherited in previous steps (that is stored in nhs_reuse,
-   * i.e. created by merging or allocalted in calc_next_hop()).
-   *
-   * Generally, a node first inherits shared nexthops from its
-   * parent and later possibly gets reusable copy during merging.
-   */
-
-  while ((s1 || s2) && count--)
-  {
-    int cmp = cmp_nhs(s1, s2);
-    if (cmp < 0)
-    {
-      *n = r1 ? s1 : copy_nexthop(p, s1);
-      s1 = s1->next;
-    }
-    else if (cmp > 0)
-    {
-      *n = r2 ? s2 : copy_nexthop(p, s2);
-      s2 = s2->next;
-    }
-    else
-    {
-      *n = r1 ? s1 : (r2 ? s2 : copy_nexthop(p, s1));
-      s1 = s1->next;
-      s2 = s2->next;
-    }
-    n = &((*n)->next);
-  }
-  *n = NULL;
-
-  return root;
-}
-
 /* Returns true if there are device nexthops in n */
 static inline int
 has_device_nexthops(const struct mpnh *n)
@@ -178,7 +96,7 @@ fix_device_nexthops(struct ospf_proto *p, const struct mpnh *n, ip_addr gw)
     }
   }
 
-  return merge_nexthops(p, root1, root2, 1, 1);
+  return mpnh_merge(root1, root2, 1, 1, p->ecmp, p->nhpool);
 }
 
 
@@ -374,7 +292,8 @@ ort_merge(struct ospf_proto *p, ort *o, const orta *new)
 
   if (old->nhs != new->nhs)
   {
-    old->nhs = merge_nexthops(p, old->nhs, new->nhs, old->nhs_reuse, new->nhs_reuse);
+    old->nhs = mpnh_merge(old->nhs, new->nhs, old->nhs_reuse, new->nhs_reuse,
+			  p->ecmp, p->nhpool);
     old->nhs_reuse = 1;
   }
 
@@ -389,7 +308,8 @@ ort_merge_ext(struct ospf_proto *p, ort *o, const orta *new)
 
   if (old->nhs != new->nhs)
   {
-    old->nhs = merge_nexthops(p, old->nhs, new->nhs, old->nhs_reuse, new->nhs_reuse);
+    old->nhs = mpnh_merge(old->nhs, new->nhs, old->nhs_reuse, new->nhs_reuse,
+			  p->ecmp, p->nhpool);
     old->nhs_reuse = 1;
   }
 
@@ -1885,8 +1805,7 @@ add_cand(list * l, struct top_hash_entry *en, struct top_hash_entry *par,
     return;
   }
 
-  /* We know that en->color == CANDIDATE and en->nhs is defined. */
-
+  /* If en->dist > 0, we know that en->color == CANDIDATE and en->nhs is defined. */
   if ((dist == en->dist) && !nh_is_vlink(en->nhs))
   {
     /*
@@ -1900,7 +1819,14 @@ add_cand(list * l, struct top_hash_entry *en, struct top_hash_entry *par,
      * allocated in calc_next_hop()).
      *
      * Generally, a node first inherits shared nexthops from its parent and
-     * later possibly gets reusable copy during merging.
+     * later possibly gets reusable (private) copy during merging. This is more
+     * or less same for both top_hash_entry nodes and orta nodes.
+     *
+     * Note that when a child inherits a private nexthop from its parent, it
+     * should make the nexthop shared for both parent and child, while we only
+     * update nhs_reuse for the child node. This makes nhs_reuse field for the
+     * parent technically incorrect, but it is not a problem as parent's nhs
+     * will not be modified (and nhs_reuse examined) afterwards.
      */
 
     /* Keep old ones */
@@ -1909,7 +1835,7 @@ add_cand(list * l, struct top_hash_entry *en, struct top_hash_entry *par,
 
     /* Merge old and new */
     int new_reuse = (par->nhs != nhs);
-    en->nhs = merge_nexthops(p, en->nhs, nhs, en->nhs_reuse, new_reuse);
+    en->nhs = mpnh_merge(en->nhs, nhs, en->nhs_reuse, new_reuse, p->ecmp, p->nhpool);
     en->nhs_reuse = 1;
     return;
   }
diff --git a/proto/ospf/rt.h b/proto/ospf/rt.h
index 61936f3c..30332f3b 100644
--- a/proto/ospf/rt.h
+++ b/proto/ospf/rt.h
@@ -18,7 +18,8 @@
 typedef struct orta
 {
   u8 type;			/* RTS_OSPF_* */
-  u8 nhs_reuse;			/* Whether nhs nodes can be reused during merging */
+  u8 nhs_reuse;			/* Whether nhs nodes can be reused during merging.
+				   See a note in rt.c:add_cand() */
   u32 options;
   /*
    * For ORT_ROUTER routes, options field are router-LSA style
diff --git a/proto/ospf/topology.h b/proto/ospf/topology.h
index e2d6c773..5652ced0 100644
--- a/proto/ospf/topology.h
+++ b/proto/ospf/topology.h
@@ -39,7 +39,7 @@ struct top_hash_entry
 #define INSPF 2
   u8 mode;			/* LSA generated during RT calculation (LSA_RTCALC or LSA_STALE)*/
   u8 nhs_reuse;			/* Whether nhs nodes can be reused during merging.
-				   See a note in rt.c:merge_nexthops() */
+				   See a note in rt.c:add_cand() */
 };
 
 

From 78a2cc289fbe11d5b5783220e2cc61d119a78ec3 Mon Sep 17 00:00:00 2001
From: Ondrej Zajicek <santiago@crfreenet.org>
Date: Wed, 3 Jun 2015 11:58:46 +0200
Subject: [PATCH 013/165] KRT: Fixes some minor bugs in kernel protocol

---
 sysdep/linux/netlink.c |   5 ++
 sysdep/unix/krt.c      | 107 +++++++++++++++++++++++++----------------
 2 files changed, 71 insertions(+), 41 deletions(-)

diff --git a/sysdep/linux/netlink.c b/sysdep/linux/netlink.c
index c4d52255..9f206e1c 100644
--- a/sysdep/linux/netlink.c
+++ b/sysdep/linux/netlink.c
@@ -703,6 +703,11 @@ nl_send_route(struct krt_proto *p, rte *e, struct ea_list *eattrs, int new)
   r.r.rtm_scope = RT_SCOPE_UNIVERSE;
   nl_add_attr_ipa(&r.h, sizeof(r), RTA_DST, net->n.prefix);
 
+  /* For route delete, we do not specify route attributes */
+  if (!new)
+    return nl_exchange(&r.h);
+
+
   if (ea = ea_find(eattrs, EA_KRT_METRIC))
     nl_add_attr_u32(&r.h, sizeof(r), RTA_PRIORITY, ea->u.data);
 
diff --git a/sysdep/unix/krt.c b/sysdep/unix/krt.c
index cfb623ce..d8d28c7c 100644
--- a/sysdep/unix/krt.c
+++ b/sysdep/unix/krt.c
@@ -592,6 +592,44 @@ krt_flush_routes(struct krt_proto *p)
   FIB_WALK_END;
 }
 
+static struct rte *
+krt_export_net(struct krt_proto *p, net *net, rte **rt_free, ea_list **tmpa)
+{
+  struct filter *filter = p->p.main_ahook->out_filter;
+  rte *rt;
+
+  rt = net->routes;
+  *rt_free = NULL;
+
+  if (!rte_is_valid(rt))
+    return NULL;
+
+  if (filter == FILTER_REJECT)
+    return NULL;
+
+  struct proto *src = rt->attrs->src->proto;
+  *tmpa = src->make_tmp_attrs ? src->make_tmp_attrs(rt, krt_filter_lp) : NULL;
+
+  /* We could run krt_import_control() here, but it is already handled by KRF_INSTALLED */
+
+  if (filter == FILTER_ACCEPT)
+    goto accept;
+
+  if (f_run(filter, &rt, tmpa, krt_filter_lp, FF_FORCE_TMPATTR) > F_ACCEPT)
+    goto reject;
+
+
+accept:
+  if (rt != net->routes)
+    *rt_free = rt;
+  return rt;
+
+reject:
+  if (rt != net->routes)
+    rte_free(rt);
+  return NULL;
+}
+
 static int
 krt_same_dest(rte *k, rte *e)
 {
@@ -620,7 +658,6 @@ krt_same_dest(rte *k, rte *e)
 void
 krt_got_route(struct krt_proto *p, rte *e)
 {
-  rte *old;
   net *net = e->net;
   int verdict;
 
@@ -663,15 +700,26 @@ krt_got_route(struct krt_proto *p, rte *e)
       goto sentenced;
     }
 
-  old = net->routes;
-  if ((net->n.flags & KRF_INSTALLED) && rte_is_valid(old))
+  if (net->n.flags & KRF_INSTALLED)
     {
-      /* There may be changes in route attributes, we ignore that.
-         Also, this does not work well if gw is changed in export filter */
-      if ((net->n.flags & KRF_SYNC_ERROR) || ! krt_same_dest(e, old))
+      rte *new, *rt_free;
+      ea_list *tmpa;
+
+      new = krt_export_net(p, net, &rt_free, &tmpa);
+
+      /* TODO: There also may be changes in route eattrs, we ignore that for now. */
+
+      if (!new)
+	verdict = KRF_DELETE;
+      else if ((net->n.flags & KRF_SYNC_ERROR) || !krt_same_dest(e, new))
 	verdict = KRF_UPDATE;
       else
 	verdict = KRF_SEEN;
+
+      if (rt_free)
+	rte_free(rt_free);
+
+      lp_flush(krt_filter_lp);
     }
   else
     verdict = KRF_DELETE;
@@ -692,25 +740,6 @@ krt_got_route(struct krt_proto *p, rte *e)
     rte_free(e);
 }
 
-static inline int
-krt_export_rte(struct krt_proto *p, rte **new, ea_list **tmpa)
-{
-  struct filter *filter = p->p.main_ahook->out_filter;
-
-  if (! *new)
-    return 0;
-
-  if (filter == FILTER_REJECT)
-    return 0;
-
-  if (filter == FILTER_ACCEPT)
-    return 1;
-
-  struct proto *src = (*new)->attrs->src->proto;
-  *tmpa = src->make_tmp_attrs ? src->make_tmp_attrs(*new, krt_filter_lp) : NULL;
-  return f_run(filter, new, tmpa, krt_filter_lp, FF_FORCE_TMPATTR) <= F_ACCEPT;
-}
-
 static void
 krt_prune(struct krt_proto *p)
 {
@@ -721,7 +750,7 @@ krt_prune(struct krt_proto *p)
     {
       net *n = (net *) f;
       int verdict = f->flags & KRF_VERDICT_MASK;
-      rte *new, *new0, *old;
+      rte *new, *old, *rt_free = NULL;
       ea_list *tmpa = NULL;
 
       if (verdict == KRF_UPDATE || verdict == KRF_DELETE)
@@ -733,23 +762,18 @@ krt_prune(struct krt_proto *p)
       else
 	old = NULL;
 
-      new = new0 = n->routes;
       if (verdict == KRF_CREATE || verdict == KRF_UPDATE)
 	{
 	  /* We have to run export filter to get proper 'new' route */
-	  if (! krt_export_rte(p, &new, &tmpa))
-	    {
-	      /* Route rejected, should not happen (KRF_INSTALLED) but to be sure .. */
-	      verdict = (verdict == KRF_CREATE) ? KRF_IGNORE : KRF_DELETE;
-	    }
+	  new = krt_export_net(p, n, &rt_free, &tmpa);
+
+	  if (!new)
+	    verdict = (verdict == KRF_CREATE) ? KRF_IGNORE : KRF_DELETE;
 	  else
-	    {
-	      ea_list **x = &tmpa;
-	      while (*x)
-		x = &((*x)->next);
-	      *x = new ? new->attrs->eattrs : NULL;
-	    }
+	    tmpa = ea_append(tmpa, new->attrs->eattrs);
 	}
+      else
+	new = NULL;
 
       switch (verdict)
 	{
@@ -778,8 +802,8 @@ krt_prune(struct krt_proto *p)
 
       if (old)
 	rte_free(old);
-      if (new != new0)
-	rte_free(new);
+      if (rt_free)
+	rte_free(rt_free);
       lp_flush(krt_filter_lp);
       f->flags &= ~KRF_VERDICT_MASK;
     }
@@ -974,7 +998,8 @@ krt_import_control(struct proto *P, rte **new, ea_list **attrs, struct linpool *
      * We will remove KRT_INSTALLED flag, which stops such withdraw to be
      * processed in krt_rt_notify() and krt_replace_rte().
      */
-    e->net->n.flags &= ~KRF_INSTALLED;
+    if (e == e->net->routes)
+      e->net->n.flags &= ~KRF_INSTALLED;
 #endif
     return -1;
   }

From db027a41d47b8fc52b65067ccabe2024554e53ca Mon Sep 17 00:00:00 2001
From: Ondrej Zajicek <santiago@crfreenet.org>
Date: Thu, 4 Jun 2015 11:35:26 +0200
Subject: [PATCH 014/165] Fixes subtle bug in temporary attribute handling

In some cases, export filter accessed attributes of a different route.
---
 nest/rt-table.c | 49 ++++++++++++++++++++-----------------------------
 1 file changed, 20 insertions(+), 29 deletions(-)

diff --git a/nest/rt-table.c b/nest/rt-table.c
index 27c6cb76..22e1c489 100644
--- a/nest/rt-table.c
+++ b/nest/rt-table.c
@@ -208,12 +208,10 @@ export_filter(struct announce_hook *ah, rte *rt0, rte **rt_free, ea_list **tmpa,
   rt = rt0;
   *rt_free = NULL;
 
-  /* If called does not care for eattrs, we prepare one internally */
   if (!tmpa)
-    {
-      tmpb = make_tmp_attrs(rt, rte_update_pool);
-      tmpa = &tmpb;
-    }
+    tmpa = &tmpb;
+
+  *tmpa = make_tmp_attrs(rt, rte_update_pool);
 
   v = p->import_control ? p->import_control(p, &rt, tmpa, rte_update_pool) : 0;
   if (v < 0)
@@ -347,7 +345,7 @@ do_rt_notify(struct announce_hook *ah, net *net, rte *new, rte *old, ea_list *tm
 }
 
 static void
-rt_notify_basic(struct announce_hook *ah, net *net, rte *new0, rte *old0, ea_list *tmpa, int refeed)
+rt_notify_basic(struct announce_hook *ah, net *net, rte *new0, rte *old0, int refeed)
 {
   struct proto *p = ah->proto;
   struct proto_stats *stats = ah->stats;
@@ -356,6 +354,7 @@ rt_notify_basic(struct announce_hook *ah, net *net, rte *new0, rte *old0, ea_lis
   rte *old = old0;
   rte *new_free = NULL;
   rte *old_free = NULL;
+  ea_list *tmpa = NULL;
 
   if (new)
     stats->exp_updates_received++;
@@ -419,17 +418,17 @@ rt_notify_basic(struct announce_hook *ah, net *net, rte *new0, rte *old0, ea_lis
 }
 
 static void
-rt_notify_accepted(struct announce_hook *ah, net *net, rte *new_changed, rte *old_changed, rte *before_old,
-		   ea_list *tmpa, int feed)
+rt_notify_accepted(struct announce_hook *ah, net *net, rte *new_changed, rte *old_changed, rte *before_old, int feed)
 {
   // struct proto *p = ah->proto;
   struct proto_stats *stats = ah->stats;
 
+  rte *r;
   rte *new_best = NULL;
   rte *old_best = NULL;
   rte *new_free = NULL;
   rte *old_free = NULL;
-  rte *r;
+  ea_list *tmpa = NULL;
 
   /* Used to track whether we met old_changed position. If before_old is NULL
      old_changed was the first and we met it implicitly before current best route. */
@@ -543,7 +542,6 @@ rt_notify_accepted(struct announce_hook *ah, net *net, rte *new_changed, rte *ol
  * @net: network in question
  * @new: the new route to be announced
  * @old: the previous route for the same network
- * @tmpa: a list of temporary attributes belonging to the new route
  *
  * This function gets a routing table update and announces it
  * to all protocols that acccepts given type of route announcement
@@ -566,7 +564,7 @@ rt_notify_accepted(struct announce_hook *ah, net *net, rte *new_changed, rte *ol
  * the protocol gets called.
  */
 static void
-rte_announce(rtable *tab, unsigned type, net *net, rte *new, rte *old, rte *before_old, ea_list *tmpa)
+rte_announce(rtable *tab, unsigned type, net *net, rte *new, rte *old, rte *before_old)
 {
   if (!rte_is_valid(old))
     old = before_old = NULL;
@@ -594,9 +592,9 @@ rte_announce(rtable *tab, unsigned type, net *net, rte *new, rte *old, rte *befo
       ASSERT(a->proto->export_state != ES_DOWN);
       if (a->proto->accept_ra_types == type)
 	if (type == RA_ACCEPTED)
-	  rt_notify_accepted(a, net, new, old, before_old, tmpa, 0);
+	  rt_notify_accepted(a, net, new, old, before_old, 0);
 	else
-	  rt_notify_basic(a, net, new, old, tmpa, 0);
+	  rt_notify_basic(a, net, new, old, 0);
     }
 }
 
@@ -659,7 +657,7 @@ rte_same(rte *x, rte *y)
 static inline int rte_is_ok(rte *e) { return e && !rte_is_filtered(e); }
 
 static void
-rte_recalculate(struct announce_hook *ah, net *net, rte *new, ea_list *tmpa, struct rte_src *src)
+rte_recalculate(struct announce_hook *ah, net *net, rte *new, struct rte_src *src)
 {
   struct proto *p = ah->proto;
   struct rtable *table = ah->table;
@@ -900,11 +898,11 @@ rte_recalculate(struct announce_hook *ah, net *net, rte *new, ea_list *tmpa, str
     }
 
   /* Propagate the route change */
-  rte_announce(table, RA_ANY, net, new, old, NULL, tmpa);
+  rte_announce(table, RA_ANY, net, new, old, NULL);
   if (net->routes != old_best)
-    rte_announce(table, RA_OPTIMAL, net, net->routes, old_best, NULL, tmpa);
+    rte_announce(table, RA_OPTIMAL, net, net->routes, old_best, NULL);
   if (table->config->sorted)
-    rte_announce(table, RA_ACCEPTED, net, new, old, before_old, tmpa);
+    rte_announce(table, RA_ACCEPTED, net, new, old, before_old);
 
   if (!net->routes &&
       (table->gc_counter++ >= table->config->gc_max_ops) &&
@@ -1069,7 +1067,7 @@ rte_update2(struct announce_hook *ah, net *net, rte *new, struct rte_src *src)
 
  recalc:
   rte_hide_dummy_routes(net, &dummy);
-  rte_recalculate(ah, net, new, tmpa, src);
+  rte_recalculate(ah, net, new, src);
   rte_unhide_dummy_routes(net, &dummy);
   rte_update_unlock();
   return;
@@ -1077,7 +1075,6 @@ rte_update2(struct announce_hook *ah, net *net, rte *new, struct rte_src *src)
  drop:
   rte_free(new);
   new = NULL;
-  tmpa = NULL;
   goto recalc;
 }
 
@@ -1086,11 +1083,8 @@ rte_update2(struct announce_hook *ah, net *net, rte *new, struct rte_src *src)
 static inline void 
 rte_announce_i(rtable *tab, unsigned type, net *n, rte *new, rte *old)
 {
-  ea_list *tmpa;
-
   rte_update_lock();
-  tmpa = make_tmp_attrs(new, rte_update_pool);
-  rte_announce(tab, type, n, new, old, NULL, tmpa);
+  rte_announce(tab, type, n, new, old, NULL);
   rte_update_unlock();
 }
 
@@ -1098,7 +1092,7 @@ void
 rte_discard(rtable *t, rte *old)	/* Non-filtered route deletion, used during garbage collection */
 {
   rte_update_lock();
-  rte_recalculate(old->sender, old->net, NULL, NULL, old->attrs->src);
+  rte_recalculate(old->sender, old->net, NULL, old->attrs->src);
   rte_update_unlock();
 }
 
@@ -1758,14 +1752,11 @@ rt_commit(struct config *new, struct config *old)
 static inline void
 do_feed_baby(struct proto *p, int type, struct announce_hook *h, net *n, rte *e)
 {
-  ea_list *tmpa;
-
   rte_update_lock();
-  tmpa = make_tmp_attrs(e, rte_update_pool);
   if (type == RA_ACCEPTED)
-    rt_notify_accepted(h, n, e, NULL, NULL, tmpa, p->refeeding ? 2 : 1);
+    rt_notify_accepted(h, n, e, NULL, NULL, p->refeeding ? 2 : 1);
   else
-    rt_notify_basic(h, n, e, p->refeeding ? e : NULL, tmpa, p->refeeding);
+    rt_notify_basic(h, n, e, p->refeeding ? e : NULL, p->refeeding);
   rte_update_unlock();
 }
 

From 8d9eef17713a9b38cd42bd59c4ce76c3ef6c2fc2 Mon Sep 17 00:00:00 2001
From: Ondrej Zajicek <santiago@crfreenet.org>
Date: Mon, 8 Jun 2015 02:20:43 +0200
Subject: [PATCH 015/165] BGP multipath support

Kernel option 'merge paths' allows to merge routes exported to kernel
protocol (currently BGP and static routes) to multipath routes.
---
 doc/bird.sgml         |  12 +++
 filter/filter.c       |  36 +++----
 lib/birdlib.h         |   1 +
 nest/protocol.h       |   3 +
 nest/route.h          |  11 ++
 nest/rt-attr.c        |  10 ++
 nest/rt-table.c       | 228 +++++++++++++++++++++++++++++++++++++++---
 proto/bgp/attrs.c     |  76 ++++++++++++++
 proto/bgp/bgp.c       |   1 +
 proto/bgp/bgp.h       |   1 +
 proto/static/static.c |   7 ++
 sysdep/unix/krt.Y     |   4 +-
 sysdep/unix/krt.c     |  17 +++-
 sysdep/unix/krt.h     |   3 +
 14 files changed, 371 insertions(+), 39 deletions(-)

diff --git a/doc/bird.sgml b/doc/bird.sgml
index 1c2dda4b..752465b9 100644
--- a/doc/bird.sgml
+++ b/doc/bird.sgml
@@ -2227,6 +2227,18 @@ limitations can be overcome using another routing table and the pipe protocol.
 	a graceful restart recovery is active, the Kernel protocol will defer
 	synchronization of routing tables until the end of the recovery. Note
 	that import of kernel routes to BIRD is not affected.
+
+	<tag>merge paths <M>switch</M> [limit <M>number</M>]</tag>
+	Usually, only best routes are exported to the kernel protocol. With path
+	merging enabled, both best routes and equivalent non-best routes are
+	merged during export to generate one ECMP (equal-cost multipath) route
+	for each network. This is useful e.g. for BGP multipath. Note that best
+	routes are still pivotal for route export (responsible for most
+	properties of resulting ECMP routes), while exported non-best routes are
+	responsible just for additional multipath next hops. This option also
+	allows to specify a limit on maximal number of nexthops in one route. By
+	default, multipath merging is disabled. If enabled, default value of the
+	limit is 16.
 </descrip>
 
 <sect1>Attributes
diff --git a/filter/filter.c b/filter/filter.c
index 3b14fc0c..3f8968aa 100644
--- a/filter/filter.c
+++ b/filter/filter.c
@@ -471,26 +471,22 @@ static inline void f_rte_cow(void)
 static void
 f_rta_cow(void)
 {
-  if ((*f_rte)->attrs->aflags & RTAF_CACHED) {
-
-    /* Prepare to modify rte */
-    f_rte_cow();
-
-    /* Store old rta to free it later */
-    f_old_rta = (*f_rte)->attrs;
-
-    /*
-     * Alloc new rta, do shallow copy and update rte. Fields eattrs
-     * and nexthops of rta are shared with f_old_rta (they will be
-     * copied when the cached rta will be obtained at the end of
-     * f_run()), also the lock of hostentry is inherited (we suppose
-     * hostentry is not changed by filters).
-     */
-    rta *ra = lp_alloc(f_pool, sizeof(rta));
-    memcpy(ra, f_old_rta, sizeof(rta));
-    ra->aflags = 0;
-    (*f_rte)->attrs = ra;
-  }
+  if (!rta_is_cached((*f_rte)->attrs))
+    return;
+
+  /* Prepare to modify rte */
+  f_rte_cow();
+
+  /* Store old rta to free it later, it stores reference from rte_cow() */
+  f_old_rta = (*f_rte)->attrs;
+
+  /*
+   * Get shallow copy of rta. Fields eattrs and nexthops of rta are shared
+   * with f_old_rta (they will be copied when the cached rta will be obtained
+   * at the end of f_run()), also the lock of hostentry is inherited (we
+   * suppose hostentry is not changed by filters).
+   */
+  (*f_rte)->attrs = rta_do_cow((*f_rte)->attrs, f_pool);
 }
 
 static struct tbf rl_runtime_err = TBF_DEFAULT_LOG_LIMITS;
diff --git a/lib/birdlib.h b/lib/birdlib.h
index 94054769..ad41dca3 100644
--- a/lib/birdlib.h
+++ b/lib/birdlib.h
@@ -31,6 +31,7 @@
 #endif
 
 #define ABS(a)   ((a)>=0 ? (a) : -(a))
+#define DELTA(a,b) (((a)>=(b))?(a)-(b):(b)-(a))
 #define ARRAY_SIZE(a) (sizeof(a)/sizeof(*(a)))
 
 
diff --git a/nest/protocol.h b/nest/protocol.h
index a51e9afd..8c49154f 100644
--- a/nest/protocol.h
+++ b/nest/protocol.h
@@ -158,6 +158,7 @@ struct proto {
   byte gr_wait;				/* Route export to protocol is postponed until graceful restart */
   byte down_sched;			/* Shutdown is scheduled for later (PDS_*) */
   byte down_code;			/* Reason for shutdown (PDC_* codes) */
+  byte merge_limit;			/* Maximal number of nexthops for RA_MERGED */
   u32 hash_key;				/* Random key used for hashing of neighbors */
   bird_clock_t last_state_change;	/* Time of last state transition */
   char *last_state_name_announced;	/* Last state name we've announced to the user */
@@ -200,6 +201,7 @@ struct proto {
    *	   rte_recalculate Called at the beginning of the best route selection
    *	   rte_better	Compare two rte's and decide which one is better (1=first, 0=second).
    *       rte_same	Compare two rte's and decide whether they are identical (1=yes, 0=no).
+   *       rte_mergable	Compare two rte's and decide whether they could be merged (1=yes, 0=no).
    *	   rte_insert	Called whenever a rte is inserted to a routing table.
    *	   rte_remove	Called whenever a rte is removed from the routing table.
    */
@@ -207,6 +209,7 @@ struct proto {
   int (*rte_recalculate)(struct rtable *, struct network *, struct rte *, struct rte *, struct rte *);
   int (*rte_better)(struct rte *, struct rte *);
   int (*rte_same)(struct rte *, struct rte *);
+  int (*rte_mergable)(struct rte *, struct rte *);
   void (*rte_insert)(struct network *, struct rte *);
   void (*rte_remove)(struct network *, struct rte *);
 
diff --git a/nest/route.h b/nest/route.h
index e22f950b..6067526d 100644
--- a/nest/route.h
+++ b/nest/route.h
@@ -240,6 +240,7 @@ static inline int rte_is_filtered(rte *r) { return !!(r->flags & REF_FILTERED);
 #define RA_OPTIMAL	1		/* Announcement of optimal route change */
 #define RA_ACCEPTED	2		/* Announcement of first accepted route */
 #define RA_ANY		3		/* Announcement of any route change */
+#define RA_MERGED	4		/* Announcement of optimal route merged with next ones */
 
 /* Return value of import_control() callback */
 #define RIC_ACCEPT	1		/* Accepted by protocol */
@@ -263,12 +264,14 @@ void rte_update2(struct announce_hook *ah, net *net, rte *new, struct rte_src *s
 static inline void rte_update(struct proto *p, net *net, rte *new) { rte_update2(p->main_ahook, net, new, p->main_source); }
 void rte_discard(rtable *tab, rte *old);
 int rt_examine(rtable *t, ip_addr prefix, int pxlen, struct proto *p, struct filter *filter);
+rte *rt_export_merged(struct announce_hook *ah, net *net, rte **rt_free, struct ea_list **tmpa, int silent);
 void rt_refresh_begin(rtable *t, struct announce_hook *ah);
 void rt_refresh_end(rtable *t, struct announce_hook *ah);
 void rte_dump(rte *);
 void rte_free(rte *);
 rte *rte_do_cow(rte *);
 static inline rte * rte_cow(rte *r) { return (r->flags & REF_COW) ? rte_do_cow(r) : r; }
+rte *rte_cow_rta(rte *r, linpool *lp);
 void rt_dump(rtable *);
 void rt_dump_all(void);
 int rt_feed_baby(struct proto *p);
@@ -388,6 +391,12 @@ typedef struct rta {
 #define IGP_METRIC_UNKNOWN 0x80000000	/* Default igp_metric used when no other
 					   protocol-specific metric is availabe */
 
+
+/* Route has regular, reachable nexthop (i.e. not RTD_UNREACHABLE and like) */
+static inline int rte_is_reachable(rte *r)
+{ uint d = r->attrs->dest; return (d == RTD_ROUTER) || (d == RTD_DEVICE) || (d == RTD_MULTIPATH); }
+
+
 /*
  *	Extended Route Attributes
  */
@@ -490,6 +499,8 @@ static inline int rta_is_cached(rta *r) { return r->aflags & RTAF_CACHED; }
 static inline rta *rta_clone(rta *r) { r->uc++; return r; }
 void rta__free(rta *r);
 static inline void rta_free(rta *r) { if (r && !--r->uc) rta__free(r); }
+rta *rta_do_cow(rta *o, linpool *lp);
+static inline rta * rta_cow(rta *r, linpool *lp) { return rta_is_cached(r) ? rta_do_cow(r, lp) : r; }
 void rta_dump(rta *);
 void rta_dump_all(void);
 void rta_show(struct cli *, rta *, ea_list *);
diff --git a/nest/rt-attr.c b/nest/rt-attr.c
index 32090b52..7fa05d6d 100644
--- a/nest/rt-attr.c
+++ b/nest/rt-attr.c
@@ -1138,6 +1138,16 @@ rta__free(rta *a)
   sl_free(rta_slab, a);
 }
 
+rta *
+rta_do_cow(rta *o, linpool *lp)
+{
+  rta *r = lp_alloc(lp, sizeof(rta));
+  memcpy(r, o, sizeof(rta));
+  r->aflags = 0;
+  r->uc = 0;
+  return r;
+}
+
 /**
  * rta_dump - dump route attributes
  * @a: attribute structure to dump
diff --git a/nest/rt-table.c b/nest/rt-table.c
index 22e1c489..9e2c4e0d 100644
--- a/nest/rt-table.c
+++ b/nest/rt-table.c
@@ -144,6 +144,38 @@ rte_do_cow(rte *r)
   return e;
 }
 
+/**
+ * rte_cow_rta - get a private writable copy of &rte with writable &rta
+ * @r: a route entry to be copied
+ * @lp: a linpool from which to allocate &rta
+ *
+ * rte_cow_rta() takes a &rte and prepares it and associated &rta for
+ * modification. There are three possibilities: First, both &rte and &rta are
+ * private copies, in that case they are returned unchanged.  Second, &rte is
+ * private copy, but &rta is cached, in that case &rta is duplicated using
+ * rta_do_cow(). Third, both &rte is shared and &rta is cached, in that case
+ * both structures are duplicated by rte_do_cow() and rta_do_cow().
+ *
+ * Note that in the second case, cached &rta loses one reference, while private
+ * copy created by rta_do_cow() is a shallow copy sharing indirect data (eattrs,
+ * nexthops, ...) with it. To work properly, original shared &rta should have
+ * another reference during the life of created private copy.
+ *
+ * Result: a pointer to the new writable &rte with writable &rta.
+ */
+rte *
+rte_cow_rta(rte *r, linpool *lp)
+{
+  if (!rta_is_cached(r->attrs))
+    return r;
+
+  rte *e = rte_cow(r);
+  rta *a = rta_do_cow(r->attrs, lp);
+  rta_free(e->attrs);
+  e->attrs = a;
+  return e;
+}
+
 static int				/* Actually better or at least as good as */
 rte_better(rte *new, rte *old)
 {
@@ -172,6 +204,26 @@ rte_better(rte *new, rte *old)
   return 0;
 }
 
+static int
+rte_mergable(rte *pri, rte *sec)
+{
+  int (*mergable)(rte *, rte *);
+
+  if (!rte_is_valid(pri) || !rte_is_valid(sec))
+    return 0;
+
+  if (pri->pref != sec->pref)
+    return 0;
+
+  if (pri->attrs->src->proto->proto != sec->attrs->src->proto->proto)
+    return 0;
+
+  if (mergable = pri->attrs->src->proto->rte_mergable)
+    return mergable(pri, sec);
+
+  return 0;
+}
+
 static void
 rte_trace(struct proto *p, rte *e, int dir, char *msg)
 {
@@ -535,6 +587,129 @@ rt_notify_accepted(struct announce_hook *ah, net *net, rte *new_changed, rte *ol
     rte_free(old_free);
 }
 
+
+static struct mpnh *
+mpnh_merge_rta(struct mpnh *nhs, rta *a, int max)
+{
+  struct mpnh nh = { .gw = a->gw, .iface = a->iface };
+  struct mpnh *nh2 = (a->dest == RTD_MULTIPATH) ? a->nexthops : &nh;
+  return mpnh_merge(nhs, nh2, 1, 0, max, rte_update_pool);
+}
+
+rte *
+rt_export_merged(struct announce_hook *ah, net *net, rte **rt_free, ea_list **tmpa, int silent)
+{
+  // struct proto *p = ah->proto;
+  struct mpnh *nhs = NULL;
+  rte *best0, *best, *rt0, *rt, *tmp;
+
+  best0 = net->routes;
+  *rt_free = NULL;
+
+  if (!rte_is_valid(best0))
+    return NULL;
+
+  best = export_filter(ah, best0, rt_free, tmpa, silent);
+
+  if (!best || !rte_is_reachable(best))
+    return best;
+
+  for (rt0 = best0->next; rt0; rt0 = rt0->next)
+  {
+    if (!rte_mergable(best0, rt0))
+      continue;
+
+    rt = export_filter(ah, rt0, &tmp, NULL, 1);
+
+    if (!rt)
+      continue;
+
+    if (rte_is_reachable(rt))
+      nhs = mpnh_merge_rta(nhs, rt->attrs, ah->proto->merge_limit);
+
+    if (tmp)
+      rte_free(tmp);
+  }
+
+  if (nhs)
+  {
+    nhs = mpnh_merge_rta(nhs, best->attrs, ah->proto->merge_limit);
+
+    if (nhs->next)
+    {
+      best = rte_cow_rta(best, rte_update_pool);
+      best->attrs->dest = RTD_MULTIPATH;
+      best->attrs->nexthops = nhs;
+    }
+  }
+
+  if (best != best0)
+    *rt_free = best;
+
+  return best;
+}
+
+
+static void
+rt_notify_merged(struct announce_hook *ah, net *net, rte *new_changed, rte *old_changed,
+		 rte *new_best, rte*old_best, int refeed)
+{
+  // struct proto *p = ah->proto;
+
+  rte *new_best_free = NULL;
+  rte *old_best_free = NULL;
+  rte *new_changed_free = NULL;
+  rte *old_changed_free = NULL;
+  ea_list *tmpa = NULL;
+
+  /* We assume that all rte arguments are either NULL or rte_is_valid() */
+
+  /* This check should be done by the caller */
+  if (!new_best && !old_best)
+    return;
+
+  /* Check whether the change is relevant to the merged route */
+  if ((new_best == old_best) && !refeed)
+  {
+    new_changed = rte_mergable(new_best, new_changed) ?
+      export_filter(ah, new_changed, &new_changed_free, NULL, 1) : NULL;
+
+    old_changed = rte_mergable(old_best, old_changed) ?
+      export_filter(ah, old_changed, &old_changed_free, NULL, 1) : NULL;
+
+    if (!new_changed && !old_changed)
+      return;
+  }
+
+  if (new_best)
+    ah->stats->exp_updates_received++;
+  else
+    ah->stats->exp_withdraws_received++;
+
+  /* Prepare new merged route */
+  if (new_best)
+    new_best = rt_export_merged(ah, net, &new_best_free, &tmpa, 0);
+
+  /* Prepare old merged route (without proper merged next hops) */
+  /* There are some issues with running filter on old route - see rt_notify_basic() */
+  if (old_best && !refeed)
+    old_best = export_filter(ah, old_best, &old_best_free, NULL, 1);
+
+  if (new_best || old_best)
+    do_rt_notify(ah, net, new_best, old_best, tmpa, refeed);
+
+  /* Discard temporary rte's */
+  if (new_best_free)
+    rte_free(new_best_free);
+  if (old_best_free)
+    rte_free(old_best_free);
+  if (new_changed_free)
+    rte_free(new_changed_free);
+  if (old_changed_free)
+    rte_free(old_changed_free);
+}
+
+
 /**
  * rte_announce - announce a routing table change
  * @tab: table the route has been added to
@@ -564,13 +739,20 @@ rt_notify_accepted(struct announce_hook *ah, net *net, rte *new_changed, rte *ol
  * the protocol gets called.
  */
 static void
-rte_announce(rtable *tab, unsigned type, net *net, rte *new, rte *old, rte *before_old)
+rte_announce(rtable *tab, unsigned type, net *net, rte *new, rte *old,
+	     rte *new_best, rte *old_best, rte *before_old)
 {
+  if (!rte_is_valid(new))
+    new = NULL;
+
   if (!rte_is_valid(old))
     old = before_old = NULL;
 
-  if (!rte_is_valid(new))
-    new = NULL;
+  if (!rte_is_valid(new_best))
+    new_best = NULL;
+
+  if (!rte_is_valid(old_best))
+    old_best = NULL;
 
   if (!old && !new)
     return;
@@ -593,6 +775,8 @@ rte_announce(rtable *tab, unsigned type, net *net, rte *new, rte *old, rte *befo
       if (a->proto->accept_ra_types == type)
 	if (type == RA_ACCEPTED)
 	  rt_notify_accepted(a, net, new, old, before_old, 0);
+	else if (type == RA_MERGED)
+	  rt_notify_merged(a, net, new, old, new_best, old_best, 0);
 	else
 	  rt_notify_basic(a, net, new, old, 0);
     }
@@ -898,11 +1082,12 @@ rte_recalculate(struct announce_hook *ah, net *net, rte *new, struct rte_src *sr
     }
 
   /* Propagate the route change */
-  rte_announce(table, RA_ANY, net, new, old, NULL);
+  rte_announce(table, RA_ANY, net, new, old, NULL, NULL, NULL);
   if (net->routes != old_best)
-    rte_announce(table, RA_OPTIMAL, net, net->routes, old_best, NULL);
+    rte_announce(table, RA_OPTIMAL, net, net->routes, old_best, NULL, NULL, NULL);
   if (table->config->sorted)
-    rte_announce(table, RA_ACCEPTED, net, new, old, before_old);
+    rte_announce(table, RA_ACCEPTED, net, new, old, NULL, NULL, before_old);
+  rte_announce(table, RA_MERGED, net, new, old, net->routes, old_best, NULL);
 
   if (!net->routes &&
       (table->gc_counter++ >= table->config->gc_max_ops) &&
@@ -1081,10 +1266,11 @@ rte_update2(struct announce_hook *ah, net *net, rte *new, struct rte_src *src)
 /* Independent call to rte_announce(), used from next hop
    recalculation, outside of rte_update(). new must be non-NULL */
 static inline void 
-rte_announce_i(rtable *tab, unsigned type, net *n, rte *new, rte *old)
+rte_announce_i(rtable *tab, unsigned type, net *net, rte *new, rte *old,
+	       rte *new_best, rte *old_best)
 {
   rte_update_lock();
-  rte_announce(tab, type, n, new, old, NULL);
+  rte_announce(tab, type, net, new, old, new_best, old_best, NULL);
   rte_update_unlock();
 }
 
@@ -1548,7 +1734,7 @@ rt_next_hop_update_net(rtable *tab, net *n)
 	new = rt_next_hop_update_rte(tab, e);
 	*k = new;
 
-	rte_announce_i(tab, RA_ANY, n, new, e);
+	rte_announce_i(tab, RA_ANY, n, new, e, NULL, NULL);
 	rte_trace_in(D_ROUTES, new->sender->proto, new, "updated");
 
 	/* Call a pre-comparison hook */
@@ -1588,10 +1774,13 @@ rt_next_hop_update_net(rtable *tab, net *n)
   /* Announce the new best route */
   if (new != old_best)
     {
-      rte_announce_i(tab, RA_OPTIMAL, n, new, old_best);
+      rte_announce_i(tab, RA_OPTIMAL, n, new, old_best, NULL, NULL);
       rte_trace_in(D_ROUTES, new->sender->proto, new, "updated [best]");
     }
 
+  /* FIXME: Better announcement of merged routes */
+  rte_announce_i(tab, RA_MERGED, n, new, old_best, new, old_best);
+
    if (free_old_best)
     rte_free_quick(old_best);
 
@@ -1755,6 +1944,8 @@ do_feed_baby(struct proto *p, int type, struct announce_hook *h, net *n, rte *e)
   rte_update_lock();
   if (type == RA_ACCEPTED)
     rt_notify_accepted(h, n, e, NULL, NULL, p->refeeding ? 2 : 1);
+  else if (type == RA_MERGED)
+    rt_notify_merged(h, n, NULL, NULL, e, p->refeeding ? e : NULL, p->refeeding);
   else
     rt_notify_basic(h, n, e, p->refeeding ? e : NULL, p->refeeding);
   rte_update_unlock();
@@ -1802,7 +1993,8 @@ rt_feed_baby(struct proto *p)
       /* XXXX perhaps we should change feed for RA_ACCEPTED to not use 'new' */
 
       if ((p->accept_ra_types == RA_OPTIMAL) ||
-	  (p->accept_ra_types == RA_ACCEPTED))
+	  (p->accept_ra_types == RA_ACCEPTED) ||
+	  (p->accept_ra_types == RA_MERGED))
 	if (rte_is_valid(e))
 	  {
 	    if (p->export_state != ES_FEEDING)
@@ -2267,12 +2459,22 @@ rt_show_net(struct cli *c, net *n, struct rt_show_data *d)
       rte_update_lock();		/* We use the update buffer for filtering */
       tmpa = make_tmp_attrs(e, rte_update_pool);
 
-      if (d->export_mode)
+      /* Special case for merged export */
+      if ((d->export_mode == RSEM_EXPORT) && (d->export_protocol->accept_ra_types == RA_MERGED))
+        {
+	  rte *rt_free;
+	  e = rt_export_merged(a, n, &rt_free, &tmpa, 1);
+	  pass = 1;
+
+	  if (!e)
+	  { e = ee; goto skip; }
+	}
+      else if (d->export_mode)
 	{
 	  struct proto *ep = d->export_protocol;
 	  int ic = ep->import_control ? ep->import_control(ep, &e, &tmpa, rte_update_pool) : 0;
 
-	  if (ep->accept_ra_types == RA_OPTIMAL)
+	  if (ep->accept_ra_types == RA_OPTIMAL || ep->accept_ra_types == RA_MERGED)
 	    pass = 1;
 
 	  if (ic < 0)
diff --git a/proto/bgp/attrs.c b/proto/bgp/attrs.c
index d56c017d..d85afa8f 100644
--- a/proto/bgp/attrs.c
+++ b/proto/bgp/attrs.c
@@ -1312,6 +1312,82 @@ bgp_rte_better(rte *new, rte *old)
 }
 
 
+int
+bgp_rte_mergable(rte *pri, rte *sec)
+{
+  struct bgp_proto *pri_bgp = (struct bgp_proto *) pri->attrs->src->proto;
+  struct bgp_proto *sec_bgp = (struct bgp_proto *) sec->attrs->src->proto;
+  eattr *x, *y;
+  u32 p, s;
+
+  /* Skip suppressed routes (see bgp_rte_recalculate()) */
+  if (pri->u.bgp.suppressed != sec->u.bgp.suppressed)
+    return 0;
+
+  /* RFC 4271 9.1.2.1. Route resolvability test */
+  if (!rte_resolvable(sec))
+    return 0;
+
+  /* Start with local preferences */
+  x = ea_find(pri->attrs->eattrs, EA_CODE(EAP_BGP, BA_LOCAL_PREF));
+  y = ea_find(sec->attrs->eattrs, EA_CODE(EAP_BGP, BA_LOCAL_PREF));
+  p = x ? x->u.data : pri_bgp->cf->default_local_pref;
+  s = y ? y->u.data : sec_bgp->cf->default_local_pref;
+  if (p != s)
+    return 0;
+
+  /* RFC 4271 9.1.2.2. a)  Use AS path lengths */
+  if (pri_bgp->cf->compare_path_lengths || sec_bgp->cf->compare_path_lengths)
+    {
+      x = ea_find(pri->attrs->eattrs, EA_CODE(EAP_BGP, BA_AS_PATH));
+      y = ea_find(sec->attrs->eattrs, EA_CODE(EAP_BGP, BA_AS_PATH));
+      p = x ? as_path_getlen(x->u.ptr) : AS_PATH_MAXLEN;
+      s = y ? as_path_getlen(y->u.ptr) : AS_PATH_MAXLEN;
+
+      if (p != s)
+	return 0;
+
+//      if (DELTA(p, s) > pri_bgp->cf->relax_multipath)
+//	return 0;
+    }
+
+  /* RFC 4271 9.1.2.2. b) Use origins */
+  x = ea_find(pri->attrs->eattrs, EA_CODE(EAP_BGP, BA_ORIGIN));
+  y = ea_find(sec->attrs->eattrs, EA_CODE(EAP_BGP, BA_ORIGIN));
+  p = x ? x->u.data : ORIGIN_INCOMPLETE;
+  s = y ? y->u.data : ORIGIN_INCOMPLETE;
+  if (p != s)
+    return 0;
+
+  /* RFC 4271 9.1.2.2. c) Compare MED's */
+  if (pri_bgp->cf->med_metric || sec_bgp->cf->med_metric ||
+      (bgp_get_neighbor(pri) == bgp_get_neighbor(sec)))
+    {
+      x = ea_find(pri->attrs->eattrs, EA_CODE(EAP_BGP, BA_MULTI_EXIT_DISC));
+      y = ea_find(sec->attrs->eattrs, EA_CODE(EAP_BGP, BA_MULTI_EXIT_DISC));
+      p = x ? x->u.data : pri_bgp->cf->default_med;
+      s = y ? y->u.data : sec_bgp->cf->default_med;
+      if (p != s)
+	return 0;
+    }
+
+  /* RFC 4271 9.1.2.2. d) Prefer external peers */
+  if (pri_bgp->is_internal != sec_bgp->is_internal)
+    return 0;
+
+  /* RFC 4271 9.1.2.2. e) Compare IGP metrics */
+  p = pri_bgp->cf->igp_metric ? pri->attrs->igp_metric : 0;
+  s = sec_bgp->cf->igp_metric ? sec->attrs->igp_metric : 0;
+  if (p != s)
+    return 0;
+
+  /* Remaining criteria are ignored */
+
+  return 1;
+}
+
+
+
 static inline int
 same_group(rte *r, u32 lpref, u32 lasn)
 {
diff --git a/proto/bgp/bgp.c b/proto/bgp/bgp.c
index e48b643b..9e28b278 100644
--- a/proto/bgp/bgp.c
+++ b/proto/bgp/bgp.c
@@ -1243,6 +1243,7 @@ bgp_init(struct proto_config *C)
   P->feed_begin = bgp_feed_begin;
   P->feed_end = bgp_feed_end;
   P->rte_better = bgp_rte_better;
+  P->rte_mergable = bgp_rte_mergable;
   P->rte_recalculate = c->deterministic_med ? bgp_rte_recalculate : NULL;
 
   p->cf = c;
diff --git a/proto/bgp/bgp.h b/proto/bgp/bgp.h
index 446fc857..b6e80fe5 100644
--- a/proto/bgp/bgp.h
+++ b/proto/bgp/bgp.h
@@ -238,6 +238,7 @@ byte *bgp_attach_attr_wa(struct ea_list **to, struct linpool *pool, unsigned att
 struct rta *bgp_decode_attrs(struct bgp_conn *conn, byte *a, uint len, struct linpool *pool, int mandatory);
 int bgp_get_attr(struct eattr *e, byte *buf, int buflen);
 int bgp_rte_better(struct rte *, struct rte *);
+int bgp_rte_mergable(rte *pri, rte *sec);
 int bgp_rte_recalculate(rtable *table, net *net, rte *new, rte *old, rte *old_best);
 void bgp_rt_notify(struct proto *P, rtable *tbl UNUSED, net *n, rte *new, rte *old UNUSED, ea_list *attrs);
 int bgp_import_control(struct proto *, struct rte **, struct ea_list **, struct linpool *);
diff --git a/proto/static/static.c b/proto/static/static.c
index 4b72fa9d..e7e7ab15 100644
--- a/proto/static/static.c
+++ b/proto/static/static.c
@@ -352,6 +352,12 @@ static_if_notify(struct proto *p, unsigned flags, struct iface *i)
     }
 }
 
+int
+static_rte_mergable(rte *pri, rte *sec)
+{
+  return 1;
+}
+
 void
 static_init_config(struct static_config *c)
 {
@@ -366,6 +372,7 @@ static_init(struct proto_config *c)
 
   p->neigh_notify = static_neigh_notify;
   p->if_notify = static_if_notify;
+  p->rte_mergable = static_rte_mergable;
 
   return p;
 }
diff --git a/sysdep/unix/krt.Y b/sysdep/unix/krt.Y
index 630cda38..e036081d 100644
--- a/sysdep/unix/krt.Y
+++ b/sysdep/unix/krt.Y
@@ -17,7 +17,7 @@ CF_DEFINES
 
 CF_DECLS
 
-CF_KEYWORDS(KERNEL, PERSIST, SCAN, TIME, LEARN, DEVICE, ROUTES, GRACEFUL, RESTART, KRT_SOURCE, KRT_METRIC)
+CF_KEYWORDS(KERNEL, PERSIST, SCAN, TIME, LEARN, DEVICE, ROUTES, GRACEFUL, RESTART, KRT_SOURCE, KRT_METRIC, MERGE, PATHS)
 
 CF_GRAMMAR
 
@@ -47,6 +47,8 @@ kern_item:
    }
  | DEVICE ROUTES bool { THIS_KRT->devroutes = $3; }
  | GRACEFUL RESTART bool { THIS_KRT->graceful_restart = $3; }
+ | MERGE PATHS bool { THIS_KRT->merge_paths = $3 ? KRT_DEFAULT_ECMP_LIMIT : 0; }
+ | MERGE PATHS bool LIMIT expr { THIS_KRT->merge_paths = $3 ? $5 : 0; if (($5 <= 0) || ($5 > 255)) cf_error("Merge paths limit must be in range 1-255"); }
  ;
 
 /* Kernel interface protocol */
diff --git a/sysdep/unix/krt.c b/sysdep/unix/krt.c
index d8d28c7c..2eab5cb2 100644
--- a/sysdep/unix/krt.c
+++ b/sysdep/unix/krt.c
@@ -595,9 +595,13 @@ krt_flush_routes(struct krt_proto *p)
 static struct rte *
 krt_export_net(struct krt_proto *p, net *net, rte **rt_free, ea_list **tmpa)
 {
-  struct filter *filter = p->p.main_ahook->out_filter;
+  struct announce_hook *ah = p->p.main_ahook;
+  struct filter *filter = ah->out_filter;
   rte *rt;
 
+  if (p->p.accept_ra_types == RA_MERGED)
+    return rt_export_merged(ah, net, rt_free, tmpa, 1);
+
   rt = net->routes;
   *rt_free = NULL;
 
@@ -1091,11 +1095,13 @@ krt_rte_same(rte *a, rte *b)
 struct krt_config *krt_cf;
 
 static struct proto *
-krt_init(struct proto_config *c)
+krt_init(struct proto_config *C)
 {
-  struct krt_proto *p = proto_new(c, sizeof(struct krt_proto));
+  struct krt_proto *p = proto_new(C, sizeof(struct krt_proto));
+  struct krt_config *c = (struct krt_config *) C;
 
-  p->p.accept_ra_types = RA_OPTIMAL;
+  p->p.accept_ra_types = c->merge_paths ? RA_MERGED : RA_OPTIMAL;
+  p->p.merge_limit = c->merge_paths;
   p->p.import_control = krt_import_control;
   p->p.rt_notify = krt_rt_notify;
   p->p.if_notify = krt_if_notify;
@@ -1161,7 +1167,8 @@ krt_reconfigure(struct proto *p, struct proto_config *new)
     return 0;
 
   /* persist, graceful restart need not be the same */
-  return o->scan_time == n->scan_time && o->learn == n->learn && o->devroutes == n->devroutes;
+  return o->scan_time == n->scan_time && o->learn == n->learn &&
+    o->devroutes == n->devroutes && o->merge_paths == n->merge_paths;
 }
 
 static void
diff --git a/sysdep/unix/krt.h b/sysdep/unix/krt.h
index 1940cbcd..9d5d4e8c 100644
--- a/sysdep/unix/krt.h
+++ b/sysdep/unix/krt.h
@@ -26,6 +26,8 @@ struct kif_proto;
 #define KRF_DELETE 3			/* Should be deleted */
 #define KRF_IGNORE 4			/* To be ignored */
 
+#define KRT_DEFAULT_ECMP_LIMIT	16
+
 #define EA_KRT_SOURCE	EA_CODE(EAP_KRT, 0)
 #define EA_KRT_METRIC	EA_CODE(EAP_KRT, 1)
 
@@ -47,6 +49,7 @@ struct krt_config {
   int learn;			/* Learn routes from other sources */
   int devroutes;		/* Allow export of device routes */
   int graceful_restart;		/* Regard graceful restart recovery */
+  int merge_paths;		/* Exported routes are merged for ECMP */
 };
 
 struct krt_proto {

From ab4da3423d89fb6c60a4137f19c189a8716ecab6 Mon Sep 17 00:00:00 2001
From: Ondrej Zajicek <santiago@crfreenet.org>
Date: Sat, 18 Jul 2015 13:05:05 +0200
Subject: [PATCH 016/165] Direct: Fixes behavior for the same routes on
 different interfaces

Thanks to Andrew (seti.kr.ua) for the bug report.
---
 nest/rt-dev.c | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/nest/rt-dev.c b/nest/rt-dev.c
index 87ffc5ec..f6bc1432 100644
--- a/nest/rt-dev.c
+++ b/nest/rt-dev.c
@@ -51,7 +51,10 @@ dev_ifa_notify(struct proto *p, unsigned c, struct ifa *ad)
 	  DBG("dev_if_notify: device shutdown: prefix not found\n");
 	  return;
 	}
-      rte_update(p, n, NULL);
+
+      /* Use iface ID as local source ID */
+      struct rte_src *src = rt_get_source(p, ad->iface->index);
+      rte_update2(p->main_ahook, n, NULL, src);
     }
   else if (c & IF_CHANGE_UP)
     {
@@ -61,8 +64,11 @@ dev_ifa_notify(struct proto *p, unsigned c, struct ifa *ad)
 
       DBG("dev_if_notify: %s:%I going up\n", ad->iface->name, ad->ip);
 
+      /* Use iface ID as local source ID */
+      struct rte_src *src = rt_get_source(p, ad->iface->index);
+
       rta a0 = {
-	.src = p->main_source,
+	.src = src,
 	.source = RTS_DEVICE,
 	.scope = SCOPE_UNIVERSE,
 	.cast = RTC_UNICAST,
@@ -75,7 +81,7 @@ dev_ifa_notify(struct proto *p, unsigned c, struct ifa *ad)
       e = rte_get_temp(a);
       e->net = n;
       e->pflags = 0;
-      rte_update(p, n, e);
+      rte_update2(p->main_ahook, n, e, src);
     }
 }
 

From 06e0d1b692d8a190c3f1d073c5c557d8efe78b17 Mon Sep 17 00:00:00 2001
From: Ondrej Zajicek <santiago@crfreenet.org>
Date: Sat, 18 Jul 2015 13:38:21 +0200
Subject: [PATCH 017/165] BGP: Extended messages support

Implements draft-ietf-idr-bgp-extended-messages-10, for now
undocumented and with temporary private capability number.
---
 doc/bird.sgml       |  2 +-
 proto/bgp/bgp.c     | 22 ++++++++++++++++------
 proto/bgp/bgp.h     | 13 +++++++++++--
 proto/bgp/config.Y  |  3 ++-
 proto/bgp/packets.c | 29 ++++++++++++++++++++++++-----
 5 files changed, 54 insertions(+), 15 deletions(-)

diff --git a/doc/bird.sgml b/doc/bird.sgml
index 752465b9..2ae9f649 100644
--- a/doc/bird.sgml
+++ b/doc/bird.sgml
@@ -1571,7 +1571,7 @@ RFC 4271<htmlurl url="ftp://ftp.rfc-editor.org/in-notes/rfc4271.txt">
 It also supports the community attributes
 (RFC 1997<htmlurl url="ftp://ftp.rfc-editor.org/in-notes/rfc1997.txt">),
 capability negotiation
-(RFC 3392<htmlurl url="ftp://ftp.rfc-editor.org/in-notes/rfc3392.txt">),
+(RFC 5492<htmlurl url="ftp://ftp.rfc-editor.org/in-notes/rfc5492.txt">),
 MD5 password authentication
 (RFC 2385<htmlurl url="ftp://ftp.rfc-editor.org/in-notes/rfc2385.txt">),
 extended communities
diff --git a/proto/bgp/bgp.c b/proto/bgp/bgp.c
index 9e28b278..f549b0ed 100644
--- a/proto/bgp/bgp.c
+++ b/proto/bgp/bgp.c
@@ -569,6 +569,7 @@ bgp_send_open(struct bgp_conn *conn)
   conn->peer_gr_time = 0;
   conn->peer_gr_flags = 0;
   conn->peer_gr_aflags = 0;
+  conn->peer_ext_messages_support = 0;
 
   DBG("BGP: Sending open\n");
   conn->sk->rx_hook = bgp_rx;
@@ -733,8 +734,8 @@ bgp_connect(struct bgp_proto *p)	/* Enter Connect state and start establishing c
   s->dport = p->cf->remote_port;
   s->iface = p->neigh ? p->neigh->iface : NULL;
   s->ttl = p->cf->ttl_security ? 255 : hops;
-  s->rbsize = BGP_RX_BUFFER_SIZE;
-  s->tbsize = BGP_TX_BUFFER_SIZE;
+  s->rbsize = p->cf->enable_extended_messages ? BGP_RX_BUFFER_EXT_SIZE : BGP_RX_BUFFER_SIZE;
+  s->tbsize = p->cf->enable_extended_messages ? BGP_TX_BUFFER_EXT_SIZE : BGP_TX_BUFFER_SIZE;
   s->tos = IP_PREC_INTERNET_CONTROL;
   s->password = p->cf->password;
   s->tx_hook = bgp_connected;
@@ -843,6 +844,13 @@ bgp_incoming_connection(sock *sk, int dummy UNUSED)
     if (sk_set_min_ttl(sk, 256 - hops) < 0)
       goto err;
 
+  if (p->cf->enable_extended_messages)
+    {
+      sk->rbsize = BGP_RX_BUFFER_EXT_SIZE;
+      sk->tbsize = BGP_TX_BUFFER_EXT_SIZE;
+      sk_reallocate(sk);
+    }
+
   bgp_setup_conn(p, &p->incoming_conn);
   bgp_setup_sk(&p->incoming_conn, sk);
   bgp_send_open(&p->incoming_conn);
@@ -1518,21 +1526,23 @@ bgp_show_proto_info(struct proto *P)
   else if (P->proto_state == PS_UP)
     {
       cli_msg(-1006, "    Neighbor ID:      %R", p->remote_id);
-      cli_msg(-1006, "    Neighbor caps:   %s%s%s%s%s%s",
+      cli_msg(-1006, "    Neighbor caps:   %s%s%s%s%s%s%s",
 	      c->peer_refresh_support ? " refresh" : "",
 	      c->peer_enhanced_refresh_support ? " enhanced-refresh" : "",
 	      c->peer_gr_able ? " restart-able" : (c->peer_gr_aware ? " restart-aware" : ""),
 	      c->peer_as4_support ? " AS4" : "",
 	      (c->peer_add_path & ADD_PATH_RX) ? " add-path-rx" : "",
-	      (c->peer_add_path & ADD_PATH_TX) ? " add-path-tx" : "");
-      cli_msg(-1006, "    Session:          %s%s%s%s%s%s%s",
+	      (c->peer_add_path & ADD_PATH_TX) ? " add-path-tx" : "",
+	      c->peer_ext_messages_support ? " ext-messages" : "");
+      cli_msg(-1006, "    Session:          %s%s%s%s%s%s%s%s",
 	      p->is_internal ? "internal" : "external",
 	      p->cf->multihop ? " multihop" : "",
 	      p->rr_client ? " route-reflector" : "",
 	      p->rs_client ? " route-server" : "",
 	      p->as4_session ? " AS4" : "",
 	      p->add_path_rx ? " add-path-rx" : "",
-	      p->add_path_tx ? " add-path-tx" : "");
+	      p->add_path_tx ? " add-path-tx" : "",
+	      p->ext_messages ? " ext-messages" : "");
       cli_msg(-1006, "    Source address:   %I", p->source_addr);
       if (P->cf->in_limit)
 	cli_msg(-1006, "    Route limit:      %d/%d",
diff --git a/proto/bgp/bgp.h b/proto/bgp/bgp.h
index b6e80fe5..274794f1 100644
--- a/proto/bgp/bgp.h
+++ b/proto/bgp/bgp.h
@@ -40,6 +40,7 @@ struct bgp_config {
   int capabilities;			/* Enable capability handshake [RFC3392] */
   int enable_refresh;			/* Enable local support for route refresh [RFC2918] */
   int enable_as4;			/* Enable local support for 4B AS numbers [RFC4893] */
+  int enable_extended_messages;		/* Enable local support for extended messages [draft] */
   u32 rr_cluster_id;			/* Route reflector cluster ID, if different from local ID */
   int rr_client;			/* Whether neighbor is RR client of me */
   int rs_client;			/* Whether neighbor is RS client of me */
@@ -109,6 +110,7 @@ struct bgp_conn {
   u16 peer_gr_time;
   u8 peer_gr_flags;
   u8 peer_gr_aflags;
+  u8 peer_ext_messages_support;		/* Peer supports extended message length [draft] */
   unsigned hold_time, keepalive_time;	/* Times calculated from my and neighbor's requirements */
 };
 
@@ -121,6 +123,7 @@ struct bgp_proto {
   u8 as4_session;			/* Session uses 4B AS numbers in AS_PATH (both sides support it) */
   u8 add_path_rx;			/* Session expects receive of ADD-PATH extended NLRI */
   u8 add_path_tx;			/* Session expects transmit of ADD-PATH extended NLRI */
+  u8 ext_messages;			/* Session allows to use extended messages (both sides support it) */
   u32 local_id;				/* BGP identifier of this router */
   u32 remote_id;			/* BGP identifier of the neighbor */
   u32 rr_cluster_id;			/* Route reflector cluster ID */
@@ -180,9 +183,15 @@ struct bgp_bucket {
 #define BGP_PORT		179
 #define BGP_VERSION		4
 #define BGP_HEADER_LENGTH	19
-#define BGP_MAX_PACKET_LENGTH	4096
+#define BGP_MAX_MESSAGE_LENGTH	4096
+#define BGP_MAX_EXT_MSG_LENGTH	65535
 #define BGP_RX_BUFFER_SIZE	4096
-#define BGP_TX_BUFFER_SIZE	BGP_MAX_PACKET_LENGTH
+#define BGP_TX_BUFFER_SIZE	4096
+#define BGP_RX_BUFFER_EXT_SIZE	65535
+#define BGP_TX_BUFFER_EXT_SIZE	65535
+
+static inline int bgp_max_packet_length(struct bgp_proto *p)
+{ return p->ext_messages ? BGP_MAX_EXT_MSG_LENGTH : BGP_MAX_MESSAGE_LENGTH; }
 
 extern struct linpool *bgp_linpool;
 
diff --git a/proto/bgp/config.Y b/proto/bgp/config.Y
index 49afe5ae..85b93a6b 100644
--- a/proto/bgp/config.Y
+++ b/proto/bgp/config.Y
@@ -27,7 +27,7 @@ CF_KEYWORDS(BGP, LOCAL, NEIGHBOR, AS, HOLD, TIME, CONNECT, RETRY,
 	INTERPRET, COMMUNITIES, BGP_ORIGINATOR_ID, BGP_CLUSTER_LIST, IGP,
 	TABLE, GATEWAY, DIRECT, RECURSIVE, MED, TTL, SECURITY, DETERMINISTIC,
 	SECONDARY, ALLOW, BFD, ADD, PATHS, RX, TX, GRACEFUL, RESTART, AWARE,
-	CHECK, LINK, PORT)
+	CHECK, LINK, PORT, EXTENDED, MESSAGES)
 
 CF_GRAMMAR
 
@@ -108,6 +108,7 @@ bgp_proto:
  | bgp_proto DISABLE AFTER ERROR bool ';' { BGP_CFG->disable_after_error = $5; }
  | bgp_proto ENABLE ROUTE REFRESH bool ';' { BGP_CFG->enable_refresh = $5; }
  | bgp_proto ENABLE AS4 bool ';' { BGP_CFG->enable_as4 = $4; }
+ | bgp_proto ENABLE EXTENDED MESSAGES bool ';' { BGP_CFG->enable_extended_messages = $5; }
  | bgp_proto CAPABILITIES bool ';' { BGP_CFG->capabilities = $3; }
  | bgp_proto ADVERTISE IPV4 bool ';' { BGP_CFG->advertise_ipv4 = $4; }
  | bgp_proto PASSWORD text ';' { BGP_CFG->password = $3; }
diff --git a/proto/bgp/packets.c b/proto/bgp/packets.c
index 378f5ab1..ed99f623 100644
--- a/proto/bgp/packets.c
+++ b/proto/bgp/packets.c
@@ -84,7 +84,7 @@ mrt_put_bgp4_hdr(byte *buf, struct bgp_conn *conn, int as4)
 static void
 mrt_dump_bgp_packet(struct bgp_conn *conn, byte *pkt, unsigned len)
 {
-  byte buf[BGP_MAX_PACKET_LENGTH + 128];
+  byte *buf = alloca(128+len);	/* 128 is enough for MRT headers */
   byte *bp = buf + MRTDUMP_HDR_LENGTH;
   int as4 = conn->bgp->as4_session;
 
@@ -223,6 +223,14 @@ bgp_put_cap_err(struct bgp_proto *p UNUSED, byte *buf)
   return buf;
 }
 
+static byte *
+bgp_put_cap_ext_msg(struct bgp_proto *p UNUSED, byte *buf)
+{
+  *buf++ = 230;		/* Capability TBD: Support for extended messages */
+  *buf++ = 0;		/* Capability data length */
+  return buf;
+}
+
 
 static byte *
 bgp_create_open(struct bgp_conn *conn, byte *buf)
@@ -274,6 +282,9 @@ bgp_create_open(struct bgp_conn *conn, byte *buf)
   if (p->cf->enable_refresh)
     cap = bgp_put_cap_err(p, cap);
 
+  if (p->cf->enable_extended_messages)
+    cap = bgp_put_cap_ext_msg(p, cap);
+
   cap_len = cap - buf - 12;
   if (cap_len > 0)
     {
@@ -342,7 +353,7 @@ bgp_create_update(struct bgp_conn *conn, byte *buf)
 {
   struct bgp_proto *p = conn->bgp;
   struct bgp_bucket *buck;
-  int remains = BGP_MAX_PACKET_LENGTH - BGP_HEADER_LENGTH - 4;
+  int remains = bgp_max_packet_length(p) - BGP_HEADER_LENGTH - 4;
   byte *w;
   int wd_size = 0;
   int r_size = 0;
@@ -428,7 +439,7 @@ bgp_create_update(struct bgp_conn *conn, byte *buf)
   struct bgp_proto *p = conn->bgp;
   struct bgp_bucket *buck;
   int size, second, rem_stored;
-  int remains = BGP_MAX_PACKET_LENGTH - BGP_HEADER_LENGTH - 4;
+  int remains = bgp_max_packet_length(p) - BGP_HEADER_LENGTH - 4;
   byte *w, *w_stored, *tmp, *tstart;
   ip_addr *ipp, ip, ip_ll;
   ea_list *ea;
@@ -856,6 +867,12 @@ bgp_parse_capabilities(struct bgp_conn *conn, byte *opt, int len)
 	  conn->peer_enhanced_refresh_support = 1;
 	  break;
 
+	case 230: /* Extended message length capability, draft, cap number TBD */
+	  if (cl != 0)
+	    goto err;
+	  conn->peer_ext_messages_support = 1;
+	  break;
+
 	  /* We can safely ignore all other capabilities */
 	}
       len -= 2 + cl;
@@ -1019,6 +1036,7 @@ bgp_rx_open(struct bgp_conn *conn, byte *pkt, int len)
   p->add_path_rx = (p->cf->add_path & ADD_PATH_RX) && (conn->peer_add_path & ADD_PATH_TX);
   p->add_path_tx = (p->cf->add_path & ADD_PATH_TX) && (conn->peer_add_path & ADD_PATH_RX);
   p->gr_ready = p->cf->gr_mode && conn->peer_gr_able;
+  p->ext_messages = p->cf->enable_extended_messages && conn->peer_ext_messages_support;
 
   if (p->add_path_tx)
     p->p.accept_ra_types = RA_ANY;
@@ -1418,7 +1436,7 @@ static struct {
   { 2, 4, "Unsupported optional parameter" },
   { 2, 5, "Authentication failure" },
   { 2, 6, "Unacceptable hold time" },
-  { 2, 7, "Required capability missing" }, /* [RFC3392] */
+  { 2, 7, "Required capability missing" }, /* [RFC5492] */
   { 2, 8, "No supported AFI/SAFI" }, /* This error msg is nonstandard */
   { 3, 0, "Invalid UPDATE message" },
   { 3, 1, "Malformed attribute list" },
@@ -1666,6 +1684,7 @@ int
 bgp_rx(sock *sk, int size)
 {
   struct bgp_conn *conn = sk->data;
+  struct bgp_proto *p = conn->bgp;
   byte *pkt_start = sk->rbuf;
   byte *end = pkt_start + size;
   unsigned i, len;
@@ -1682,7 +1701,7 @@ bgp_rx(sock *sk, int size)
 	    break;
 	  }
       len = get_u16(pkt_start+16);
-      if (len < BGP_HEADER_LENGTH || len > BGP_MAX_PACKET_LENGTH)
+      if (len < BGP_HEADER_LENGTH || len > bgp_max_packet_length(p))
 	{
 	  bgp_error(conn, 1, 2, pkt_start+16, 2);
 	  break;

From 6683d42d5b560c8805b977736b2a769ea2d9aa8b Mon Sep 17 00:00:00 2001
From: Ondrej Zajicek <santiago@crfreenet.org>
Date: Sat, 18 Jul 2015 19:05:11 +0200
Subject: [PATCH 018/165] Documentation update

---
 doc/bird.sgml | 25 ++++++++++++++++++++++---
 1 file changed, 22 insertions(+), 3 deletions(-)

diff --git a/doc/bird.sgml b/doc/bird.sgml
index 2ae9f649..df83aacd 100644
--- a/doc/bird.sgml
+++ b/doc/bird.sgml
@@ -1707,7 +1707,11 @@ using the following configuration parameters:
 	<cf/bgp_next_hop/ is used if it is directly reachable, otherwise the
 	neighbor IP address is used. Recursive mode means that the gateway is
 	computed by an IGP routing table lookup for the IP address from
-	<cf/bgp_next_hop/. Recursive mode is the behavior specified by the BGP
+	<cf/bgp_next_hop/. Note that there is just one level of indirection in
+	recursive mode - the route obtained by the lookup must not be recursive
+	itself, to prevent mutually recursive routes.
+
+	Recursive mode is the behavior specified by the BGP
 	standard. Direct mode is simpler, does not require any routes in a
 	routing table, and was used in older versions of BIRD, but does not
 	handle well nontrivial iBGP setups and multihop. Recursive mode is
@@ -2081,7 +2085,6 @@ interfaces to be defined for them to work with.
 <p><descrip>
 
 	<tag>scan time <m/number/</tag>
-
 	Time in seconds between two scans of the network interface list. On
 	systems where we are notified about interface status changes
 	asynchronously (such as newer versions of Linux), we need to scan the
@@ -2266,6 +2269,20 @@ these attributes:
 	The realm of the route. Can be used for traffic classification.
 </descrip>
 
+<p>In Linux, there is also a plenty of obscure route attributes mostly focused
+on tuning TCP performance of local connections. BIRD supports most of these
+attributes, see Linux or iproute2 documentation for their meaning. Attributes
+<cf/krt_lock_*/ and <cf/krt_feature_*/ have type bool, others have type int.
+Supported attributes are:
+
+<cf/krt_mtu/, <cf/krt_lock_mtu/, <cf/krt_window/, <cf/krt_lock_window/,
+<cf/krt_rtt/, <cf/krt_lock_rtt/, <cf/krt_rttvar/, <cf/krt_lock_rttvar/,
+<cf/krt_sstresh/, <cf/krt_lock_sstresh/, <cf/krt_cwnd/, <cf/krt_lock_cwnd/,
+<cf/krt_advmss/, <cf/krt_lock_advmss/, <cf/krt_reordering/, <cf/krt_lock_reordering/,
+<cf/krt_hoplimit/, <cf/krt_lock_hoplimit/, <cf/krt_rto_min/, <cf/krt_lock_rto_min/,
+<cf/krt_initcwnd/, <cf/krt_initrwnd/, <cf/krt_quickack/,
+<cf/krt_feature_ecn/, <cf/krt_feature_allfrag/
+
 <sect1>Example
 
 <p>A simple configuration can look this way:
@@ -3394,7 +3411,9 @@ of the protocol contains mainly a list of static routes:
 
 <descrip>
 	<tag>route <m/prefix/ via <m/ip/</tag>
-	Static route through a neighboring router.
+	Static route through a neighboring router. For link-local next hops,
+	interface can be specified as a part of the address (e.g.,
+	<cf/via fe80::1234%eth0/).
 
 	<tag>route <m/prefix/ multipath via <m/ip/ [weight <m/num/] [via ...]</tag>
 	Static multipath route. Contains several nexthops (gateways), possibly

From 17661ff934a80d517284c96756357d4ed5af9a64 Mon Sep 17 00:00:00 2001
From: Ondrej Zajicek <santiago@crfreenet.org>
Date: Sat, 18 Jul 2015 19:30:35 +0200
Subject: [PATCH 019/165] Nest: Fixes symbols in router id

Thanks to Peter Hudec for noticing the problem.
---
 nest/config.Y | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/nest/config.Y b/nest/config.Y
index 37551802..7ad6c712 100644
--- a/nest/config.Y
+++ b/nest/config.Y
@@ -94,6 +94,7 @@ rtrid:
 
 idval:
    NUM { $$ = $1; }
+ | '(' term ')' { $$ = f_eval_int($2); }
  | RTRID
  | IPA {
 #ifndef IPV6
@@ -102,6 +103,16 @@ idval:
      cf_error("Router IDs must be entered as hexadecimal numbers or IPv4 addresses in IPv6 version");
 #endif
    }
+ | SYM {
+     if ($1->class == (SYM_CONSTANT | T_INT) || $1->class == (SYM_CONSTANT | T_QUAD))
+       $$ = SYM_VAL($1).i;
+#ifndef IPV6
+     else if ($1->class == (SYM_CONSTANT | T_IP))
+       $$ = SYM_VAL($1).px.ip;
+#endif
+     else
+       cf_error("Number of IPv4 address constant expected");
+   }
  ;
 
 

From a8ad8fd6491d04620fe4fdebc50f0da2927f9b21 Mon Sep 17 00:00:00 2001
From: Ondrej Zajicek <santiago@crfreenet.org>
Date: Sat, 18 Jul 2015 23:15:04 +0200
Subject: [PATCH 020/165] Simplify build messages

Thanks to Christian Tacke for the original patch.
---
 tools/Makefile.in | 9 ++++++---
 tools/Rules.in    | 6 ++++--
 2 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/tools/Makefile.in b/tools/Makefile.in
index 062ba916..01bb7a7c 100644
--- a/tools/Makefile.in
+++ b/tools/Makefile.in
@@ -37,13 +37,16 @@ subdir: sysdep/paths.h .dir-stamp .dep-stamp
 	set -e ; for a in $(static-dirs) $(client-dirs) ; do $(MAKE) -C $$a -f $(srcdir_abs)/$$a/Makefile $@ ; done
 
 $(exedir)/bird: $(bird-dep)
-	$(CC) $(LDFLAGS) -o $@ $^ $(LIBS)
+	@echo LD $(LDFLAGS) -o $@ $^ $(LIBS)
+	@$(CC) $(LDFLAGS) -o $@ $^ $(LIBS)
 
 $(exedir)/birdc: $(birdc-dep)
-	$(CC) $(LDFLAGS) -o $@ $^ $(LIBS) $(CLIENT_LIBS)
+	@echo LD $(LDFLAGS) -o $@ $^ $(LIBS) $(CLIENT_LIBS)
+	@$(CC) $(LDFLAGS) -o $@ $^ $(LIBS) $(CLIENT_LIBS)
 
 $(exedir)/birdcl: $(birdcl-dep)
-	$(CC) $(LDFLAGS) -o $@ $^ $(LIBS)
+	@echo LD $(LDFLAGS) -o $@ $^ $(LIBS)
+	@$(CC) $(LDFLAGS) -o $@ $^ $(LIBS)
 
 .dir-stamp: sysdep/paths.h
 	mkdir -p $(static-dirs) $(client-dirs) $(doc-dirs)
diff --git a/tools/Rules.in b/tools/Rules.in
index ca930ec8..f00c85d1 100644
--- a/tools/Rules.in
+++ b/tools/Rules.in
@@ -68,12 +68,14 @@ subdir: all.o
 all.o: $(objs)
 #       $(LD) -r -o $@ $^
 #	Changed to $(CC) because $(LD) has problems with crosscompiling
-	$(CC) -nostdlib -r -o $@ $^
+	@echo LD -r -o $@ $^
+	@$(CC) -nostdlib -r -o $@ $^
 
 endif
 
 %.o: $(src-path)%.c
-	$(CC) $(CFLAGS) -o $@ -c $<
+	@echo CC -o $@ -c $<
+	@$(CC) $(CFLAGS) -o $@ -c $<
 
 ifndef source-dep
 source-dep := $(source)

From ffa398b8d8bac4cf6368fe700466cad4ff12fee8 Mon Sep 17 00:00:00 2001
From: Ondrej Zajicek <santiago@crfreenet.org>
Date: Sun, 19 Jul 2015 11:39:24 +0200
Subject: [PATCH 021/165] BFD: Fixes crash after socket error

Thanks to Thomas King for the bugreport.
---
 proto/bfd/bfd.c     | 28 ++++++++++++++++------------
 proto/bfd/packets.c |  8 ++++++--
 2 files changed, 22 insertions(+), 14 deletions(-)

diff --git a/proto/bfd/bfd.c b/proto/bfd/bfd.c
index 5f089846..7a085791 100644
--- a/proto/bfd/bfd.c
+++ b/proto/bfd/bfd.c
@@ -43,7 +43,7 @@
  * the needs of BFD sessions. When a new session is created, it requests a
  * proper BFD interface by function bfd_get_iface(), which either finds an
  * existing one in &iface_list (from &bfd_proto) or allocates a new one. When a
- * session is removed, an associated iface is dicharged by bfd_free_iface().
+ * session is removed, an associated iface is discharged by bfd_free_iface().
  *
  * BFD requests are the external API for the other protocols. When a protocol
  * wants a BFD session, it calls bfd_request_session(), which creates a
@@ -62,7 +62,7 @@
  * configuration (like static routes in the static protocol). BFD neighbors are
  * handled by BFD protocol like it is a BFD client -- when a BFD neighbor is
  * ready, the protocol just creates a BFD request like any other protocol.
- * 
+ *
  * The protocol uses a new generic event loop (structure &birdloop) from |io.c|,
  * which supports sockets, timers and events like the main loop. Timers
  * (structure &timer2) are new microsecond based timers, while sockets and
@@ -129,11 +129,11 @@ static inline void bfd_notify_kick(struct bfd_proto *p);
  *	BFD sessions
  */
 
-static void 
+static void
 bfd_session_update_state(struct bfd_session *s, uint state, uint diag)
 {
   struct bfd_proto *p = s->ifa->bfd;
-  uint old_state = s->loc_state; 
+  uint old_state = s->loc_state;
   int notify;
 
   if (state == old_state)
@@ -201,8 +201,8 @@ bfd_session_control_tx_timer(struct bfd_session *s, int reset)
   if (s->passive && (s->rem_id == 0))
     goto stop;
 
-  if (s->rem_demand_mode && 
-      !s->poll_active && 
+  if (s->rem_demand_mode &&
+      !s->poll_active &&
       (s->loc_state == BFD_STATE_UP) &&
       (s->rem_state == BFD_STATE_UP))
     goto stop;
@@ -303,7 +303,7 @@ bfd_session_process_ctl(struct bfd_session *s, u8 flags, u32 old_tx_int, u32 old
     bfd_send_ctl(s->ifa->bfd, s, 1);
 }
 
-static void 
+static void
 bfd_session_timeout(struct bfd_session *s)
 {
   struct bfd_proto *p = s->ifa->bfd;
@@ -353,7 +353,7 @@ bfd_session_set_min_rx(struct bfd_session *s, u32 val)
   if (val == s->req_min_rx_new)
     return;
 
-  s->req_min_rx_new = val; 
+  s->req_min_rx_new = val;
 
   /* Postpone timer update if req_min_rx_int decreases and the session is up */
   if ((s->loc_state != BFD_STATE_UP) || (val > s->req_min_rx_int))
@@ -575,9 +575,13 @@ bfd_free_iface(struct bfd_iface *ifa)
   if (!ifa || --ifa->uc)
     return;
 
+  if (ifa->sk)
+  {
+    sk_stop(ifa->sk);
+    rfree(ifa->sk);
+  }
+
   rem_node(&ifa->n);
-  sk_stop(ifa->sk);
-  rfree(ifa->sk);
   mb_free(ifa);
 }
 
@@ -873,7 +877,7 @@ bfd_notify_hook(sock *sk, int len)
     diag = s->loc_diag;
     bfd_unlock_sessions(p);
 
-    /* FIXME: convert to btime and move to bfd_session_update_state() */ 
+    /* FIXME: convert to btime and move to bfd_session_update_state() */
     s->last_state_change = now;
 
     s->notify_running = 1;
@@ -1092,7 +1096,7 @@ bfd_show_sessions(struct proto *P)
     /* FIXME: this is thread-unsafe, but perhaps harmless */
     state = s->loc_state;
     diag = s->loc_diag;
-    ifname = (s->ifa && s->ifa->sk->iface) ? s->ifa->sk->iface->name : "---";
+    ifname = (s->ifa && s->ifa->iface) ? s->ifa->iface->name : "---";
     tx_int = s->last_tx ? (MAX(s->des_min_tx_int, s->rem_min_rx_int) TO_MS) : 0;
     timeout = (MAX(s->req_min_rx_int, s->rem_min_tx_int) TO_MS) * s->rem_detect_mult;
 
diff --git a/proto/bfd/packets.c b/proto/bfd/packets.c
index b5fd6782..cb40bcda 100644
--- a/proto/bfd/packets.c
+++ b/proto/bfd/packets.c
@@ -63,9 +63,13 @@ void
 bfd_send_ctl(struct bfd_proto *p, struct bfd_session *s, int final)
 {
   sock *sk = s->ifa->sk;
-  struct bfd_ctl_packet *pkt = (struct bfd_ctl_packet *) sk->tbuf;
+  struct bfd_ctl_packet *pkt;
   char fb[8];
 
+  if (!sk)
+    return;
+
+  pkt = (struct bfd_ctl_packet *) sk->tbuf;
   pkt->vdiag = bfd_pack_vdiag(1, s->loc_diag);
   pkt->flags = bfd_pack_flags(s->loc_state, 0);
   pkt->detect_mult = s->detect_mult;
@@ -139,7 +143,7 @@ bfd_rx_hook(sock *sk, int len)
     u8 ps = bfd_pkt_get_state(pkt);
     if (ps > BFD_STATE_DOWN)
       DROP("invalid init state", ps);
-      
+
     s = bfd_find_session_by_addr(p, sk->faddr);
 
     /* FIXME: better session matching and message */

From 1321e12ac460bd542d3946a0c4a4dacd71157cfa Mon Sep 17 00:00:00 2001
From: Ondrej Zajicek <santiago@crfreenet.org>
Date: Mon, 20 Jul 2015 11:12:02 +0200
Subject: [PATCH 022/165] Static: Allows to specify attributes for static
 routes

The patch adds suport for specifying route attributes together with
static routes, e.g.:

 route 10.1.1.0/24 via 10.0.0.1 { krt_advmss = 1200; ospf_metric1 = 100; };
---
 filter/filter.c       | 24 ++++++++++++++++++++++++
 filter/filter.h       |  1 +
 proto/ospf/ospf.c     | 17 ++++++++++++++---
 proto/static/config.Y | 19 ++++++++++++++++++-
 proto/static/static.c | 30 +++++++++++++++++++++++++-----
 proto/static/static.h |  1 +
 6 files changed, 83 insertions(+), 9 deletions(-)

diff --git a/filter/filter.c b/filter/filter.c
index 3f8968aa..55062aca 100644
--- a/filter/filter.c
+++ b/filter/filter.c
@@ -1527,6 +1527,30 @@ f_run(struct filter *filter, struct rte **rte, struct ea_list **tmp_attrs, struc
   return res.val.i;
 }
 
+/* TODO: perhaps we could integrate f_eval(), f_eval_rte() and f_run() */
+
+struct f_val
+f_eval_rte(struct f_inst *expr, struct rte **rte, struct linpool *tmp_pool)
+{
+  struct ea_list *tmp_attrs = NULL;
+
+  f_rte = rte;
+  f_old_rta = NULL;
+  f_tmp_attrs = &tmp_attrs;
+  f_pool = tmp_pool;
+  f_flags = 0;
+
+  LOG_BUFFER_INIT(f_buf);
+
+  /* Note that in this function we assume that rte->attrs is private / uncached */
+  struct f_val res = interpret(expr);
+
+  /* Hack to include EAF_TEMP attributes to the main list */
+  (*rte)->attrs->eattrs = ea_append(tmp_attrs, (*rte)->attrs->eattrs);
+
+  return res;
+}
+
 struct f_val
 f_eval(struct f_inst *expr, struct linpool *tmp_pool)
 {
diff --git a/filter/filter.h b/filter/filter.h
index 2b2d23c2..e59c8226 100644
--- a/filter/filter.h
+++ b/filter/filter.h
@@ -107,6 +107,7 @@ struct ea_list;
 struct rte;
 
 int f_run(struct filter *filter, struct rte **rte, struct ea_list **tmp_attrs, struct linpool *tmp_pool, int flags);
+struct f_val f_eval_rte(struct f_inst *expr, struct rte **rte, struct linpool *tmp_pool);
 struct f_val f_eval(struct f_inst *expr, struct linpool *tmp_pool);
 uint f_eval_int(struct f_inst *expr);
 u32 f_eval_asn(struct f_inst *expr);
diff --git a/proto/ospf/ospf.c b/proto/ospf/ospf.c
index 1bc4e077..d5d5d354 100644
--- a/proto/ospf/ospf.c
+++ b/proto/ospf/ospf.c
@@ -450,10 +450,21 @@ ospf_import_control(struct proto *P, rte **new, ea_list **attrs, struct linpool
   if (oa_is_stub(oa))
     return -1;			/* Do not export routes to stub areas */
 
-  eattr *ea = ea_find(e->attrs->eattrs, EA_GEN_IGP_METRIC);
-  u32 m1 = (ea && (ea->u.data < LSINFINITY)) ? ea->u.data : LSINFINITY;
+  ea_list *ea = e->attrs->eattrs;
+  u32 m0 = ea_get_int(ea, EA_GEN_IGP_METRIC, LSINFINITY);
+  u32 m1 = MIN(m0, LSINFINITY);
+  u32 m2 = 10000;
+  u32 tag = 0;
+
+  /* Hack for setting attributes directly in static protocol */
+  if (e->attrs->source == RTS_STATIC)
+  {
+    m1 = ea_get_int(ea, EA_OSPF_METRIC1, m1);
+    m2 = ea_get_int(ea, EA_OSPF_METRIC2, 10000);
+    tag = ea_get_int(ea, EA_OSPF_TAG, 0);
+  }
 
-  *attrs = ospf_build_attrs(*attrs, pool, m1, 10000, 0, 0);
+  *attrs = ospf_build_attrs(*attrs, pool, m1, m2, tag, 0);
   return 0;			/* Leave decision to the filters */
 }
 
diff --git a/proto/static/config.Y b/proto/static/config.Y
index a8bfa36f..d1b62af9 100644
--- a/proto/static/config.Y
+++ b/proto/static/config.Y
@@ -14,6 +14,7 @@ CF_DEFINES
 
 #define STATIC_CFG ((struct static_config *) this_proto)
 static struct static_route *this_srt, *this_srt_nh, *last_srt_nh;
+static struct f_inst **this_srt_last_cmd;
 
 CF_DECLS
 
@@ -36,7 +37,7 @@ static_proto:
  | static_proto proto_item ';'
  | static_proto CHECK LINK bool ';' { STATIC_CFG->check_link = $4; }
  | static_proto IGP TABLE rtable ';' { STATIC_CFG->igp_table = $4; }
- | static_proto stat_route ';'
+ | static_proto stat_route stat_route_opt_list ';'
  ;
 
 stat_route0: ROUTE prefix {
@@ -44,6 +45,7 @@ stat_route0: ROUTE prefix {
      add_tail(&STATIC_CFG->other_routes, &this_srt->n);
      this_srt->net = $2.addr;
      this_srt->masklen = $2.len;
+     this_srt_last_cmd = &(this_srt->cmds);
   }
  ;
 
@@ -94,6 +96,21 @@ stat_route:
  | stat_route0 PROHIBIT		{ this_srt->dest = RTD_PROHIBIT; }
  ;
 
+stat_route_item:
+   cmd { *this_srt_last_cmd = $1; this_srt_last_cmd = &($1->next); }
+ ;
+
+stat_route_opts:
+   /* empty */
+ | stat_route_opts stat_route_item
+ ;
+
+stat_route_opt_list:
+   /* empty */
+ | '{' stat_route_opts '}'
+ ;
+
+
 CF_CLI(SHOW STATIC, optsym, [<name>], [[Show details of static protocol]])
 { static_show(proto_get_named($3, &proto_static)); } ;
 
diff --git a/proto/static/static.c b/proto/static/static.c
index e7e7ab15..57c44885 100644
--- a/proto/static/static.c
+++ b/proto/static/static.c
@@ -42,11 +42,14 @@
 #include "nest/route.h"
 #include "nest/cli.h"
 #include "conf/conf.h"
+#include "filter/filter.h"
 #include "lib/string.h"
 #include "lib/alloca.h"
 
 #include "static.h"
 
+static linpool *static_lp;
+
 static inline rtable *
 p_igp_table(struct proto *p)
 {
@@ -54,12 +57,11 @@ p_igp_table(struct proto *p)
   return cf->igp_table ? cf->igp_table->table : p->table;
 }
 
-
 static void
 static_install(struct proto *p, struct static_route *r, struct iface *ifa)
 {
   net *n;
-  rta a, *aa;
+  rta a;
   rte *e;
 
   if (r->installed > 0)
@@ -108,13 +110,21 @@ static_install(struct proto *p, struct static_route *r, struct iface *ifa)
   if (r->dest == RTDX_RECURSIVE)
     rta_set_recursive_next_hop(p->table, &a, p_igp_table(p), &r->via, &r->via);
 
-  aa = rta_lookup(&a);
+  /* We skip rta_lookup() here */
+
   n = net_get(p->table, r->net, r->masklen);
-  e = rte_get_temp(aa);
+  e = rte_get_temp(&a);
   e->net = n;
   e->pflags = 0;
+
+  if (r->cmds)
+    f_eval_rte(r->cmds, &e, static_lp);
+
   rte_update(p, n, e);
   r->installed = 1;
+
+  if (r->cmds)
+    lp_flush(static_lp);
 }
 
 static void
@@ -220,6 +230,9 @@ static_start(struct proto *p)
 
   DBG("Static: take off!\n");
 
+  if (!static_lp)
+    static_lp = lp_new(&root_pool, 1008);
+
   if (cf->igp_table)
     rt_lock_table(cf->igp_table->table);
 
@@ -413,6 +426,13 @@ static_same_dest(struct static_route *x, struct static_route *y)
     }
 }
 
+static inline int
+static_same_rte(struct static_route *x, struct static_route *y)
+{
+  return static_same_dest(x, y) && i_same(x->cmds, y->cmds);
+}
+
+
 static void
 static_match(struct proto *p, struct static_route *r, struct static_config *n)
 {
@@ -441,7 +461,7 @@ static_match(struct proto *p, struct static_route *r, struct static_config *n)
 
  found:
   /* If destination is different, force reinstall */
-  if ((r->installed > 0) && !static_same_dest(r, t))
+  if ((r->installed > 0) && !static_same_rte(r, t))
     t->installed = -1;
   else
     t->installed = r->installed;
diff --git a/proto/static/static.h b/proto/static/static.h
index 99a0e68b..f197d352 100644
--- a/proto/static/static.h
+++ b/proto/static/static.h
@@ -31,6 +31,7 @@ struct static_route {
   struct neighbor *neigh;
   byte *if_name;			/* Name for RTD_DEVICE routes */
   struct static_route *mp_next;		/* Nexthops for RTD_MULTIPATH routes */
+  struct f_inst *cmds;			/* List of commands for setting attributes */
   int installed;			/* Installed in rt table, -1 for reinstall */
 };
 

From 538264cf1a7690d90b2953aebff21958c2b55c44 Mon Sep 17 00:00:00 2001
From: Ondrej Zajicek <santiago@crfreenet.org>
Date: Fri, 24 Jul 2015 18:02:07 +0200
Subject: [PATCH 023/165] Static: Support for BFD controlled static routes

---
 nest/bfd.h            |   6 ++
 proto/static/config.Y |  21 +++++-
 proto/static/static.c | 148 ++++++++++++++++++++++++++++++++----------
 proto/static/static.h |   5 ++
 4 files changed, 142 insertions(+), 38 deletions(-)

diff --git a/nest/bfd.h b/nest/bfd.h
index 79c3c921..f1e95cb2 100644
--- a/nest/bfd.h
+++ b/nest/bfd.h
@@ -32,6 +32,12 @@ struct bfd_request {
 };
 
 
+#define BFD_STATE_ADMIN_DOWN	0
+#define BFD_STATE_DOWN		1
+#define BFD_STATE_INIT		2
+#define BFD_STATE_UP		3
+
+
 #ifdef CONFIG_BFD
 
 struct bfd_request * bfd_request_session(pool *p, ip_addr addr, ip_addr local, struct iface *iface, void (*hook)(struct bfd_request *), void *data);
diff --git a/proto/static/config.Y b/proto/static/config.Y
index d1b62af9..182721b3 100644
--- a/proto/static/config.Y
+++ b/proto/static/config.Y
@@ -16,10 +16,22 @@ CF_DEFINES
 static struct static_route *this_srt, *this_srt_nh, *last_srt_nh;
 static struct f_inst **this_srt_last_cmd;
 
+static void
+static_route_finish(void)
+{
+  struct static_route *r;
+
+  /* Update undefined use_bfd entries in multipath nexthops */
+  if (this_srt->dest == RTD_MULTIPATH)
+    for (r = this_srt->mp_next; r; r = r->mp_next)
+      if (r->use_bfd < 0)
+        r->use_bfd = this_srt->use_bfd;
+}
+
 CF_DECLS
 
 CF_KEYWORDS(STATIC, ROUTE, VIA, DROP, REJECT, PROHIBIT, PREFERENCE, CHECK, LINK)
-CF_KEYWORDS(MULTIPATH, WEIGHT, RECURSIVE, IGP, TABLE, BLACKHOLE, UNREACHABLE)
+CF_KEYWORDS(MULTIPATH, WEIGHT, RECURSIVE, IGP, TABLE, BLACKHOLE, UNREACHABLE, BFD)
 
 
 CF_GRAMMAR
@@ -37,7 +49,7 @@ static_proto:
  | static_proto proto_item ';'
  | static_proto CHECK LINK bool ';' { STATIC_CFG->check_link = $4; }
  | static_proto IGP TABLE rtable ';' { STATIC_CFG->igp_table = $4; }
- | static_proto stat_route stat_route_opt_list ';'
+ | static_proto stat_route stat_route_opt_list ';' { static_route_finish(); }
  ;
 
 stat_route0: ROUTE prefix {
@@ -57,11 +69,15 @@ stat_multipath1:
      this_srt_nh->via = $2;
      this_srt_nh->via_if = $3;
      this_srt_nh->if_name = (void *) this_srt; /* really */
+     this_srt_nh->use_bfd = -1; /* undefined */
    }
  | stat_multipath1 WEIGHT expr {
      this_srt_nh->masklen = $3 - 1; /* really */
      if (($3<1) || ($3>256)) cf_error("Weight must be in range 1-256"); 
    }
+ | stat_multipath1 BFD bool {
+     this_srt_nh->use_bfd = $3; cf_check_bfd($3);
+   }
  ;
 
 stat_multipath:
@@ -98,6 +114,7 @@ stat_route:
 
 stat_route_item:
    cmd { *this_srt_last_cmd = $1; this_srt_last_cmd = &($1->next); }
+ | BFD bool ';' { this_srt->use_bfd = $2; cf_check_bfd($2); }
  ;
 
 stat_route_opts:
diff --git a/proto/static/static.c b/proto/static/static.c
index 57c44885..be808593 100644
--- a/proto/static/static.c
+++ b/proto/static/static.c
@@ -141,6 +141,29 @@ static_remove(struct proto *p, struct static_route *r)
   r->installed = 0;
 }
 
+static void
+static_bfd_notify(struct bfd_request *req);
+
+static void
+static_update_bfd(struct proto *p, struct static_route *r)
+{
+  struct neighbor *nb = r->neigh;
+  int bfd_up = (nb->scope > 0) && r->use_bfd;
+
+  if (bfd_up && !r->bfd_req)
+  {
+    // ip_addr local = ipa_nonzero(r->local) ? r->local : nb->ifa->ip;
+    r->bfd_req = bfd_request_session(p->pool, r->via, nb->ifa->ip, nb->iface,
+				     static_bfd_notify, r);
+  }
+
+  if (!bfd_up && r->bfd_req)
+  {
+    rfree(r->bfd_req);
+    r->bfd_req = NULL;
+  }
+}
+
 static int
 static_decide(struct static_config *cf, struct static_route *r)
 {
@@ -153,6 +176,9 @@ static_decide(struct static_config *cf, struct static_route *r)
   if (cf->check_link && !(r->neigh->iface->flags & IF_LINK_UP))
     return 0;
 
+  if (r->bfd_req && r->bfd_req->state != BFD_STATE_UP)
+    return 0;
+
   return 1;
 }
 
@@ -171,6 +197,8 @@ static_add(struct proto *p, struct static_config *cf, struct static_route *r)
 	    r->chain = n->data;
 	    n->data = r;
 	    r->neigh = n;
+
+	    static_update_bfd(p, r);
 	    if (static_decide(cf, r))
 	      static_install(p, r, n->iface);
 	    else
@@ -200,6 +228,8 @@ static_add(struct proto *p, struct static_config *cf, struct static_route *r)
 		r2->chain = n->data;
 		n->data = r2;
 		r2->neigh = n;
+
+		static_update_bfd(p, r2);
 		r2->installed = static_decide(cf, r2);
 		count += r2->installed;
 	      }
@@ -222,6 +252,26 @@ static_add(struct proto *p, struct static_config *cf, struct static_route *r)
     }
 }
 
+static void
+static_rte_cleanup(struct proto *p, struct static_route *r)
+{
+  struct static_route *r2;
+
+  if (r->bfd_req)
+  {
+    rfree(r->bfd_req);
+    r->bfd_req = NULL;
+  }
+
+  if (r->dest == RTD_MULTIPATH)
+    for (r2 = r->mp_next; r2; r2 = r2->mp_next)
+      if (r2->bfd_req)
+      {
+	rfree(r2->bfd_req);
+	r2->bfd_req = NULL;
+      }
+}
+
 static int
 static_start(struct proto *p)
 {
@@ -254,7 +304,10 @@ static_shutdown(struct proto *p)
   WALK_LIST(r, cf->iface_routes)
     r->installed = 0;
   WALK_LIST(r, cf->other_routes)
+  {
+    static_rte_cleanup(p, r);
     r->installed = 0;
+  }
 
   return PS_DOWN;
 }
@@ -268,6 +321,44 @@ static_cleanup(struct proto *p)
     rt_unlock_table(cf->igp_table->table);
 }
 
+static void
+static_update_rte(struct proto *p, struct static_route *r)
+{
+  switch (r->dest)
+  {
+  case RTD_ROUTER:
+    if (static_decide((struct static_config *) p->cf, r))
+      static_install(p, r, r->neigh->iface);
+    else
+      static_remove(p, r);
+    break;
+
+  case RTD_NONE: /* a part of multipath route */
+  {
+    int decision = static_decide((struct static_config *) p->cf, r);
+    if (decision == r->installed)
+      break; /* no change */
+    r->installed = decision;
+
+    struct static_route *r1, *r2;
+    int count = 0;
+    r1 = (void *) r->if_name; /* really */
+    for (r2 = r1->mp_next; r2; r2 = r2->mp_next)
+      count += r2->installed;
+
+    if (count)
+    {
+      /* Set of nexthops changed - force reinstall */
+      r1->installed = 0;
+      static_install(p, r1, NULL);
+    }
+    else
+      static_remove(p, r1);
+
+    break;
+  }
+  }
+}
 
 static void
 static_neigh_notify(struct neighbor *n)
@@ -277,40 +368,21 @@ static_neigh_notify(struct neighbor *n)
 
   DBG("Static: neighbor notify for %I: iface %p\n", n->addr, n->iface);
   for(r=n->data; r; r=r->chain)
-    switch (r->dest)
-      {
-      case RTD_ROUTER:
-	if (static_decide((struct static_config *) p->cf, r))
-	  static_install(p, r, n->iface);
-	else
-	  static_remove(p, r);
-	break;
+  {
+    static_update_bfd(p, r);
+    static_update_rte(p, r);
+  }
+}
 
-      case RTD_NONE: /* a part of multipath route */
-	{
-	  int decision = static_decide((struct static_config *) p->cf, r);
-	  if (decision == r->installed)
-	    break; /* no change */
-	  r->installed = decision;
-
-	  struct static_route *r1, *r2;
-	  int count = 0;
-	  r1 = (void *) r->if_name; /* really */
-	  for (r2 = r1->mp_next; r2; r2 = r2->mp_next)
-	    count += r2->installed;
-
-	  if (count)
-	    {
-	      /* Set of nexthops changed - force reinstall */
-	      r1->installed = 0;
-	      static_install(p, r1, NULL);
-	    }
-	  else
-	    static_remove(p, r1);
+static void
+static_bfd_notify(struct bfd_request *req)
+{
+  struct static_route *r = req->data;
+  struct proto *p = r->neigh->proto;
 
-	  break;
-	}
-      }
+  // if (req->down) TRACE(D_EVENTS, "BFD session down for nbr %I on %s", XXXX);
+
+  static_update_rte(p, r);
 }
 
 static void
@@ -414,7 +486,7 @@ static_same_dest(struct static_route *x, struct static_route *y)
       for (x = x->mp_next, y = y->mp_next;
 	   x && y;
 	   x = x->mp_next, y = y->mp_next)
-	if (!ipa_equal(x->via, y->via) || (x->via_if != y->via_if))
+	if (!ipa_equal(x->via, y->via) || (x->via_if != y->via_if) || (x->use_bfd != y->use_bfd))
 	  return 0;
       return !x && !y;
 
@@ -499,6 +571,9 @@ static_reconfigure(struct proto *p, struct proto_config *new)
   WALK_LIST(r, n->other_routes)
     static_add(p, n, r);
 
+  WALK_LIST(r, o->other_routes)
+    static_rte_cleanup(p, r);
+
   return 1;
 }
 
@@ -584,13 +659,14 @@ static_show_rt(struct static_route *r)
     case RTDX_RECURSIVE: bsprintf(via, "recursive %I", r->via); break;
     default:		bsprintf(via, "???");
     }
-  cli_msg(-1009, "%I/%d %s%s", r->net, r->masklen, via, r->installed ? "" : " (dormant)");
+  cli_msg(-1009, "%I/%d %s%s%s", r->net, r->masklen, via,
+	  r->bfd_req ? " (bfd)" : "", r->installed ? "" : " (dormant)");
 
   struct static_route *r2;
   if (r->dest == RTD_MULTIPATH)
     for (r2 = r->mp_next; r2; r2 = r2->mp_next)
-      cli_msg(-1009, "\tvia %I%J weight %d%s", r2->via, r2->via_if, r2->masklen + 1, /* really */
-	      r2->installed ? "" : " (dormant)");
+      cli_msg(-1009, "\tvia %I%J weight %d%s%s", r2->via, r2->via_if, r2->masklen + 1, /* really */
+	      r2->bfd_req ? " (bfd)" : "", r2->installed ? "" : " (dormant)");
 }
 
 void
diff --git a/proto/static/static.h b/proto/static/static.h
index f197d352..6b047234 100644
--- a/proto/static/static.h
+++ b/proto/static/static.h
@@ -9,6 +9,9 @@
 #ifndef _BIRD_STATIC_H_
 #define _BIRD_STATIC_H_
 
+#include "nest/route.h"
+#include "nest/bfd.h"
+
 struct static_config {
   struct proto_config c;
   list iface_routes;		/* Routes to search on interface events */
@@ -33,6 +36,8 @@ struct static_route {
   struct static_route *mp_next;		/* Nexthops for RTD_MULTIPATH routes */
   struct f_inst *cmds;			/* List of commands for setting attributes */
   int installed;			/* Installed in rt table, -1 for reinstall */
+  int use_bfd;				/* Configured to use BFD */
+  struct bfd_request *bfd_req;		/* BFD request, if BFD is used */
 };
 
 /* Dummy nodes (parts of multipath route) abuses masklen field for weight

From 641172c6e5e4e291029084074f94f448d6bc69dd Mon Sep 17 00:00:00 2001
From: Ondrej Zajicek <santiago@crfreenet.org>
Date: Tue, 28 Jul 2015 12:35:12 +0200
Subject: [PATCH 024/165] Netlink: Fixes uninitialized variable

Thanks to Pavel Tvrdik for the bugfix
---
 sysdep/linux/netlink.c | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/sysdep/linux/netlink.c b/sysdep/linux/netlink.c
index 9f206e1c..9c9449e2 100644
--- a/sysdep/linux/netlink.c
+++ b/sysdep/linux/netlink.c
@@ -100,11 +100,12 @@ nl_request_dump(int af, int cmd)
   struct {
     struct nlmsghdr nh;
     struct rtgenmsg g;
-  } req;
-  req.nh.nlmsg_type = cmd;
-  req.nh.nlmsg_len = sizeof(req);
-  req.nh.nlmsg_flags = NLM_F_REQUEST | NLM_F_DUMP;
-  req.g.rtgen_family = af;
+  } req = {
+    .nh.nlmsg_type = cmd,
+    .nh.nlmsg_len = sizeof(req),
+    .nh.nlmsg_flags = NLM_F_REQUEST | NLM_F_DUMP,
+    .g.rtgen_family = af
+  };
   nl_send(&nl_scan, &req.nh);
 }
 

From dbf4c0cb258bd92efb54f95194f664f95ba98fd9 Mon Sep 17 00:00:00 2001
From: Ondrej Zajicek <santiago@crfreenet.org>
Date: Tue, 28 Jul 2015 12:56:51 +0200
Subject: [PATCH 025/165] Minor update to test commits

---
 README | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README b/README
index daeb18bd..5d4bd9b2 100644
--- a/README
+++ b/README
@@ -64,6 +64,7 @@ What do we support:
 	o  Static routes
 	o  Inter-table protocol
 	o  IPv6 router advertisements
+	o  Bidirectional Forwarding Detection (BFD)
 	o  Command-line interface (using the `birdc' client; to get
 	   some help, just press `?')
 	o  Soft reconfiguration -- no online commands for changing the

From c7b99a932cab1873042e356143ab71755920157a Mon Sep 17 00:00:00 2001
From: Ondrej Zajicek <santiago@crfreenet.org>
Date: Tue, 28 Jul 2015 15:08:21 +0200
Subject: [PATCH 026/165] Nest: Fixes one of previous commit

---
 nest/config.Y | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/nest/config.Y b/nest/config.Y
index 7ad6c712..799a09f9 100644
--- a/nest/config.Y
+++ b/nest/config.Y
@@ -108,7 +108,7 @@ idval:
        $$ = SYM_VAL($1).i;
 #ifndef IPV6
      else if ($1->class == (SYM_CONSTANT | T_IP))
-       $$ = SYM_VAL($1).px.ip;
+       $$ = ipa_to_u32(SYM_VAL($1).px.ip);
 #endif
      else
        cf_error("Number of IPv4 address constant expected");

From b5e76398de1d4468b4061d9ef57dd3154b2f745e Mon Sep 17 00:00:00 2001
From: Ondrej Zajicek <santiago@crfreenet.org>
Date: Wed, 19 Aug 2015 11:16:23 +0200
Subject: [PATCH 027/165] OSPF: Fixes some issues with link detection

Thanks to Bernardo Figueiredo and Israel G. Lugo for the bugreport.
---
 proto/ospf/iface.c  | 7 +++++--
 proto/ospf/packet.c | 4 ++++
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/proto/ospf/iface.c b/proto/ospf/iface.c
index 9b0f7797..77ce839a 100644
--- a/proto/ospf/iface.c
+++ b/proto/ospf/iface.c
@@ -493,8 +493,11 @@ ospf_iface_add(struct object_lock *lock)
     ifa->flood_queue = mb_allocz(ifa->pool, ifa->flood_queue_size * sizeof(void *));
   }
 
-  /* Do iface UP, unless there is no link and we use link detection */
-  ospf_iface_sm(ifa, (ifa->check_link && !(ifa->iface->flags & IF_LINK_UP)) ? ISM_LOOP : ISM_UP);
+  /* Do iface UP, unless there is no link (then wait in LOOP state) */
+  if (!ifa->check_link || (ifa->iface->flags & IF_LINK_UP))
+    ospf_iface_sm(ifa, ISM_UP);
+  else
+    ospf_iface_chstate(ifa, OSPF_IS_LOOP);
 }
 
 static inline void
diff --git a/proto/ospf/packet.c b/proto/ospf/packet.c
index fb63e61c..6b8fd7b5 100644
--- a/proto/ospf/packet.c
+++ b/proto/ospf/packet.c
@@ -231,6 +231,10 @@ ospf_rx_hook(sock *sk, int len)
   const char *err_dsc = NULL;
   uint err_val = 0;
 
+  /* Should not happen */
+  if (ifa->state <= OSPF_IS_LOOP)
+    return 1;
+
   int src_local, dst_local, dst_mcast;
   src_local = ipa_in_net(sk->faddr, ifa->addr->prefix, ifa->addr->pxlen);
   dst_local = ipa_equal(sk->laddr, ifa->addr->ip);

From 8465dccb06afffed171dc1e224e4eb5f67cc3326 Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Mon, 5 Oct 2015 12:14:50 +0200
Subject: [PATCH 028/165] Major RIP redesign

The new RIP implementation fixes plenty of old bugs and also adds support
for many new features: ECMP support, link state support, BFD support,
configurable split horizon and more. Most options are now per-interface.
---
 client/commands.c   |    2 +-
 doc/bird.sgml       |  244 ++++--
 doc/reply_codes     |    2 +
 lib/ip.c            |    4 +-
 lib/ip.h            |    7 +
 nest/password.c     |   15 +
 nest/password.h     |    3 +-
 nest/route.h        |   12 +-
 nest/rt-fib.c       |   19 +
 nest/rt-table.c     |    6 -
 proto/ospf/packet.c |    2 +-
 proto/rip/Doc       |    2 +-
 proto/rip/Makefile  |    2 +-
 proto/rip/auth.c    |  168 ----
 proto/rip/config.Y  |  207 +++--
 proto/rip/packets.c |  772 ++++++++++++++++++
 proto/rip/rip.c     | 1853 ++++++++++++++++++++++++-------------------
 proto/rip/rip.h     |  330 ++++----
 18 files changed, 2364 insertions(+), 1286 deletions(-)
 delete mode 100644 proto/rip/auth.c
 create mode 100644 proto/rip/packets.c

diff --git a/client/commands.c b/client/commands.c
index 50fcba40..226ae048 100644
--- a/client/commands.c
+++ b/client/commands.c
@@ -67,7 +67,7 @@ cmd_build_tree(void)
 	      new->plastson = &new->son;
 	      new->len = c-d;
 	      memcpy(new->token, d, c-d);
-	      new->prio = (new->len == 3 && !memcmp(new->token, "roa", 3)) ? 0 : 1; /* Hack */
+	      new->prio = (new->len == 3 && (!memcmp(new->token, "roa", 3) || !memcmp(new->token, "rip", 3))) ? 0 : 1; /* Hack */
 	    }
 	  old = new;
 	  while (isspace(*c))
diff --git a/doc/bird.sgml b/doc/bird.sgml
index df83aacd..86df0456 100644
--- a/doc/bird.sgml
+++ b/doc/bird.sgml
@@ -2476,7 +2476,7 @@ protocol ospf &lt;name&gt; {
 	This option specifies whether OSPF is allowed to generate ECMP
 	(equal-cost multipath) routes. Such routes are used when there are
 	several directions to the destination, each with the same (computed)
-	cost. This option also allows to specify a limit on maximal number of
+	cost. This option also allows to specify a limit on maximum number of
 	nexthops in one route. By default, ECMP is disabled. If enabled,
 	default	value of the limit is 16.
 
@@ -3244,16 +3244,14 @@ one). After some time, the distance reaches infinity (that's 15 in RIP) and all
 routers know that network is unreachable. RIP tries to minimize situations where
 counting to infinity is necessary, because it is slow. Due to infinity being 16,
 you can't use RIP on networks where maximal distance is higher than 15
-hosts. You can read more about RIP at
-<HTMLURL URL="http://www.ietf.org/html.charters/rip-charter.html"
-name="http://www.ietf.org/html.charters/rip-charter.html">. Both IPv4
-(RFC 1723 <htmlurl url="ftp://ftp.rfc-editor.org/in-notes/rfc1723.txt">) and IPv6
-(RFC 2080 <htmlurl url="ftp://ftp.rfc-editor.org/in-notes/rfc2080.txt">) versions
-of RIP are supported by BIRD, historical RIPv1
-(RFC 1058 <htmlurl url="ftp://ftp.rfc-editor.org/in-notes/rfc1058.txt">) is not
-currently supported. RIPv4 MD5 authentication
-(RFC 2082 <htmlurl url="ftp://ftp.rfc-editor.org/in-notes/rfc2082.txt">) is
-supported.
+hosts.
+
+<p>BIRD supports RIPv1
+(RFC 1058<htmlurl url="http://www.rfc-editor.org/rfc/rfc1058.txt">),
+RIPv2 (RFC 2453<htmlurl url="http://www.rfc-editor.org/rfc/rfc2453.txt">),
+RIPng (RFC 2080<htmlurl url="http://www.rfc-editor.org/rfc/rfc2080.txt">),
+and RIP cryptographic authentication (SHA-1 not implemented)
+(RFC 4822<htmlurl url="http://www.rfc-editor.org/rfc/rfc4822.txt">).
 
 <p>RIP is a very simple protocol, and it has a lot of shortcomings. Slow
 convergence, big network load and inability to handle larger networks makes it
@@ -3261,39 +3259,156 @@ pretty much obsolete. It is still usable on very small networks.
 
 <sect1>Configuration
 
-<p>In addition to options common for all to other protocols, RIP supports the
-following ones:
+<p>RIP configuration consists mainly of common protocol options and interface
+definitions, most RIP options are interface specific.
+
+<code>
+protocol rip [&lt;name&gt;] {
+	infinity &lt;number&gt;;
+	ecmp &lt;switch&gt; [limit &lt;number&gt;];
+	interface &lt;interface pattern&gt; {
+		metric &lt;number&gt;;
+		mode multicast|broadcast;
+		passive &lt;switch&gt;;
+		address &lt;ip&gt;;
+		port &lt;number&gt;;
+		version 1|2;
+		split horizon &lt;switch&gt;;
+		poison reverse &lt;switch&gt;;
+		check zero &lt;switch&gt;;
+		update time &lt;number&gt;;
+		timeout time &lt;number&gt;;
+		garbage time &lt;number&gt;;
+		ecmp weight &lt;number&gt;;
+		ttl security &lt;switch&gt;; | tx only;
+		tx class|dscp &lt;number&gt;;
+		tx priority &lt;number&gt;;
+		rx buffer &lt;number&gt;;
+		tx length &lt;number&gt;;
+		check link &lt;switch&gt;;
+		authentication none|plaintext|cryptographic;
+		password "&lt;text&gt;";
+		password "&lt;text&gt;" {
+			id &lt;num&gt;;
+			generate from "&lt;date&gt;";
+			generate to "&lt;date&gt;";
+			accept from "&lt;date&gt;";
+			accept to "&lt;date&gt;";
+		};
+	};
+}
+</code>
 
 <descrip>
-	<tag>authentication none|plaintext|md5</tag>
-	Selects authentication method to be used. <cf/none/ means that packets
-	are not authenticated at all, <cf/plaintext/ means that a plaintext
-	password is embedded into each packet, and <cf/md5/ means that packets
-	are authenticated using a MD5 cryptographic hash. If you set
-	authentication to not-none, it is a good idea to add <cf>password</cf>
-	section. Default: none.
+	<tag>infinity <M>number</M></tag>
+	Selects the distance of infinity. Bigger values will make
+	protocol convergence even slower. The default value is 16.
 
-	<tag>honor always|neighbor|never</tag>
-	Specifies when should requests for dumping routing table be honored.
-	(Always, when sent from a host on a directly connected network or
-	never.) Routing table updates are honored only from neighbors, that is
-	not configurable. Default: never.
+	<tag>ecmp <M>switch</M> [limit <M>number</M>]</tag>
+	This option specifies whether RIP is allowed to generate ECMP
+	(equal-cost multipath) routes. Such routes are used when there are
+	several directions to the destination, each with the same (computed)
+	cost. This option also allows to specify a limit on maximum number of
+	nexthops in one route. By default, ECMP is disabled. If enabled,
+	default	value of the limit is 16.
+
+	<tag>interface <m/pattern [, ...]/ { <m/options/ }</tag>
+	Interface definitions specify a set of interfaces on which the
+	protocol is activated and contain interface specific options.
+	See <ref id="dsc-iface" name="interface"> common options for
+	detailed description.
 </descrip>
 
-<p>There are some options that can be specified per-interface:
+<p>Interface specific options:
 
 <descrip>
 	<tag>metric <m/num/</tag>
-	This option specifies the metric of the interface. Valid
+	This option specifies the metric of the interface. When a route is
+	received from the interface, its metric is increased by this value
+	before further processing. Valid values are 1-255, but values higher
+	than infinity has no further meaning. Default: 1.
+
+	<tag>mode multicast|broadcast</tag>
+	This option selects the mode for RIP to use on the interface. The
+	default is multicast mode for RIPv2 and broadcast mode for RIPv1.
+	RIPng always uses the multicast mode.
+
+	<tag>passive <m/switch/</tag>
+	Passive interfaces receive routing updates but do not transmit any
+	messages. Default: no.
+
+	<tag>address <m/ip/</tag>
+	This option specifies a destination address used for multicast or
+	broadcast messages, the default is the official RIP (224.0.0.9) or RIPng
+	(ff02::9) multicast address, or an appropriate broadcast address in the
+	broadcast mode.
+
+	<tag>port <m/number/</tag>
+	This option selects an UDP port to operate on, the default is the
+	official RIP (520) or RIPng (521) port.
+
+	<tag>version 1|2</tag>
+	This option selects the version of RIP used on the interface. For RIPv1,
+	automatic subnet aggregation is not implemented, only classful network
+	routes and host routes are propagated. Note that BIRD allows RIPv1 to be
+	configured with features that are defined for RIPv2 only, like
+	authentication or using multicast sockets. The default is RIPv2 for IPv4
+	RIP, the option is not supported for RIPng, as no further versions are
+	defined.
+
+	<tag>split horizon <m/switch/</tag>
+	Split horizon is a scheme for preventing routing loops. When split
+	horizon is active, routes are not regularly propagated back to the
+	interface from which they were received. They are either not propagated
+	back at all (plain split horizon) or propagated back with an infinity
+	metric (split horizon with poisoned reverse). Therefore, other routers
+	on the interface will not consider the router as a part of an
+	independent path to the destination of the route. Default: yes.
+
+	<tag>poison reverse <m/switch/</tag>
+	When split horizon is active, this option specifies whether the poisoned
+	reverse variant (propagating routes back with an infinity metric) is
+	used. The poisoned reverse has some advantages in faster convergence,
+	but uses more network traffic. Default: yes.
+
+	<tag>check zero <m/switch/</tag>
+	Received RIPv1 packets with non-zero values in reserved fields should
+	be discarded. This option specifies whether the check is performed or
+	such packets are just processed as usual. Default: yes.
+
+	<tag>update time <m/number/</tag>
+	Specifies the number of seconds between periodic updates. A lower number
+	will mean faster convergence but bigger network load. Default: 30.
+
+	<tag>timeout time <m/number/</tag>
+	Specifies the time interval (in seconds) between the last received route
+	announcement and the route expiration. After that, the network is
+	considered unreachable, but still is propagated with infinity distance.
+	Default: 180.
+
+	<tag>garbage time <m/number/</tag>
+	Specifies the time interval (in seconds) between the route expiration
+	and the removal of the unreachable network entry. The garbage interval,
+	when a route with infinity metric is propagated, is used for both
+	internal (after expiration) and external (after withdrawal) routes.
+	Default: 120.
+
+	<tag>ecmp weight <m/number/</tag>
+	When ECMP (multipath) routes are allowed, this value specifies a
+	relative weight used for nexthops going through the iface. Valid
+	values are 1-256. Default value is 1.
+
+	<tag>authentication none|plaintext|cryptographic</tag>
+	Selects authentication method to be used. <cf/none/ means that packets
+	are not authenticated at all, <cf/plaintext/ means that a plaintext
+	password is embedded into each packet, and <cf/cryptographic/ means that
+	packets are authenticated using a MD5 cryptographic hash. If you set
+	authentication to not-none, it is a good idea to add <cf>password</cf>
+	section. Default: none.
 
-	<tag>mode multicast|broadcast|quiet|nolisten|version1</tag>
-	This option selects the mode for RIP to use on the interface. If nothing
-	is specified, RIP runs in multicast mode. <cf/version1/ is currently
-	equivalent to <cf/broadcast/, and it makes RIP talk to a broadcast
-	address even through multicast mode is possible. <cf/quiet/ option means
-	that RIP will not transmit any periodic messages to this interface and
-	<cf/nolisten/ means that RIP will send to this interface butnot listen
-	to it.
+	<tag>password "<m/text/"</tag>
+	Specifies a password used for authentication. See <ref id="dsc-pass"
+	name="password"> common option for detailed description.
 
 	<tag>ttl security [<m/switch/ | tx only]</tag>
 	TTL security is a feature that protects routing protocols from remote
@@ -3309,43 +3424,31 @@ following ones:
 	compatibility with neighbors regardless of whether they use ttl
 	security.
 
-	Note that for RIPng, TTL security is a standard behavior (required by
-	RFC 2080), but BIRD uses <cf/tx only/ by default, for compatibility with
-	older versions. For IPv4 RIP, default value is no.
+	For RIPng, TTL security is a standard behavior (required by RFC 2080)
+	and therefore default value is yes. For IPv4 RIP, default value is no.
 
-	<tag>tx class|dscp|priority <m/num/</tag>
+	<tag>tx class|dscp|priority <m/number/</tag>
 	These options specify the ToS/DiffServ/Traffic class/Priority of the
 	outgoing RIP packets. See <ref id="dsc-prio" name="tx class"> common
 	option for detailed description.
-</descrip>
 
-<p>The following options generally override behavior specified in RFC. If you
-use any of these options, BIRD will no longer be RFC-compliant, which means it
-will not be able to talk to anything other than equally configured BIRD. I have
-warned you.
+	<tag>rx buffer <m/number/</tag>
+	This option specifies the size of buffers used for packet processing.
+	The buffer size should be bigger than maximal size of received packets.
+	The default value is 532 for IPv4 RIP and interface MTU value for RIPng.
 
-<descrip>
-	<tag>port <M>number</M></tag>
-	Selects IP port to operate on, default 520. (This is useful when testing
-	BIRD, if you set this to an address &gt;1024, you will not need to run
-	bird with UID==0).
+	<tag>tx length <m/number/</tag>
+	This option specifies the maximum length of generated RIP packets. To
+	avoid IP fragmentation, it should not exceed the interface MTU value.
+	The default value is 532 for IPv4 RIP and interface MTU value for RIPng.
 
-	<tag>infinity <M>number</M></tag>
-	Selects the value of infinity, default is 16. Bigger values will make
-	protocol convergence even slower.
-
-	<tag>period <M>number</M></tag>
-	Specifies the number of seconds between periodic updates. Default is 30
-	seconds. A lower number will mean faster convergence but bigger network
-	load. Do not use values lower than 12.
-
-	<tag>timeout time <M>number</M></tag>
-	Specifies how old route has to be to be considered unreachable.
-	Default is 4*<cf/period/.
-
-	<tag>garbage time <M>number</M></tag>
-	Specifies how old route has to be to be discarded. Default is
-	10*<cf/period/.
+	<tag>check link <m/switch/</tag>
+	If set, the hardware link state (as reported by OS) is taken into
+	consideration. When the link disappears (e.g. an ethernet cable is
+	unplugged), neighbors are immediately considered unreachable and all
+	routes received from them are withdrawn. It is possible that some
+	hardware drivers or platforms do not implement this feature. Default:
+	no.
 </descrip>
 
 <sect1>Attributes
@@ -3356,27 +3459,26 @@ warned you.
 	<tag>int <cf/rip_metric/</tag>
 	RIP metric of the route (ranging from 0 to <cf/infinity/).  When routes
 	from different RIP instances are available and all of them have the same
-	preference, BIRD prefers the route with lowest <cf/rip_metric/. When
-	importing a non-RIP route, the metric defaults to 5.
+	preference, BIRD prefers the route with lowest <cf/rip_metric/. When a
+	non-RIP route is exported to RIP, the default metric is 1.
 
 	<tag>int <cf/rip_tag/</tag>
 	RIP route tag: a 16-bit number which can be used to carry additional
 	information with the route (for example, an originating AS number in
-	case of external routes). When importing a non-RIP route, the tag
-	defaults to 0.
+	case of external routes). When a non-RIP route is exported to RIP, the
+	default tag is 0.
 </descrip>
 
 <sect1>Example
 
 <p><code>
-protocol rip MyRIP_test {
+protocol rip {
         debug all;
         port 1520;
         period 12;
         garbage time 60;
         interface "eth0" { metric 3; mode multicast; };
 	interface "eth*" { metric 2; mode broadcast; };
-        honor neighbor;
         authentication none;
         import filter { print "importing"; accept; };
         export filter { print "exporting"; accept; };
diff --git a/doc/reply_codes b/doc/reply_codes
index cd5f2620..79a7eb92 100644
--- a/doc/reply_codes
+++ b/doc/reply_codes
@@ -55,6 +55,8 @@ Reply codes of BIRD command-line interface
 1018	Show memory
 1019	Show ROA list
 1020	Show BFD sessions
+1021	Show RIP interface
+1022	Show RIP neighbors
 
 8000	Reply too long
 8001	Route not found
diff --git a/lib/ip.c b/lib/ip.c
index e1bfba49..3dc8919a 100644
--- a/lib/ip.c
+++ b/lib/ip.c
@@ -364,7 +364,9 @@ ip4_class_mask(ip4_addr ad)
 {
   u32 m, a = _I(ad);
 
-  if (a < 0x80000000)
+  if (a == 0x00000000)
+    m = 0x00000000;
+  else if (a < 0x80000000)
     m = 0xff000000;
   else if (a < 0xc0000000)
     m = 0xffff0000;
diff --git a/lib/ip.h b/lib/ip.h
index 90bb7f8a..9ac5798a 100644
--- a/lib/ip.h
+++ b/lib/ip.h
@@ -15,8 +15,11 @@
 #include "lib/unaligned.h"
 
 
+#define IP4_ALL_NODES		ipa_build4(224, 0, 0, 1)
+#define IP4_ALL_ROUTERS		ipa_build4(224, 0, 0, 2)
 #define IP4_OSPF_ALL_ROUTERS	ipa_build4(224, 0, 0, 5)
 #define IP4_OSPF_DES_ROUTERS	ipa_build4(224, 0, 0, 6)
+#define IP4_RIP_ROUTERS		ipa_build4(224, 0, 0, 9)
 
 #define IP6_ALL_NODES		ipa_build6(0xFF020000, 0, 0, 1)
 #define IP6_ALL_ROUTERS		ipa_build6(0xFF020000, 0, 0, 2)
@@ -32,6 +35,10 @@
 
 #define IP_PREC_INTERNET_CONTROL 0xc0
 
+#define IP4_HEADER_LENGTH	20
+#define IP6_HEADER_LENGTH	40
+#define UDP_HEADER_LENGTH	8
+
 
 #ifdef IPV6
 #define MAX_PREFIX_LENGTH 128
diff --git a/nest/password.c b/nest/password.c
index 21e42e0e..91aaa418 100644
--- a/nest/password.c
+++ b/nest/password.c
@@ -51,3 +51,18 @@ password_find_by_id(list *l, int id)
   return NULL;
 }
 
+struct password_item *
+password_find_by_value(list *l, char *pass, uint size)
+{
+  struct password_item *pi;
+
+  if (!l)
+    return NULL;
+
+  WALK_LIST(pi, *l)
+    if (password_verify(pi, pass, size) && (pi->accfrom <= now_real) && (now_real < pi->accto))
+      return pi;
+
+  return NULL;
+}
+
diff --git a/nest/password.h b/nest/password.h
index cd120d70..1d9de53c 100644
--- a/nest/password.h
+++ b/nest/password.h
@@ -11,8 +11,6 @@
 #define PASSWORD_H
 #include "lib/timer.h"
 
-#define MD5_AUTH_SIZE 16
-
 struct password_item {
   node n;
   char *password;
@@ -24,6 +22,7 @@ extern struct password_item *last_password_item;
 
 struct password_item *password_find(list *l, int first_fit);
 struct password_item *password_find_by_id(list *l, int id);
+struct password_item *password_find_by_value(list *l, char *pass, uint size);
 
 static inline int password_verify(struct password_item *p1, char *p2, uint size)
 {
diff --git a/nest/route.h b/nest/route.h
index 6067526d..285fb372 100644
--- a/nest/route.h
+++ b/nest/route.h
@@ -75,6 +75,8 @@ void fib_check(struct fib *);		/* Consistency check for debugging */
 void fit_init(struct fib_iterator *, struct fib *); /* Internal functions, don't call */
 struct fib_node *fit_get(struct fib *, struct fib_iterator *);
 void fit_put(struct fib_iterator *, struct fib_node *);
+void fit_put_next(struct fib *f, struct fib_iterator *i, struct fib_node *n, uint hpos);
+
 
 #define FIB_WALK(fib, z) do {					\
 	struct fib_node *z, **ff = (fib)->hash_table;		\
@@ -103,6 +105,11 @@ void fit_put(struct fib_iterator *, struct fib_node *);
 
 #define FIB_ITERATE_PUT(it, z) fit_put(it, z)
 
+#define FIB_ITERATE_PUT_NEXT(it, fib, z) fit_put_next(fib, it, z, hpos)
+
+#define FIB_ITERATE_UNLINK(it, fib) fit_get(fib, it)
+
+
 /*
  *	Master Routing Tables. Generally speaking, each of them contains a FIB
  *	with each entry pointing to a list of route entries representing routes
@@ -196,10 +203,9 @@ typedef struct rte {
   union {				/* Protocol-dependent data (metrics etc.) */
 #ifdef CONFIG_RIP
     struct {
-      node garbage;			/* List for garbage collection */
-      byte metric;			/* RIP metric */
+      struct iface *from;		/* Incoming iface */
+      u8 metric;			/* RIP metric */
       u16 tag;				/* External route tag */
-      struct rip_entry *entry;
     } rip;
 #endif
 #ifdef CONFIG_OSPF
diff --git a/nest/rt-fib.c b/nest/rt-fib.c
index aa5e2357..a73de1fd 100644
--- a/nest/rt-fib.c
+++ b/nest/rt-fib.c
@@ -430,6 +430,25 @@ fit_put(struct fib_iterator *i, struct fib_node *n)
   i->prev = (struct fib_iterator *) n;
 }
 
+void
+fit_put_next(struct fib *f, struct fib_iterator *i, struct fib_node *n, uint hpos)
+{
+  if (n = n->next)
+    goto found;
+
+  while (++hpos < f->hash_size)
+    if (n = f->hash_table[hpos])
+      goto found;
+
+  /* We are at the end */
+  i->prev = i->next = NULL;
+  i->node = NULL;
+  return;
+
+found:
+  fit_put(i, n);
+}
+
 #ifdef DEBUGGING
 
 /**
diff --git a/nest/rt-table.c b/nest/rt-table.c
index 9e2c4e0d..b39f2a69 100644
--- a/nest/rt-table.c
+++ b/nest/rt-table.c
@@ -888,12 +888,6 @@ rte_recalculate(struct announce_hook *ah, net *net, rte *new, struct rte_src *sr
 		}
 
 	      rte_free_quick(new);
-#ifdef CONFIG_RIP
-	      /* lastmod is used internally by RIP as the last time
-		 when the route was received. */
-	      if (src->proto->proto == &proto_rip)
-		old->lastmod = now;
-#endif
 	      return;
 	    }
 	  *k = old->next;
diff --git a/proto/ospf/packet.c b/proto/ospf/packet.c
index fb63e61c..65842037 100644
--- a/proto/ospf/packet.c
+++ b/proto/ospf/packet.c
@@ -223,7 +223,7 @@ ospf_rx_hook(sock *sk, int len)
     return 1;
 
   DBG("OSPF: RX hook called (iface %s, src %I, dst %I)\n",
-      sk->ifname, sk->faddr, sk->laddr);
+      sk->iface->name, sk->faddr, sk->laddr);
 
   /* Initially, the packet is associated with the 'master' iface */
   struct ospf_iface *ifa = sk->data;
diff --git a/proto/rip/Doc b/proto/rip/Doc
index 2c7f4c8f..561b2153 100644
--- a/proto/rip/Doc
+++ b/proto/rip/Doc
@@ -1,2 +1,2 @@
 S rip.c
-S auth.c
+S packets.c
diff --git a/proto/rip/Makefile b/proto/rip/Makefile
index d03e3a90..d2d3c987 100644
--- a/proto/rip/Makefile
+++ b/proto/rip/Makefile
@@ -1,4 +1,4 @@
-source=rip.c auth.c
+source=rip.c packets.c
 root-rel=../../
 dir-name=proto/rip
 
diff --git a/proto/rip/auth.c b/proto/rip/auth.c
deleted file mode 100644
index 5634547a..00000000
--- a/proto/rip/auth.c
+++ /dev/null
@@ -1,168 +0,0 @@
-/*
- *	Rest in pieces - RIP protocol
- *
- *	Copyright (c) 1999 Pavel Machek <pavel@ucw.cz>
- *	Copyright (c) 2004 Ondrej Filip <feela@network.cz>
- *
- *	Bug fixes by Eric Leblond <eleblond@init-sys.com>, April 2003
- * 
- *	Can be freely distributed and used under the terms of the GNU GPL.
- */
-
-#undef LOCAL_DEBUG
-
-#include "nest/bird.h"
-#include "nest/iface.h"
-#include "nest/protocol.h"
-#include "nest/route.h"
-#include "lib/socket.h"
-#include "lib/resource.h"
-#include "lib/lists.h"
-#include "lib/timer.h"
-#include "lib/md5.h"
-#include "lib/string.h"
-
-#include "rip.h"
-
-#define P ((struct rip_proto *) p)
-#define P_CF ((struct rip_proto_config *)p->cf)
-
-#define PACKETLEN(num) (num * sizeof(struct rip_block) + sizeof(struct rip_packet_heading))
-
-/*
- * rip_incoming_authentication - check authentication of incomming packet and return 1 if there's problem.
- */
-int
-rip_incoming_authentication( struct proto *p, struct rip_block_auth *block, struct rip_packet *packet, int num, ip_addr whotoldme )
-{
-  DBG( "Incoming authentication: " );
-  switch (ntohs(block->authtype)) {	/* Authentication type */
-  case AT_PLAINTEXT: 
-    {
-      struct password_item *passwd = password_find(P_CF->passwords, 1);
-      DBG( "Plaintext passwd" );
-      if (!passwd) {
-	log( L_AUTH "No passwords set and password authentication came" );
-	return 1;
-      }
-      if (strncmp( (char *) (&block->packetlen), passwd->password, 16)) {
-	log( L_AUTH "Passwd authentication failed!" );
-	DBG( "Expected %s, got %.16s\n", passwd->password, &block->packetlen );
-	return 1;
-      }
-    }
-    break;
-  case AT_MD5:
-    DBG( "md5 password" );
-    {
-      struct password_item *pass = NULL, *ptmp;
-      struct rip_md5_tail *tail;
-      struct MD5Context ctxt;
-      char md5sum_packet[16];
-      char md5sum_computed[16];
-      struct neighbor *neigh = neigh_find(p, &whotoldme, 0);
-      list *l = P_CF->passwords;
-
-      if (ntohs(block->packetlen) != PACKETLEN(num) - sizeof(struct rip_md5_tail) ) {
-	log( L_ERR "Packet length in MD5 does not match computed value" );
-	return 1;
-      }
-
-      tail = (struct rip_md5_tail *) ((char *) packet + (ntohs(block->packetlen) ));
-      if ((tail->mustbeFFFF != 0xffff) || (tail->mustbe0001 != 0x0100)) {
-	log( L_ERR "MD5 tail signature is not there" );
-	return 1;
-      }
-
-      WALK_LIST(ptmp, *l)
-      {
-        if (block->keyid != ptmp->id) continue;
-        if ((ptmp->genfrom > now_real) || (ptmp->gento < now_real)) continue;
-        pass = ptmp;
-        break;
-      }
-
-      if(!pass) return 1;
-
-      if (!neigh) {
-        log( L_AUTH "Non-neighbour MD5 checksummed packet?" );
-      } else {
-	if (neigh->aux > block->seq) {
-	  log( L_AUTH "MD5 protected packet with lower numbers" );
-	  return 1;
-        }
-	neigh->aux = block->seq;
-      }
-
-      memcpy(md5sum_packet, tail->md5, 16);
-      strncpy(tail->md5, pass->password, 16);
-
-      MD5Init(&ctxt);
-      MD5Update(&ctxt, (char *) packet, ntohs(block->packetlen) +  sizeof(struct rip_block_auth) );
-      MD5Final(md5sum_computed, &ctxt);
-      if (memcmp(md5sum_packet, md5sum_computed, 16))
-        return 1;
-    }
-  }
-    
-  return 0;
-}
-
-/*
- * rip_outgoing_authentication - append authentication information to the packet.
- * %num: number of rip_blocks already in packets. This function returns size of packet to send.
- */
-int
-rip_outgoing_authentication( struct proto *p, struct rip_block_auth *block, struct rip_packet *packet, int num )
-{
-  struct password_item *passwd = password_find(P_CF->passwords, 1);
-
-  if (!P_CF->authtype)
-    return PACKETLEN(num);
-
-  DBG( "Outgoing authentication: " );
-
-  if (!passwd) {
-    log( L_ERR "No suitable password found for authentication" );
-    return PACKETLEN(num);
-  }
-
-  block->authtype = htons(P_CF->authtype);
-  block->mustbeFFFF = 0xffff;
-  switch (P_CF->authtype) {
-  case AT_PLAINTEXT:
-    strncpy( (char *) (&block->packetlen), passwd->password, 16);
-    return PACKETLEN(num);
-  case AT_MD5:
-    {
-      struct rip_md5_tail *tail;
-      struct MD5Context ctxt;
-      static u32 sequence = 0;
-
-      if (num > PACKET_MD5_MAX)
-	bug(  "We can not add MD5 authentication to this long packet" );
-
-      /* need to preset the sequence number to a sane value */
-      if (!sequence)
-	sequence = (u32) time(NULL);
-
-      block->keyid = passwd->id;
-      block->authlen = sizeof(struct rip_block_auth);
-      block->seq = sequence++;
-      block->zero0 = 0;
-      block->zero1 = 0;
-      block->packetlen = htons(PACKETLEN(num));
-      tail = (struct rip_md5_tail *) ((char *) packet + PACKETLEN(num) );
-      tail->mustbeFFFF = 0xffff;
-      tail->mustbe0001 = 0x0100;
-
-      strncpy(tail->md5, passwd->password, 16);
-      MD5Init(&ctxt);
-      MD5Update(&ctxt, (char *) packet, PACKETLEN(num) + sizeof(struct  rip_md5_tail));
-      MD5Final(tail->md5, &ctxt);
-      return PACKETLEN(num) + block->authlen;
-    }
-  default:
-    bug( "Unknown authtype in outgoing authentication?" );
-  }
-}
diff --git a/proto/rip/config.Y b/proto/rip/config.Y
index b2b99095..29ea7eb1 100644
--- a/proto/rip/config.Y
+++ b/proto/rip/config.Y
@@ -1,17 +1,14 @@
 /*
  *	BIRD -- RIP Configuration
  *
+ *	(c) 1998--1999 Pavel Machek <pavel@ucw.cz>
+ *	(c) 2004--2013 Ondrej Filip <feela@network.cz>
+ *	(c) 2009--2015 Ondrej Zajicek <santiago@crfreenet.org>
+ *	(c) 2009--2015 CZ.NIC z.s.p.o.
+ *
  *	Can be freely distributed and used under the terms of the GNU GPL.
  */
 
-/*
-To add:
-
-version1 switch
-
-*/
-
-
 CF_HDR
 
 #include "proto/rip/rip.h"
@@ -19,76 +16,141 @@ CF_HDR
 
 CF_DEFINES
 
-#define RIP_CFG ((struct rip_proto_config *) this_proto)
-#define RIP_IPATT ((struct rip_patt *) this_ipatt)
+#define RIP_CFG ((struct rip_config *) this_proto)
+#define RIP_IFACE ((struct rip_iface_config *) this_ipatt)
+
+static inline int rip_cfg_is_v2(void) { return RIP_CFG->rip2; }
+static inline int rip_cfg_is_ng(void) { return ! RIP_CFG->rip2; }
+
+static inline void
+rip_check_auth(void)
+{
+  if (rip_cfg_is_ng())
+    cf_error("Authentication not supported in RIPng");
+}
 
-#ifdef IPV6
-#define RIP_DEFAULT_TTL_SECURITY 2
-#else
-#define RIP_DEFAULT_TTL_SECURITY 0
-#endif
 
 CF_DECLS
 
-CF_KEYWORDS(RIP, INFINITY, METRIC, PORT, PERIOD, GARBAGE, TIMEOUT,
-	    MODE, BROADCAST, MULTICAST, QUIET, NOLISTEN, VERSION1, 
-	    AUTHENTICATION, NONE, PLAINTEXT, MD5, TTL, SECURITY,
-	    HONOR, NEVER, NEIGHBOR, ALWAYS, TX, PRIORITY, ONLY,
-	    RIP_METRIC, RIP_TAG)
+CF_KEYWORDS(RIP, ECMP, LIMIT, WEIGHT, INFINITY, METRIC, UPDATE, TIMEOUT,
+	    GARBAGE, PORT, ADDRESS, MODE, BROADCAST, MULTICAST, PASSIVE,
+	    VERSION, SPLIT, HORIZON, POISON, REVERSE, CHECK, ZERO, TIME, BFD,
+	    AUTHENTICATION, NONE, PLAINTEXT, CRYPTOGRAPHIC, MD5, TTL, SECURITY,
+	    RX, TX, BUFFER, LENGTH, PRIORITY, ONLY, LINK, RIP_METRIC, RIP_TAG)
 
-%type <i> rip_mode rip_auth
+%type <i> rip_auth
 
 CF_GRAMMAR
 
-CF_ADDTO(proto, rip_cfg '}' { RIP_CFG->passwords = get_passwords(); } )
+CF_ADDTO(proto, rip_proto)
 
-rip_cfg_start: proto_start RIP {
-     this_proto = proto_config_new(&proto_rip, $1);
-     rip_init_config(RIP_CFG);
-   }
- ;
+rip_proto_start: proto_start RIP
+{
+  this_proto = proto_config_new(&proto_rip, $1);
+  init_list(&RIP_CFG->patt_list);
 
-rip_cfg:
-   rip_cfg_start proto_name '{'
- | rip_cfg proto_item ';'
- | rip_cfg INFINITY expr ';'	{ RIP_CFG->infinity = $3; }
- | rip_cfg PORT expr ';'	{ RIP_CFG->port = $3; }
- | rip_cfg PERIOD expr ';'	{ RIP_CFG->period = $3; }
- | rip_cfg GARBAGE TIME expr ';' { RIP_CFG->garbage_time = $4; }
- | rip_cfg TIMEOUT TIME expr ';' { RIP_CFG->timeout_time = $4; }
- | rip_cfg AUTHENTICATION rip_auth ';' {RIP_CFG->authtype = $3; }
- | rip_cfg password_list ';'
- | rip_cfg HONOR ALWAYS ';'    { RIP_CFG->honor = HO_ALWAYS; }
- | rip_cfg HONOR NEIGHBOR ';'    { RIP_CFG->honor = HO_NEIGHBOR; }
- | rip_cfg HONOR NEVER ';'    { RIP_CFG->honor = HO_NEVER; }
- | rip_cfg INTERFACE rip_iface ';'
- ;
+  RIP_CFG->rip2 = RIP_IS_V2;
+  RIP_CFG->infinity = RIP_DEFAULT_INFINITY;
 
-rip_auth:
-   PLAINTEXT { $$=AT_PLAINTEXT; }
- | MD5 { $$=AT_MD5; }
- | NONE { $$=AT_NONE; }
- ;
+  RIP_CFG->min_timeout_time = 60;
+  RIP_CFG->max_garbage_time = 60;
+};
 
+rip_proto_item:
+   proto_item
+ | ECMP bool		{ RIP_CFG->ecmp = $2 ? RIP_DEFAULT_ECMP_LIMIT : 0; }
+ | ECMP bool LIMIT expr	{ RIP_CFG->ecmp = $2 ? $4 : 0; if ($4 < 0) cf_error("ECMP limit cannot be negative"); }
+ | INFINITY expr	{ RIP_CFG->infinity = $2; }
+ | INTERFACE rip_iface
+ ;
 
-rip_mode: 
-    BROADCAST { $$=IM_BROADCAST; }
-  | MULTICAST { $$=0; }
-  | QUIET     { $$=IM_QUIET; }
-  | NOLISTEN  { $$=IM_NOLISTEN; }
-  | VERSION1  { $$=IM_VERSION1 | IM_BROADCAST; }
+rip_proto_opts:
+   /* empty */
+ | rip_proto_opts rip_proto_item ';'
  ;
 
+rip_proto:
+   rip_proto_start proto_name '{' rip_proto_opts '}';
+
+
+rip_iface_start:
+{
+  this_ipatt = cfg_allocz(sizeof(struct rip_iface_config));
+  add_tail(&RIP_CFG->patt_list, NODE this_ipatt);
+  init_list(&this_ipatt->ipn_list);
+  reset_passwords();
+
+  RIP_IFACE->metric = 1;
+  RIP_IFACE->port = rip_cfg_is_v2() ? RIP_PORT : RIP_NG_PORT;
+  RIP_IFACE->version = rip_cfg_is_v2() ? RIP_V2 : RIP_V1;
+  RIP_IFACE->split_horizon = 1;
+  RIP_IFACE->poison_reverse = 1;
+  RIP_IFACE->check_zero = 1;
+  RIP_IFACE->ttl_security = rip_cfg_is_v2() ? 0 : 1;
+  RIP_IFACE->rx_buffer = rip_cfg_is_v2() ? RIP_MAX_PKT_LENGTH : 0;
+  RIP_IFACE->tx_length = rip_cfg_is_v2() ? RIP_MAX_PKT_LENGTH : 0;
+  RIP_IFACE->tx_tos = IP_PREC_INTERNET_CONTROL;
+  RIP_IFACE->tx_priority = sk_priority_control;
+  RIP_IFACE->update_time = RIP_DEFAULT_UPDATE_TIME;
+  RIP_IFACE->timeout_time = RIP_DEFAULT_TIMEOUT_TIME;
+  RIP_IFACE->garbage_time = RIP_DEFAULT_GARBAGE_TIME;
+};
+
+rip_iface_finish:
+{
+  RIP_IFACE->passwords = get_passwords();
+
+  if (!RIP_IFACE->auth_type != !RIP_IFACE->passwords)
+    log(L_WARN "Authentication and password options should be used together");
+
+  /* Default mode is broadcast for RIPv1, multicast for RIPv2 and RIPng */
+  if (!RIP_IFACE->mode)
+    RIP_IFACE->mode = (rip_cfg_is_v2() && (RIP_IFACE->version == RIP_V1)) ?
+      RIP_IM_BROADCAST : RIP_IM_MULTICAST;
+
+  RIP_CFG->min_timeout_time = MIN_(RIP_CFG->min_timeout_time, RIP_IFACE->timeout_time);
+  RIP_CFG->max_garbage_time = MAX_(RIP_CFG->max_garbage_time, RIP_IFACE->garbage_time);
+};
+
 rip_iface_item:
- | METRIC expr { RIP_IPATT->metric = $2; }
- | MODE rip_mode { RIP_IPATT->mode |= $2; }
- | TX tos { RIP_IPATT->tx_tos = $2; }
- | TX PRIORITY expr { RIP_IPATT->tx_priority = $3; }
- | TTL SECURITY bool { RIP_IPATT->ttl_security = $3; }
- | TTL SECURITY TX ONLY { RIP_IPATT->ttl_security = 2; }
+   METRIC expr		{ RIP_IFACE->metric = $2; if (($2<1) || ($2>255)) cf_error("Metric must be in range 1-255"); }
+ | MODE MULTICAST	{ RIP_IFACE->mode = RIP_IM_MULTICAST; }
+ | MODE BROADCAST	{ RIP_IFACE->mode = RIP_IM_BROADCAST; if (rip_cfg_is_ng()) cf_error("Broadcast not supported in RIPng"); }
+ | PASSIVE bool		{ RIP_IFACE->passive = $2; }
+ | ADDRESS ipa		{ RIP_IFACE->address = $2; }
+ | PORT expr		{ RIP_IFACE->port = $2; if (($2<1) || ($2>65535)) cf_error("Invalid port number"); }
+ | VERSION expr		{ RIP_IFACE->version = $2;
+			  if (rip_cfg_is_ng()) cf_error("Version not supported in RIPng");
+			  if (($2 != RIP_V1) && ($2 != RIP_V2)) cf_error("Unsupported version");
+			}
+ | VERSION ONLY bool	{ RIP_IFACE->version_only = $3; }
+ | SPLIT HORIZON bool	{ RIP_IFACE->split_horizon = $3; }
+ | POISON REVERSE bool	{ RIP_IFACE->poison_reverse = $3; }
+ | CHECK ZERO bool	{ RIP_IFACE->check_zero = $3; }
+ | UPDATE TIME expr	{ RIP_IFACE->update_time = $3; if ($3<=0) cf_error("Update time must be positive"); }
+ | TIMEOUT TIME expr	{ RIP_IFACE->timeout_time = $3; if ($3<=0) cf_error("Timeout time must be positive"); }
+ | GARBAGE TIME expr	{ RIP_IFACE->garbage_time = $3; if ($3<=0) cf_error("Garbage time must be positive"); }
+ | ECMP WEIGHT expr	{ RIP_IFACE->ecmp_weight = $3 - 1; if (($3<1) || ($3>256)) cf_error("ECMP weight must be in range 1-256"); }
+ | RX BUFFER expr	{ RIP_IFACE->rx_buffer = $3; if (($3<256) || ($3>65535)) cf_error("TX length must be in range 256-65535"); }
+ | TX LENGTH expr	{ RIP_IFACE->tx_length = $3; if (($3<256) || ($3>65535)) cf_error("TX length must be in range 256-65535"); }
+ | TX tos		{ RIP_IFACE->tx_tos = $2; }
+ | TX PRIORITY expr	{ RIP_IFACE->tx_priority = $3; }
+ | TTL SECURITY bool	{ RIP_IFACE->ttl_security = $3; }
+ | TTL SECURITY TX ONLY	{ RIP_IFACE->ttl_security = 2; }
+ | CHECK LINK bool	{ RIP_IFACE->check_link = $3; }
+ | BFD bool		{ RIP_IFACE->bfd = $2; cf_check_bfd($2); }
+ | AUTHENTICATION rip_auth { RIP_IFACE->auth_type = $2; if ($2) rip_check_auth(); }
+ | password_list	{ rip_check_auth(); }
+;
+
+rip_auth:
+   NONE			{ $$ = RIP_AUTH_NONE; }
+ | PLAINTEXT		{ $$ = RIP_AUTH_PLAIN; }
+ | CRYPTOGRAPHIC	{ $$ = RIP_AUTH_CRYPTO; }
+ | MD5			{ $$ = RIP_AUTH_CRYPTO; }
  ;
 
-rip_iface_opts: 
+rip_iface_opts:
    /* empty */
  | rip_iface_opts rip_iface_item ';'
  ;
@@ -98,25 +160,22 @@ rip_iface_opt_list:
  | '{' rip_iface_opts '}'
  ;
 
-rip_iface_init:
-   /* EMPTY */ {
-     this_ipatt = cfg_allocz(sizeof(struct rip_patt));
-     add_tail(&RIP_CFG->iface_list, NODE this_ipatt);
-     init_list(&this_ipatt->ipn_list);
-     RIP_IPATT->metric = 1;
-     RIP_IPATT->tx_tos = IP_PREC_INTERNET_CONTROL;
-     RIP_IPATT->tx_priority = sk_priority_control;
-     RIP_IPATT->ttl_security = RIP_DEFAULT_TTL_SECURITY;
-   }
- ;
+rip_iface:
+  rip_iface_start iface_patt_list_nopx rip_iface_opt_list rip_iface_finish;
 
-rip_iface:	/* TODO: switch to iface_patt_list_nopx */
-   rip_iface_init iface_patt_list rip_iface_opt_list
- ;
 
 CF_ADDTO(dynamic_attr, RIP_METRIC { $$ = f_new_dynamic_attr(EAF_TYPE_INT | EAF_TEMP, T_INT, EA_RIP_METRIC); })
 CF_ADDTO(dynamic_attr, RIP_TAG { $$ = f_new_dynamic_attr(EAF_TYPE_INT | EAF_TEMP, T_INT, EA_RIP_TAG); })
 
+CF_CLI_HELP(SHOW RIP, ..., [[Show information about RIP protocol]]);
+
+CF_CLI(SHOW RIP INTERFACES, optsym opttext, [<name>] [\"<interface>\"], [[Show information about RIP interfaces]])
+{ rip_show_interfaces(proto_get_named($4, &proto_rip), $5); };
+
+CF_CLI(SHOW RIP NEIGHBORS, optsym opttext, [<name>] [\"<interface>\"], [[Show information about RIP neighbors]])
+{ rip_show_neighbors(proto_get_named($4, &proto_rip), $5); };
+
+
 CF_CODE
 
 CF_END
diff --git a/proto/rip/packets.c b/proto/rip/packets.c
new file mode 100644
index 00000000..be20734f
--- /dev/null
+++ b/proto/rip/packets.c
@@ -0,0 +1,772 @@
+/*
+ *	BIRD -- Routing Information Protocol (RIP)
+ *
+ *	(c) 1998--1999 Pavel Machek <pavel@ucw.cz>
+ *	(c) 2004--2013 Ondrej Filip <feela@network.cz>
+ *	(c) 2009--2015 Ondrej Zajicek <santiago@crfreenet.org>
+ *	(c) 2009--2015 CZ.NIC z.s.p.o.
+ *
+ *	Can be freely distributed and used under the terms of the GNU GPL.
+ */
+
+#include "rip.h"
+#include "lib/md5.h"
+
+
+#define RIP_CMD_REQUEST		1	/* want info */
+#define RIP_CMD_RESPONSE	2	/* responding to request */
+
+#define RIP_BLOCK_LENGTH	20
+
+#define RIP_PASSWD_LENGTH	16
+#define RIP_MD5_LENGTH		16
+
+#define RIP_AF_IPV4		2
+#define RIP_AF_AUTH		0xffff
+
+
+/* RIP packet header */
+struct rip_packet
+{
+  u8 command;
+  u8 version;
+  u16 unused;
+};
+
+/* RTE block for RIPv2 */
+struct rip_block_v2
+{
+  u16 family;
+  u16 tag;
+  ip4_addr network;
+  ip4_addr netmask;
+  ip4_addr next_hop;
+  u32 metric;
+};
+
+/* RTE block for RIPng */
+struct rip_block_ng
+{
+  ip6_addr prefix;
+  u16 tag;
+  u8 pxlen;
+  u8 metric;
+};
+
+/* Authentication block for RIPv2 */
+struct rip_block_auth
+{
+  u16 must_be_ffff;
+  u16 auth_type;
+  char password[0];
+  u16 packet_len;
+  u8 key_id;
+  u8 auth_len;
+  u32 seq_num;
+  u32 unused1;
+  u32 unused2;
+};
+
+/* Authentication tail, RFC 4822 */
+struct rip_auth_tail
+{
+  u16 must_be_ffff;
+  u16 must_be_0001;
+  byte auth_data[];
+};
+
+/* Internal representation of RTE block data */
+struct rip_block
+{
+  ip_addr prefix;
+  int pxlen;
+  u32 metric;
+  u16 tag;
+  u16 no_af;
+  ip_addr next_hop;
+};
+
+
+#define DROP(DSC,VAL) do { err_dsc = DSC; err_val = VAL; goto drop; } while(0)
+#define DROP1(DSC) do { err_dsc = DSC; goto drop; } while(0)
+#define SKIP(DSC) do { err_dsc = DSC; goto skip; } while(0)
+
+#define LOG_PKT(msg, args...) \
+  log_rl(&p->log_pkt_tbf, L_REMOTE "%s: " msg, p->p.name, args)
+
+#define LOG_PKT_AUTH(msg, args...) \
+  log_rl(&p->log_pkt_tbf, L_AUTH "%s: " msg, p->p.name, args)
+
+#define LOG_RTE(msg, args...) \
+  log_rl(&p->log_rte_tbf, L_REMOTE "%s: " msg, p->p.name, args)
+
+
+static inline void * rip_tx_buffer(struct rip_iface *ifa)
+{ return ifa->sk->tbuf; }
+
+static inline uint rip_pkt_hdrlen(struct rip_iface *ifa)
+{ return sizeof(struct rip_packet) + (ifa->cf->auth_type ? RIP_BLOCK_LENGTH : 0); }
+
+static inline void
+rip_put_block(struct rip_proto *p, byte *pos, struct rip_block *rte)
+{
+  if (rip_is_v2(p))
+  {
+    struct rip_block_v2 *block = (void *) pos;
+    block->family = rte->no_af ? 0 : htons(RIP_AF_IPV4);
+    block->tag = htons(rte->tag);
+    block->network = ip4_hton(ipa_to_ip4(rte->prefix));
+    block->netmask = ip4_hton(ip4_mkmask(rte->pxlen));
+    block->next_hop = ip4_hton(ipa_to_ip4(rte->next_hop));
+    block->metric = htonl(rte->metric);
+  }
+  else /* RIPng */
+  {
+    struct rip_block_ng *block = (void *) pos;
+    block->prefix = ip6_hton(ipa_to_ip6(rte->prefix));
+    block->tag = htons(rte->tag);
+    block->pxlen = rte->pxlen;
+    block->metric = rte->metric;
+  }
+}
+
+static inline void
+rip_put_next_hop(struct rip_proto *p, byte *pos, struct rip_block *rte)
+{
+  struct rip_block_ng *block = (void *) pos;
+  block->prefix = ip6_hton(ipa_to_ip6(rte->next_hop));
+  block->tag = 0;
+  block->pxlen = 0;
+  block->metric = 0xff;
+}
+
+static inline int
+rip_get_block(struct rip_proto *p, byte *pos, struct rip_block *rte)
+{
+  if (rip_is_v2(p))
+  {
+    struct rip_block_v2 *block = (void *) pos;
+
+    /* Skip blocks with strange AF, including authentication blocks */
+    if (block->family != (rte->no_af ? 0 : htons(RIP_AF_IPV4)))
+      return 0;
+
+    rte->prefix = ipa_from_ip4(ip4_ntoh(block->network));
+    rte->pxlen = ip4_masklen(ip4_ntoh(block->netmask));
+    rte->metric = ntohl(block->metric);
+    rte->tag = ntohs(block->tag);
+    rte->next_hop = ipa_from_ip4(ip4_ntoh(block->next_hop));
+
+    return 1;
+  }
+  else /* RIPng */
+  {
+    struct rip_block_ng *block = (void *) pos;
+
+    /* Handle and skip next hop blocks */
+    if (block->metric == 0xff)
+    {
+      rte->next_hop = ipa_from_ip6(ip6_ntoh(block->prefix));
+      if (!ipa_is_link_local(rte->next_hop)) rte->next_hop = IPA_NONE;
+      return 0;
+    }
+
+    rte->prefix = ipa_from_ip6(ip6_ntoh(block->prefix));
+    rte->pxlen = block->pxlen;
+    rte->metric = block->metric;
+    rte->tag = ntohs(block->tag);
+    /* rte->next_hop is deliberately kept unmodified */;
+
+    return 1;
+  }
+}
+
+static inline void
+rip_update_csn(struct rip_proto *p UNUSED, struct rip_iface *ifa)
+{
+  /*
+   * We update crypto sequence numbers at the beginning of update session to
+   * avoid issues with packet reordering, so packets inside one update session
+   * have the same CSN. We are using real time, but enforcing monotonicity.
+   */
+  if (ifa->cf->auth_type == RIP_AUTH_CRYPTO)
+    ifa->csn = (ifa->csn < (u32) now_real) ? (u32) now_real : ifa->csn + 1;
+}
+
+static void
+rip_fill_authentication(struct rip_proto *p, struct rip_iface *ifa, struct rip_packet *pkt, uint *plen)
+{
+  struct rip_block_auth *auth = (void *) (pkt + 1);
+  struct password_item *pass = password_find(ifa->cf->passwords, 0);
+
+  if (!pass)
+  {
+    /* FIXME: This should not happen */
+    log(L_ERR "%s: No suitable password found for authentication", p->p.name);
+    memset(auth, 0, sizeof(struct rip_block_auth));
+    return;
+  }
+
+  switch (ifa->cf->auth_type)
+  {
+  case RIP_AUTH_PLAIN:
+    auth->must_be_ffff = htons(0xffff);
+    auth->auth_type = htons(RIP_AUTH_PLAIN);
+    strncpy(auth->password, pass->password, RIP_PASSWD_LENGTH);
+    return;
+
+  case RIP_AUTH_CRYPTO:
+    auth->must_be_ffff = htons(0xffff);
+    auth->auth_type = htons(RIP_AUTH_CRYPTO);
+    auth->packet_len = htons(*plen);
+    auth->key_id = pass->id;
+    auth->auth_len = sizeof(struct rip_auth_tail) + RIP_MD5_LENGTH;
+    auth->seq_num = ifa->csn_ready ? htonl(ifa->csn) : 0;
+    auth->unused1 = 0;
+    auth->unused2 = 0;
+    ifa->csn_ready = 1;
+
+    /*
+     * Note that RFC 4822 is unclear whether auth_len should cover whole
+     * authentication trailer or just auth_data length.
+     *
+     * Crypto sequence numbers are increased by sender in rip_update_csn().
+     * First CSN should be zero, this is handled by csn_ready.
+     */
+
+    struct rip_auth_tail *tail = (void *) ((byte *) pkt + *plen);
+    tail->must_be_ffff = htons(0xffff);
+    tail->must_be_0001 = htons(0x0001);
+    strncpy(tail->auth_data, pass->password, RIP_MD5_LENGTH);
+
+    *plen += sizeof(struct rip_auth_tail) + RIP_MD5_LENGTH;
+
+    struct MD5Context ctxt;
+    MD5Init(&ctxt);
+    MD5Update(&ctxt, (byte *) pkt, *plen);
+    MD5Final(tail->auth_data, &ctxt);
+    return;
+
+  default:
+    bug("Unknown authentication type");
+  }
+}
+
+static int
+rip_check_authentication(struct rip_proto *p, struct rip_iface *ifa, struct rip_packet *pkt, uint *plen, struct rip_neighbor *n)
+{
+  struct rip_block_auth *auth = (void *) (pkt + 1);
+  struct password_item *pass = NULL;
+  const char *err_dsc = NULL;
+  uint err_val = 0;
+  uint auth_type = 0;
+
+  /* Check for authentication entry */
+  if ((*plen >= (sizeof(struct rip_packet) + sizeof(struct rip_block_auth))) &&
+      (auth->must_be_ffff == htons(0xffff)))
+    auth_type = ntohs(auth->auth_type);
+
+  if (auth_type != ifa->cf->auth_type)
+    DROP("authentication method mismatch", auth_type);
+
+  switch (auth_type)
+  {
+  case RIP_AUTH_NONE:
+    return 1;
+
+  case RIP_AUTH_PLAIN:
+    pass = password_find_by_value(ifa->cf->passwords, auth->password, RIP_PASSWD_LENGTH);
+    if (!pass)
+      DROP1("wrong password");
+
+    return 1;
+
+  case RIP_AUTH_CRYPTO:
+    pass = password_find_by_id(ifa->cf->passwords, auth->key_id);
+    if (!pass)
+      DROP("no suitable password found", auth->key_id);
+
+    uint data_len = ntohs(auth->packet_len);
+    uint auth_len = sizeof(struct rip_auth_tail) + RIP_MD5_LENGTH;
+
+    if (data_len + auth_len != *plen)
+      DROP("packet length mismatch", data_len);
+
+    if ((auth->auth_len != RIP_MD5_LENGTH) && (auth->auth_len != auth_len))
+      DROP("authentication data length mismatch", auth->auth_len);
+
+    struct rip_auth_tail *tail = (void *) ((byte *) pkt + data_len);
+    if ((tail->must_be_ffff != htons(0xffff)) || (tail->must_be_0001 != htons(0x0001)))
+      DROP1("authentication trailer is missing");
+
+    /* Accept higher sequence number, or zero if connectivity is lost */
+    /* FIXME: sequence number must be password/SA specific */
+    u32 rcv_csn = ntohl(auth->seq_num);
+    if ((rcv_csn < n->csn) && (rcv_csn || n->uc))
+    {
+      /* We want to report both new and old CSN */
+      LOG_PKT_AUTH("Authentication failed for %I on %s - "
+		   "lower sequence number (rcv %u, old %u)",
+		   n->nbr->addr, ifa->iface->name, rcv_csn, n->csn);
+      return 0;
+    }
+
+    char received[RIP_MD5_LENGTH];
+    char computed[RIP_MD5_LENGTH];
+
+    memcpy(received, tail->auth_data, RIP_MD5_LENGTH);
+    strncpy(tail->auth_data, pass->password, RIP_MD5_LENGTH);
+
+    struct MD5Context ctxt;
+    MD5Init(&ctxt);
+    MD5Update(&ctxt, (byte *) pkt, *plen);
+    MD5Final(computed, &ctxt);
+
+    if (memcmp(received, computed, RIP_MD5_LENGTH))
+      DROP("wrong MD5 digest", pass->id);
+
+    *plen = data_len;
+    n->csn = rcv_csn;
+
+    return 1;
+  }
+
+drop:
+  LOG_PKT_AUTH("Authentication failed for %I on %s - %s (%u)",
+	       n->nbr->addr, ifa->iface->name, err_dsc, err_val);
+
+  return 0;
+}
+
+static inline int
+rip_send_to(struct rip_proto *p, struct rip_iface *ifa, struct rip_packet *pkt, uint plen, ip_addr dst)
+{
+  if (ifa->cf->auth_type)
+    rip_fill_authentication(p, ifa, pkt, &plen);
+
+  return sk_send_to(ifa->sk, plen, dst, 0);
+}
+
+
+void
+rip_send_request(struct rip_proto *p, struct rip_iface *ifa)
+{
+  byte *pos = rip_tx_buffer(ifa);
+
+  struct rip_packet *pkt = (void *) pos;
+  pkt->command = RIP_CMD_REQUEST;
+  pkt->version = ifa->cf->version;
+  pkt->unused = 0;
+  pos += rip_pkt_hdrlen(ifa);
+
+  struct rip_block b = { .no_af = 1, .metric = p->infinity };
+  rip_put_block(p, pos, &b);
+  pos += RIP_BLOCK_LENGTH;
+
+  rip_update_csn(p, ifa);
+
+  TRACE(D_PACKETS, "Sending request via %s", ifa->iface->name);
+  rip_send_to(p, ifa, pkt, pos - (byte *) pkt, ifa->addr);
+}
+
+static void
+rip_receive_request(struct rip_proto *p, struct rip_iface *ifa, struct rip_packet *pkt, uint plen, struct rip_neighbor *from)
+{
+  TRACE(D_PACKETS, "Request received from %I on %s", from->nbr->addr, ifa->iface->name);
+
+  byte *pos = (byte *) pkt + rip_pkt_hdrlen(ifa);
+
+  /* We expect one regular block */
+  if (plen != (rip_pkt_hdrlen(ifa) + RIP_BLOCK_LENGTH))
+    return;
+
+  struct rip_block b = { .no_af = 1 };
+
+  if (!rip_get_block(p, pos, &b))
+    return;
+
+  /* Special case - zero prefix, infinity metric */
+  if (ipa_nonzero(b.prefix) || b.pxlen || (b.metric != p->infinity))
+    return;
+
+  /* We do nothing if TX is already active */
+  if (ifa->tx_active)
+  {
+    TRACE(D_EVENTS, "Skipping request from %I on %s, TX is busy", from->nbr->addr, ifa->iface->name);
+    return;
+  }
+
+  if (!ifa->cf->passive)
+    rip_send_table(p, ifa, from->nbr->addr, 0);
+}
+
+
+static int
+rip_send_response(struct rip_proto *p, struct rip_iface *ifa)
+{
+  if (! ifa->tx_active)
+    return 0;
+
+  byte *pos = rip_tx_buffer(ifa);
+  byte *max = rip_tx_buffer(ifa) + ifa->tx_plen -
+    (rip_is_v2(p) ? RIP_BLOCK_LENGTH : 2*RIP_BLOCK_LENGTH);
+  ip_addr last_next_hop = IPA_NONE;
+  int send = 0;
+
+  struct rip_packet *pkt = (void *) pos;
+  pkt->command = RIP_CMD_RESPONSE;
+  pkt->version = ifa->cf->version;
+  pkt->unused = 0;
+  pos += rip_pkt_hdrlen(ifa);
+
+  FIB_ITERATE_START(&p->rtable, &ifa->tx_fit, z)
+  {
+    struct rip_entry *en = (struct rip_entry *) z;
+
+    /* Dummy entries */
+    if (!en->valid)
+      goto next_entry;
+
+    /* Stale entries that should be removed */
+    if ((en->valid == RIP_ENTRY_STALE) &&
+	((en->changed + ifa->cf->garbage_time) <= now))
+      goto next_entry;
+
+    /* Triggered updates */
+    if (en->changed < ifa->tx_changed)
+      goto next_entry;
+
+    /* Not enough space for current entry */
+    if (pos > max)
+    {
+      FIB_ITERATE_PUT(&ifa->tx_fit, z);
+      goto break_loop;
+    }
+
+    struct rip_block rte = {
+      .prefix = en->n.prefix,
+      .pxlen = en->n.pxlen,
+      .metric = en->metric,
+      .tag = en->tag
+    };
+
+    if (en->iface == ifa->iface)
+      rte.next_hop = en->next_hop;
+
+    if (rip_is_v2(p) && (ifa->cf->version == RIP_V1))
+    {
+      /* Skipping subnets (i.e. not hosts, classful networks or default route) */
+      if (ip4_masklen(ip4_class_mask(ipa_to_ip4(en->n.prefix))) != en->n.pxlen)
+	goto next_entry;
+
+      rte.tag = 0;
+      rte.pxlen = 0;
+      rte.next_hop = IPA_NONE;
+    }
+
+    /* Split horizon */
+    if (en->from == ifa->iface && ifa->cf->split_horizon)
+    {
+      if (ifa->cf->poison_reverse)
+      {
+	rte.metric = p->infinity;
+	rte.next_hop = IPA_NONE;
+      }
+      else
+	goto next_entry;
+    }
+
+    // TRACE(D_PACKETS, "    %I/%d -> %I metric %d", rte.prefix, rte.pxlen, rte.next_hop, rte.metric);
+
+    /* RIPng next hop entry */
+    if (rip_is_ng(p) && !ipa_equal(rte.next_hop, last_next_hop))
+    {
+      last_next_hop = rte.next_hop;
+      rip_put_next_hop(p, pos, &rte);
+      pos += RIP_BLOCK_LENGTH;
+    }
+
+    rip_put_block(p, pos, &rte);
+    pos += RIP_BLOCK_LENGTH;
+    send = 1;
+
+  next_entry: ;
+  }
+  FIB_ITERATE_END(z);
+  ifa->tx_active = 0;
+
+  /* Do not send empty packet */
+  if (!send)
+    return 0;
+
+break_loop:
+  TRACE(D_PACKETS, "Sending response via %s", ifa->iface->name);
+  return rip_send_to(p, ifa, pkt, pos - (byte *) pkt, ifa->tx_addr);
+}
+
+/**
+ * rip_send_table - RIP interface timer hook
+ * @p: RIP instance
+ * @ifa: RIP interface
+ * @addr: destination IP address
+ * @changed: time limit for triggered updates
+ *
+ * The function activates an update session and starts sending routing update
+ * packets (using rip_send_response()). The session may be finished during the
+ * call or may continue in rip_tx_hook() until all appropriate routes are
+ * transmitted. Note that there may be at most one active update session per
+ * interface, the function will terminate the old active session before
+ * activating the new one.
+ */
+void
+rip_send_table(struct rip_proto *p, struct rip_iface *ifa, ip_addr addr, bird_clock_t changed)
+{
+  DBG("RIP: Opening TX session to %I on %s\n", dst, ifa->iface->name);
+
+  rip_reset_tx_session(p, ifa);
+
+  ifa->tx_active = 1;
+  ifa->tx_addr = addr;
+  ifa->tx_changed = changed;
+  FIB_ITERATE_INIT(&ifa->tx_fit, &p->rtable);
+
+  rip_update_csn(p, ifa);
+
+  while (rip_send_response(p, ifa) > 0)
+    ;
+}
+
+static void
+rip_tx_hook(sock *sk)
+{
+  struct rip_iface *ifa = sk->data;
+  struct rip_proto *p = ifa->rip;
+
+  DBG("RIP: TX hook called (iface %s, src %I, dst %I)\n",
+      sk->iface->name, sk->saddr, sk->daddr);
+
+  while (rip_send_response(p, ifa) > 0)
+    ;
+}
+
+static void
+rip_err_hook(sock *sk, int err)
+{
+  struct rip_iface *ifa = sk->data;
+  struct rip_proto *p = ifa->rip;
+
+  log(L_ERR "%s: Socket error on %s: %M", p->p.name, ifa->iface->name, err);
+
+  rip_reset_tx_session(p, ifa);
+}
+
+static void
+rip_receive_response(struct rip_proto *p, struct rip_iface *ifa, struct rip_packet *pkt, uint plen, struct rip_neighbor *from)
+{
+  struct rip_block rte = {};
+  const char *err_dsc = NULL;
+
+  TRACE(D_PACKETS, "Response received from %I on %s", from->nbr->addr, ifa->iface->name);
+
+  byte *pos = (byte *) pkt + sizeof(struct rip_packet);
+  byte *end = (byte *) pkt + plen;
+
+  for (; pos < end; pos += RIP_BLOCK_LENGTH)
+  {
+    /* Find next regular RTE */
+    if (!rip_get_block(p, pos, &rte))
+      continue;
+
+    int c = ipa_classify_net(rte.prefix);
+    if ((c < 0) || !(c & IADDR_HOST) || ((c & IADDR_SCOPE_MASK) <= SCOPE_LINK))
+      SKIP("invalid prefix");
+
+    if (rip_is_v2(p) && (pkt->version == RIP_V1))
+    {
+      if (ifa->cf->check_zero && (rte.tag || rte.pxlen || ipa_nonzero(rte.next_hop)))
+	SKIP("RIPv1 reserved field is nonzero");
+
+      rte.tag = 0;
+      rte.pxlen = ip4_masklen(ip4_class_mask(ipa_to_ip4(rte.prefix)));
+      rte.next_hop = IPA_NONE;
+    }
+
+    if ((rte.pxlen < 0) || (rte.pxlen > MAX_PREFIX_LENGTH))
+      SKIP("invalid prefix length");
+
+    if (rte.metric > p->infinity)
+      SKIP("invalid metric");
+
+    if (ipa_nonzero(rte.next_hop))
+    {
+      neighbor *nbr = neigh_find2(&p->p, &rte.next_hop, ifa->iface, 0);
+      if (!nbr || (nbr->scope <= 0))
+	rte.next_hop = IPA_NONE;
+    }
+
+    // TRACE(D_PACKETS, "    %I/%d -> %I metric %d", rte.prefix, rte.pxlen, rte.next_hop, rte.metric);
+
+    rte.metric += ifa->cf->metric;
+
+    if (rte.metric < p->infinity)
+    {
+      struct rip_rte new = {
+	.from = from,
+	.next_hop = ipa_nonzero(rte.next_hop) ? rte.next_hop : from->nbr->addr,
+	.metric = rte.metric,
+	.tag = rte.tag,
+	.expires = now + ifa->cf->timeout_time
+      };
+
+      rip_update_rte(p, &rte.prefix, rte.pxlen, &new);
+    }
+    else
+      rip_withdraw_rte(p, &rte.prefix, rte.pxlen, from);
+
+    continue;
+
+  skip:
+    LOG_RTE("Ignoring route %I/%d received from %I - %s",
+	    rte.prefix, rte.pxlen, from->nbr->addr, err_dsc);
+  }
+}
+
+static int
+rip_rx_hook(sock *sk, int len)
+{
+  struct rip_iface *ifa = sk->data;
+  struct rip_proto *p = ifa->rip;
+  const char *err_dsc = NULL;
+  uint err_val = 0;
+
+  if (sk->lifindex != sk->iface->index)
+    return 1;
+
+  DBG("RIP: RX hook called (iface %s, src %I, dst %I)\n",
+      sk->iface->name, sk->faddr, sk->laddr);
+
+  /* Silently ignore my own packets */
+  /* FIXME: Better local address check */
+  if (ipa_equal(ifa->iface->addr->ip, sk->faddr))
+    return 1;
+
+  if (rip_is_ng(p) && !ipa_is_link_local(sk->faddr))
+    DROP1("wrong src address");
+
+  struct rip_neighbor *n = rip_get_neighbor(p, &sk->faddr, ifa);
+
+  if (!n)
+    DROP1("not from neighbor");
+
+  if ((ifa->cf->ttl_security == 1) && (sk->rcv_ttl < 255))
+    DROP("wrong TTL", sk->rcv_ttl);
+
+  if (sk->fport != sk->dport)
+    DROP("wrong src port", sk->fport);
+
+  if (len < sizeof(struct rip_packet))
+    DROP("too short", len);
+
+  if (sk->flags & SKF_TRUNCATED)
+    DROP("truncated", len);
+
+  struct rip_packet *pkt = (struct rip_packet *) sk->rbuf;
+  uint plen = len;
+
+  if (!pkt->version || (ifa->cf->version_only && (pkt->version != ifa->cf->version)))
+    DROP("wrong version", pkt->version);
+
+  /* rip_check_authentication() has its own error logging */
+  if (rip_is_v2(p) && !rip_check_authentication(p, ifa, pkt, &plen, n))
+    return 1;
+
+  if ((plen - sizeof(struct rip_packet)) % RIP_BLOCK_LENGTH)
+    DROP("invalid length", plen);
+
+  n->last_seen = now;
+  rip_update_bfd(p, n);
+
+  switch (pkt->command)
+  {
+  case RIP_CMD_REQUEST:
+    rip_receive_request(p, ifa, pkt, plen, n);
+    break;
+
+  case RIP_CMD_RESPONSE:
+    rip_receive_response(p, ifa, pkt, plen, n);
+    break;
+
+  default:
+    DROP("unknown command", pkt->command);
+  }
+  return 1;
+
+drop:
+  LOG_PKT("Bad packet from %I via %s - %s (%u)",
+	  sk->faddr, sk->iface->name, err_dsc, err_val);
+
+  return 1;
+}
+
+int
+rip_open_socket(struct rip_iface *ifa)
+{
+  struct rip_proto *p = ifa->rip;
+
+  sock *sk = sk_new(p->p.pool);
+  sk->type = SK_UDP;
+  sk->sport = ifa->cf->port;
+  sk->dport = ifa->cf->port;
+  sk->iface = ifa->iface;
+
+  /*
+   * For RIPv2, we explicitly choose a primary address, mainly to ensure that
+   * RIP and BFD uses the same one. For RIPng, we left it to kernel, which
+   * should choose some link-local address based on the same scope rule.
+   */
+  if (rip_is_v2(p))
+    sk->saddr = ifa->iface->addr->ip;
+
+  sk->rx_hook = rip_rx_hook;
+  sk->tx_hook = rip_tx_hook;
+  sk->err_hook = rip_err_hook;
+  sk->data = ifa;
+
+  sk->tos = ifa->cf->tx_tos;
+  sk->priority = ifa->cf->tx_priority;
+  sk->ttl = ifa->cf->ttl_security ? 255 : 1;
+  sk->flags = SKF_LADDR_RX | ((ifa->cf->ttl_security == 1) ? SKF_TTL_RX : 0);
+
+  /* sk->rbsize and sk->tbsize are handled in rip_iface_update_buffers() */
+
+  if (sk_open(sk) < 0)
+    goto err;
+
+  if (ifa->cf->mode == RIP_IM_MULTICAST)
+  {
+    if (sk_setup_multicast(sk) < 0)
+      goto err;
+
+    if (sk_join_group(sk, ifa->addr) < 0)
+      goto err;
+  }
+  else /* Broadcast */
+  {
+    if (sk_setup_broadcast(sk) < 0)
+      goto err;
+
+    if (ipa_zero(ifa->addr))
+    {
+      sk->err = "Missing broadcast address";
+      goto err;
+    }
+  }
+
+  ifa->sk = sk;
+  return 1;
+
+err:
+  sk_log_error(sk, p->p.name);
+  rfree(sk);
+  return 0;
+}
diff --git a/proto/rip/rip.c b/proto/rip/rip.c
index b77cf409..c85fd69b 100644
--- a/proto/rip/rip.c
+++ b/proto/rip/rip.c
@@ -1,1047 +1,1275 @@
 /*
- *	Rest in pieces - RIP protocol
+ *	BIRD -- Routing Information Protocol (RIP)
  *
- *	Copyright (c) 1998, 1999 Pavel Machek <pavel@ucw.cz>
- *	              2004       Ondrej Filip <feela@network.cz>
+ *	(c) 1998--1999 Pavel Machek <pavel@ucw.cz>
+ *	(c) 2004--2013 Ondrej Filip <feela@network.cz>
+ *	(c) 2009--2015 Ondrej Zajicek <santiago@crfreenet.org>
+ *	(c) 2009--2015 CZ.NIC z.s.p.o.
  *
  *	Can be freely distributed and used under the terms of the GNU GPL.
- *
- 	FIXME: IPv6 support: packet size
-	FIXME: (nonurgent) IPv6 support: receive "route using" blocks
-	FIXME: (nonurgent) IPv6 support: generate "nexthop" blocks
-		next hops are only advisory, and they are pretty ugly in IPv6.
-		I suggest just forgetting about them.
-
-	FIXME: (nonurgent): fold rip_connection into rip_interface?
-
-	FIXME: propagation of metric=infinity into main routing table may or may not be good idea.
  */
 
 /**
- * DOC: Routing Information Protocol
+ * DOC: Routing Information Protocol (RIP)
+ *
+ * The RIP protocol is implemented in two files: |rip.c| containing the protocol
+ * logic, route management and the protocol glue with BIRD core, and |packets.c|
+ * handling RIP packet processing, RX, TX and protocol sockets.
+ *
+ * Each instance of RIP is described by a structure &rip_proto, which contains
+ * an internal RIP routing table, a list of protocol interfaces and the main
+ * timer responsible for RIP routing table cleanup.
+ *
+ * RIP internal routing table contains incoming and outgoing routes. For each
+ * network (represented by structure &rip_entry) there is one outgoing route
+ * stored directly in &rip_entry and an one-way linked list of incoming routes
+ * (structures &rip_rte). The list contains incoming routes from different RIP
+ * neighbors, but only routes with the lowest metric are stored (i.e., all
+ * stored incoming routes have the same metric).
+ *
+ * Note that RIP itself does not select outgoing route, that is done by the core
+ * routing table. When a new incoming route is received, it is propagated to the
+ * RIP table by rip_update_rte() and possibly stored in the list of incoming
+ * routes. Then the change may be propagated to the core by rip_announce_rte().
+ * The core selects the best route and propagate it to RIP by rip_rt_notify(),
+ * which updates outgoing route part of &rip_entry and possibly triggers route
+ * propagation by rip_trigger_update().
  *
- * RIP is a pretty simple protocol, so about a half of its code is interface
- * with the core.
+ * RIP interfaces are represented by structures &rip_iface. A RIP interface
+ * contains a per-interface socket, a list of associated neighbors, interface
+ * configuration, and state information related to scheduled interface events
+ * and running update sessions. RIP interfaces are added and removed based on
+ * core interface notifications.
  *
- * We maintain our own linked list of &rip_entry structures -- it serves
- * as our small routing table. RIP never adds to this linked list upon
- * packet reception; instead, it lets the core know about data from the packet
- * and waits for the core to call rip_rt_notify().
+ * There are two RIP interface events - regular updates and triggered updates.
+ * Both are managed from the RIP interface timer (rip_iface_timer()). Regular
+ * updates are called at fixed interval and propagate the whole routing table,
+ * while triggered updates are scheduled by rip_trigger_update() due to some
+ * routing table change and propagate only the routes modified since the time
+ * they were scheduled. There are also unicast-destined requested updates, but
+ * these are sent directly as a reaction to received RIP request message. The
+ * update session is started by rip_send_table(). There may be at most one
+ * active update session per interface, as the associated state (including the
+ * fib iterator) is stored directly in &rip_iface structure.
  *
- * Within rip_tx(), the list is
- * walked and a packet is generated using rip_tx_prepare(). This gets
- * tricky because we may need to send more than one packet to one
- * destination. Struct &rip_connection is used to hold context information such as how
- * many of &rip_entry's we have already sent and it's also used to protect
- * against two concurrent sends to one destination. Each &rip_interface has
- * at most one &rip_connection.
+ * RIP neighbors are represented by structures &rip_neighbor. Compared to
+ * neighbor handling in other routing protocols, RIP does not have explicit
+ * neighbor discovery and adjacency maintenance, which makes the &rip_neighbor
+ * related code a bit peculiar. RIP neighbors are interlinked with core neighbor
+ * structures (&neighbor) and use core neighbor notifications to ensure that RIP
+ * neighbors are timely removed. RIP neighbors are added based on received route
+ * notifications and removed based on core neighbor and RIP interface events.
  *
- * We are not going to honor requests for sending part of
- * routing table. That would need to turn split horizon off etc.  
+ * RIP neighbors are linked by RIP routes and use counter to track the number of
+ * associated routes, but when these RIP routes timeout, associated RIP neighbor
+ * is still alive (with zero counter). When RIP neighbor is removed but still
+ * has some associated routes, it is not freed, just changed to detached state
+ * (core neighbors and RIP ifaces are unlinked), then during the main timer
+ * cleanup phase the associated routes are removed and the &rip_neighbor
+ * structure is finally freed.
  *
- * About triggered updates, RFC says: when a triggered update was sent,
- * don't send a new one for something between 1 and 5 seconds (and send one
- * after that). We do something else: each 5 seconds,
- * we look for any changed routes and broadcast them.
+ * Supported standards:
+ * - RFC 1058 - RIPv1
+ * - RFC 2453 - RIPv2
+ * - RFC 2080 - RIPng
+ * - RFC 4822 - RIP cryptographic authentication
  */
 
-#undef LOCAL_DEBUG
-#define LOCAL_DEBUG 1
-
-#include "nest/bird.h"
-#include "nest/iface.h"
-#include "nest/protocol.h"
-#include "nest/route.h"
-#include "lib/socket.h"
-#include "lib/resource.h"
-#include "lib/lists.h"
-#include "lib/timer.h"
-#include "lib/string.h"
-
+#include <stdlib.h>
 #include "rip.h"
 
-#define P ((struct rip_proto *) p)
-#define P_CF ((struct rip_proto_config *)p->cf)
 
-#undef TRACE
-#define TRACE(level, msg, args...) do { if (p->debug & level) { log(L_TRACE "%s: " msg, p->name , ## args); } } while(0)
+static inline void rip_lock_neighbor(struct rip_neighbor *n);
+static inline void rip_unlock_neighbor(struct rip_neighbor *n);
+static inline int rip_iface_link_up(struct rip_iface *ifa);
+static inline void rip_kick_timer(struct rip_proto *p);
+static inline void rip_iface_kick_timer(struct rip_iface *ifa);
+static void rip_iface_timer(timer *timer);
+static void rip_trigger_update(struct rip_proto *p);
 
-static struct rip_interface *new_iface(struct proto *p, struct iface *new, unsigned long flags, struct iface_patt *patt);
 
 /*
- * Output processing
- *
- * This part is responsible for getting packets out to the network.
+ *	RIP routes
  */
 
 static void
-rip_tx_err( sock *s, int err )
+rip_init_entry(struct fib_node *fn)
 {
-  struct rip_connection *c = ((struct rip_interface *)(s->data))->busy;
-  struct proto *p = c->proto;
-  log( L_ERR "%s: Unexpected error at rip transmit: %M", p->name, err );
+  // struct rip_entry *en = (void) *fn;
+
+  const uint offset = OFFSETOF(struct rip_entry, routes);
+  memset((byte *)fn + offset, 0, sizeof(struct rip_entry) - offset);
 }
 
-/*
- * rip_tx_prepare:
- * @e: rip entry that needs to be translated to form suitable for network
- * @b: block to be filled
- *
- * Fill one rip block with info that needs to go to the network. Handle
- * nexthop and split horizont correctly. (Next hop is ignored for IPv6,
- * that could be fixed but it is not real problem).
- */
-static int
-rip_tx_prepare(struct proto *p, struct rip_block *b, struct rip_entry *e, struct rip_interface *rif, int pos )
+static struct rip_rte *
+rip_add_rte(struct rip_proto *p, struct rip_rte **rp, struct rip_rte *src)
 {
-  int metric;
-  DBG( "." );
-  b->tag     = htons( e->tag );
-  b->network = e->n.prefix;
-  metric = e->metric;
-  if (neigh_connected_to(p, &e->whotoldme, rif->iface)) {
-    DBG( "(split horizon)" );
-    metric = P_CF->infinity;
-  }
-#ifndef IPV6
-  b->family  = htons( 2 ); /* AF_INET */
-  b->netmask = ipa_mkmask( e->n.pxlen );
-  ipa_hton( b->netmask );
+  struct rip_rte *rt = sl_alloc(p->rte_slab);
 
-  if (neigh_connected_to(p, &e->nexthop, rif->iface))
-    b->nexthop = e->nexthop;
-  else
-    b->nexthop = IPA_NONE;
-  ipa_hton( b->nexthop );  
-  b->metric  = htonl( metric );
-#else
-  b->pxlen = e->n.pxlen;
-  b->metric  = metric; /* it is u8 */
-#endif
+  memcpy(rt, src, sizeof(struct rip_rte));
+  rt->next = *rp;
+  *rp = rt;
 
-  ipa_hton( b->network );
+  rip_lock_neighbor(rt->from);
 
-  return pos+1;
+  return rt;
 }
 
-/*
- * rip_tx - send one rip packet to the network
+static inline void
+rip_remove_rte(struct rip_proto *p, struct rip_rte **rp)
+{
+  struct rip_rte *rt = *rp;
+
+  rip_unlock_neighbor(rt->from);
+
+  *rp = rt->next;
+  sl_free(p->rte_slab, rt);
+}
+
+static inline int rip_same_rte(struct rip_rte *a, struct rip_rte *b)
+{ return a->metric == b->metric && a->tag == b->tag && ipa_equal(a->next_hop, b->next_hop); }
+
+static inline int rip_valid_rte(struct rip_rte *rt)
+{ return rt->from->ifa != NULL; }
+
+/**
+ * rip_announce_rte - announce route from RIP routing table to the core
+ * @p: RIP instance
+ * @en: related network
+ *
+ * The function takes a list of incoming routes from @en, prepare appropriate
+ * &rte for the core and propagate it by rte_update().
  */
 static void
-rip_tx( sock *s )
+rip_announce_rte(struct rip_proto *p, struct rip_entry *en)
 {
-  struct rip_interface *rif = s->data;
-  struct rip_connection *c = rif->busy;
-  struct proto *p = c->proto;
-  struct rip_packet *packet = (void *) s->tbuf;
-  int i, packetlen;
-  int maxi, nullupdate = 1;
-
-  DBG( "Sending to %I\n", s->daddr );
-  do {
-
-    if (c->done)
-      goto done;
-
-    DBG( "Preparing packet to send: " );
-
-    packet->heading.command = RIPCMD_RESPONSE;
-#ifndef IPV6
-    packet->heading.version = RIP_V2;
-#else
-    packet->heading.version = RIP_NG;
-#endif
-    packet->heading.unused  = 0;
-
-    i = !!P_CF->authtype;
-#ifndef IPV6
-    maxi = ((P_CF->authtype == AT_MD5) ? PACKET_MD5_MAX : PACKET_MAX);
-#else
-    maxi = 5; /* We need to have at least reserve of one at end of packet */
-#endif
-    
-    FIB_ITERATE_START(&P->rtable, &c->iter, z) {
-      struct rip_entry *e = (struct rip_entry *) z;
-
-      if (!rif->triggered || (!(e->updated < now-2))) {		/* FIXME: Should be probably 1 or some different algorithm */
-	nullupdate = 0;
-	i = rip_tx_prepare( p, packet->block + i, e, rif, i );
-	if (i >= maxi) {
-	  FIB_ITERATE_PUT(&c->iter, z);
-	  goto break_loop;
-	}
-      }
-    } FIB_ITERATE_END(z);
-    c->done = 1;
+  struct rip_rte *rt = en->routes;
+
+  /* Find first valid rte */
+  while (rt && !rip_valid_rte(rt))
+    rt = rt->next;
+
+  if (rt)
+  {
+    /* Update */
+    net *n = net_get(p->p.table, en->n.prefix, en->n.pxlen);
 
-  break_loop:
+    rta a0 = {
+      .src = p->p.main_source,
+      .source = RTS_RIP,
+      .scope = SCOPE_UNIVERSE,
+      .cast = RTC_UNICAST
+    };
 
-    packetlen = rip_outgoing_authentication(p, (void *) &packet->block[0], packet, i);
+    u8 rt_metric = rt->metric;
+    u16 rt_tag = rt->tag;
+    struct rip_rte *rt2 = rt->next;
+
+    /* Find second valid rte */
+    while (rt2 && !rip_valid_rte(rt2))
+      rt2 = rt2->next;
+
+    if (p->ecmp && rt2)
+    {
+      /* ECMP route */
+      struct mpnh *nhs = NULL;
+      struct mpnh **nhp = &nhs;
+      int num = 0;
 
-    DBG( ", sending %d blocks, ", i );
-    if (nullupdate) {
-      DBG( "not sending NULL update\n" );
-      c->done = 1;
-      goto done;
+      for (rt = en->routes; rt && (num < p->ecmp); rt = rt->next)
+      {
+	if (!rip_valid_rte(rt))
+	    continue;
+
+	struct mpnh *nh = alloca(sizeof(struct mpnh));
+	nh->gw = rt->next_hop;
+	nh->iface = rt->from->nbr->iface;
+	nh->weight = rt->from->ifa->cf->ecmp_weight;
+	nh->next = NULL;
+	*nhp = nh;
+	nhp = &(nh->next);
+	num++;
+
+	if (rt->tag != rt_tag)
+	  rt_tag = 0;
+      }
+
+      a0.dest = RTD_MULTIPATH;
+      a0.nexthops = nhs;
     }
-    if (ipa_nonzero(c->daddr))
-      i = sk_send_to( s, packetlen, c->daddr, c->dport );
     else
-      i = sk_send( s, packetlen );
-
-    DBG( "it wants more\n" );
-  
-  } while (i>0);
-  
-  if (i<0) rip_tx_err( s, i );
-  DBG( "blocked\n" );
-  return;
-
-done:
-  DBG( "Looks like I'm" );
-  c->rif->busy = NULL;
-  rem_node(NODE c);
-  mb_free(c);
-  DBG( " done\n" );
-  return;
-}
+    {
+      /* Unipath route */
+      a0.dest = RTD_ROUTER;
+      a0.gw = rt->next_hop;
+      a0.iface = rt->from->nbr->iface;
+      a0.from = rt->from->nbr->addr;
+    }
 
-/* 
- * rip_sendto - send whole routing table to selected destination
- * @rif: interface to use. Notice that we lock interface so that at
- * most one send to one interface is done.
- */
-static void
-rip_sendto( struct proto *p, ip_addr daddr, int dport, struct rip_interface *rif )
-{
-  struct iface *iface = rif->iface;
-  struct rip_connection *c;
-  static int num = 0;
+    rta *a = rta_lookup(&a0);
+    rte *e = rte_get_temp(a);
 
-  if (rif->busy) {
-    log (L_WARN "%s: Interface %s is much too slow, dropping request", p->name, iface->name);
-    return;
+    e->u.rip.from = a0.iface;
+    e->u.rip.metric = rt_metric;
+    e->u.rip.tag = rt_tag;
+
+    e->net = n;
+    e->pflags = 0;
+
+    rte_update(&p->p, n, e);
   }
-  c = mb_alloc( p->pool, sizeof( struct rip_connection ));
-  rif->busy = c;
-  
-  c->addr = daddr;
-  c->proto = p;
-  c->num = num++;
-  c->rif = rif;
-
-  c->dport = dport;
-  c->daddr = daddr;
-  if (c->rif->sock->data != rif)
-    bug("not enough send magic");
-
-  c->done = 0;
-  FIB_ITERATE_INIT( &c->iter, &P->rtable );
-  add_head( &P->connections, NODE c );
-  if (ipa_nonzero(daddr))
-    TRACE(D_PACKETS, "Sending my routing table to %I:%d on %s", daddr, dport, rif->iface->name );
   else
-    TRACE(D_PACKETS, "Broadcasting routing table to %s", rif->iface->name );
-
-  rip_tx(c->rif->sock);
+  {
+    /* Withdraw */
+    net *n = net_find(p->p.table, en->n.prefix, en->n.pxlen);
+    rte_update(&p->p, n, NULL);
+  }
 }
 
-static struct rip_interface*
-find_interface(struct proto *p, struct iface *what)
+/**
+ * rip_update_rte - enter a route update to RIP routing table
+ * @p: RIP instance
+ * @prefix: network prefix
+ * @pxlen: network prefix length
+ * @new: a &rip_rte representing the new route
+ *
+ * The function is called by the RIP packet processing code whenever it receives
+ * a reachable route. The appropriate routing table entry is found and the list
+ * of incoming routes is updated. Eventually, the change is also propagated to
+ * the core by rip_announce_rte(). Note that for unreachable routes,
+ * rip_withdraw_rte() should be called instead of rip_update_rte().
+ */
+void
+rip_update_rte(struct rip_proto *p, ip_addr *prefix, int pxlen, struct rip_rte *new)
 {
-  struct rip_interface *i;
+  struct rip_entry *en = fib_get(&p->rtable, prefix, pxlen);
+  struct rip_rte *rt, **rp;
+  int changed = 0;
+
+  /* If the new route is better, remove all current routes */
+  if (en->routes && new->metric < en->routes->metric)
+    while (en->routes)
+      rip_remove_rte(p, &en->routes);
+
+  /* Find the old route (also set rp for later) */
+  for (rp = &en->routes; rt = *rp; rp = &rt->next)
+    if (rt->from == new->from)
+    {
+      if (rip_same_rte(rt, new))
+      {
+	rt->expires = new->expires;
+	return;
+      }
 
-  WALK_LIST (i, P->interfaces)
-    if (i->iface == what)
-      return i;
-  return NULL;
+      /* Remove the old route */
+      rip_remove_rte(p, rp);
+      changed = 1;
+      break;
+    }
+
+  /* If the new route is optimal, add it to the list */
+  if (!en->routes || new->metric == en->routes->metric)
+  {
+    rt = rip_add_rte(p, rp, new);
+    changed = 1;
+  }
+
+  /* Announce change if on relevant position (the first or any for ECMP) */
+  if (changed && (rp == &en->routes || p->ecmp))
+    rip_announce_rte(p, en);
 }
 
-/*
- * Input processing
+/**
+ * rip_withdraw_rte - enter a route withdraw to RIP routing table
+ * @p: RIP instance
+ * @prefix: network prefix
+ * @pxlen: network prefix length
+ * @from: a &rip_neighbor propagating the withdraw
  *
- * This part is responsible for any updates that come from network 
+ * The function is called by the RIP packet processing code whenever it receives
+ * an unreachable route. The incoming route for given network from nbr @from is
+ * removed. Eventually, the change is also propagated by rip_announce_rte().
  */
+void
+rip_withdraw_rte(struct rip_proto *p, ip_addr *prefix, int pxlen, struct rip_neighbor *from)
+{
+  struct rip_entry *en = fib_find(&p->rtable, prefix, pxlen);
+  struct rip_rte *rt, **rp;
 
-static int rip_rte_better(struct rte *new, struct rte *old);
+  if (!en)
+    return;
 
-static void
-rip_rte_update_if_better(rtable *tab, net *net, struct proto *p, rte *new)
-{
-  rte *old;
+  /* Find the old route */
+  for (rp = &en->routes; rt = *rp; rp = &rt->next)
+    if (rt->from == from)
+      break;
 
-  old = rte_find(net, p->main_source);
-  if (!old || rip_rte_better(new, old) ||
-      (ipa_equal(old->attrs->from, new->attrs->from) &&
-      (old->u.rip.metric != new->u.rip.metric)) )
-    rte_update(p, net, new);
-  else
-    rte_free(new);
+  if (!rt)
+    return;
+
+  /* Remove the old route */
+  rip_remove_rte(p, rp);
+
+  /* Announce change if on relevant position */
+  if (rp == &en->routes || p->ecmp)
+    rip_announce_rte(p, en);
 }
 
 /*
- * advertise_entry - let main routing table know about our new entry
- * @b: entry in network format
- *
- * This basically translates @b to format used by bird core and feeds
- * bird core with this route.
+ * rip_rt_notify - core tells us about new route, so store
+ * it into our data structures.
  */
 static void
-advertise_entry( struct proto *p, struct rip_block *b, ip_addr whotoldme, struct iface *iface )
+rip_rt_notify(struct proto *P, struct rtable *table UNUSED, struct network *net, struct rte *new,
+	      struct rte *old UNUSED, struct ea_list *attrs)
 {
-  rta *a, A;
-  rte *r;
-  net *n;
-  neighbor *neighbor;
-  struct rip_interface *rif;
-  int pxlen;
-
-  bzero(&A, sizeof(A));
-  A.src= p->main_source;
-  A.source = RTS_RIP;
-  A.scope = SCOPE_UNIVERSE;
-  A.cast = RTC_UNICAST;
-  A.dest = RTD_ROUTER;
-  A.flags = 0;
-#ifndef IPV6
-  A.gw = ipa_nonzero(b->nexthop) ? b->nexthop : whotoldme;
-  pxlen = ipa_masklen(b->netmask);
-#else
-  /* FIXME: next hop is in other packet for v6 */
-  A.gw = whotoldme; 
-  pxlen = b->pxlen;
-#endif
-  A.from = whotoldme;
-
-  /* No need to look if destination looks valid - ie not net 0 or 127 -- core will do for us. */
-
-  neighbor = neigh_find2( p, &A.gw, iface, 0 );
-  if (!neighbor) {
-    log( L_REMOTE "%s: %I asked me to route %I/%d using not-neighbor %I.", p->name, A.from, b->network, pxlen, A.gw );
-    return;
-  }
-  if (neighbor->scope == SCOPE_HOST) {
-    DBG("Self-destined route, ignoring.\n");
-    return;
+  struct rip_proto *p = (struct rip_proto *) P;
+  struct rip_entry *en;
+  int old_metric;
+
+  if (new)
+  {
+    /* Update */
+    u32 rt_metric = ea_get_int(attrs, EA_RIP_METRIC, 1);
+    u32 rt_tag = ea_get_int(attrs, EA_RIP_TAG, 0);
+
+    if (rt_metric > p->infinity)
+    {
+      log(L_WARN "%s: Invalid rip_metric value %u for route %I/%d",
+	  p->p.name, rt_metric, net->n.prefix, net->n.pxlen);
+      rt_metric = p->infinity;
+    }
+
+    if (rt_tag > 0xffff)
+    {
+      log(L_WARN "%s: Invalid rip_tag value %u for route %I/%d",
+	  p->p.name, rt_tag, net->n.prefix, net->n.pxlen);
+      rt_metric = p->infinity;
+      rt_tag = 0;
+    }
+
+    /*
+     * Note that we accept exported routes with infinity metric (this could
+     * happen if rip_metric is modified in filters). Such entry has infinity
+     * metric but is RIP_ENTRY_VALID and therefore is not subject to garbage
+     * collection.
+     */
+
+    en = fib_get(&p->rtable, &net->n.prefix, net->n.pxlen);
+
+    old_metric = en->valid ? en->metric : -1;
+
+    en->valid = RIP_ENTRY_VALID;
+    en->metric = rt_metric;
+    en->tag = rt_tag;
+    en->from = (new->attrs->src->proto == P) ? new->u.rip.from : NULL;
+    en->iface = new->attrs->iface;
+    en->next_hop = new->attrs->gw;
   }
+  else
+  {
+    /* Withdraw */
+    en = fib_find(&p->rtable, &net->n.prefix, net->n.pxlen);
 
-  A.iface = neighbor->iface;
-  if (!(rif = neighbor->data)) {
-    rif = neighbor->data = find_interface(p, A.iface);
+    if (!en || en->valid != RIP_ENTRY_VALID)
+      return;
+
+    old_metric = en->metric;
+
+    en->valid = RIP_ENTRY_STALE;
+    en->metric = p->infinity;
+    en->tag = 0;
+    en->from = NULL;
+    en->iface = NULL;
+    en->next_hop = IPA_NONE;
   }
-  if (!rif)
-    bug("Route packet using unknown interface? No.");
-    
-  /* set to: interface of nexthop */
-  a = rta_lookup(&A);
-  if (pxlen==-1)  {
-    log( L_REMOTE "%s: %I gave me invalid pxlen/netmask for %I.", p->name, A.from, b->network );
-    return;
+
+  /* Activate triggered updates */
+  if (en->metric != old_metric)
+  {
+    en->changed = now;
+    rip_trigger_update(p);
   }
-  n = net_get( p->table, b->network, pxlen );
-  r = rte_get_temp(a);
-#ifndef IPV6
-  r->u.rip.metric = ntohl(b->metric) + rif->metric;
-#else  
-  r->u.rip.metric = b->metric + rif->metric;
-#endif
-
-  r->u.rip.entry = NULL;
-  if (r->u.rip.metric > P_CF->infinity) r->u.rip.metric = P_CF->infinity;
-  r->u.rip.tag = ntohl(b->tag);
-  r->net = n;
-  r->pflags = 0; /* Here go my flags */
-  rip_rte_update_if_better( p->table, n, p, r );
-  DBG( "done\n" );
 }
 
+
 /*
- * process_block - do some basic check and pass block to advertise_entry
+ *	RIP neighbors
  */
+
+struct rip_neighbor *
+rip_get_neighbor(struct rip_proto *p, ip_addr *a, struct rip_iface *ifa)
+{
+  neighbor *nbr = neigh_find2(&p->p, a, ifa->iface, 0);
+
+  if (!nbr || (nbr->scope == SCOPE_HOST) || !rip_iface_link_up(ifa))
+    return NULL;
+
+  if (nbr->data)
+    return nbr->data;
+
+  TRACE(D_EVENTS, "New neighbor %I on %s", *a, ifa->iface->name);
+
+  struct rip_neighbor *n = mb_allocz(p->p.pool, sizeof(struct rip_neighbor));
+  n->ifa = ifa;
+  n->nbr = nbr;
+  nbr->data = n;
+  n->csn = nbr->aux;
+
+  add_tail(&ifa->neigh_list, NODE n);
+
+  return n;
+}
+
 static void
-process_block( struct proto *p, struct rip_block *block, ip_addr whotoldme, struct iface *iface )
+rip_remove_neighbor(struct rip_proto *p, struct rip_neighbor *n)
 {
-  int metric, pxlen;
-
-#ifndef IPV6
-  metric = ntohl( block->metric );
-  pxlen = ipa_masklen(block->netmask);
-#else
-  metric = block->metric;
-  pxlen = block->pxlen;
-#endif
-  ip_addr network = block->network;
-
-  CHK_MAGIC;
-
-  TRACE(D_ROUTES, "block: %I tells me: %I/%d available, metric %d... ",
-      whotoldme, network, pxlen, metric );
-
-  if ((!metric) || (metric > P_CF->infinity)) {
-#ifdef IPV6 /* Someone is sending us nexthop and we are ignoring it */
-    if (metric == 0xff)
-      { DBG( "IPv6 nexthop ignored" ); return; }
-#endif
-    log( L_WARN "%s: Got metric %d from %I", p->name, metric, whotoldme );
-    return;
-  }
+  neighbor *nbr = n->nbr;
+
+  TRACE(D_EVENTS, "Removing neighbor %I on %s", nbr->addr, nbr->iface->name);
 
-  advertise_entry( p, block, whotoldme, iface );
+  rem_node(NODE n);
+  n->ifa = NULL;
+  n->nbr = NULL;
+  nbr->data = NULL;
+  nbr->aux = n->csn;
+
+  rfree(n->bfd_req);
+  n->bfd_req = NULL;
+  n->last_seen = 0;
+
+  if (!n->uc)
+    mb_free(n);
+
+  /* Related routes are removed in rip_timer() */
+  rip_kick_timer(p);
 }
 
-#define BAD( x ) { log( L_REMOTE "%s: " x, p->name ); return 1; }
+static inline void
+rip_lock_neighbor(struct rip_neighbor *n)
+{
+  n->uc++;
+}
 
-/*
- * rip_process_packet - this is main routine for incoming packets.
- */
-static int
-rip_process_packet( struct proto *p, struct rip_packet *packet, int num, ip_addr whotoldme, int port, struct iface *iface )
+static inline void
+rip_unlock_neighbor(struct rip_neighbor *n)
 {
-  int i;
-  int authenticated = 0;
-  neighbor *neighbor;
+  n->uc--;
+
+  if (!n->nbr && !n->uc)
+    mb_free(n);
+}
+
+static void
+rip_neigh_notify(struct neighbor *nbr)
+{
+  struct rip_proto *p = (struct rip_proto *) nbr->proto;
+  struct rip_neighbor *n = nbr->data;
+
+  if (!n)
+    return;
+
+  /*
+   * We assume that rip_neigh_notify() is called before rip_if_notify() for
+   * IF_CHANGE_DOWN and therefore n->ifa is still valid. We have no such
+   * ordering assumption for IF_CHANGE_LINK, so we test link state of the
+   * underlying iface instead of just rip_iface state.
+   */
+  if ((nbr->scope <= 0) || !rip_iface_link_up(n->ifa))
+    rip_remove_neighbor(p, n);
+}
+
+static void
+rip_bfd_notify(struct bfd_request *req)
+{
+  struct rip_neighbor *n = req->data;
+  struct rip_proto *p = n->ifa->rip;
 
-  switch( packet->heading.version ) {
-  case RIP_V1: DBG( "Rip1: " ); break;
-  case RIP_V2: DBG( "Rip2: " ); break;
-  default: BAD( "Unknown version" );
+  if (req->down)
+  {
+    TRACE(D_EVENTS, "BFD session down for nbr %I on %s",
+	  n->nbr->addr, n->ifa->iface->name);
+    rip_remove_neighbor(p, n);
   }
+}
+
+void
+rip_update_bfd(struct rip_proto *p, struct rip_neighbor *n)
+{
+  int use_bfd = n->ifa->cf->bfd && n->last_seen;
 
-  switch( packet->heading.command ) {
-  case RIPCMD_REQUEST: DBG( "Asked to send my routing table\n" ); 
-	  if (P_CF->honor == HO_NEVER)
-	    BAD( "They asked me to send routing table, but I was told not to do it" );
-
-	  if ((P_CF->honor == HO_NEIGHBOR) && (!neigh_find2( p, &whotoldme, iface, 0 )))
-	    BAD( "They asked me to send routing table, but he is not my neighbor" );
-    	  rip_sendto( p, whotoldme, port, HEAD(P->interfaces) ); /* no broadcast */
-          break;
-  case RIPCMD_RESPONSE: DBG( "*** Rtable from %I\n", whotoldme ); 
-          if (port != P_CF->port) {
-	    log( L_REMOTE "%s: %I send me routing info from port %d", p->name, whotoldme, port );
-	    return 1;
-	  }
-
-	  if (!(neighbor = neigh_find2( p, &whotoldme, iface, 0 )) || neighbor->scope == SCOPE_HOST) {
-	    log( L_REMOTE "%s: %I send me routing info but he is not my neighbor", p->name, whotoldme );
-	    return 0;
-	  }
-
-          for (i=0; i<num; i++) {
-	    struct rip_block *block = &packet->block[i];
-#ifndef IPV6
-	    /* Authentication is not defined for v6 */
-	    if (block->family == 0xffff) {
-	      if (i)
-		continue;	/* md5 tail has this family */
-	      if (rip_incoming_authentication(p, (void *) block, packet, num, whotoldme))
-		BAD( "Authentication failed" );
-	      authenticated = 1;
-	      continue;
-	    }
-#endif
-	    if ((!authenticated) && (P_CF->authtype != AT_NONE))
-	      BAD( "Packet is not authenticated and it should be" );
-	    ipa_ntoh( block->network );
-#ifndef IPV6
-	    ipa_ntoh( block->netmask );
-	    ipa_ntoh( block->nexthop );
-	    if (packet->heading.version == RIP_V1)	/* FIXME (nonurgent): switch to disable this? */
-	      block->netmask = ip4_class_mask(ipa_to_ip4(block->network));
-#endif
-	    process_block( p, block, whotoldme, iface );
-	  }
-          break;
-  case RIPCMD_TRACEON:
-  case RIPCMD_TRACEOFF: BAD( "I was asked for traceon/traceoff" );
-  case 5: BAD( "Some Sun extension around here" );
-  default: BAD( "Unknown command" );
+  if (use_bfd && !n->bfd_req)
+  {
+    /*
+     * For RIPv2, use the same address as rip_open_socket(). For RIPng, neighbor
+     * should contain an address from the same prefix, thus also link-local. It
+     * may cause problems if two link-local addresses are assigned to one iface.
+     */
+    ip_addr saddr = rip_is_v2(p) ? n->ifa->sk->saddr : n->nbr->ifa->ip;
+    n->bfd_req = bfd_request_session(p->p.pool, n->nbr->addr, saddr,
+				     n->nbr->iface, rip_bfd_notify, n);
   }
 
-  return 0;
+  if (!use_bfd && n->bfd_req)
+  {
+    rfree(n->bfd_req);
+    n->bfd_req = NULL;
+  }
 }
 
+
 /*
- * rip_rx - Receive hook: do basic checks and pass packet to rip_process_packet
+ *	RIP interfaces
  */
-static int
-rip_rx(sock *s, int size)
+
+static void
+rip_iface_start(struct rip_iface *ifa)
 {
-  struct rip_interface *i = s->data;
-  struct proto *p = i->proto;
-  struct iface *iface = NULL;
-  int num;
+  struct rip_proto *p = ifa->rip;
 
-  /* In non-listening mode, just ignore packet */
-  if (i->mode & IM_NOLISTEN)
-    return 1;
+  TRACE(D_EVENTS, "Starting interface %s", ifa->iface->name);
 
-#ifdef IPV6
-  if (! i->iface || s->lifindex != i->iface->index)
-    return 1;
+  ifa->next_regular = now + (random() % ifa->cf->update_time) + 1;
+  ifa->next_triggered = now;	/* Available immediately */
+  ifa->want_triggered = 1;	/* All routes in triggered update */
+  tm_start(ifa->timer, 1);	/* Or 100 ms */
+  ifa->up = 1;
 
-  iface = i->iface;
-#endif
+  if (!ifa->cf->passive)
+    rip_send_request(ifa->rip, ifa);
+}
 
-  if (i->check_ttl && (s->rcv_ttl < 255))
-  {
-    log( L_REMOTE "%s: Discarding packet with TTL %d (< 255) from %I on %s",
-	 p->name, s->rcv_ttl, s->faddr, i->iface->name);
-    return 1;
-  }
+static void
+rip_iface_stop(struct rip_iface *ifa)
+{
+  struct rip_proto *p = ifa->rip;
+  struct rip_neighbor *n;
 
+  TRACE(D_EVENTS, "Stopping interface %s", ifa->iface->name);
 
-  CHK_MAGIC;
-  DBG( "RIP: message came: %d bytes from %I via %s\n", size, s->faddr, i->iface ? i->iface->name : "(dummy)" );
-  size -= sizeof( struct rip_packet_heading );
-  if (size < 0) BAD( "Too small packet" );
-  if (size % sizeof( struct rip_block )) BAD( "Odd sized packet" );
-  num = size / sizeof( struct rip_block );
-  if (num>PACKET_MAX) BAD( "Too many blocks" );
+  rip_reset_tx_session(p, ifa);
 
-  if (ipa_equal(i->iface->addr->ip, s->faddr)) {
-    DBG("My own packet\n");
-    return 1;
-  }
+  WALK_LIST_FIRST(n, ifa->neigh_list)
+    rip_remove_neighbor(p, n);
 
-  rip_process_packet( p, (struct rip_packet *) s->rbuf, num, s->faddr, s->fport, iface );
-  return 1;
+  tm_stop(ifa->timer);
+  ifa->up = 0;
 }
 
-/*
- * Interface to BIRD core
- */
+static inline int
+rip_iface_link_up(struct rip_iface *ifa)
+{
+  return !ifa->cf->check_link || (ifa->iface->flags & IF_LINK_UP);
+}
 
 static void
-rip_dump_entry( struct rip_entry *e )
+rip_iface_update_state(struct rip_iface *ifa)
 {
-  debug( "%I told me %d/%d ago: to %I/%d go via %I, metric %d ", 
-  e->whotoldme, e->updated-now, e->changed-now, e->n.prefix, e->n.pxlen, e->nexthop, e->metric );
-  debug( "\n" );
-}
+  int up = ifa->sk && rip_iface_link_up(ifa);
 
-/**
- * rip_timer
- * @t: timer
- *
- * Broadcast routing tables periodically (using rip_tx) and kill
- * routes that are too old. RIP keeps a list of its own entries present
- * in the core table by a linked list (functions rip_rte_insert() and
- * rip_rte_delete() are responsible for that), it walks this list in the timer
- * and in case an entry is too old, it is discarded.
- */
+  if (up == ifa->up)
+    return;
+
+  if (up)
+    rip_iface_start(ifa);
+  else
+    rip_iface_stop(ifa);
+}
 
 static void
-rip_timer(timer *t)
+rip_iface_update_buffers(struct rip_iface *ifa)
 {
-  struct proto *p = t->data;
-  struct fib_node *e, *et;
+  if (!ifa->sk)
+    return;
 
-  CHK_MAGIC;
-  DBG( "RIP: tick tock\n" );
-  
-  WALK_LIST_DELSAFE( e, et, P->garbage ) {
-    rte *rte;
-    rte = SKIP_BACK( struct rte, u.rip.garbage, e );
+  uint rbsize = ifa->cf->rx_buffer ?: ifa->iface->mtu;
+  uint tbsize = ifa->cf->tx_length ?: ifa->iface->mtu;
+  rbsize = MAX(rbsize, tbsize);
 
-    CHK_MAGIC;
+  sk_set_rbsize(ifa->sk, rbsize);
+  sk_set_tbsize(ifa->sk, tbsize);
 
-    DBG( "Garbage: (%p)", rte ); rte_dump( rte );
+  uint headers = (rip_is_v2(ifa->rip) ? IP4_HEADER_LENGTH : IP6_HEADER_LENGTH) + UDP_HEADER_LENGTH;
+  ifa->tx_plen = tbsize - headers;
 
-    if (now - rte->lastmod > P_CF->timeout_time) {
-      TRACE(D_EVENTS, "entry is too old: %I", rte->net->n.prefix );
-      if (rte->u.rip.entry) {
-	rte->u.rip.entry->metric = P_CF->infinity;
-	rte->u.rip.metric = P_CF->infinity;
-      }
-    }
+  if (ifa->cf->auth_type == RIP_AUTH_CRYPTO)
+    ifa->tx_plen -= RIP_AUTH_TAIL_LENGTH;
+}
 
-    if (now - rte->lastmod > P_CF->garbage_time) {
-      TRACE(D_EVENTS, "entry is much too old: %I", rte->net->n.prefix );
-      rte_discard(p->table, rte);
-    }
-  }
+static inline void
+rip_iface_update_bfd(struct rip_iface *ifa)
+{
+  struct rip_proto *p = ifa->rip;
+  struct rip_neighbor *n;
+
+  WALK_LIST(n, ifa->neigh_list)
+    rip_update_bfd(p, n);
+}
+
+
+static void
+rip_iface_locked(struct object_lock *lock)
+{
+  struct rip_iface *ifa = lock->data;
+  struct rip_proto *p = ifa->rip;
 
-  DBG( "RIP: Broadcasting routing tables\n" );
+  if (!rip_open_socket(ifa))
   {
-    struct rip_interface *rif;
+    log(L_ERR "%s: Cannot open socket for %s", p->p.name, ifa->iface->name);
+    return;
+  }
 
-    if ( P_CF->period > 2 ) {		/* Bring some randomness into sending times */
-      if (! (P->tx_count % P_CF->period)) P->rnd_count = random_u32() % 2;
-    } else P->rnd_count = P->tx_count % P_CF->period;
+  rip_iface_update_buffers(ifa);
+  rip_iface_update_state(ifa);
+}
 
-    WALK_LIST( rif, P->interfaces ) {
-      struct iface *iface = rif->iface;
 
-      if (!iface) continue;
-      if (rif->mode & IM_QUIET) continue;
-      if (!(iface->flags & IF_UP)) continue;
-      rif->triggered = P->rnd_count;
+static struct rip_iface *
+rip_find_iface(struct rip_proto *p, struct iface *what)
+{
+  struct rip_iface *ifa;
 
-      rip_sendto( p, IPA_NONE, 0, rif );
-    }
-    P->tx_count++;
-    P->rnd_count--;
-  }
+  WALK_LIST(ifa, p->iface_list)
+    if (ifa->iface == what)
+      return ifa;
 
-  DBG( "RIP: tick tock done\n" );
+  return NULL;
 }
 
-/*
- * rip_start - initialize instance of rip
- */
-static int
-rip_start(struct proto *p)
+static void
+rip_add_iface(struct rip_proto *p, struct iface *iface, struct rip_iface_config *ic)
 {
-  struct rip_interface *rif;
-  DBG( "RIP: starting instance...\n" );
-
-  ASSERT(sizeof(struct rip_packet_heading) == 4);
-  ASSERT(sizeof(struct rip_block) == 20);
-  ASSERT(sizeof(struct rip_block_auth) == 20);
-
-#ifdef LOCAL_DEBUG
-  P->magic = RIP_MAGIC;
-#endif
-  fib_init( &P->rtable, p->pool, sizeof( struct rip_entry ), 0, NULL );
-  init_list( &P->connections );
-  init_list( &P->garbage );
-  init_list( &P->interfaces );
-  P->timer = tm_new( p->pool );
-  P->timer->data = p;
-  P->timer->recurrent = 1;
-  P->timer->hook = rip_timer;
-  tm_start( P->timer, 2 );
-  rif = new_iface(p, NULL, 0, NULL);	/* Initialize dummy interface */
-  add_head( &P->interfaces, NODE rif );
-  CHK_MAGIC;
-
-  DBG( "RIP: ...done\n");
-  return PS_UP;
+  struct rip_iface *ifa;
+
+  TRACE(D_EVENTS, "Adding interface %s", iface->name);
+
+  ifa = mb_allocz(p->p.pool, sizeof(struct rip_iface));
+  ifa->rip = p;
+  ifa->iface = iface;
+  ifa->cf = ic;
+
+  if (ipa_nonzero(ic->address))
+    ifa->addr = ic->address;
+  else if (ic->mode == RIP_IM_MULTICAST)
+    ifa->addr = rip_is_v2(p) ? IP4_RIP_ROUTERS : IP6_RIP_ROUTERS;
+  else /* Broadcast */
+    ifa->addr = iface->addr->brd;
+
+  init_list(&ifa->neigh_list);
+
+  add_tail(&p->iface_list, NODE ifa);
+
+  ifa->timer = tm_new_set(p->p.pool, rip_iface_timer, ifa, 0, 0);
+
+  struct object_lock *lock = olock_new(p->p.pool);
+  lock->type = OBJLOCK_UDP;
+  lock->port = ic->port;
+  lock->iface = iface;
+  lock->data = ifa;
+  lock->hook = rip_iface_locked;
+  ifa->lock = lock;
+
+  olock_acquire(lock);
 }
 
 static void
-rip_dump(struct proto *p)
+rip_remove_iface(struct rip_proto *p, struct rip_iface *ifa)
 {
-  int i;
-  node *w;
-  struct rip_interface *rif;
+  rip_iface_stop(ifa);
 
-  CHK_MAGIC;
-  WALK_LIST( w, P->connections ) {
-    struct rip_connection *n = (void *) w;
-    debug( "RIP: connection #%d: %I\n", n->num, n->addr );
-  }
-  i = 0;
-  FIB_WALK( &P->rtable, e ) {
-    debug( "RIP: entry #%d: ", i++ );
-    rip_dump_entry( (struct rip_entry *)e );
-  } FIB_WALK_END;
-  i = 0;
-  WALK_LIST( rif, P->interfaces ) {
-    debug( "RIP: interface #%d: %s, %I, busy = %x\n", i++, rif->iface?rif->iface->name:"(dummy)", rif->sock->daddr, rif->busy );
-  }
+  TRACE(D_EVENTS, "Removing interface %s", ifa->iface->name);
+
+  rem_node(NODE ifa);
+
+  rfree(ifa->sk);
+  rfree(ifa->lock);
+  rfree(ifa->timer);
+
+  mb_free(ifa);
+}
+
+static int
+rip_reconfigure_iface(struct rip_proto *p, struct rip_iface *ifa, struct rip_iface_config *new)
+{
+  struct rip_iface_config *old = ifa->cf;
+
+  /* Change of these options would require to reset the iface socket */
+  if ((new->mode != old->mode) ||
+      (new->port != old->port) ||
+      (new->tx_tos != old->tx_tos) ||
+      (new->tx_priority != old->tx_priority) ||
+      (new->ttl_security != old->ttl_security))
+    return 0;
+
+  TRACE(D_EVENTS, "Reconfiguring interface %s", ifa->iface->name);
+
+  ifa->cf = new;
+
+  if (ifa->next_regular > (now + new->update_time))
+    ifa->next_regular = now + (random() % new->update_time) + 1;
+
+  if ((new->tx_length != old->tx_length) || (new->rx_buffer != old->rx_buffer))
+    rip_iface_update_buffers(ifa);
+
+  if (new->check_link != old->check_link)
+    rip_iface_update_state(ifa);
+
+  if (new->bfd != old->bfd)
+    rip_iface_update_bfd(ifa);
+
+  if (ifa->up)
+    rip_iface_kick_timer(ifa);
+
+  return 1;
 }
 
 static void
-rip_get_route_info(rte *rte, byte *buf, ea_list *attrs)
+rip_reconfigure_ifaces(struct rip_proto *p, struct rip_config *cf)
 {
-  eattr *metric = ea_find(attrs, EA_RIP_METRIC);
-  eattr *tag = ea_find(attrs, EA_RIP_TAG);
+  struct iface *iface;
+
+  WALK_LIST(iface, iface_list)
+  {
+    if (! (iface->flags & IF_UP))
+      continue;
+
+    struct rip_iface *ifa = rip_find_iface(p, iface);
+    struct rip_iface_config *ic = (void *) iface_patt_find(&cf->patt_list, iface, NULL);
 
-  buf += bsprintf(buf, " (%d/%d)", rte->pref, metric ? metric->u.data : 0);
-  if (tag && tag->u.data)
-    bsprintf(buf, " t%04x", tag->u.data);
+    if (ifa && ic)
+    {
+      if (rip_reconfigure_iface(p, ifa, ic))
+	continue;
+
+      /* Hard restart */
+      log(L_INFO "%s: Restarting interface %s", p->p.name, ifa->iface->name);
+      rip_remove_iface(p, ifa);
+      rip_add_iface(p, iface, ic);
+    }
+
+    if (ifa && !ic)
+      rip_remove_iface(p, ifa);
+
+    if (!ifa && ic)
+      rip_add_iface(p, iface, ic);
+  }
 }
 
 static void
-kill_iface(struct rip_interface *i)
+rip_if_notify(struct proto *P, unsigned flags, struct iface *iface)
 {
-  DBG( "RIP: Interface %s disappeared\n", i->iface->name);
-  rfree(i->sock);
-  mb_free(i);
+  struct rip_proto *p = (void *) P;
+  struct rip_config *cf = (void *) P->cf;
+
+  if (iface->flags & IF_IGNORE)
+    return;
+
+  if (flags & IF_CHANGE_UP)
+  {
+    struct rip_iface_config *ic = (void *) iface_patt_find(&cf->patt_list, iface, NULL);
+
+    if (ic)
+      rip_add_iface(p, iface, ic);
+
+    return;
+  }
+
+  struct rip_iface *ifa = rip_find_iface(p, iface);
+
+  if (!ifa)
+    return;
+
+  if (flags & IF_CHANGE_DOWN)
+  {
+    rip_remove_iface(p, ifa);
+    return;
+  }
+
+  if (flags & IF_CHANGE_MTU)
+    rip_iface_update_buffers(ifa);
+
+  if (flags & IF_CHANGE_LINK)
+    rip_iface_update_state(ifa);
 }
 
+
+/*
+ *	RIP timer events
+ */
+
 /**
- * new_iface
- * @p: myself
- * @new: interface to be created or %NULL if we are creating a magic
- * socket. The magic socket is used for listening and also for
- * sending requested responses.
- * @flags: interface flags
- * @patt: pattern this interface matched, used for access to config options
+ * rip_timer - RIP main timer hook
+ * @t: timer
  *
- * Create an interface structure and start listening on the interface.
+ * The RIP main timer is responsible for routing table maintenance. Invalid or
+ * expired routes (&rip_rte) are removed and garbage collection of stale routing
+ * table entries (&rip_entry) is done. Changes are propagated to core tables,
+ * route reload is also done here. Note that garbage collection uses a maximal
+ * GC time, while interfaces maintain an illusion of per-interface GC times in
+ * rip_send_response().
+ *
+ * Keeping incoming routes and the selected outgoing route are two independent
+ * functions, therefore after garbage collection some entries now considered
+ * invalid (RIP_ENTRY_DUMMY) still may have non-empty list of incoming routes,
+ * while some valid entries (representing an outgoing route) may have that list
+ * empty.
+ *
+ * The main timer is not scheduled periodically but it uses the time of the
+ * current next event and the minimal interval of any possible event to compute
+ * the time of the next run.
  */
-static struct rip_interface *
-new_iface(struct proto *p, struct iface *new, unsigned long flags, struct iface_patt *patt )
+static void
+rip_timer(timer *t)
 {
-  struct rip_interface *rif;
-  struct rip_patt *PATT = (struct rip_patt *) patt;
-
-  rif = mb_allocz(p->pool, sizeof( struct rip_interface ));
-  rif->iface = new;
-  rif->proto = p;
-  rif->busy = NULL;
-  if (PATT) {
-    rif->mode = PATT->mode;
-    rif->metric = PATT->metric;
-    rif->multicast = (!(PATT->mode & IM_BROADCAST)) && (flags & IF_MULTICAST);
-    rif->check_ttl = (PATT->ttl_security == 1);
-  }
-  /* lookup multicasts over unnumbered links - no: rip is not defined over unnumbered links */
-
-  if (rif->multicast)
-    DBG( "Doing multicasts!\n" );
-
-  rif->sock = sk_new( p->pool );
-  rif->sock->type = SK_UDP;
-  rif->sock->sport = P_CF->port;
-  rif->sock->rx_hook = rip_rx;
-  rif->sock->data = rif;
-  rif->sock->rbsize = 10240;
-  rif->sock->iface = new;		/* Automagically works for dummy interface */
-  rif->sock->tbuf = mb_alloc( p->pool, sizeof( struct rip_packet ));
-  rif->sock->tx_hook = rip_tx;
-  rif->sock->err_hook = rip_tx_err;
-  rif->sock->daddr = IPA_NONE;
-  rif->sock->dport = P_CF->port;
-  if (new)
+  struct rip_proto *p = t->data;
+  struct rip_config *cf = (void *) (p->p.cf);
+  struct rip_iface *ifa;
+  struct rip_neighbor *n, *nn;
+  struct fib_iterator fit;
+  bird_clock_t next = now + MIN(cf->min_timeout_time, cf->max_garbage_time);
+  bird_clock_t expires = 0;
+
+  TRACE(D_EVENTS, "Main timer fired");
+
+  FIB_ITERATE_INIT(&fit, &p->rtable);
+
+  loop:
+  FIB_ITERATE_START(&p->rtable, &fit, node)
+  {
+    struct rip_entry *en = (struct rip_entry *) node;
+    struct rip_rte *rt, **rp;
+    int changed = 0;
+
+    /* Checking received routes for timeout and for dead neighbors */
+    for (rp = &en->routes; rt = *rp; /* rp = &rt->next */)
     {
-      rif->sock->tos = PATT->tx_tos;
-      rif->sock->priority = PATT->tx_priority;
-      rif->sock->ttl = PATT->ttl_security ? 255 : 1;
-      rif->sock->flags = SKF_LADDR_RX | (rif->check_ttl ? SKF_TTL_RX : 0);
-    }
+      if (!rip_valid_rte(rt) || (rt->expires <= now))
+      {
+	rip_remove_rte(p, rp);
+	changed = 1;
+	continue;
+      }
 
-  if (new) {
-    if (new->addr->flags & IA_PEER)
-      log( L_WARN "%s: rip is not defined over unnumbered links", p->name );
-    if (rif->multicast) {
-#ifndef IPV6
-      rif->sock->daddr = ipa_from_u32(0xe0000009);
-#else
-      rif->sock->daddr = IP6_RIP_ROUTERS;
-#endif
-    } else {
-      rif->sock->daddr = new->addr->brd;
+      next = MIN(next, rt->expires);
+      rp = &rt->next;
     }
-  }
 
-  if (!ipa_nonzero(rif->sock->daddr)) {
-    if (rif->iface)
-      log( L_WARN "%s: interface %s is too strange for me", p->name, rif->iface->name );
-  } else {
+    /* Propagating eventual change */
+    if (changed || p->rt_reload)
+    {
+      /*
+       * We have to restart the iteration because there may be a cascade of
+       * synchronous events rip_announce_rte() -> nest table change ->
+       * rip_rt_notify() -> p->rtable change, invalidating hidden variables.
+       */
+
+      FIB_ITERATE_PUT_NEXT(&fit, &p->rtable, node);
+      rip_announce_rte(p, en);
+      goto loop;
+    }
 
-    if (sk_open(rif->sock) < 0)
-      goto err;
+    /* Checking stale entries for garbage collection timeout */
+    if (en->valid == RIP_ENTRY_STALE)
+    {
+      expires = en->changed + cf->max_garbage_time;
 
-    if (rif->multicast)
+      if (expires <= now)
       {
-	if (sk_setup_multicast(rif->sock) < 0)
-	  goto err;
-	if (sk_join_group(rif->sock, rif->sock->daddr) < 0)
-	  goto err;
+	// TRACE(D_EVENTS, "entry is too old: %I/%d", en->n.prefix, en->n.pxlen);
+	en->valid = 0;
       }
-    else
+      else
+	next = MIN(next, expires);
+    }
+
+    /* Remove empty nodes */
+    if (!en->valid && !en->routes)
+    {
+      FIB_ITERATE_PUT(&fit, node);
+      fib_delete(&p->rtable, node);
+      goto loop;
+    }
+  }
+  FIB_ITERATE_END(node);
+
+  p->rt_reload = 0;
+
+  /* Handling neighbor expiration */
+  WALK_LIST(ifa, p->iface_list)
+    WALK_LIST_DELSAFE(n, nn, ifa->neigh_list)
+      if (n->last_seen)
       {
-	if (sk_setup_broadcast(rif->sock) < 0)
-	  goto err;
+	expires = n->last_seen + n->ifa->cf->timeout_time;
+
+	if (expires <= now)
+	  rip_remove_neighbor(p, n);
+	else
+	  next = MIN(next, expires);
       }
-  }
 
-  TRACE(D_EVENTS, "Listening on %s, port %d, mode %s (%I)", rif->iface ? rif->iface->name : "(dummy)", P_CF->port, rif->multicast ? "multicast" : "broadcast", rif->sock->daddr );
-  
-  return rif;
+  tm_start(p->timer, MAX(next - now, 1));
+}
+
+static inline void
+rip_kick_timer(struct rip_proto *p)
+{
+  if (p->timer->expires > (now + 1))
+    tm_start(p->timer, 1);	/* Or 100 ms */
+}
 
- err:
-  sk_log_error(rif->sock, p->name);
-  log(L_ERR "%s: Cannot open socket for %s", p->name, rif->iface ? rif->iface->name : "(dummy)" );
-  if (rif->iface) {
-    rfree(rif->sock);
-    mb_free(rif);
-    return NULL;
+/**
+ * rip_iface_timer - RIP interface timer hook
+ * @t: timer
+ *
+ * RIP interface timers are responsible for scheduling both regular and
+ * triggered updates. Fixed, delay-independent period is used for regular
+ * updates, while minimal separating interval is enforced for triggered updates.
+ * The function also ensures that a new update is not started when the old one
+ * is still running.
+ */
+static void
+rip_iface_timer(timer *t)
+{
+  struct rip_iface *ifa = t->data;
+  struct rip_proto *p = ifa->rip;
+  bird_clock_t period = ifa->cf->update_time;
+
+  if (ifa->cf->passive)
+    return;
+
+  TRACE(D_EVENTS, "Interface timer fired for %s", ifa->iface->name);
+
+  if (ifa->tx_active)
+  {
+    if (now < (ifa->next_regular + period))
+      { tm_start(ifa->timer, 1); return; }
+
+    /* We are too late, reset is done by rip_send_table() */
+    log(L_WARN "%s: Too slow update on %s, resetting", p->p.name, ifa->iface->name);
   }
-  /* On dummy, we just return non-working socket, so that user gets error every time anyone requests table */
-  return rif;
+
+  if (now >= ifa->next_regular)
+  {
+    /* Send regular update, set timer for next period (or following one if necessay) */
+    TRACE(D_EVENTS, "Sending regular updates for %s", ifa->iface->name);
+    rip_send_table(p, ifa, ifa->addr, 0);
+    ifa->next_regular += period * (1 + ((now - ifa->next_regular) / period));
+    ifa->want_triggered = 0;
+    p->triggered = 0;
+  }
+  else if (ifa->want_triggered && (now >= ifa->next_triggered))
+  {
+    /* Send triggered update, enforce interval between triggered updates */
+    TRACE(D_EVENTS, "Sending triggered updates for %s", ifa->iface->name);
+    rip_send_table(p, ifa, ifa->addr, ifa->want_triggered);
+    ifa->next_triggered = now + MIN(5, period / 2 + 1);
+    ifa->want_triggered = 0;
+    p->triggered = 0;
+  }
+
+  tm_start(ifa->timer, ifa->want_triggered ? 1 : (ifa->next_regular - now));
 }
 
-static void
-rip_real_if_add(struct object_lock *lock)
+static inline void
+rip_iface_kick_timer(struct rip_iface *ifa)
 {
-  struct iface *iface = lock->iface;
-  struct proto *p = lock->data;
-  struct rip_interface *rif;
-  struct iface_patt *k = iface_patt_find(&P_CF->iface_list, iface, iface->addr);
-
-  if (!k)
-    bug("This can not happen! It existed few seconds ago!" );
-  DBG("adding interface %s\n", iface->name );
-  rif = new_iface(p, iface, iface->flags, k);
-  if (rif) {
-    add_head( &P->interfaces, NODE rif );
-    DBG("Adding object lock of %p for %p\n", lock, rif);
-    rif->lock = lock;
-  } else { rfree(lock); }
+  if (ifa->timer->expires > (now + 1))
+    tm_start(ifa->timer, 1);	/* Or 100 ms */
 }
 
 static void
-rip_if_notify(struct proto *p, unsigned c, struct iface *iface)
+rip_trigger_update(struct rip_proto *p)
 {
-  DBG( "RIP: if notify\n" );
-  if (iface->flags & IF_IGNORE)
+  if (p->triggered)
     return;
-  if (c & IF_CHANGE_DOWN) {
-    struct rip_interface *i;
-    i = find_interface(p, iface);
-    if (i) {
-      rem_node(NODE i);
-      rfree(i->lock);
-      kill_iface(i);
-    }
-  }
-  if (c & IF_CHANGE_UP) {
-    struct iface_patt *k = iface_patt_find(&P_CF->iface_list, iface, iface->addr);
-    struct object_lock *lock;
-    struct rip_patt *PATT = (struct rip_patt *) k;
-
-    if (!k) return; /* We are not interested in this interface */
-
-    lock = olock_new( p->pool );
-    if (!(PATT->mode & IM_BROADCAST) && (iface->flags & IF_MULTICAST))
-#ifndef IPV6
-      lock->addr = ipa_from_u32(0xe0000009);
-#else
-      lock->addr = IP6_RIP_ROUTERS;
-#endif
-    else
-      lock->addr = iface->addr->brd;
-    lock->port = P_CF->port;
-    lock->iface = iface;
-    lock->hook = rip_real_if_add;
-    lock->data = p;
-    lock->type = OBJLOCK_UDP;
-    olock_acquire(lock);
+
+  struct rip_iface *ifa;
+  WALK_LIST(ifa, p->iface_list)
+  {
+    /* Interface not active */
+    if (! ifa->up)
+      continue;
+
+    /* Already scheduled */
+    if (ifa->want_triggered)
+      continue;
+
+    TRACE(D_EVENTS, "Scheduling triggered updates for %s", ifa->iface->name);
+    ifa->want_triggered = now;
+    rip_iface_kick_timer(ifa);
   }
+
+  p->triggered = 1;
 }
 
+
+/*
+ *	RIP protocol glue
+ */
+
 static struct ea_list *
-rip_gen_attrs(struct linpool *pool, int metric, u16 tag)
+rip_prepare_attrs(struct linpool *pool, ea_list *next, u8 metric, u16 tag)
 {
-  struct ea_list *l = lp_alloc(pool, sizeof(struct ea_list) + 2*sizeof(eattr));
+  struct ea_list *l = lp_alloc(pool, sizeof(struct ea_list) + 2 * sizeof(eattr));
 
-  l->next = NULL;
+  l->next = next;
   l->flags = EALF_SORTED;
   l->count = 2;
-  l->attrs[0].id = EA_RIP_TAG;
+
+  l->attrs[0].id = EA_RIP_METRIC;
   l->attrs[0].flags = 0;
   l->attrs[0].type = EAF_TYPE_INT | EAF_TEMP;
-  l->attrs[0].u.data = tag;
-  l->attrs[1].id = EA_RIP_METRIC;
+  l->attrs[0].u.data = metric;
+
+  l->attrs[1].id = EA_RIP_TAG;
   l->attrs[1].flags = 0;
   l->attrs[1].type = EAF_TYPE_INT | EAF_TEMP;
-  l->attrs[1].u.data = metric;
+  l->attrs[1].u.data = tag;
+
   return l;
 }
 
 static int
-rip_import_control(struct proto *p, struct rte **rt, struct ea_list **attrs, struct linpool *pool)
+rip_import_control(struct proto *P, struct rte **rt, struct ea_list **attrs, struct linpool *pool)
 {
-  if ((*rt)->attrs->src->proto == p)	/* My own must not be touched */
-    return 1;
+  /* Prepare attributes with initial values */
+  if ((*rt)->attrs->source != RTS_RIP)
+    *attrs = rip_prepare_attrs(pool, *attrs, 1, 0);
 
-  if ((*rt)->attrs->source != RTS_RIP) {
-    struct ea_list *new = rip_gen_attrs(pool, 1, 0);
-    new->next = *attrs;
-    *attrs = new;
-  }
   return 0;
 }
 
+static int
+rip_reload_routes(struct proto *P)
+{
+  struct rip_proto *p = (struct rip_proto *) P;
+
+  if (p->rt_reload)
+    return 1;
+
+  TRACE(D_EVENTS, "Scheduling route reload");
+  p->rt_reload = 1;
+  rip_kick_timer(p);
+
+  return 1;
+}
+
 static struct ea_list *
 rip_make_tmp_attrs(struct rte *rt, struct linpool *pool)
 {
-  return rip_gen_attrs(pool, rt->u.rip.metric, rt->u.rip.tag);
+  return rip_prepare_attrs(pool, NULL, rt->u.rip.metric, rt->u.rip.tag);
 }
 
-static void 
+static void
 rip_store_tmp_attrs(struct rte *rt, struct ea_list *attrs)
 {
-  rt->u.rip.tag = ea_get_int(attrs, EA_RIP_TAG, 0);
   rt->u.rip.metric = ea_get_int(attrs, EA_RIP_METRIC, 1);
+  rt->u.rip.tag = ea_get_int(attrs, EA_RIP_TAG, 0);
 }
 
-/*
- * rip_rt_notify - core tells us about new route (possibly our
- * own), so store it into our data structures. 
- */
-static void
-rip_rt_notify(struct proto *p, struct rtable *table UNUSED, struct network *net,
-	      struct rte *new, struct rte *old UNUSED, struct ea_list *attrs)
+static int
+rip_rte_better(struct rte *new, struct rte *old)
 {
-  CHK_MAGIC;
-  struct rip_entry *e;
-
-  e = fib_find( &P->rtable, &net->n.prefix, net->n.pxlen );
-  if (e)
-    fib_delete( &P->rtable, e );
-
-  if (new) {
-    e = fib_get( &P->rtable, &net->n.prefix, net->n.pxlen );
-
-    e->nexthop = new->attrs->gw;
-    e->metric = 0;
-    e->whotoldme = IPA_NONE;
-    new->u.rip.entry = e;
-
-    e->tag = ea_get_int(attrs, EA_RIP_TAG, 0);
-    e->metric = ea_get_int(attrs, EA_RIP_METRIC, 1);
-    if (e->metric > P_CF->infinity)
-      e->metric = P_CF->infinity;
-
-    if (new->attrs->src->proto == p)
-      e->whotoldme = new->attrs->from;
-
-    if (!e->metric)	/* That's okay: this way user can set his own value for external
-			   routes in rip. */
-      e->metric = 5;
-    e->updated = e->changed = now;
-    e->flags = 0;
-  }
+  return new->u.rip.metric < old->u.rip.metric;
 }
 
 static int
 rip_rte_same(struct rte *new, struct rte *old)
 {
-  /* new->attrs == old->attrs always */
-  return new->u.rip.metric == old->u.rip.metric;
+  return ((new->u.rip.metric == old->u.rip.metric) &&
+	  (new->u.rip.tag == old->u.rip.tag) &&
+	  (new->u.rip.from == old->u.rip.from));
 }
 
 
+static struct proto *
+rip_init(struct proto_config *cfg)
+{
+  struct proto *P = proto_new(cfg, sizeof(struct rip_proto));
+
+  P->accept_ra_types = RA_OPTIMAL;
+  P->if_notify = rip_if_notify;
+  P->rt_notify = rip_rt_notify;
+  P->neigh_notify = rip_neigh_notify;
+  P->import_control = rip_import_control;
+  P->reload_routes = rip_reload_routes;
+  P->make_tmp_attrs = rip_make_tmp_attrs;
+  P->store_tmp_attrs = rip_store_tmp_attrs;
+  P->rte_better = rip_rte_better;
+  P->rte_same = rip_rte_same;
+
+  return P;
+}
+
 static int
-rip_rte_better(struct rte *new, struct rte *old)
+rip_start(struct proto *P)
 {
-  struct proto *p = new->attrs->src->proto;
+  struct rip_proto *p = (void *) P;
+  struct rip_config *cf = (void *) (P->cf);
 
-  if (ipa_equal(old->attrs->from, new->attrs->from))
-    return 1;
+  init_list(&p->iface_list);
+  fib_init(&p->rtable, P->pool, sizeof(struct rip_entry), 0, rip_init_entry);
+  p->rte_slab = sl_new(P->pool, sizeof(struct rip_rte));
+  p->timer = tm_new_set(P->pool, rip_timer, p, 0, 0);
 
-  if (old->u.rip.metric < new->u.rip.metric)
-    return 0;
+  p->ecmp = cf->ecmp;
+  p->infinity = cf->infinity;
+  p->triggered = 0;
 
-  if (old->u.rip.metric > new->u.rip.metric)
-    return 1;
+  p->log_pkt_tbf = (struct tbf){ .rate = 1, .burst = 5 };
+  p->log_rte_tbf = (struct tbf){ .rate = 4, .burst = 20 };
 
-  if (old->attrs->src->proto == new->attrs->src->proto)		/* This does not make much sense for different protocols */
-    if ((old->u.rip.metric == new->u.rip.metric) &&
-	((now - old->lastmod) > (P_CF->timeout_time / 2)))
-      return 1;
+  tm_start(p->timer, MIN(cf->min_timeout_time, cf->max_garbage_time));
 
-  return 0;
+  return PS_UP;
 }
 
-/*
- * rip_rte_insert - we maintain linked list of "our" entries in main
- * routing table, so that we can timeout them correctly. rip_timer()
- * walks the list.
- */
-static void
-rip_rte_insert(net *net UNUSED, rte *rte)
+static int
+rip_reconfigure(struct proto *P, struct proto_config *c)
 {
-  struct proto *p = rte->attrs->src->proto;
-  CHK_MAGIC;
-  DBG( "rip_rte_insert: %p\n", rte );
-  add_head( &P->garbage, &rte->u.rip.garbage );
-}
+  struct rip_proto *p = (void *) P;
+  struct rip_config *new = (void *) c;
+  // struct rip_config *old = (void *) (P->cf);
 
-/*
- * rip_rte_remove - link list maintenance
- */
-static void
-rip_rte_remove(net *net UNUSED, rte *rte)
-{
-#ifdef LOCAL_DEBUG
-  struct proto *p = rte->attrs->src->proto;
-  CHK_MAGIC;
-  DBG( "rip_rte_remove: %p\n", rte );
-#endif
-  rem_node( &rte->u.rip.garbage );
-}
+  if (new->infinity != p->infinity)
+    return 0;
 
-static struct proto *
-rip_init(struct proto_config *cfg)
-{
-  struct proto *p = proto_new(cfg, sizeof(struct rip_proto));
-
-  p->accept_ra_types = RA_OPTIMAL;
-  p->if_notify = rip_if_notify;
-  p->rt_notify = rip_rt_notify;
-  p->import_control = rip_import_control;
-  p->make_tmp_attrs = rip_make_tmp_attrs;
-  p->store_tmp_attrs = rip_store_tmp_attrs;
-  p->rte_better = rip_rte_better;
-  p->rte_same = rip_rte_same;
-  p->rte_insert = rip_rte_insert;
-  p->rte_remove = rip_rte_remove;
-
-  return p;
+  TRACE(D_EVENTS, "Reconfiguring");
+
+  p->p.cf = c;
+  p->ecmp = new->ecmp;
+  rip_reconfigure_ifaces(p, new);
+
+  p->rt_reload = 1;
+  rip_kick_timer(p);
+
+  return 1;
 }
 
-void
-rip_init_config(struct rip_proto_config *c)
+static void
+rip_get_route_info(rte *rte, byte *buf, ea_list *attrs)
 {
-  init_list(&c->iface_list);
-  c->infinity	= 16;
-  c->port	= RIP_PORT;
-  c->period	= 30;
-  c->garbage_time = 120+180;
-  c->timeout_time = 120;
-  c->passwords	= NULL;
-  c->authtype	= AT_NONE;
+  buf += bsprintf(buf, " (%d/%d)", rte->pref, rte->u.rip.metric);
+
+  if (rte->u.rip.tag)
+    bsprintf(buf, " [%04x]", rte->u.rip.tag);
 }
 
 static int
 rip_get_attr(eattr *a, byte *buf, int buflen UNUSED)
 {
-  switch (a->id) {
-  case EA_RIP_METRIC: bsprintf( buf, "metric: %d", a->u.data ); return GA_FULL;
-  case EA_RIP_TAG:    bsprintf( buf, "tag: %d", a->u.data );    return GA_FULL;
-  default: return GA_UNKNOWN;
+  switch (a->id)
+  {
+  case EA_RIP_METRIC:
+    bsprintf(buf, "metric: %d", a->u.data);
+    return GA_FULL;
+
+  case EA_RIP_TAG:
+    bsprintf(buf, "tag: %04x", a->u.data);
+    return GA_FULL;
+
+  default:
+    return GA_UNKNOWN;
   }
 }
 
-static int
-rip_pat_compare(struct rip_patt *a, struct rip_patt *b)
+void
+rip_show_interfaces(struct proto *P, char *iff)
 {
-  return ((a->metric == b->metric) &&
-	  (a->mode == b->mode) &&
-	  (a->tx_tos == b->tx_tos) &&
-	  (a->tx_priority == b->tx_priority));
+  struct rip_proto *p = (void *) P;
+  struct rip_iface *ifa = NULL;
+  struct rip_neighbor *n = NULL;
+
+  if (p->p.proto_state != PS_UP)
+  {
+    cli_msg(-1021, "%s: is not up", p->p.name);
+    cli_msg(0, "");
+    return;
+  }
+
+  cli_msg(-1021, "%s:", p->p.name);
+  cli_msg(-1021, "%-10s %-6s %6s %6s %6s",
+	  "Interface", "State", "Metric", "Nbrs", "Timer");
+
+  WALK_LIST(ifa, p->iface_list)
+  {
+    if (iff && !patmatch(iff, ifa->iface->name))
+      continue;
+
+    int nbrs = 0;
+    WALK_LIST(n, ifa->neigh_list)
+      if (n->last_seen)
+	nbrs++;
+
+    int timer = MAX(ifa->next_regular - now, 0);
+    cli_msg(-1021, "%-10s %-6s %6u %6u %6u",
+	    ifa->iface->name, (ifa->up ? "Up" : "Down"), ifa->cf->metric, nbrs, timer);
+  }
+
+  cli_msg(0, "");
 }
 
-static int
-rip_reconfigure(struct proto *p, struct proto_config *c)
+void
+rip_show_neighbors(struct proto *P, char *iff)
 {
-  struct rip_proto_config *new = (struct rip_proto_config *) c;
-  int generic = sizeof(struct proto_config) + sizeof(list) /* + sizeof(struct password_item *) */;
+  struct rip_proto *p = (void *) P;
+  struct rip_iface *ifa = NULL;
+  struct rip_neighbor *n = NULL;
 
-  if (!iface_patts_equal(&P_CF->iface_list, &new->iface_list, (void *) rip_pat_compare))
-    return 0;
-  return !memcmp(((byte *) P_CF) + generic,
-                 ((byte *) new) + generic,
-                 sizeof(struct rip_proto_config) - generic);
+  if (p->p.proto_state != PS_UP)
+  {
+    cli_msg(-1022, "%s: is not up", p->p.name);
+    cli_msg(0, "");
+    return;
+  }
+
+  cli_msg(-1022, "%s:", p->p.name);
+  cli_msg(-1022, "%-25s %-10s %6s %6s %6s",
+	  "IP address", "Interface", "Metric", "Routes", "Seen");
+
+  WALK_LIST(ifa, p->iface_list)
+  {
+    if (iff && !patmatch(iff, ifa->iface->name))
+      continue;
+
+    WALK_LIST(n, ifa->neigh_list)
+    {
+      if (!n->last_seen)
+	continue;
+
+      int timer = now - n->last_seen;
+      cli_msg(-1022, "%-25I %-10s %6u %6u %6u",
+	      n->nbr->addr, ifa->iface->name, ifa->cf->metric, n->uc, timer);
+    }
+  }
+
+  cli_msg(0, "");
 }
 
 static void
-rip_copy_config(struct proto_config *dest, struct proto_config *src)
+rip_dump(struct proto *P)
 {
-  /* Shallow copy of everything */
-  proto_copy_rest(dest, src, sizeof(struct rip_proto_config));
+  struct rip_proto *p = (struct rip_proto *) P;
+  struct rip_iface *ifa;
+  int i;
 
-  /* We clean up iface_list, ifaces are non-sharable */
-  init_list(&((struct rip_proto_config *) dest)->iface_list);
+  i = 0;
+  FIB_WALK(&p->rtable, e)
+  {
+    struct rip_entry *en = (struct rip_entry *) e;
+    debug("RIP: entry #%d: %I/%d via %I dev %s valid %d metric %d age %d s\n",
+	  i++, en->n.prefix, en->n.pxlen, en->next_hop, en->iface->name,
+	  en->valid, en->metric, now - en->changed);
+  }
+  FIB_WALK_END;
 
-  /* Copy of passwords is OK, it just will be replaced in dest when used */
+  i = 0;
+  WALK_LIST(ifa, p->iface_list)
+  {
+    debug("RIP: interface #%d: %s, %I, up = %d, busy = %d\n",
+	  i++, ifa->iface->name, ifa->sk ? ifa->sk->daddr : IPA_NONE,
+	  ifa->up, ifa->tx_active);
+  }
 }
 
 
@@ -1050,12 +1278,11 @@ struct protocol proto_rip = {
   .template =		"rip%d",
   .attr_class =		EAP_RIP,
   .preference =		DEF_PREF_RIP,
-  .config_size =	sizeof(struct rip_proto_config),
+  .config_size =	sizeof(struct rip_config),
   .init =		rip_init,
   .dump =		rip_dump,
   .start =		rip_start,
   .reconfigure =	rip_reconfigure,
-  .copy_config =	rip_copy_config,
   .get_route_info =	rip_get_route_info,
   .get_attr =		rip_get_attr
 };
diff --git a/proto/rip/rip.h b/proto/rip/rip.h
index 2a327260..f245e612 100644
--- a/proto/rip/rip.h
+++ b/proto/rip/rip.h
@@ -1,185 +1,227 @@
 /*
- * Structures for RIP protocol
+ *	BIRD -- Routing Information Protocol (RIP)
  *
-   FIXME: in V6, they insert additional entry whenever next hop differs. Such entry is identified by 0xff in metric.
+ *	(c) 1998--1999 Pavel Machek <pavel@ucw.cz>
+ *	(c) 2004--2013 Ondrej Filip <feela@network.cz>
+ *	(c) 2009--2015 Ondrej Zajicek <santiago@crfreenet.org>
+ *	(c) 2009--2015 CZ.NIC z.s.p.o.
+ *
+ *	Can be freely distributed and used under the terms of the GNU GPL.
  */
 
+#ifndef _BIRD_RIP_H_
+#define _BIRD_RIP_H_
+
+#include "nest/bird.h"
+#include "nest/cli.h"
+#include "nest/iface.h"
+#include "nest/protocol.h"
 #include "nest/route.h"
 #include "nest/password.h"
 #include "nest/locks.h"
+#include "nest/bfd.h"
+#include "lib/lists.h"
+#include "lib/resource.h"
+#include "lib/socket.h"
+#include "lib/string.h"
+#include "lib/timer.h"
 
-#define EA_RIP_TAG	EA_CODE(EAP_RIP, 0)
-#define EA_RIP_METRIC	EA_CODE(EAP_RIP, 1)
 
-#define PACKET_MAX	25
-#define PACKET_MD5_MAX	18	/* FIXME */
+#ifdef IPV6
+#define RIP_IS_V2 0
+#else
+#define RIP_IS_V2 1
+#endif
 
+#define RIP_V1			1
+#define RIP_V2			2
 
-#define RIP_V1		1
-#define RIP_V2		2
-#define RIP_NG		1	/* A new version numbering */
+#define RIP_PORT		520	/* RIP for IPv4 */
+#define RIP_NG_PORT		521	/* RIPng */
 
-#ifndef IPV6
-#define RIP_PORT	520	/* RIP for IPv4 */
-#else
-#define RIP_PORT	521	/* RIPng */
-#endif
+#define RIP_MAX_PKT_LENGTH	532	/* 512 + IP4_HEADER_LENGTH */
+#define RIP_AUTH_TAIL_LENGTH	20	/* 4 + MD5 length */
 
-struct rip_connection {
-  node n;
+#define RIP_DEFAULT_ECMP_LIMIT	16
+#define RIP_DEFAULT_INFINITY	16
+#define RIP_DEFAULT_UPDATE_TIME	30
+#define RIP_DEFAULT_TIMEOUT_TIME 180
+#define RIP_DEFAULT_GARBAGE_TIME 120
 
-  int num;
-  struct proto *proto;
-  ip_addr addr;
-  sock *send;
-  struct rip_interface *rif;
-  struct fib_iterator iter;
 
-  ip_addr daddr;
-  int dport;
-  int done;
-};
+struct rip_config
+{
+  struct proto_config c;
+  list patt_list;			/* List of iface configs (struct rip_iface_config) */
 
-struct rip_packet_heading {		/* 4 bytes */
-  u8 command;
-#define RIPCMD_REQUEST          1       /* want info */
-#define RIPCMD_RESPONSE         2       /* responding to request */
-#define RIPCMD_TRACEON          3       /* turn tracing on */
-#define RIPCMD_TRACEOFF         4       /* turn it off */
-#define RIPCMD_MAX              5
-  u8 version;
-#define RIP_V1			1
-#define RIP_V2			2
-#define RIP_NG 			1	/* this is verion 1 of RIPng */
-  u16 unused;
+  u8 rip2;				/* RIPv2 (IPv4) or RIPng (IPv6) */
+  u8 ecmp;				/* Maximum number of nexthops in ECMP route, or 0 */
+  u8 infinity;				/* Maximum metric value, representing infinity */
+
+  u32 min_timeout_time;			/* Minimum of interface timeout_time */
+  u32 max_garbage_time;			/* Maximum of interface garbage_time */
 };
 
-#ifndef IPV6
-struct rip_block {	/* 20 bytes */
-  u16 family;	/* 0xffff on first message means this is authentication */
-  u16 tag;
-  ip_addr network;
-  ip_addr netmask;
-  ip_addr nexthop;
-  u32 metric;
+struct rip_iface_config
+{
+  struct iface_patt i;
+  ip_addr address;			/* Configured dst address */
+  u16 port;				/* Src+dst port */
+  u8 metric;				/* Incoming metric */
+  u8 mode;				/* Interface mode (RIP_IM_*) */
+  u8 passive;				/* Passive iface - no packets are sent */
+  u8 version;				/* RIP version used for outgoing packets */
+  u8 version_only;	/* FIXXX */
+  u8 split_horizon;			/* Split horizon is used in route updates */
+  u8 poison_reverse;			/* Poisoned reverse is used in route updates */
+  u8 check_zero;			/* Validation of RIPv1 reserved fields */
+  u8 ecmp_weight;			/* Weight for ECMP routes*/
+  u8 auth_type;				/* Authentication type (RIP_AUTH_*) */
+  u8 ttl_security;			/* bool + 2 for TX only (send, but do not check on RX) */
+  u8 check_link;			/* Whether iface link change is used */
+  u8 bfd;				/* Use BFD on iface */
+  u16 rx_buffer;			/* RX buffer size, 0 for MTU */
+  u16 tx_length;			/* TX packet length limit (including headers), 0 for MTU */
+  int tx_tos;
+  int tx_priority;
+  u32 update_time;			/* Periodic update interval */
+  u32 timeout_time;			/* Route expiration timeout */
+  u32 garbage_time;			/* Unreachable entry GC timeout */
+  list *passwords;			/* Passwords for authentication */
 };
-#else
-struct rip_block { /* IPv6 version!, 20 bytes, too */
-  ip_addr network;
-  u16 tag;
-  u8 pxlen;
-  u8 metric;
+
+struct rip_proto
+{
+  struct proto p;
+  struct fib rtable;			/* Internal routing table */
+  list iface_list;			/* List of interfaces (struct rip_iface) */
+  slab *rte_slab;			/* Slab for internal routes (struct rip_rte) */
+  timer *timer;				/* Main protocol timer */
+
+  u8 ecmp;				/* Maximum number of nexthops in ECMP route, or 0 */
+  u8 infinity;				/* Maximum metric value, representing infinity */
+  u8 triggered;				/* Logical AND of interface want_triggered values */
+  u8 rt_reload;				/* Route reload is scheduled */
+
+  struct tbf log_pkt_tbf;		/* TBF for packet messages */
+  struct tbf log_rte_tbf;		/* TBF for RTE messages */
 };
-#endif
 
-struct rip_block_auth { /* 20 bytes */
-  u16 mustbeFFFF;
-  u16 authtype;
-  u16 packetlen;
-  u8 keyid;
-  u8 authlen;
-  u32 seq;
-  u32 zero0;
-  u32 zero1;
+struct rip_iface
+{
+  node n;
+  struct rip_proto *rip;
+  struct iface *iface;			/* Underyling core interface */
+  struct rip_iface_config *cf;		/* Related config, must be updated in reconfigure */
+  struct object_lock *lock;		/* Interface lock */
+  timer *timer;				/* Interface timer */
+  sock *sk;				/* UDP socket */
+
+  u8 up;				/* Interface is active */
+  u8 csn_ready;				/* Nonzero CSN can be used */
+  u16 tx_plen;				/* Max TX packet data length */
+  u32 csn;				/* Last used crypto sequence number */
+  ip_addr addr;				/* Destination multicast/broadcast address */
+  list neigh_list;			/* List of iface neighbors (struct rip_neighbor) */
+
+  /* Update scheduling */
+  bird_clock_t next_regular;		/* Next time when regular update should be called */
+  bird_clock_t next_triggered;		/* Next time when triggerd update may be called */
+  bird_clock_t want_triggered;		/* Nonzero if triggered update is scheduled */
+
+  /* Active update */
+  int tx_active;			/* Update session is active */
+  ip_addr tx_addr;			/* Update session destination address */
+  bird_clock_t tx_changed;		/* Minimal changed time for triggered update */
+  struct fib_iterator tx_fit;		/* FIB iterator in RIP routing table (p.rtable) */
 };
 
-struct rip_md5_tail {	/* 20 bytes */
-  u16 mustbeFFFF;
-  u16 mustbe0001;
-  char md5[16];
+struct rip_neighbor
+{
+  node n;
+  struct rip_iface *ifa;		/* Associated interface, may be NULL if stale */
+  struct neighbor *nbr;			/* Associaded core neighbor, may be NULL if stale */
+  struct bfd_request *bfd_req;		/* BFD request, if BFD is used */
+  bird_clock_t last_seen;		/* Time of last received and accepted message */
+  u32 uc;				/* Use count, number of routes linking the neighbor */
+  u32 csn;				/* Last received crypto sequence number */
 };
 
-struct rip_entry {
+struct rip_entry
+{
   struct fib_node n;
+  struct rip_rte *routes;		/* List of incoming routes */
 
-  ip_addr whotoldme;
-  ip_addr nexthop;
-  int metric;
-  u16 tag;
+  u8 valid;				/* Entry validity state (RIP_ENTRY_*) */
+  u8 metric;				/* Outgoing route metric */
+  u16 tag;				/* Outgoing route tag */
+  struct iface *from;			/* Outgoing route from, NULL if from  proto */
+  struct iface *iface;			/* Outgoing route iface (for next hop) */
+  ip_addr next_hop;			/* Outgoing route next hop */
 
-  bird_clock_t updated, changed;
-  int flags;
+  bird_clock_t changed;			/* Last time when the outgoing route metric changed */
 };
 
-struct rip_packet {
-  struct rip_packet_heading heading;
-  struct rip_block block[PACKET_MAX];
-};
+struct rip_rte
+{
+  struct rip_rte *next;
 
-struct rip_interface {
-  node n;
-  struct proto *proto;
-  struct iface *iface;
-  sock *sock;
-  struct rip_connection *busy;
-  int metric;			/* You don't want to put struct rip_patt *patt here -- think about reconfigure */
-  int mode;
-  int check_ttl;		/* Check incoming packets for TTL 255 */
-  int triggered;
-  struct object_lock *lock;
-  int multicast;
+  struct rip_neighbor *from;		/* Advertising router */
+  ip_addr next_hop;			/* Route next hop (iface is from->nbr->iface) */
+  u16 metric;				/* Route metric (after increase) */
+  u16 tag;				/* Route tag */
+
+  bird_clock_t expires;			/* Time of route expiration */
 };
 
-struct rip_patt {
-  struct iface_patt i;
 
-  int metric;		/* If you add entries here, don't forget to modify patt_compare! */
-  int mode;
-#define IM_BROADCAST 2
-#define IM_QUIET 4
-#define IM_NOLISTEN 8
-#define IM_VERSION1 16
-  int tx_tos;
-  int tx_priority;
-  int ttl_security;	/* bool + 2 for TX only (send, but do not check on RX) */
-};
+#define RIP_AUTH_NONE		0
+#define RIP_AUTH_PLAIN		2
+#define RIP_AUTH_CRYPTO		3
 
-struct rip_proto_config {
-  struct proto_config c;
-  list iface_list;	/* Patterns configured -- keep it first; see rip_reconfigure why */
-  list *passwords;	/* Passwords, keep second */
-
-  int infinity;		/* User configurable data; must be comparable with memcmp */
-  int port;
-  int period;
-  int garbage_time;
-  int timeout_time;
-
-  int authtype;
-#define AT_NONE 0
-#define AT_PLAINTEXT 2
-#define AT_MD5 3
-  int honor;
-#define HO_NEVER 0
-#define HO_NEIGHBOR 1
-#define HO_ALWAYS 2
-};
+#define RIP_IM_MULTICAST	1
+#define RIP_IM_BROADCAST	2
 
-struct rip_proto {
-  struct proto inherited;
-  timer *timer;
-  list connections;
-  struct fib rtable;
-  list garbage;
-  list interfaces;	/* Interfaces we really know about */
-#ifdef LOCAL_DEBUG
-  int magic;
-#endif
-  int tx_count;		/* Do one regular update once in a while */
-  int rnd_count;	/* Randomize sending time */
-};
+#define RIP_ENTRY_DUMMY		0	/* Only used to store list of incoming routes */
+#define RIP_ENTRY_VALID		1	/* Valid outgoing route */
+#define RIP_ENTRY_STALE		2	/* Stale outgoing route, waiting for GC */
 
-#ifdef LOCAL_DEBUG
-#define RIP_MAGIC 81861253
-#define CHK_MAGIC do { if (P->magic != RIP_MAGIC) bug( "Not enough magic" ); } while (0)
-#else
-#define CHK_MAGIC do { } while (0)
-#endif
+#define EA_RIP_METRIC		EA_CODE(EAP_RIP, 0)
+#define EA_RIP_TAG		EA_CODE(EAP_RIP, 1)
 
+#define rip_is_v2(X) RIP_IS_V2
+#define rip_is_ng(X) (!RIP_IS_V2)
 
-void rip_init_config(struct rip_proto_config *c);
+/*
+static inline int rip_is_v2(struct rip_proto *p)
+{ return p->rip2; }
+
+static inline int rip_is_ng(struct rip_proto *p)
+{ return ! p->rip2; }
+*/
+
+static inline void
+rip_reset_tx_session(struct rip_proto *p, struct rip_iface *ifa)
+{
+  if (ifa->tx_active)
+  {
+    FIB_ITERATE_UNLINK(&ifa->tx_fit, &p->rtable);
+    ifa->tx_active = 0;
+  }
+}
+
+/* rip.c */
+void rip_update_rte(struct rip_proto *p, ip_addr *prefix, int pxlen, struct rip_rte *new);
+void rip_withdraw_rte(struct rip_proto *p, ip_addr *prefix, int pxlen, struct rip_neighbor *from);
+struct rip_neighbor * rip_get_neighbor(struct rip_proto *p, ip_addr *a, struct rip_iface *ifa);
+void rip_update_bfd(struct rip_proto *p, struct rip_neighbor *n);
+void rip_show_interfaces(struct proto *P, char *iff);
+void rip_show_neighbors(struct proto *P, char *iff);
+
+/* packets.c */
+void rip_send_request(struct rip_proto *p, struct rip_iface *ifa);
+void rip_send_table(struct rip_proto *p, struct rip_iface *ifa, ip_addr addr, bird_clock_t changed);
+int rip_open_socket(struct rip_iface *ifa);
 
-/* Authentication functions */
 
-int rip_incoming_authentication( struct proto *p, struct rip_block_auth *block, struct rip_packet *packet, int num, ip_addr whotoldme );
-int rip_outgoing_authentication( struct proto *p, struct rip_block_auth *block, struct rip_packet *packet, int num );
+#endif

From acb04cfdc550697a7171a86ca559fd8c52841acb Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Sat, 17 Oct 2015 14:36:53 +0200
Subject: [PATCH 029/165] Minor changes

---
 nest/route.h           | 34 ++++++++++++++++++++--------------
 sysdep/linux/netlink.c | 23 ++++++++++++++++-------
 2 files changed, 36 insertions(+), 21 deletions(-)

diff --git a/nest/route.h b/nest/route.h
index 6067526d..d0f8c688 100644
--- a/nest/route.h
+++ b/nest/route.h
@@ -174,7 +174,7 @@ struct hostentry {
   ip_addr addr;				/* IP address of host, part of key */
   ip_addr link;				/* (link-local) IP address of host, used as gw
 					   if host is directly attached */
-  struct rtable *tab;			/* Dependent table, part of key*/
+  struct rtable *tab;			/* Dependent table, part of key */
   struct hostentry *next;		/* Next in hash chain */
   unsigned hash_key;			/* Hash key */
   unsigned uc;				/* Use count */
@@ -507,19 +507,25 @@ void rta_show(struct cli *, rta *, ea_list *);
 void rta_set_recursive_next_hop(rtable *dep, rta *a, rtable *tab, ip_addr *gw, ip_addr *ll);
 
 /*
- * rta_set_recursive_next_hop() acquires hostentry from hostcache and
- * fills rta->hostentry field.  New hostentry has zero use
- * count. Cached rta locks its hostentry (increases its use count),
- * uncached rta does not lock it. Hostentry with zero use count is
- * removed asynchronously during host cache update, therefore it is
- * safe to hold such hostentry temorarily. Hostentry holds a lock for
- * a 'source' rta, mainly to share multipath nexthops. There is no
- * need to hold a lock for hostentry->dep table, because that table
- * contains routes responsible for that hostentry, and therefore is
- * non-empty if given hostentry has non-zero use count. The protocol
- * responsible for routes with recursive next hops should also hold a
- * lock for a table governing that routes (argument tab to
- * rta_set_recursive_next_hop()).
+ * rta_set_recursive_next_hop() acquires hostentry from hostcache and fills
+ * rta->hostentry field.  New hostentry has zero use count. Cached rta locks its
+ * hostentry (increases its use count), uncached rta does not lock it. Hostentry
+ * with zero use count is removed asynchronously during host cache update,
+ * therefore it is safe to hold such hostentry temorarily. Hostentry holds a
+ * lock for a 'source' rta, mainly to share multipath nexthops.
+ *
+ * There is no need to hold a lock for hostentry->dep table, because that table
+ * contains routes responsible for that hostentry, and therefore is non-empty if
+ * given hostentry has non-zero use count. If the hostentry has zero use count,
+ * the entry is removed before dep is referenced.
+ *
+ * The protocol responsible for routes with recursive next hops should hold a
+ * lock for a 'source' table governing that routes (argument tab to
+ * rta_set_recursive_next_hop()), because its routes reference hostentries
+ * (through rta) related to the governing table. When all such routes are
+ * removed, rtas are immediately removed achieving zero uc. Then the 'source'
+ * table lock could be immediately released, although hostentries may still
+ * exist - they will be freed together with the 'source' table.
  */
 
 static inline void rt_lock_hostentry(struct hostentry *he) { if (he) he->uc++; }
diff --git a/sysdep/linux/netlink.c b/sysdep/linux/netlink.c
index 9c9449e2..674d338b 100644
--- a/sysdep/linux/netlink.c
+++ b/sysdep/linux/netlink.c
@@ -239,6 +239,16 @@ nl_parse_attrs(struct rtattr *a, struct rtattr **k, int ksize)
     return 1;
 }
 
+static inline ip4_addr rta_get_u32(struct rtattr *a)
+{ return *(u32 *) RTA_DATA(a); }
+
+static inline ip4_addr rta_get_ip4(struct rtattr *a)
+{ return ip4_ntoh(*(ip4_addr *) RTA_DATA(a)); }
+
+static inline ip6_addr rta_get_ip6(struct rtattr *a)
+{ return ip6_ntoh(*(ip6_addr *) RTA_DATA(a)); }
+
+
 struct rtattr *
 nl_add_attr(struct nlmsghdr *h, uint bufsize, uint code, const void *data, uint dlen)
 {
@@ -420,7 +430,7 @@ nl_parse_metrics(struct rtattr *hdr, u32 *metrics, int max)
       return -1;
 
     metrics[0] |= 1 << a->rta_type;
-    metrics[a->rta_type] = *(u32 *)RTA_DATA(a);
+    metrics[a->rta_type] = rta_get_u32(a);
   }
 
   if (len > 0)
@@ -456,7 +466,7 @@ nl_parse_link(struct nlmsghdr *h, int scan)
       return;
     }
   name = RTA_DATA(a[IFLA_IFNAME]);
-  memcpy(&mtu, RTA_DATA(a[IFLA_MTU]), sizeof(u32));
+  mtu = rta_get_u32(a[IFLA_MTU]);
 
   ifi = if_find_by_index(i->ifi_index);
   if (!new)
@@ -831,7 +841,7 @@ nl_parse_route(struct nlmsghdr *h, int scan)
     }
 
   if (a[RTA_OIF])
-    memcpy(&oif, RTA_DATA(a[RTA_OIF]), sizeof(oif));
+    oif = rta_get_u32(a[RTA_OIF]);
 
   p = nl_table_map[i->rtm_table];	/* Do we know this table? */
   DBG("KRT: Got %I/%d, type=%d, oif=%d, table=%d, prid=%d, proto=%s\n", dst, i->rtm_dst_len, i->rtm_type, oif, i->rtm_table, i->rtm_protocol, p ? p->p.name : "(none)");
@@ -965,11 +975,10 @@ nl_parse_route(struct nlmsghdr *h, int scan)
   e->u.krt.src = src;
   e->u.krt.proto = i->rtm_protocol;
   e->u.krt.type = i->rtm_type;
+  e->u.krt.metric = 0;
 
   if (a[RTA_PRIORITY])
-    memcpy(&e->u.krt.metric, RTA_DATA(a[RTA_PRIORITY]), sizeof(e->u.krt.metric));
-  else
-    e->u.krt.metric = 0;
+    e->u.krt.metric = rta_get_u32(a[RTA_PRIORITY]);
 
   if (a[RTA_PREFSRC])
     {
@@ -1000,7 +1009,7 @@ nl_parse_route(struct nlmsghdr *h, int scan)
       ea->attrs[0].id = EA_KRT_REALM;
       ea->attrs[0].flags = 0;
       ea->attrs[0].type = EAF_TYPE_INT;
-      memcpy(&ea->attrs[0].u.data, RTA_DATA(a[RTA_FLOW]), 4);
+      ea->attrs[0].u.data = rta_get_u32(a[RTA_FLOW]);
     }
 
   if (a[RTA_METRICS])

From 338f85ca7721fac16394ccabd561ddb5ccaacb36 Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Tue, 3 Nov 2015 11:08:57 +0100
Subject: [PATCH 030/165] IO: Handle fd values too big for select()

If the number of sockets is too much for select(), we should at least
handle it with proper error messages and reject new sockets instead of
breaking the event loop.

Thanks to Alexander V. Chernikov for the patch.
---
 sysdep/unix/io.c | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/sysdep/unix/io.c b/sysdep/unix/io.c
index 0724667d..726f1e49 100644
--- a/sysdep/unix/io.c
+++ b/sysdep/unix/io.c
@@ -1309,6 +1309,16 @@ sk_passive_connected(sock *s, int type)
     return 0;
   }
 
+  if (fd >= FD_SETSIZE)
+  {
+    /* FIXME: Call err_hook instead ? */
+    log(L_ERR "SOCK: Incoming connection from %I%J (port %d) %s",
+	t->daddr, ipa_is_link_local(t->daddr) ? t->iface : NULL,
+	t->dport, "rejected due to FD_SETSIZE limit");
+    close(fd);
+    return 1;
+  }
+
   sock *t = sk_new(s->pool);
   t->type = type;
   t->fd = fd;
@@ -1404,6 +1414,9 @@ sk_open(sock *s)
   if (fd < 0)
     ERR("socket");
 
+  if (fd >= FD_SETSIZE)
+    ERR2("FD_SETSIZE limit reached");
+
   s->af = af;
   s->fd = fd;
 

From 3aed0a6ff7b2b811a535202fd787281d2ac33409 Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Tue, 3 Nov 2015 11:27:27 +0100
Subject: [PATCH 031/165] IO: Fix the previous bugfix

I should check it after making some trivial changes. The original patch
from Alexander has it right.
---
 sysdep/unix/io.c | 22 ++++++++++++----------
 1 file changed, 12 insertions(+), 10 deletions(-)

diff --git a/sysdep/unix/io.c b/sysdep/unix/io.c
index 726f1e49..b636e799 100644
--- a/sysdep/unix/io.c
+++ b/sysdep/unix/io.c
@@ -1309,16 +1309,6 @@ sk_passive_connected(sock *s, int type)
     return 0;
   }
 
-  if (fd >= FD_SETSIZE)
-  {
-    /* FIXME: Call err_hook instead ? */
-    log(L_ERR "SOCK: Incoming connection from %I%J (port %d) %s",
-	t->daddr, ipa_is_link_local(t->daddr) ? t->iface : NULL,
-	t->dport, "rejected due to FD_SETSIZE limit");
-    close(fd);
-    return 1;
-  }
-
   sock *t = sk_new(s->pool);
   t->type = type;
   t->fd = fd;
@@ -1338,6 +1328,18 @@ sk_passive_connected(sock *s, int type)
       log(L_WARN "SOCK: Cannot get remote IP address for TCP<");
   }
 
+  if (fd >= FD_SETSIZE)
+  {
+    /* FIXME: Call err_hook instead ? */
+    log(L_ERR "SOCK: Incoming connection from %I%J (port %d) %s",
+	t->daddr, ipa_is_link_local(t->daddr) ? t->iface : NULL,
+	t->dport, "rejected due to FD_SETSIZE limit");
+    close(fd);
+    t->fd = -1;
+    rfree(t);
+    return 1;
+  }
+
   if (sk_setup(t) < 0)
   {
     /* FIXME: Call err_hook instead ? */

From 9b9a7143c43d01f0459d40363d56e9c7690c596f Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Mon, 9 Nov 2015 00:42:02 +0100
Subject: [PATCH 032/165] Conf: Fixes bug in symbol lookup during
 reconfiguration

Symbol lookup by cf_find_symbol() not only did the lookup but also added
new void symbols allocated from cfg_mem linpool, which gets broken when
lookups are done outside of config parsing, which may lead to crashes
during reconfiguration.

The patch separates lookup-only cf_find_symbol() and config-modifying
cf_get_symbol(), while the later is called only during parsing. Also
new_config and cfg_mem global variables are NULLed outside of parsing.
---
 conf/cf-lex.l      | 64 ++++++++++++++++++++++++++++++---------------
 conf/conf.c        | 65 +++++++++++++++++++++++++++-------------------
 conf/conf.h        |  4 ++-
 nest/proto.c       |  2 +-
 nest/rt-roa.c      |  2 +-
 nest/rt-table.c    |  4 +--
 sysdep/unix/main.c |  2 +-
 7 files changed, 90 insertions(+), 53 deletions(-)

diff --git a/conf/cf-lex.l b/conf/cf-lex.l
index 61e04075..5a2a4d6b 100644
--- a/conf/cf-lex.l
+++ b/conf/cf-lex.l
@@ -70,7 +70,7 @@ struct sym_scope {
 static struct sym_scope *conf_this_scope;
 
 static int cf_hash(byte *c);
-static struct symbol *cf_find_sym(byte *c, unsigned int h0);
+static inline struct symbol * cf_get_sym(byte *c, uint h0);
 
 linpool *cfg_mem;
 
@@ -194,7 +194,7 @@ else: {
 	}
       k=k->next;
     }
-  cf_lval.s = cf_find_sym(yytext, h);
+  cf_lval.s = cf_get_sym(yytext, h);
   return SYM;
 }
 
@@ -426,8 +426,9 @@ check_eof(void)
 }
 
 static struct symbol *
-cf_new_sym(byte *c, unsigned int h)
+cf_new_sym(byte *c, uint h0)
 {
+  uint h = h0 & (SYM_HASH_SIZE-1);
   struct symbol *s, **ht;
   int l;
 
@@ -449,56 +450,77 @@ cf_new_sym(byte *c, unsigned int h)
 }
 
 static struct symbol *
-cf_find_sym(byte *c, unsigned int h0)
+cf_find_sym(struct config *cfg, byte *c, uint h0)
 {
-  unsigned int h = h0 & (SYM_HASH_SIZE-1);
+  uint h = h0 & (SYM_HASH_SIZE-1);
   struct symbol *s, **ht;
 
-  if (ht = new_config->sym_hash)
+  if (ht = cfg->sym_hash)
     {
       for(s = ht[h]; s; s=s->next)
 	if (!strcmp(s->name, c) && s->scope->active)
 	  return s;
     }
-  if (new_config->sym_fallback)
+  if (ht = cfg->sym_fallback)
     {
       /* We know only top-level scope is active */
-      for(s = new_config->sym_fallback[h]; s; s=s->next)
+      for(s = ht[h]; s; s=s->next)
 	if (!strcmp(s->name, c) && s->scope->active)
 	  return s;
     }
-  return cf_new_sym(c, h);
+
+  return NULL;
+}
+
+static inline struct symbol *
+cf_get_sym(byte *c, uint h0)
+{
+  return cf_find_sym(new_config, c, h0) ?: cf_new_sym(c, h0);
 }
 
 /**
  * cf_find_symbol - find a symbol by name
+ * @cfg: specificed config
+ * @c: symbol name
+ *
+ * This functions searches the symbol table in the config @cfg for a symbol of
+ * given name. First it examines the current scope, then the second recent one
+ * and so on until it either finds the symbol and returns a pointer to its
+ * &symbol structure or reaches the end of the scope chain and returns %NULL to
+ * signify no match.
+ */
+struct symbol *
+cf_find_symbol(struct config *cfg, byte *c)
+{
+  return cf_find_sym(cfg, c, cf_hash(c));
+}
+
+/**
+ * cf_get_symbol - get a symbol by name
  * @c: symbol name
  *
- * This functions searches the symbol table for a symbol of given
- * name. First it examines the current scope, then the second recent
- * one and so on until it either finds the symbol and returns a pointer
- * to its &symbol structure or reaches the end of the scope chain
- * and returns %NULL to signify no match.
+ * This functions searches the symbol table of the currently parsed config
+ * (@new_config) for a symbol of given name. It returns either the already
+ * existing symbol or a newly allocated undefined (%SYM_VOID) symbol if no
+ * existing symbol is found.
  */
 struct symbol *
-cf_find_symbol(byte *c)
+cf_get_symbol(byte *c)
 {
-  return cf_find_sym(c, cf_hash(c));
+  return cf_get_sym(c, cf_hash(c));
 }
 
 struct symbol *
 cf_default_name(char *template, int *counter)
 {
-  char buf[32];
+  char buf[SYM_MAX_LEN];
   struct symbol *s;
   char *perc = strchr(template, '%');
 
   for(;;)
     {
       bsprintf(buf, template, ++(*counter));
-      s = cf_find_sym(buf, cf_hash(buf));
-      if (!s)
-	break;
+      s = cf_get_sym(buf, cf_hash(buf));
       if (s->class == SYM_VOID)
 	return s;
       if (!perc)
@@ -529,7 +551,7 @@ cf_define_symbol(struct symbol *sym, int type, void *def)
     {
       if (sym->scope == conf_this_scope)
 	cf_error("Symbol already defined");
-      sym = cf_new_sym(sym->name, cf_hash(sym->name) & (SYM_HASH_SIZE-1));
+      sym = cf_new_sym(sym->name, cf_hash(sym->name));
     }
   sym->class = type;
   sym->def = def;
diff --git a/conf/conf.c b/conf/conf.c
index a907402d..825a8e9f 100644
--- a/conf/conf.c
+++ b/conf/conf.c
@@ -20,19 +20,19 @@
  *
  * There can exist up to four different configurations at one time: an active
  * one (pointed to by @config), configuration we are just switching from
- * (@old_config), one queued for the next reconfiguration (@future_config;
- * if there is one and the user wants to reconfigure once again, we just
- * free the previous queued config and replace it with the new one) and
- * finally a config being parsed (@new_config). The stored @old_config 
- * is also used for undo reconfiguration, which works in a similar way.
- * Reconfiguration could also have timeout (using @config_timer) and undo
- * is automatically called if the new configuration is not confirmed later.
+ * (@old_config), one queued for the next reconfiguration (@future_config; if
+ * there is one and the user wants to reconfigure once again, we just free the
+ * previous queued config and replace it with the new one) and finally a config
+ * being parsed (@new_config). The stored @old_config is also used for undo
+ * reconfiguration, which works in a similar way. Reconfiguration could also
+ * have timeout (using @config_timer) and undo is automatically called if the
+ * new configuration is not confirmed later. The new config (@new_config) and
+ * associated linear pool (@cfg_mem) is non-NULL only during parsing.
  *
- * Loading of new configuration is very simple: just call config_alloc()
- * to get a new &config structure, then use config_parse() to parse a
- * configuration file and fill all fields of the structure
- * and finally ask the config manager to switch to the new
- * config by calling config_commit().
+ * Loading of new configuration is very simple: just call config_alloc() to get
+ * a new &config structure, then use config_parse() to parse a configuration
+ * file and fill all fields of the structure and finally ask the config manager
+ * to switch to the new config by calling config_commit().
  *
  * CLI commands are parsed in a very similar way -- there is also a stripped-down
  * &config structure associated with them and they are lex-ed and parsed by the
@@ -91,10 +91,15 @@ config_alloc(byte *name)
   linpool *l = lp_new(p, 4080);
   struct config *c = lp_allocz(l, sizeof(struct config));
 
+  /* Duplication of name string in local linear pool */
+  uint nlen = strlen(name) + 1;
+  char *ndup = lp_allocu(l, nlen);
+  memcpy(ndup, name, nlen);
+
   c->mrtdump_file = -1; /* Hack, this should be sysdep-specific */
   c->pool = p;
-  cfg_mem = c->mem = l;
-  c->file_name = cfg_strdup(name);
+  c->mem = l;
+  c->file_name = ndup;
   c->load_time = now;
   c->tf_route = c->tf_proto = (struct timeformat){"%T", "%F", 20*3600};
   c->tf_base = c->tf_log = (struct timeformat){"%F %T", NULL, 0};
@@ -119,11 +124,13 @@ config_alloc(byte *name)
 int
 config_parse(struct config *c)
 {
+  int done = 0;
   DBG("Parsing configuration file `%s'\n", c->file_name);
   new_config = c;
   cfg_mem = c->mem;
   if (setjmp(conf_jmpbuf))
-    return 0;
+    goto cleanup;
+
   cf_lex_init(0, c);
   sysdep_preconfig(c);
   protos_preconfig(c);
@@ -137,7 +144,12 @@ config_parse(struct config *c)
   if (!c->router_id)
     cf_error("Router ID must be configured manually on IPv6 routers");
 #endif
-  return 1;
+  done = 1;
+
+cleanup:
+  new_config = NULL;
+  cfg_mem = NULL;
+  return done;
 }
 
 /**
@@ -150,14 +162,22 @@ config_parse(struct config *c)
 int
 cli_parse(struct config *c)
 {
-  new_config = c;
+  int done = 0;
   c->sym_fallback = config->sym_hash;
+  new_config = c;
   cfg_mem = c->mem;
   if (setjmp(conf_jmpbuf))
-    return 0;
+    goto cleanup;
+
   cf_lex_init(1, c);
   cf_parse();
-  return 1;
+  done = 1;
+
+cleanup:
+  c->sym_fallback = NULL;
+  new_config = NULL;
+  cfg_mem = NULL;
+  return done;
 }
 
 /**
@@ -237,10 +257,6 @@ config_do_commit(struct config *c, int type)
   if (old_config && !config->shutdown)
     log(L_INFO "Reconfiguring");
 
-  /* This should not be necessary, but it seems there are some
-     functions that access new_config instead of config */
-  new_config = config;
-
   if (old_config)
     old_config->obstacle_count++;
 
@@ -254,9 +270,6 @@ config_do_commit(struct config *c, int type)
   DBG("protos_commit\n");
   protos_commit(c, old_config, force_restart, type);
 
-  /* Just to be sure nobody uses that now */
-  new_config = NULL;
-
   int obs = 0;
   if (old_config)
     obs = --old_config->obstacle_count;
diff --git a/conf/conf.h b/conf/conf.h
index 515efbb3..89a2c5b7 100644
--- a/conf/conf.h
+++ b/conf/conf.h
@@ -147,7 +147,9 @@ int cf_lex(void);
 void cf_lex_init(int is_cli, struct config *c);
 void cf_lex_unwind(void);
 
-struct symbol *cf_find_symbol(byte *c);
+struct symbol *cf_find_symbol(struct config *cfg, byte *c);
+
+struct symbol *cf_get_symbol(byte *c);
 struct symbol *cf_default_name(char *template, int *counter);
 struct symbol *cf_define_symbol(struct symbol *symbol, int type, void *def);
 void cf_push_scope(struct symbol *);
diff --git a/nest/proto.c b/nest/proto.c
index 6531083c..d04da333 100644
--- a/nest/proto.c
+++ b/nest/proto.c
@@ -521,7 +521,7 @@ protos_commit(struct config *new, struct config *old, int force_reconfig, int ty
       WALK_LIST(oc, old->protos)
 	{
 	  p = oc->proto;
-	  sym = cf_find_symbol(oc->name);
+	  sym = cf_find_symbol(new, oc->name);
 	  if (sym && sym->class == SYM_PROTO && !new->shutdown)
 	    {
 	      /* Found match, let's check if we can smoothly switch to new configuration */
diff --git a/nest/rt-roa.c b/nest/rt-roa.c
index aa453f16..0fd89667 100644
--- a/nest/rt-roa.c
+++ b/nest/rt-roa.c
@@ -311,7 +311,7 @@ roa_commit(struct config *new, struct config *old)
   if (old)
     WALK_LIST(t, roa_table_list)
       {
-	struct symbol *sym = cf_find_symbol(t->name);
+	struct symbol *sym = cf_find_symbol(new, t->name);
 	if (sym && sym->class == SYM_ROA)
 	  {
 	    /* Found old table in new config */
diff --git a/nest/rt-table.c b/nest/rt-table.c
index 9e2c4e0d..2ddff12e 100644
--- a/nest/rt-table.c
+++ b/nest/rt-table.c
@@ -1663,7 +1663,7 @@ rt_prune_loop(void)
 void
 rt_preconfig(struct config *c)
 {
-  struct symbol *s = cf_find_symbol("master");
+  struct symbol *s = cf_get_symbol("master");
 
   init_list(&c->tables);
   c->master_rtc = rt_new_table(s);
@@ -1903,7 +1903,7 @@ rt_commit(struct config *new, struct config *old)
 	  rtable *ot = o->table;
 	  if (!ot->deleted)
 	    {
-	      struct symbol *sym = cf_find_symbol(o->name);
+	      struct symbol *sym = cf_find_symbol(new, o->name);
 	      if (sym && sym->class == SYM_TABLE && !new->shutdown)
 		{
 		  DBG("\t%s: same\n", o->name);
diff --git a/sysdep/unix/main.c b/sysdep/unix/main.c
index e31471da..24d34f60 100644
--- a/sysdep/unix/main.c
+++ b/sysdep/unix/main.c
@@ -96,7 +96,7 @@ drop_gid(gid_t gid)
 static inline void
 add_num_const(char *name, int val)
 {
-  struct symbol *s = cf_find_symbol(name);
+  struct symbol *s = cf_get_symbol(name);
   s->class = SYM_CONSTANT | T_INT;
   s->def = cfg_allocz(sizeof(struct f_val));
   SYM_TYPE(s) = T_INT;

From 86b4e17001fe4cca6dde7ff523346121c0ae68fe Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Mon, 9 Nov 2015 01:01:12 +0100
Subject: [PATCH 033/165] Nest: Fixes bug in missing cleanup during table
 removal

When a table is removed during reconfiguration, a reference was not
cleared in the old configuration, which breaks undo.
---
 nest/rt-table.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/nest/rt-table.c b/nest/rt-table.c
index 2ddff12e..10ce400a 100644
--- a/nest/rt-table.c
+++ b/nest/rt-table.c
@@ -1868,6 +1868,7 @@ rt_unlock_table(rtable *r)
     {
       struct config *conf = r->deleted;
       DBG("Deleting routing table %s\n", r->name);
+      r->config->table = NULL;
       if (r->hostcache)
 	rt_free_hostcache(r);
       rem_node(&r->n);

From 9ddbfbddf87462bbf50437bdc1d44499a5c223e7 Mon Sep 17 00:00:00 2001
From: Jan Moskyto Matejka <mq@ucw.cz>
Date: Tue, 3 Nov 2015 14:42:41 +0100
Subject: [PATCH 034/165] Netlink: Allow more than 256 routing tables.

Since 2.6.19, the netlink API defines RTA_TABLE routing attribute to
allow 32-bit routing table IDs. Using this attribute to index routing
tables at Linux, instead of 8-bit rtm_table field.
---
 sysdep/bsd/krt-sock.c  |  7 +++-
 sysdep/bsd/krt-sys.h   |  1 +
 sysdep/linux/krt-sys.h |  8 ++--
 sysdep/linux/netlink.Y |  2 -
 sysdep/linux/netlink.c | 90 ++++++++++++++++++++++++++++--------------
 sysdep/unix/krt.c      | 11 +++++-
 sysdep/unix/krt.h      |  3 +-
 7 files changed, 82 insertions(+), 40 deletions(-)

diff --git a/sysdep/bsd/krt-sock.c b/sysdep/bsd/krt-sock.c
index 064bae18..29203d1b 100644
--- a/sysdep/bsd/krt-sock.c
+++ b/sysdep/bsd/krt-sock.c
@@ -970,13 +970,15 @@ krt_sock_close_shared(void)
   }
 }
 
-void
+int
 krt_sys_start(struct krt_proto *p)
 {
   krt_table_map[KRT_CF->sys.table_id] = p;
 
   krt_sock_open_shared();
   p->sys.sk = krt_sock;
+
+  return 1;
 }
 
 void
@@ -992,10 +994,11 @@ krt_sys_shutdown(struct krt_proto *p)
 
 #else
 
-void
+int
 krt_sys_start(struct krt_proto *p)
 {
   p->sys.sk = krt_sock_open(p->p.pool, p, KRT_CF->sys.table_id);
+  return 1;
 }
 
 void
diff --git a/sysdep/bsd/krt-sys.h b/sysdep/bsd/krt-sys.h
index 2c6e35c5..a63f8caf 100644
--- a/sysdep/bsd/krt-sys.h
+++ b/sysdep/bsd/krt-sys.h
@@ -42,6 +42,7 @@ struct krt_state {
 };
 
 
+static inline void krt_sys_io_init(void) { }
 static inline void krt_sys_init(struct krt_proto *p UNUSED) { }
 
 static inline int krt_sys_get_attr(eattr *a UNUSED, byte *buf UNUSED, int buflen UNUSED) { }
diff --git a/sysdep/linux/krt-sys.h b/sysdep/linux/krt-sys.h
index e32e4fe1..7fd5f139 100644
--- a/sysdep/linux/krt-sys.h
+++ b/sysdep/linux/krt-sys.h
@@ -84,18 +84,18 @@ static inline struct ifa * kif_get_primary_ip(struct iface *i) { return NULL; }
 #define EA_KRT_FEATURE_ALLFRAG	EA_KRT_FEATURES | EA_BIT(0x3)
 
 
-
-#define NL_NUM_TABLES 256
-
 struct krt_params {
-  int table_id;				/* Kernel table ID we sync with */
+  u32 table_id;				/* Kernel table ID we sync with */
 };
 
 struct krt_state {
+  struct krt_proto *hash_next;
 };
 
 
 static inline void krt_sys_init(struct krt_proto *p UNUSED) { }
+static inline void krt_sys_preconfig(struct config *c UNUSED) { }
+static inline void krt_sys_postconfig(struct krt_config *x UNUSED) { }
 
 
 #endif
diff --git a/sysdep/linux/netlink.Y b/sysdep/linux/netlink.Y
index f8137e23..e9c225a2 100644
--- a/sysdep/linux/netlink.Y
+++ b/sysdep/linux/netlink.Y
@@ -23,8 +23,6 @@ CF_ADDTO(kern_proto, kern_proto kern_sys_item ';')
 
 kern_sys_item:
    KERNEL TABLE expr {
-	if ($3 <= 0 || $3 >= NL_NUM_TABLES)
-	  cf_error("Kernel routing table number out of range");
 	THIS_KRT->sys.table_id = $3;
    }
  ;
diff --git a/sysdep/linux/netlink.c b/sysdep/linux/netlink.c
index 674d338b..db998926 100644
--- a/sysdep/linux/netlink.c
+++ b/sysdep/linux/netlink.c
@@ -25,6 +25,7 @@
 #include "lib/krt.h"
 #include "lib/socket.h"
 #include "lib/string.h"
+#include "lib/hash.h"
 #include "conf/conf.h"
 
 #include <asm/types.h>
@@ -32,6 +33,7 @@
 #include <linux/netlink.h>
 #include <linux/rtnetlink.h>
 
+
 #ifndef MSG_TRUNC			/* Hack: Several versions of glibc miss this one :( */
 #define MSG_TRUNC 0x20
 #endif
@@ -40,6 +42,11 @@
 #define IFF_LOWER_UP 0x10000
 #endif
 
+#ifndef RTA_TABLE
+#define RTA_TABLE  15
+#endif
+
+
 /*
  *	Synchronous Netlink interface
  */
@@ -650,7 +657,23 @@ kif_do_scan(struct kif_proto *p UNUSED)
  *	Routes
  */
 
-static struct krt_proto *nl_table_map[NL_NUM_TABLES];
+static inline u32
+krt_table_id(struct krt_proto *p)
+{
+  return KRT_CF->sys.table_id;
+}
+
+static HASH(struct krt_proto) nl_table_map;
+
+#define RTH_FN(k)	u32_hash(k)
+#define RTH_EQ(k1,k2)	k1 == k2
+#define RTH_KEY(p)	krt_table_id(p)
+#define RTH_NEXT(p)	p->sys.hash_next
+
+#define RTH_REHASH		rth_rehash
+#define RTH_PARAMS		/8, *2, 2, 2, 6, 20
+
+HASH_DEFINE_REHASH_FN(RTH, struct krt_proto)
 
 int
 krt_capable(rte *e)
@@ -708,12 +731,15 @@ nl_send_route(struct krt_proto *p, rte *e, struct ea_list *eattrs, int new)
 
   r.r.rtm_family = BIRD_AF;
   r.r.rtm_dst_len = net->n.pxlen;
-  r.r.rtm_tos = 0;
-  r.r.rtm_table = KRT_CF->sys.table_id;
   r.r.rtm_protocol = RTPROT_BIRD;
   r.r.rtm_scope = RT_SCOPE_UNIVERSE;
   nl_add_attr_ipa(&r.h, sizeof(r), RTA_DST, net->n.prefix);
 
+  if (krt_table_id(p) < 256)
+    r.r.rtm_table = krt_table_id(p);
+  else
+    nl_add_attr_u32(&r.h, sizeof(r), RTA_TABLE, krt_table_id(p));
+
   /* For route delete, we do not specify route attributes */
   if (!new)
     return nl_exchange(&r.h);
@@ -809,11 +835,12 @@ nl_parse_route(struct nlmsghdr *h, int scan)
 {
   struct krt_proto *p;
   struct rtmsg *i;
-  struct rtattr *a[RTA_CACHEINFO+1];
+  struct rtattr *a[RTA_TABLE+1];
   int new = h->nlmsg_type == RTM_NEWROUTE;
 
   ip_addr dst = IPA_NONE;
   u32 oif = ~0;
+  u32 table;
   int src;
 
   if (!(i = nl_checkin(h, sizeof(*i))) || !nl_parse_attrs(RTM_RTA(i), a, sizeof(a)))
@@ -825,6 +852,7 @@ nl_parse_route(struct nlmsghdr *h, int scan)
       (a[RTA_IIF] && RTA_PAYLOAD(a[RTA_IIF]) != 4) ||
 #endif
       (a[RTA_OIF] && RTA_PAYLOAD(a[RTA_OIF]) != 4) ||
+      (a[RTA_TABLE] && RTA_PAYLOAD(a[RTA_TABLE]) != 4) ||
       (a[RTA_GATEWAY] && RTA_PAYLOAD(a[RTA_GATEWAY]) != sizeof(ip_addr)) ||
       (a[RTA_PRIORITY] && RTA_PAYLOAD(a[RTA_PRIORITY]) != 4) ||
       (a[RTA_PREFSRC] && RTA_PAYLOAD(a[RTA_PREFSRC]) != sizeof(ip_addr)) ||
@@ -843,10 +871,15 @@ nl_parse_route(struct nlmsghdr *h, int scan)
   if (a[RTA_OIF])
     oif = rta_get_u32(a[RTA_OIF]);
 
-  p = nl_table_map[i->rtm_table];	/* Do we know this table? */
-  DBG("KRT: Got %I/%d, type=%d, oif=%d, table=%d, prid=%d, proto=%s\n", dst, i->rtm_dst_len, i->rtm_type, oif, i->rtm_table, i->rtm_protocol, p ? p->p.name : "(none)");
+  if (a[RTA_TABLE])
+    table = rta_get_u32(a[RTA_TABLE]);
+  else
+    table = i->rtm_table;
+
+  p = HASH_FIND(nl_table_map, RTH, table); /* Do we know this table? */
+  DBG("KRT: Got %I/%d, type=%d, oif=%d, table=%d, prid=%d, proto=%s\n", dst, i->rtm_dst_len, i->rtm_type, oif, table, i->rtm_protocol, p ? p->p.name : "(none)");
   if (!p)
-    SKIP("unknown table %d\n", i->rtm_table);
+    SKIP("unknown table %d\n", table);
 
 
 #ifdef IPV6
@@ -1186,25 +1219,41 @@ nl_open_async(void)
     bug("Netlink: sk_open failed");
 }
 
+
 /*
  *	Interface to the UNIX krt module
  */
 
-static u8 nl_cf_table[(NL_NUM_TABLES+7) / 8];
-
 void
+krt_sys_io_init(void)
+{
+  HASH_INIT(nl_table_map, krt_pool, 6);
+}
+
+int
 krt_sys_start(struct krt_proto *p)
 {
-  nl_table_map[KRT_CF->sys.table_id] = p;
+  struct krt_proto *old = HASH_FIND(nl_table_map, RTH, krt_table_id(p));
+
+  if (old)
+    {
+      log(L_ERR "%s: Kernel table %u already registered by %s",
+	  p->p.name, krt_table_id(p), old->p.name);
+      return 0;
+    }
+
+  HASH_INSERT2(nl_table_map, RTH, krt_pool, p);
 
   nl_open();
   nl_open_async();
+
+  return 1;
 }
 
 void
-krt_sys_shutdown(struct krt_proto *p UNUSED)
+krt_sys_shutdown(struct krt_proto *p)
 {
-  nl_table_map[KRT_CF->sys.table_id] = NULL;
+  HASH_REMOVE2(nl_table_map, RTH, krt_pool, p);
 }
 
 int
@@ -1213,23 +1262,6 @@ krt_sys_reconfigure(struct krt_proto *p UNUSED, struct krt_config *n, struct krt
   return n->sys.table_id == o->sys.table_id;
 }
 
-
-void
-krt_sys_preconfig(struct config *c UNUSED)
-{
-  bzero(&nl_cf_table, sizeof(nl_cf_table));
-}
-
-void
-krt_sys_postconfig(struct krt_config *x)
-{
-  int id = x->sys.table_id;
-
-  if (nl_cf_table[id/8] & (1 << (id%8)))
-    cf_error("Multiple kernel syncers defined for table #%d", id);
-  nl_cf_table[id/8] |= (1 << (id%8));
-}
-
 void
 krt_sys_init_config(struct krt_config *cf)
 {
diff --git a/sysdep/unix/krt.c b/sysdep/unix/krt.c
index 2eab5cb2..49bf9519 100644
--- a/sysdep/unix/krt.c
+++ b/sysdep/unix/krt.c
@@ -77,6 +77,7 @@ krt_io_init(void)
   krt_pool = rp_new(&root_pool, "Kernel Syncer");
   krt_filter_lp = lp_new(krt_pool, 4080);
   init_list(&krt_proto_list);
+  krt_sys_io_init();
 }
 
 /*
@@ -1126,7 +1127,11 @@ krt_start(struct proto *P)
   krt_learn_init(p);
 #endif
 
-  krt_sys_start(p);
+  if (!krt_sys_start(p))
+  {
+    rem_node(&p->krt_node);
+    return PS_START;
+  }
 
   krt_scan_timer_start(p);
 
@@ -1150,8 +1155,10 @@ krt_shutdown(struct proto *P)
   p->ready = 0;
   p->initialized = 0;
 
-  krt_sys_shutdown(p);
+  if (p->p.proto_state == PS_START)
+    return PS_DOWN;
 
+  krt_sys_shutdown(p);
   rem_node(&p->krt_node);
 
   return PS_DOWN;
diff --git a/sysdep/unix/krt.h b/sysdep/unix/krt.h
index 9d5d4e8c..aea20102 100644
--- a/sysdep/unix/krt.h
+++ b/sysdep/unix/krt.h
@@ -119,8 +119,9 @@ struct proto_config * krt_init_config(int class);
 
 /* krt sysdep */
 
+void krt_sys_io_init(void);
 void krt_sys_init(struct krt_proto *);
-void krt_sys_start(struct krt_proto *);
+int krt_sys_start(struct krt_proto *);
 void krt_sys_shutdown(struct krt_proto *);
 int krt_sys_reconfigure(struct krt_proto *p UNUSED, struct krt_config *n, struct krt_config *o);
 

From fce764f90e8331d1adb6a85ec00136dfeae1a398 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pavel=20Tvrd=C3=ADk?= <pawel.tvrdik@gmail.com>
Date: Mon, 9 Nov 2015 09:14:26 +0100
Subject: [PATCH 035/165] Fix compiling with --enable-debug option

---
 sysdep/linux/netlink.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sysdep/linux/netlink.c b/sysdep/linux/netlink.c
index db998926..f2f60100 100644
--- a/sysdep/linux/netlink.c
+++ b/sysdep/linux/netlink.c
@@ -246,7 +246,7 @@ nl_parse_attrs(struct rtattr *a, struct rtattr **k, int ksize)
     return 1;
 }
 
-static inline ip4_addr rta_get_u32(struct rtattr *a)
+static inline u32 rta_get_u32(struct rtattr *a)
 { return *(u32 *) RTA_DATA(a); }
 
 static inline ip4_addr rta_get_ip4(struct rtattr *a)

From 75ff08022ea58fe3efa96639f080ce375e997675 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pavel=20Tvrd=C3=ADk?= <pawel.tvrdik@gmail.com>
Date: Fri, 13 Nov 2015 16:10:33 +0100
Subject: [PATCH 036/165] Add get_u64() and put_u64() into lib/unaligned.h

---
 lib/unaligned.h | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/lib/unaligned.h b/lib/unaligned.h
index af655204..a2dbae4f 100644
--- a/lib/unaligned.h
+++ b/lib/unaligned.h
@@ -35,6 +35,15 @@ get_u32(void *p)
   return ntohl(x);
 }
 
+static inline u64
+get_u64(const void *p)
+{
+  u32 xh, xl;
+  memcpy(&xh, p, 4);
+  memcpy(&xl, p+4, 4);
+  return (((u64) ntohl(xh)) << 32) | ntohl(xl);
+}
+
 static inline void
 put_u16(void *p, u16 x)
 {
@@ -49,4 +58,14 @@ put_u32(void *p, u32 x)
   memcpy(p, &x, 4);
 }
 
+static inline void
+put_u64(void *p, u64 x)
+{
+  u32 xh, xl;
+  xh = htonl(x >> 32);
+  xl = htonl((u32) x);
+  memcpy(p, &xh, 4);
+  memcpy(p+4, &xl, 4);
+}
+
 #endif

From 5d0c36f1da83b2a2a07e043247410948d90c600e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pavel=20Tvrd=C3=ADk?= <pawel.tvrdik@gmail.com>
Date: Fri, 13 Nov 2015 16:11:51 +0100
Subject: [PATCH 037/165] Add SHA1 and SHA1-HMAC crypto hash

---
 lib/Modules |   2 +
 lib/sha1.c  | 342 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 lib/sha1.h  |  86 +++++++++++++
 3 files changed, 430 insertions(+)
 create mode 100644 lib/sha1.c
 create mode 100644 lib/sha1.h

diff --git a/lib/Modules b/lib/Modules
index 7254df2d..a227f9a1 100644
--- a/lib/Modules
+++ b/lib/Modules
@@ -1,3 +1,5 @@
+sha1.c
+sha1.h
 birdlib.h
 bitops.c
 bitops.h
diff --git a/lib/sha1.c b/lib/sha1.c
new file mode 100644
index 00000000..dd29b5fd
--- /dev/null
+++ b/lib/sha1.c
@@ -0,0 +1,342 @@
+/*
+ *	BIRD Library -- SHA-1 Hash Function (FIPS 180-1, RFC 3174) and HMAC-SHA-1
+ *
+ *	(c) 2015 CZ.NIC z.s.p.o.
+ *
+ *	Based on the code from libucw-6.4
+ *	(c) 2008--2009 Martin Mares <mj@ucw.cz>
+ *
+ *	Based on the code from libgcrypt-1.2.3, which is
+ *	(c) 1998, 2001, 2002, 2003 Free Software Foundation, Inc.
+ *
+ *	Can be freely distributed and used under the terms of the GNU GPL.
+ */
+
+#include "lib/sha1.h"
+#include "lib/unaligned.h"
+
+void
+sha1_init(struct sha1_context *hd)
+{
+  hd->h0 = 0x67452301;
+  hd->h1 = 0xefcdab89;
+  hd->h2 = 0x98badcfe;
+  hd->h3 = 0x10325476;
+  hd->h4 = 0xc3d2e1f0;
+  hd->nblocks = 0;
+  hd->count = 0;
+}
+
+/*
+ * Transform the message X which consists of 16 32-bit-words
+ */
+static void
+sha1_transform(struct sha1_context *hd, const byte *data)
+{
+  u32 a,b,c,d,e,tm;
+  u32 x[16];
+
+  /* Get values from the chaining vars. */
+  a = hd->h0;
+  b = hd->h1;
+  c = hd->h2;
+  d = hd->h3;
+  e = hd->h4;
+
+#ifdef CPU_BIG_ENDIAN
+  memcpy(x, data, 64);
+#else
+  int i;
+  for (i = 0; i < 16; i++)
+    x[i] = get_u32(data+4*i);
+#endif
+
+#define K1		0x5A827999L
+#define K2		0x6ED9EBA1L
+#define K3		0x8F1BBCDCL
+#define K4  		0xCA62C1D6L
+#define F1(x,y,z)	( z ^ ( x & ( y ^ z ) ) )
+#define F2(x,y,z)	( x ^ y ^ z )
+#define F3(x,y,z)	( ( x & y ) | ( z & ( x | y ) ) )
+#define F4(x,y,z)	( x ^ y ^ z )
+
+#define M(i) (tm = x[i&0x0f] ^ x[(i-14)&0x0f] ^ x[(i-8)&0x0f] ^ x[(i-3)&0x0f], (x[i&0x0f] = ROL(tm, 1)))
+
+/* Bitwise rotation of an unsigned int to the left **/
+#define	ROL(x, bits) (((x) << (bits)) | ((uint)(x) >> (sizeof(uint)*8 - (bits))))
+
+  #define R(a, b, c, d, e, f, k, m)		\
+    do 						\
+    {						\
+      e += ROL(a, 5) + f(b, c, d) + k + m;	\
+      b = ROL( b, 30 );				\
+    } while(0)
+
+  R( a, b, c, d, e, F1, K1, x[ 0] );
+  R( e, a, b, c, d, F1, K1, x[ 1] );
+  R( d, e, a, b, c, F1, K1, x[ 2] );
+  R( c, d, e, a, b, F1, K1, x[ 3] );
+  R( b, c, d, e, a, F1, K1, x[ 4] );
+  R( a, b, c, d, e, F1, K1, x[ 5] );
+  R( e, a, b, c, d, F1, K1, x[ 6] );
+  R( d, e, a, b, c, F1, K1, x[ 7] );
+  R( c, d, e, a, b, F1, K1, x[ 8] );
+  R( b, c, d, e, a, F1, K1, x[ 9] );
+  R( a, b, c, d, e, F1, K1, x[10] );
+  R( e, a, b, c, d, F1, K1, x[11] );
+  R( d, e, a, b, c, F1, K1, x[12] );
+  R( c, d, e, a, b, F1, K1, x[13] );
+  R( b, c, d, e, a, F1, K1, x[14] );
+  R( a, b, c, d, e, F1, K1, x[15] );
+  R( e, a, b, c, d, F1, K1, M(16) );
+  R( d, e, a, b, c, F1, K1, M(17) );
+  R( c, d, e, a, b, F1, K1, M(18) );
+  R( b, c, d, e, a, F1, K1, M(19) );
+  R( a, b, c, d, e, F2, K2, M(20) );
+  R( e, a, b, c, d, F2, K2, M(21) );
+  R( d, e, a, b, c, F2, K2, M(22) );
+  R( c, d, e, a, b, F2, K2, M(23) );
+  R( b, c, d, e, a, F2, K2, M(24) );
+  R( a, b, c, d, e, F2, K2, M(25) );
+  R( e, a, b, c, d, F2, K2, M(26) );
+  R( d, e, a, b, c, F2, K2, M(27) );
+  R( c, d, e, a, b, F2, K2, M(28) );
+  R( b, c, d, e, a, F2, K2, M(29) );
+  R( a, b, c, d, e, F2, K2, M(30) );
+  R( e, a, b, c, d, F2, K2, M(31) );
+  R( d, e, a, b, c, F2, K2, M(32) );
+  R( c, d, e, a, b, F2, K2, M(33) );
+  R( b, c, d, e, a, F2, K2, M(34) );
+  R( a, b, c, d, e, F2, K2, M(35) );
+  R( e, a, b, c, d, F2, K2, M(36) );
+  R( d, e, a, b, c, F2, K2, M(37) );
+  R( c, d, e, a, b, F2, K2, M(38) );
+  R( b, c, d, e, a, F2, K2, M(39) );
+  R( a, b, c, d, e, F3, K3, M(40) );
+  R( e, a, b, c, d, F3, K3, M(41) );
+  R( d, e, a, b, c, F3, K3, M(42) );
+  R( c, d, e, a, b, F3, K3, M(43) );
+  R( b, c, d, e, a, F3, K3, M(44) );
+  R( a, b, c, d, e, F3, K3, M(45) );
+  R( e, a, b, c, d, F3, K3, M(46) );
+  R( d, e, a, b, c, F3, K3, M(47) );
+  R( c, d, e, a, b, F3, K3, M(48) );
+  R( b, c, d, e, a, F3, K3, M(49) );
+  R( a, b, c, d, e, F3, K3, M(50) );
+  R( e, a, b, c, d, F3, K3, M(51) );
+  R( d, e, a, b, c, F3, K3, M(52) );
+  R( c, d, e, a, b, F3, K3, M(53) );
+  R( b, c, d, e, a, F3, K3, M(54) );
+  R( a, b, c, d, e, F3, K3, M(55) );
+  R( e, a, b, c, d, F3, K3, M(56) );
+  R( d, e, a, b, c, F3, K3, M(57) );
+  R( c, d, e, a, b, F3, K3, M(58) );
+  R( b, c, d, e, a, F3, K3, M(59) );
+  R( a, b, c, d, e, F4, K4, M(60) );
+  R( e, a, b, c, d, F4, K4, M(61) );
+  R( d, e, a, b, c, F4, K4, M(62) );
+  R( c, d, e, a, b, F4, K4, M(63) );
+  R( b, c, d, e, a, F4, K4, M(64) );
+  R( a, b, c, d, e, F4, K4, M(65) );
+  R( e, a, b, c, d, F4, K4, M(66) );
+  R( d, e, a, b, c, F4, K4, M(67) );
+  R( c, d, e, a, b, F4, K4, M(68) );
+  R( b, c, d, e, a, F4, K4, M(69) );
+  R( a, b, c, d, e, F4, K4, M(70) );
+  R( e, a, b, c, d, F4, K4, M(71) );
+  R( d, e, a, b, c, F4, K4, M(72) );
+  R( c, d, e, a, b, F4, K4, M(73) );
+  R( b, c, d, e, a, F4, K4, M(74) );
+  R( a, b, c, d, e, F4, K4, M(75) );
+  R( e, a, b, c, d, F4, K4, M(76) );
+  R( d, e, a, b, c, F4, K4, M(77) );
+  R( c, d, e, a, b, F4, K4, M(78) );
+  R( b, c, d, e, a, F4, K4, M(79) );
+
+  /* Update chaining vars. */
+  hd->h0 += a;
+  hd->h1 += b;
+  hd->h2 += c;
+  hd->h3 += d;
+  hd->h4 += e;
+}
+
+/*
+ * Update the message digest with the contents
+ * of INBUF with length INLEN.
+ */
+void
+sha1_update(struct sha1_context *hd, const byte *inbuf, uint inlen)
+{
+  if (hd->count == 64)  /* flush the buffer */
+  {
+    sha1_transform(hd, hd->buf);
+    hd->count = 0;
+    hd->nblocks++;
+  }
+  if (!inbuf)
+    return;
+
+  if (hd->count)
+  {
+    for (; inlen && hd->count < 64; inlen--)
+      hd->buf[hd->count++] = *inbuf++;
+    sha1_update( hd, NULL, 0 );
+    if(!inlen)
+      return;
+  }
+
+  while (inlen >= 64)
+  {
+    sha1_transform(hd, inbuf);
+    hd->count = 0;
+    hd->nblocks++;
+    inlen -= 64;
+    inbuf += 64;
+  }
+  for (; inlen && hd->count < 64; inlen--)
+    hd->buf[hd->count++] = *inbuf++;
+}
+
+/*
+ * The routine final terminates the computation and
+ * returns the digest.
+ * The handle is prepared for a new cycle, but adding bytes to the
+ * handle will the destroy the returned buffer.
+ * Returns: 20 bytes representing the digest.
+ */
+byte *
+sha1_final(struct sha1_context *hd)
+{
+  u32 t, msb, lsb;
+  u32 *p;
+
+  sha1_update(hd, NULL, 0); /* flush */;
+
+  t = hd->nblocks;
+  /* multiply by 64 to make a byte count */
+  lsb = t << 6;
+  msb = t >> 26;
+  /* add the count */
+  t = lsb;
+  if ((lsb += hd->count) < t)
+    msb++;
+  /* multiply by 8 to make a bit count */
+  t = lsb;
+  lsb <<= 3;
+  msb <<= 3;
+  msb |= t >> 29;
+
+  if (hd->count < 56)  /* enough room */
+  {
+    hd->buf[hd->count++] = 0x80; /* pad */
+    while (hd->count < 56)
+      hd->buf[hd->count++] = 0;  /* pad */
+  }
+  else  /* need one extra block */
+  {
+    hd->buf[hd->count++] = 0x80; /* pad character */
+    while (hd->count < 64)
+      hd->buf[hd->count++] = 0;
+    sha1_update(hd, NULL, 0);  /* flush */;
+    memset(hd->buf, 0, 56 ); /* fill next block with zeroes */
+  }
+  /* append the 64 bit count */
+  hd->buf[56] = msb >> 24;
+  hd->buf[57] = msb >> 16;
+  hd->buf[58] = msb >>  8;
+  hd->buf[59] = msb	   ;
+  hd->buf[60] = lsb >> 24;
+  hd->buf[61] = lsb >> 16;
+  hd->buf[62] = lsb >>  8;
+  hd->buf[63] = lsb	   ;
+  sha1_transform(hd, hd->buf);
+
+  p = (u32*) hd->buf;
+#define X(a) do { put_u32(p, hd->h##a); p++; } while(0)
+  X(0);
+  X(1);
+  X(2);
+  X(3);
+  X(4);
+#undef X
+
+  return hd->buf;
+}
+
+
+/*
+ * 	SHA1-HMAC
+ */
+
+/*
+ * Shortcut function which puts the hash value of the supplied buffer
+ * into outbuf which must have a size of 20 bytes.
+ */
+void
+sha1_hash_buffer(byte *outbuf, const byte *buffer, uint length)
+{
+  struct sha1_context ctx;
+
+  sha1_init(&ctx);
+  sha1_update(&ctx, buffer, length);
+  memcpy(outbuf, sha1_final(&ctx), SHA1_SIZE);
+}
+
+void
+sha1_hmac_init(struct sha1_hmac_context *ctx, const byte *key, uint keylen)
+{
+  byte keybuf[SHA1_BLOCK_SIZE], buf[SHA1_BLOCK_SIZE];
+
+  /* Hash the key if necessary */
+  if (keylen <= SHA1_BLOCK_SIZE)
+  {
+    memcpy(keybuf, key, keylen);
+    bzero(keybuf + keylen, SHA1_BLOCK_SIZE - keylen);
+  }
+  else
+  {
+    sha1_hash_buffer(keybuf, key, keylen);
+    bzero(keybuf + SHA1_SIZE, SHA1_BLOCK_SIZE - SHA1_SIZE);
+  }
+
+  /* Initialize the inner digest */
+  sha1_init(&ctx->ictx);
+  int i;
+  for (i = 0; i < SHA1_BLOCK_SIZE; i++)
+    buf[i] = keybuf[i] ^ 0x36;
+  sha1_update(&ctx->ictx, buf, SHA1_BLOCK_SIZE);
+
+  /* Initialize the outer digest */
+  sha1_init(&ctx->octx);
+  for (i = 0; i < SHA1_BLOCK_SIZE; i++)
+    buf[i] = keybuf[i] ^ 0x5c;
+  sha1_update(&ctx->octx, buf, SHA1_BLOCK_SIZE);
+}
+
+void
+sha1_hmac_update(struct sha1_hmac_context *ctx, const byte *data, uint datalen)
+{
+  /* Just update the inner digest */
+  sha1_update(&ctx->ictx, data, datalen);
+}
+
+byte *sha1_hmac_final(struct sha1_hmac_context *ctx)
+{
+  /* Finish the inner digest */
+  byte *isha = sha1_final(&ctx->ictx);
+
+  /* Finish the outer digest */
+  sha1_update(&ctx->octx, isha, SHA1_SIZE);
+  return sha1_final(&ctx->octx);
+}
+
+void
+sha1_hmac(byte *outbuf, const byte *key, uint keylen, const byte *data, uint datalen)
+{
+  struct sha1_hmac_context hd;
+  sha1_hmac_init(&hd, key, keylen);
+  sha1_hmac_update(&hd, data, datalen);
+  byte *osha = sha1_hmac_final(&hd);
+  memcpy(outbuf, osha, SHA1_SIZE);
+}
diff --git a/lib/sha1.h b/lib/sha1.h
new file mode 100644
index 00000000..425160a0
--- /dev/null
+++ b/lib/sha1.h
@@ -0,0 +1,86 @@
+/*
+ *	BIRD Library -- SHA-1 Hash Function (FIPS 180-1, RFC 3174) and HMAC-SHA-1
+ *
+ *	(c) 2015 CZ.NIC z.s.p.o.
+ *
+ *	Based on the code from libucw-6.4
+ *	(c) 2008--2009 Martin Mares <mj@ucw.cz>
+ *
+ *	Based on the code from libgcrypt-1.2.3, which is
+ *	(c) 1998, 2001, 2002, 2003 Free Software Foundation, Inc.
+ *
+ *	Can be freely distributed and used under the terms of the GNU GPL.
+ */
+
+#ifndef _BIRD_SHA1_H_
+#define _BIRD_SHA1_H_
+
+#include "nest/bird.h"
+
+/*
+ * Internal SHA1 state.
+ * You should use it just as an opaque handle only.
+ */
+struct sha1_context {
+  u32 h0,h1,h2,h3,h4;
+  u32 nblocks;
+  byte buf[64];
+  int count;
+} ;
+
+void sha1_init(struct sha1_context *hd); /* Initialize new algorithm run in the @hd context. **/
+/*
+ * Push another @inlen bytes of data pointed to by @inbuf onto the
+ * SHA1 hash currently in @hd. You can call this any times you want on
+ * the same hash (and you do not need to reinitialize it by
+ * @sha1_init()). It has the same effect as concatenating all the data
+ * together and passing them at once.
+ */
+void sha1_update(struct sha1_context *hd, const byte *inbuf, uint inlen);
+/*
+ * No more @sha1_update() calls will be done. This terminates the hash
+ * and returns a pointer to it.
+ *
+ * Note that the pointer points into data in the @hd context. If it ceases
+ * to exist, the pointer becomes invalid.
+ *
+ * To convert the hash to its usual hexadecimal representation, see
+ * <<string:mem_to_hex()>>.
+ */
+byte *sha1_final(struct sha1_context *hd);
+
+/*
+ * A convenience one-shot function for SHA1 hash.
+ * It is equivalent to this snippet of code:
+ *
+ *  sha1_context hd;
+ *  sha1_init(&hd);
+ *  sha1_update(&hd, buffer, length);
+ *  memcpy(outbuf, sha1_final(&hd), SHA1_SIZE);
+ */
+void sha1_hash_buffer(byte *outbuf, const byte *buffer, uint length);
+
+/*
+ * SHA1 HMAC message authentication. If you provide @key and @data,
+ * the result will be stored in @outbuf.
+ */
+void sha1_hmac(byte *outbuf, const byte *key, uint keylen, const byte *data, uint datalen);
+
+/*
+ * The HMAC also exists in a stream version in a way analogous to the
+ * plain SHA1. Pass this as a context.
+ */
+struct sha1_hmac_context {
+  struct sha1_context ictx;
+  struct sha1_context octx;
+};
+
+void sha1_hmac_init(struct sha1_hmac_context *hd, const byte *key, uint keylen);	/* Initialize HMAC with context @hd and the given key. See sha1_init(). */
+void sha1_hmac_update(struct sha1_hmac_context *hd, const byte *data, uint datalen);	/* Hash another @datalen bytes of data. See sha1_update(). */
+byte *sha1_hmac_final(struct sha1_hmac_context *hd);					/* Terminate the HMAC and return a pointer to the allocated hash. See sha1_final(). */
+
+#define SHA1_SIZE 20 		/* Size of the SHA1 hash in its binary representation **/
+#define SHA1_HEX_SIZE 41 	/* Buffer length for a string containing SHA1 in hexadecimal format. **/
+#define SHA1_BLOCK_SIZE 64 	/* SHA1 splits input to blocks of this size. **/
+
+#endif /* _BIRD_SHA1_H_ */

From 4035e0e79c609bde30a2f755eec864771ea08e21 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pavel=20Tvrd=C3=ADk?= <pawel.tvrdik@gmail.com>
Date: Fri, 13 Nov 2015 16:13:15 +0100
Subject: [PATCH 038/165] Add SHA-224/256 and HMAC-SHA-224/256 crypto hash

---
 lib/Modules  |   2 +
 lib/sha256.c | 467 +++++++++++++++++++++++++++++++++++++++++++++++++++
 lib/sha256.h |  71 ++++++++
 3 files changed, 540 insertions(+)
 create mode 100644 lib/sha256.c
 create mode 100644 lib/sha256.h

diff --git a/lib/Modules b/lib/Modules
index a227f9a1..b3daf25d 100644
--- a/lib/Modules
+++ b/lib/Modules
@@ -1,3 +1,5 @@
+sha256.c
+sha256.h
 sha1.c
 sha1.h
 birdlib.h
diff --git a/lib/sha256.c b/lib/sha256.c
new file mode 100644
index 00000000..2d979f90
--- /dev/null
+++ b/lib/sha256.c
@@ -0,0 +1,467 @@
+/*
+ *	BIRD Library -- SHA-256 and SHA-224 Hash Functions,
+ *			HMAC-SHA-256 and HMAC-SHA-224 Functions
+ *
+ *	(c) 2015 CZ.NIC z.s.p.o.
+ *
+ *	Based on the code from libgcrypt-1.6.0, which is
+ *	(c) 2003, 2006, 2008, 2009 Free Software Foundation, Inc.
+ *
+ *	Can be freely distributed and used under the terms of the GNU GPL.
+ */
+
+#include "lib/sha256.h"
+#include "lib/unaligned.h"
+
+static uint sha256_transform(void *ctx, const byte *data, size_t nblks);
+
+void
+sha256_init(struct sha256_context *ctx)
+{
+  ctx->h0 = 0x6a09e667;
+  ctx->h1 = 0xbb67ae85;
+  ctx->h2 = 0x3c6ef372;
+  ctx->h3 = 0xa54ff53a;
+  ctx->h4 = 0x510e527f;
+  ctx->h5 = 0x9b05688c;
+  ctx->h6 = 0x1f83d9ab;
+  ctx->h7 = 0x5be0cd19;
+
+  ctx->nblocks = 0;
+  ctx->nblocks_high = 0;
+  ctx->count = 0;
+  ctx->blocksize = 64;
+  ctx->transform = sha256_transform;
+}
+
+void
+sha224_init(struct sha224_context *ctx)
+{
+  ctx->h0 = 0xc1059ed8;
+  ctx->h1 = 0x367cd507;
+  ctx->h2 = 0x3070dd17;
+  ctx->h3 = 0xf70e5939;
+  ctx->h4 = 0xffc00b31;
+  ctx->h5 = 0x68581511;
+  ctx->h6 = 0x64f98fa7;
+  ctx->h7 = 0xbefa4fa4;
+
+  ctx->nblocks = 0;
+  ctx->nblocks_high = 0;
+  ctx->count = 0;
+  ctx->blocksize = 64;
+  ctx->transform = sha256_transform;
+}
+
+/* (4.2) same as SHA-1's F1.  */
+static inline u32
+f1(u32 x, u32 y, u32 z)
+{
+  return (z ^ (x & (y ^ z)));
+}
+
+/* (4.3) same as SHA-1's F3 */
+static inline u32
+f3(u32 x, u32 y, u32 z)
+{
+  return ((x & y) | (z & (x|y)));
+}
+
+/* Bitwise rotation of an uint to the right */
+static inline u32 ror(u32 x, int n)
+{
+  return ( (x >> (n&(32-1))) | (x << ((32-n)&(32-1))) );
+}
+
+/* (4.4) */
+static inline u32
+sum0(u32 x)
+{
+  return (ror(x, 2) ^ ror(x, 13) ^ ror(x, 22));
+}
+
+/* (4.5) */
+static inline u32
+sum1(u32 x)
+{
+  return (ror(x, 6) ^ ror(x, 11) ^ ror(x, 25));
+}
+
+/*
+  Transform the message X which consists of 16 32-bit-words. See FIPS
+  180-2 for details.  */
+#define S0(x) (ror((x),  7) ^ ror((x), 18) ^ ((x) >>  3))	/* (4.6) */
+#define S1(x) (ror((x), 17) ^ ror((x), 19) ^ ((x) >> 10))	/* (4.7) */
+#define R(a,b,c,d,e,f,g,h,k,w)					\
+    do								\
+    {								\
+      t1 = (h) + sum1((e)) + f1((e),(f),(g)) + (k) + (w);	\
+      t2 = sum0((a)) + f3((a),(b),(c));				\
+      h = g;							\
+      g = f;							\
+      f = e;							\
+      e = d + t1;						\
+      d = c;							\
+      c = b;							\
+      b = a;							\
+      a = t1 + t2;						\
+    } while (0)
+
+/*
+    The SHA-256 core: Transform the message X which consists of 16
+    32-bit-words. See FIPS 180-2 for details.
+ */
+static uint
+sha256_transform_block(struct sha256_context *ctx, const byte *data)
+{
+  static const u32 K[64] = {
+      0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
+      0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+      0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
+      0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+      0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
+      0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+      0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
+      0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+      0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
+      0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+      0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
+      0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+      0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
+      0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+      0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
+      0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
+  };
+
+  u32 a,b,c,d,e,f,g,h,t1,t2;
+  u32 w[64];
+  int i;
+
+  a = ctx->h0;
+  b = ctx->h1;
+  c = ctx->h2;
+  d = ctx->h3;
+  e = ctx->h4;
+  f = ctx->h5;
+  g = ctx->h6;
+  h = ctx->h7;
+
+  for (i = 0; i < 16; i++)
+    w[i] = get_u32(data + i * 4);
+  for (; i < 64; i++)
+    w[i] = S1(w[i-2]) + w[i-7] + S0(w[i-15]) + w[i-16];
+
+  for (i = 0; i < 64;)
+  {
+    t1 = h + sum1(e) + f1(e, f, g) + K[i] + w[i];
+    t2 = sum0 (a) + f3(a, b, c);
+    d += t1;
+    h  = t1 + t2;
+
+    t1 = g + sum1(d) + f1(d, e, f) + K[i+1] + w[i+1];
+    t2 = sum0 (h) + f3(h, a, b);
+    c += t1;
+    g  = t1 + t2;
+
+    t1 = f + sum1(c) + f1(c, d, e) + K[i+2] + w[i+2];
+    t2 = sum0 (g) + f3(g, h, a);
+    b += t1;
+    f  = t1 + t2;
+
+    t1 = e + sum1(b) + f1(b, c, d) + K[i+3] + w[i+3];
+    t2 = sum0 (f) + f3(f, g, h);
+    a += t1;
+    e  = t1 + t2;
+
+    t1 = d + sum1(a) + f1(a, b, c) + K[i+4] + w[i+4];
+    t2 = sum0 (e) + f3(e, f, g);
+    h += t1;
+    d  = t1 + t2;
+
+    t1 = c + sum1(h) + f1(h, a, b) + K[i+5] + w[i+5];
+    t2 = sum0 (d) + f3(d, e, f);
+    g += t1;
+    c  = t1 + t2;
+
+    t1 = b + sum1(g) + f1(g, h, a) + K[i+6] + w[i+6];
+    t2 = sum0 (c) + f3(c, d, e);
+    f += t1;
+    b  = t1 + t2;
+
+    t1 = a + sum1(f) + f1(f, g, h) + K[i+7] + w[i+7];
+    t2 = sum0 (b) + f3(b, c, d);
+    e += t1;
+    a  = t1 + t2;
+
+    i += 8;
+  }
+
+  ctx->h0 += a;
+  ctx->h1 += b;
+  ctx->h2 += c;
+  ctx->h3 += d;
+  ctx->h4 += e;
+  ctx->h5 += f;
+  ctx->h6 += g;
+  ctx->h7 += h;
+
+  return /*burn_stack*/ 74*4+32;
+}
+#undef S0
+#undef S1
+#undef R
+
+static uint
+sha256_transform(void *ctx, const byte *data, size_t nblks)
+{
+  struct sha256_context *hd = ctx;
+  uint burn;
+
+  do
+  {
+    burn = sha256_transform_block(hd, data);
+    data += 64;
+  }
+  while (--nblks);
+
+  return burn;
+}
+
+/* Common function to write a chunk of data to the transform function
+   of a hash algorithm.  Note that the use of the term "block" does
+   not imply a fixed size block.  Note that we explicitly allow to use
+   this function after the context has been finalized; the result does
+   not have any meaning but writing after finalize is sometimes
+   helpful to mitigate timing attacks. */
+void
+sha256_update(struct sha256_context *ctx, const byte *in_buf, size_t in_len)
+{
+  const uint blocksize = ctx->blocksize;
+  size_t inblocks;
+
+  if (sizeof(ctx->buf) < blocksize)
+    debug("BUG: in file %s at line %d", __FILE__ , __LINE__);
+
+  if (ctx->count == blocksize)  /* Flush the buffer. */
+  {
+    ctx->transform(ctx, ctx->buf, 1);
+    ctx->count = 0;
+    if (!++ctx->nblocks)
+      ctx->nblocks_high++;
+  }
+  if (!in_buf)
+    return;
+
+  if (ctx->count)
+  {
+    for (; in_len && ctx->count < blocksize; in_len--)
+      ctx->buf[ctx->count++] = *in_buf++;
+    sha256_update(ctx, NULL, 0);
+    if (!in_len)
+      return;
+  }
+
+  if (in_len >= blocksize)
+  {
+    inblocks = in_len / blocksize;
+    ctx->transform(ctx, in_buf, inblocks);
+    ctx->count = 0;
+    ctx->nblocks_high += (ctx->nblocks + inblocks < inblocks);
+    ctx->nblocks += inblocks;
+    in_len -= inblocks * blocksize;
+    in_buf += inblocks * blocksize;
+  }
+  for (; in_len && ctx->count < blocksize; in_len--)
+    ctx->buf[ctx->count++] = *in_buf++;
+}
+
+/*
+   The routine finally terminates the computation and returns the
+   digest.  The handle is prepared for a new cycle, but adding bytes
+   to the handle will the destroy the returned buffer.  Returns: 32
+   bytes with the message the digest.  */
+byte*
+sha256_final(struct sha256_context *ctx)
+{
+  u32 t, th, msb, lsb;
+  byte *p;
+
+  sha256_update(ctx, NULL, 0); /* flush */;
+
+  t = ctx->nblocks;
+  if (sizeof t == sizeof ctx->nblocks)
+    th = ctx->nblocks_high;
+  else
+    th = 0;
+
+  /* multiply by 64 to make a byte count */
+  lsb = t << 6;
+  msb = (th << 6) | (t >> 26);
+  /* add the count */
+  t = lsb;
+  if ((lsb += ctx->count) < t)
+    msb++;
+  /* multiply by 8 to make a bit count */
+  t = lsb;
+  lsb <<= 3;
+  msb <<= 3;
+  msb |= t >> 29;
+
+  if (ctx->count < 56)
+  { /* enough room */
+    ctx->buf[ctx->count++] = 0x80; /* pad */
+    while (ctx->count < 56)
+      ctx->buf[ctx->count++] = 0;  /* pad */
+  }
+  else
+  { /* need one extra block */
+    ctx->buf[ctx->count++] = 0x80; /* pad character */
+    while (ctx->count < 64)
+      ctx->buf[ctx->count++] = 0;
+    sha256_update(ctx, NULL, 0);  /* flush */;
+    memset (ctx->buf, 0, 56 ); /* fill next block with zeroes */
+  }
+  /* append the 64 bit count */
+  put_u32(ctx->buf + 56, msb);
+  put_u32(ctx->buf + 60, lsb);
+  sha256_transform(ctx, ctx->buf, 1);
+
+  p = ctx->buf;
+
+#define X(a) do { put_u32(p, ctx->h##a); p += 4; } while(0)
+  X(0);
+  X(1);
+  X(2);
+  X(3);
+  X(4);
+  X(5);
+  X(6);
+  X(7);
+#undef X
+
+  return ctx->buf;
+}
+
+
+/*
+ * 	SHA256-HMAC
+ */
+
+static void
+sha256_hash_buffer(byte *outbuf, const byte *buffer, size_t length)
+{
+  struct sha256_context hd_tmp;
+
+  sha256_init(&hd_tmp);
+  sha256_update(&hd_tmp, buffer, length);
+  memcpy(outbuf, sha256_final(&hd_tmp), SHA256_SIZE);
+}
+
+void
+sha256_hmac_init(struct sha256_hmac_context *ctx, const byte *key, size_t keylen)
+{
+  byte keybuf[SHA256_BLOCK_SIZE], buf[SHA256_BLOCK_SIZE];
+
+  /* Hash the key if necessary */
+  if (keylen <= SHA256_BLOCK_SIZE)
+  {
+    memcpy(keybuf, key, keylen);
+    bzero(keybuf + keylen, SHA256_BLOCK_SIZE - keylen);
+  }
+  else
+  {
+    sha256_hash_buffer(keybuf, key, keylen);
+    bzero(keybuf + SHA256_SIZE, SHA256_BLOCK_SIZE - SHA256_SIZE);
+  }
+
+  /* Initialize the inner digest */
+  sha256_init(&ctx->ictx);
+  int i;
+  for (i = 0; i < SHA256_BLOCK_SIZE; i++)
+    buf[i] = keybuf[i] ^ 0x36;
+  sha256_update(&ctx->ictx, buf, SHA256_BLOCK_SIZE);
+
+  /* Initialize the outer digest */
+  sha256_init(&ctx->octx);
+  for (i = 0; i < SHA256_BLOCK_SIZE; i++)
+    buf[i] = keybuf[i] ^ 0x5c;
+  sha256_update(&ctx->octx, buf, SHA256_BLOCK_SIZE);
+}
+
+void sha256_hmac_update(struct sha256_hmac_context *ctx, const byte *buf, size_t buflen)
+{
+  /* Just update the inner digest */
+  sha256_update(&ctx->ictx, buf, buflen);
+}
+
+byte *sha256_hmac_final(struct sha256_hmac_context *ctx)
+{
+  /* Finish the inner digest */
+  byte *isha = sha256_final(&ctx->ictx);
+
+  /* Finish the outer digest */
+  sha256_update(&ctx->octx, isha, SHA256_SIZE);
+  return sha256_final(&ctx->octx);
+}
+
+
+/*
+ * 	SHA224-HMAC
+ */
+
+static void
+sha224_hash_buffer(byte *outbuf, const byte *buffer, size_t length)
+{
+  struct sha224_context hd_tmp;
+
+  sha224_init(&hd_tmp);
+  sha224_update(&hd_tmp, buffer, length);
+  memcpy(outbuf, sha224_final(&hd_tmp), SHA224_SIZE);
+}
+
+void
+sha224_hmac_init(struct sha224_hmac_context *ctx, const byte *key, size_t keylen)
+{
+  byte keybuf[SHA224_BLOCK_SIZE], buf[SHA224_BLOCK_SIZE];
+
+  /* Hash the key if necessary */
+  if (keylen <= SHA224_BLOCK_SIZE)
+  {
+    memcpy(keybuf, key, keylen);
+    bzero(keybuf + keylen, SHA224_BLOCK_SIZE - keylen);
+  }
+  else
+  {
+    sha224_hash_buffer(keybuf, key, keylen);
+    bzero(keybuf + SHA224_SIZE, SHA224_BLOCK_SIZE - SHA224_SIZE);
+  }
+
+  /* Initialize the inner digest */
+  sha224_init(&ctx->ictx);
+  int i;
+  for (i = 0; i < SHA224_BLOCK_SIZE; i++)
+    buf[i] = keybuf[i] ^ 0x36;
+  sha224_update(&ctx->ictx, buf, SHA224_BLOCK_SIZE);
+
+  /* Initialize the outer digest */
+  sha224_init(&ctx->octx);
+  for (i = 0; i < SHA224_BLOCK_SIZE; i++)
+    buf[i] = keybuf[i] ^ 0x5c;
+  sha224_update(&ctx->octx, buf, SHA224_BLOCK_SIZE);
+}
+
+void sha224_hmac_update(struct sha224_hmac_context *ctx, const byte *buf, size_t buflen)
+{
+  /* Just update the inner digest */
+  sha256_update(&ctx->ictx, buf, buflen);
+}
+
+byte *sha224_hmac_final(struct sha224_hmac_context *ctx)
+{
+  /* Finish the inner digest */
+  byte *isha = sha224_final(&ctx->ictx);
+
+  /* Finish the outer digest */
+  sha224_update(&ctx->octx, isha, SHA224_SIZE);
+  return sha224_final(&ctx->octx);
+}
diff --git a/lib/sha256.h b/lib/sha256.h
new file mode 100644
index 00000000..848d2176
--- /dev/null
+++ b/lib/sha256.h
@@ -0,0 +1,71 @@
+/*
+ *	BIRD Library -- SHA-256 and SHA-224 Hash Functions,
+ *			HMAC-SHA-256 and HMAC-SHA-224 Functions
+ *
+ *	(c) 2015 CZ.NIC z.s.p.o.
+ *
+ *	Based on the code from libgcrypt-1.6.0, which is
+ *	(c) 2003, 2006, 2008, 2009 Free Software Foundation, Inc.
+ *
+ *	Can be freely distributed and used under the terms of the GNU GPL.
+ */
+
+#ifndef _BIRD_SHA256_H_
+#define _BIRD_SHA256_H_
+
+#include "nest/bird.h"
+
+#define SHA224_SIZE 		28
+#define SHA224_HEX_SIZE		57
+#define SHA224_BLOCK_SIZE 	64
+
+#define SHA256_SIZE 		32
+#define SHA256_HEX_SIZE		65
+#define SHA256_BLOCK_SIZE 	64
+
+struct sha256_context {
+  u32  h0,h1,h2,h3,h4,h5,h6,h7;
+  byte buf[128];			/* 128 is for SHA384 and SHA512 support, otherwise for SHA224 and SHA256 is 64 enough */
+  u32 nblocks;
+  u32 nblocks_high;
+  int count;
+  u32 blocksize;
+  uint (*transform)(void *c, const byte *blks, size_t nblks);
+};
+#define sha224_context sha256_context	/* aliasing 'struct sha224_context' to 'struct sha256_context' */
+
+void sha256_init(struct sha256_context *ctx);
+void sha224_init(struct sha224_context *ctx);
+
+void sha256_update(struct sha256_context *ctx, const byte *in_buf, size_t in_len);
+static inline void sha224_update(struct sha224_context *ctx, const byte *in_buf, size_t in_len)
+{
+  sha256_update(ctx, in_buf, in_len);
+}
+
+byte* sha256_final(struct sha256_context *ctx);
+static inline byte* sha224_final(struct sha224_context *ctx)
+{
+  return sha256_final(ctx);
+}
+
+/*
+ *	HMAC-SHA256, HMAC-SHA224
+ */
+struct sha256_hmac_context
+{
+  struct sha256_context ictx;
+  struct sha256_context octx;
+};
+#define sha224_hmac_context sha256_hmac_context	/* aliasing 'struct sha224_hmac_context' to 'struct sha256_hmac_context' */
+
+void sha256_hmac_init(struct sha256_hmac_context *ctx, const byte *key, size_t keylen);
+void sha224_hmac_init(struct sha224_hmac_context *ctx, const byte *key,  size_t keylen);
+
+void sha256_hmac_update(struct sha256_hmac_context *ctx, const byte *buf, size_t buflen);
+void sha224_hmac_update(struct sha224_hmac_context *ctx, const byte *buf, size_t buflen);
+
+byte *sha256_hmac_final(struct sha256_hmac_context *ctx);
+byte *sha224_hmac_final(struct sha224_hmac_context *ctx);
+
+#endif /* _BIRD_SHA256_H_ */

From f312a837e919c660884ceb9c50c106df1e4c0658 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pavel=20Tvrd=C3=ADk?= <pawel.tvrdik@gmail.com>
Date: Fri, 13 Nov 2015 16:14:36 +0100
Subject: [PATCH 039/165] Add SHA-384/512 and HMAC-SHA-384/512 crypto hash

---
 lib/Modules  |   2 +
 lib/sha512.c | 614 +++++++++++++++++++++++++++++++++++++++++++++++++++
 lib/sha512.h |  73 ++++++
 3 files changed, 689 insertions(+)
 create mode 100644 lib/sha512.c
 create mode 100644 lib/sha512.h

diff --git a/lib/Modules b/lib/Modules
index b3daf25d..745306d9 100644
--- a/lib/Modules
+++ b/lib/Modules
@@ -1,5 +1,7 @@
 sha256.c
 sha256.h
+sha512.c
+sha512.h
 sha1.c
 sha1.h
 birdlib.h
diff --git a/lib/sha512.c b/lib/sha512.c
new file mode 100644
index 00000000..e46e4c98
--- /dev/null
+++ b/lib/sha512.c
@@ -0,0 +1,614 @@
+/*
+ *	BIRD Library -- SHA-512 and SHA-384 Hash Functions,
+ *			HMAC-SHA-512 and HMAC-SHA-384 Functions
+ *
+ *	(c) 2015 CZ.NIC z.s.p.o.
+ *
+ *	Based on the code from libgcrypt-1.6.0, which is
+ *	(c) 2003, 2006, 2008, 2009 Free Software Foundation, Inc.
+ *
+ *	Can be freely distributed and used under the terms of the GNU GPL.
+ */
+
+#include "lib/sha256.h"
+#include "lib/sha512.h"
+#include "lib/unaligned.h"
+
+static uint sha512_transform(void *context, const byte *data, size_t nblks);
+
+void
+sha512_init(struct sha512_context *ctx)
+{
+  struct sha512_state *hd = &ctx->state;
+
+  hd->h0 = UINT64_C(0x6a09e667f3bcc908);
+  hd->h1 = UINT64_C(0xbb67ae8584caa73b);
+  hd->h2 = UINT64_C(0x3c6ef372fe94f82b);
+  hd->h3 = UINT64_C(0xa54ff53a5f1d36f1);
+  hd->h4 = UINT64_C(0x510e527fade682d1);
+  hd->h5 = UINT64_C(0x9b05688c2b3e6c1f);
+  hd->h6 = UINT64_C(0x1f83d9abfb41bd6b);
+  hd->h7 = UINT64_C(0x5be0cd19137e2179);
+
+  ctx->bctx.nblocks = 0;
+  ctx->bctx.nblocks_high = 0;
+  ctx->bctx.count = 0;
+  ctx->bctx.blocksize = 128;
+  ctx->bctx.transform = sha512_transform;
+}
+
+void
+sha384_init(struct sha384_context *ctx)
+{
+  struct sha512_state *hd = &ctx->state;
+
+  hd->h0 = UINT64_C(0xcbbb9d5dc1059ed8);
+  hd->h1 = UINT64_C(0x629a292a367cd507);
+  hd->h2 = UINT64_C(0x9159015a3070dd17);
+  hd->h3 = UINT64_C(0x152fecd8f70e5939);
+  hd->h4 = UINT64_C(0x67332667ffc00b31);
+  hd->h5 = UINT64_C(0x8eb44a8768581511);
+  hd->h6 = UINT64_C(0xdb0c2e0d64f98fa7);
+  hd->h7 = UINT64_C(0x47b5481dbefa4fa4);
+
+  ctx->bctx.nblocks = 0;
+  ctx->bctx.nblocks_high = 0;
+  ctx->bctx.count = 0;
+  ctx->bctx.blocksize = 128;
+  ctx->bctx.transform = sha512_transform;
+}
+
+void sha512_update(struct sha512_context *ctx, const byte *in_buf, size_t in_len)
+{
+  sha256_update(&ctx->bctx, in_buf, in_len);
+}
+
+static inline u64
+ROTR(u64 x, u64 n)
+{
+  return ((x >> n) | (x << (64 - n)));
+}
+
+static inline u64
+Ch(u64 x, u64 y, u64 z)
+{
+  return ((x & y) ^ ( ~x & z));
+}
+
+static inline u64
+Maj(u64 x, u64 y, u64 z)
+{
+  return ((x & y) ^ (x & z) ^ (y & z));
+}
+
+static inline u64
+Sum0(u64 x)
+{
+  return (ROTR (x, 28) ^ ROTR (x, 34) ^ ROTR (x, 39));
+}
+
+static inline u64
+Sum1 (u64 x)
+{
+  return (ROTR (x, 14) ^ ROTR (x, 18) ^ ROTR (x, 41));
+}
+
+static const u64 k[] =
+{
+    UINT64_C(0x428a2f98d728ae22), UINT64_C(0x7137449123ef65cd),
+    UINT64_C(0xb5c0fbcfec4d3b2f), UINT64_C(0xe9b5dba58189dbbc),
+    UINT64_C(0x3956c25bf348b538), UINT64_C(0x59f111f1b605d019),
+    UINT64_C(0x923f82a4af194f9b), UINT64_C(0xab1c5ed5da6d8118),
+    UINT64_C(0xd807aa98a3030242), UINT64_C(0x12835b0145706fbe),
+    UINT64_C(0x243185be4ee4b28c), UINT64_C(0x550c7dc3d5ffb4e2),
+    UINT64_C(0x72be5d74f27b896f), UINT64_C(0x80deb1fe3b1696b1),
+    UINT64_C(0x9bdc06a725c71235), UINT64_C(0xc19bf174cf692694),
+    UINT64_C(0xe49b69c19ef14ad2), UINT64_C(0xefbe4786384f25e3),
+    UINT64_C(0x0fc19dc68b8cd5b5), UINT64_C(0x240ca1cc77ac9c65),
+    UINT64_C(0x2de92c6f592b0275), UINT64_C(0x4a7484aa6ea6e483),
+    UINT64_C(0x5cb0a9dcbd41fbd4), UINT64_C(0x76f988da831153b5),
+    UINT64_C(0x983e5152ee66dfab), UINT64_C(0xa831c66d2db43210),
+    UINT64_C(0xb00327c898fb213f), UINT64_C(0xbf597fc7beef0ee4),
+    UINT64_C(0xc6e00bf33da88fc2), UINT64_C(0xd5a79147930aa725),
+    UINT64_C(0x06ca6351e003826f), UINT64_C(0x142929670a0e6e70),
+    UINT64_C(0x27b70a8546d22ffc), UINT64_C(0x2e1b21385c26c926),
+    UINT64_C(0x4d2c6dfc5ac42aed), UINT64_C(0x53380d139d95b3df),
+    UINT64_C(0x650a73548baf63de), UINT64_C(0x766a0abb3c77b2a8),
+    UINT64_C(0x81c2c92e47edaee6), UINT64_C(0x92722c851482353b),
+    UINT64_C(0xa2bfe8a14cf10364), UINT64_C(0xa81a664bbc423001),
+    UINT64_C(0xc24b8b70d0f89791), UINT64_C(0xc76c51a30654be30),
+    UINT64_C(0xd192e819d6ef5218), UINT64_C(0xd69906245565a910),
+    UINT64_C(0xf40e35855771202a), UINT64_C(0x106aa07032bbd1b8),
+    UINT64_C(0x19a4c116b8d2d0c8), UINT64_C(0x1e376c085141ab53),
+    UINT64_C(0x2748774cdf8eeb99), UINT64_C(0x34b0bcb5e19b48a8),
+    UINT64_C(0x391c0cb3c5c95a63), UINT64_C(0x4ed8aa4ae3418acb),
+    UINT64_C(0x5b9cca4f7763e373), UINT64_C(0x682e6ff3d6b2b8a3),
+    UINT64_C(0x748f82ee5defb2fc), UINT64_C(0x78a5636f43172f60),
+    UINT64_C(0x84c87814a1f0ab72), UINT64_C(0x8cc702081a6439ec),
+    UINT64_C(0x90befffa23631e28), UINT64_C(0xa4506cebde82bde9),
+    UINT64_C(0xbef9a3f7b2c67915), UINT64_C(0xc67178f2e372532b),
+    UINT64_C(0xca273eceea26619c), UINT64_C(0xd186b8c721c0c207),
+    UINT64_C(0xeada7dd6cde0eb1e), UINT64_C(0xf57d4f7fee6ed178),
+    UINT64_C(0x06f067aa72176fba), UINT64_C(0x0a637dc5a2c898a6),
+    UINT64_C(0x113f9804bef90dae), UINT64_C(0x1b710b35131c471b),
+    UINT64_C(0x28db77f523047d84), UINT64_C(0x32caab7b40c72493),
+    UINT64_C(0x3c9ebe0a15c9bebc), UINT64_C(0x431d67c49c100d4c),
+    UINT64_C(0x4cc5d4becb3e42b6), UINT64_C(0x597f299cfc657e2a),
+    UINT64_C(0x5fcb6fab3ad6faec), UINT64_C(0x6c44198c4a475817)
+};
+
+/*
+ * Transform the message W which consists of 16 64-bit-words
+ */
+static uint
+sha512_transform_block(struct sha512_state *hd, const byte *data)
+{
+  u64 a, b, c, d, e, f, g, h;
+  u64 w[16];
+  int t;
+
+  /* get values from the chaining vars */
+  a = hd->h0;
+  b = hd->h1;
+  c = hd->h2;
+  d = hd->h3;
+  e = hd->h4;
+  f = hd->h5;
+  g = hd->h6;
+  h = hd->h7;
+
+  for ( t = 0; t < 16; t++ )
+    w[t] = get_u64(data + t * 8);
+
+#define S0(x) (ROTR((x),1) ^ ROTR((x),8) ^ ((x)>>7))
+#define S1(x) (ROTR((x),19) ^ ROTR((x),61) ^ ((x)>>6))
+
+  for (t = 0; t < 80 - 16; )
+  {
+    u64 t1, t2;
+
+    /* Performance on a AMD Athlon(tm) Dual Core Processor 4050e
+         with gcc 4.3.3 using gcry_md_hash_buffer of each 10000 bytes
+         initialized to 0,1,2,3...255,0,... and 1000 iterations:
+
+         Not unrolled with macros:  440ms
+         Unrolled with macros:      350ms
+         Unrolled with inline:      330ms
+     */
+#if 0 /* Not unrolled.  */
+    t1 = h + Sum1 (e) + Ch(e, f, g) + k[t] + w[t%16];
+    w[t%16] += S1 (w[(t - 2)%16]) + w[(t - 7)%16] + S0 (w[(t - 15)%16]);
+    t2 = Sum0 (a) + Maj(a, b, c);
+    h = g;
+    g = f;
+    f = e;
+    e = d + t1;
+    d = c;
+    c = b;
+    b = a;
+    a = t1 + t2;
+    t++;
+#else /* Unrolled to interweave the chain variables.  */
+    t1 = h + Sum1 (e) + Ch(e, f, g) + k[t] + w[0];
+    w[0] += S1 (w[14]) + w[9] + S0 (w[1]);
+    t2 = Sum0 (a) + Maj(a, b, c);
+    d += t1;
+    h = t1 + t2;
+
+    t1 = g + Sum1 (d) + Ch(d, e, f) + k[t+1] + w[1];
+    w[1] += S1 (w[15]) + w[10] + S0 (w[2]);
+    t2 = Sum0 (h) + Maj(h, a, b);
+    c += t1;
+    g  = t1 + t2;
+
+    t1 = f + Sum1 (c) + Ch(c, d, e) + k[t+2] + w[2];
+    w[2] += S1 (w[0]) + w[11] + S0 (w[3]);
+    t2 = Sum0 (g) + Maj(g, h, a);
+    b += t1;
+    f  = t1 + t2;
+
+    t1 = e + Sum1 (b) + Ch(b, c, d) + k[t+3] + w[3];
+    w[3] += S1 (w[1]) + w[12] + S0 (w[4]);
+    t2 = Sum0 (f) + Maj(f, g, h);
+    a += t1;
+    e  = t1 + t2;
+
+    t1 = d + Sum1 (a) + Ch(a, b, c) + k[t+4] + w[4];
+    w[4] += S1 (w[2]) + w[13] + S0 (w[5]);
+    t2 = Sum0 (e) + Maj(e, f, g);
+    h += t1;
+    d  = t1 + t2;
+
+    t1 = c + Sum1 (h) + Ch(h, a, b) + k[t+5] + w[5];
+    w[5] += S1 (w[3]) + w[14] + S0 (w[6]);
+    t2 = Sum0 (d) + Maj(d, e, f);
+    g += t1;
+    c  = t1 + t2;
+
+    t1 = b + Sum1 (g) + Ch(g, h, a) + k[t+6] + w[6];
+    w[6] += S1 (w[4]) + w[15] + S0 (w[7]);
+    t2 = Sum0 (c) + Maj(c, d, e);
+    f += t1;
+    b  = t1 + t2;
+
+    t1 = a + Sum1 (f) + Ch(f, g, h) + k[t+7] + w[7];
+    w[7] += S1 (w[5]) + w[0] + S0 (w[8]);
+    t2 = Sum0 (b) + Maj(b, c, d);
+    e += t1;
+    a  = t1 + t2;
+
+    t1 = h + Sum1 (e) + Ch(e, f, g) + k[t+8] + w[8];
+    w[8] += S1 (w[6]) + w[1] + S0 (w[9]);
+    t2 = Sum0 (a) + Maj(a, b, c);
+    d += t1;
+    h  = t1 + t2;
+
+    t1 = g + Sum1 (d) + Ch(d, e, f) + k[t+9] + w[9];
+    w[9] += S1 (w[7]) + w[2] + S0 (w[10]);
+    t2 = Sum0 (h) + Maj(h, a, b);
+    c += t1;
+    g  = t1 + t2;
+
+    t1 = f + Sum1 (c) + Ch(c, d, e) + k[t+10] + w[10];
+    w[10] += S1 (w[8]) + w[3] + S0 (w[11]);
+    t2 = Sum0 (g) + Maj(g, h, a);
+    b += t1;
+    f  = t1 + t2;
+
+    t1 = e + Sum1 (b) + Ch(b, c, d) + k[t+11] + w[11];
+    w[11] += S1 (w[9]) + w[4] + S0 (w[12]);
+    t2 = Sum0 (f) + Maj(f, g, h);
+    a += t1;
+    e  = t1 + t2;
+
+    t1 = d + Sum1 (a) + Ch(a, b, c) + k[t+12] + w[12];
+    w[12] += S1 (w[10]) + w[5] + S0 (w[13]);
+    t2 = Sum0 (e) + Maj(e, f, g);
+    h += t1;
+    d  = t1 + t2;
+
+    t1 = c + Sum1 (h) + Ch(h, a, b) + k[t+13] + w[13];
+    w[13] += S1 (w[11]) + w[6] + S0 (w[14]);
+    t2 = Sum0 (d) + Maj(d, e, f);
+    g += t1;
+    c  = t1 + t2;
+
+    t1 = b + Sum1 (g) + Ch(g, h, a) + k[t+14] + w[14];
+    w[14] += S1 (w[12]) + w[7] + S0 (w[15]);
+    t2 = Sum0 (c) + Maj(c, d, e);
+    f += t1;
+    b  = t1 + t2;
+
+    t1 = a + Sum1 (f) + Ch(f, g, h) + k[t+15] + w[15];
+    w[15] += S1 (w[13]) + w[8] + S0 (w[0]);
+    t2 = Sum0 (b) + Maj(b, c, d);
+    e += t1;
+    a  = t1 + t2;
+
+    t += 16;
+#endif
+  }
+
+  for (; t < 80; )
+  {
+    u64 t1, t2;
+
+#if 0 /* Not unrolled.  */
+    t1 = h + Sum1 (e) + Ch(e, f, g) + k[t] + w[t%16];
+    t2 = Sum0 (a) + Maj(a, b, c);
+    h = g;
+    g = f;
+    f = e;
+    e = d + t1;
+    d = c;
+    c = b;
+    b = a;
+    a = t1 + t2;
+    t++;
+#else /* Unrolled to interweave the chain variables.  */
+    t1 = h + Sum1 (e) + Ch(e, f, g) + k[t] + w[0];
+    t2 = Sum0 (a) + Maj(a, b, c);
+    d += t1;
+    h  = t1 + t2;
+
+    t1 = g + Sum1 (d) + Ch(d, e, f) + k[t+1] + w[1];
+    t2 = Sum0 (h) + Maj(h, a, b);
+    c += t1;
+    g  = t1 + t2;
+
+    t1 = f + Sum1 (c) + Ch(c, d, e) + k[t+2] + w[2];
+    t2 = Sum0 (g) + Maj(g, h, a);
+    b += t1;
+    f  = t1 + t2;
+
+    t1 = e + Sum1 (b) + Ch(b, c, d) + k[t+3] + w[3];
+    t2 = Sum0 (f) + Maj(f, g, h);
+    a += t1;
+    e  = t1 + t2;
+
+    t1 = d + Sum1 (a) + Ch(a, b, c) + k[t+4] + w[4];
+    t2 = Sum0 (e) + Maj(e, f, g);
+    h += t1;
+    d  = t1 + t2;
+
+    t1 = c + Sum1 (h) + Ch(h, a, b) + k[t+5] + w[5];
+    t2 = Sum0 (d) + Maj(d, e, f);
+    g += t1;
+    c  = t1 + t2;
+
+    t1 = b + Sum1 (g) + Ch(g, h, a) + k[t+6] + w[6];
+    t2 = Sum0 (c) + Maj(c, d, e);
+    f += t1;
+    b  = t1 + t2;
+
+    t1 = a + Sum1 (f) + Ch(f, g, h) + k[t+7] + w[7];
+    t2 = Sum0 (b) + Maj(b, c, d);
+    e += t1;
+    a  = t1 + t2;
+
+    t1 = h + Sum1 (e) + Ch(e, f, g) + k[t+8] + w[8];
+    t2 = Sum0 (a) + Maj(a, b, c);
+    d += t1;
+    h  = t1 + t2;
+
+    t1 = g + Sum1 (d) + Ch(d, e, f) + k[t+9] + w[9];
+    t2 = Sum0 (h) + Maj(h, a, b);
+    c += t1;
+    g  = t1 + t2;
+
+    t1 = f + Sum1 (c) + Ch(c, d, e) + k[t+10] + w[10];
+    t2 = Sum0 (g) + Maj(g, h, a);
+    b += t1;
+    f  = t1 + t2;
+
+    t1 = e + Sum1 (b) + Ch(b, c, d) + k[t+11] + w[11];
+    t2 = Sum0 (f) + Maj(f, g, h);
+    a += t1;
+    e  = t1 + t2;
+
+    t1 = d + Sum1 (a) + Ch(a, b, c) + k[t+12] + w[12];
+    t2 = Sum0 (e) + Maj(e, f, g);
+    h += t1;
+    d  = t1 + t2;
+
+    t1 = c + Sum1 (h) + Ch(h, a, b) + k[t+13] + w[13];
+    t2 = Sum0 (d) + Maj(d, e, f);
+    g += t1;
+    c  = t1 + t2;
+
+    t1 = b + Sum1 (g) + Ch(g, h, a) + k[t+14] + w[14];
+    t2 = Sum0 (c) + Maj(c, d, e);
+    f += t1;
+    b  = t1 + t2;
+
+    t1 = a + Sum1 (f) + Ch(f, g, h) + k[t+15] + w[15];
+    t2 = Sum0 (b) + Maj(b, c, d);
+    e += t1;
+    a  = t1 + t2;
+
+    t += 16;
+#endif
+  }
+
+  /* Update chaining vars.  */
+  hd->h0 += a;
+  hd->h1 += b;
+  hd->h2 += c;
+  hd->h3 += d;
+  hd->h4 += e;
+  hd->h5 += f;
+  hd->h6 += g;
+  hd->h7 += h;
+
+  return /* burn_stack */ (8 + 16) * sizeof(u64) + sizeof(u32) + 3 * sizeof(void*);
+}
+
+static uint
+sha512_transform(void *context, const byte *data, size_t nblks)
+{
+  struct sha512_context *ctx = context;
+  uint burn;
+
+  do
+  {
+    burn = sha512_transform_block(&ctx->state, data) + 3 * sizeof(void*);
+    data += 128;
+  }
+  while(--nblks);
+
+  return burn;
+}
+
+/* The routine final terminates the computation and
+ * returns the digest.
+ * The handle is prepared for a new cycle, but adding bytes to the
+ * handle will the destroy the returned buffer.
+ * Returns: 64 bytes representing the digest.  When used for sha384,
+ * we take the leftmost 48 of those bytes.
+ */
+byte *
+sha512_final(struct sha512_context *ctx)
+{
+  u64 t, th, msb, lsb;
+  byte *p;
+
+  sha256_update(&ctx->bctx, NULL, 0); /* flush */ ;
+
+  t = ctx->bctx.nblocks;
+  /* if (sizeof t == sizeof ctx->bctx.nblocks) */
+  th = ctx->bctx.nblocks_high;
+  /* else */
+  /*   th = ctx->bctx.nblocks >> 64; In case we ever use u128  */
+
+  /* multiply by 128 to make a byte count */
+  lsb = t << 7;
+  msb = (th << 7) | (t >> 57);
+  /* add the count */
+  t = lsb;
+  if ((lsb += ctx->bctx.count) < t)
+    msb++;
+  /* multiply by 8 to make a bit count */
+  t = lsb;
+  lsb <<= 3;
+  msb <<= 3;
+  msb |= t >> 61;
+
+  if (ctx->bctx.count < 112)
+  {						/* enough room */
+    ctx->bctx.buf[ctx->bctx.count++] = 0x80;	/* pad */
+    while(ctx->bctx.count < 112)
+      ctx->bctx.buf[ctx->bctx.count++] = 0;	/* pad */
+  }
+  else
+  {						/* need one extra block */
+    ctx->bctx.buf[ctx->bctx.count++] = 0x80;	/* pad character */
+    while(ctx->bctx.count < 128)
+      ctx->bctx.buf[ctx->bctx.count++] = 0;
+    sha256_update(&ctx->bctx, NULL, 0); 	/* flush */ ;
+    memset(ctx->bctx.buf, 0, 112);		/* fill next block with zeroes */
+  }
+  /* append the 128 bit count */
+  put_u64(ctx->bctx.buf + 112, msb);
+  put_u64(ctx->bctx.buf + 120, lsb);
+  sha512_transform(ctx, ctx->bctx.buf, 1);
+
+  p = ctx->bctx.buf;
+#define X(a) do { put_u64(p, ctx->state.h##a); p += 8; } while(0)
+  X (0);
+  X (1);
+  X (2);
+  X (3);
+  X (4);
+  X (5);
+  /* Note that these last two chunks are included even for SHA384.
+     We just ignore them. */
+  X (6);
+  X (7);
+#undef X
+
+  return ctx->bctx.buf;
+}
+
+
+/*
+ * 	SHA512-HMAC
+ */
+
+static void
+sha512_hash_buffer(byte *outbuf, const byte *buffer, size_t length)
+{
+  struct sha512_context hd_tmp;
+
+  sha512_init(&hd_tmp);
+  sha512_update(&hd_tmp, buffer, length);
+  memcpy(outbuf, sha512_final(&hd_tmp), SHA512_SIZE);
+}
+
+void
+sha512_hmac_init(struct sha512_hmac_context *ctx, const byte *key, size_t keylen)
+{
+  byte keybuf[SHA512_BLOCK_SIZE], buf[SHA512_BLOCK_SIZE];
+
+  /* Hash the key if necessary */
+  if (keylen <= SHA512_BLOCK_SIZE)
+  {
+    memcpy(keybuf, key, keylen);
+    bzero(keybuf + keylen, SHA512_BLOCK_SIZE - keylen);
+  }
+  else
+  {
+    sha512_hash_buffer(keybuf, key, keylen);
+    bzero(keybuf + SHA512_SIZE, SHA512_BLOCK_SIZE - SHA512_SIZE);
+  }
+
+  /* Initialize the inner digest */
+  sha512_init(&ctx->ictx);
+  int i;
+  for (i = 0; i < SHA512_BLOCK_SIZE; i++)
+    buf[i] = keybuf[i] ^ 0x36;
+  sha512_update(&ctx->ictx, buf, SHA512_BLOCK_SIZE);
+
+  /* Initialize the outer digest */
+  sha512_init(&ctx->octx);
+  for (i = 0; i < SHA512_BLOCK_SIZE; i++)
+    buf[i] = keybuf[i] ^ 0x5c;
+  sha512_update(&ctx->octx, buf, SHA512_BLOCK_SIZE);
+}
+
+void sha512_hmac_update(struct sha512_hmac_context *ctx, const byte *buf, size_t buflen)
+{
+  /* Just update the inner digest */
+  sha512_update(&ctx->ictx, buf, buflen);
+}
+
+byte *sha512_hmac_final(struct sha512_hmac_context *ctx)
+{
+  /* Finish the inner digest */
+  byte *isha = sha512_final(&ctx->ictx);
+
+  /* Finish the outer digest */
+  sha512_update(&ctx->octx, isha, SHA512_SIZE);
+  return sha512_final(&ctx->octx);
+}
+
+
+/*
+ * 	SHA384-HMAC
+ */
+
+static void
+sha384_hash_buffer(byte *outbuf, const byte *buffer, size_t length)
+{
+  struct sha384_context hd_tmp;
+
+  sha384_init(&hd_tmp);
+  sha384_update(&hd_tmp, buffer, length);
+  memcpy(outbuf, sha384_final(&hd_tmp), SHA384_SIZE);
+}
+
+void
+sha384_hmac_init(struct sha384_hmac_context *ctx, const byte *key, size_t keylen)
+{
+  byte keybuf[SHA384_BLOCK_SIZE], buf[SHA384_BLOCK_SIZE];
+
+  /* Hash the key if necessary */
+  if (keylen <= SHA384_BLOCK_SIZE)
+  {
+    memcpy(keybuf, key, keylen);
+    bzero(keybuf + keylen, SHA384_BLOCK_SIZE - keylen);
+  }
+  else
+  {
+    sha384_hash_buffer(keybuf, key, keylen);
+    bzero(keybuf + SHA384_SIZE, SHA384_BLOCK_SIZE - SHA384_SIZE);
+  }
+
+  /* Initialize the inner digest */
+  sha384_init(&ctx->ictx);
+  int i;
+  for (i = 0; i < SHA384_BLOCK_SIZE; i++)
+    buf[i] = keybuf[i] ^ 0x36;
+  sha384_update(&ctx->ictx, buf, SHA384_BLOCK_SIZE);
+
+  /* Initialize the outer digest */
+  sha384_init(&ctx->octx);
+  for (i = 0; i < SHA384_BLOCK_SIZE; i++)
+    buf[i] = keybuf[i] ^ 0x5c;
+  sha384_update(&ctx->octx, buf, SHA384_BLOCK_SIZE);
+}
+
+void sha384_hmac_update(struct sha384_hmac_context *ctx, const byte *buf, size_t buflen)
+{
+  /* Just update the inner digest */
+  sha384_update(&ctx->ictx, buf, buflen);
+}
+
+byte *sha384_hmac_final(struct sha384_hmac_context *ctx)
+{
+  /* Finish the inner digest */
+  byte *isha = sha384_final(&ctx->ictx);
+
+  /* Finish the outer digest */
+  sha384_update(&ctx->octx, isha, SHA384_SIZE);
+  return sha384_final(&ctx->octx);
+}
diff --git a/lib/sha512.h b/lib/sha512.h
new file mode 100644
index 00000000..bd998152
--- /dev/null
+++ b/lib/sha512.h
@@ -0,0 +1,73 @@
+/*
+ *	BIRD Library -- SHA-512 and SHA-384 Hash Functions,
+ *			HMAC-SHA-512 and HMAC-SHA-384 Functions
+ *
+ *	(c) 2015 CZ.NIC z.s.p.o.
+ *
+ *	Based on the code from libgcrypt-1.6.0, which is
+ *	(c) 2003, 2006, 2008, 2009 Free Software Foundation, Inc.
+ *
+ *	Can be freely distributed and used under the terms of the GNU GPL.
+ */
+
+#ifndef _BIRD_SHA512_H_
+#define _BIRD_SHA512_H_
+
+#include "lib/sha256.h"
+
+#define SHA384_SIZE 		48
+#define SHA384_HEX_SIZE		97
+#define SHA384_BLOCK_SIZE	128
+
+#define SHA512_SIZE 		64
+#define SHA512_HEX_SIZE		129
+#define SHA512_BLOCK_SIZE	128
+
+struct sha512_state
+{
+  u64 h0, h1, h2, h3, h4, h5, h6, h7;
+};
+
+struct sha512_context
+{
+  struct sha256_context bctx;
+  struct sha512_state state;
+};
+#define sha384_context sha512_context	/* aliasing 'struct sha384_context' to 'struct sha512_context' */
+
+
+void sha512_init(struct sha512_context *ctx);
+void sha384_init(struct sha384_context *ctx);
+
+void sha512_update(struct sha512_context *ctx, const byte *in_buf, size_t in_len);
+static inline void sha384_update(struct sha384_context *ctx, const byte *in_buf, size_t in_len)
+{
+  sha512_update(ctx, in_buf, in_len);
+}
+
+byte* sha512_final(struct sha512_context *ctx);
+static inline byte* sha384_final(struct sha384_context *ctx)
+{
+  return sha512_final(ctx);
+}
+
+/*
+ *	HMAC-SHA512, HMAC-SHA384
+ */
+struct sha512_hmac_context
+{
+  struct sha512_context ictx;
+  struct sha512_context octx;
+} ;
+#define sha384_hmac_context sha512_hmac_context	/* aliasing 'struct sha384_hmac_context' to 'struct sha384_hmac_context' */
+
+void sha512_hmac_init(struct sha512_hmac_context *ctx, const byte *key, size_t keylen);
+void sha384_hmac_init(struct sha384_hmac_context *ctx, const byte *key, size_t keylen);
+
+void sha512_hmac_update(struct sha512_hmac_context *ctx, const byte *buf, size_t buflen);
+void sha384_hmac_update(struct sha384_hmac_context *ctx, const byte *buf, size_t buflen);
+
+byte *sha512_hmac_final(struct sha512_hmac_context *ctx);
+byte *sha384_hmac_final(struct sha384_hmac_context *ctx);
+
+#endif /* _BIRD_SHA512_H_ */

From 1e4891e48e7b6f022564e7409d15c3fdb65ec2ad Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Mon, 23 Nov 2015 11:13:40 +0100
Subject: [PATCH 040/165] Nest: Fix bug in device proto

If an interface address notification is received during device protocol
shutdown/restart, BIRD crashed.

Thanks to Wei Huang for the bugreport.
---
 sysdep/linux/netlink.c | 6 ++++--
 sysdep/unix/krt.c      | 2 +-
 sysdep/unix/krt.h      | 2 ++
 3 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/sysdep/linux/netlink.c b/sysdep/linux/netlink.c
index f2f60100..efbf41a6 100644
--- a/sysdep/linux/netlink.c
+++ b/sysdep/linux/netlink.c
@@ -1116,12 +1116,14 @@ nl_async_msg(struct nlmsghdr *h)
     case RTM_NEWLINK:
     case RTM_DELLINK:
       DBG("KRT: Received async link notification (%d)\n", h->nlmsg_type);
-      nl_parse_link(h, 0);
+      if (kif_proto)
+	nl_parse_link(h, 0);
       break;
     case RTM_NEWADDR:
     case RTM_DELADDR:
       DBG("KRT: Received async address notification (%d)\n", h->nlmsg_type);
-      nl_parse_addr(h, 0);
+      if (kif_proto)
+	nl_parse_addr(h, 0);
       break;
     default:
       DBG("KRT: Received unknown async notification (%d)\n", h->nlmsg_type);
diff --git a/sysdep/unix/krt.c b/sysdep/unix/krt.c
index 49bf9519..5e78586b 100644
--- a/sysdep/unix/krt.c
+++ b/sysdep/unix/krt.c
@@ -84,8 +84,8 @@ krt_io_init(void)
  *	Interfaces
  */
 
+struct kif_proto *kif_proto;
 static struct kif_config *kif_cf;
-static struct kif_proto *kif_proto;
 static timer *kif_scan_timer;
 static bird_clock_t kif_last_shot;
 
diff --git a/sysdep/unix/krt.h b/sysdep/unix/krt.h
index aea20102..d4a8717e 100644
--- a/sysdep/unix/krt.h
+++ b/sysdep/unix/krt.h
@@ -112,6 +112,8 @@ struct kif_proto {
   struct kif_state sys;		/* Sysdep state */
 };
 
+struct kif_proto *kif_proto;
+
 #define KIF_CF ((struct kif_config *)p->p.cf)
 
 struct proto_config * krt_init_config(int class);

From 5126380beace4e39578f005fe115917b8e8b8ff3 Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Tue, 24 Nov 2015 13:47:28 +0100
Subject: [PATCH 041/165] Minor changes to SHA hash functions

---
 lib/birdlib.h |   1 +
 lib/sha1.c    | 176 +++++++++--------
 lib/sha1.h    |  72 +++----
 lib/sha256.c  | 176 ++++++++---------
 lib/sha256.h  |  42 ++--
 lib/sha512.c  | 528 +++++++++++++++++++++++++-------------------------
 lib/sha512.h  |  42 ++--
 7 files changed, 517 insertions(+), 520 deletions(-)

diff --git a/lib/birdlib.h b/lib/birdlib.h
index ad41dca3..16f437ef 100644
--- a/lib/birdlib.h
+++ b/lib/birdlib.h
@@ -30,6 +30,7 @@
 #define MAX(a,b) MAX_(a,b)
 #endif
 
+#define U64(c) UINT64_C(c)
 #define ABS(a)   ((a)>=0 ? (a) : -(a))
 #define DELTA(a,b) (((a)>=(b))?(a)-(b):(b)-(a))
 #define ARRAY_SIZE(a) (sizeof(a)/sizeof(*(a)))
diff --git a/lib/sha1.c b/lib/sha1.c
index dd29b5fd..73b4b280 100644
--- a/lib/sha1.c
+++ b/lib/sha1.c
@@ -15,33 +15,35 @@
 #include "lib/sha1.h"
 #include "lib/unaligned.h"
 
+
 void
-sha1_init(struct sha1_context *hd)
+sha1_init(struct sha1_context *ctx)
 {
-  hd->h0 = 0x67452301;
-  hd->h1 = 0xefcdab89;
-  hd->h2 = 0x98badcfe;
-  hd->h3 = 0x10325476;
-  hd->h4 = 0xc3d2e1f0;
-  hd->nblocks = 0;
-  hd->count = 0;
+  ctx->h0 = 0x67452301;
+  ctx->h1 = 0xefcdab89;
+  ctx->h2 = 0x98badcfe;
+  ctx->h3 = 0x10325476;
+  ctx->h4 = 0xc3d2e1f0;
+
+  ctx->nblocks = 0;
+  ctx->count = 0;
 }
 
 /*
  * Transform the message X which consists of 16 32-bit-words
  */
 static void
-sha1_transform(struct sha1_context *hd, const byte *data)
+sha1_transform(struct sha1_context *ctx, const byte *data)
 {
   u32 a,b,c,d,e,tm;
   u32 x[16];
 
   /* Get values from the chaining vars. */
-  a = hd->h0;
-  b = hd->h1;
-  c = hd->h2;
-  d = hd->h3;
-  e = hd->h4;
+  a = ctx->h0;
+  b = ctx->h1;
+  c = ctx->h2;
+  d = ctx->h3;
+  e = ctx->h4;
 
 #ifdef CPU_BIG_ENDIAN
   memcpy(x, data, 64);
@@ -69,7 +71,7 @@ sha1_transform(struct sha1_context *hd, const byte *data)
     do 						\
     {						\
       e += ROL(a, 5) + f(b, c, d) + k + m;	\
-      b = ROL( b, 30 );				\
+      b = ROL(b, 30);				\
     } while(0)
 
   R( a, b, c, d, e, F1, K1, x[ 0] );
@@ -154,72 +156,72 @@ sha1_transform(struct sha1_context *hd, const byte *data)
   R( b, c, d, e, a, F4, K4, M(79) );
 
   /* Update chaining vars. */
-  hd->h0 += a;
-  hd->h1 += b;
-  hd->h2 += c;
-  hd->h3 += d;
-  hd->h4 += e;
+  ctx->h0 += a;
+  ctx->h1 += b;
+  ctx->h2 += c;
+  ctx->h3 += d;
+  ctx->h4 += e;
 }
 
 /*
- * Update the message digest with the contents
- * of INBUF with length INLEN.
+ * Update the message digest with the contents of BUF with length LEN.
  */
 void
-sha1_update(struct sha1_context *hd, const byte *inbuf, uint inlen)
+sha1_update(struct sha1_context *ctx, const byte *buf, uint len)
 {
-  if (hd->count == 64)  /* flush the buffer */
+  if (ctx->count)
   {
-    sha1_transform(hd, hd->buf);
-    hd->count = 0;
-    hd->nblocks++;
-  }
-  if (!inbuf)
-    return;
+    /* Fill rest of internal buffer */
+    for (; len && ctx->count < SHA1_BLOCK_SIZE; len--)
+      ctx->buf[ctx->count++] = *buf++;
 
-  if (hd->count)
-  {
-    for (; inlen && hd->count < 64; inlen--)
-      hd->buf[hd->count++] = *inbuf++;
-    sha1_update( hd, NULL, 0 );
-    if(!inlen)
+    if (ctx->count < SHA1_BLOCK_SIZE)
       return;
+
+    /* Process data from internal buffer */
+    sha1_transform(ctx, ctx->buf);
+    ctx->nblocks++;
+    ctx->count = 0;
   }
 
-  while (inlen >= 64)
+  if (!len)
+    return;
+
+  /* Process data from input buffer */
+  while (len >= SHA1_BLOCK_SIZE)
   {
-    sha1_transform(hd, inbuf);
-    hd->count = 0;
-    hd->nblocks++;
-    inlen -= 64;
-    inbuf += 64;
+    sha1_transform(ctx, buf);
+    ctx->nblocks++;
+    buf += SHA1_BLOCK_SIZE;
+    len -= SHA1_BLOCK_SIZE;
   }
-  for (; inlen && hd->count < 64; inlen--)
-    hd->buf[hd->count++] = *inbuf++;
+
+  /* Copy remaining data to internal buffer */
+  memcpy(ctx->buf, buf, len);
+  ctx->count = len;
 }
 
 /*
- * The routine final terminates the computation and
- * returns the digest.
- * The handle is prepared for a new cycle, but adding bytes to the
- * handle will the destroy the returned buffer.
+ * The routine final terminates the computation and returns the digest. The
+ * handle is prepared for a new cycle, but adding bytes to the handle will the
+ * destroy the returned buffer.
+ *
  * Returns: 20 bytes representing the digest.
  */
 byte *
-sha1_final(struct sha1_context *hd)
+sha1_final(struct sha1_context *ctx)
 {
   u32 t, msb, lsb;
-  u32 *p;
 
-  sha1_update(hd, NULL, 0); /* flush */;
+  sha1_update(ctx, NULL, 0);	/* flush */
 
-  t = hd->nblocks;
+  t = ctx->nblocks;
   /* multiply by 64 to make a byte count */
   lsb = t << 6;
   msb = t >> 26;
   /* add the count */
   t = lsb;
-  if ((lsb += hd->count) < t)
+  if ((lsb += ctx->count) < t)
     msb++;
   /* multiply by 8 to make a bit count */
   t = lsb;
@@ -227,33 +229,36 @@ sha1_final(struct sha1_context *hd)
   msb <<= 3;
   msb |= t >> 29;
 
-  if (hd->count < 56)  /* enough room */
+  if (ctx->count < 56)
   {
-    hd->buf[hd->count++] = 0x80; /* pad */
-    while (hd->count < 56)
-      hd->buf[hd->count++] = 0;  /* pad */
+    /* enough room */
+    ctx->buf[ctx->count++] = 0x80; /* pad */
+    while (ctx->count < 56)
+      ctx->buf[ctx->count++] = 0;  /* pad */
   }
-  else  /* need one extra block */
+  else
   {
-    hd->buf[hd->count++] = 0x80; /* pad character */
-    while (hd->count < 64)
-      hd->buf[hd->count++] = 0;
-    sha1_update(hd, NULL, 0);  /* flush */;
-    memset(hd->buf, 0, 56 ); /* fill next block with zeroes */
+    /* need one extra block */
+    ctx->buf[ctx->count++] = 0x80; /* pad character */
+    while (ctx->count < 64)
+      ctx->buf[ctx->count++] = 0;
+    sha1_update(ctx, NULL, 0);	/* flush */
+    memset(ctx->buf, 0, 56); /* fill next block with zeroes */
   }
+
   /* append the 64 bit count */
-  hd->buf[56] = msb >> 24;
-  hd->buf[57] = msb >> 16;
-  hd->buf[58] = msb >>  8;
-  hd->buf[59] = msb	   ;
-  hd->buf[60] = lsb >> 24;
-  hd->buf[61] = lsb >> 16;
-  hd->buf[62] = lsb >>  8;
-  hd->buf[63] = lsb	   ;
-  sha1_transform(hd, hd->buf);
-
-  p = (u32*) hd->buf;
-#define X(a) do { put_u32(p, hd->h##a); p++; } while(0)
+  ctx->buf[56] = msb >> 24;
+  ctx->buf[57] = msb >> 16;
+  ctx->buf[58] = msb >>  8;
+  ctx->buf[59] = msb;
+  ctx->buf[60] = lsb >> 24;
+  ctx->buf[61] = lsb >> 16;
+  ctx->buf[62] = lsb >>  8;
+  ctx->buf[63] = lsb;
+  sha1_transform(ctx, ctx->buf);
+
+  byte *p = ctx->buf;
+#define X(a) do { put_u32(p, ctx->h##a); p += 4; } while(0)
   X(0);
   X(1);
   X(2);
@@ -261,12 +266,12 @@ sha1_final(struct sha1_context *hd)
   X(4);
 #undef X
 
-  return hd->buf;
+  return ctx->buf;
 }
 
 
 /*
- * 	SHA1-HMAC
+ *	SHA1-HMAC
  */
 
 /*
@@ -292,12 +297,12 @@ sha1_hmac_init(struct sha1_hmac_context *ctx, const byte *key, uint keylen)
   if (keylen <= SHA1_BLOCK_SIZE)
   {
     memcpy(keybuf, key, keylen);
-    bzero(keybuf + keylen, SHA1_BLOCK_SIZE - keylen);
+    memset(keybuf + keylen, 0, SHA1_BLOCK_SIZE - keylen);
   }
   else
   {
     sha1_hash_buffer(keybuf, key, keylen);
-    bzero(keybuf + SHA1_SIZE, SHA1_BLOCK_SIZE - SHA1_SIZE);
+    memset(keybuf + SHA1_SIZE, 0, SHA1_BLOCK_SIZE - SHA1_SIZE);
   }
 
   /* Initialize the inner digest */
@@ -321,7 +326,8 @@ sha1_hmac_update(struct sha1_hmac_context *ctx, const byte *data, uint datalen)
   sha1_update(&ctx->ictx, data, datalen);
 }
 
-byte *sha1_hmac_final(struct sha1_hmac_context *ctx)
+byte *
+sha1_hmac_final(struct sha1_hmac_context *ctx)
 {
   /* Finish the inner digest */
   byte *isha = sha1_final(&ctx->ictx);
@@ -334,9 +340,9 @@ byte *sha1_hmac_final(struct sha1_hmac_context *ctx)
 void
 sha1_hmac(byte *outbuf, const byte *key, uint keylen, const byte *data, uint datalen)
 {
-  struct sha1_hmac_context hd;
-  sha1_hmac_init(&hd, key, keylen);
-  sha1_hmac_update(&hd, data, datalen);
-  byte *osha = sha1_hmac_final(&hd);
-  memcpy(outbuf, osha, SHA1_SIZE);
+  struct sha1_hmac_context ctx;
+
+  sha1_hmac_init(&ctx, key, keylen);
+  sha1_hmac_update(&ctx, data, datalen);
+  memcpy(outbuf, sha1_hmac_final(&ctx), SHA1_SIZE);
 }
diff --git a/lib/sha1.h b/lib/sha1.h
index 425160a0..c019bb49 100644
--- a/lib/sha1.h
+++ b/lib/sha1.h
@@ -17,70 +17,70 @@
 
 #include "nest/bird.h"
 
+
+#define SHA1_SIZE		20	/* Size of the SHA1 hash in its binary representation */
+#define SHA1_HEX_SIZE		41	/* Buffer length for a string containing SHA1 in hexadecimal format. */
+#define SHA1_BLOCK_SIZE		64	/* SHA1 splits input to blocks of this size. */
+
+
 /*
  * Internal SHA1 state.
  * You should use it just as an opaque handle only.
  */
 struct sha1_context {
-  u32 h0,h1,h2,h3,h4;
-  u32 nblocks;
-  byte buf[64];
-  int count;
-} ;
+  u32 h0, h1, h2, h3, h4;
+  byte buf[SHA1_BLOCK_SIZE];
+  uint nblocks;
+  uint count;
+};
+
 
-void sha1_init(struct sha1_context *hd); /* Initialize new algorithm run in the @hd context. **/
+void sha1_init(struct sha1_context *ctx); /* Initialize new algorithm run in the @ctx context. **/
 /*
- * Push another @inlen bytes of data pointed to by @inbuf onto the
- * SHA1 hash currently in @hd. You can call this any times you want on
- * the same hash (and you do not need to reinitialize it by
- * @sha1_init()). It has the same effect as concatenating all the data
- * together and passing them at once.
+ * Push another @len bytes of data pointed to by @buf onto the SHA1 hash
+ * currently in @ctx. You can call this any times you want on the same hash (and
+ * you do not need to reinitialize it by @sha1_init()). It has the same effect
+ * as concatenating all the data together and passing them at once.
  */
-void sha1_update(struct sha1_context *hd, const byte *inbuf, uint inlen);
+void sha1_update(struct sha1_context *ctx, const byte *buf, uint len);
 /*
- * No more @sha1_update() calls will be done. This terminates the hash
- * and returns a pointer to it.
- *
- * Note that the pointer points into data in the @hd context. If it ceases
- * to exist, the pointer becomes invalid.
+ * No more @sha1_update() calls will be done. This terminates the hash and
+ * returns a pointer to it.
  *
- * To convert the hash to its usual hexadecimal representation, see
- * <<string:mem_to_hex()>>.
+ * Note that the pointer points into data in the @ctx context. If it ceases to
+ * exist, the pointer becomes invalid.
  */
-byte *sha1_final(struct sha1_context *hd);
+byte *sha1_final(struct sha1_context *ctx);
 
 /*
- * A convenience one-shot function for SHA1 hash.
- * It is equivalent to this snippet of code:
+ * A convenience one-shot function for SHA1 hash. It is equivalent to this
+ * snippet of code:
  *
- *  sha1_context hd;
- *  sha1_init(&hd);
- *  sha1_update(&hd, buffer, length);
- *  memcpy(outbuf, sha1_final(&hd), SHA1_SIZE);
+ *  sha1_context ctx;
+ *  sha1_init(&ctx);
+ *  sha1_update(&ctx, buffer, length);
+ *  memcpy(outbuf, sha1_final(&ctx), SHA1_SIZE);
  */
 void sha1_hash_buffer(byte *outbuf, const byte *buffer, uint length);
 
 /*
- * SHA1 HMAC message authentication. If you provide @key and @data,
- * the result will be stored in @outbuf.
+ * SHA1 HMAC message authentication. If you provide @key and @data, the result
+ * will be stored in @outbuf.
  */
 void sha1_hmac(byte *outbuf, const byte *key, uint keylen, const byte *data, uint datalen);
 
 /*
- * The HMAC also exists in a stream version in a way analogous to the
- * plain SHA1. Pass this as a context.
+ * The HMAC also exists in a stream version in a way analogous to the plain
+ * SHA1. Pass this as a context.
  */
 struct sha1_hmac_context {
   struct sha1_context ictx;
   struct sha1_context octx;
 };
 
-void sha1_hmac_init(struct sha1_hmac_context *hd, const byte *key, uint keylen);	/* Initialize HMAC with context @hd and the given key. See sha1_init(). */
-void sha1_hmac_update(struct sha1_hmac_context *hd, const byte *data, uint datalen);	/* Hash another @datalen bytes of data. See sha1_update(). */
-byte *sha1_hmac_final(struct sha1_hmac_context *hd);					/* Terminate the HMAC and return a pointer to the allocated hash. See sha1_final(). */
+void sha1_hmac_init(struct sha1_hmac_context *ctx, const byte *key, uint keylen);	/* Initialize HMAC with context @ctx and the given key. See sha1_init(). */
+void sha1_hmac_update(struct sha1_hmac_context *ctx, const byte *data, uint datalen);	/* Hash another @datalen bytes of data. See sha1_update(). */
+byte *sha1_hmac_final(struct sha1_hmac_context *ctx);					/* Terminate the HMAC and return a pointer to the allocated hash. See sha1_final(). */
 
-#define SHA1_SIZE 20 		/* Size of the SHA1 hash in its binary representation **/
-#define SHA1_HEX_SIZE 41 	/* Buffer length for a string containing SHA1 in hexadecimal format. **/
-#define SHA1_BLOCK_SIZE 64 	/* SHA1 splits input to blocks of this size. **/
 
 #endif /* _BIRD_SHA1_H_ */
diff --git a/lib/sha256.c b/lib/sha256.c
index 2d979f90..440245d5 100644
--- a/lib/sha256.c
+++ b/lib/sha256.c
@@ -13,7 +13,8 @@
 #include "lib/sha256.h"
 #include "lib/unaligned.h"
 
-static uint sha256_transform(void *ctx, const byte *data, size_t nblks);
+
+// #define SHA256_UNROLLED
 
 void
 sha256_init(struct sha256_context *ctx)
@@ -28,10 +29,7 @@ sha256_init(struct sha256_context *ctx)
   ctx->h7 = 0x5be0cd19;
 
   ctx->nblocks = 0;
-  ctx->nblocks_high = 0;
   ctx->count = 0;
-  ctx->blocksize = 64;
-  ctx->transform = sha256_transform;
 }
 
 void
@@ -47,10 +45,7 @@ sha224_init(struct sha224_context *ctx)
   ctx->h7 = 0xbefa4fa4;
 
   ctx->nblocks = 0;
-  ctx->nblocks_high = 0;
   ctx->count = 0;
-  ctx->blocksize = 64;
-  ctx->transform = sha256_transform;
 }
 
 /* (4.2) same as SHA-1's F1.  */
@@ -70,7 +65,7 @@ f3(u32 x, u32 y, u32 z)
 /* Bitwise rotation of an uint to the right */
 static inline u32 ror(u32 x, int n)
 {
-  return ( (x >> (n&(32-1))) | (x << ((32-n)&(32-1))) );
+  return ((x >> (n&(32-1))) | (x << ((32-n)&(32-1))));
 }
 
 /* (4.4) */
@@ -112,7 +107,7 @@ sum1(u32 x)
     32-bit-words. See FIPS 180-2 for details.
  */
 static uint
-sha256_transform_block(struct sha256_context *ctx, const byte *data)
+sha256_transform(struct sha256_context *ctx, const byte *data)
 {
   static const u32 K[64] = {
       0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
@@ -148,52 +143,58 @@ sha256_transform_block(struct sha256_context *ctx, const byte *data)
 
   for (i = 0; i < 16; i++)
     w[i] = get_u32(data + i * 4);
+
   for (; i < 64; i++)
     w[i] = S1(w[i-2]) + w[i-7] + S0(w[i-15]) + w[i-16];
 
   for (i = 0; i < 64;)
   {
+#ifndef SHA256_UNROLLED
+    R(a,b,c,d,e,f,g,h,K[i],w[i]);
+    i++;
+#else /* Unrolled */
     t1 = h + sum1(e) + f1(e, f, g) + K[i] + w[i];
-    t2 = sum0 (a) + f3(a, b, c);
+    t2 = sum0(a) + f3(a, b, c);
     d += t1;
     h  = t1 + t2;
 
     t1 = g + sum1(d) + f1(d, e, f) + K[i+1] + w[i+1];
-    t2 = sum0 (h) + f3(h, a, b);
+    t2 = sum0(h) + f3(h, a, b);
     c += t1;
     g  = t1 + t2;
 
     t1 = f + sum1(c) + f1(c, d, e) + K[i+2] + w[i+2];
-    t2 = sum0 (g) + f3(g, h, a);
+    t2 = sum0(g) + f3(g, h, a);
     b += t1;
     f  = t1 + t2;
 
     t1 = e + sum1(b) + f1(b, c, d) + K[i+3] + w[i+3];
-    t2 = sum0 (f) + f3(f, g, h);
+    t2 = sum0(f) + f3(f, g, h);
     a += t1;
     e  = t1 + t2;
 
     t1 = d + sum1(a) + f1(a, b, c) + K[i+4] + w[i+4];
-    t2 = sum0 (e) + f3(e, f, g);
+    t2 = sum0(e) + f3(e, f, g);
     h += t1;
     d  = t1 + t2;
 
     t1 = c + sum1(h) + f1(h, a, b) + K[i+5] + w[i+5];
-    t2 = sum0 (d) + f3(d, e, f);
+    t2 = sum0(d) + f3(d, e, f);
     g += t1;
     c  = t1 + t2;
 
     t1 = b + sum1(g) + f1(g, h, a) + K[i+6] + w[i+6];
-    t2 = sum0 (c) + f3(c, d, e);
+    t2 = sum0(c) + f3(c, d, e);
     f += t1;
     b  = t1 + t2;
 
     t1 = a + sum1(f) + f1(f, g, h) + K[i+7] + w[i+7];
-    t2 = sum0 (b) + f3(b, c, d);
+    t2 = sum0(b) + f3(b, c, d);
     e += t1;
     a  = t1 + t2;
 
     i += 8;
+#endif
   }
 
   ctx->h0 += a;
@@ -211,22 +212,6 @@ sha256_transform_block(struct sha256_context *ctx, const byte *data)
 #undef S1
 #undef R
 
-static uint
-sha256_transform(void *ctx, const byte *data, size_t nblks)
-{
-  struct sha256_context *hd = ctx;
-  uint burn;
-
-  do
-  {
-    burn = sha256_transform_block(hd, data);
-    data += 64;
-  }
-  while (--nblks);
-
-  return burn;
-}
-
 /* Common function to write a chunk of data to the transform function
    of a hash algorithm.  Note that the use of the term "block" does
    not imply a fixed size block.  Note that we explicitly allow to use
@@ -234,65 +219,56 @@ sha256_transform(void *ctx, const byte *data, size_t nblks)
    not have any meaning but writing after finalize is sometimes
    helpful to mitigate timing attacks. */
 void
-sha256_update(struct sha256_context *ctx, const byte *in_buf, size_t in_len)
+sha256_update(struct sha256_context *ctx, const byte *buf, size_t len)
 {
-  const uint blocksize = ctx->blocksize;
-  size_t inblocks;
+  if (ctx->count)
+  {
+    /* Fill rest of internal buffer */
+    for (; len && ctx->count < SHA256_BLOCK_SIZE; len--)
+      ctx->buf[ctx->count++] = *buf++;
 
-  if (sizeof(ctx->buf) < blocksize)
-    debug("BUG: in file %s at line %d", __FILE__ , __LINE__);
+    if (ctx->count < SHA256_BLOCK_SIZE)
+      return;
 
-  if (ctx->count == blocksize)  /* Flush the buffer. */
-  {
-    ctx->transform(ctx, ctx->buf, 1);
+    /* Process data from internal buffer */
+    sha256_transform(ctx, ctx->buf);
+    ctx->nblocks++;
     ctx->count = 0;
-    if (!++ctx->nblocks)
-      ctx->nblocks_high++;
   }
-  if (!in_buf)
+
+  if (!len)
     return;
 
-  if (ctx->count)
+  /* Process data from input buffer */
+  while (len >= SHA256_BLOCK_SIZE)
   {
-    for (; in_len && ctx->count < blocksize; in_len--)
-      ctx->buf[ctx->count++] = *in_buf++;
-    sha256_update(ctx, NULL, 0);
-    if (!in_len)
-      return;
+    sha256_transform(ctx, buf);
+    ctx->nblocks++;
+    buf += SHA256_BLOCK_SIZE;
+    len -= SHA256_BLOCK_SIZE;
   }
 
-  if (in_len >= blocksize)
-  {
-    inblocks = in_len / blocksize;
-    ctx->transform(ctx, in_buf, inblocks);
-    ctx->count = 0;
-    ctx->nblocks_high += (ctx->nblocks + inblocks < inblocks);
-    ctx->nblocks += inblocks;
-    in_len -= inblocks * blocksize;
-    in_buf += inblocks * blocksize;
-  }
-  for (; in_len && ctx->count < blocksize; in_len--)
-    ctx->buf[ctx->count++] = *in_buf++;
+  /* Copy remaining data to internal buffer */
+  memcpy(ctx->buf, buf, len);
+  ctx->count = len;
 }
 
 /*
-   The routine finally terminates the computation and returns the
-   digest.  The handle is prepared for a new cycle, but adding bytes
-   to the handle will the destroy the returned buffer.  Returns: 32
-   bytes with the message the digest.  */
-byte*
+ * The routine finally terminates the computation and returns the digest.  The
+ * handle is prepared for a new cycle, but adding bytes to the handle will the
+ * destroy the returned buffer.
+ *
+ * Returns: 32 bytes with the message the digest. 28 bytes for SHA-224.
+ */
+byte *
 sha256_final(struct sha256_context *ctx)
 {
   u32 t, th, msb, lsb;
-  byte *p;
 
-  sha256_update(ctx, NULL, 0); /* flush */;
+  sha256_update(ctx, NULL, 0);	/* flush */
 
   t = ctx->nblocks;
-  if (sizeof t == sizeof ctx->nblocks)
-    th = ctx->nblocks_high;
-  else
-    th = 0;
+  th = 0;
 
   /* multiply by 64 to make a byte count */
   lsb = t << 6;
@@ -308,26 +284,28 @@ sha256_final(struct sha256_context *ctx)
   msb |= t >> 29;
 
   if (ctx->count < 56)
-  { /* enough room */
+  {
+    /* enough room */
     ctx->buf[ctx->count++] = 0x80; /* pad */
     while (ctx->count < 56)
       ctx->buf[ctx->count++] = 0;  /* pad */
   }
   else
-  { /* need one extra block */
+  {
+    /* need one extra block */
     ctx->buf[ctx->count++] = 0x80; /* pad character */
     while (ctx->count < 64)
       ctx->buf[ctx->count++] = 0;
     sha256_update(ctx, NULL, 0);  /* flush */;
-    memset (ctx->buf, 0, 56 ); /* fill next block with zeroes */
+    memset(ctx->buf, 0, 56 ); /* fill next block with zeroes */
   }
+
   /* append the 64 bit count */
   put_u32(ctx->buf + 56, msb);
   put_u32(ctx->buf + 60, lsb);
-  sha256_transform(ctx, ctx->buf, 1);
-
-  p = ctx->buf;
+  sha256_transform(ctx, ctx->buf);
 
+  byte *p = ctx->buf;
 #define X(a) do { put_u32(p, ctx->h##a); p += 4; } while(0)
   X(0);
   X(1);
@@ -344,17 +322,17 @@ sha256_final(struct sha256_context *ctx)
 
 
 /*
- * 	SHA256-HMAC
+ *	SHA256-HMAC
  */
 
 static void
 sha256_hash_buffer(byte *outbuf, const byte *buffer, size_t length)
 {
-  struct sha256_context hd_tmp;
+  struct sha256_context ctx;
 
-  sha256_init(&hd_tmp);
-  sha256_update(&hd_tmp, buffer, length);
-  memcpy(outbuf, sha256_final(&hd_tmp), SHA256_SIZE);
+  sha256_init(&ctx);
+  sha256_update(&ctx, buffer, length);
+  memcpy(outbuf, sha256_final(&ctx), SHA256_SIZE);
 }
 
 void
@@ -366,12 +344,12 @@ sha256_hmac_init(struct sha256_hmac_context *ctx, const byte *key, size_t keylen
   if (keylen <= SHA256_BLOCK_SIZE)
   {
     memcpy(keybuf, key, keylen);
-    bzero(keybuf + keylen, SHA256_BLOCK_SIZE - keylen);
+    memset(keybuf + keylen, 0, SHA256_BLOCK_SIZE - keylen);
   }
   else
   {
     sha256_hash_buffer(keybuf, key, keylen);
-    bzero(keybuf + SHA256_SIZE, SHA256_BLOCK_SIZE - SHA256_SIZE);
+    memset(keybuf + SHA256_SIZE, 0, SHA256_BLOCK_SIZE - SHA256_SIZE);
   }
 
   /* Initialize the inner digest */
@@ -388,13 +366,15 @@ sha256_hmac_init(struct sha256_hmac_context *ctx, const byte *key, size_t keylen
   sha256_update(&ctx->octx, buf, SHA256_BLOCK_SIZE);
 }
 
-void sha256_hmac_update(struct sha256_hmac_context *ctx, const byte *buf, size_t buflen)
+void
+sha256_hmac_update(struct sha256_hmac_context *ctx, const byte *buf, size_t buflen)
 {
   /* Just update the inner digest */
   sha256_update(&ctx->ictx, buf, buflen);
 }
 
-byte *sha256_hmac_final(struct sha256_hmac_context *ctx)
+byte *
+sha256_hmac_final(struct sha256_hmac_context *ctx)
 {
   /* Finish the inner digest */
   byte *isha = sha256_final(&ctx->ictx);
@@ -406,17 +386,17 @@ byte *sha256_hmac_final(struct sha256_hmac_context *ctx)
 
 
 /*
- * 	SHA224-HMAC
+ *	SHA224-HMAC
  */
 
 static void
 sha224_hash_buffer(byte *outbuf, const byte *buffer, size_t length)
 {
-  struct sha224_context hd_tmp;
+  struct sha224_context ctx;
 
-  sha224_init(&hd_tmp);
-  sha224_update(&hd_tmp, buffer, length);
-  memcpy(outbuf, sha224_final(&hd_tmp), SHA224_SIZE);
+  sha224_init(&ctx);
+  sha224_update(&ctx, buffer, length);
+  memcpy(outbuf, sha224_final(&ctx), SHA224_SIZE);
 }
 
 void
@@ -428,12 +408,12 @@ sha224_hmac_init(struct sha224_hmac_context *ctx, const byte *key, size_t keylen
   if (keylen <= SHA224_BLOCK_SIZE)
   {
     memcpy(keybuf, key, keylen);
-    bzero(keybuf + keylen, SHA224_BLOCK_SIZE - keylen);
+    memset(keybuf + keylen, 0, SHA224_BLOCK_SIZE - keylen);
   }
   else
   {
     sha224_hash_buffer(keybuf, key, keylen);
-    bzero(keybuf + SHA224_SIZE, SHA224_BLOCK_SIZE - SHA224_SIZE);
+    memset(keybuf + SHA224_SIZE, 0, SHA224_BLOCK_SIZE - SHA224_SIZE);
   }
 
   /* Initialize the inner digest */
@@ -450,13 +430,15 @@ sha224_hmac_init(struct sha224_hmac_context *ctx, const byte *key, size_t keylen
   sha224_update(&ctx->octx, buf, SHA224_BLOCK_SIZE);
 }
 
-void sha224_hmac_update(struct sha224_hmac_context *ctx, const byte *buf, size_t buflen)
+void
+sha224_hmac_update(struct sha224_hmac_context *ctx, const byte *buf, size_t buflen)
 {
   /* Just update the inner digest */
   sha256_update(&ctx->ictx, buf, buflen);
 }
 
-byte *sha224_hmac_final(struct sha224_hmac_context *ctx)
+byte *
+sha224_hmac_final(struct sha224_hmac_context *ctx)
 {
   /* Finish the inner digest */
   byte *isha = sha224_final(&ctx->ictx);
diff --git a/lib/sha256.h b/lib/sha256.h
index 848d2176..381200a9 100644
--- a/lib/sha256.h
+++ b/lib/sha256.h
@@ -15,6 +15,7 @@
 
 #include "nest/bird.h"
 
+
 #define SHA224_SIZE 		28
 #define SHA224_HEX_SIZE		57
 #define SHA224_BLOCK_SIZE 	64
@@ -23,44 +24,44 @@
 #define SHA256_HEX_SIZE		65
 #define SHA256_BLOCK_SIZE 	64
 
+
 struct sha256_context {
-  u32  h0,h1,h2,h3,h4,h5,h6,h7;
-  byte buf[128];			/* 128 is for SHA384 and SHA512 support, otherwise for SHA224 and SHA256 is 64 enough */
-  u32 nblocks;
-  u32 nblocks_high;
-  int count;
-  u32 blocksize;
-  uint (*transform)(void *c, const byte *blks, size_t nblks);
+  u32  h0, h1, h2, h3, h4, h5, h6, h7;
+  byte buf[SHA256_BLOCK_SIZE];
+  uint nblocks;
+  uint count;
 };
-#define sha224_context sha256_context	/* aliasing 'struct sha224_context' to 'struct sha256_context' */
+
+#define sha224_context sha256_context
+
 
 void sha256_init(struct sha256_context *ctx);
 void sha224_init(struct sha224_context *ctx);
 
-void sha256_update(struct sha256_context *ctx, const byte *in_buf, size_t in_len);
-static inline void sha224_update(struct sha224_context *ctx, const byte *in_buf, size_t in_len)
-{
-  sha256_update(ctx, in_buf, in_len);
-}
+void sha256_update(struct sha256_context *ctx, const byte *buf, size_t len);
+static inline void sha224_update(struct sha224_context *ctx, const byte *buf, size_t len)
+{ sha256_update(ctx, buf, len); }
+
+byte *sha256_final(struct sha256_context *ctx);
+static inline byte *sha224_final(struct sha224_context *ctx)
+{ return sha256_final(ctx); }
 
-byte* sha256_final(struct sha256_context *ctx);
-static inline byte* sha224_final(struct sha224_context *ctx)
-{
-  return sha256_final(ctx);
-}
 
 /*
  *	HMAC-SHA256, HMAC-SHA224
  */
+
 struct sha256_hmac_context
 {
   struct sha256_context ictx;
   struct sha256_context octx;
 };
-#define sha224_hmac_context sha256_hmac_context	/* aliasing 'struct sha224_hmac_context' to 'struct sha256_hmac_context' */
+
+#define sha224_hmac_context sha256_hmac_context
+
 
 void sha256_hmac_init(struct sha256_hmac_context *ctx, const byte *key, size_t keylen);
-void sha224_hmac_init(struct sha224_hmac_context *ctx, const byte *key,  size_t keylen);
+void sha224_hmac_init(struct sha224_hmac_context *ctx, const byte *key, size_t keylen);
 
 void sha256_hmac_update(struct sha256_hmac_context *ctx, const byte *buf, size_t buflen);
 void sha224_hmac_update(struct sha224_hmac_context *ctx, const byte *buf, size_t buflen);
@@ -68,4 +69,5 @@ void sha224_hmac_update(struct sha224_hmac_context *ctx, const byte *buf, size_t
 byte *sha256_hmac_final(struct sha256_hmac_context *ctx);
 byte *sha224_hmac_final(struct sha224_hmac_context *ctx);
 
+
 #endif /* _BIRD_SHA256_H_ */
diff --git a/lib/sha512.c b/lib/sha512.c
index e46e4c98..37e660f7 100644
--- a/lib/sha512.c
+++ b/lib/sha512.c
@@ -10,57 +10,42 @@
  *	Can be freely distributed and used under the terms of the GNU GPL.
  */
 
-#include "lib/sha256.h"
 #include "lib/sha512.h"
 #include "lib/unaligned.h"
 
-static uint sha512_transform(void *context, const byte *data, size_t nblks);
+
+// #define SHA512_UNROLLED
 
 void
 sha512_init(struct sha512_context *ctx)
 {
-  struct sha512_state *hd = &ctx->state;
-
-  hd->h0 = UINT64_C(0x6a09e667f3bcc908);
-  hd->h1 = UINT64_C(0xbb67ae8584caa73b);
-  hd->h2 = UINT64_C(0x3c6ef372fe94f82b);
-  hd->h3 = UINT64_C(0xa54ff53a5f1d36f1);
-  hd->h4 = UINT64_C(0x510e527fade682d1);
-  hd->h5 = UINT64_C(0x9b05688c2b3e6c1f);
-  hd->h6 = UINT64_C(0x1f83d9abfb41bd6b);
-  hd->h7 = UINT64_C(0x5be0cd19137e2179);
-
-  ctx->bctx.nblocks = 0;
-  ctx->bctx.nblocks_high = 0;
-  ctx->bctx.count = 0;
-  ctx->bctx.blocksize = 128;
-  ctx->bctx.transform = sha512_transform;
+  ctx->h0 = U64(0x6a09e667f3bcc908);
+  ctx->h1 = U64(0xbb67ae8584caa73b);
+  ctx->h2 = U64(0x3c6ef372fe94f82b);
+  ctx->h3 = U64(0xa54ff53a5f1d36f1);
+  ctx->h4 = U64(0x510e527fade682d1);
+  ctx->h5 = U64(0x9b05688c2b3e6c1f);
+  ctx->h6 = U64(0x1f83d9abfb41bd6b);
+  ctx->h7 = U64(0x5be0cd19137e2179);
+
+  ctx->nblocks = 0;
+  ctx->count = 0;
 }
 
 void
 sha384_init(struct sha384_context *ctx)
 {
-  struct sha512_state *hd = &ctx->state;
-
-  hd->h0 = UINT64_C(0xcbbb9d5dc1059ed8);
-  hd->h1 = UINT64_C(0x629a292a367cd507);
-  hd->h2 = UINT64_C(0x9159015a3070dd17);
-  hd->h3 = UINT64_C(0x152fecd8f70e5939);
-  hd->h4 = UINT64_C(0x67332667ffc00b31);
-  hd->h5 = UINT64_C(0x8eb44a8768581511);
-  hd->h6 = UINT64_C(0xdb0c2e0d64f98fa7);
-  hd->h7 = UINT64_C(0x47b5481dbefa4fa4);
-
-  ctx->bctx.nblocks = 0;
-  ctx->bctx.nblocks_high = 0;
-  ctx->bctx.count = 0;
-  ctx->bctx.blocksize = 128;
-  ctx->bctx.transform = sha512_transform;
-}
-
-void sha512_update(struct sha512_context *ctx, const byte *in_buf, size_t in_len)
-{
-  sha256_update(&ctx->bctx, in_buf, in_len);
+  ctx->h0 = U64(0xcbbb9d5dc1059ed8);
+  ctx->h1 = U64(0x629a292a367cd507);
+  ctx->h2 = U64(0x9159015a3070dd17);
+  ctx->h3 = U64(0x152fecd8f70e5939);
+  ctx->h4 = U64(0x67332667ffc00b31);
+  ctx->h5 = U64(0x8eb44a8768581511);
+  ctx->h6 = U64(0xdb0c2e0d64f98fa7);
+  ctx->h7 = U64(0x47b5481dbefa4fa4);
+
+  ctx->nblocks = 0;
+  ctx->count = 0;
 }
 
 static inline u64
@@ -82,82 +67,82 @@ Maj(u64 x, u64 y, u64 z)
 }
 
 static inline u64
-Sum0(u64 x)
+sum0(u64 x)
 {
-  return (ROTR (x, 28) ^ ROTR (x, 34) ^ ROTR (x, 39));
+  return (ROTR(x, 28) ^ ROTR(x, 34) ^ ROTR(x, 39));
 }
 
 static inline u64
-Sum1 (u64 x)
+sum1(u64 x)
 {
-  return (ROTR (x, 14) ^ ROTR (x, 18) ^ ROTR (x, 41));
+  return (ROTR(x, 14) ^ ROTR(x, 18) ^ ROTR(x, 41));
 }
 
 static const u64 k[] =
 {
-    UINT64_C(0x428a2f98d728ae22), UINT64_C(0x7137449123ef65cd),
-    UINT64_C(0xb5c0fbcfec4d3b2f), UINT64_C(0xe9b5dba58189dbbc),
-    UINT64_C(0x3956c25bf348b538), UINT64_C(0x59f111f1b605d019),
-    UINT64_C(0x923f82a4af194f9b), UINT64_C(0xab1c5ed5da6d8118),
-    UINT64_C(0xd807aa98a3030242), UINT64_C(0x12835b0145706fbe),
-    UINT64_C(0x243185be4ee4b28c), UINT64_C(0x550c7dc3d5ffb4e2),
-    UINT64_C(0x72be5d74f27b896f), UINT64_C(0x80deb1fe3b1696b1),
-    UINT64_C(0x9bdc06a725c71235), UINT64_C(0xc19bf174cf692694),
-    UINT64_C(0xe49b69c19ef14ad2), UINT64_C(0xefbe4786384f25e3),
-    UINT64_C(0x0fc19dc68b8cd5b5), UINT64_C(0x240ca1cc77ac9c65),
-    UINT64_C(0x2de92c6f592b0275), UINT64_C(0x4a7484aa6ea6e483),
-    UINT64_C(0x5cb0a9dcbd41fbd4), UINT64_C(0x76f988da831153b5),
-    UINT64_C(0x983e5152ee66dfab), UINT64_C(0xa831c66d2db43210),
-    UINT64_C(0xb00327c898fb213f), UINT64_C(0xbf597fc7beef0ee4),
-    UINT64_C(0xc6e00bf33da88fc2), UINT64_C(0xd5a79147930aa725),
-    UINT64_C(0x06ca6351e003826f), UINT64_C(0x142929670a0e6e70),
-    UINT64_C(0x27b70a8546d22ffc), UINT64_C(0x2e1b21385c26c926),
-    UINT64_C(0x4d2c6dfc5ac42aed), UINT64_C(0x53380d139d95b3df),
-    UINT64_C(0x650a73548baf63de), UINT64_C(0x766a0abb3c77b2a8),
-    UINT64_C(0x81c2c92e47edaee6), UINT64_C(0x92722c851482353b),
-    UINT64_C(0xa2bfe8a14cf10364), UINT64_C(0xa81a664bbc423001),
-    UINT64_C(0xc24b8b70d0f89791), UINT64_C(0xc76c51a30654be30),
-    UINT64_C(0xd192e819d6ef5218), UINT64_C(0xd69906245565a910),
-    UINT64_C(0xf40e35855771202a), UINT64_C(0x106aa07032bbd1b8),
-    UINT64_C(0x19a4c116b8d2d0c8), UINT64_C(0x1e376c085141ab53),
-    UINT64_C(0x2748774cdf8eeb99), UINT64_C(0x34b0bcb5e19b48a8),
-    UINT64_C(0x391c0cb3c5c95a63), UINT64_C(0x4ed8aa4ae3418acb),
-    UINT64_C(0x5b9cca4f7763e373), UINT64_C(0x682e6ff3d6b2b8a3),
-    UINT64_C(0x748f82ee5defb2fc), UINT64_C(0x78a5636f43172f60),
-    UINT64_C(0x84c87814a1f0ab72), UINT64_C(0x8cc702081a6439ec),
-    UINT64_C(0x90befffa23631e28), UINT64_C(0xa4506cebde82bde9),
-    UINT64_C(0xbef9a3f7b2c67915), UINT64_C(0xc67178f2e372532b),
-    UINT64_C(0xca273eceea26619c), UINT64_C(0xd186b8c721c0c207),
-    UINT64_C(0xeada7dd6cde0eb1e), UINT64_C(0xf57d4f7fee6ed178),
-    UINT64_C(0x06f067aa72176fba), UINT64_C(0x0a637dc5a2c898a6),
-    UINT64_C(0x113f9804bef90dae), UINT64_C(0x1b710b35131c471b),
-    UINT64_C(0x28db77f523047d84), UINT64_C(0x32caab7b40c72493),
-    UINT64_C(0x3c9ebe0a15c9bebc), UINT64_C(0x431d67c49c100d4c),
-    UINT64_C(0x4cc5d4becb3e42b6), UINT64_C(0x597f299cfc657e2a),
-    UINT64_C(0x5fcb6fab3ad6faec), UINT64_C(0x6c44198c4a475817)
+    U64(0x428a2f98d728ae22), U64(0x7137449123ef65cd),
+    U64(0xb5c0fbcfec4d3b2f), U64(0xe9b5dba58189dbbc),
+    U64(0x3956c25bf348b538), U64(0x59f111f1b605d019),
+    U64(0x923f82a4af194f9b), U64(0xab1c5ed5da6d8118),
+    U64(0xd807aa98a3030242), U64(0x12835b0145706fbe),
+    U64(0x243185be4ee4b28c), U64(0x550c7dc3d5ffb4e2),
+    U64(0x72be5d74f27b896f), U64(0x80deb1fe3b1696b1),
+    U64(0x9bdc06a725c71235), U64(0xc19bf174cf692694),
+    U64(0xe49b69c19ef14ad2), U64(0xefbe4786384f25e3),
+    U64(0x0fc19dc68b8cd5b5), U64(0x240ca1cc77ac9c65),
+    U64(0x2de92c6f592b0275), U64(0x4a7484aa6ea6e483),
+    U64(0x5cb0a9dcbd41fbd4), U64(0x76f988da831153b5),
+    U64(0x983e5152ee66dfab), U64(0xa831c66d2db43210),
+    U64(0xb00327c898fb213f), U64(0xbf597fc7beef0ee4),
+    U64(0xc6e00bf33da88fc2), U64(0xd5a79147930aa725),
+    U64(0x06ca6351e003826f), U64(0x142929670a0e6e70),
+    U64(0x27b70a8546d22ffc), U64(0x2e1b21385c26c926),
+    U64(0x4d2c6dfc5ac42aed), U64(0x53380d139d95b3df),
+    U64(0x650a73548baf63de), U64(0x766a0abb3c77b2a8),
+    U64(0x81c2c92e47edaee6), U64(0x92722c851482353b),
+    U64(0xa2bfe8a14cf10364), U64(0xa81a664bbc423001),
+    U64(0xc24b8b70d0f89791), U64(0xc76c51a30654be30),
+    U64(0xd192e819d6ef5218), U64(0xd69906245565a910),
+    U64(0xf40e35855771202a), U64(0x106aa07032bbd1b8),
+    U64(0x19a4c116b8d2d0c8), U64(0x1e376c085141ab53),
+    U64(0x2748774cdf8eeb99), U64(0x34b0bcb5e19b48a8),
+    U64(0x391c0cb3c5c95a63), U64(0x4ed8aa4ae3418acb),
+    U64(0x5b9cca4f7763e373), U64(0x682e6ff3d6b2b8a3),
+    U64(0x748f82ee5defb2fc), U64(0x78a5636f43172f60),
+    U64(0x84c87814a1f0ab72), U64(0x8cc702081a6439ec),
+    U64(0x90befffa23631e28), U64(0xa4506cebde82bde9),
+    U64(0xbef9a3f7b2c67915), U64(0xc67178f2e372532b),
+    U64(0xca273eceea26619c), U64(0xd186b8c721c0c207),
+    U64(0xeada7dd6cde0eb1e), U64(0xf57d4f7fee6ed178),
+    U64(0x06f067aa72176fba), U64(0x0a637dc5a2c898a6),
+    U64(0x113f9804bef90dae), U64(0x1b710b35131c471b),
+    U64(0x28db77f523047d84), U64(0x32caab7b40c72493),
+    U64(0x3c9ebe0a15c9bebc), U64(0x431d67c49c100d4c),
+    U64(0x4cc5d4becb3e42b6), U64(0x597f299cfc657e2a),
+    U64(0x5fcb6fab3ad6faec), U64(0x6c44198c4a475817)
 };
 
 /*
  * Transform the message W which consists of 16 64-bit-words
  */
 static uint
-sha512_transform_block(struct sha512_state *hd, const byte *data)
+sha512_transform(struct sha512_context *ctx, const byte *data)
 {
   u64 a, b, c, d, e, f, g, h;
   u64 w[16];
-  int t;
+  uint t;
 
   /* get values from the chaining vars */
-  a = hd->h0;
-  b = hd->h1;
-  c = hd->h2;
-  d = hd->h3;
-  e = hd->h4;
-  f = hd->h5;
-  g = hd->h6;
-  h = hd->h7;
-
-  for ( t = 0; t < 16; t++ )
+  a = ctx->h0;
+  b = ctx->h1;
+  c = ctx->h2;
+  d = ctx->h3;
+  e = ctx->h4;
+  f = ctx->h5;
+  g = ctx->h6;
+  h = ctx->h7;
+
+  for (t = 0; t < 16; t++)
     w[t] = get_u64(data + t * 8);
 
 #define S0(x) (ROTR((x),1) ^ ROTR((x),8) ^ ((x)>>7))
@@ -175,10 +160,10 @@ sha512_transform_block(struct sha512_state *hd, const byte *data)
          Unrolled with macros:      350ms
          Unrolled with inline:      330ms
      */
-#if 0 /* Not unrolled.  */
-    t1 = h + Sum1 (e) + Ch(e, f, g) + k[t] + w[t%16];
-    w[t%16] += S1 (w[(t - 2)%16]) + w[(t - 7)%16] + S0 (w[(t - 15)%16]);
-    t2 = Sum0 (a) + Maj(a, b, c);
+#ifndef SHA512_UNROLLED
+    t1 = h + sum1(e) + Ch(e, f, g) + k[t] + w[t%16];
+    w[t%16] += S1(w[(t - 2)%16]) + w[(t - 7)%16] + S0(w[(t - 15)%16]);
+    t2 = sum0(a) + Maj(a, b, c);
     h = g;
     g = f;
     f = e;
@@ -188,100 +173,100 @@ sha512_transform_block(struct sha512_state *hd, const byte *data)
     b = a;
     a = t1 + t2;
     t++;
-#else /* Unrolled to interweave the chain variables.  */
-    t1 = h + Sum1 (e) + Ch(e, f, g) + k[t] + w[0];
-    w[0] += S1 (w[14]) + w[9] + S0 (w[1]);
-    t2 = Sum0 (a) + Maj(a, b, c);
+#else /* Unrolled */
+    t1 = h + sum1(e) + Ch(e, f, g) + k[t] + w[0];
+    w[0] += S1(w[14]) + w[9] + S0(w[1]);
+    t2 = sum0(a) + Maj(a, b, c);
     d += t1;
     h = t1 + t2;
 
-    t1 = g + Sum1 (d) + Ch(d, e, f) + k[t+1] + w[1];
-    w[1] += S1 (w[15]) + w[10] + S0 (w[2]);
-    t2 = Sum0 (h) + Maj(h, a, b);
+    t1 = g + sum1(d) + Ch(d, e, f) + k[t+1] + w[1];
+    w[1] += S1(w[15]) + w[10] + S0(w[2]);
+    t2 = sum0(h) + Maj(h, a, b);
     c += t1;
     g  = t1 + t2;
 
-    t1 = f + Sum1 (c) + Ch(c, d, e) + k[t+2] + w[2];
-    w[2] += S1 (w[0]) + w[11] + S0 (w[3]);
-    t2 = Sum0 (g) + Maj(g, h, a);
+    t1 = f + sum1(c) + Ch(c, d, e) + k[t+2] + w[2];
+    w[2] += S1(w[0]) + w[11] + S0(w[3]);
+    t2 = sum0(g) + Maj(g, h, a);
     b += t1;
     f  = t1 + t2;
 
-    t1 = e + Sum1 (b) + Ch(b, c, d) + k[t+3] + w[3];
-    w[3] += S1 (w[1]) + w[12] + S0 (w[4]);
-    t2 = Sum0 (f) + Maj(f, g, h);
+    t1 = e + sum1(b) + Ch(b, c, d) + k[t+3] + w[3];
+    w[3] += S1(w[1]) + w[12] + S0(w[4]);
+    t2 = sum0(f) + Maj(f, g, h);
     a += t1;
     e  = t1 + t2;
 
-    t1 = d + Sum1 (a) + Ch(a, b, c) + k[t+4] + w[4];
-    w[4] += S1 (w[2]) + w[13] + S0 (w[5]);
-    t2 = Sum0 (e) + Maj(e, f, g);
+    t1 = d + sum1(a) + Ch(a, b, c) + k[t+4] + w[4];
+    w[4] += S1(w[2]) + w[13] + S0(w[5]);
+    t2 = sum0(e) + Maj(e, f, g);
     h += t1;
     d  = t1 + t2;
 
-    t1 = c + Sum1 (h) + Ch(h, a, b) + k[t+5] + w[5];
-    w[5] += S1 (w[3]) + w[14] + S0 (w[6]);
-    t2 = Sum0 (d) + Maj(d, e, f);
+    t1 = c + sum1(h) + Ch(h, a, b) + k[t+5] + w[5];
+    w[5] += S1(w[3]) + w[14] + S0(w[6]);
+    t2 = sum0(d) + Maj(d, e, f);
     g += t1;
     c  = t1 + t2;
 
-    t1 = b + Sum1 (g) + Ch(g, h, a) + k[t+6] + w[6];
-    w[6] += S1 (w[4]) + w[15] + S0 (w[7]);
-    t2 = Sum0 (c) + Maj(c, d, e);
+    t1 = b + sum1(g) + Ch(g, h, a) + k[t+6] + w[6];
+    w[6] += S1(w[4]) + w[15] + S0(w[7]);
+    t2 = sum0(c) + Maj(c, d, e);
     f += t1;
     b  = t1 + t2;
 
-    t1 = a + Sum1 (f) + Ch(f, g, h) + k[t+7] + w[7];
-    w[7] += S1 (w[5]) + w[0] + S0 (w[8]);
-    t2 = Sum0 (b) + Maj(b, c, d);
+    t1 = a + sum1(f) + Ch(f, g, h) + k[t+7] + w[7];
+    w[7] += S1(w[5]) + w[0] + S0(w[8]);
+    t2 = sum0(b) + Maj(b, c, d);
     e += t1;
     a  = t1 + t2;
 
-    t1 = h + Sum1 (e) + Ch(e, f, g) + k[t+8] + w[8];
-    w[8] += S1 (w[6]) + w[1] + S0 (w[9]);
-    t2 = Sum0 (a) + Maj(a, b, c);
+    t1 = h + sum1(e) + Ch(e, f, g) + k[t+8] + w[8];
+    w[8] += S1(w[6]) + w[1] + S0(w[9]);
+    t2 = sum0(a) + Maj(a, b, c);
     d += t1;
     h  = t1 + t2;
 
-    t1 = g + Sum1 (d) + Ch(d, e, f) + k[t+9] + w[9];
-    w[9] += S1 (w[7]) + w[2] + S0 (w[10]);
-    t2 = Sum0 (h) + Maj(h, a, b);
+    t1 = g + sum1(d) + Ch(d, e, f) + k[t+9] + w[9];
+    w[9] += S1(w[7]) + w[2] + S0(w[10]);
+    t2 = sum0(h) + Maj(h, a, b);
     c += t1;
     g  = t1 + t2;
 
-    t1 = f + Sum1 (c) + Ch(c, d, e) + k[t+10] + w[10];
-    w[10] += S1 (w[8]) + w[3] + S0 (w[11]);
-    t2 = Sum0 (g) + Maj(g, h, a);
+    t1 = f + sum1(c) + Ch(c, d, e) + k[t+10] + w[10];
+    w[10] += S1(w[8]) + w[3] + S0(w[11]);
+    t2 = sum0(g) + Maj(g, h, a);
     b += t1;
     f  = t1 + t2;
 
-    t1 = e + Sum1 (b) + Ch(b, c, d) + k[t+11] + w[11];
-    w[11] += S1 (w[9]) + w[4] + S0 (w[12]);
-    t2 = Sum0 (f) + Maj(f, g, h);
+    t1 = e + sum1(b) + Ch(b, c, d) + k[t+11] + w[11];
+    w[11] += S1(w[9]) + w[4] + S0(w[12]);
+    t2 = sum0(f) + Maj(f, g, h);
     a += t1;
     e  = t1 + t2;
 
-    t1 = d + Sum1 (a) + Ch(a, b, c) + k[t+12] + w[12];
-    w[12] += S1 (w[10]) + w[5] + S0 (w[13]);
-    t2 = Sum0 (e) + Maj(e, f, g);
+    t1 = d + sum1(a) + Ch(a, b, c) + k[t+12] + w[12];
+    w[12] += S1(w[10]) + w[5] + S0(w[13]);
+    t2 = sum0(e) + Maj(e, f, g);
     h += t1;
     d  = t1 + t2;
 
-    t1 = c + Sum1 (h) + Ch(h, a, b) + k[t+13] + w[13];
-    w[13] += S1 (w[11]) + w[6] + S0 (w[14]);
-    t2 = Sum0 (d) + Maj(d, e, f);
+    t1 = c + sum1(h) + Ch(h, a, b) + k[t+13] + w[13];
+    w[13] += S1(w[11]) + w[6] + S0(w[14]);
+    t2 = sum0(d) + Maj(d, e, f);
     g += t1;
     c  = t1 + t2;
 
-    t1 = b + Sum1 (g) + Ch(g, h, a) + k[t+14] + w[14];
-    w[14] += S1 (w[12]) + w[7] + S0 (w[15]);
-    t2 = Sum0 (c) + Maj(c, d, e);
+    t1 = b + sum1(g) + Ch(g, h, a) + k[t+14] + w[14];
+    w[14] += S1(w[12]) + w[7] + S0(w[15]);
+    t2 = sum0(c) + Maj(c, d, e);
     f += t1;
     b  = t1 + t2;
 
-    t1 = a + Sum1 (f) + Ch(f, g, h) + k[t+15] + w[15];
-    w[15] += S1 (w[13]) + w[8] + S0 (w[0]);
-    t2 = Sum0 (b) + Maj(b, c, d);
+    t1 = a + sum1(f) + Ch(f, g, h) + k[t+15] + w[15];
+    w[15] += S1(w[13]) + w[8] + S0(w[0]);
+    t2 = sum0(b) + Maj(b, c, d);
     e += t1;
     a  = t1 + t2;
 
@@ -293,9 +278,9 @@ sha512_transform_block(struct sha512_state *hd, const byte *data)
   {
     u64 t1, t2;
 
-#if 0 /* Not unrolled.  */
-    t1 = h + Sum1 (e) + Ch(e, f, g) + k[t] + w[t%16];
-    t2 = Sum0 (a) + Maj(a, b, c);
+#ifndef SHA512_UNROLLED
+    t1 = h + sum1(e) + Ch(e, f, g) + k[t] + w[t%16];
+    t2 = sum0(a) + Maj(a, b, c);
     h = g;
     g = f;
     f = e;
@@ -305,84 +290,84 @@ sha512_transform_block(struct sha512_state *hd, const byte *data)
     b = a;
     a = t1 + t2;
     t++;
-#else /* Unrolled to interweave the chain variables.  */
-    t1 = h + Sum1 (e) + Ch(e, f, g) + k[t] + w[0];
-    t2 = Sum0 (a) + Maj(a, b, c);
+#else /* Unrolled */
+    t1 = h + sum1(e) + Ch(e, f, g) + k[t] + w[0];
+    t2 = sum0(a) + Maj(a, b, c);
     d += t1;
     h  = t1 + t2;
 
-    t1 = g + Sum1 (d) + Ch(d, e, f) + k[t+1] + w[1];
-    t2 = Sum0 (h) + Maj(h, a, b);
+    t1 = g + sum1(d) + Ch(d, e, f) + k[t+1] + w[1];
+    t2 = sum0(h) + Maj(h, a, b);
     c += t1;
     g  = t1 + t2;
 
-    t1 = f + Sum1 (c) + Ch(c, d, e) + k[t+2] + w[2];
-    t2 = Sum0 (g) + Maj(g, h, a);
+    t1 = f + sum1(c) + Ch(c, d, e) + k[t+2] + w[2];
+    t2 = sum0(g) + Maj(g, h, a);
     b += t1;
     f  = t1 + t2;
 
-    t1 = e + Sum1 (b) + Ch(b, c, d) + k[t+3] + w[3];
-    t2 = Sum0 (f) + Maj(f, g, h);
+    t1 = e + sum1(b) + Ch(b, c, d) + k[t+3] + w[3];
+    t2 = sum0(f) + Maj(f, g, h);
     a += t1;
     e  = t1 + t2;
 
-    t1 = d + Sum1 (a) + Ch(a, b, c) + k[t+4] + w[4];
-    t2 = Sum0 (e) + Maj(e, f, g);
+    t1 = d + sum1(a) + Ch(a, b, c) + k[t+4] + w[4];
+    t2 = sum0(e) + Maj(e, f, g);
     h += t1;
     d  = t1 + t2;
 
-    t1 = c + Sum1 (h) + Ch(h, a, b) + k[t+5] + w[5];
-    t2 = Sum0 (d) + Maj(d, e, f);
+    t1 = c + sum1(h) + Ch(h, a, b) + k[t+5] + w[5];
+    t2 = sum0(d) + Maj(d, e, f);
     g += t1;
     c  = t1 + t2;
 
-    t1 = b + Sum1 (g) + Ch(g, h, a) + k[t+6] + w[6];
-    t2 = Sum0 (c) + Maj(c, d, e);
+    t1 = b + sum1(g) + Ch(g, h, a) + k[t+6] + w[6];
+    t2 = sum0(c) + Maj(c, d, e);
     f += t1;
     b  = t1 + t2;
 
-    t1 = a + Sum1 (f) + Ch(f, g, h) + k[t+7] + w[7];
-    t2 = Sum0 (b) + Maj(b, c, d);
+    t1 = a + sum1(f) + Ch(f, g, h) + k[t+7] + w[7];
+    t2 = sum0(b) + Maj(b, c, d);
     e += t1;
     a  = t1 + t2;
 
-    t1 = h + Sum1 (e) + Ch(e, f, g) + k[t+8] + w[8];
-    t2 = Sum0 (a) + Maj(a, b, c);
+    t1 = h + sum1(e) + Ch(e, f, g) + k[t+8] + w[8];
+    t2 = sum0(a) + Maj(a, b, c);
     d += t1;
     h  = t1 + t2;
 
-    t1 = g + Sum1 (d) + Ch(d, e, f) + k[t+9] + w[9];
-    t2 = Sum0 (h) + Maj(h, a, b);
+    t1 = g + sum1(d) + Ch(d, e, f) + k[t+9] + w[9];
+    t2 = sum0(h) + Maj(h, a, b);
     c += t1;
     g  = t1 + t2;
 
-    t1 = f + Sum1 (c) + Ch(c, d, e) + k[t+10] + w[10];
-    t2 = Sum0 (g) + Maj(g, h, a);
+    t1 = f + sum1(c) + Ch(c, d, e) + k[t+10] + w[10];
+    t2 = sum0(g) + Maj(g, h, a);
     b += t1;
     f  = t1 + t2;
 
-    t1 = e + Sum1 (b) + Ch(b, c, d) + k[t+11] + w[11];
-    t2 = Sum0 (f) + Maj(f, g, h);
+    t1 = e + sum1(b) + Ch(b, c, d) + k[t+11] + w[11];
+    t2 = sum0(f) + Maj(f, g, h);
     a += t1;
     e  = t1 + t2;
 
-    t1 = d + Sum1 (a) + Ch(a, b, c) + k[t+12] + w[12];
-    t2 = Sum0 (e) + Maj(e, f, g);
+    t1 = d + sum1(a) + Ch(a, b, c) + k[t+12] + w[12];
+    t2 = sum0(e) + Maj(e, f, g);
     h += t1;
     d  = t1 + t2;
 
-    t1 = c + Sum1 (h) + Ch(h, a, b) + k[t+13] + w[13];
-    t2 = Sum0 (d) + Maj(d, e, f);
+    t1 = c + sum1(h) + Ch(h, a, b) + k[t+13] + w[13];
+    t2 = sum0(d) + Maj(d, e, f);
     g += t1;
     c  = t1 + t2;
 
-    t1 = b + Sum1 (g) + Ch(g, h, a) + k[t+14] + w[14];
-    t2 = Sum0 (c) + Maj(c, d, e);
+    t1 = b + sum1(g) + Ch(g, h, a) + k[t+14] + w[14];
+    t2 = sum0(c) + Maj(c, d, e);
     f += t1;
     b  = t1 + t2;
 
-    t1 = a + Sum1 (f) + Ch(f, g, h) + k[t+15] + w[15];
-    t2 = Sum0 (b) + Maj(b, c, d);
+    t1 = a + sum1(f) + Ch(f, g, h) + k[t+15] + w[15];
+    t2 = sum0(b) + Maj(b, c, d);
     e += t1;
     a  = t1 + t2;
 
@@ -391,61 +376,77 @@ sha512_transform_block(struct sha512_state *hd, const byte *data)
   }
 
   /* Update chaining vars.  */
-  hd->h0 += a;
-  hd->h1 += b;
-  hd->h2 += c;
-  hd->h3 += d;
-  hd->h4 += e;
-  hd->h5 += f;
-  hd->h6 += g;
-  hd->h7 += h;
+  ctx->h0 += a;
+  ctx->h1 += b;
+  ctx->h2 += c;
+  ctx->h3 += d;
+  ctx->h4 += e;
+  ctx->h5 += f;
+  ctx->h6 += g;
+  ctx->h7 += h;
 
   return /* burn_stack */ (8 + 16) * sizeof(u64) + sizeof(u32) + 3 * sizeof(void*);
 }
 
-static uint
-sha512_transform(void *context, const byte *data, size_t nblks)
+void
+sha512_update(struct sha512_context *ctx, const byte *buf, size_t len)
 {
-  struct sha512_context *ctx = context;
-  uint burn;
+  if (ctx->count)
+  {
+    /* Fill rest of internal buffer */
+    for (; len && ctx->count < SHA512_BLOCK_SIZE; len--)
+      ctx->buf[ctx->count++] = *buf++;
+
+    if (ctx->count < SHA512_BLOCK_SIZE)
+      return;
+
+    /* Process data from internal buffer */
+    sha512_transform(ctx, ctx->buf);
+    ctx->nblocks++;
+    ctx->count = 0;
+  }
 
-  do
+  if (!len)
+    return;
+
+  /* Process data from input buffer */
+  while (len >= SHA512_BLOCK_SIZE)
   {
-    burn = sha512_transform_block(&ctx->state, data) + 3 * sizeof(void*);
-    data += 128;
+    sha512_transform(ctx, buf);
+    ctx->nblocks++;
+    buf += SHA512_BLOCK_SIZE;
+    len -= SHA512_BLOCK_SIZE;
   }
-  while(--nblks);
 
-  return burn;
+  /* Copy remaining data to internal buffer */
+  memcpy(ctx->buf, buf, len);
+  ctx->count = len;
 }
 
-/* The routine final terminates the computation and
- * returns the digest.
- * The handle is prepared for a new cycle, but adding bytes to the
- * handle will the destroy the returned buffer.
- * Returns: 64 bytes representing the digest.  When used for sha384,
- * we take the leftmost 48 of those bytes.
+/*
+ * The routine final terminates the computation and returns the digest. The
+ * handle is prepared for a new cycle, but adding bytes to the handle will the
+ * destroy the returned buffer.
+ *
+ * Returns: 64 bytes representing the digest. When used for sha384, we take the
+ * first 48 of those bytes.
  */
 byte *
 sha512_final(struct sha512_context *ctx)
 {
   u64 t, th, msb, lsb;
-  byte *p;
 
-  sha256_update(&ctx->bctx, NULL, 0); /* flush */ ;
+  sha512_update(ctx, NULL, 0);	/* flush */
 
-  t = ctx->bctx.nblocks;
-  /* if (sizeof t == sizeof ctx->bctx.nblocks) */
-  th = ctx->bctx.nblocks_high;
-  /* else */
-  /*   th = ctx->bctx.nblocks >> 64; In case we ever use u128  */
+  t = ctx->nblocks;
+  th = 0;
 
   /* multiply by 128 to make a byte count */
   lsb = t << 7;
   msb = (th << 7) | (t >> 57);
   /* add the count */
   t = lsb;
-  if ((lsb += ctx->bctx.count) < t)
+  if ((lsb += ctx->count) < t)
     msb++;
   /* multiply by 8 to make a bit count */
   t = lsb;
@@ -453,55 +454,56 @@ sha512_final(struct sha512_context *ctx)
   msb <<= 3;
   msb |= t >> 61;
 
-  if (ctx->bctx.count < 112)
-  {						/* enough room */
-    ctx->bctx.buf[ctx->bctx.count++] = 0x80;	/* pad */
-    while(ctx->bctx.count < 112)
-      ctx->bctx.buf[ctx->bctx.count++] = 0;	/* pad */
+  if (ctx->count < 112)
+  {
+    /* enough room */
+    ctx->buf[ctx->count++] = 0x80;	/* pad */
+    while(ctx->count < 112)
+      ctx->buf[ctx->count++] = 0;	/* pad */
   }
   else
-  {						/* need one extra block */
-    ctx->bctx.buf[ctx->bctx.count++] = 0x80;	/* pad character */
-    while(ctx->bctx.count < 128)
-      ctx->bctx.buf[ctx->bctx.count++] = 0;
-    sha256_update(&ctx->bctx, NULL, 0); 	/* flush */ ;
-    memset(ctx->bctx.buf, 0, 112);		/* fill next block with zeroes */
+  {
+    /* need one extra block */
+    ctx->buf[ctx->count++] = 0x80;	/* pad character */
+    while(ctx->count < 128)
+      ctx->buf[ctx->count++] = 0;
+    sha512_update(ctx, NULL, 0); 	/* flush */
+    memset(ctx->buf, 0, 112);		/* fill next block with zeroes */
   }
+
   /* append the 128 bit count */
-  put_u64(ctx->bctx.buf + 112, msb);
-  put_u64(ctx->bctx.buf + 120, lsb);
-  sha512_transform(ctx, ctx->bctx.buf, 1);
-
-  p = ctx->bctx.buf;
-#define X(a) do { put_u64(p, ctx->state.h##a); p += 8; } while(0)
-  X (0);
-  X (1);
-  X (2);
-  X (3);
-  X (4);
-  X (5);
-  /* Note that these last two chunks are included even for SHA384.
-     We just ignore them. */
-  X (6);
-  X (7);
+  put_u64(ctx->buf + 112, msb);
+  put_u64(ctx->buf + 120, lsb);
+  sha512_transform(ctx, ctx->buf);
+
+  byte *p = ctx->buf;
+#define X(a) do { put_u64(p, ctx->h##a); p += 8; } while(0)
+  X(0);
+  X(1);
+  X(2);
+  X(3);
+  X(4);
+  X(5);
+  X(6);
+  X(7);
 #undef X
 
-  return ctx->bctx.buf;
+  return ctx->buf;
 }
 
 
 /*
- * 	SHA512-HMAC
+ *	SHA512-HMAC
  */
 
 static void
 sha512_hash_buffer(byte *outbuf, const byte *buffer, size_t length)
 {
-  struct sha512_context hd_tmp;
+  struct sha512_context ctx;
 
-  sha512_init(&hd_tmp);
-  sha512_update(&hd_tmp, buffer, length);
-  memcpy(outbuf, sha512_final(&hd_tmp), SHA512_SIZE);
+  sha512_init(&ctx);
+  sha512_update(&ctx, buffer, length);
+  memcpy(outbuf, sha512_final(&ctx), SHA512_SIZE);
 }
 
 void
@@ -513,12 +515,12 @@ sha512_hmac_init(struct sha512_hmac_context *ctx, const byte *key, size_t keylen
   if (keylen <= SHA512_BLOCK_SIZE)
   {
     memcpy(keybuf, key, keylen);
-    bzero(keybuf + keylen, SHA512_BLOCK_SIZE - keylen);
+    memset(keybuf + keylen, 0, SHA512_BLOCK_SIZE - keylen);
   }
   else
   {
     sha512_hash_buffer(keybuf, key, keylen);
-    bzero(keybuf + SHA512_SIZE, SHA512_BLOCK_SIZE - SHA512_SIZE);
+    memset(keybuf + SHA512_SIZE, 0, SHA512_BLOCK_SIZE - SHA512_SIZE);
   }
 
   /* Initialize the inner digest */
@@ -535,13 +537,15 @@ sha512_hmac_init(struct sha512_hmac_context *ctx, const byte *key, size_t keylen
   sha512_update(&ctx->octx, buf, SHA512_BLOCK_SIZE);
 }
 
-void sha512_hmac_update(struct sha512_hmac_context *ctx, const byte *buf, size_t buflen)
+void
+sha512_hmac_update(struct sha512_hmac_context *ctx, const byte *buf, size_t buflen)
 {
   /* Just update the inner digest */
   sha512_update(&ctx->ictx, buf, buflen);
 }
 
-byte *sha512_hmac_final(struct sha512_hmac_context *ctx)
+byte *
+sha512_hmac_final(struct sha512_hmac_context *ctx)
 {
   /* Finish the inner digest */
   byte *isha = sha512_final(&ctx->ictx);
@@ -553,17 +557,17 @@ byte *sha512_hmac_final(struct sha512_hmac_context *ctx)
 
 
 /*
- * 	SHA384-HMAC
+ *	SHA384-HMAC
  */
 
 static void
 sha384_hash_buffer(byte *outbuf, const byte *buffer, size_t length)
 {
-  struct sha384_context hd_tmp;
+  struct sha384_context ctx;
 
-  sha384_init(&hd_tmp);
-  sha384_update(&hd_tmp, buffer, length);
-  memcpy(outbuf, sha384_final(&hd_tmp), SHA384_SIZE);
+  sha384_init(&ctx);
+  sha384_update(&ctx, buffer, length);
+  memcpy(outbuf, sha384_final(&ctx), SHA384_SIZE);
 }
 
 void
@@ -575,12 +579,12 @@ sha384_hmac_init(struct sha384_hmac_context *ctx, const byte *key, size_t keylen
   if (keylen <= SHA384_BLOCK_SIZE)
   {
     memcpy(keybuf, key, keylen);
-    bzero(keybuf + keylen, SHA384_BLOCK_SIZE - keylen);
+    memset(keybuf + keylen, 0, SHA384_BLOCK_SIZE - keylen);
   }
   else
   {
     sha384_hash_buffer(keybuf, key, keylen);
-    bzero(keybuf + SHA384_SIZE, SHA384_BLOCK_SIZE - SHA384_SIZE);
+    memset(keybuf + SHA384_SIZE, 0, SHA384_BLOCK_SIZE - SHA384_SIZE);
   }
 
   /* Initialize the inner digest */
@@ -597,13 +601,15 @@ sha384_hmac_init(struct sha384_hmac_context *ctx, const byte *key, size_t keylen
   sha384_update(&ctx->octx, buf, SHA384_BLOCK_SIZE);
 }
 
-void sha384_hmac_update(struct sha384_hmac_context *ctx, const byte *buf, size_t buflen)
+void
+sha384_hmac_update(struct sha384_hmac_context *ctx, const byte *buf, size_t buflen)
 {
   /* Just update the inner digest */
   sha384_update(&ctx->ictx, buf, buflen);
 }
 
-byte *sha384_hmac_final(struct sha384_hmac_context *ctx)
+byte *
+sha384_hmac_final(struct sha384_hmac_context *ctx)
 {
   /* Finish the inner digest */
   byte *isha = sha384_final(&ctx->ictx);
diff --git a/lib/sha512.h b/lib/sha512.h
index bd998152..1614a3ac 100644
--- a/lib/sha512.h
+++ b/lib/sha512.h
@@ -13,7 +13,8 @@
 #ifndef _BIRD_SHA512_H_
 #define _BIRD_SHA512_H_
 
-#include "lib/sha256.h"
+#include "nest/bird.h"
+
 
 #define SHA384_SIZE 		48
 #define SHA384_HEX_SIZE		97
@@ -23,43 +24,41 @@
 #define SHA512_HEX_SIZE		129
 #define SHA512_BLOCK_SIZE	128
 
-struct sha512_state
-{
+
+struct sha512_context {
   u64 h0, h1, h2, h3, h4, h5, h6, h7;
+  byte buf[SHA512_BLOCK_SIZE];
+  uint nblocks;
+  uint count;
 };
 
-struct sha512_context
-{
-  struct sha256_context bctx;
-  struct sha512_state state;
-};
-#define sha384_context sha512_context	/* aliasing 'struct sha384_context' to 'struct sha512_context' */
+#define sha384_context sha512_context
 
 
 void sha512_init(struct sha512_context *ctx);
 void sha384_init(struct sha384_context *ctx);
 
-void sha512_update(struct sha512_context *ctx, const byte *in_buf, size_t in_len);
-static inline void sha384_update(struct sha384_context *ctx, const byte *in_buf, size_t in_len)
-{
-  sha512_update(ctx, in_buf, in_len);
-}
+void sha512_update(struct sha512_context *ctx, const byte *buf, size_t len);
+static inline void sha384_update(struct sha384_context *ctx, const byte *buf, size_t len)
+{ sha512_update(ctx, buf, len); }
+
+byte *sha512_final(struct sha512_context *ctx);
+static inline byte *sha384_final(struct sha384_context *ctx)
+{ return sha512_final(ctx); }
 
-byte* sha512_final(struct sha512_context *ctx);
-static inline byte* sha384_final(struct sha384_context *ctx)
-{
-  return sha512_final(ctx);
-}
 
 /*
  *	HMAC-SHA512, HMAC-SHA384
  */
+
 struct sha512_hmac_context
 {
   struct sha512_context ictx;
   struct sha512_context octx;
-} ;
-#define sha384_hmac_context sha512_hmac_context	/* aliasing 'struct sha384_hmac_context' to 'struct sha384_hmac_context' */
+};
+
+#define sha384_hmac_context sha512_hmac_context
+
 
 void sha512_hmac_init(struct sha512_hmac_context *ctx, const byte *key, size_t keylen);
 void sha384_hmac_init(struct sha384_hmac_context *ctx, const byte *key, size_t keylen);
@@ -70,4 +69,5 @@ void sha384_hmac_update(struct sha384_hmac_context *ctx, const byte *buf, size_t
 byte *sha512_hmac_final(struct sha512_hmac_context *ctx);
 byte *sha384_hmac_final(struct sha384_hmac_context *ctx);
 
+
 #endif /* _BIRD_SHA512_H_ */

From e422ca0f292d08a873deacdbffbb6c6cbd79f88a Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Tue, 24 Nov 2015 13:52:26 +0100
Subject: [PATCH 042/165] Some consts for function arguments

Patch from Pavel Tvrdik
---
 lib/ip.c        | 6 +++---
 lib/ip.h        | 4 ++--
 lib/patmatch.c  | 2 +-
 lib/string.h    | 2 +-
 lib/unaligned.h | 4 ++--
 5 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/lib/ip.c b/lib/ip.c
index e1bfba49..2061a1f7 100644
--- a/lib/ip.c
+++ b/lib/ip.c
@@ -233,7 +233,7 @@ ip6_ntop(ip6_addr a, char *b)
 }
 
 int
-ip4_pton(char *a, ip4_addr *o)
+ip4_pton(const char *a, ip4_addr *o)
 {
   int i;
   unsigned long int l;
@@ -258,11 +258,11 @@ ip4_pton(char *a, ip4_addr *o)
 }
 
 int
-ip6_pton(char *a, ip6_addr *o)
+ip6_pton(const char *a, ip6_addr *o)
 {
   u16 words[8];
   int i, j, k, l, hfil;
-  char *start;
+  const char *start;
 
   if (a[0] == ':')			/* Leading :: */
   {
diff --git a/lib/ip.h b/lib/ip.h
index 90bb7f8a..e33adc6e 100644
--- a/lib/ip.h
+++ b/lib/ip.h
@@ -446,8 +446,8 @@ static inline char * ip4_ntox(ip4_addr a, char *b)
 static inline char * ip6_ntox(ip6_addr a, char *b)
 { return b + bsprintf(b, "%08x.%08x.%08x.%08x", _I0(a), _I1(a), _I2(a), _I3(a)); }
 
-int ip4_pton(char *a, ip4_addr *o);
-int ip6_pton(char *a, ip6_addr *o);
+int ip4_pton(const char *a, ip4_addr *o);
+int ip6_pton(const char *a, ip6_addr *o);
 
 // XXXX these functions must be redesigned or removed
 #ifdef IPV6
diff --git a/lib/patmatch.c b/lib/patmatch.c
index 923e8f86..d2e1e313 100644
--- a/lib/patmatch.c
+++ b/lib/patmatch.c
@@ -16,7 +16,7 @@
 #endif
 
 int
-MATCH_FUNC_NAME(byte *p, byte *s)
+MATCH_FUNC_NAME(const byte *p, const byte *s)
 {
   while (*p)
     {
diff --git a/lib/string.h b/lib/string.h
index 528a1a19..218f7b1c 100644
--- a/lib/string.h
+++ b/lib/string.h
@@ -22,6 +22,6 @@ int buffer_vprint(buffer *buf, const char *fmt, va_list args);
 int buffer_print(buffer *buf, const char *fmt, ...);
 void buffer_puts(buffer *buf, const char *str);
 
-int patmatch(byte *pat, byte *str);
+int patmatch(const byte *pat, const byte *str);
 
 #endif
diff --git a/lib/unaligned.h b/lib/unaligned.h
index a2dbae4f..dc777fbf 100644
--- a/lib/unaligned.h
+++ b/lib/unaligned.h
@@ -20,7 +20,7 @@
 #include "lib/string.h"
 
 static inline u16
-get_u16(void *p)
+get_u16(const void *p)
 {
   u16 x;
   memcpy(&x, p, 2);
@@ -28,7 +28,7 @@ get_u16(void *p)
 }
 
 static inline u32
-get_u32(void *p)
+get_u32(const void *p)
 {
   u32 x;
   memcpy(&x, p, 4);

From ad27615760e2795da3efe5e97c0e888281d5ca59 Mon Sep 17 00:00:00 2001
From: Jan Moskyto Matejka <mq@ucw.cz>
Date: Tue, 10 Nov 2015 14:59:41 +0100
Subject: [PATCH 043/165] Netlink: attribute validation before parsing

Wanted netlink attributes are defined in a table, specifying
their size and neediness. Removing the long conditions that did the
validation before.

Also parsing IPv4 and IPv6 versions regardless on the IPV6 macro.
---
 sysdep/linux/netlink.c | 187 +++++++++++++++++++++++++++++++----------
 1 file changed, 141 insertions(+), 46 deletions(-)

diff --git a/sysdep/linux/netlink.c b/sysdep/linux/netlink.c
index efbf41a6..640d1877 100644
--- a/sysdep/linux/netlink.c
+++ b/sysdep/linux/netlink.c
@@ -226,24 +226,98 @@ nl_checkin(struct nlmsghdr *h, int lsize)
   return NLMSG_DATA(h);
 }
 
+struct nl_want_attrs {
+  u8 defined:1;
+  u8 checksize:1;
+  u8 size;
+};
+
+
+#define BIRD_IFLA_MAX (IFLA_WIRELESS+1)
+
+static struct nl_want_attrs ifla_attr_want[BIRD_IFLA_MAX] = {
+  [IFLA_IFNAME]	  = { 1, 0, 0 },
+  [IFLA_MTU]	  = { 1, 1, sizeof(u32) },
+  [IFLA_WIRELESS] = { 1, 0, 0 },
+};
+
+
+#define BIRD_IFA_MAX  (IFA_ANYCAST+1)
+
+#ifndef IPV6
+static struct nl_want_attrs ifa_attr_want4[BIRD_IFA_MAX] = {
+  [IFA_ADDRESS]	  = { 1, 1, sizeof(ip4_addr) },
+  [IFA_LOCAL]	  = { 1, 1, sizeof(ip4_addr) },
+  [IFA_BROADCAST] = { 1, 1, sizeof(ip4_addr) },
+};
+#else
+static struct nl_want_attrs ifa_attr_want6[BIRD_IFA_MAX] = {
+  [IFA_ADDRESS]	  = { 1, 1, sizeof(ip6_addr) },
+  [IFA_LOCAL]	  = { 1, 1, sizeof(ip6_addr) },
+};
+#endif
+
+
+#define BIRD_RTA_MAX  (RTA_TABLE+1)
+
+static struct nl_want_attrs mpnh_attr_want4[BIRD_RTA_MAX] = {
+  [RTA_GATEWAY]	  = { 1, 1, sizeof(ip4_addr) },
+};
+
+#ifndef IPV6
+static struct nl_want_attrs rtm_attr_want4[BIRD_RTA_MAX] = {
+  [RTA_DST]	  = { 1, 1, sizeof(ip4_addr) },
+  [RTA_OIF]	  = { 1, 1, sizeof(u32) },
+  [RTA_GATEWAY]	  = { 1, 1, sizeof(ip4_addr) },
+  [RTA_PRIORITY]  = { 1, 1, sizeof(u32) },
+  [RTA_PREFSRC]	  = { 1, 1, sizeof(ip4_addr) },
+  [RTA_METRICS]	  = { 1, 0, 0 },
+  [RTA_MULTIPATH] = { 1, 0, 0 },
+  [RTA_FLOW]	  = { 1, 1, sizeof(u32) },
+  [RTA_TABLE]	  = { 1, 1, sizeof(u32) },
+};
+#else
+static struct nl_want_attrs rtm_attr_want6[BIRD_RTA_MAX] = {
+  [RTA_DST]	  = { 1, 1, sizeof(ip6_addr) },
+  [RTA_IIF]	  = { 1, 1, sizeof(u32) },
+  [RTA_OIF]	  = { 1, 1, sizeof(u32) },
+  [RTA_GATEWAY]	  = { 1, 1, sizeof(ip6_addr) },
+  [RTA_PRIORITY]  = { 1, 1, sizeof(u32) },
+  [RTA_PREFSRC]	  = { 1, 1, sizeof(ip6_addr) },
+  [RTA_METRICS]	  = { 1, 0, 0 },
+  [RTA_FLOW]	  = { 1, 1, sizeof(u32) },
+  [RTA_TABLE]	  = { 1, 1, sizeof(u32) },
+};
+#endif
+
+
 static int
-nl_parse_attrs(struct rtattr *a, struct rtattr **k, int ksize)
+nl_parse_attrs(struct rtattr *a, struct nl_want_attrs *want, struct rtattr **k, int ksize)
 {
   int max = ksize / sizeof(struct rtattr *);
   bzero(k, ksize);
-  while (RTA_OK(a, nl_attr_len))
+
+  for ( ; RTA_OK(a, nl_attr_len); a = RTA_NEXT(a, nl_attr_len))
     {
-      if (a->rta_type < max)
-	k[a->rta_type] = a;
-      a = RTA_NEXT(a, nl_attr_len);
+      if ((a->rta_type >= max) || !want[a->rta_type].defined)
+	continue;
+
+      if (want[a->rta_type].checksize && (RTA_PAYLOAD(a) != want[a->rta_type].size))
+	{
+	  log(L_ERR "nl_parse_attrs: Malformed message received");
+	  return 0;
+	}
+
+      k[a->rta_type] = a;
     }
+
   if (nl_attr_len)
     {
       log(L_ERR "nl_parse_attrs: remnant of size %d", nl_attr_len);
       return 0;
     }
-  else
-    return 1;
+
+  return 1;
 }
 
 static inline u32 rta_get_u32(struct rtattr *a)
@@ -350,7 +424,7 @@ nl_parse_multipath(struct krt_proto *p, struct rtattr *ra)
   static int nh_buf_size;	/* in number of structures */
   static int nh_buf_used;
 
-  struct rtattr *a[RTA_CACHEINFO+1];
+  struct rtattr *a[BIRD_RTA_MAX];
   struct rtnexthop *nh = RTA_DATA(ra);
   struct mpnh *rv, *first, **last;
   int len = RTA_PAYLOAD(ra);
@@ -381,12 +455,9 @@ nl_parse_multipath(struct krt_proto *p, struct rtattr *ra)
 
       /* Nonexistent RTNH_PAYLOAD ?? */
       nl_attr_len = nh->rtnh_len - RTNH_LENGTH(0);
-      nl_parse_attrs(RTNH_DATA(nh), a, sizeof(a));
+      nl_parse_attrs(RTNH_DATA(nh), mpnh_attr_want4, a, sizeof(a));
       if (a[RTA_GATEWAY])
 	{
-	  if (RTA_PAYLOAD(a[RTA_GATEWAY]) != sizeof(ip_addr))
-	    return NULL;
-
 	  memcpy(&rv->gw, RTA_DATA(a[RTA_GATEWAY]), sizeof(ip_addr));
 	  ipa_ntoh(rv->gw);
 
@@ -455,7 +526,7 @@ static void
 nl_parse_link(struct nlmsghdr *h, int scan)
 {
   struct ifinfomsg *i;
-  struct rtattr *a[IFLA_WIRELESS+1];
+  struct rtattr *a[BIRD_IFLA_MAX];
   int new = h->nlmsg_type == RTM_NEWLINK;
   struct iface f = {};
   struct iface *ifi;
@@ -463,15 +534,23 @@ nl_parse_link(struct nlmsghdr *h, int scan)
   u32 mtu;
   uint fl;
 
-  if (!(i = nl_checkin(h, sizeof(*i))) || !nl_parse_attrs(IFLA_RTA(i), a, sizeof(a)))
+  if (!(i = nl_checkin(h, sizeof(*i))) || !nl_parse_attrs(IFLA_RTA(i), ifla_attr_want, a, sizeof(a)))
     return;
-  if (!a[IFLA_IFNAME] || RTA_PAYLOAD(a[IFLA_IFNAME]) < 2 ||
-      !a[IFLA_MTU] || RTA_PAYLOAD(a[IFLA_MTU]) != 4)
+  if (!a[IFLA_IFNAME] || (RTA_PAYLOAD(a[IFLA_IFNAME]) < 2) || !a[IFLA_MTU])
     {
-      if (scan || !a[IFLA_WIRELESS])
-        log(L_ERR "nl_parse_link: Malformed message received");
+      /*
+       * IFLA_IFNAME and IFLA_MTU are required, in fact, but there may also come
+       * a message with IFLA_WIRELESS set, where (e.g.) no IFLA_IFNAME exists.
+       * We simply ignore all such messages with IFLA_WIRELESS without notice.
+       */
+
+      if (a[IFLA_WIRELESS])
+	return;
+
+      log(L_ERR "KIF: Malformed message received");
       return;
     }
+
   name = RTA_DATA(a[IFLA_IFNAME]);
   mtu = rta_get_u32(a[IFLA_MTU]);
 
@@ -522,26 +601,40 @@ static void
 nl_parse_addr(struct nlmsghdr *h, int scan)
 {
   struct ifaddrmsg *i;
-  struct rtattr *a[IFA_ANYCAST+1];
+  struct rtattr *a[BIRD_IFA_MAX];
   int new = h->nlmsg_type == RTM_NEWADDR;
   struct ifa ifa;
   struct iface *ifi;
   int scope;
 
-  if (!(i = nl_checkin(h, sizeof(*i))) || !nl_parse_attrs(IFA_RTA(i), a, sizeof(a)))
+  if (!(i = nl_checkin(h, sizeof(*i))))
     return;
-  if (i->ifa_family != BIRD_AF)
-    return;
-  if (!a[IFA_ADDRESS] || RTA_PAYLOAD(a[IFA_ADDRESS]) != sizeof(ip_addr)
-#ifdef IPV6
-      || a[IFA_LOCAL] && RTA_PAYLOAD(a[IFA_LOCAL]) != sizeof(ip_addr)
+
+  switch (i->ifa_family)
+    {
+#ifndef IPV6
+      case AF_INET:
+	if (!nl_parse_attrs(IFA_RTA(i), ifa_attr_want4, a, sizeof(a)))
+	  return;
+	if (!a[IFA_LOCAL])
+	  {
+	    log(L_ERR "KIF: Malformed message received (missing IFA_LOCAL)");
+	    return;
+	  }
+	break;
 #else
-      || !a[IFA_LOCAL] || RTA_PAYLOAD(a[IFA_LOCAL]) != sizeof(ip_addr)
-      || (a[IFA_BROADCAST] && RTA_PAYLOAD(a[IFA_BROADCAST]) != sizeof(ip_addr))
+      case AF_INET6:
+	if (!nl_parse_attrs(IFA_RTA(i), ifa_attr_want6, a, sizeof(a)))
+	  return;
+	break;
 #endif
-      )
+      default:
+	return;
+    }
+
+  if (!a[IFA_ADDRESS])
     {
-      log(L_ERR "nl_parse_addr: Malformed message received");
+      log(L_ERR "KIF: Malformed message received (missing IFA_ADDRESS)");
       return;
     }
 
@@ -835,7 +928,7 @@ nl_parse_route(struct nlmsghdr *h, int scan)
 {
   struct krt_proto *p;
   struct rtmsg *i;
-  struct rtattr *a[RTA_TABLE+1];
+  struct rtattr *a[BIRD_RTA_MAX];
   int new = h->nlmsg_type == RTM_NEWROUTE;
 
   ip_addr dst = IPA_NONE;
@@ -843,25 +936,27 @@ nl_parse_route(struct nlmsghdr *h, int scan)
   u32 table;
   int src;
 
-  if (!(i = nl_checkin(h, sizeof(*i))) || !nl_parse_attrs(RTM_RTA(i), a, sizeof(a)))
+  if (!(i = nl_checkin(h, sizeof(*i))))
     return;
-  if (i->rtm_family != BIRD_AF)
-    return;
-  if ((a[RTA_DST] && RTA_PAYLOAD(a[RTA_DST]) != sizeof(ip_addr)) ||
-#ifdef IPV6
-      (a[RTA_IIF] && RTA_PAYLOAD(a[RTA_IIF]) != 4) ||
-#endif
-      (a[RTA_OIF] && RTA_PAYLOAD(a[RTA_OIF]) != 4) ||
-      (a[RTA_TABLE] && RTA_PAYLOAD(a[RTA_TABLE]) != 4) ||
-      (a[RTA_GATEWAY] && RTA_PAYLOAD(a[RTA_GATEWAY]) != sizeof(ip_addr)) ||
-      (a[RTA_PRIORITY] && RTA_PAYLOAD(a[RTA_PRIORITY]) != 4) ||
-      (a[RTA_PREFSRC] && RTA_PAYLOAD(a[RTA_PREFSRC]) != sizeof(ip_addr)) ||
-      (a[RTA_FLOW] && RTA_PAYLOAD(a[RTA_FLOW]) != 4))
+
+  switch (i->rtm_family)
     {
-      log(L_ERR "KRT: Malformed message received");
-      return;
+#ifndef IPV6
+      case AF_INET:
+	if (!nl_parse_attrs(RTM_RTA(i), rtm_attr_want4, a, sizeof(a)))
+	  return;
+	break;
+#else
+      case AF_INET6:
+	if (!nl_parse_attrs(RTM_RTA(i), rtm_attr_want6, a, sizeof(a)))
+	  return;
+	break;
+#endif
+      default:
+	return;
     }
 
+
   if (a[RTA_DST])
     {
       memcpy(&dst, RTA_DATA(a[RTA_DST]), sizeof(dst));
@@ -938,7 +1033,7 @@ nl_parse_route(struct nlmsghdr *h, int scan)
     {
     case RTN_UNICAST:
 
-      if (a[RTA_MULTIPATH])
+      if (a[RTA_MULTIPATH] && (i->rtm_family == AF_INET))
 	{
 	  ra.dest = RTD_MULTIPATH;
 	  ra.nexthops = nl_parse_multipath(p, a[RTA_MULTIPATH]);

From 33b4f40acce02c90b4b7766c5c94ebf2d22765c6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pavel=20Tvrd=C3=ADk?= <pawel.tvrdik@gmail.com>
Date: Fri, 13 Nov 2015 16:08:28 +0100
Subject: [PATCH 044/165] MD5: Mormalize naming style

---
 lib/md5.c           | 442 +++++++++++++++++++++++++-------------------
 lib/md5.h           |  55 ++++--
 proto/ospf/packet.c |  31 ++--
 proto/rip/packets.c |  18 +-
 4 files changed, 322 insertions(+), 224 deletions(-)

diff --git a/lib/md5.c b/lib/md5.c
index ad284f07..8efa62d6 100644
--- a/lib/md5.c
+++ b/lib/md5.c
@@ -1,154 +1,159 @@
 /*
- * This code implements the MD5 message-digest algorithm.
- * The algorithm is due to Ron Rivest.  This code was
- * written by Colin Plumb in 1993, no copyright is claimed.
- * This code is in the public domain; do with it what you wish.
+ *	BIRD Library -- MD5 Hash Function and HMAC-MD5 Function
  *
- * Equivalent code is available from RSA Data Security, Inc.
- * This code has been tested against that, and is equivalent,
- * except that you don't need to include two pages of legalese
- * with every copy.
+ *	(c) 2015 CZ.NIC z.s.p.o.
  *
- * To compute the message digest of a chunk of bytes, declare an
- * MD5Context structure, pass it to MD5Init, call MD5Update as
- * needed on buffers full of bytes, and then call MD5Final, which
- * will fill a supplied 16-byte array with the digest.
- */
-
-/*
- * Adapted for BIRD by Martin Mares <mj@atrey.karlin.mff.cuni.cz>
+ *	The code was written by Colin Plumb in 1993, no copyright is claimed.
+ *
+ *	Adapted for BIRD by Martin Mares <mj@ucw.cz>
+ *
+ *	Can be freely distributed and used under the terms of the GNU GPL.
  */
 
-#include "nest/bird.h"
-#include "lib/string.h"
-#include "md5.h"
+#include "lib/md5.h"
 
 #ifdef CPU_LITTLE_ENDIAN
 #define byteReverse(buf, len)	/* Nothing */
 #else
-void byteReverse(unsigned char *buf, unsigned longs);
+void byteReverse(byte *buf, uint longs);
 
 /*
  * Note: this code is harmless on little-endian machines.
  */
-void byteReverse(unsigned char *buf, unsigned longs)
+void byteReverse(byte *buf, uint longs)
 {
-    u32 t;
-    do {
-	t = (u32) ((unsigned) buf[3] << 8 | buf[2]) << 16 |
-	    ((unsigned) buf[1] << 8 | buf[0]);
-	*(u32 *) buf = t;
-	buf += 4;
-    } while (--longs);
+  u32 t;
+  do {
+    t = (u32) ((uint) buf[3] << 8 | buf[2]) << 16 |
+	((uint) buf[1] << 8 | buf[0]);
+    *(u32 *) buf = t;
+    buf += 4;
+  } while (--longs);
 }
 #endif
 
+static void md5_transform(u32 buf[4], u32 const in[16]);
+
 /*
  * Start MD5 accumulation.  Set bit count to 0 and buffer to mysterious
  * initialization constants.
  */
-void MD5Init(struct MD5Context *ctx)
+void
+md5_init(struct md5_context *ctx)
 {
-    ctx->buf[0] = 0x67452301;
-    ctx->buf[1] = 0xefcdab89;
-    ctx->buf[2] = 0x98badcfe;
-    ctx->buf[3] = 0x10325476;
+  ctx->buf[0] = 0x67452301;
+  ctx->buf[1] = 0xefcdab89;
+  ctx->buf[2] = 0x98badcfe;
+  ctx->buf[3] = 0x10325476;
 
-    ctx->bits[0] = 0;
-    ctx->bits[1] = 0;
+  ctx->bits[0] = 0;
+  ctx->bits[1] = 0;
 }
 
 /*
  * Update context to reflect the concatenation of another buffer full
  * of bytes.
  */
-void MD5Update(struct MD5Context *ctx, unsigned char const *buf, unsigned len)
+void
+md5_update(struct md5_context *ctx, const byte *buf, uint len)
 {
-    u32 t;
+  u32 t;
 
-    /* Update bitcount */
+  /* Update bitcount */
 
-    t = ctx->bits[0];
-    if ((ctx->bits[0] = t + ((u32) len << 3)) < t)
-	ctx->bits[1]++;		/* Carry from low to high */
-    ctx->bits[1] += len >> 29;
+  t = ctx->bits[0];
+  if ((ctx->bits[0] = t + ((u32) len << 3)) < t)
+    ctx->bits[1]++;		/* Carry from low to high */
+  ctx->bits[1] += len >> 29;
 
-    t = (t >> 3) & 0x3f;	/* Bytes already in shsInfo->data */
+  t = (t >> 3) & 0x3f;	/* Bytes already in shsInfo->data */
 
-    /* Handle any leading odd-sized chunks */
+  /* Handle any leading odd-sized chunks */
+  if (t)
+  {
+    byte *p = (byte *) ctx->in + t;
 
-    if (t) {
-	unsigned char *p = (unsigned char *) ctx->in + t;
-
-	t = 64 - t;
-	if (len < t) {
-	    memcpy(p, buf, len);
-	    return;
-	}
-	memcpy(p, buf, t);
-	byteReverse(ctx->in, 16);
-	MD5Transform(ctx->buf, (u32 *) ctx->in);
-	buf += t;
-	len -= t;
-    }
-    /* Process data in 64-byte chunks */
-
-    while (len >= 64) {
-	memcpy(ctx->in, buf, 64);
-	byteReverse(ctx->in, 16);
-	MD5Transform(ctx->buf, (u32 *) ctx->in);
-	buf += 64;
-	len -= 64;
+    t = 64 - t;
+    if (len < t)
+    {
+      memcpy(p, buf, len);
+      return;
     }
-
-    /* Handle any remaining bytes of data. */
-
-    memcpy(ctx->in, buf, len);
+    memcpy(p, buf, t);
+    byteReverse(ctx->in, 16);
+    md5_transform(ctx->buf, (u32 *) ctx->in);
+    buf += t;
+    len -= t;
+  }
+
+  /* Process data in 64-byte chunks */
+  while (len >= 64)
+  {
+    memcpy(ctx->in, buf, 64);
+    byteReverse(ctx->in, 16);
+    md5_transform(ctx->buf, (u32 *) ctx->in);
+    buf += 64;
+    len -= 64;
+  }
+
+  /* Handle any remaining bytes of data. */
+  memcpy(ctx->in, buf, len);
 }
 
 /*
- * Final wrapup - pad to 64-byte boundary with the bit pattern 
+ * Final wrapup - pad to 64-byte boundary with the bit pattern
  * 1 0* (64-bit count of bits processed, MSB-first)
  */
-void MD5Final(unsigned char digest[16], struct MD5Context *ctx)
+byte *
+md5_final(struct md5_context *ctx)
 {
-    unsigned count;
-    unsigned char *p;
+  uint count;
+  byte *p;
 
-    /* Compute number of bytes mod 64 */
-    count = (ctx->bits[0] >> 3) & 0x3F;
+  /* Compute number of bytes mod 64 */
+  count = (ctx->bits[0] >> 3) & 0x3F;
 
-    /* Set the first char of padding to 0x80.  This is safe since there is
+  /* Set the first char of padding to 0x80.  This is safe since there is
        always at least one byte free */
-    p = ctx->in + count;
-    *p++ = 0x80;
-
-    /* Bytes of padding needed to make 64 bytes */
-    count = 64 - 1 - count;
-
-    /* Pad out to 56 mod 64 */
-    if (count < 8) {
-	/* Two lots of padding:  Pad the first block to 64 bytes */
-	memset(p, 0, count);
-	byteReverse(ctx->in, 16);
-	MD5Transform(ctx->buf, (u32 *) ctx->in);
-
-	/* Now fill the next block with 56 bytes */
-	memset(ctx->in, 0, 56);
-    } else {
-	/* Pad block to 56 bytes */
-	memset(p, 0, count - 8);
-    }
-    byteReverse(ctx->in, 14);
-
-    /* Append length in bits and transform */
-    ((u32 *) ctx->in)[14] = ctx->bits[0];
-    ((u32 *) ctx->in)[15] = ctx->bits[1];
+  p = ctx->in + count;
+  *p++ = 0x80;
+
+  /* Bytes of padding needed to make 64 bytes */
+  count = 64 - 1 - count;
+
+  /* Pad out to 56 mod 64 */
+  if (count < 8)
+  {
+    /* Two lots of padding:  Pad the first block to 64 bytes */
+    memset(p, 0, count);
+    byteReverse(ctx->in, 16);
+    md5_transform(ctx->buf, (u32 *) ctx->in);
+
+    /* Now fill the next block with 56 bytes */
+    memset(ctx->in, 0, 56);
+  }
+  else
+  {
+    /* Pad block to 56 bytes */
+    memset(p, 0, count - 8);
+  }
+  byteReverse(ctx->in, 14);
+
+  /* Append length in bits and transform */
+  ((u32 *) ctx->in)[14] = ctx->bits[0];
+  ((u32 *) ctx->in)[15] = ctx->bits[1];
+
+  md5_transform(ctx->buf, (u32 *) ctx->in);
+  byteReverse((byte *) ctx->buf, 4);
+
+  return (byte*) ctx->buf;
+}
 
-    MD5Transform(ctx->buf, (u32 *) ctx->in);
-    byteReverse((unsigned char *) ctx->buf, 4);
-    memcpy(digest, ctx->buf, 16);
-    memset((char *) ctx, 0, sizeof(ctx));	/* In case it's sensitive */
+/* I am a hard paranoid */
+void
+md5_erase_ctx(struct md5_context *ctx)
+{
+  memset((char *) ctx, 0, sizeof(*ctx));	/* In case it's sensitive */
 }
 
 /* The four core functions - F1 is optimized somewhat */
@@ -161,92 +166,157 @@ void MD5Final(unsigned char digest[16], struct MD5Context *ctx)
 
 /* This is the central step in the MD5 algorithm. */
 #define MD5STEP(f, w, x, y, z, data, s) \
-	( w += f(x, y, z) + data,  w = w<<s | w>>(32-s),  w += x )
+    ( w += f(x, y, z) + data,  w = w<<s | w>>(32-s),  w += x )
 
 /*
  * The core of the MD5 algorithm, this alters an existing MD5 hash to
  * reflect the addition of 16 longwords of new data.  MD5Update blocks
  * the data and converts bytes into longwords for this routine.
  */
-void MD5Transform(u32 buf[4], u32 const in[16])
+void
+md5_transform(u32 buf[4], u32 const in[16])
+{
+  register u32 a, b, c, d;
+
+  a = buf[0];
+  b = buf[1];
+  c = buf[2];
+  d = buf[3];
+
+  MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
+  MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
+  MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
+  MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
+  MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
+  MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
+  MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
+  MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
+  MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
+  MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
+  MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
+  MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
+  MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
+  MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
+  MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
+  MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);
+
+  MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
+  MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
+  MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
+  MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
+  MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
+  MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
+  MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
+  MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
+  MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
+  MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
+  MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
+  MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
+  MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
+  MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
+  MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
+  MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
+
+  MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
+  MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
+  MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
+  MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
+  MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
+  MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
+  MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
+  MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
+  MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
+  MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
+  MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
+  MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
+  MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
+  MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
+  MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
+  MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
+
+  MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
+  MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
+  MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
+  MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
+  MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
+  MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
+  MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
+  MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
+  MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
+  MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
+  MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
+  MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
+  MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
+  MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
+  MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
+  MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
+
+  buf[0] += a;
+  buf[1] += b;
+  buf[2] += c;
+  buf[3] += d;
+}
+
+
+/*
+ * 	MD5-HMAC
+ */
+
+static void
+md5_hash_buffer(byte *outbuf, const byte *buffer, size_t length)
+{
+  struct md5_context hd_tmp;
+
+  md5_init(&hd_tmp);
+  md5_update(&hd_tmp, buffer, length);
+  memcpy(outbuf, md5_final(&hd_tmp), MD5_SIZE);
+}
+
+void
+md5_hmac_init(struct md5_hmac_context *ctx, const byte *key, size_t keylen)
+{
+  byte keybuf[MD5_BLOCK_SIZE], buf[MD5_BLOCK_SIZE];
+
+  /* Hash the key if necessary */
+  if (keylen <= MD5_BLOCK_SIZE)
+  {
+    memcpy(keybuf, key, keylen);
+    bzero(keybuf + keylen, MD5_BLOCK_SIZE - keylen);
+  }
+  else
+  {
+    md5_hash_buffer(keybuf, key, keylen);
+    bzero(keybuf + MD5_SIZE, MD5_BLOCK_SIZE - MD5_SIZE);
+  }
+
+  /* Initialize the inner digest */
+  md5_init(&ctx->ictx);
+  int i;
+  for (i = 0; i < MD5_BLOCK_SIZE; i++)
+    buf[i] = keybuf[i] ^ 0x36;
+  md5_update(&ctx->ictx, buf, MD5_BLOCK_SIZE);
+
+  /* Initialize the outer digest */
+  md5_init(&ctx->octx);
+  for (i = 0; i < MD5_BLOCK_SIZE; i++)
+    buf[i] = keybuf[i] ^ 0x5c;
+  md5_update(&ctx->octx, buf, MD5_BLOCK_SIZE);
+}
+
+void
+md5_hmac_update(struct md5_hmac_context *ctx, const byte *buf, size_t buflen)
 {
-    register u32 a, b, c, d;
-
-    a = buf[0];
-    b = buf[1];
-    c = buf[2];
-    d = buf[3];
-
-    MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
-    MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
-    MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
-    MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
-    MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
-    MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
-    MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
-    MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
-    MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
-    MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
-    MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
-    MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
-    MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
-    MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
-    MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
-    MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);
-
-    MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
-    MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
-    MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
-    MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
-    MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
-    MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
-    MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
-    MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
-    MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
-    MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
-    MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
-    MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
-    MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
-    MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
-    MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
-    MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
-
-    MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
-    MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
-    MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
-    MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
-    MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
-    MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
-    MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
-    MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
-    MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
-    MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
-    MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
-    MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
-    MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
-    MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
-    MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
-    MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
-
-    MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
-    MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
-    MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
-    MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
-    MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
-    MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
-    MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
-    MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
-    MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
-    MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
-    MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
-    MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
-    MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
-    MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
-    MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
-    MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
-
-    buf[0] += a;
-    buf[1] += b;
-    buf[2] += c;
-    buf[3] += d;
+  /* Just update the inner digest */
+  md5_update(&ctx->ictx, buf, buflen);
+}
+
+byte *
+md5_hmac_final(struct md5_hmac_context *ctx)
+{
+  /* Finish the inner digest */
+  byte *isha = md5_final(&ctx->ictx);
+
+  /* Finish the outer digest */
+  md5_update(&ctx->octx, isha, MD5_SIZE);
+  return md5_final(&ctx->octx);
 }
diff --git a/lib/md5.h b/lib/md5.h
index 12586357..034d764c 100644
--- a/lib/md5.h
+++ b/lib/md5.h
@@ -1,16 +1,47 @@
-#ifndef MD5_H
-#define MD5_H
+/*
+ *	BIRD Library -- MD5 Hash Function and HMAC-MD5 Function
+ *
+ *	(c) 2015 CZ.NIC z.s.p.o.
+ *
+ *	Adapted for BIRD by Martin Mares <mj@ucw.cz>
+ *
+ *	Can be freely distributed and used under the terms of the GNU GPL.
+ */
 
-struct MD5Context {
-	u32 buf[4];
-	u32 bits[2];
-	unsigned char in[64];
+#ifndef _BIRD_MD5_H_
+#define _BIRD_MD5_H_
+
+#include "nest/bird.h"
+
+
+#define MD5_SIZE		16
+#define MD5_HEX_SIZE		33
+#define MD5_BLOCK_SIZE		64
+
+
+struct md5_context {
+  u32 buf[4];
+  u32 bits[2];
+  byte in[64];
 };
 
-void MD5Init(struct MD5Context *context);
-void MD5Update(struct MD5Context *context, unsigned char const *buf,
-	       unsigned len);
-void MD5Final(unsigned char digest[16], struct MD5Context *context);
-void MD5Transform(u32 buf[4], u32 const in[16]);
+void md5_init(struct md5_context *ctx);
+void md5_update(struct md5_context *ctx, const byte *buf, uint len);
+byte *md5_final(struct md5_context *ctx);
+
+
+/*
+ *	HMAC-MD5
+ */
+
+struct md5_hmac_context {
+  struct md5_context ictx;
+  struct md5_context octx;
+};
+
+void md5_hmac_init(struct md5_hmac_context *ctx, const byte *key, size_t keylen);
+void md5_hmac_update(struct md5_hmac_context *ctx, const byte *buf, size_t buflen);
+byte *md5_hmac_final(struct md5_hmac_context *ctx);
+
 
-#endif /* !MD5_H */
+#endif /* _BIRD_MD5_H_ */
diff --git a/proto/ospf/packet.c b/proto/ospf/packet.c
index 5af9e875..faa33664 100644
--- a/proto/ospf/packet.c
+++ b/proto/ospf/packet.c
@@ -11,6 +11,7 @@
 #include "ospf.h"
 #include "nest/password.h"
 #include "lib/md5.h"
+#include "lib/socket.h"
 
 void
 ospf_pkt_fill_hdr(struct ospf_iface *ifa, void *buf, u8 h_type)
@@ -108,11 +109,11 @@ ospf_pkt_finalize(struct ospf_iface *ifa, struct ospf_packet *pkt)
     char password[OSPF_AUTH_CRYPT_SIZE];
     strncpy(password, passwd->password, sizeof(password));
 
-    struct MD5Context ctxt;
-    MD5Init(&ctxt);
-    MD5Update(&ctxt, (char *) pkt, plen);
-    MD5Update(&ctxt, password, OSPF_AUTH_CRYPT_SIZE);
-    MD5Final(tail, &ctxt);
+    struct md5_context ctx;
+    md5_init(&ctx);
+    md5_update(&ctx, (char *) pkt, plen);
+    md5_update(&ctx, password, OSPF_AUTH_CRYPT_SIZE);
+    memcpy((byte *) tail, md5_final(&ctx), MD5_SIZE);
     break;
 
   default:
@@ -174,19 +175,17 @@ ospf_pkt_checkauth(struct ospf_neighbor *n, struct ospf_iface *ifa, struct ospf_
     if (!pass)
       DROP("no suitable password found", auth->md5.keyid);
 
-    void *tail = ((void *) pkt) + plen;
-    char passwd[OSPF_AUTH_CRYPT_SIZE];
-    char md5sum[OSPF_AUTH_CRYPT_SIZE];
-
-    strncpy(passwd, pass->password, OSPF_AUTH_CRYPT_SIZE);
+    byte *tail = ((byte *) pkt) + plen;
+    char received[OSPF_AUTH_CRYPT_SIZE];
+    memcpy(received, tail, OSPF_AUTH_CRYPT_SIZE);
+    strncpy(tail, pass->password, OSPF_AUTH_CRYPT_SIZE);
 
-    struct MD5Context ctxt;
-    MD5Init(&ctxt);
-    MD5Update(&ctxt, (char *) pkt, plen);
-    MD5Update(&ctxt, passwd, OSPF_AUTH_CRYPT_SIZE);
-    MD5Final(md5sum, &ctxt);
+    struct md5_context ctx;
+    md5_init(&ctx);
+    md5_update(&ctx, (byte *) pkt, plen + OSPF_AUTH_CRYPT_SIZE);
+    char *computed = md5_final(&ctx);
 
-    if (memcmp(md5sum, tail, OSPF_AUTH_CRYPT_SIZE))
+    if (memcmp(received, computed, OSPF_AUTH_CRYPT_SIZE))
       DROP("wrong MD5 digest", pass->id);
 
     if (n)
diff --git a/proto/rip/packets.c b/proto/rip/packets.c
index be20734f..9f10fd67 100644
--- a/proto/rip/packets.c
+++ b/proto/rip/packets.c
@@ -241,10 +241,10 @@ rip_fill_authentication(struct rip_proto *p, struct rip_iface *ifa, struct rip_p
 
     *plen += sizeof(struct rip_auth_tail) + RIP_MD5_LENGTH;
 
-    struct MD5Context ctxt;
-    MD5Init(&ctxt);
-    MD5Update(&ctxt, (byte *) pkt, *plen);
-    MD5Final(tail->auth_data, &ctxt);
+    struct md5_context ctx;
+    md5_init(&ctx);
+    md5_update(&ctx, (byte *) pkt, *plen);
+    memcpy(tail->auth_data, md5_final(&ctx), RIP_MD5_LENGTH);
     return;
 
   default:
@@ -312,15 +312,13 @@ rip_check_authentication(struct rip_proto *p, struct rip_iface *ifa, struct rip_
     }
 
     char received[RIP_MD5_LENGTH];
-    char computed[RIP_MD5_LENGTH];
-
     memcpy(received, tail->auth_data, RIP_MD5_LENGTH);
     strncpy(tail->auth_data, pass->password, RIP_MD5_LENGTH);
 
-    struct MD5Context ctxt;
-    MD5Init(&ctxt);
-    MD5Update(&ctxt, (byte *) pkt, *plen);
-    MD5Final(computed, &ctxt);
+    struct md5_context ctx;
+    md5_init(&ctx);
+    md5_update(&ctx, (byte *) pkt, *plen);
+    char *computed = md5_final(&ctx);
 
     if (memcmp(received, computed, RIP_MD5_LENGTH))
       DROP("wrong MD5 digest", pass->id);

From 52e21323b6c49af9d076586241451973a7d1e7c6 Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Wed, 25 Nov 2015 15:52:58 +0100
Subject: [PATCH 045/165] BGP: Update capability number from IANA for extended
 messages

---
 proto/bgp/packets.c | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/proto/bgp/packets.c b/proto/bgp/packets.c
index ed99f623..72ca3728 100644
--- a/proto/bgp/packets.c
+++ b/proto/bgp/packets.c
@@ -163,6 +163,14 @@ bgp_put_cap_rr(struct bgp_proto *p UNUSED, byte *buf)
   return buf;
 }
 
+static byte *
+bgp_put_cap_ext_msg(struct bgp_proto *p UNUSED, byte *buf)
+{
+  *buf++ = 6;		/* Capability 6: Support for extended messages */
+  *buf++ = 0;		/* Capability data length */
+  return buf;
+}
+
 static byte *
 bgp_put_cap_gr1(struct bgp_proto *p, byte *buf)
 {
@@ -223,14 +231,6 @@ bgp_put_cap_err(struct bgp_proto *p UNUSED, byte *buf)
   return buf;
 }
 
-static byte *
-bgp_put_cap_ext_msg(struct bgp_proto *p UNUSED, byte *buf)
-{
-  *buf++ = 230;		/* Capability TBD: Support for extended messages */
-  *buf++ = 0;		/* Capability data length */
-  return buf;
-}
-
 
 static byte *
 bgp_create_open(struct bgp_conn *conn, byte *buf)
@@ -827,6 +827,12 @@ bgp_parse_capabilities(struct bgp_conn *conn, byte *opt, int len)
 	  conn->peer_refresh_support = 1;
 	  break;
 
+	case 6: /* Extended message length capability, draft */
+	  if (cl != 0)
+	    goto err;
+	  conn->peer_ext_messages_support = 1;
+	  break;
+
 	case 64: /* Graceful restart capability, RFC 4724 */
 	  if (cl % 4 != 2)
 	    goto err;
@@ -867,12 +873,6 @@ bgp_parse_capabilities(struct bgp_conn *conn, byte *opt, int len)
 	  conn->peer_enhanced_refresh_support = 1;
 	  break;
 
-	case 230: /* Extended message length capability, draft, cap number TBD */
-	  if (cl != 0)
-	    goto err;
-	  conn->peer_ext_messages_support = 1;
-	  break;
-
 	  /* We can safely ignore all other capabilities */
 	}
       len -= 2 + cl;

From 487c6961cb29046dbe9560262e3e742e38691b83 Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Thu, 11 Feb 2016 16:38:28 +0100
Subject: [PATCH 046/165] BGP: Fix bug in incoming connection handling

When a BGP session was established by an outgoing connection with
Graceful Restart behavior negotiated, a pending incoming connection in
OpenSent state, and another incoming connection was received, then the
outgoing connection (and whole BGP session) was closed, but the old
incoming connection was just overwritten by the new one. That later
caused a crash when the hold timer from the old connection fired.
---
 proto/bgp/bgp.c | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/proto/bgp/bgp.c b/proto/bgp/bgp.c
index f549b0ed..11f33b14 100644
--- a/proto/bgp/bgp.c
+++ b/proto/bgp/bgp.c
@@ -813,7 +813,13 @@ bgp_incoming_connection(sock *sk, int dummy UNUSED)
       return 0;
     }
 
-  /* We are in proper state and there is no other incoming connection */
+  /*
+   * BIRD should keep multiple incoming connections in OpenSent state (for
+   * details RFC 4271 8.2.1 par 3), but it keeps just one. Duplicate incoming
+   * connections are rejected istead. The exception is the case where an
+   * incoming connection triggers a graceful restart.
+   */
+
   acc = (p->p.proto_state == PS_START || p->p.proto_state == PS_UP) &&
     (p->start_state >= BSS_CONNECT) && (!p->incoming_conn.sk);
 
@@ -823,6 +829,10 @@ bgp_incoming_connection(sock *sk, int dummy UNUSED)
       bgp_handle_graceful_restart(p);
       bgp_conn_enter_idle_state(p->conn);
       acc = 1;
+
+      /* There might be separate incoming connection in OpenSent state */
+      if (p->incoming_conn.state > BS_ACTIVE)
+	bgp_close_conn(&p->incoming_conn);
     }
 
   BGP_TRACE(D_EVENTS, "Incoming connection from %I%J (port %d) %s",

From c2106b674ca632f7c0bffd7cab4b1940f74d353c Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Thu, 11 Feb 2016 21:53:55 +0100
Subject: [PATCH 047/165] Unix: Fix bug in syslog name handling

Pointer to current_log_name has to be changed even if the name is the
same, because the old one will be invalid/freed after reconfiguration.
---
 sysdep/unix/log.c | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/sysdep/unix/log.c b/sysdep/unix/log.c
index 7cb26360..b90bbbd2 100644
--- a/sysdep/unix/log.c
+++ b/sysdep/unix/log.c
@@ -284,17 +284,18 @@ log_switch(int debug, list *l, char *new_syslog_name)
   current_log_list = l;
 
 #ifdef HAVE_SYSLOG
-  if (current_syslog_name && new_syslog_name &&
-      !strcmp(current_syslog_name, new_syslog_name))
+  char *old_syslog_name = current_syslog_name;
+  current_syslog_name = new_syslog_name;
+
+  if (old_syslog_name && new_syslog_name &&
+      !strcmp(old_syslog_name, new_syslog_name))
     return;
 
-  if (current_syslog_name)
+  if (old_syslog_name)
     closelog();
 
   if (new_syslog_name)
     openlog(new_syslog_name, LOG_CONS | LOG_NDELAY, LOG_DAEMON);
-
-  current_syslog_name = new_syslog_name;
 #endif
 }
 

From 9c9cc35c0273f8bcae10fb8b546d199514b2bbc5 Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Tue, 16 Feb 2016 17:33:58 +0100
Subject: [PATCH 048/165] Filter: Implement last_nonaggregated operator on
 bgp_path

---
 doc/bird.sgml   |  5 ++++-
 filter/config.Y |  3 ++-
 filter/filter.c |  8 ++++++++
 nest/a-path.c   | 31 ++++++++++++++++++++++++++++++-
 nest/attrs.h    |  1 +
 5 files changed, 45 insertions(+), 3 deletions(-)

diff --git a/doc/bird.sgml b/doc/bird.sgml
index 86df0456..c5316d87 100644
--- a/doc/bird.sgml
+++ b/doc/bird.sgml
@@ -1119,9 +1119,12 @@ foot).
 
 	<cf><m/P/.last</cf> returns the last ASN (the source ASN) in path <m/P/.
 
+	<cf><m/P/.last_nonaggregated</cf> returns the last ASN in the non-aggregated part of the path <m/P/.
+
 	Both <cf/first/ and <cf/last/ return zero if there is no appropriate
 	ASN, for example if the path contains an AS set element as the first (or
-	the last) part.
+	the last) part. If the path ends with an AS set, <cf/last_nonaggregated/
+	may be used to get last ASN before any AS set.
 
 	<cf><m/P/.len</cf> returns the length of path <m/P/.
 
diff --git a/filter/config.Y b/filter/config.Y
index 7eb2c0a3..b94f5dff 100644
--- a/filter/config.Y
+++ b/filter/config.Y
@@ -283,7 +283,7 @@ CF_KEYWORDS(FUNCTION, PRINT, PRINTN, UNSET, RETURN,
 	LEN,
 	DEFINED,
 	ADD, DELETE, CONTAINS, RESET,
-	PREPEND, FIRST, LAST, MATCH,
+	PREPEND, FIRST, LAST, LAST_NONAGGREGATED, MATCH,
 	ROA_CHECK,
 	EMPTY,
 	FILTER, WHERE, EVAL)
@@ -752,6 +752,7 @@ term:
  | term '.' MASK '(' term ')' { $$ = f_new_inst(); $$->code = P('i','M'); $$->a1.p = $1; $$->a2.p = $5; }
  | term '.' FIRST { $$ = f_new_inst(); $$->code = P('a','f'); $$->a1.p = $1; }
  | term '.' LAST  { $$ = f_new_inst(); $$->code = P('a','l'); $$->a1.p = $1; }
+ | term '.' LAST_NONAGGREGATED  { $$ = f_new_inst(); $$->code = P('a','L'); $$->a1.p = $1; }
 
 /* Communities */
 /* This causes one shift/reduce conflict
diff --git a/filter/filter.c b/filter/filter.c
index 55062aca..eddf4228 100644
--- a/filter/filter.c
+++ b/filter/filter.c
@@ -1091,6 +1091,14 @@ interpret(struct f_inst *what)
     res.type = T_INT;
     res.val.i = as;
     break;
+  case P('a','L'):	/* Get last ASN from non-aggregated part of AS PATH */
+    ONEARG;
+    if (v1.type != T_PATH)
+      runtime( "AS path expected" );
+
+    res.type = T_INT;
+    res.val.i = as_path_get_last_nonaggregated(v1.val.ad);
+    break;
   case 'r':
     ONEARG;
     res = v1;
diff --git a/nest/a-path.c b/nest/a-path.c
index c9c5aefb..32e2d27e 100644
--- a/nest/a-path.c
+++ b/nest/a-path.c
@@ -220,7 +220,7 @@ as_path_get_last(struct adata *path, u32 *orig_as)
 	      p += BS * len;
 	    }
 	  break;
-	default: bug("as_path_get_first: Invalid path segment");
+	default: bug("Invalid path segment");
 	}
     }
 
@@ -229,6 +229,35 @@ as_path_get_last(struct adata *path, u32 *orig_as)
   return found;
 }
 
+u32
+as_path_get_last_nonaggregated(struct adata *path)
+{
+  u8 *p = path->data;
+  u8 *q = p+path->length;
+  u32 res = 0;
+  int len;
+
+  while (p<q)
+    {
+      switch (*p++)
+	{
+	case AS_PATH_SET:
+	  return res;
+
+	case AS_PATH_SEQUENCE:
+	  if (len = *p++)
+	    res = get_as(p + BS * (len - 1));
+	  p += BS * len;
+	  break;
+
+	default: bug("Invalid path segment");
+	}
+    }
+
+  return res;
+}
+
+
 int
 as_path_get_first(struct adata *path, u32 *last_as)
 {
diff --git a/nest/attrs.h b/nest/attrs.h
index 1d005a6a..0171c6a8 100644
--- a/nest/attrs.h
+++ b/nest/attrs.h
@@ -35,6 +35,7 @@ int as_path_getlen(struct adata *path);
 int as_path_getlen_int(struct adata *path, int bs);
 int as_path_get_first(struct adata *path, u32 *orig_as);
 int as_path_get_last(struct adata *path, u32 *last_as);
+u32 as_path_get_last_nonaggregated(struct adata *path);
 int as_path_contains(struct adata *path, u32 as, int min);
 int as_path_match_set(struct adata *path, struct f_tree *set);
 struct adata *as_path_filter(struct linpool *pool, struct adata *path, struct f_tree *set, u32 key, int pos);

From b25509e5128e6f2a856cd4a07bb78f3d6b7fc789 Mon Sep 17 00:00:00 2001
From: Jan Moskyto Matejka <mq@ucw.cz>
Date: Wed, 20 Jan 2016 15:23:17 +0100
Subject: [PATCH 049/165] All the current pthread implementations are OK and
 working with us.

No more need to disable pthread for specific BSD's.
---
 configure.in | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/configure.in b/configure.in
index c81709e6..b9220a1d 100644
--- a/configure.in
+++ b/configure.in
@@ -85,12 +85,12 @@ if test -z "$GCC" ; then
 fi
 
 # Enable threads by default just in Linux and FreeBSD
-if test "$enable_pthreads" = try ; then
-	case "$host_os" in
-		(linux* | freebsd*)	enable_pthreads=try ;;
-		(*)			enable_pthreads=no ;;
-	esac
-fi
+#if test "$enable_pthreads" = try ; then
+#	case "$host_os" in
+#		(linux* | freebsd* | openbsd* | netbsd* )	enable_pthreads=try ;;
+#		(*)				enable_pthreads=no ;;
+#	esac
+#fi
 
 if test "$enable_pthreads" != no ; then
 	BIRD_CHECK_PTHREADS

From e3f506f9b53bd8e44976df1c935c7ec417793ace Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Thu, 25 Feb 2016 18:16:59 +0100
Subject: [PATCH 050/165] OSPF: Multicast ability is irrelevant for stub
 interfaces

---
 proto/ospf/iface.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/proto/ospf/iface.c b/proto/ospf/iface.c
index 77ce839a..67ae094d 100644
--- a/proto/ospf/iface.c
+++ b/proto/ospf/iface.c
@@ -599,10 +599,10 @@ ospf_iface_new(struct ospf_area *oa, struct ifa *addr, struct ospf_iface_patt *i
   if (ospf_is_v2(p) && (ifa->type == OSPF_IT_NBMA) && (addr->flags & IA_PEER))
     ifa->type = OSPF_IT_PTMP;
 
-  if ((ifa->type == OSPF_IT_BCAST) && !(iface->flags & if_multi_flag))
+  if ((ifa->type == OSPF_IT_BCAST) && !(iface->flags & if_multi_flag) && !ifa->stub)
     ifa->type = OSPF_IT_NBMA;
 
-  if ((ifa->type == OSPF_IT_PTP) && !(iface->flags & if_multi_flag))
+  if ((ifa->type == OSPF_IT_PTP) && !(iface->flags & if_multi_flag) && !ifa->stub)
     ifa->type = OSPF_IT_PTMP;
 
   if (ifa->type != old_type)

From e1c13a5a7b86f2ba09178300bad960224658c833 Mon Sep 17 00:00:00 2001
From: Jan Moskyto Matejka <mq@ucw.cz>
Date: Wed, 9 Mar 2016 12:12:02 +0100
Subject: [PATCH 051/165] Unix: Rework of select-loop to poll-loop

This should lift the limit of FD_SETSIZE and allow more than 1024 fd's.
FD_SETSIZE limit doesn't matter now when creating new sockets.
---
 sysdep/unix/io.c | 101 ++++++++++++++++++++++-------------------------
 1 file changed, 47 insertions(+), 54 deletions(-)

diff --git a/sysdep/unix/io.c b/sysdep/unix/io.c
index b636e799..bc212de1 100644
--- a/sysdep/unix/io.c
+++ b/sysdep/unix/io.c
@@ -19,6 +19,7 @@
 #include <sys/socket.h>
 #include <sys/uio.h>
 #include <sys/un.h>
+#include <poll.h>
 #include <unistd.h>
 #include <fcntl.h>
 #include <errno.h>
@@ -41,12 +42,12 @@
 #include "lib/sysio.h"
 
 /* Maximum number of calls of tx handler for one socket in one
- * select iteration. Should be small enough to not monopolize CPU by
+ * poll iteration. Should be small enough to not monopolize CPU by
  * one protocol instance.
  */
 #define MAX_STEPS 4
 
-/* Maximum number of calls of rx handler for all sockets in one select
+/* Maximum number of calls of rx handler for all sockets in one poll
    iteration. RX callbacks are often much more costly so we limit
    this to gen small latencies */
 #define MAX_RX_STEPS 4
@@ -1022,7 +1023,6 @@ sk_log_error(sock *s, const char *p)
 static list sock_list;
 static struct birdsock *current_sock;
 static struct birdsock *stored_sock;
-static int sock_recalc_fdsets_p;
 
 static inline sock *
 sk_next(sock *s)
@@ -1078,7 +1078,6 @@ sk_free(resource *r)
     if (s == stored_sock)
       stored_sock = sk_next(s);
     rem_node(&s->n);
-    sock_recalc_fdsets_p = 1;
   }
 }
 
@@ -1276,7 +1275,6 @@ static void
 sk_insert(sock *s)
 {
   add_tail(&sock_list, &s->n);
-  sock_recalc_fdsets_p = 1;
 }
 
 static void
@@ -1328,18 +1326,6 @@ sk_passive_connected(sock *s, int type)
       log(L_WARN "SOCK: Cannot get remote IP address for TCP<");
   }
 
-  if (fd >= FD_SETSIZE)
-  {
-    /* FIXME: Call err_hook instead ? */
-    log(L_ERR "SOCK: Incoming connection from %I%J (port %d) %s",
-	t->daddr, ipa_is_link_local(t->daddr) ? t->iface : NULL,
-	t->dport, "rejected due to FD_SETSIZE limit");
-    close(fd);
-    t->fd = -1;
-    rfree(t);
-    return 1;
-  }
-
   if (sk_setup(t) < 0)
   {
     /* FIXME: Call err_hook instead ? */
@@ -1416,9 +1402,6 @@ sk_open(sock *s)
   if (fd < 0)
     ERR("socket");
 
-  if (fd >= FD_SETSIZE)
-    ERR2("FD_SETSIZE limit reached");
-
   s->af = af;
   s->fd = fd;
 
@@ -2062,15 +2045,15 @@ static int short_loops = 0;
 void
 io_loop(void)
 {
-  fd_set rd, wr;
-  struct timeval timo;
+  int poll_tout;
   time_t tout;
-  int hi, events;
+  int nfds, events;
   sock *s;
   node *n;
+  int fdmax = 256;
+  struct pollfd *pfd = xmalloc(fdmax * sizeof(struct pollfd));
 
   watchdog_start1();
-  sock_recalc_fdsets_p = 1;
   for(;;)
     {
       events = ev_run_list(&global_event_list);
@@ -2081,43 +2064,43 @@ io_loop(void)
 	  tm_shot();
 	  continue;
 	}
-      timo.tv_sec = events ? 0 : MIN(tout - now, 3);
-      timo.tv_usec = 0;
+      poll_tout = (events ? 0 : MIN(tout - now, 3)) * 1000; /* Time in milliseconds */
 
       io_close_event();
 
-      if (sock_recalc_fdsets_p)
-	{
-	  sock_recalc_fdsets_p = 0;
-	  FD_ZERO(&rd);
-	  FD_ZERO(&wr);
-	}
-
-      hi = 0;
+      nfds = 0;
       WALK_LIST(n, sock_list)
 	{
+	  pfd[nfds] = (struct pollfd) { .fd = -1 }; /* everything other set to 0 by this */
 	  s = SKIP_BACK(sock, n, n);
 	  if (s->rx_hook)
 	    {
-	      FD_SET(s->fd, &rd);
-	      if (s->fd > hi)
-		hi = s->fd;
+	      pfd[nfds].fd = s->fd;
+	      pfd[nfds].events |= POLLIN;
 	    }
-	  else
-	    FD_CLR(s->fd, &rd);
 	  if (s->tx_hook && s->ttx != s->tpos)
 	    {
-	      FD_SET(s->fd, &wr);
-	      if (s->fd > hi)
-		hi = s->fd;
+	      pfd[nfds].fd = s->fd;
+	      pfd[nfds].events |= POLLOUT;
+	    }
+	  if (pfd[nfds].fd != -1)
+	    {
+	      s->index = nfds;
+	      nfds++;
 	    }
 	  else
-	    FD_CLR(s->fd, &wr);
+	    s->index = -1;
+
+	  if (nfds >= fdmax)
+	    {
+	      fdmax *= 2;
+	      pfd = xrealloc(pfd, fdmax * sizeof(struct pollfd));
+	    }
 	}
 
       /*
        * Yes, this is racy. But even if the signal comes before this test
-       * and entering select(), it gets caught on the next timer tick.
+       * and entering poll(), it gets caught on the next timer tick.
        */
 
       if (async_config_flag)
@@ -2142,18 +2125,18 @@ io_loop(void)
 	  continue;
 	}
 
-      /* And finally enter select() to find active sockets */
+      /* And finally enter poll() to find active sockets */
       watchdog_stop();
-      hi = select(hi+1, &rd, &wr, NULL, &timo);
+      events = poll(pfd, nfds, poll_tout);
       watchdog_start();
 
-      if (hi < 0)
+      if (events < 0)
 	{
 	  if (errno == EINTR || errno == EAGAIN)
 	    continue;
-	  die("select: %m");
+	  die("poll: %m");
 	}
-      if (hi)
+      if (events)
 	{
 	  /* guaranteed to be non-empty */
 	  current_sock = SKIP_BACK(sock, n, HEAD(sock_list));
@@ -2161,11 +2144,17 @@ io_loop(void)
 	  while (current_sock)
 	    {
 	      sock *s = current_sock;
+	      if (s->index == -1)
+		{
+		  current_sock = sk_next(s);
+		  goto next;
+		}
+
 	      int e;
 	      int steps;
 
 	      steps = MAX_STEPS;
-	      if ((s->type >= SK_MAGIC) && FD_ISSET(s->fd, &rd) && s->rx_hook)
+	      if ((s->type >= SK_MAGIC) && (pfd[s->index].revents & (POLLIN | POLLHUP | POLLERR)) && s->rx_hook)
 		do
 		  {
 		    steps--;
@@ -2177,7 +2166,7 @@ io_loop(void)
 		while (e && s->rx_hook && steps);
 
 	      steps = MAX_STEPS;
-	      if (FD_ISSET(s->fd, &wr))
+	      if (pfd[s->index].revents & POLLOUT)
 		do
 		  {
 		    steps--;
@@ -2204,13 +2193,17 @@ io_loop(void)
 	  while (current_sock && count < MAX_RX_STEPS)
 	    {
 	      sock *s = current_sock;
-	      int e UNUSED;
+	      if (s->index == -1)
+		{
+		  current_sock = sk_next(s);
+		  goto next2;
+		}
 
-	      if ((s->type < SK_MAGIC) && FD_ISSET(s->fd, &rd) && s->rx_hook)
+	      if ((s->type < SK_MAGIC) && (pfd[s->index].revents & (POLLIN | POLLHUP | POLLERR)) && s->rx_hook)
 		{
 		  count++;
 		  io_log_event(s->rx_hook, s->data);
-		  e = sk_read(s);
+		  sk_read(s);
 		  if (s != current_sock)
 		      goto next2;
 		}

From fd926ed4eea319b94bd0e09e093b90846bcb169b Mon Sep 17 00:00:00 2001
From: Jan Moskyto Matejka <mq@ucw.cz>
Date: Tue, 15 Mar 2016 14:57:49 +0100
Subject: [PATCH 052/165] Poll: Prevent the improbable case of EAGAIN after
 POLLIN

---
 proto/bfd/io.c   |  4 ++--
 sysdep/unix/io.c | 11 ++++++++---
 2 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/proto/bfd/io.c b/proto/bfd/io.c
index fb150040..79ed9af7 100644
--- a/proto/bfd/io.c
+++ b/proto/bfd/io.c
@@ -576,7 +576,7 @@ sockets_close_fds(struct birdloop *loop)
   loop->close_scheduled = 0;
 }
 
-int sk_read(sock *s);
+int sk_read(sock *s, int revents);
 int sk_write(sock *s);
 
 static void
@@ -605,7 +605,7 @@ sockets_fire(struct birdloop *loop)
 
     if (pfd->revents & POLLIN)
       while (e && *psk && (*psk)->rx_hook)
-	e = sk_read(*psk);
+	e = sk_read(*psk, 0);
 
     e = 1;
     if (pfd->revents & POLLOUT)
diff --git a/sysdep/unix/io.c b/sysdep/unix/io.c
index bc212de1..b769de58 100644
--- a/sysdep/unix/io.c
+++ b/sysdep/unix/io.c
@@ -1760,7 +1760,7 @@ sk_send_full(sock *s, unsigned len, struct iface *ifa,
  /* sk_read() and sk_write() are called from BFD's event loop */
 
 int
-sk_read(sock *s)
+sk_read(sock *s, int revents)
 {
   switch (s->type)
   {
@@ -1779,6 +1779,11 @@ sk_read(sock *s)
       {
 	if (errno != EINTR && errno != EAGAIN)
 	  s->err_hook(s, errno);
+	else if (errno == EAGAIN && !(revents & POLLIN))
+	{
+	  log(L_ERR "Got EAGAIN from read when revents=%x (without POLLIN)", revents);
+	  s->err_hook(s, 0);
+	}
       }
       else if (!c)
 	s->err_hook(s, 0);
@@ -2159,7 +2164,7 @@ io_loop(void)
 		  {
 		    steps--;
 		    io_log_event(s->rx_hook, s->data);
-		    e = sk_read(s);
+		    e = sk_read(s, pfd[s->index].revents);
 		    if (s != current_sock)
 		      goto next;
 		  }
@@ -2203,7 +2208,7 @@ io_loop(void)
 		{
 		  count++;
 		  io_log_event(s->rx_hook, s->data);
-		  sk_read(s);
+		  sk_read(s, pfd[s->index].revents);
 		  if (s != current_sock)
 		      goto next2;
 		}

From 79a4f74a65941603cc42680d2e61b00ec88abe97 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pavel=20Tvrd=C3=ADk?= <pawel.tvrdik@gmail.com>
Date: Tue, 15 Mar 2016 10:29:32 +0100
Subject: [PATCH 053/165] BGP: Add documentaion for extended messages

---
 doc/bird.sgml | 9 +++++++--
 nest/config.Y | 2 +-
 2 files changed, 8 insertions(+), 3 deletions(-)

diff --git a/doc/bird.sgml b/doc/bird.sgml
index c5316d87..73061202 100644
--- a/doc/bird.sgml
+++ b/doc/bird.sgml
@@ -1862,6 +1862,11 @@ using the following configuration parameters:
 	in neighbor's implementation of 4B AS extension. Even when disabled
 	(off), BIRD behaves internally as AS4-aware BGP router. Default: on.
 
+	<tag>enable extended messages <m/switch/</tag>
+	The BGP protocol uses maximum message length of 4096 bytes. This option
+	provides an extension to allow extended messages with length up
+	to 65535 bytes. Default: off.
+
 	<tag>capabilities <m/switch/</tag>
 	Use capability advertisement to advertise optional capabilities. This is
 	standard behavior for newer BGP implementations, but there might be some
@@ -2057,7 +2062,7 @@ protocol bgp {
 	multihop;			     # ... which is connected indirectly
 	export filter {			     # We use non-trivial export rules
 		if source = RTS_STATIC then { # Export only static routes
-		        # Assign our community
+			# Assign our community
 			bgp_community.add((65000,64501));
 			# Artificially increase path length
 			# by advertising local AS number twice
@@ -2266,7 +2271,7 @@ these attributes:
 
 	<tag>ip <cf/krt_prefsrc/</tag> (Linux)
 	The preferred source address. Used in source address selection for
- 	outgoing packets. Has to be one of the IP addresses of the router.
+	outgoing packets. Has to be one of the IP addresses of the router.
 
 	<tag>int <cf/krt_realm/</tag> (Linux)
 	The realm of the route. Can be used for traffic classification.
diff --git a/nest/config.Y b/nest/config.Y
index 799a09f9..87827c10 100644
--- a/nest/config.Y
+++ b/nest/config.Y
@@ -111,7 +111,7 @@ idval:
        $$ = ipa_to_u32(SYM_VAL($1).px.ip);
 #endif
      else
-       cf_error("Number of IPv4 address constant expected");
+       cf_error("Number or IPv4 address constant expected");
    }
  ;
 

From 9036bbf2b7cc781c87f2a6b3979198f77ec6ada1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pavel=20Tvrd=C3=ADk?= <pawel.tvrdik@gmail.com>
Date: Tue, 15 Mar 2016 14:55:40 +0100
Subject: [PATCH 054/165] RIP: fix typo in configuration at rx length opt

---
 proto/rip/config.Y | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/proto/rip/config.Y b/proto/rip/config.Y
index 29ea7eb1..083d2e91 100644
--- a/proto/rip/config.Y
+++ b/proto/rip/config.Y
@@ -131,7 +131,7 @@ rip_iface_item:
  | TIMEOUT TIME expr	{ RIP_IFACE->timeout_time = $3; if ($3<=0) cf_error("Timeout time must be positive"); }
  | GARBAGE TIME expr	{ RIP_IFACE->garbage_time = $3; if ($3<=0) cf_error("Garbage time must be positive"); }
  | ECMP WEIGHT expr	{ RIP_IFACE->ecmp_weight = $3 - 1; if (($3<1) || ($3>256)) cf_error("ECMP weight must be in range 1-256"); }
- | RX BUFFER expr	{ RIP_IFACE->rx_buffer = $3; if (($3<256) || ($3>65535)) cf_error("TX length must be in range 256-65535"); }
+ | RX BUFFER expr	{ RIP_IFACE->rx_buffer = $3; if (($3<256) || ($3>65535)) cf_error("RX length must be in range 256-65535"); }
  | TX LENGTH expr	{ RIP_IFACE->tx_length = $3; if (($3<256) || ($3>65535)) cf_error("TX length must be in range 256-65535"); }
  | TX tos		{ RIP_IFACE->tx_tos = $2; }
  | TX PRIORITY expr	{ RIP_IFACE->tx_priority = $3; }

From 9c92f69272de3795f7289969e815d99a93d0d9b3 Mon Sep 17 00:00:00 2001
From: Jan Moskyto Matejka <mq@ucw.cz>
Date: Fri, 18 Mar 2016 11:44:28 +0100
Subject: [PATCH 055/165] Unix: Substituted select -> poll also in congestion
 checker

It does strange things when even one fd larger than FD_SETSIZE is
passed to select().
---
 sysdep/unix/io.c | 13 +++----------
 1 file changed, 3 insertions(+), 10 deletions(-)

diff --git a/sysdep/unix/io.c b/sysdep/unix/io.c
index b769de58..eb1c1cad 100644
--- a/sysdep/unix/io.c
+++ b/sysdep/unix/io.c
@@ -1679,19 +1679,12 @@ sk_maybe_write(sock *s)
 int
 sk_rx_ready(sock *s)
 {
-  fd_set rd, wr;
-  struct timeval timo;
   int rv;
-
-  FD_ZERO(&rd);
-  FD_ZERO(&wr);
-  FD_SET(s->fd, &rd);
-
-  timo.tv_sec = 0;
-  timo.tv_usec = 0;
+  struct pollfd pfd = { .fd = s->fd };
+  pfd.events |= POLLIN;
 
  redo:
-  rv = select(s->fd+1, &rd, &wr, NULL, &timo);
+  rv = poll(&pfd, 1, 0);
 
   if ((rv < 0) && (errno == EINTR || errno == EAGAIN))
     goto redo;

From a459f4df16eca156cb7c6def4a758fd89c9fa504 Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Wed, 9 Mar 2016 17:37:44 +0100
Subject: [PATCH 056/165] OSPF: Fix reading from freed memory

Thanks to Pavel Tvrdik for noticing it.
---
 proto/ospf/neighbor.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/proto/ospf/neighbor.c b/proto/ospf/neighbor.c
index c5d44dec..0223ccdf 100644
--- a/proto/ospf/neighbor.c
+++ b/proto/ospf/neighbor.c
@@ -108,6 +108,7 @@ ospf_neigh_down(struct ospf_neighbor *n)
 {
   struct ospf_iface *ifa = n->ifa;
   struct ospf_proto *p = ifa->oa->po;
+  u32 rid = n->rid;
 
   if ((ifa->type == OSPF_IT_NBMA) || (ifa->type == OSPF_IT_PTMP))
   {
@@ -121,7 +122,7 @@ ospf_neigh_down(struct ospf_neighbor *n)
   rem_node(NODE n);
   rfree(n->pool);
 
-  OSPF_TRACE(D_EVENTS, "Neighbor %R on %s removed", n->rid, ifa->ifname);
+  OSPF_TRACE(D_EVENTS, "Neighbor %R on %s removed", rid, ifa->ifname);
 }
 
 /**

From 0a505706bc909b2625d308ffb2eaed3dc8398538 Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Wed, 9 Mar 2016 17:51:50 +0100
Subject: [PATCH 057/165] Minor changes in documentation

---
 doc/bird.sgml | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/doc/bird.sgml b/doc/bird.sgml
index 73061202..5e5aeee4 100644
--- a/doc/bird.sgml
+++ b/doc/bird.sgml
@@ -318,8 +318,9 @@ protocol rip {
 <p><descrip>
 	<tag>include "<m/filename/"</tag>
 	This statement causes inclusion of a new file. <m/Filename/ could also
-	be a wildcard. The maximal depth is 8. Note that this statement could be
-	used anywhere in the config file, not just as a top-level option.
+	be a wildcard, in that case matching files are included in alphabetic
+	order. The maximal depth is 8. Note that this statement could be used
+	anywhere in the config file, not just as a top-level option.
 
 	<tag><label id="dsc-log">log "<m/filename/"|syslog [name <m/name/]|stderr all|{ <m/list of classes/ }</tag>
 	Set logging of messages having the given class (either <cf/all/ or
@@ -2616,8 +2617,8 @@ protocol ospf &lt;name&gt; {
 	updates. Default value is 5.
 
 	<tag>priority <M>num</M></tag>
-	On every multiple access network (e.g., the Ethernet) Designed Router
-	and Backup Designed router are elected. These routers have some special
+	On every multiple access network (e.g., the Ethernet) Designated Router
+	and Backup Designated router are elected. These routers have some special
 	functions in the flooding process. Higher priority increases preferences
 	in this election. Routers with priority 0 are not eligible. Default
 	value is 1.

From 39a6b19d6d7e420805bd75783b77bf442745bccb Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Tue, 22 Mar 2016 12:51:31 +0100
Subject: [PATCH 058/165] OSPF: Fix bogus LSA ID collisions between received
 and originated LSAs

After restart, LSAs locally originated by the previous instance are
received from neighbors. They are installed to LSA db and flushed. If
export of a route triggers origination of a new external LSA before flush
of the received one is complete, the check in ospf_originate_lsa() causes
origination to fail (because en->nf is NULL for the old LSA and non-NULL
for the new LSA). The patch fixes this by updating the en->nf for LSAs
being flushed (as is already done for empty ones). Generally, en->nf
field deserves some better description in the code.

Thanks to Jigar Mehta for analyzing the problem.
---
 proto/ospf/topology.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/proto/ospf/topology.c b/proto/ospf/topology.c
index 8119cfa6..7558d4a0 100644
--- a/proto/ospf/topology.c
+++ b/proto/ospf/topology.c
@@ -278,7 +278,7 @@ ospf_originate_lsa(struct ospf_proto *p, struct ospf_new_lsa *lsa)
   if (!SNODE_VALID(en))
     s_add_tail(&p->lsal, SNODE en);
 
-  if (en->lsa_body == NULL)
+  if (!en->nf || !en->lsa_body)
     en->nf = lsa->nf;
 
   if (en->nf != lsa->nf)

From 665b8e5283df4f64eb44d8fb434489be1474b5d4 Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Tue, 22 Mar 2016 13:35:40 +0100
Subject: [PATCH 059/165] Birdlib: Do cleanups after remove/free

To avoid byzantine behavior in case of some errors, linked lists are
cleared after rem_node() and resource headers are cleared after rfree().
---
 lib/lists.c     | 19 +------------------
 lib/lists.h     |  1 -
 lib/resource.c  | 12 +++---------
 proto/bfd/bfd.c |  2 +-
 4 files changed, 5 insertions(+), 29 deletions(-)

diff --git a/lib/lists.c b/lib/lists.c
index d323a4b6..20a9a072 100644
--- a/lib/lists.c
+++ b/lib/lists.c
@@ -88,7 +88,7 @@ insert_node(node *n, node *after)
  * rem_node - remove a node from a list
  * @n: node to be removed
  *
- * Removes a node @n from the list it's linked in.
+ * Removes a node @n from the list it's linked in. Afterwards, node @n is cleared.
  */
 LIST_INLINE void
 rem_node(node *n)
@@ -96,23 +96,6 @@ rem_node(node *n)
   node *z = n->prev;
   node *x = n->next;
 
-  z->next = x;
-  x->prev = z;
-}
-
-/**
- * rem2_node - remove a node from a list, with cleanup
- * @n: node to be removed
- *
- * Removes a node @n from the list it's linked in and resets its pointers to NULL.
- * Useful if you want to distinguish between linked and unlinked nodes.
- */
-LIST_INLINE void
-rem2_node(node *n)
-{
-  node *z = n->prev;
-  node *x = n->next;
-
   z->next = x;
   x->prev = z;
   n->next = NULL;
diff --git a/lib/lists.h b/lib/lists.h
index 80a4dc93..4204cbc5 100644
--- a/lib/lists.h
+++ b/lib/lists.h
@@ -61,7 +61,6 @@ typedef struct list {			/* In fact two overlayed nodes */
 void add_tail(list *, node *);
 void add_head(list *, node *);
 void rem_node(node *);
-void rem2_node(node *);
 void add_tail_list(list *, list *);
 void init_list(list *);
 void insert_node(node *, node *);
diff --git a/lib/resource.c b/lib/resource.c
index 64f9a39c..68718dfb 100644
--- a/lib/resource.c
+++ b/lib/resource.c
@@ -163,6 +163,7 @@ rfree(void *res)
   if (r->n.next)
     rem_node(&r->n);
   r->class->free(r);
+  r->class = NULL;
   xfree(r);
 }
 
@@ -383,16 +384,9 @@ mb_allocz(pool *p, unsigned size)
 void *
 mb_realloc(void *m, unsigned size)
 {
-  struct mblock *ob = NULL;
-
-  if (m)
-    {
-      ob = SKIP_BACK(struct mblock, data, m);
-      if (ob->r.n.next)
-	rem_node(&ob->r.n);
-    }
+  struct mblock *b = SKIP_BACK(struct mblock, data, m);
 
-  struct mblock *b = xrealloc(ob, sizeof(struct mblock) + size);
+  b = xrealloc(b, sizeof(struct mblock) + size);
   replace_node(&b->r.n, &b->r.n);
   b->size = size;
   return b->data;
diff --git a/proto/bfd/bfd.c b/proto/bfd/bfd.c
index 7a085791..5de2f556 100644
--- a/proto/bfd/bfd.c
+++ b/proto/bfd/bfd.c
@@ -872,7 +872,7 @@ bfd_notify_hook(sock *sk, int len)
   WALK_LIST_FIRST(s, tmp_list)
   {
     bfd_lock_sessions(p);
-    rem2_node(&s->n);
+    rem_node(&s->n);
     state = s->loc_state;
     diag = s->loc_diag;
     bfd_unlock_sessions(p);

From 54bb032d21d25a2221877e15325e79add10278ec Mon Sep 17 00:00:00 2001
From: Jan Moskyto Matejka <mq@ucw.cz>
Date: Wed, 23 Mar 2016 01:45:37 +0100
Subject: [PATCH 060/165] Birdlib: Modify lists to avoid problems with pointer
 aliasing rules

The old linked list implementation used some wild typecasts and required
GCC option -fno-strict-aliasing to work properly. This patch fixes that.
However, we still keep the option due to other potential problems.

(Commited by Ondrej Santiago Zajicek)
---
 lib/lists.c | 10 +++++-----
 lib/lists.h | 17 +++++++++++++++--
 2 files changed, 20 insertions(+), 7 deletions(-)

diff --git a/lib/lists.c b/lib/lists.c
index 20a9a072..12ef3cc6 100644
--- a/lib/lists.c
+++ b/lib/lists.c
@@ -41,7 +41,7 @@ add_tail(list *l, node *n)
 {
   node *z = l->tail;
 
-  n->next = (node *) &l->null;
+  n->next = &l->tail_node;
   n->prev = z;
   z->next = n;
   l->tail = n;
@@ -60,7 +60,7 @@ add_head(list *l, node *n)
   node *z = l->head;
 
   n->next = z;
-  n->prev = (node *) &l->head;
+  n->prev = &l->head_node;
   z->prev = n;
   l->head = n;
 }
@@ -133,9 +133,9 @@ replace_node(node *old, node *new)
 LIST_INLINE void
 init_list(list *l)
 {
-  l->head = (node *) &l->null;
+  l->head = &l->tail_node;
   l->null = NULL;
-  l->tail = (node *) &l->head;
+  l->tail = &l->head_node;
 }
 
 /**
@@ -155,6 +155,6 @@ add_tail_list(list *to, list *l)
   p->next = q;
   q->prev = p;
   q = l->tail;
-  q->next = (node *) &to->null;
+  q->next = &to->tail_node;
   to->tail = q;
 }
diff --git a/lib/lists.h b/lib/lists.h
index 4204cbc5..51856b05 100644
--- a/lib/lists.h
+++ b/lib/lists.h
@@ -26,10 +26,23 @@ typedef struct node {
   struct node *next, *prev;
 } node;
 
-typedef struct list {			/* In fact two overlayed nodes */
-  struct node *head, *null, *tail;
+typedef union list {			/* In fact two overlayed nodes */
+  struct {				/* Head node */
+    struct node head_node;
+    void *head_padding;
+  };
+  struct {				/* Tail node */
+    void *tail_padding;
+    struct node tail_node;
+  };
+  struct {				/* Split to separate pointers */
+    struct node *head;
+    struct node *null;
+    struct node *tail;
+  };
 } list;
 
+
 #define NODE (node *)
 #define HEAD(list) ((void *)((list).head))
 #define TAIL(list) ((void *)((list).tail))

From ea0a8be2ff5afb8385a69cc0df70984e0fd3a570 Mon Sep 17 00:00:00 2001
From: Jan Moskyto Matejka <mq@ucw.cz>
Date: Wed, 30 Mar 2016 16:21:32 +0200
Subject: [PATCH 061/165] IO/Poll: fix mistaken variable merge

The events variable is used in the short loop decision. The reasons are
not much clear, keeping this to keep the former behaviour.
---
 sysdep/unix/io.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/sysdep/unix/io.c b/sysdep/unix/io.c
index eb1c1cad..112ebe91 100644
--- a/sysdep/unix/io.c
+++ b/sysdep/unix/io.c
@@ -2045,7 +2045,7 @@ io_loop(void)
 {
   int poll_tout;
   time_t tout;
-  int nfds, events;
+  int nfds, events, pout;
   sock *s;
   node *n;
   int fdmax = 256;
@@ -2125,16 +2125,16 @@ io_loop(void)
 
       /* And finally enter poll() to find active sockets */
       watchdog_stop();
-      events = poll(pfd, nfds, poll_tout);
+      pout = poll(pfd, nfds, poll_tout);
       watchdog_start();
 
-      if (events < 0)
+      if (pout < 0)
 	{
 	  if (errno == EINTR || errno == EAGAIN)
 	    continue;
 	  die("poll: %m");
 	}
-      if (events)
+      if (pout)
 	{
 	  /* guaranteed to be non-empty */
 	  current_sock = SKIP_BACK(sock, n, HEAD(sock_list));

From e86cfd41d975122cc944db68383aef4028da9575 Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Wed, 23 Mar 2016 18:25:15 +0100
Subject: [PATCH 062/165] KRT: Fix route learn scan when route changed

When a kernel route changed, function krt_learn_scan() noticed that and
replaced the route in internal kernel FIB, but after that, function
krt_learn_prune() failed to propagate the new route to the nest, because
it confused the new route with the (removed) old best route and decided
that the best route did not changed.

Wow, the original code (and the bug) is almost 17 years old.
---
 nest/route.h           |  2 +-
 sysdep/bsd/krt-sock.c  |  5 ++---
 sysdep/linux/netlink.c |  3 ++-
 sysdep/unix/krt.c      | 46 ++++++++++++++++++++++++++----------------
 4 files changed, 34 insertions(+), 22 deletions(-)

diff --git a/nest/route.h b/nest/route.h
index c435b9e0..9368808f 100644
--- a/nest/route.h
+++ b/nest/route.h
@@ -223,8 +223,8 @@ typedef struct rte {
     struct {				/* Routes generated by krt sync (both temporary and inherited ones) */
       s8 src;				/* Alleged route source (see krt.h) */
       u8 proto;				/* Kernel source protocol ID */
-      u8 type;				/* Kernel route type */
       u8 seen;				/* Seen during last scan */
+      u8 best;				/* Best route in network, propagated to core */
       u32 metric;			/* Kernel metric */
     } krt;
   } u;
diff --git a/sysdep/bsd/krt-sock.c b/sysdep/bsd/krt-sock.c
index 29203d1b..6ff3b2b7 100644
--- a/sysdep/bsd/krt-sock.c
+++ b/sysdep/bsd/krt-sock.c
@@ -493,9 +493,8 @@ krt_read_route(struct ks_msg *msg, struct krt_proto *p, int scan)
   e->net = net;
   e->u.krt.src = src;
   e->u.krt.proto = src2;
-
-  /* These are probably too Linux-specific */
-  e->u.krt.type = 0;
+  e->u.krt.seen = 0;
+  e->u.krt.best = 0;
   e->u.krt.metric = 0;
 
   if (scan)
diff --git a/sysdep/linux/netlink.c b/sysdep/linux/netlink.c
index 640d1877..1ffdff07 100644
--- a/sysdep/linux/netlink.c
+++ b/sysdep/linux/netlink.c
@@ -1102,7 +1102,8 @@ nl_parse_route(struct nlmsghdr *h, int scan)
   e->net = net;
   e->u.krt.src = src;
   e->u.krt.proto = i->rtm_protocol;
-  e->u.krt.type = i->rtm_type;
+  e->u.krt.seen = 0;
+  e->u.krt.best = 0;
   e->u.krt.metric = 0;
 
   if (a[RTA_PRIORITY])
diff --git a/sysdep/unix/krt.c b/sysdep/unix/krt.c
index 5e78586b..f5dee877 100644
--- a/sysdep/unix/krt.c
+++ b/sysdep/unix/krt.c
@@ -417,46 +417,58 @@ krt_learn_prune(struct krt_proto *p)
       net *n = (net *) f;
       rte *e, **ee, *best, **pbest, *old_best;
 
-      old_best = n->routes;
+      /*
+       * Note that old_best may be NULL even if there was an old best route in
+       * the previous step, because it might be replaced in krt_learn_scan().
+       * But in that case there is a new valid best route.
+       */
+
+      old_best = NULL;
       best = NULL;
       pbest = NULL;
       ee = &n->routes;
       while (e = *ee)
 	{
+	  if (e->u.krt.best)
+	    old_best = e;
+
 	  if (!e->u.krt.seen)
 	    {
 	      *ee = e->next;
 	      rte_free(e);
 	      continue;
 	    }
+
 	  if (!best || best->u.krt.metric > e->u.krt.metric)
 	    {
 	      best = e;
 	      pbest = ee;
 	    }
+
 	  e->u.krt.seen = 0;
+	  e->u.krt.best = 0;
 	  ee = &e->next;
 	}
       if (!n->routes)
 	{
 	  DBG("%I/%d: deleting\n", n->n.prefix, n->n.pxlen);
 	  if (old_best)
-	    {
-	      krt_learn_announce_delete(p, n);
-	      n->n.flags &= ~KRF_INSTALLED;
-	    }
+	    krt_learn_announce_delete(p, n);
+
 	  FIB_ITERATE_PUT(&fit, f);
 	  fib_delete(fib, f);
 	  goto again;
 	}
+
+      best->u.krt.best = 1;
       *pbest = best->next;
       best->next = n->routes;
       n->routes = best;
-      if (best != old_best || !(n->n.flags & KRF_INSTALLED) || p->reload)
+
+      if ((best != old_best) || p->reload)
 	{
 	  DBG("%I/%d: announcing (metric=%d)\n", n->n.prefix, n->n.pxlen, best->u.krt.metric);
 	  krt_learn_announce_update(p, best);
-	  n->n.flags |= KRF_INSTALLED;
 	}
       else
 	DBG("%I/%d: uptodate (metric=%d)\n", n->n.prefix, n->n.pxlen, best->u.krt.metric);
@@ -515,31 +527,31 @@ krt_learn_async(struct krt_proto *p, rte *e, int new)
   best = n->routes;
   bestp = &n->routes;
   for(gg=&n->routes; g=*gg; gg=&g->next)
+  {
     if (best->u.krt.metric > g->u.krt.metric)
       {
 	best = g;
 	bestp = gg;
       }
+
+    g->u.krt.best = 0;
+  }
+
   if (best)
     {
+      best->u.krt.best = 1;
       *bestp = best->next;
       best->next = n->routes;
       n->routes = best;
     }
+
   if (best != old_best)
     {
       DBG("krt_learn_async: distributing change\n");
       if (best)
-	{
-	  krt_learn_announce_update(p, best);
-	  n->n.flags |= KRF_INSTALLED;
-	}
+	krt_learn_announce_update(p, best);
       else
-	{
-	  n->routes = NULL;
-	  krt_learn_announce_delete(p, n);
-	  n->n.flags &= ~KRF_INSTALLED;
-	}
+	krt_learn_announce_delete(p, n);
     }
 }
 
@@ -564,7 +576,7 @@ krt_dump(struct proto *P)
 static void
 krt_dump_attrs(rte *e)
 {
-  debug(" [m=%d,p=%d,t=%d]", e->u.krt.metric, e->u.krt.proto, e->u.krt.type);
+  debug(" [m=%d,p=%d]", e->u.krt.metric, e->u.krt.proto);
 }
 
 #endif

From 9e7b3ebdf9556d7464911dd39e862b1c003319b3 Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Wed, 6 Apr 2016 11:49:34 +0200
Subject: [PATCH 063/165] IO: Replace RX priority heuristic with explicit mark

In BIRD, RX has lower priority than TX with the exception of RX from
control socket. The patch replaces heuristic based on socket type with
explicit mark and uses it for both control socket and BGP session waiting
to be established.

This should avoid an issue when during heavy load, outgoing connection
could connect (TX event), send open, but then failed to receive OPEN /
establish in time, not sending notifications between and therefore
got hold timer expired error from the neighbor immediately after it
finally established the connection.
---
 lib/socket.h       | 1 +
 proto/bgp/bgp.c    | 3 +++
 sysdep/unix/io.c   | 4 ++--
 sysdep/unix/main.c | 2 ++
 4 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/lib/socket.h b/lib/socket.h
index fbea92aa..0327e9e5 100644
--- a/lib/socket.h
+++ b/lib/socket.h
@@ -28,6 +28,7 @@ typedef struct birdsock {
   struct iface *iface;			/* Interface; specify this for broad/multicast sockets */
 
   byte *rbuf, *rpos;			/* NULL=allocate automatically */
+  uint fast_rx;				/* RX has higher priority in event loop */
   uint rbsize;
   int (*rx_hook)(struct birdsock *, int size); /* NULL=receiving turned off, returns 1 to clear rx buffer */
 
diff --git a/proto/bgp/bgp.c b/proto/bgp/bgp.c
index 11f33b14..7328cb79 100644
--- a/proto/bgp/bgp.c
+++ b/proto/bgp/bgp.c
@@ -374,6 +374,8 @@ bgp_conn_enter_established_state(struct bgp_conn *conn)
   if (ipa_zero(p->source_addr))
     p->source_addr = conn->sk->saddr;
 
+  conn->sk->fast_rx = 0;
+
   p->conn = conn;
   p->last_error_class = 0;
   p->last_error_code = 0;
@@ -696,6 +698,7 @@ bgp_setup_sk(struct bgp_conn *conn, sock *s)
 {
   s->data = conn;
   s->err_hook = bgp_sock_err;
+  s->fast_rx = 1;
   conn->sk = s;
 }
 
diff --git a/sysdep/unix/io.c b/sysdep/unix/io.c
index 112ebe91..078fe73c 100644
--- a/sysdep/unix/io.c
+++ b/sysdep/unix/io.c
@@ -2152,7 +2152,7 @@ io_loop(void)
 	      int steps;
 
 	      steps = MAX_STEPS;
-	      if ((s->type >= SK_MAGIC) && (pfd[s->index].revents & (POLLIN | POLLHUP | POLLERR)) && s->rx_hook)
+	      if (s->fast_rx && (pfd[s->index].revents & (POLLIN | POLLHUP | POLLERR)) && s->rx_hook)
 		do
 		  {
 		    steps--;
@@ -2197,7 +2197,7 @@ io_loop(void)
 		  goto next2;
 		}
 
-	      if ((s->type < SK_MAGIC) && (pfd[s->index].revents & (POLLIN | POLLHUP | POLLERR)) && s->rx_hook)
+	      if (!s->fast_rx && (pfd[s->index].revents & (POLLIN | POLLHUP | POLLERR)) && s->rx_hook)
 		{
 		  count++;
 		  io_log_event(s->rx_hook, s->data);
diff --git a/sysdep/unix/main.c b/sysdep/unix/main.c
index 24d34f60..5d5586a0 100644
--- a/sysdep/unix/main.c
+++ b/sysdep/unix/main.c
@@ -450,6 +450,7 @@ cli_connect(sock *s, int size UNUSED)
   s->err_hook = cli_err;
   s->data = c = cli_new(s);
   s->pool = c->pool;		/* We need to have all the socket buffers allocated in the cli pool */
+  s->fast_rx = 1;
   c->rx_pos = c->rx_buf;
   c->rx_aux = NULL;
   rmove(s, c->pool);
@@ -466,6 +467,7 @@ cli_init_unix(uid_t use_uid, gid_t use_gid)
   s->type = SK_UNIX_PASSIVE;
   s->rx_hook = cli_connect;
   s->rbsize = 1024;
+  s->fast_rx = 1;
 
   /* Return value intentionally ignored */
   unlink(path_control_socket);

From bd22d7f41d37dec8f7b8b845f6a18c775e66ddfc Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Wed, 6 Apr 2016 11:57:28 +0200
Subject: [PATCH 064/165] IO: Avoid multiple event cycles in one loop cycle.

Event cycle may took too much time and trigger next timer events, so
avoid cycling between timer and event cycles inside the loop cycle.
---
 proto/bgp/bgp.c  | 4 ++++
 sysdep/unix/io.c | 3 ++-
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/proto/bgp/bgp.c b/proto/bgp/bgp.c
index 7328cb79..94c8e5c2 100644
--- a/proto/bgp/bgp.c
+++ b/proto/bgp/bgp.c
@@ -668,6 +668,10 @@ bgp_keepalive_timeout(timer *t)
 
   DBG("BGP: Keepalive timer\n");
   bgp_schedule_packet(conn, PKT_KEEPALIVE);
+
+  /* Kick TX a bit faster */
+  if (ev_active(conn->tx_ev))
+    ev_run(conn->tx_ev);
 }
 
 static void
diff --git a/sysdep/unix/io.c b/sysdep/unix/io.c
index 078fe73c..5955dbfe 100644
--- a/sysdep/unix/io.c
+++ b/sysdep/unix/io.c
@@ -2055,12 +2055,13 @@ io_loop(void)
   for(;;)
     {
       events = ev_run_list(&global_event_list);
+    timers:
       update_times();
       tout = tm_first_shot();
       if (tout <= now)
 	{
 	  tm_shot();
-	  continue;
+	  goto timers;
 	}
       poll_tout = (events ? 0 : MIN(tout - now, 3)) * 1000; /* Time in milliseconds */
 

From 06edbb67ed807811654e7fd8f0f9b83766430216 Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Thu, 7 Apr 2016 01:10:24 +0200
Subject: [PATCH 065/165] Nest: Reset export route counter during graceful
 restart

Counter exp_routes is increased during initial route feed after GR
recovery, so it has to start with zero, otherwise BIRD will end with
double value in exp_routes.
---
 nest/proto.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/nest/proto.c b/nest/proto.c
index d04da333..436377f1 100644
--- a/nest/proto.c
+++ b/nest/proto.c
@@ -1260,6 +1260,7 @@ proto_want_export_down(struct proto *p)
     rt_feed_baby_abort(p);
 
   p->export_state = ES_DOWN;
+  p->stats.exp_routes = 0;
   proto_unlink_ahooks(p);
 }
 

From f2ae2badff37c008ba8217a12f8ee6dc6a3c5a39 Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Thu, 7 Apr 2016 12:20:45 +0200
Subject: [PATCH 066/165] Main: Add local option

Add option that changes default paths for config file and control socket
to the current working directory.
---
 client/client.c    | 10 ++++++++--
 doc/bird.sgml      |  5 +++++
 lib/string.h       |  6 ++++++
 sysdep/unix/main.c | 16 +++++++++++++---
 4 files changed, 32 insertions(+), 5 deletions(-)

diff --git a/client/client.c b/client/client.c
index b938f344..4075b9e6 100644
--- a/client/client.c
+++ b/client/client.c
@@ -37,7 +37,7 @@
 
 #define SERVER_READ_BUF_LEN 4096
 
-static char *opt_list = "s:vr";
+static char *opt_list = "s:vrl";
 static int verbose, restricted, once;
 static char *init_cmd;
 
@@ -59,13 +59,14 @@ int term_lns, term_cls;
 static void
 usage(char *name)
 {
-  fprintf(stderr, "Usage: %s [-s <control-socket>] [-v] [-r]\n", name);
+  fprintf(stderr, "Usage: %s [-s <control-socket>] [-v] [-r] [-l]\n", name);
   exit(1);
 }
 
 static void
 parse_args(int argc, char **argv)
 {
+  int server_changed = 0;
   int c;
 
   while ((c = getopt(argc, argv, opt_list)) >= 0)
@@ -73,6 +74,7 @@ parse_args(int argc, char **argv)
       {
       case 's':
 	server_path = optarg;
+	server_changed = 1;
 	break;
       case 'v':
 	verbose++;
@@ -80,6 +82,10 @@ parse_args(int argc, char **argv)
       case 'r':
 	restricted = 1;
 	break;
+      case 'l':
+	if (!server_changed)
+	  server_path = xbasename(server_path);
+	break;
       default:
 	usage(argv[0]);
       }
diff --git a/doc/bird.sgml b/doc/bird.sgml
index 5e5aeee4..5e943d7c 100644
--- a/doc/bird.sgml
+++ b/doc/bird.sgml
@@ -171,6 +171,11 @@ BIRD executable by configuring out routing protocols you don't use, and
 	<tag>-f</tag>
 	run bird in foreground.
 
+	<tag>-l</tag>
+	look for a configuration file and a communication socket in the current
+	working directory instead of in default system paths. However, paths
+	specified by options <cf/-c/, <cf/-s/ have higher priority.
+
 	<tag>-R</tag>
 	apply graceful restart recovery after start.
 </descrip>
diff --git a/lib/string.h b/lib/string.h
index 218f7b1c..0f249d37 100644
--- a/lib/string.h
+++ b/lib/string.h
@@ -24,4 +24,10 @@ void buffer_puts(buffer *buf, const char *str);
 
 int patmatch(const byte *pat, const byte *str);
 
+static inline char *xbasename(const char *str)
+{
+  char *s = strrchr(str, '/');
+  return s ? s+1 : (char *) str;
+}
+
 #endif
diff --git a/sysdep/unix/main.c b/sysdep/unix/main.c
index 5d5586a0..11a4acc6 100644
--- a/sysdep/unix/main.c
+++ b/sysdep/unix/main.c
@@ -617,7 +617,7 @@ signal_init(void)
  *	Parsing of command-line arguments
  */
 
-static char *opt_list = "c:dD:ps:P:u:g:fR";
+static char *opt_list = "c:dD:ps:P:u:g:flR";
 static int parse_and_exit;
 char *bird_name;
 static char *use_user;
@@ -627,7 +627,7 @@ static int run_in_foreground = 0;
 static void
 usage(void)
 {
-  fprintf(stderr, "Usage: %s [-c <config-file>] [-d] [-D <debug-file>] [-p] [-s <control-socket>] [-P <pid-file>] [-u <user>] [-g <group>] [-f] [-R]\n", bird_name);
+  fprintf(stderr, "Usage: %s [-c <config-file>] [-d] [-D <debug-file>] [-p] [-s <control-socket>] [-P <pid-file>] [-u <user>] [-g <group>] [-f] [-l] [-R]\n", bird_name);
   exit(1);
 }
 
@@ -677,7 +677,7 @@ get_gid(const char *s)
 
   if (!s)
     return 0;
-  
+
   errno = 0;
   rv = strtol(s, &endptr, 10);
 
@@ -694,6 +694,8 @@ get_gid(const char *s)
 static void
 parse_args(int argc, char **argv)
 {
+  int config_changed = 0;
+  int socket_changed = 0;
   int c;
 
   bird_name = get_bird_name(argv[0], "bird");
@@ -712,6 +714,7 @@ parse_args(int argc, char **argv)
       {
       case 'c':
 	config_name = optarg;
+	config_changed = 1;
 	break;
       case 'd':
 	debug_flag |= 1;
@@ -725,6 +728,7 @@ parse_args(int argc, char **argv)
 	break;
       case 's':
 	path_control_socket = optarg;
+	socket_changed = 1;
 	break;
       case 'P':
 	pid_file = optarg;
@@ -738,6 +742,12 @@ parse_args(int argc, char **argv)
       case 'f':
 	run_in_foreground = 1;
 	break;
+      case 'l':
+	if (!config_changed)
+	  config_name = xbasename(config_name);
+	if (!socket_changed)
+	  path_control_socket = xbasename(path_control_socket);
+	break;
       case 'R':
 	graceful_restart_recovery();
 	break;

From e90dd656cc9126e1fbcc45fb77a10bf1baa2a1b5 Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Fri, 8 Apr 2016 15:10:57 +0200
Subject: [PATCH 067/165] Direct: Implement check link for direct protocol

When enabled, direct protocol generates routes only if the underlying
link state is up.
---
 doc/bird.sgml |  8 +++++++-
 nest/config.Y |  1 +
 nest/rt-dev.c | 28 +++++++++++++++++++++++++++-
 nest/rt-dev.h |  1 +
 4 files changed, 36 insertions(+), 2 deletions(-)

diff --git a/doc/bird.sgml b/doc/bird.sgml
index 5e943d7c..829b148a 100644
--- a/doc/bird.sgml
+++ b/doc/bird.sgml
@@ -2155,7 +2155,7 @@ conditions, because a lower priority IGP route for the same network is not
 exported to the kernel routing table. This is an issue on BSD systems only, as
 on Linux systems BIRD cannot change non-BIRD route in the kernel routing table.
 
-<p>The only configurable thing about direct is what interfaces it watches:
+<p>There are just few configuration options for the Direct protocol:
 
 <p><descrip>
 	<tag>interface <m/pattern [, ...]/</tag>
@@ -2166,6 +2166,12 @@ on Linux systems BIRD cannot change non-BIRD route in the kernel routing table.
 	interfaces), just use this clause. See <ref id="dsc-iface" name="interface">
 	common option for detailed description. The Direct protocol uses
 	extended interface clauses.
+
+	<tag>check link <m/switch/</tag>
+	If enabled, a hardware link state (reported by OS) is taken into
+	consideration. Routes for directly connected networks are generated only
+	if link up is reported and they are withdrawn when link disappears
+	(e.g., an ethernet cable is unplugged). Default value is no.
 </descrip>
 
 <p>Direct device routes don't contain any specific attributes.
diff --git a/nest/config.Y b/nest/config.Y
index 87827c10..4566971f 100644
--- a/nest/config.Y
+++ b/nest/config.Y
@@ -335,6 +335,7 @@ dev_proto:
    dev_proto_start proto_name '{'
  | dev_proto proto_item ';'
  | dev_proto dev_iface_patt ';'
+ | dev_proto CHECK LINK bool ';' { DIRECT_CFG->check_link = $4; }
  ;
 
 dev_iface_init:
diff --git a/nest/rt-dev.c b/nest/rt-dev.c
index f6bc1432..ed6c06af 100644
--- a/nest/rt-dev.c
+++ b/nest/rt-dev.c
@@ -64,6 +64,9 @@ dev_ifa_notify(struct proto *p, unsigned c, struct ifa *ad)
 
       DBG("dev_if_notify: %s:%I going up\n", ad->iface->name, ad->ip);
 
+      if (P->check_link && !(ad->iface->flags & IF_LINK_UP))
+	return;
+
       /* Use iface ID as local source ID */
       struct rte_src *src = rt_get_source(p, ad->iface->index);
 
@@ -85,11 +88,31 @@ dev_ifa_notify(struct proto *p, unsigned c, struct ifa *ad)
     }
 }
 
+static void
+dev_if_notify(struct proto *p, uint c, struct iface *iface)
+{
+  struct rt_dev_config *cf = (void *) p->cf;
+
+  if (c & (IF_CHANGE_UP | IF_CHANGE_DOWN))
+    return;
+
+  if ((c & IF_CHANGE_LINK) && cf->check_link)
+  {
+    uint ac = (iface->flags & IF_LINK_UP) ? IF_CHANGE_UP : IF_CHANGE_DOWN;
+
+    struct ifa *a;
+    WALK_LIST(a, iface->addrs)
+      dev_ifa_notify(p, ac, a);
+  }
+}
+
+
 static struct proto *
 dev_init(struct proto_config *c)
 {
   struct proto *p = proto_new(c, sizeof(struct proto));
 
+  p->if_notify = dev_if_notify;
   p->ifa_notify = dev_ifa_notify;
   return p;
 }
@@ -100,7 +123,8 @@ dev_reconfigure(struct proto *p, struct proto_config *new)
   struct rt_dev_config *o = (struct rt_dev_config *) p->cf;
   struct rt_dev_config *n = (struct rt_dev_config *) new;
 
-  return iface_patts_equal(&o->iface_list, &n->iface_list, NULL);
+  return iface_patts_equal(&o->iface_list, &n->iface_list, NULL) &&
+    (o->check_link == n->check_link);
 }
 
 static void
@@ -115,6 +139,8 @@ dev_copy_config(struct proto_config *dest, struct proto_config *src)
    * old nodes cannot be modified (although they contain internal lists).
    */
   cfg_copy_list(&d->iface_list, &s->iface_list, sizeof(struct iface_patt));
+
+  d->check_link = s->check_link;
 }
 
 struct protocol proto_device = {
diff --git a/nest/rt-dev.h b/nest/rt-dev.h
index c36d0742..191b9a02 100644
--- a/nest/rt-dev.h
+++ b/nest/rt-dev.h
@@ -12,6 +12,7 @@
 struct rt_dev_config {
   struct proto_config c;
   list iface_list;		/* list of struct iface_patt */
+  int check_link;
 };
 
 #endif

From 43fc6bb0fb720762f12124076e2241855741ceb5 Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Mon, 11 Apr 2016 00:41:10 +0200
Subject: [PATCH 068/165] Documentation update

---
 doc/bird.sgml | 98 +++++++++++++++++++++++++++++++++++++++------------
 1 file changed, 76 insertions(+), 22 deletions(-)

diff --git a/doc/bird.sgml b/doc/bird.sgml
index 829b148a..653e0bb5 100644
--- a/doc/bird.sgml
+++ b/doc/bird.sgml
@@ -173,7 +173,7 @@ BIRD executable by configuring out routing protocols you don't use, and
 
 	<tag>-l</tag>
 	look for a configuration file and a communication socket in the current
-	working directory instead of in default system paths. However, paths
+	working directory instead of in default system locations. However, paths
 	specified by options <cf/-c/, <cf/-s/ have higher priority.
 
 	<tag>-R</tag>
@@ -717,6 +717,10 @@ This argument can be omitted if there exists only a single instance.
 	Show router status, that is BIRD version, uptime and time from last
 	reconfiguration.
 
+	<tag>show interfaces [summary]</tag>
+	Show the list of interfaces. For each interface, print its type, state,
+	MTU and addresses assigned.
+
 	<tag>show protocols [all]</tag>
 	Show list of protocol instances along with tables they are connected to
 	and protocol status, possibly giving verbose information, if <cf/all/ is
@@ -744,16 +748,18 @@ This argument can be omitted if there exists only a single instance.
 	Show contents of an OSPF LSA database. Options could be used to filter
 	entries.
 
+	<tag>show rip interfaces [<m/name/] ["<m/interface/"]</tag>
+	Show detailed information about RIP interfaces.
+
+	<tag>show rip neighbors [<m/name/] ["<m/interface/"]</tag>
+	Show a list of RIP neighbors and associated state.
+
 	<tag>show static [<m/name/]</tag>
 	Show detailed information about static routes.
 
 	<tag>show bfd sessions [<m/name/]</tag>
 	Show information about BFD sessions.
 
-	<tag>show interfaces [summary]</tag>
-	Show the list of interfaces. For each interface, print its type, state,
-	MTU and addresses assigned.
-
 	<tag>show symbols [table|filter|function|protocol|template|roa|<m/symbol/]</tag>
 	Show the list of symbols defined in the configuration (names of
 	protocols, routing tables etc.).
@@ -3376,6 +3382,11 @@ protocol rip [&lt;name&gt;] {
 	RIP, the option is not supported for RIPng, as no further versions are
 	defined.
 
+	<tag>version only <m/switch/</tag>
+	Regardless of RIP version configured for the interface, BIRD accepts
+	incoming packets of any RIP version. This option restrict accepted
+	packets to the configured version. Default: no.
+
 	<tag>split horizon <m/switch/</tag>
 	Split horizon is a scheme for preventing routing loops. When split
 	horizon is active, routes are not regularly propagated back to the
@@ -3520,7 +3531,7 @@ default route to prevent routing loops).
 packets to a neighboring router, multipath routes specifying several (possibly
 weighted) neighboring routers, device routes specifying forwarding to hosts on a
 directly connected network, recursive routes computing their nexthops by doing
-route table lookups for a given IP and special routes (sink, blackhole etc.)
+route table lookups for a given IP, and special routes (sink, blackhole etc.)
 which specify a special action to be done instead of forwarding the packet.
 
 <p>When the particular destination is not available (the interface is down or
@@ -3528,8 +3539,26 @@ the next hop of the route is not a neighbor at the moment), Static just
 uninstalls the route from the table it is connected to and adds it again as soon
 as the destination becomes adjacent again.
 
-<p>The Static protocol does not have many configuration options. The definition
-of the protocol contains mainly a list of static routes:
+<p>There are three classes of definitions in Static protocol configuration --
+global options, static route definitions, and per-route options. Usually, the
+definition of the protocol contains mainly a list of static routes.
+
+<p>Global options:
+
+<descrip>
+	<tag>check link <m/switch/</tag>
+	If set, hardware link states of network interfaces are taken into
+	consideration.  When link disappears (e.g. ethernet cable is unplugged),
+	static routes directing to that interface are removed. It is possible
+	that some hardware drivers or platforms do not implement this feature.
+	Default: off.
+
+	<tag>igp table <m/name/</tag>
+	Specifies a table that is used for route table lookups of recursive
+	routes. Default: the same table as the protocol is connected to.
+</descrip>
+
+<p>Route definitions (each may also contain a block of per-route options):
 
 <descrip>
 	<tag>route <m/prefix/ via <m/ip/</tag>
@@ -3537,7 +3566,7 @@ of the protocol contains mainly a list of static routes:
 	interface can be specified as a part of the address (e.g.,
 	<cf/via fe80::1234%eth0/).
 
-	<tag>route <m/prefix/ multipath via <m/ip/ [weight <m/num/] [via ...]</tag>
+	<tag>route <m/prefix/ multipath via <m/ip/ [weight <m/num/] [bfd </m/switch/] [via ...]</tag>
 	Static multipath route. Contains several nexthops (gateways), possibly
  	with their weights.
 
@@ -3553,17 +3582,33 @@ of the protocol contains mainly a list of static routes:
 	Special routes specifying to silently drop the packet, return it as
 	unreachable or return it as administratively prohibited. First two
 	targets are also known as <cf/drop/ and <cf/reject/.
+</descrip>
 
-	<tag>check link <m/switch/</tag>
-	If set, hardware link states of network interfaces are taken into
-	consideration.  When link disappears (e.g. ethernet cable is unplugged),
-	static routes directing to that interface are removed. It is possible
-	that some hardware drivers or platforms do not implement this feature.
-	Default: off.
+<p>Per-route options:
 
-	<tag>igp table <m/name/</tag>
-	Specifies a table that is used for route table lookups of recursive
-	routes. Default: the same table as the protocol is connected to.
+<descrip>
+	<tag>bfd <m/switch/</tag>
+	The Static protocol could use BFD protocol for next hop liveness
+	detection. If enabled, a BFD session to the route next hop is created
+	and the static route is BFD-controlled -- the static route is announced
+	only if the next hop liveness is confirmed by BFD. If the BFD session
+	fails, the static route is removed. Note that this is a bit different
+	compared to other protocols, which may use BFD as an advisory mechanism
+	for fast failure detection but ignores it if a BFD session is not even
+	established.
+
+	This option can be used for static routes with a direct next hop, or
+	also for for individual next hops in a static multipath route (see
+	above). Note that BFD protocol also has to be configured, see
+	<ref id="sect-bfd" name="BFD"> section for details. Default value is no.
+
+	<tag><m/filter expression/</tag>
+	This is a special option that allows filter expressions to be configured
+	on per-route basis. Can be used multiple times. These expressions are
+	evaluated when the route is originated, similarly to the import filter
+	of the static protocol. This is especially useful for configuring route
+	attributes, e.g., <cf/ospf_metric1 = 100;/ for a route that will be
+	exported to the OSPF protocol.
 </descrip>
 
 <p>Static routes have no specific attributes.
@@ -3572,14 +3617,23 @@ of the protocol contains mainly a list of static routes:
 
 <p><code>
 protocol static {
-	table testable;			 # Connect to a non-default routing table
+	table testable;			# Connect to a non-default routing table
+	check link;			# Advertise routes only if link is up
 	route 0.0.0.0/0 via 198.51.100.130; # Default route
-	route 10.0.0.0/8 multipath	 # Multipath route
+	route 10.0.0.0/8 multipath	# Multipath route
 		via 198.51.100.10 weight 2
-		via 198.51.100.20
+		via 198.51.100.20 bfd	# BFD-controlled next hop
 		via 192.0.2.1;
 	route 203.0.113.0/24 unreachable; # Sink route
-	route 10.2.0.0/24 via "arc0";	 # Secondary network
+	route 10.2.0.0/24 via "arc0";	# Secondary network
+	route 192.168.10.0/24 via 198.51.100.100 {
+		ospf_metric1 = 20;	# Set extended attribute
+	}
+	route 192.168.10.0/24 via 198.51.100.100 {
+		ospf_metric2 = 100;	# Set extended attribute
+		ospf_tag = 2;		# Set extended attribute
+		bfd;			# BFD-controlled route
+	}
 }
 </code>
 

From a7baa09862e6b4856cd66197c6bd74c7df336b8f Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Wed, 13 Apr 2016 14:30:28 +0200
Subject: [PATCH 069/165] BSD: Add the IPsec SA/SP database entries control

Add code for manipulation with TCP-MD5 keys in the IPsec SA/SP database
at FreeBSD systems. Now, BGP MD5 authentication (RFC 2385) keys are
handled automatically on both Linux and FreeBSD.

Based on patches from Pavel Tvrdik.
---
 doc/bird.sgml        |  17 ++++-
 lib/socket.h         |   2 +-
 proto/bgp/bgp.c      |   6 +-
 proto/bgp/bgp.h      |   1 +
 proto/bgp/config.Y   |   4 +-
 sysdep/bsd/Modules   |   1 +
 sysdep/bsd/setkey.h  | 170 +++++++++++++++++++++++++++++++++++++++++++
 sysdep/bsd/sysio.h   |  28 +++----
 sysdep/linux/sysio.h |   6 +-
 sysdep/unix/io.c     |  25 +++++--
 10 files changed, 226 insertions(+), 34 deletions(-)
 create mode 100644 sysdep/bsd/setkey.h

diff --git a/doc/bird.sgml b/doc/bird.sgml
index 653e0bb5..1a5fbaff 100644
--- a/doc/bird.sgml
+++ b/doc/bird.sgml
@@ -1764,9 +1764,20 @@ using the following configuration parameters:
 	only. Default: disabled.
 
 	<tag>password <m/string/</tag>
-	Use this password for MD5 authentication of BGP sessions. Default: no
-	authentication. Password has to be set by external utility
-	(e.g. setkey(8)) on BSD systems.
+	Use this password for MD5 authentication of BGP sessions (RFC 2385).
+	When used on BSD systems, see also <cf/setkey/ option below. Default:
+	no authentication.
+
+	<tag>setkey <m/switch/</tag>
+	On BSD systems, keys for TCP MD5 authentication are stored in the global
+	SA/SP database, which can be accessed by external utilities (e.g.
+	setkey(8)). BIRD configures security associations in the SA/SP database
+	automatically based on <cf/password/ options (see above), this option
+	allows to disable automatic updates by BIRD when manual configuration by
+	external utilities is preferred. Note that automatic SA/SP database
+	updates are currently implemented only for FreeBSD. Passwords have to be
+	set manually by an external utility on NetBSD and OpenBSD. Default:
+	enabled (ignored on non-FreeBSD).
 
 	<tag>passive <m/switch/</tag>
 	Standard BGP behavior is both initiating outgoing connections and
diff --git a/lib/socket.h b/lib/socket.h
index 0327e9e5..6babfa7b 100644
--- a/lib/socket.h
+++ b/lib/socket.h
@@ -87,7 +87,7 @@ int sk_leave_group(sock *s, ip_addr maddr);	/* Leave multicast group on sk iface
 int sk_setup_broadcast(sock *s);
 int sk_set_ttl(sock *s, int ttl);	/* Set transmit TTL for given socket */
 int sk_set_min_ttl(sock *s, int ttl);	/* Set minimal accepted TTL for given socket */
-int sk_set_md5_auth(sock *s, ip_addr a, struct iface *ifa, char *passwd);
+int sk_set_md5_auth(sock *s, ip_addr local, ip_addr remote, struct iface *ifa, char *passwd, int setkey);
 int sk_set_ipv6_checksum(sock *s, int offset);
 int sk_set_icmp6_filter(sock *s, int p1, int p2);
 void sk_log_error(sock *s, const char *p);
diff --git a/proto/bgp/bgp.c b/proto/bgp/bgp.c
index 94c8e5c2..2014525e 100644
--- a/proto/bgp/bgp.c
+++ b/proto/bgp/bgp.c
@@ -121,7 +121,8 @@ bgp_open(struct bgp_proto *p)
   bgp_counter++;
 
   if (p->cf->password)
-    if (sk_set_md5_auth(bgp_listen_sk, p->cf->remote_ip, p->cf->iface, p->cf->password) < 0)
+    if (sk_set_md5_auth(bgp_listen_sk, p->cf->source_addr, p->cf->remote_ip,
+			p->cf->iface, p->cf->password, p->cf->setkey) < 0)
       {
 	sk_log_error(bgp_listen_sk, p->p.name);
 	bgp_close(p, 0);
@@ -191,7 +192,8 @@ bgp_close(struct bgp_proto *p, int apply_md5)
   bgp_counter--;
 
   if (p->cf->password && apply_md5)
-    if (sk_set_md5_auth(bgp_listen_sk, p->cf->remote_ip, p->cf->iface, NULL) < 0)
+    if (sk_set_md5_auth(bgp_listen_sk, p->cf->source_addr, p->cf->remote_ip,
+			p->cf->iface, NULL, p->cf->setkey) < 0)
       sk_log_error(bgp_listen_sk, p->p.name);
 
   if (!bgp_counter)
diff --git a/proto/bgp/bgp.h b/proto/bgp/bgp.h
index 274794f1..b1cca2d9 100644
--- a/proto/bgp/bgp.h
+++ b/proto/bgp/bgp.h
@@ -51,6 +51,7 @@ struct bgp_config {
   int add_path;				/* Use ADD-PATH extension [draft] */
   int allow_local_as;			/* Allow that number of local ASNs in incoming AS_PATHs */
   int gr_mode;				/* Graceful restart mode (BGP_GR_*) */
+  int setkey;				/* Set MD5 password to system SA/SP database */
   unsigned gr_time;			/* Graceful restart timeout */
   unsigned connect_delay_time;		/* Minimum delay between connect attempts */
   unsigned connect_retry_time;		/* Timeout for connect attempts */
diff --git a/proto/bgp/config.Y b/proto/bgp/config.Y
index 85b93a6b..f3ba0e16 100644
--- a/proto/bgp/config.Y
+++ b/proto/bgp/config.Y
@@ -27,7 +27,7 @@ CF_KEYWORDS(BGP, LOCAL, NEIGHBOR, AS, HOLD, TIME, CONNECT, RETRY,
 	INTERPRET, COMMUNITIES, BGP_ORIGINATOR_ID, BGP_CLUSTER_LIST, IGP,
 	TABLE, GATEWAY, DIRECT, RECURSIVE, MED, TTL, SECURITY, DETERMINISTIC,
 	SECONDARY, ALLOW, BFD, ADD, PATHS, RX, TX, GRACEFUL, RESTART, AWARE,
-	CHECK, LINK, PORT, EXTENDED, MESSAGES)
+	CHECK, LINK, PORT, EXTENDED, MESSAGES, SETKEY)
 
 CF_GRAMMAR
 
@@ -54,6 +54,7 @@ bgp_proto_start: proto_start BGP {
      BGP_CFG->default_local_pref = 100;
      BGP_CFG->gr_mode = BGP_GR_AWARE;
      BGP_CFG->gr_time = 120;
+     BGP_CFG->setkey = 1;
  }
  ;
 
@@ -112,6 +113,7 @@ bgp_proto:
  | bgp_proto CAPABILITIES bool ';' { BGP_CFG->capabilities = $3; }
  | bgp_proto ADVERTISE IPV4 bool ';' { BGP_CFG->advertise_ipv4 = $4; }
  | bgp_proto PASSWORD text ';' { BGP_CFG->password = $3; }
+ | bgp_proto SETKEY bool ';' { BGP_CFG->setkey = $3; }
  | bgp_proto ROUTE LIMIT expr ';' {
      this_proto->in_limit = cfg_allocz(sizeof(struct proto_limit));
      this_proto->in_limit->limit = $4;
diff --git a/sysdep/bsd/Modules b/sysdep/bsd/Modules
index 96455db7..39db88e9 100644
--- a/sysdep/bsd/Modules
+++ b/sysdep/bsd/Modules
@@ -2,3 +2,4 @@ krt-sock.c
 krt-sock.Y
 krt-sys.h
 sysio.h
+setkey.h
diff --git a/sysdep/bsd/setkey.h b/sysdep/bsd/setkey.h
new file mode 100644
index 00000000..b417faca
--- /dev/null
+++ b/sysdep/bsd/setkey.h
@@ -0,0 +1,170 @@
+/*
+ *	BIRD -- Manipulation the IPsec SA/SP database using setkey(8) utility
+ *
+ * 	(c) 2016 CZ.NIC z.s.p.o.
+ */
+
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <net/pfkeyv2.h>
+#include <netipsec/ipsec.h>
+
+#include "nest/bird.h"
+#include "lib/unix.h"
+
+
+/*
+ * Open a socket for manage the IPsec SA/SP database entries
+ */
+static int
+setkey_open_socket(void)
+{
+  int s = socket(PF_KEY, SOCK_RAW, PF_KEY_V2);
+  if (s < 0)
+  {
+    log(L_ERR "SETKEY: socket: %m");
+    return -1;
+  }
+
+  return s;
+}
+
+static int
+setkey_send(struct sadb_msg *msg, uint len)
+{
+  int s = setkey_open_socket();
+  if (s < 0)
+    return -1;
+
+  if (msg->sadb_msg_type == SADB_ADD)
+  {
+    /* Delete possible current key in the IPsec SA/SP database */
+    msg->sadb_msg_type = SADB_DELETE;
+    send(s, msg, len, 0);
+    msg->sadb_msg_type = SADB_ADD;
+  }
+
+  if (send(s, msg, len, 0) < 0)
+  {
+    log(L_ERR "SETKEY: send: %m");
+    close(s);
+    return -1;
+  }
+
+  close(s);
+  return 0;
+}
+
+/*
+ * Perform setkey(8)-like operation for set the password for TCP MD5 Signature.
+ * Could be called with SABD_ADD or SADB_DELETE argument. Note that SADB_ADD
+ * argument is internally processed as a pair of SADB_ADD and SADB_DELETE
+ * operations to implement replace.
+ */
+static int
+setkey_md5(sockaddr *src, sockaddr *dst, char *passwd, uint type)
+{
+  uint passwd_len = passwd ? strlen(passwd) : 0;
+
+  uint total =
+    sizeof(struct sadb_msg) +
+    sizeof(struct sadb_key) + PFKEY_ALIGN8(passwd_len) +
+    sizeof(struct sadb_sa) +
+    sizeof(struct sadb_x_sa2) +
+    sizeof(struct sadb_address) + PFKEY_ALIGN8(src->sa.sa_len) +
+    sizeof(struct sadb_address) + PFKEY_ALIGN8(dst->sa.sa_len);
+
+  char *buf = alloca(total);
+  char *pos = buf;
+  uint len;
+
+  memset(buf, 0, total);
+
+  struct sadb_msg *msg = (void *) pos;
+  len = sizeof(struct sadb_msg);
+  msg->sadb_msg_version = PF_KEY_V2;
+  msg->sadb_msg_type = type;
+  msg->sadb_msg_satype = SADB_X_SATYPE_TCPSIGNATURE;
+  msg->sadb_msg_len = 0;	/* Fix it later */
+  msg->sadb_msg_pid = getpid();
+  pos += len;
+
+  /* Set authentication algorithm and password */
+  struct sadb_key *key = (void *) pos;
+  len = sizeof(struct sadb_key) + PFKEY_ALIGN8(passwd_len);
+  key->sadb_key_len = PFKEY_UNIT64(len);
+  key->sadb_key_exttype = SADB_EXT_KEY_AUTH;
+  key->sadb_key_bits = passwd_len * 8;
+  memcpy(pos + sizeof(struct sadb_key), passwd, passwd_len);
+  pos += len;
+
+  struct sadb_sa *sa = (void *) pos;
+  len = sizeof(struct sadb_sa);
+  sa->sadb_sa_len = PFKEY_UNIT64(len);
+  sa->sadb_sa_exttype = SADB_EXT_SA;
+  sa->sadb_sa_spi = htonl((u32) TCP_SIG_SPI);
+  sa->sadb_sa_auth = SADB_X_AALG_TCP_MD5;
+  sa->sadb_sa_encrypt = SADB_EALG_NONE;
+  sa->sadb_sa_flags = SADB_X_EXT_CYCSEQ;
+  pos += len;
+
+  struct sadb_x_sa2 *sa2 = (void *) pos;
+  len = sizeof(struct sadb_x_sa2);
+  sa2->sadb_x_sa2_len = PFKEY_UNIT64(len);
+  sa2->sadb_x_sa2_exttype = SADB_X_EXT_SA2;
+  sa2->sadb_x_sa2_mode = IPSEC_MODE_ANY;
+  pos += len;
+
+  /* Set source address */
+  struct sadb_address *saddr = (void *) pos;
+  len = sizeof(struct sadb_address) + PFKEY_ALIGN8(src->sa.sa_len);
+  saddr->sadb_address_len = PFKEY_UNIT64(len);
+  saddr->sadb_address_exttype = SADB_EXT_ADDRESS_SRC;
+  saddr->sadb_address_proto = IPSEC_ULPROTO_ANY;
+  saddr->sadb_address_prefixlen = MAX_PREFIX_LENGTH;
+  memcpy(pos + sizeof(struct sadb_address), &src->sa, src->sa.sa_len);
+  pos += len;
+
+  /* Set destination address */
+  struct sadb_address *daddr = (void *) pos;
+  len = sizeof(struct sadb_address) + PFKEY_ALIGN8(dst->sa.sa_len);
+  daddr->sadb_address_len = PFKEY_UNIT64(len);
+  daddr->sadb_address_exttype = SADB_EXT_ADDRESS_DST;
+  daddr->sadb_address_proto = IPSEC_ULPROTO_ANY;
+  daddr->sadb_address_prefixlen = MAX_PREFIX_LENGTH;
+  memcpy(pos + sizeof(struct sadb_address), &dst->sa, dst->sa.sa_len);
+  pos += len;
+
+  len = pos - buf;
+  msg->sadb_msg_len = PFKEY_UNIT64(len);
+
+  return setkey_send(msg, len);
+}
+
+/*
+ * Manipulation with the IPsec SA/SP database
+ */
+static int
+sk_set_md5_in_sasp_db(sock *s, ip_addr local, ip_addr remote, struct iface *ifa, char *passwd)
+{
+  sockaddr src, dst;
+  sockaddr_fill(&src, s->af, local, ifa, 0);
+  sockaddr_fill(&dst, s->af, remote, ifa, 0);
+
+  if (passwd && *passwd)
+  {
+    int len = strlen(passwd);
+    if (len > TCP_KEYLEN_MAX)
+      ERR_MSG("The password for TCP MD5 Signature is too long");
+
+    if (setkey_md5(&src, &dst, passwd, SADB_ADD) < 0)
+      ERR_MSG("Cannot add TCP-MD5 password into the IPsec SA/SP database");
+  }
+  else
+  {
+    if (setkey_md5(&src, &dst, NULL, SADB_DELETE) < 0)
+      ERR_MSG("Cannot delete TCP-MD5 password from the IPsec SA/SP database");
+  }
+  return 0;
+}
diff --git a/sysdep/bsd/sysio.h b/sysdep/bsd/sysio.h
index c82d7a1e..6c20733f 100644
--- a/sysdep/bsd/sysio.h
+++ b/sysdep/bsd/sysio.h
@@ -189,30 +189,26 @@ sk_prepare_ip_header(sock *s, void *hdr, int dlen)
 #ifndef TCP_KEYLEN_MAX
 #define TCP_KEYLEN_MAX 80
 #endif
+
 #ifndef TCP_SIG_SPI
 #define TCP_SIG_SPI 0x1000
 #endif
 
-/* 
- * FIXME: Passwords has to be set by setkey(8) command. This is the same
- * behaviour like Quagga. We need to add code for SA/SP entries
- * management.
- */
+#if defined(__FreeBSD__)
+#define USE_MD5SIG_SETKEY
+#include "lib/setkey.h"
+#endif
 
 int
-sk_set_md5_auth(sock *s, ip_addr a, struct iface *ifa, char *passwd)
+sk_set_md5_auth(sock *s, ip_addr local, ip_addr remote, struct iface *ifa, char *passwd, int setkey UNUSED)
 {
-  int enable = 0;
-
-  if (passwd && *passwd)
-  {
-    int len = strlen(passwd);
-    enable = TCP_SIG_SPI;
-
-    if (len > TCP_KEYLEN_MAX)
-      ERR_MSG("MD5 password too long");
-  }
+#ifdef USE_MD5SIG_SETKEY
+  if (setkey)
+    if (sk_set_md5_in_sasp_db(s, local, remote, ifa, passwd) < 0)
+      return -1;
+#endif
 
+  int enable = (passwd && *passwd) ? TCP_SIG_SPI : 0;
   if (setsockopt(s->fd, IPPROTO_TCP, TCP_MD5SIG, &enable, sizeof(enable)) < 0)
   {
     if (errno == ENOPROTOOPT)
diff --git a/sysdep/linux/sysio.h b/sysdep/linux/sysio.h
index c1561cbf..58644417 100644
--- a/sysdep/linux/sysio.h
+++ b/sysdep/linux/sysio.h
@@ -179,19 +179,19 @@ sk_prepare_cmsgs4(sock *s, struct msghdr *msg, void *cbuf, size_t cbuflen)
  */
 
 int
-sk_set_md5_auth(sock *s, ip_addr a, struct iface *ifa, char *passwd)
+sk_set_md5_auth(sock *s, ip_addr local UNUSED, ip_addr remote, struct iface *ifa, char *passwd, int setkey UNUSED)
 {
   struct tcp_md5sig md5;
 
   memset(&md5, 0, sizeof(md5));
-  sockaddr_fill((sockaddr *) &md5.tcpm_addr, s->af, a, ifa, 0);
+  sockaddr_fill((sockaddr *) &md5.tcpm_addr, s->af, remote, ifa, 0);
 
   if (passwd)
   {
     int len = strlen(passwd);
 
     if (len > TCP_MD5SIG_MAXKEYLEN)
-      ERR_MSG("MD5 password too long");
+      ERR_MSG("The password for TCP MD5 Signature is too long");
 
     md5.tcpm_keylen = len;
     memcpy(&md5.tcpm_key, passwd, len);
diff --git a/sysdep/unix/io.c b/sysdep/unix/io.c
index 5955dbfe..d918d321 100644
--- a/sysdep/unix/io.c
+++ b/sysdep/unix/io.c
@@ -951,23 +951,32 @@ sk_set_min_ttl(sock *s, int ttl)
 /**
  * sk_set_md5_auth - add / remove MD5 security association for given socket
  * @s: socket
- * @a: IP address of the other side
+ * @local: IP address of local side
+ * @remote: IP address of remote side
  * @ifa: Interface for link-local IP address
- * @passwd: password used for MD5 authentication
+ * @passwd: Password used for MD5 authentication
+ * @setkey: Update also system SA/SP database
  *
- * In TCP MD5 handling code in kernel, there is a set of pairs (address,
- * password) used to choose password according to address of the other side.
- * This function is useful for listening socket, for active sockets it is enough
- * to set s->password field.
+ * In TCP MD5 handling code in kernel, there is a set of security associations
+ * used for choosing password and other authentication parameters according to
+ * the local and remote address. This function is useful for listening socket,
+ * for active sockets it may be enough to set s->password field.
  *
  * When called with passwd != NULL, the new pair is added,
  * When called with passwd == NULL, the existing pair is removed.
  *
+ * Note that while in Linux, the MD5 SAs are specific to socket, in BSD they are
+ * stored in global SA/SP database (but the behavior also must be enabled on
+ * per-socket basis). In case of multiple sockets to the same neighbor, the
+ * socket-specific state must be configured for each socket while global state
+ * just once per src-dst pair. The @setkey argument controls whether the global
+ * state (SA/SP database) is also updated.
+ *
  * Result: 0 for success, -1 for an error.
  */
 
 int
-sk_set_md5_auth(sock *s, ip_addr a, struct iface *ifa, char *passwd)
+sk_set_md5_auth(sock *s, ip_addr local, ip_addr remote, struct iface *ifa, char *passwd, int setkey)
 { DUMMY; }
 #endif
 
@@ -1437,7 +1446,7 @@ sk_open(sock *s)
   }
 
   if (s->password)
-    if (sk_set_md5_auth(s, s->daddr, s->iface, s->password) < 0)
+    if (sk_set_md5_auth(s, s->saddr, s->daddr, s->iface, s->password, 0) < 0)
       goto err;
 
   switch (s->type)

From 937e75d8f1d203b637ba0ea050026f9af92485f3 Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Thu, 28 Apr 2016 18:01:40 +0200
Subject: [PATCH 070/165] Add the Babel routing protocol (RFC 6126)

This patch implements the IPv6 subset of the Babel routing protocol.
Based on the patch from Toke Hoiland-Jorgensen, with some heavy
modifications and bugfixes.

Thanks to Toke Hoiland-Jorgensen for the original patch.
---
 configure.in          |    3 +
 doc/bird.sgml         |   96 ++
 doc/reply_codes       |    3 +
 lib/birdlib.h         |    1 +
 lib/bitops.h          |    3 +-
 lib/ip.h              |    1 +
 lib/printf.c          |   31 +-
 lib/string.h          |    2 +
 nest/proto.c          |    3 +
 nest/protocol.h       |    2 +-
 nest/route.h          |   11 +-
 proto/Doc             |    1 +
 proto/babel/Doc       |    2 +
 proto/babel/Makefile  |    5 +
 proto/babel/babel.c   | 2055 +++++++++++++++++++++++++++++++++++++++++
 proto/babel/babel.h   |  335 +++++++
 proto/babel/config.Y  |  129 +++
 proto/babel/packets.c | 1093 ++++++++++++++++++++++
 sysdep/autoconf.h.in  |    1 +
 19 files changed, 3767 insertions(+), 10 deletions(-)
 create mode 100644 proto/babel/Doc
 create mode 100644 proto/babel/Makefile
 create mode 100644 proto/babel/babel.c
 create mode 100644 proto/babel/babel.h
 create mode 100644 proto/babel/config.Y
 create mode 100644 proto/babel/packets.c

diff --git a/configure.in b/configure.in
index b9220a1d..16a0b414 100644
--- a/configure.in
+++ b/configure.in
@@ -206,6 +206,9 @@ fi
 AC_SUBST(iproutedir)
 
 all_protocols="$proto_bfd bgp ospf pipe $proto_radv rip static"
+if test "$ip" = ipv6 ; then
+   all_protocols="$all_protocols babel"
+fi
 all_protocols=`echo $all_protocols | sed 's/ /,/g'`
 
 if test "$with_protocols" = all ; then
diff --git a/doc/bird.sgml b/doc/bird.sgml
index 1a5fbaff..6c6ff3db 100644
--- a/doc/bird.sgml
+++ b/doc/bird.sgml
@@ -1380,6 +1380,102 @@ corresponding protocol sections.
 
 <chapt>Protocols
 
+<sect>Babel
+
+<sect1>Introduction
+
+<p>The Babel protocol (RFC6126) is a loop-avoiding distance-vector routing
+protocol that is robust and efficient both in ordinary wired networks and in
+wireless mesh networks. Babel is conceptually very simple in its operation and
+"just works" in its default configuration, though some configuration is possible
+and in some cases desirable.
+
+<p>While the Babel protocol is dual stack (i.e., can carry both IPv4 and IPv6
+routes over the same IPv6 transport), BIRD presently implements only the IPv6
+subset of the protocol. No Babel extensions are implemented, but the BIRD
+implementation can coexist with implementations using the extensions (and will
+just ignore extension messages).
+
+<p>The Babel protocol implementation in BIRD is currently in alpha stage.
+
+<sect1>Configuration
+
+<p>Babel supports no global configuration options apart from those common to all
+other protocols, but supports the following per-interface configuration options:
+
+<code>
+protocol babel [<name>] {
+	interface <interface pattern> {
+		type <wired|wireless>;
+		rxcost <number>;
+		hello interval <number>;
+		update interval <number>;
+		port <number>;
+		tx class|dscp <number>;
+		tx priority <number>;
+		rx buffer <number>;
+		tx length <number>;
+		check link <switch>;
+	};
+}
+</code>
+
+<descrip>
+      <tag>type wired|wireless </tag>
+      This option specifies the interface type: Wired or wireless. Wired
+      interfaces are considered more reliable, and so the default hello
+      interval is higher, and a neighbour is considered unreachable after only
+      a small number of "hello" packets are lost. On wireless interfaces,
+      hello packets are sent more often, and the ETX link quality estimation
+      technique is used to compute the metrics of routes discovered over this
+      interface. This technique will gradually degrade the metric of routes
+      when packets are lost rather than the more binary up/down mechanism of
+      wired type links. Default: <cf/wired/.
+
+      <tag>rxcost <m/num/</tag>
+      This specifies the RX cost of the interface. The route metrics will be
+      computed from this value with a mechanism determined by the interface
+      <cf/type/. Default: 96 for wired interfaces, 256 for wireless.
+
+      <tag>hello interval <m/num/</tag>
+      Interval at which periodic "hello" messages are sent on this interface,
+      in seconds. Default: 4 seconds.
+
+      <tag>update interval <m/num/</tag>
+      Interval at which periodic (full) updates are sent. Default: 4 times the
+      hello interval.
+
+      <tag>port <m/number/</tag>
+      This option selects an UDP port to operate on. The default is to operate
+      on port 6696 as specified in the Babel RFC.
+
+      <tag>tx class|dscp|priority <m/number/</tag>
+      These options specify the ToS/DiffServ/Traffic class/Priority of the
+      outgoing Babel packets. See <ref id="dsc-prio" name="tx class"> common
+      option for detailed description.
+
+      <tag>rx buffer <m/number/</tag>
+      This option specifies the size of buffers used for packet processing.
+      The buffer size should be bigger than maximal size of received packets.
+      The default value is the interface MTU, and the value will be clamped to a
+      minimum of 512 bytes + IP packet overhead.
+
+      <tag>tx length <m/number/</tag>
+      This option specifies the maximum length of generated Babel packets. To
+      avoid IP fragmentation, it should not exceed the interface MTU value.
+      The default value is the interface MTU value, and the value will be
+      clamped to a minimum of 512 bytes + IP packet overhead.
+
+      <tag>check link <m/switch/</tag>
+      If set, the hardware link state (as reported by OS) is taken into
+      consideration. When the link disappears (e.g. an ethernet cable is
+      unplugged), neighbors are immediately considered unreachable and all
+      routes received from them are withdrawn. It is possible that some
+      hardware drivers or platforms do not implement this feature. Default:
+      yes.
+</descrip>
+
+
 <sect><label id="sect-bfd">BFD
 
 <sect1>Introduction
diff --git a/doc/reply_codes b/doc/reply_codes
index 79a7eb92..3a7f2c90 100644
--- a/doc/reply_codes
+++ b/doc/reply_codes
@@ -57,6 +57,9 @@ Reply codes of BIRD command-line interface
 1020	Show BFD sessions
 1021	Show RIP interface
 1022	Show RIP neighbors
+1023	Show Babel interfaces
+1024	Show Babel neighbors
+1025	Show Babel entries
 
 8000	Reply too long
 8001	Route not found
diff --git a/lib/birdlib.h b/lib/birdlib.h
index 16f437ef..904544cb 100644
--- a/lib/birdlib.h
+++ b/lib/birdlib.h
@@ -60,6 +60,7 @@
 
 #define NORET __attribute__((noreturn))
 #define UNUSED __attribute__((unused))
+#define PACKED __attribute__((packed))
 
 
 /* Microsecond time */
diff --git a/lib/bitops.h b/lib/bitops.h
index c0ad1a70..ce13732a 100644
--- a/lib/bitops.h
+++ b/lib/bitops.h
@@ -25,5 +25,6 @@ u32 u32_log2(u32 v);
 
 static inline u32 u32_hash(u32 v) { return v * 2902958171u; }
 
-#endif
+static inline u8 u32_popcount(u32 v) { return __builtin_popcount(v); }
 
+#endif
diff --git a/lib/ip.h b/lib/ip.h
index 5389c44a..298b72a7 100644
--- a/lib/ip.h
+++ b/lib/ip.h
@@ -26,6 +26,7 @@
 #define IP6_OSPF_ALL_ROUTERS	ipa_build6(0xFF020000, 0, 0, 5)
 #define IP6_OSPF_DES_ROUTERS	ipa_build6(0xFF020000, 0, 0, 6)
 #define IP6_RIP_ROUTERS		ipa_build6(0xFF020000, 0, 0, 9)
+#define IP6_BABEL_ROUTERS	ipa_build6(0xFF020000, 0, 0, 0x00010006)
 
 #define IP4_NONE		_MI4(0)
 #define IP6_NONE		_MI6(0,0,0,0)
diff --git a/lib/printf.c b/lib/printf.c
index e4cc3006..a067fe98 100644
--- a/lib/printf.c
+++ b/lib/printf.c
@@ -124,6 +124,7 @@ static char * number(char * str, long num, int base, int size, int precision,
  * width is automatically replaced by standard IP address width which
  * depends on whether we use IPv4 or IPv6; |%#I| gives hexadecimal format),
  * |%R| for Router / Network ID (u32 value printed as IPv4 address)
+ * |%lR| for 64bit Router / Network ID (u64 value printed as eight :-separated octets)
  * and |%m| resp. |%M| for error messages (uses strerror() to translate @errno code to
  * message text). On the other hand, it doesn't support floating
  * point numbers.
@@ -137,9 +138,10 @@ int bvsnprintf(char *buf, int size, const char *fmt, va_list args)
 	unsigned long num;
 	int i, base;
 	u32 x;
+	u64 X;
 	char *str, *start;
 	const char *s;
-	char ipbuf[STD_ADDRESS_P_LENGTH+1];
+	char ipbuf[MAX(STD_ADDRESS_P_LENGTH,ROUTER_ID_64_LENGTH)+1];
 	struct iface *iface;
 
 	int flags;		/* flags to number() */
@@ -309,12 +311,27 @@ int bvsnprintf(char *buf, int size, const char *fmt, va_list args)
 
 		/* Router/Network ID - essentially IPv4 address in u32 value */
 		case 'R':
-			x = va_arg(args, u32);
-			bsprintf(ipbuf, "%d.%d.%d.%d",
-				 ((x >> 24) & 0xff),
-				 ((x >> 16) & 0xff),
-				 ((x >> 8) & 0xff),
-				 (x & 0xff));
+			if(qualifier == 'l') {
+				X = va_arg(args, u64);
+				bsprintf(ipbuf, "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
+					((X >> 56) & 0xff),
+					((X >> 48) & 0xff),
+					((X >> 40) & 0xff),
+					((X >> 32) & 0xff),
+					((X >> 24) & 0xff),
+					((X >> 16) & 0xff),
+					((X >> 8) & 0xff),
+					(X & 0xff));
+			}
+			else
+			{
+				x = va_arg(args, u32);
+				bsprintf(ipbuf, "%d.%d.%d.%d",
+					((x >> 24) & 0xff),
+					((x >> 16) & 0xff),
+					((x >> 8) & 0xff),
+					(x & 0xff));
+			}
 			s = ipbuf;
 			goto str;
 
diff --git a/lib/string.h b/lib/string.h
index 0f249d37..9af49b9e 100644
--- a/lib/string.h
+++ b/lib/string.h
@@ -30,4 +30,6 @@ static inline char *xbasename(const char *str)
   return s ? s+1 : (char *) str;
 }
 
+#define ROUTER_ID_64_LENGTH 23
+
 #endif
diff --git a/nest/proto.c b/nest/proto.c
index 436377f1..3e97e9da 100644
--- a/nest/proto.c
+++ b/nest/proto.c
@@ -919,6 +919,9 @@ protos_build(void)
   proto_build(&proto_bfd);
   bfd_init_all();
 #endif
+#ifdef CONFIG_BABEL
+  proto_build(&proto_babel);
+#endif
 
   proto_pool = rp_new(&root_pool, "Protocols");
   proto_flush_event = ev_new(proto_pool);
diff --git a/nest/protocol.h b/nest/protocol.h
index 8c49154f..ec787355 100644
--- a/nest/protocol.h
+++ b/nest/protocol.h
@@ -76,7 +76,7 @@ void protos_dump_all(void);
 
 extern struct protocol
   proto_device, proto_radv, proto_rip, proto_static,
-  proto_ospf, proto_pipe, proto_bgp, proto_bfd;
+  proto_ospf, proto_pipe, proto_bgp, proto_bfd, proto_babel;
 
 /*
  *	Routing Protocol Instance
diff --git a/nest/route.h b/nest/route.h
index 9368808f..3969db6b 100644
--- a/nest/route.h
+++ b/nest/route.h
@@ -219,6 +219,12 @@ typedef struct rte {
     struct {
       u8 suppressed;			/* Used for deterministic MED comparison */
     } bgp;
+#endif
+#ifdef CONFIG_BABEL
+    struct {
+      u16 metric;			/* Babel metric */
+      u64 router_id;			/* Babel router id */
+    } babel;
 #endif
     struct {				/* Routes generated by krt sync (both temporary and inherited ones) */
       s8 src;				/* Alleged route source (see krt.h) */
@@ -374,6 +380,7 @@ typedef struct rta {
 #define RTS_OSPF_EXT2 10		/* OSPF external route type 2 */
 #define RTS_BGP 11			/* BGP route */
 #define RTS_PIPE 12			/* Inter-table wormhole */
+#define RTS_BABEL 13			/* Babel route */
 
 #define RTC_UNICAST 0
 #define RTC_BROADCAST 1
@@ -422,7 +429,8 @@ typedef struct eattr {
 #define EAP_RIP 2			/* RIP */
 #define EAP_OSPF 3			/* OSPF */
 #define EAP_KRT 4			/* Kernel route attributes */
-#define EAP_MAX 5
+#define EAP_BABEL 5			/* Babel attributes */
+#define EAP_MAX 6
 
 #define EA_CODE(proto,id) (((proto) << 8) | (id))
 #define EA_PROTO(ea) ((ea) >> 8)
@@ -547,6 +555,7 @@ extern struct protocol *attr_class_to_protocol[EAP_MAX];
 #define DEF_PREF_DIRECT	    	240	/* Directly connected */
 #define DEF_PREF_STATIC		200	/* Static route */
 #define DEF_PREF_OSPF		150	/* OSPF intra-area, inter-area and type 1 external routes */
+#define DEF_PREF_BABEL		130	/* Babel */
 #define DEF_PREF_RIP		120	/* RIP */
 #define DEF_PREF_BGP		100	/* BGP */
 #define DEF_PREF_PIPE		70	/* Routes piped from other tables */
diff --git a/proto/Doc b/proto/Doc
index 7863472f..04c25bc0 100644
--- a/proto/Doc
+++ b/proto/Doc
@@ -1,4 +1,5 @@
 H Protocols
+C babel
 C bfd
 C bgp
 C ospf
diff --git a/proto/babel/Doc b/proto/babel/Doc
new file mode 100644
index 00000000..2480239e
--- /dev/null
+++ b/proto/babel/Doc
@@ -0,0 +1,2 @@
+S babel.c
+S packet.c
diff --git a/proto/babel/Makefile b/proto/babel/Makefile
new file mode 100644
index 00000000..400ffbac
--- /dev/null
+++ b/proto/babel/Makefile
@@ -0,0 +1,5 @@
+source=babel.c packets.c
+root-rel=../../
+dir-name=proto/babel
+
+include ../../Rules
diff --git a/proto/babel/babel.c b/proto/babel/babel.c
new file mode 100644
index 00000000..8e104d60
--- /dev/null
+++ b/proto/babel/babel.c
@@ -0,0 +1,2055 @@
+/*
+ *	BIRD -- The Babel protocol
+ *
+ *	Copyright (c) 2015--2016 Toke Hoiland-Jorgensen
+ *
+ *	Can be freely distributed and used under the terms of the GNU GPL.
+ *
+ *	This file contains the main routines for handling and sending TLVs, as
+ *	well as timers and interaction with the nest.
+ */
+
+/**
+ * DOC: The Babel protocol
+ *
+ * Babel (RFC6126) is a loop-avoiding distance-vector routing protocol that is
+ * robust and efficient both in ordinary wired networks and in wireless mesh
+ * networks.
+ *
+ * The Babel protocol keeps state for each neighbour in a &babel_neighbor
+ * struct, tracking received Hello and I Heard You (IHU) messages. A
+ * &babel_interface struct keeps hello and update times for each interface, and
+ * a separate hello seqno is maintained for each interface.
+ *
+ * For each prefix, Babel keeps track of both the possible routes (with next hop
+ * and router IDs), as well as the feasibility distance for each prefix and
+ * router id. The prefix itself is tracked in a &babel_entry struct, while the
+ * possible routes for the prefix are tracked as &babel_route entries and the
+ * feasibility distance is maintained through &babel_source structures.
+ *
+ * The main route selection is done in babel_select_route(). This is called when
+ * an entry is updated by receiving updates from the network or when modified by
+ * internal timers. It performs feasibility checks on the available routes for
+ * the prefix and selects the one with the lowest metric to be announced to the
+ * core.
+ */
+
+#include <stdlib.h>
+#include "babel.h"
+
+
+#define OUR_ROUTE(r) (r->neigh == NULL)
+
+/*
+ * Is one number greater or equal than another mod 2^16? This is based on the
+ * definition of serial number space in RFC 1982. Note that arguments are of
+ * uint type to avoid integer promotion to signed integer.
+ */
+static inline int ge_mod64k(uint a, uint b)
+{ return (u16)(a - b) < 0x8000; }
+
+static void babel_dump_entry(struct babel_entry *e);
+static void babel_dump_route(struct babel_route *r);
+static void babel_select_route(struct babel_entry *e);
+static void babel_send_route_request(struct babel_entry *e, struct babel_neighbor *n);
+static void babel_send_wildcard_request(struct babel_iface *ifa);
+static int  babel_cache_seqno_request(struct babel_proto *p, ip_addr prefix, u8 plen,
+			       u64 router_id, u16 seqno);
+static void babel_trigger_iface_update(struct babel_iface *ifa);
+static void babel_trigger_update(struct babel_proto *p);
+static void babel_send_seqno_request(struct babel_entry *e);
+static inline void babel_kick_timer(struct babel_proto *p);
+static inline void babel_iface_kick_timer(struct babel_iface *ifa);
+
+
+/*
+ *	Functions to maintain data structures
+ */
+
+static void
+babel_init_entry(struct fib_node *n)
+{
+  struct babel_entry *e = (void *) n;
+  e->proto = NULL;
+  e->selected_in = NULL;
+  e->selected_out = NULL;
+  e->updated = now;
+  init_list(&e->sources);
+  init_list(&e->routes);
+}
+
+static inline struct babel_entry *
+babel_find_entry(struct babel_proto *p, ip_addr prefix, u8 plen)
+{
+  return fib_find(&p->rtable, &prefix, plen);
+}
+
+static struct babel_entry *
+babel_get_entry(struct babel_proto *p, ip_addr prefix, u8 plen)
+{
+  struct babel_entry *e = fib_get(&p->rtable, &prefix, plen);
+  e->proto = p;
+  return e;
+}
+
+static struct babel_source *
+babel_find_source(struct babel_entry *e, u64 router_id)
+{
+  struct babel_source *s;
+
+  WALK_LIST(s, e->sources)
+    if (s->router_id == router_id)
+      return s;
+
+  return NULL;
+}
+
+static struct babel_source *
+babel_get_source(struct babel_entry *e, u64 router_id)
+{
+  struct babel_proto *p = e->proto;
+  struct babel_source *s = babel_find_source(e, router_id);
+
+  if (s)
+    return s;
+
+  s = sl_alloc(p->source_slab);
+  s->router_id = router_id;
+  s->expires = now + BABEL_GARBAGE_INTERVAL;
+  s->seqno = 0;
+  s->metric = BABEL_INFINITY;
+  add_tail(&e->sources, NODE s);
+
+  return s;
+}
+
+static void
+babel_expire_sources(struct babel_entry *e)
+{
+  struct babel_proto *p = e->proto;
+  struct babel_source *n, *nx;
+
+  WALK_LIST_DELSAFE(n, nx, e->sources)
+  {
+    if (n->expires && n->expires <= now)
+    {
+      rem_node(NODE n);
+      sl_free(p->source_slab, n);
+    }
+  }
+}
+
+static struct babel_route *
+babel_find_route(struct babel_entry *e, struct babel_neighbor *n)
+{
+  struct babel_route *r;
+
+  WALK_LIST(r, e->routes)
+    if (r->neigh == n)
+      return r;
+
+  return NULL;
+}
+
+static struct babel_route *
+babel_get_route(struct babel_entry *e, struct babel_neighbor *nbr)
+{
+  struct babel_proto *p = e->proto;
+  struct babel_route *r = babel_find_route(e, nbr);
+
+  if (r)
+    return r;
+
+  r = sl_alloc(p->route_slab);
+  memset(r, 0, sizeof(*r));
+  r->e = e;
+  add_tail(&e->routes, NODE r);
+
+  if (nbr)
+  {
+    r->neigh = nbr;
+    r->expires = now + BABEL_GARBAGE_INTERVAL;
+    add_tail(&nbr->routes, NODE &r->neigh_route);
+  }
+
+  return r;
+}
+
+static void
+babel_flush_route(struct babel_route *r)
+{
+  struct babel_proto *p = r->e->proto;
+
+  DBG("Babel: Flush route %I/%d router_id %lR neigh %I\n",
+      r->e->n.prefix, r->e->n.pxlen, r->router_id, r->neigh ? r->neigh->addr : IPA_NONE);
+
+  rem_node(NODE r);
+
+  if (r->neigh)
+    rem_node(&r->neigh_route);
+
+  if (r->e->selected_in == r)
+    r->e->selected_in = NULL;
+
+  if (r->e->selected_out == r)
+    r->e->selected_out = NULL;
+
+  sl_free(p->route_slab, r);
+}
+
+static void
+babel_expire_route(struct babel_route *r)
+{
+  struct babel_proto *p = r->e->proto;
+  struct babel_entry *e = r->e;
+
+  TRACE(D_EVENTS, "Route expiry timer for %I/%d router-id %lR fired",
+	e->n.prefix, e->n.pxlen, r->router_id);
+
+  if (r->metric < BABEL_INFINITY)
+  {
+    r->metric = BABEL_INFINITY;
+    r->expires = now + r->expiry_interval;
+  }
+  else
+  {
+    babel_flush_route(r);
+  }
+}
+
+static void
+babel_refresh_route(struct babel_route *r)
+{
+  if (!OUR_ROUTE(r) && (r == r->e->selected_in))
+    babel_send_route_request(r->e, r->neigh);
+
+  r->refresh_time = 0;
+}
+
+static void
+babel_expire_routes(struct babel_proto *p)
+{
+  struct babel_entry *e;
+  struct babel_route *r, *rx;
+  struct fib_iterator fit;
+
+  FIB_ITERATE_INIT(&fit, &p->rtable);
+
+loop:
+  FIB_ITERATE_START(&p->rtable, &fit, n)
+  {
+    e = (struct babel_entry *) n;
+    int changed = 0;
+
+    WALK_LIST_DELSAFE(r, rx, e->routes)
+    {
+      if (r->refresh_time && r->refresh_time <= now)
+	babel_refresh_route(r);
+
+      if (r->expires && r->expires <= now)
+      {
+	babel_expire_route(r);
+	changed = 1;
+      }
+    }
+
+    if (changed)
+    {
+      /*
+       * We have to restart the iteration because there may be a cascade of
+       * synchronous events babel_select_route() -> nest table change ->
+       * babel_rt_notify() -> p->rtable change, invalidating hidden variables.
+       */
+
+      FIB_ITERATE_PUT(&fit, n);
+      babel_select_route(e);
+      goto loop;
+    }
+
+    babel_expire_sources(e);
+
+    /* Remove empty entries */
+    if (EMPTY_LIST(e->sources) && EMPTY_LIST(e->routes))
+    {
+      FIB_ITERATE_PUT(&fit, n);
+      fib_delete(&p->rtable, e);
+      goto loop;
+    }
+  }
+  FIB_ITERATE_END(n);
+}
+
+static struct babel_neighbor *
+babel_find_neighbor(struct babel_iface *ifa, ip_addr addr)
+{
+  struct babel_neighbor *nbr;
+
+  WALK_LIST(nbr, ifa->neigh_list)
+    if (ipa_equal(nbr->addr, addr))
+      return nbr;
+
+  return NULL;
+}
+
+static struct babel_neighbor *
+babel_get_neighbor(struct babel_iface *ifa, ip_addr addr)
+{
+  struct babel_neighbor *nbr = babel_find_neighbor(ifa, addr);
+
+  if (nbr)
+    return nbr;
+
+  nbr = mb_allocz(ifa->pool, sizeof(struct babel_neighbor));
+  nbr->ifa = ifa;
+  nbr->addr = addr;
+  nbr->txcost = BABEL_INFINITY;
+  init_list(&nbr->routes);
+  add_tail(&ifa->neigh_list, NODE nbr);
+
+  return nbr;
+}
+
+static void
+babel_flush_neighbor(struct babel_neighbor *nbr)
+{
+  struct babel_proto *p = nbr->ifa->proto;
+  node *n;
+
+  TRACE(D_EVENTS, "Flushing neighbor %I", nbr->addr);
+
+  WALK_LIST_FIRST(n, nbr->routes)
+  {
+    struct babel_route *r = SKIP_BACK(struct babel_route, neigh_route, n);
+    struct babel_entry *e = r->e;
+    int selected = (r == e->selected_in);
+
+    babel_flush_route(r);
+
+    if (selected)
+      babel_select_route(e);
+  }
+
+  rem_node(NODE nbr);
+  mb_free(nbr);
+}
+
+static void
+babel_expire_ihu(struct babel_neighbor *nbr)
+{
+  nbr->txcost = BABEL_INFINITY;
+}
+
+static void
+babel_expire_hello(struct babel_neighbor *nbr)
+{
+  nbr->hello_map <<= 1;
+
+  if (nbr->hello_cnt < 16)
+    nbr->hello_cnt++;
+
+  if (!nbr->hello_map)
+    babel_flush_neighbor(nbr);
+}
+
+static void
+babel_expire_neighbors(struct babel_proto *p)
+{
+  struct babel_iface *ifa;
+  struct babel_neighbor *nbr, *nbx;
+
+  WALK_LIST(ifa, p->interfaces)
+  {
+    WALK_LIST_DELSAFE(nbr, nbx, ifa->neigh_list)
+    {
+      if (nbr->ihu_expiry && nbr->ihu_expiry <= now)
+        babel_expire_ihu(nbr);
+
+      if (nbr->hello_expiry && nbr->hello_expiry <= now)
+        babel_expire_hello(nbr);
+    }
+  }
+}
+
+
+/*
+ *	Best route selection
+ */
+
+/*
+ * From the RFC (section 3.5.1):
+ *
+ * a route advertisement carrying the quintuple (prefix, plen, router-id, seqno,
+ * metric) is feasible if one of the following conditions holds:
+ *
+ * - metric is infinite; or
+ *
+ * - no entry exists in the source table indexed by (id, prefix, plen); or
+ *
+ * - an entry (prefix, plen, router-id, seqno', metric') exists in the source
+ *   table, and either
+ *   - seqno' < seqno or
+ *   - seqno = seqno' and metric < metric'.
+ */
+static inline int
+babel_is_feasible(struct babel_source *s, u16 seqno, u16 metric)
+{
+  return !s ||
+    (metric == BABEL_INFINITY) ||
+    (seqno > s->seqno) ||
+    ((seqno == s->seqno) && (metric < s->metric));
+}
+
+static u16
+babel_compute_rxcost(struct babel_neighbor *n)
+{
+  struct babel_iface *ifa = n->ifa;
+  u8 cnt, missed;
+  u16 map=n->hello_map;
+
+  if (!map) return BABEL_INFINITY;
+  cnt = u32_popcount(map); // number of bits set
+  missed = n->hello_cnt-cnt;
+
+  if (ifa->cf->type == BABEL_IFACE_TYPE_WIRELESS)
+  {
+    /* ETX - Appendix 2.2 in the RFC.
+
+       beta = prob. of successful transmission.
+       rxcost = BABEL_RXCOST_WIRELESS/beta
+
+       Since: beta = 1-missed/n->hello_cnt = cnt/n->hello_cnt
+       Then: rxcost = BABEL_RXCOST_WIRELESS * n->hello_cnt / cnt
+   */
+    if (!cnt) return BABEL_INFINITY;
+    return BABEL_RXCOST_WIRELESS * n->hello_cnt / cnt;
+  }
+  else
+  {
+    /* k-out-of-j selection - Appendix 2.1 in the RFC. */
+    DBG("Babel: Missed %d hellos from %I\n", missed, n->addr);
+    /* Link is bad if more than half the expected hellos were lost */
+    return (missed > n->hello_cnt/2) ? BABEL_INFINITY : ifa->cf->rxcost;
+  }
+}
+
+
+static u16
+babel_compute_cost(struct babel_neighbor *n)
+{
+  struct babel_iface *ifa = n->ifa;
+  u16 rxcost = babel_compute_rxcost(n);
+  if (rxcost == BABEL_INFINITY) return rxcost;
+  else if (ifa->cf->type == BABEL_IFACE_TYPE_WIRELESS)
+  {
+    /* ETX - Appendix 2.2 in the RFC */
+    return (MAX(n->txcost, BABEL_RXCOST_WIRELESS) * rxcost)/BABEL_RXCOST_WIRELESS;
+  }
+  else
+  {
+    /* k-out-of-j selection - Appendix 2.1 in the RFC. */
+    return n->txcost;
+  }
+}
+
+/* Simple additive metric - Appendix 3.1 in the RFC */
+static u16
+babel_compute_metric(struct babel_neighbor *n, uint metric)
+{
+  metric += babel_compute_cost(n);
+  return MIN(metric, BABEL_INFINITY);
+}
+
+
+/**
+ * babel_announce_rte - announce selected route to the core
+ * @p: Babel protocol instance
+ * @e: Babel route entry to announce
+ *
+ * This function announces a Babel entry to the core if it has a selected
+ * incoming path, and retracts it otherwise. If the selected entry has infinite
+ * metric, the route is announced as unreachable.
+ */
+static void
+babel_announce_rte(struct babel_proto *p, struct babel_entry *e)
+{
+  struct babel_route *r = e->selected_in;
+
+  if (r)
+  {
+    net *n = net_get(p->p.table, e->n.prefix, e->n.pxlen);
+    rta A = {
+      .src = p->p.main_source,
+      .source = RTS_BABEL,
+      .scope = SCOPE_UNIVERSE,
+      .cast = RTC_UNICAST,
+      .dest = r->metric == BABEL_INFINITY ? RTD_UNREACHABLE : RTD_ROUTER,
+      .flags = 0,
+      .from = r->neigh->addr,
+      .iface = r->neigh->ifa->iface,
+    };
+
+    if (r->metric < BABEL_INFINITY)
+      A.gw = r->next_hop;
+
+    rta *a = rta_lookup(&A);
+    rte *rte = rte_get_temp(a);
+    rte->u.babel.metric = r->metric;
+    rte->u.babel.router_id = r->router_id;
+    rte->net = n;
+    rte->pflags = 0;
+
+    rte_update(&p->p, n, rte);
+  }
+  else
+  {
+    /* Retraction */
+    net *n = net_find(p->p.table, e->n.prefix, e->n.pxlen);
+    rte_update(&p->p, n, NULL);
+  }
+}
+
+/**
+ * babel_select_route - select best route for given route entry
+ * @e: Babel entry to select the best route for
+ *
+ * Select the best feasible route for a given prefix among the routes received
+ * from peers, and propagate it to the nest. This just selects the feasible
+ * route with the lowest metric.
+ *
+ * If no feasible route is available for a prefix that previously had a route
+ * selected, a seqno request is sent to try to get a valid route. In the
+ * meantime, the route is marked as infeasible in the nest (to blackhole packets
+ * going to it, as per the RFC).
+ *
+ * If no feasible route is available, and no previous route is selected, the
+ * route is removed from the nest entirely.
+ */
+static void
+babel_select_route(struct babel_entry *e)
+{
+  struct babel_proto *p = e->proto;
+  struct babel_route *r, *cur = e->selected_in;
+
+  /* try to find the best feasible route */
+  WALK_LIST(r, e->routes)
+    if (!OUR_ROUTE(r) && /* prevent propagating our own routes back to core */
+	(!cur || r->metric < cur->metric) &&
+        babel_is_feasible(babel_find_source(e, r->router_id), r->seqno, r->advert_metric))
+      cur = r;
+
+  if (cur && !OUR_ROUTE(cur) &&
+      ((!e->selected_in && cur->metric < BABEL_INFINITY) ||
+       (e->selected_in && cur->metric < e->selected_in->metric)))
+  {
+    TRACE(D_EVENTS, "Picked new route for prefix %I/%d: router id %lR metric %d",
+	  e->n.prefix, e->n.pxlen, cur->router_id, cur->metric);
+
+    e->selected_in = cur;
+    e->updated = now;
+    babel_announce_rte(p, e);
+  }
+  else if (!cur || cur->metric == BABEL_INFINITY)
+  {
+    /* Couldn't find a feasible route. If we have a selected route, that means
+       it just became infeasible; so set it's metric to infinite and install it
+       (as unreachable), then send a seqno request.
+
+       babel_build_rte() will set the unreachable flag if the metric is BABEL_INFINITY.*/
+    if (e->selected_in)
+    {
+      TRACE(D_EVENTS, "Lost feasible route for prefix %I/%d",
+	    e->n.prefix, e->n.pxlen);
+
+      e->selected_in->metric = BABEL_INFINITY;
+      e->updated = now;
+
+      babel_send_seqno_request(e);
+      babel_announce_rte(p, e);
+    }
+    else
+    {
+      /* No route currently selected, and no new one selected; this means we
+	 don't have a route to this destination anymore (and were probably
+	 called from an expiry timer). Remove the route from the nest. */
+      TRACE(D_EVENTS, "Flushing route for prefix %I/%d", e->n.prefix, e->n.pxlen);
+
+      e->selected_in = NULL;
+      e->updated = now;
+      babel_announce_rte(p, e);
+    }
+  }
+}
+
+/*
+ *	Functions to send replies
+ */
+
+static void
+babel_send_ack(struct babel_iface *ifa, ip_addr dest, u16 nonce)
+{
+  struct babel_proto *p = ifa->proto;
+  union babel_msg msg = {};
+
+  TRACE(D_PACKETS, "Sending ACK to %I with nonce %d", dest, nonce);
+
+  msg.type = BABEL_TLV_ACK;
+  msg.ack.nonce = nonce;
+
+  babel_send_unicast(&msg, ifa, dest);
+}
+
+static void
+babel_build_ihu(union babel_msg *msg, struct babel_iface *ifa, struct babel_neighbor *n)
+{
+  struct babel_proto *p = ifa->proto;
+
+  msg->type = BABEL_TLV_IHU;
+  msg->ihu.addr = n->addr;
+  msg->ihu.rxcost = babel_compute_rxcost(n);
+  msg->ihu.interval = ifa->cf->ihu_interval;
+
+  TRACE(D_PACKETS, "Sending IHU for %I with rxcost %d interval %d",
+        msg->ihu.addr, msg->ihu.rxcost, msg->ihu.interval);
+}
+
+static void
+babel_send_ihu(struct babel_iface *ifa, struct babel_neighbor *n)
+{
+  union babel_msg msg = {};
+  babel_build_ihu(&msg, ifa, n);
+  babel_send_unicast(&msg, ifa, n->addr);
+}
+
+static void
+babel_send_ihus(struct babel_iface *ifa)
+{
+  struct babel_neighbor *n;
+  WALK_LIST(n, ifa->neigh_list)
+  {
+    union babel_msg msg = {};
+    babel_build_ihu(&msg, ifa, n);
+    babel_enqueue(&msg, ifa);
+  }
+}
+
+static void
+babel_send_hello(struct babel_iface *ifa, u8 send_ihu)
+{
+  struct babel_proto *p = ifa->proto;
+  union babel_msg msg = {};
+
+  msg.type = BABEL_TLV_HELLO;
+  msg.hello.seqno = ifa->hello_seqno++;
+  msg.hello.interval = ifa->cf->hello_interval;
+
+  TRACE(D_PACKETS, "Sending hello on %s with seqno %d interval %d",
+	ifa->ifname, msg.hello.seqno, msg.hello.interval);
+
+  babel_enqueue(&msg, ifa);
+
+  if (send_ihu)
+    babel_send_ihus(ifa);
+}
+
+static void
+babel_send_route_request(struct babel_entry *e, struct babel_neighbor *n)
+{
+  struct babel_proto *p = e->proto;
+  struct babel_iface *ifa = n->ifa;
+  union babel_msg msg = {};
+
+  TRACE(D_PACKETS, "Sending route request for %I/%d to %I",
+        e->n.prefix, e->n.pxlen, n->addr);
+
+  msg.type = BABEL_TLV_ROUTE_REQUEST;
+  msg.route_request.prefix = e->n.prefix;
+  msg.route_request.plen = e->n.pxlen;
+
+  babel_send_unicast(&msg, ifa, n->addr);
+}
+
+static void
+babel_send_wildcard_request(struct babel_iface *ifa)
+{
+  struct babel_proto *p = ifa->proto;
+  union babel_msg msg = {};
+
+  TRACE(D_PACKETS, "Sending wildcard route request on %s",
+	ifa->ifname);
+
+  msg.type = BABEL_TLV_ROUTE_REQUEST;
+  msg.route_request.full = 1;
+
+  babel_enqueue(&msg, ifa);
+}
+
+static void
+babel_send_seqno_request(struct babel_entry *e)
+{
+  struct babel_proto *p = e->proto;
+  struct babel_route *r = e->selected_in;
+  struct babel_iface *ifa = NULL;
+  struct babel_source *s = NULL;
+  union babel_msg msg = {};
+
+  s = babel_find_source(e, r->router_id);
+  if (!s || !babel_cache_seqno_request(p, e->n.prefix, e->n.pxlen, r->router_id, s->seqno + 1))
+    return;
+
+  TRACE(D_PACKETS, "Sending seqno request for %I/%d router-id %lR seqno %d",
+	e->n.prefix, e->n.pxlen, r->router_id, s->seqno + 1);
+
+  msg.type = BABEL_TLV_SEQNO_REQUEST;
+  msg.seqno_request.plen = e->n.pxlen;
+  msg.seqno_request.seqno = s->seqno + 1;
+  msg.seqno_request.hop_count = BABEL_INITIAL_HOP_COUNT;
+  msg.seqno_request.router_id = r->router_id;
+  msg.seqno_request.prefix = e->n.prefix;
+
+  WALK_LIST(ifa, p->interfaces)
+    babel_enqueue(&msg, ifa);
+}
+
+static void
+babel_unicast_seqno_request(struct babel_route *r)
+{
+  struct babel_entry *e = r->e;
+  struct babel_proto *p = e->proto;
+  struct babel_iface *ifa = r->neigh->ifa;
+  struct babel_source *s = NULL;
+  union babel_msg msg = {};
+
+  s = babel_find_source(e, r->router_id);
+  if (!s || !babel_cache_seqno_request(p, e->n.prefix, e->n.pxlen, r->router_id, s->seqno + 1))
+    return;
+
+  TRACE(D_PACKETS, "Sending seqno request for %I/%d router-id %lR seqno %d",
+	e->n.prefix, e->n.pxlen, r->router_id, s->seqno + 1);
+
+  msg.type = BABEL_TLV_SEQNO_REQUEST;
+  msg.seqno_request.plen = e->n.pxlen;
+  msg.seqno_request.seqno = s->seqno + 1;
+  msg.seqno_request.hop_count = BABEL_INITIAL_HOP_COUNT;
+  msg.seqno_request.router_id = r->router_id;
+  msg.seqno_request.prefix = e->n.prefix;
+
+  babel_send_unicast(&msg, ifa, r->neigh->addr);
+}
+
+/**
+ * babel_send_update - send route table updates
+ * @ifa: Interface to transmit on
+ * @changed: Only send entries changed since this time
+ *
+ * This function produces update TLVs for all entries changed since the time
+ * indicated by the &changed parameter and queues them for transmission on the
+ * selected interface. During the process, the feasibility distance for each
+ * transmitted entry is updated.
+ */
+static void
+babel_send_update(struct babel_iface *ifa, bird_clock_t changed)
+{
+  struct babel_proto *p = ifa->proto;
+
+  FIB_WALK(&p->rtable, n)
+  {
+    struct babel_entry *e = (void *) n;
+    struct babel_route *r = e->selected_out;
+
+    if (!r)
+      continue;
+
+    /* Our own seqno might have changed, in which case we update the routes we
+       originate. */
+    if ((r->router_id == p->router_id) && (r->seqno < p->update_seqno))
+    {
+      r->seqno = p->update_seqno;
+      e->updated = now;
+    }
+
+    /* Skip routes that weren't updated since 'changed' time */
+    if (e->updated < changed)
+      continue;
+
+    TRACE(D_PACKETS, "Sending update for %I/%d router-id %lR seqno %d metric %d",
+	  e->n.prefix, e->n.pxlen, r->router_id, r->seqno, r->metric);
+
+    union babel_msg msg = {};
+    msg.type = BABEL_TLV_UPDATE;
+    msg.update.plen = e->n.pxlen;
+    msg.update.interval = ifa->cf->update_interval;
+    msg.update.seqno = r->seqno;
+    msg.update.metric = r->metric;
+    msg.update.prefix = e->n.prefix;
+    msg.update.router_id = r->router_id;
+
+    /* Update feasibility distance */
+    struct babel_source *s = babel_get_source(e, r->router_id);
+    s->expires = now + BABEL_GARBAGE_INTERVAL;
+    if ((msg.update.seqno > s->seqno) ||
+	((msg.update.seqno == s->seqno) && (msg.update.metric < s->metric)))
+    {
+      s->seqno = msg.update.seqno;
+      s->metric = msg.update.metric;
+    }
+    babel_enqueue(&msg, ifa);
+  }
+  FIB_WALK_END;
+}
+
+static void
+babel_trigger_iface_update(struct babel_iface *ifa)
+{
+  struct babel_proto *p = ifa->proto;
+
+  /* Interface not active or already scheduled */
+  if (!ifa->up || ifa->want_triggered)
+    return;
+
+  TRACE(D_EVENTS, "Scheduling triggered updates for %s seqno %d",
+	ifa->iface->name, p->update_seqno);
+
+  ifa->want_triggered = now;
+  babel_iface_kick_timer(ifa);
+}
+
+/* Sends and update on all interfaces. */
+static void
+babel_trigger_update(struct babel_proto *p)
+{
+  if (p->triggered)
+    return;
+
+  struct babel_iface *ifa;
+  WALK_LIST(ifa, p->interfaces)
+    babel_trigger_iface_update(ifa);
+
+  p->triggered = 1;
+}
+
+/* A retraction is an update with an infinite metric */
+static void
+babel_send_retraction(struct babel_iface *ifa, ip_addr prefix, int plen)
+{
+  struct babel_proto *p = ifa->proto;
+  union babel_msg msg = {};
+
+  TRACE(D_PACKETS, "Sending retraction for %I/%d router-id %lR seqno %d",
+	prefix, plen, p->router_id, p->update_seqno);
+
+  msg.type = BABEL_TLV_UPDATE;
+  msg.update.plen = plen;
+  msg.update.interval = ifa->cf->update_interval;
+  msg.update.seqno = p->update_seqno;
+  msg.update.metric = BABEL_INFINITY;
+  msg.update.prefix = prefix;
+  msg.update.router_id = p->router_id;
+
+  babel_enqueue(&msg, ifa);
+}
+
+
+/*
+ *	TLV handler helpers
+ */
+
+/* Update hello history according to Appendix A1 of the RFC */
+static void
+babel_update_hello_history(struct babel_neighbor *n, u16 seqno, u16 interval)
+{
+  /*
+   * Compute the difference between expected and received seqno (modulo 2^16).
+   * If the expected and received seqnos are within 16 of each other, the modular
+   * difference is going to be less than 16 for one of the directions. Otherwise,
+   * the values differ too much, so just reset the state.
+   */
+
+  u16 delta = ((uint) seqno - (uint) n->next_hello_seqno);
+
+  if (delta == 0)
+  {
+    /* Do nothing */
+  }
+  else if (delta <= 16)
+  {
+    /* Sending node decreased interval; fast-forward */
+    n->hello_map <<= delta;
+    n->hello_cnt = MIN(n->hello_cnt + delta, 16);
+  }
+  else if (delta >= 0xfff0)
+  {
+    u8 diff = (0xffff - delta);
+    /* Sending node increased interval; undo history */
+    n->hello_map >>= diff;
+    n->hello_cnt = (diff < n->hello_cnt) ? n->hello_cnt - diff : 0;
+  }
+  else
+  {
+    /* Note state reset - flush entries */
+    n->hello_map = n->hello_cnt = 0;
+  }
+
+  /* Current entry */
+  n->hello_map = (n->hello_map << 1) | 1;
+  n->next_hello_seqno = seqno+1;
+  if (n->hello_cnt < 16) n->hello_cnt++;
+  n->hello_expiry = now + BABEL_HELLO_EXPIRY_FACTOR(interval);
+}
+
+static void
+babel_expire_seqno_requests(struct babel_proto *p)
+{
+  struct babel_seqno_request *n, *nx;
+  WALK_LIST_DELSAFE(n, nx, p->seqno_cache)
+  {
+    if ((n->updated + BABEL_SEQNO_REQUEST_EXPIRY) <= now)
+    {
+      rem_node(NODE n);
+      sl_free(p->seqno_slab, n);
+    }
+  }
+}
+
+/*
+ * Checks the seqno request cache for a matching request and returns failure if
+ * found. Otherwise, a new entry is stored in the cache.
+ */
+static int
+babel_cache_seqno_request(struct babel_proto *p, ip_addr prefix, u8 plen,
+                          u64 router_id, u16 seqno)
+{
+  struct babel_seqno_request *r;
+
+  WALK_LIST(r, p->seqno_cache)
+  {
+    if (ipa_equal(r->prefix, prefix) && (r->plen == plen) &&
+	(r->router_id == router_id) && (r->seqno == seqno))
+      return 0;
+  }
+
+  /* no entries found */
+  r = sl_alloc(p->seqno_slab);
+  r->prefix = prefix;
+  r->plen = plen;
+  r->router_id = router_id;
+  r->seqno = seqno;
+  r->updated = now;
+  add_tail(&p->seqno_cache, NODE r);
+
+  return 1;
+}
+
+static void
+babel_forward_seqno_request(struct babel_entry *e,
+                            struct babel_msg_seqno_request *in,
+                            ip_addr sender)
+{
+  struct babel_proto *p = e->proto;
+  struct babel_route *r;
+
+  TRACE(D_PACKETS, "Forwarding seqno request for %I/%d router-id %lR seqno %d",
+	e->n.prefix, e->n.pxlen, in->router_id, in->seqno);
+
+  WALK_LIST(r, e->routes)
+  {
+    if ((r->router_id == in->router_id) &&
+	!OUR_ROUTE(r) &&
+	!ipa_equal(r->neigh->addr, sender))
+    {
+      if (!babel_cache_seqno_request(p, e->n.prefix, e->n.pxlen, in->router_id, in->seqno))
+	return;
+
+      union babel_msg msg = {};
+      msg.type = BABEL_TLV_SEQNO_REQUEST;
+      msg.seqno_request.plen = in->plen;
+      msg.seqno_request.seqno = in->seqno;
+      msg.seqno_request.hop_count = in->hop_count-1;
+      msg.seqno_request.router_id = in->router_id;
+      msg.seqno_request.prefix = e->n.prefix;
+
+      babel_send_unicast(&msg, r->neigh->ifa, r->neigh->addr);
+      return;
+    }
+  }
+}
+
+
+/*
+ *	TLV handlers
+ */
+
+void
+babel_handle_ack_req(union babel_msg *m, struct babel_iface *ifa)
+{
+  struct babel_proto *p = ifa->proto;
+  struct babel_msg_ack_req *msg = &m->ack_req;
+
+  TRACE(D_PACKETS, "Handling ACK request nonce %d interval %d",
+	msg->nonce, msg->interval);
+
+  babel_send_ack(ifa, msg->sender, msg->nonce);
+}
+
+void
+babel_handle_hello(union babel_msg *m, struct babel_iface *ifa)
+{
+  struct babel_proto *p = ifa->proto;
+  struct babel_msg_hello *msg = &m->hello;
+
+  TRACE(D_PACKETS, "Handling hello seqno %d interval %d",
+	msg->seqno, msg->interval);
+
+  struct babel_neighbor *n = babel_get_neighbor(ifa, msg->sender);
+  babel_update_hello_history(n, msg->seqno, msg->interval);
+  if (ifa->cf->type == BABEL_IFACE_TYPE_WIRELESS)
+    babel_send_ihu(ifa, n);
+}
+
+void
+babel_handle_ihu(union babel_msg *m, struct babel_iface *ifa)
+{
+  struct babel_proto *p = ifa->proto;
+  struct babel_msg_ihu *msg = &m->ihu;
+
+  /* Ignore IHUs that are not about us */
+  if ((msg->ae != BABEL_AE_WILDCARD) && !ipa_equal(msg->addr, ifa->addr))
+    return;
+
+  TRACE(D_PACKETS, "Handling IHU rxcost %d interval %d",
+	msg->rxcost, msg->interval);
+
+  struct babel_neighbor *n = babel_get_neighbor(ifa, msg->sender);
+  n->txcost = msg->rxcost;
+  n->ihu_expiry = now + BABEL_IHU_EXPIRY_FACTOR(msg->interval);
+}
+
+/**
+ * babel_handle_update - handle incoming route updates
+ * @m: Incoming update TLV
+ * @ifa: Interface the update was received on
+ *
+ * This function is called as a handler for update TLVs and handles the updating
+ * and maintenance of route entries in Babel's internal routing cache. The
+ * handling follows the actions described in the Babel RFC, and at the end of
+ * each update handling, babel_select_route() is called on the affected entry to
+ * optionally update the selected routes and propagate them to the core.
+ */
+void
+babel_handle_update(union babel_msg *m, struct babel_iface *ifa)
+{
+  struct babel_proto *p = ifa->proto;
+  struct babel_msg_update *msg = &m->update;
+
+  struct babel_neighbor *n;
+  struct babel_entry *e;
+  struct babel_source *s;
+  struct babel_route *r;
+  int feasible;
+
+  TRACE(D_PACKETS, "Handling update for %I/%d with seqno %d metric %d",
+	msg->prefix, msg->plen, msg->seqno, msg->metric);
+
+  n = babel_find_neighbor(ifa, msg->sender);
+  if (!n)
+  {
+    DBG("Babel: Haven't heard from neighbor %I; ignoring update.\n", msg->sender);
+    return;
+  }
+
+  if (msg->router_id == p->router_id)
+  {
+    DBG("Babel: Ignoring update for our own router ID.\n");
+    return;
+  }
+
+  /*
+   * RFC section 3.5.4:
+   *
+   * When a Babel node receives an update (id, prefix, seqno, metric) from a
+   * neighbour neigh with a link cost value equal to cost, it checks whether it
+   * already has a routing table entry indexed by (neigh, id, prefix).
+   *
+   * If no such entry exists:
+   *
+   * o if the update is unfeasible, it is ignored;
+   *
+   * o if the metric is infinite (the update is a retraction), the update is
+   *   ignored;
+   *
+   * o otherwise, a new route table entry is created, indexed by (neigh, id,
+   *   prefix), with seqno equal to seqno and an advertised metric equal to the
+   *   metric carried by the update.
+   *
+   * If such an entry exists:
+   *
+   * o if the entry is currently installed and the update is unfeasible, then
+   *   the behaviour depends on whether the router-ids of the two entries match.
+   *   If the router-ids are different, the update is treated as though it were
+   *   a retraction (i.e., as though the metric were FFFF hexadecimal). If the
+   *   router-ids are equal, the update is ignored;
+   *
+   * o otherwise (i.e., if either the update is feasible or the entry is not
+   *   currently installed), then the entry's sequence number, advertised
+   *   metric, metric, and router-id are updated and, unless the advertised
+   *   metric is infinite, the route's expiry timer is reset to a small multiple
+   *   of the Interval value included in the update.
+   */
+
+  if (msg->metric == BABEL_INFINITY)
+    e = babel_find_entry(p, msg->prefix, msg->plen);
+  else
+    e = babel_get_entry(p, msg->prefix, msg->plen);
+
+  if (!e)
+    return;
+
+  s = babel_find_source(e, msg->router_id); /* for feasibility */
+  r = babel_find_route(e, n); /* the route entry indexed by neighbour */
+  feasible = babel_is_feasible(s, msg->seqno, msg->metric);
+
+  if (!r)
+  {
+    if (!feasible || (msg->metric == BABEL_INFINITY))
+      return;
+
+    r = babel_get_route(e, n);
+    r->advert_metric = msg->metric;
+    r->router_id = msg->router_id;
+    r->metric = babel_compute_metric(n, msg->metric);
+    r->next_hop = msg->next_hop;
+    r->seqno = msg->seqno;
+  }
+  else if (r == r->e->selected_in && !feasible)
+  {
+    /* Route is installed and update is infeasible - we may lose the route, so
+       send a unicast seqno request (section 3.8.2.2 second paragraph). */
+    babel_unicast_seqno_request(r);
+
+    if (msg->router_id == r->router_id) return;
+    r->metric = BABEL_INFINITY; /* retraction */
+  }
+  else
+  {
+    /* Last paragraph above - update the entry */
+    r->advert_metric = msg->metric;
+    r->metric = babel_compute_metric(n, msg->metric);
+    r->router_id = msg->router_id;
+    r->next_hop = msg->next_hop;
+    r->seqno = msg->seqno;
+
+    if (msg->metric != BABEL_INFINITY)
+    {
+      r->expiry_interval = BABEL_ROUTE_EXPIRY_FACTOR(msg->interval);
+      r->expires = now + r->expiry_interval;
+      if (r->expiry_interval > BABEL_ROUTE_REFRESH_INTERVAL)
+        r->refresh_time = now + r->expiry_interval - BABEL_ROUTE_REFRESH_INTERVAL;
+    }
+
+    /* If the route is not feasible at this point, it means it is from another
+       neighbour than the one currently selected; so send a unicast seqno
+       request to try to get a better route (section 3.8.2.2 last paragraph). */
+    if (!feasible)
+      babel_unicast_seqno_request(r);
+  }
+
+  babel_select_route(e);
+}
+
+void
+babel_handle_route_request(union babel_msg *m, struct babel_iface *ifa)
+{
+  struct babel_proto *p = ifa->proto;
+  struct babel_msg_route_request *msg = &m->route_request;
+
+  /* RFC 6126 3.8.1.1 */
+
+  /* Wildcard request - full update on the interface */
+  if (msg->full)
+  {
+    TRACE(D_PACKETS, "Handling wildcard route request");
+    ifa->want_triggered = 1;
+    return;
+  }
+
+  TRACE(D_PACKETS, "Handling route request for %I/%d", msg->prefix, msg->plen);
+
+  /* Non-wildcard request - see if we have an entry for the route.
+     If not, send a retraction, otherwise send an update. */
+  struct babel_entry *e = babel_find_entry(p, msg->prefix, msg->plen);
+  if (!e)
+  {
+    babel_send_retraction(ifa, msg->prefix, msg->plen);
+  }
+  else
+  {
+    babel_trigger_iface_update(ifa);
+    e->updated = now;
+  }
+}
+
+
+void
+babel_handle_seqno_request(union babel_msg *m, struct babel_iface *ifa)
+{
+  struct babel_proto *p = ifa->proto;
+  struct babel_msg_seqno_request *msg = &m->seqno_request;
+
+  /* RFC 6126 3.8.1.2 */
+
+  TRACE(D_PACKETS, "Handling seqno request for %I/%d router-id %lR seqno %d hop count %d",
+	msg->prefix, msg->plen, msg->router_id, msg->seqno, msg->hop_count);
+
+  /* Ignore if we have no such entry or entry has infinite metric */
+  struct babel_entry *e = babel_find_entry(p, msg->prefix, msg->plen);
+  if (!e || !e->selected_out || (e->selected_out->metric == BABEL_INFINITY))
+    return;
+
+  /* Trigger update on incoming interface if we have a selected route with
+     different router id or seqno no smaller than requested */
+  struct babel_route *r = e->selected_out;
+  if ((r->router_id != msg->router_id) || ge_mod64k(r->seqno, msg->seqno))
+  {
+    babel_trigger_iface_update(ifa);
+    e->updated = now;
+    return;
+  }
+
+  /* Seqno is larger; check if we own the router id */
+  if (msg->router_id == p->router_id)
+  {
+    /* Ours; update seqno and trigger global update */
+    p->update_seqno++;
+    babel_trigger_update(p);
+  }
+  else
+  {
+    /* Not ours; forward if TTL allows it */
+    if (msg->hop_count > 1)
+      babel_forward_seqno_request(e, msg, msg->sender);
+  }
+}
+
+
+/*
+ *	Babel interfaces
+ */
+
+/**
+ * babel_iface_timer - Babel interface timer handler
+ * @t: Timer
+ *
+ * This function is called by the per-interface timer and triggers sending of
+ * periodic Hello's and both triggered and periodic updates. Periodic Hello's
+ * and updates are simply handled by setting the next_{hello,regular} variables
+ * on the interface, and triggering an update (and resetting the variable)
+ * whenever 'now' exceeds that value.
+ *
+ * For triggered updates, babel_trigger_iface_update() will set the
+ * want_triggered field on the interface to a timestamp value. If this is set
+ * (and the next_triggered time has passed; this is a rate limiting mechanism),
+ * babel_send_update() will be called with this timestamp as the second
+ * parameter. This causes updates to be send consisting of only the routes that
+ * have changed since the time saved in want_triggered.
+ *
+ * Mostly when an update is triggered, the route being modified will be set to
+ * the value of 'now' at the time of the trigger; the >= comparison for
+ * selecting which routes to send in the update will make sure this is included.
+ */
+static void
+babel_iface_timer(timer *t)
+{
+  struct babel_iface *ifa = t->data;
+  struct babel_proto *p = ifa->proto;
+  bird_clock_t hello_period = ifa->cf->hello_interval;
+  bird_clock_t update_period = ifa->cf->update_interval;
+
+  if (now >= ifa->next_hello)
+  {
+    babel_send_hello(ifa, (ifa->cf->type == BABEL_IFACE_TYPE_WIRELESS ||
+                           ifa->hello_seqno % BABEL_IHU_INTERVAL_FACTOR == 0));
+    ifa->next_hello +=  hello_period * (1 + (now - ifa->next_hello) / hello_period);
+  }
+
+  if (now >= ifa->next_regular)
+  {
+    TRACE(D_EVENTS, "Sending regular updates on %s", ifa->ifname);
+    babel_send_update(ifa, 0);
+    ifa->next_regular += update_period * (1 + (now - ifa->next_regular) / update_period);
+    ifa->want_triggered = 0;
+    p->triggered = 0;
+  }
+  else if (ifa->want_triggered && (now >= ifa->next_triggered))
+  {
+    TRACE(D_EVENTS, "Sending triggered updates on %s", ifa->ifname);
+    babel_send_update(ifa, ifa->want_triggered);
+    ifa->next_triggered = now + MIN(5, update_period / 2 + 1);
+    ifa->want_triggered = 0;
+    p->triggered = 0;
+  }
+
+  bird_clock_t next_event = MIN(ifa->next_hello, ifa->next_regular);
+  tm_start(ifa->timer, ifa->want_triggered ? 1 : (next_event - now));
+}
+
+static inline void
+babel_iface_kick_timer(struct babel_iface *ifa)
+{
+  if (ifa->timer->expires > (now + 1))
+    tm_start(ifa->timer, 1);
+}
+
+static void
+babel_iface_start(struct babel_iface *ifa)
+{
+  struct babel_proto *p = ifa->proto;
+
+  TRACE(D_EVENTS, "Starting interface %s", ifa->ifname);
+
+  ifa->next_hello = now + (random() % ifa->cf->hello_interval) + 1;
+  ifa->next_regular = now + (random() % ifa->cf->update_interval) + 1;
+  ifa->next_triggered = now + MIN(5, ifa->cf->update_interval / 2 + 1);
+  ifa->want_triggered = 0;	/* We send an immediate update (below) */
+  tm_start(ifa->timer, 1);
+  ifa->up = 1;
+
+  babel_send_hello(ifa, 0);
+  babel_send_wildcard_request(ifa);
+  babel_send_update(ifa, 0);	/* Full update */
+}
+
+static void
+babel_iface_stop(struct babel_iface *ifa)
+{
+  struct babel_proto *p = ifa->proto;
+  struct babel_neighbor *nbr;
+  struct babel_route *r;
+  node *n;
+
+  TRACE(D_EVENTS, "Stopping interface %s", ifa->ifname);
+
+  /*
+   * Rather than just flushing the neighbours, we set the metric of their routes
+   * to infinity. This allows us to keep the neighbour hello state for when the
+   * interface comes back up. The routes will also be kept until they expire.
+   */
+  WALK_LIST(nbr, ifa->neigh_list)
+  {
+    WALK_LIST(n, nbr->routes)
+    {
+      r = SKIP_BACK(struct babel_route, neigh_route, n);
+      r->metric = BABEL_INFINITY;
+      r->expires = now + r->expiry_interval;
+      babel_select_route(r->e);
+    }
+  }
+
+  tm_stop(ifa->timer);
+  ifa->up = 0;
+}
+
+static inline int
+babel_iface_link_up(struct babel_iface *ifa)
+{
+  return !ifa->cf->check_link || (ifa->iface->flags & IF_LINK_UP);
+}
+
+static void
+babel_iface_update_state(struct babel_iface *ifa)
+{
+  int up = ifa->sk && babel_iface_link_up(ifa);
+
+  if (up == ifa->up)
+    return;
+
+  if (up)
+    babel_iface_start(ifa);
+  else
+    babel_iface_stop(ifa);
+}
+
+static void
+babel_iface_update_buffers(struct babel_iface *ifa)
+{
+  if (!ifa->sk)
+    return;
+
+  uint mtu = MAX(BABEL_MIN_MTU, ifa->iface->mtu);
+  uint rbsize = ifa->cf->rx_buffer ?: mtu;
+  uint tbsize = ifa->cf->tx_length ?: mtu;
+  rbsize = MAX(rbsize, tbsize);
+
+  sk_set_rbsize(ifa->sk, rbsize);
+  sk_set_tbsize(ifa->sk, tbsize);
+
+  ifa->tx_length = tbsize - BABEL_OVERHEAD;
+}
+
+static struct babel_iface*
+babel_find_iface(struct babel_proto *p, struct iface *what)
+{
+  struct babel_iface *ifa;
+
+  WALK_LIST (ifa, p->interfaces)
+    if (ifa->iface == what)
+      return ifa;
+
+  return NULL;
+}
+
+static void
+babel_iface_locked(struct object_lock *lock)
+{
+  struct babel_iface *ifa = lock->data;
+  struct babel_proto *p = ifa->proto;
+
+  if (!babel_open_socket(ifa))
+  {
+    log(L_ERR "%s: Cannot open socket for %s", p->p.name, ifa->iface->name);
+    return;
+  }
+
+  babel_iface_update_buffers(ifa);
+  babel_iface_update_state(ifa);
+}
+
+static void
+babel_add_iface(struct babel_proto *p, struct iface *new, struct babel_iface_config *ic)
+{
+  struct babel_iface *ifa;
+
+  TRACE(D_EVENTS, "Adding interface %s", new->name);
+
+  pool *pool = rp_new(p->p.pool, new->name);
+
+  ifa = mb_allocz(pool, sizeof(struct babel_iface));
+  ifa->proto = p;
+  ifa->iface = new;
+  ifa->cf = ic;
+  ifa->pool = pool;
+  ifa->ifname = new->name;
+
+  add_tail(&p->interfaces, NODE ifa);
+
+  struct ifa *addr;
+  WALK_LIST(addr, new->addrs)
+    if (ipa_is_link_local(addr->ip))
+      ifa->addr = addr->ip;
+
+  if (ipa_zero(ifa->addr))
+    log(L_WARN "%s: Cannot find link-local addr on %s", p->p.name, new->name);
+
+  init_list(&ifa->neigh_list);
+  ifa->hello_seqno = 1;
+
+  ifa->timer = tm_new_set(ifa->pool, babel_iface_timer, ifa, 0, 0);
+
+  init_list(&ifa->msg_queue);
+  ifa->send_event = ev_new(ifa->pool);
+  ifa->send_event->hook = babel_send_queue;
+  ifa->send_event->data = ifa;
+
+  struct object_lock *lock = olock_new(ifa->pool);
+  lock->type = OBJLOCK_UDP;
+  lock->addr = IP6_BABEL_ROUTERS;
+  lock->port = ifa->cf->port;
+  lock->iface = ifa->iface;
+  lock->hook = babel_iface_locked;
+  lock->data = ifa;
+
+  olock_acquire(lock);
+}
+
+static void
+babel_remove_iface(struct babel_proto *p, struct babel_iface *ifa)
+{
+  TRACE(D_EVENTS, "Removing interface %s", ifa->iface->name);
+
+  struct babel_neighbor *n;
+  WALK_LIST_FIRST(n, ifa->neigh_list)
+    babel_flush_neighbor(n);
+
+  rem_node(NODE ifa);
+
+  rfree(ifa->pool); /* contains ifa itself, locks, socket, etc */
+}
+
+static void
+babel_if_notify(struct proto *P, unsigned flags, struct iface *iface)
+{
+  struct babel_proto *p = (void *) P;
+  struct babel_config *cf = (void *) P->cf;
+
+  if (iface->flags & IF_IGNORE)
+    return;
+
+  if (flags & IF_CHANGE_UP)
+  {
+    struct babel_iface_config *ic = (void *) iface_patt_find(&cf->iface_list, iface, iface->addr);
+
+    /* we only speak multicast */
+    if (!(iface->flags & IF_MULTICAST))
+      return;
+
+    if (ic)
+      babel_add_iface(p, iface, ic);
+
+    return;
+  }
+
+  struct babel_iface *ifa = babel_find_iface(p, iface);
+
+  if (!ifa)
+    return;
+
+  if (flags & IF_CHANGE_DOWN)
+  {
+    babel_remove_iface(p, ifa);
+    return;
+  }
+
+  if (flags & IF_CHANGE_MTU)
+    babel_iface_update_buffers(ifa);
+
+  if (flags & IF_CHANGE_LINK)
+    babel_iface_update_state(ifa);
+}
+
+static int
+babel_reconfigure_iface(struct babel_proto *p, struct babel_iface *ifa, struct babel_iface_config *new)
+{
+  struct babel_iface_config *old = ifa->cf;
+
+  /* Change of these options would require to reset the iface socket */
+  if ((new->port != old->port) ||
+      (new->tx_tos != old->tx_tos) ||
+      (new->tx_priority != old->tx_priority))
+    return 0;
+
+  TRACE(D_EVENTS, "Reconfiguring interface %s", ifa->iface->name);
+
+  ifa->cf = new;
+
+  if (ifa->next_regular > (now + new->update_interval))
+    ifa->next_regular = now + (random() % new->update_interval) + 1;
+
+  if ((new->tx_length != old->tx_length) || (new->rx_buffer != old->rx_buffer))
+    babel_iface_update_buffers(ifa);
+
+  if (new->check_link != old->check_link)
+    babel_iface_update_state(ifa);
+
+  if (ifa->up)
+    babel_iface_kick_timer(ifa);
+
+  return 1;
+}
+
+static void
+babel_reconfigure_ifaces(struct babel_proto *p, struct babel_config *cf)
+{
+  struct iface *iface;
+
+  WALK_LIST(iface, iface_list)
+  {
+    if (! (iface->flags & IF_UP))
+      continue;
+
+    struct babel_iface *ifa = babel_find_iface(p, iface);
+    struct babel_iface_config *ic = (void *) iface_patt_find(&cf->iface_list, iface, NULL);
+
+    if (ifa && ic)
+    {
+      if (babel_reconfigure_iface(p, ifa, ic))
+	continue;
+
+      /* Hard restart */
+      log(L_INFO "%s: Restarting interface %s", p->p.name, ifa->iface->name);
+      babel_remove_iface(p, ifa);
+      babel_add_iface(p, iface, ic);
+    }
+
+    if (ifa && !ic)
+      babel_remove_iface(p, ifa);
+
+    if (!ifa && ic)
+      babel_add_iface(p, iface, ic);
+  }
+}
+
+
+/*
+ *	Debugging and info output functions
+ */
+
+static void
+babel_dump_source(struct babel_source *s)
+{
+  debug("Source router_id %lR seqno %d metric %d expires %d\n",
+	s->router_id, s->seqno, s->metric, s->expires ? s->expires-now : 0);
+}
+
+static void
+babel_dump_route(struct babel_route *r)
+{
+  debug("Route neigh %I if %s seqno %d metric %d/%d router_id %lR expires %d\n",
+	r->neigh ? r->neigh->addr : IPA_NONE,
+        r->neigh ? r->neigh->ifa->ifname : "(none)",
+        r->seqno, r->advert_metric, r->metric,
+	r->router_id, r->expires ? r->expires-now : 0);
+}
+
+static void
+babel_dump_entry(struct babel_entry *e)
+{
+  struct babel_source *s;
+  struct babel_route *r;
+
+  debug("Babel: Entry %I/%d:\n", e->n.prefix, e->n.pxlen);
+
+  WALK_LIST(s,e->sources)
+  { debug(" "); babel_dump_source(s); }
+
+  WALK_LIST(r,e->routes)
+  {
+    debug(" ");
+    if (r == e->selected_out) debug("*");
+    if (r == e->selected_in) debug("+");
+    babel_dump_route(r);
+  }
+}
+
+static void
+babel_dump_neighbor(struct babel_neighbor *n)
+{
+  debug("Neighbor %I txcost %d hello_map %x next seqno %d expires %d/%d\n",
+	n->addr, n->txcost, n->hello_map, n->next_hello_seqno,
+        n->hello_expiry ? n->hello_expiry - now : 0,
+        n->ihu_expiry ? n->ihu_expiry - now : 0);
+}
+
+static void
+babel_dump_iface(struct babel_iface *ifa)
+{
+  struct babel_neighbor *n;
+
+  debug("Babel: Interface %s addr %I rxcost %d type %d hello seqno %d intervals %d %d\n",
+	ifa->ifname, ifa->addr, ifa->cf->rxcost, ifa->cf->type, ifa->hello_seqno,
+	ifa->cf->hello_interval, ifa->cf->update_interval);
+
+  WALK_LIST(n, ifa->neigh_list)
+  { debug(" "); babel_dump_neighbor(n); }
+}
+
+static void
+babel_dump(struct proto *P)
+{
+  struct babel_proto *p = (struct babel_proto *) P;
+  struct babel_iface *ifa;
+
+  debug("Babel: router id %lR update seqno %d\n", p->router_id, p->update_seqno);
+
+  WALK_LIST(ifa, p->interfaces)
+    babel_dump_iface(ifa);
+
+  FIB_WALK(&p->rtable, n)
+  {
+    babel_dump_entry((struct babel_entry *) n);
+  }
+  FIB_WALK_END;
+}
+
+static void
+babel_get_route_info(rte *rte, byte *buf, ea_list *attrs)
+{
+  buf += bsprintf(buf, " (%d/%d) [%lR]", rte->pref, rte->u.babel.metric, rte->u.babel.router_id);
+}
+
+static int
+babel_get_attr(eattr *a, byte *buf, int buflen UNUSED)
+{
+  switch (a->id)
+  {
+  case EA_BABEL_METRIC:
+    bsprintf(buf, "metric: %d", a->u.data);
+    return GA_FULL;
+
+  case EA_BABEL_ROUTER_ID:
+  {
+    u64 rid = 0;
+    memcpy(&rid, a->u.ptr->data, sizeof(u64));
+    bsprintf(buf, "router_id: %lR", rid);
+    return GA_FULL;
+  }
+
+  default:
+    return GA_UNKNOWN;
+  }
+}
+
+void
+babel_show_interfaces(struct proto *P, char *iff)
+{
+  struct babel_proto *p = (void *) P;
+  struct babel_iface *ifa = NULL;
+  struct babel_neighbor *nbr = NULL;
+
+  if (p->p.proto_state != PS_UP)
+  {
+    cli_msg(-1023, "%s: is not up", p->p.name);
+    cli_msg(0, "");
+    return;
+  }
+
+  cli_msg(-1023, "%s:", p->p.name);
+  cli_msg(-1023, "%-10s %-6s %7s %6s %6s",
+	  "Interface", "State", "RX cost", "Nbrs", "Timer");
+
+  WALK_LIST(ifa, p->interfaces)
+  {
+    if (iff && !patmatch(iff, ifa->iface->name))
+      continue;
+
+    int nbrs = 0;
+    WALK_LIST(nbr, ifa->neigh_list)
+	nbrs++;
+
+    int timer = MIN(ifa->next_regular, ifa->next_hello) - now;
+    cli_msg(-1023, "%-10s %-6s %7u %6u %6u",
+	    ifa->iface->name, (ifa->up ? "Up" : "Down"), ifa->cf->rxcost, nbrs, MAX(timer, 0));
+  }
+
+  cli_msg(0, "");
+}
+
+void
+babel_show_neighbors(struct proto *P, char *iff)
+{
+  struct babel_proto *p = (void *) P;
+  struct babel_iface *ifa = NULL;
+  struct babel_neighbor *n = NULL;
+  struct babel_route *r = NULL;
+
+  if (p->p.proto_state != PS_UP)
+  {
+    cli_msg(-1024, "%s: is not up", p->p.name);
+    cli_msg(0, "");
+    return;
+  }
+
+  cli_msg(-1024, "%s:", p->p.name);
+  cli_msg(-1024, "%-25s %-10s %6s %6s %10s",
+	  "IP address", "Interface", "Metric", "Routes", "Next hello");
+
+  WALK_LIST(ifa, p->interfaces)
+  {
+    if (iff && !patmatch(iff, ifa->iface->name))
+      continue;
+
+    WALK_LIST(n, ifa->neigh_list)
+    {
+      int rts = 0;
+      WALK_LIST(r, n->routes)
+        rts++;
+
+      int timer = n->hello_expiry - now;
+      cli_msg(-1024, "%-25I %-10s %6u %6u %10u",
+	      n->addr, ifa->iface->name, n->txcost, rts, MAX(timer, 0));
+    }
+  }
+
+  cli_msg(0, "");
+}
+
+void
+babel_show_entries(struct proto *P)
+{
+  struct babel_proto *p = (void *) P;
+  struct babel_entry *e = NULL;
+  struct babel_source *s = NULL;
+  struct babel_route *r = NULL;
+
+  char ipbuf[STD_ADDRESS_P_LENGTH+5];
+  char ridbuf[ROUTER_ID_64_LENGTH+1];
+
+  if (p->p.proto_state != PS_UP)
+  {
+    cli_msg(-1025, "%s: is not up", p->p.name);
+    cli_msg(0, "");
+    return;
+  }
+
+  cli_msg(-1025, "%s:", p->p.name);
+  cli_msg(-1025, "%-29s %-23s %6s %5s %7s %7s",
+	  "Prefix", "Router ID", "Metric", "Seqno", "Expires", "Sources");
+
+  FIB_WALK(&p->rtable, n)
+  {
+    e = (struct babel_entry *) n;
+    r = e->selected_in ? e->selected_in : e->selected_out;
+
+    int srcs = 0;
+    WALK_LIST(s, e->sources)
+      srcs++;
+
+    bsprintf(ipbuf, "%I/%u", e->n.prefix, e->n.pxlen);
+
+    if (r)
+    {
+      if (r->router_id == p->router_id)
+        bsprintf(ridbuf, "%s", "<self>");
+      else
+        bsprintf(ridbuf, "%lR", r->router_id);
+
+      int time = r->expires ? r->expires - now : 0;
+      cli_msg(-1025, "%-29s %-23s %6u %5u %7u %7u",
+	      ipbuf, ridbuf, r->metric, r->seqno, MAX(time, 0), srcs);
+    }
+    else
+    {
+      cli_msg(-1025, "%-29s %-44s %7u", ipbuf, "<pending>", srcs);
+    }
+  }
+  FIB_WALK_END;
+
+  cli_msg(0, "");
+}
+
+
+/*
+ *	Babel protocol glue
+ */
+
+/**
+ * babel_timer - global timer hook
+ * @t: Timer
+ *
+ * This function is called by the global protocol instance timer and handles
+ * expiration of routes and neighbours as well as pruning of the seqno request
+ * cache.
+ */
+static void
+babel_timer(timer *t)
+{
+  struct babel_proto *p = t->data;
+
+  babel_expire_routes(p);
+  babel_expire_seqno_requests(p);
+  babel_expire_neighbors(p);
+}
+
+static inline void
+babel_kick_timer(struct babel_proto *p)
+{
+  if (p->timer->expires > (now + 1))
+    tm_start(p->timer, 1);
+}
+
+
+static struct ea_list *
+babel_prepare_attrs(struct linpool *pool, ea_list *next, uint metric, u64 router_id)
+{
+  struct ea_list *l = lp_alloc(pool, sizeof(struct ea_list) + 2*sizeof(eattr));
+  struct adata *rid = lp_alloc(pool, sizeof(struct adata) + sizeof(u64));
+  rid->length = sizeof(u64);
+  memcpy(&rid->data, &router_id, sizeof(u64));
+
+  l->next = next;
+  l->flags = EALF_SORTED;
+  l->count = 2;
+
+  l->attrs[0].id = EA_BABEL_METRIC;
+  l->attrs[0].flags = 0;
+  l->attrs[0].type = EAF_TYPE_INT | EAF_TEMP;
+  l->attrs[0].u.data = metric;
+
+  l->attrs[1].id = EA_BABEL_ROUTER_ID;
+  l->attrs[1].flags = 0;
+  l->attrs[1].type = EAF_TYPE_OPAQUE | EAF_TEMP;
+  l->attrs[1].u.ptr = rid;
+
+  return l;
+}
+
+
+static int
+babel_import_control(struct proto *P, struct rte **rt, struct ea_list **attrs, struct linpool *pool)
+{
+  struct babel_proto *p = (void *) P;
+
+  /* Prepare attributes with initial values */
+  if ((*rt)->attrs->source != RTS_BABEL)
+    *attrs = babel_prepare_attrs(pool, NULL, 0, p->router_id);
+
+  return 0;
+}
+
+static struct ea_list *
+babel_make_tmp_attrs(struct rte *rt, struct linpool *pool)
+{
+  return babel_prepare_attrs(pool, NULL, rt->u.babel.metric, rt->u.babel.router_id);
+}
+
+static void
+babel_store_tmp_attrs(struct rte *rt, struct ea_list *attrs)
+{
+  rt->u.babel.metric = ea_get_int(attrs, EA_BABEL_METRIC, 0);
+}
+
+/*
+ * babel_rt_notify - core tells us about new route (possibly our own),
+ * so store it into our data structures.
+ */
+static void
+babel_rt_notify(struct proto *P, struct rtable *table UNUSED, struct network *net,
+		struct rte *new, struct rte *old, struct ea_list *attrs)
+{
+  struct babel_proto *p = (void *) P;
+  struct babel_entry *e;
+  struct babel_route *r;
+
+  if (new)
+  {
+    /* Update */
+    e = babel_get_entry(p, net->n.prefix, net->n.pxlen);
+
+    if (new->attrs->src->proto != P)
+    {
+      r = babel_get_route(e, NULL);
+      r->seqno = p->update_seqno;
+      r->router_id = p->router_id;
+      r->metric = 0;	/* FIXME: should be selectable */
+    }
+    else
+      r = e->selected_in;
+
+    if (r != e->selected_out)
+    {
+      e->selected_out = r;
+      e->updated = now;
+      babel_trigger_update(p);
+    }
+  }
+  else
+  {
+    /* Withdraw */
+    e = babel_find_entry(p, net->n.prefix, net->n.pxlen);
+    if (!e || !e->selected_out)
+      return;
+
+    if (OUR_ROUTE(e->selected_out))
+    {
+      /*
+       * We originate this route, so set its metric to infinity and set an
+       * expiry time. This causes a retraction to be sent, and later the route
+       * to be flushed once the hold time has passed.
+       */
+      e->selected_out->metric = BABEL_INFINITY;
+      e->selected_out->expires = now + BABEL_HOLD_TIME;
+      e->updated = now;
+      babel_trigger_update(p);
+    }
+    else
+    {
+      /*
+       * This is a route originating from someone else that was lost; presumably
+       * because an export filter was updated to filter it. This means we can't
+       * set the metric to infinity (it would be overridden on subsequent
+       * updates from the peer originating the route), so just clear the
+       * exported route.
+       *
+       * This causes peers to expire the route after a while (like if we just
+       * shut down), but it's the best we can do in these circumstances; and
+       * since export filters presumably aren't updated that often this is
+       * acceptable.
+       */
+      e->selected_out = NULL;
+    }
+  }
+}
+
+static int
+babel_rte_better(struct rte *new, struct rte *old)
+{
+  return new->u.babel.metric < old->u.babel.metric;
+}
+
+static int
+babel_rte_same(struct rte *new, struct rte *old)
+{
+  return ((new->u.babel.router_id == old->u.babel.router_id) &&
+          (new->u.babel.metric == old->u.babel.metric));
+}
+
+
+static struct proto *
+babel_init(struct proto_config *cfg)
+{
+  struct proto *P = proto_new(cfg, sizeof(struct babel_proto));
+
+  P->accept_ra_types = RA_OPTIMAL;
+  P->if_notify = babel_if_notify;
+  P->rt_notify = babel_rt_notify;
+  P->import_control = babel_import_control;
+  P->make_tmp_attrs = babel_make_tmp_attrs;
+  P->store_tmp_attrs = babel_store_tmp_attrs;
+  P->rte_better = babel_rte_better;
+  P->rte_same = babel_rte_same;
+
+  return P;
+}
+
+static int
+babel_start(struct proto *P)
+{
+  struct babel_proto *p = (void *) P;
+  struct babel_config *cf = (void *) P->cf;
+
+  fib_init(&p->rtable, P->pool, sizeof(struct babel_entry), 0, babel_init_entry);
+  init_list(&p->interfaces);
+  p->timer = tm_new_set(P->pool, babel_timer, p, 0, 1);
+  tm_start(p->timer, 2);
+  p->update_seqno = 1;
+  p->router_id = proto_get_router_id(&cf->c);
+
+  p->route_slab = sl_new(P->pool, sizeof(struct babel_route));
+  p->source_slab = sl_new(P->pool, sizeof(struct babel_source));
+  p->msg_slab = sl_new(P->pool, sizeof(struct babel_msg_node));
+  p->seqno_slab = sl_new(P->pool, sizeof(struct babel_seqno_request));
+  init_list(&p->seqno_cache);
+
+  p->log_pkt_tbf = (struct tbf){ .rate = 1, .burst = 5 };
+
+  return PS_UP;
+}
+
+static int
+babel_reconfigure(struct proto *P, struct proto_config *c)
+{
+  struct babel_proto *p = (void *) P;
+  struct babel_config *new = (void *) c;
+
+  TRACE(D_EVENTS, "Reconfiguring");
+
+  p->p.cf = c;
+  babel_reconfigure_ifaces(p, new);
+
+  babel_trigger_update(p);
+  babel_kick_timer(p);
+
+  return 1;
+}
+
+
+struct protocol proto_babel = {
+  .name =		"Babel",
+  .template =		"babel%d",
+  .attr_class =		EAP_BABEL,
+  .preference =		DEF_PREF_BABEL,
+  .config_size =	sizeof(struct babel_config),
+  .init =		babel_init,
+  .dump =		babel_dump,
+  .start =		babel_start,
+  .reconfigure =	babel_reconfigure,
+  .get_route_info =	babel_get_route_info,
+  .get_attr =		babel_get_attr
+};
diff --git a/proto/babel/babel.h b/proto/babel/babel.h
new file mode 100644
index 00000000..aea0dd88
--- /dev/null
+++ b/proto/babel/babel.h
@@ -0,0 +1,335 @@
+/*
+ *	BIRD -- The Babel protocol
+ *
+ *	Copyright (c) 2015--2016 Toke Hoiland-Jorgensen
+ *
+ *	Can be freely distributed and used under the terms of the GNU GPL.
+ *
+ *	This file contains the data structures used by Babel.
+ */
+
+#ifndef _BIRD_BABEL_H_
+#define _BIRD_BABEL_H_
+
+#include "nest/bird.h"
+#include "nest/cli.h"
+#include "nest/iface.h"
+#include "nest/route.h"
+#include "nest/protocol.h"
+#include "nest/locks.h"
+#include "lib/resource.h"
+#include "lib/lists.h"
+#include "lib/socket.h"
+#include "lib/string.h"
+#include "lib/timer.h"
+
+#ifndef IPV6
+#error "The Babel protocol only speaks IPv6"
+#endif
+
+#define EA_BABEL_METRIC		EA_CODE(EAP_BABEL, 0)
+#define EA_BABEL_ROUTER_ID	EA_CODE(EAP_BABEL, 1)
+
+#define BABEL_MAGIC		42
+#define BABEL_VERSION		2
+#define BABEL_PORT		6696
+#define BABEL_INFINITY		0xFFFF
+
+
+#define BABEL_HELLO_INTERVAL_WIRED	4	/* Default hello intervals in seconds */
+#define BABEL_HELLO_INTERVAL_WIRELESS	4
+#define BABEL_UPDATE_INTERVAL_FACTOR	4
+#define BABEL_IHU_INTERVAL_FACTOR	3
+#define BABEL_IHU_EXPIRY_FACTOR(X)	((X)*3/2)	/* 1.5 */
+#define BABEL_HELLO_EXPIRY_FACTOR(X)	((X)*3/2)	/* 1.5 */
+#define BABEL_ROUTE_EXPIRY_FACTOR(X)	((X)*7/2)	/* 3.5 */
+#define BABEL_ROUTE_REFRESH_INTERVAL	2	/* Seconds before route expiry to send route request */
+#define BABEL_HOLD_TIME			10	/* Expiry time for our own routes */
+#define BABEL_RXCOST_WIRED		96
+#define BABEL_RXCOST_WIRELESS		256
+#define BABEL_INITIAL_HOP_COUNT		255
+#define BABEL_MAX_SEND_INTERVAL		5
+#define BABEL_TIME_UNITS		100	/* On-wire times are counted in centiseconds */
+
+#define BABEL_SEQNO_REQUEST_EXPIRY	60
+#define BABEL_GARBAGE_INTERVAL		300
+
+#define BABEL_OVERHEAD		(SIZE_OF_IP_HEADER+UDP_HEADER_LENGTH)
+#define BABEL_MIN_MTU		(512 + BABEL_OVERHEAD)
+
+
+enum babel_tlv_type {
+  BABEL_TLV_PAD1		= 0,
+  BABEL_TLV_PADN		= 1,
+  BABEL_TLV_ACK_REQ		= 2,
+  BABEL_TLV_ACK			= 3,
+  BABEL_TLV_HELLO		= 4,
+  BABEL_TLV_IHU 		= 5,
+  BABEL_TLV_ROUTER_ID		= 6,
+  BABEL_TLV_NEXT_HOP		= 7,
+  BABEL_TLV_UPDATE		= 8,
+  BABEL_TLV_ROUTE_REQUEST	= 9,
+  BABEL_TLV_SEQNO_REQUEST	= 10,
+  /* extensions - not implemented
+  BABEL_TLV_TS_PC		= 11,
+  BABEL_TLV_HMAC		= 12,
+  BABEL_TLV_SS_UPDATE		= 13,
+  BABEL_TLV_SS_REQUEST		= 14,
+  BABEL_TLV_SS_SEQNO_REQUEST	= 15,
+  */
+  BABEL_TLV_MAX
+};
+
+enum babel_iface_type {
+  /* In practice, UNDEF and WIRED give equivalent behaviour */
+  BABEL_IFACE_TYPE_UNDEF	= 0,
+  BABEL_IFACE_TYPE_WIRED	= 1,
+  BABEL_IFACE_TYPE_WIRELESS	= 2,
+  BABEL_IFACE_TYPE_MAX
+};
+
+enum babel_ae_type {
+  BABEL_AE_WILDCARD		= 0,
+  BABEL_AE_IP4			= 1,
+  BABEL_AE_IP6			= 2,
+  BABEL_AE_IP6_LL		= 3,
+  BABEL_AE_MAX
+};
+
+
+struct babel_config {
+  struct proto_config c;
+
+  list iface_list;              /* Patterns configured -- keep it first; see babel_reconfigure why */
+};
+
+struct babel_iface_config {
+  struct iface_patt i;
+
+  u16 rxcost;
+  u8 type;
+  u8 check_link;
+  int port;
+  u16 hello_interval;
+  u16 ihu_interval;
+  u16 update_interval;
+
+  u16 rx_buffer;			/* RX buffer size, 0 for MTU */
+  u16 tx_length;			/* TX packet length limit (including headers), 0 for MTU */
+  int tx_tos;
+  int tx_priority;
+};
+
+struct babel_proto {
+  struct proto p;
+  timer *timer;
+  struct fib rtable;
+  list interfaces;			/* Interfaces we really know about (struct babel_iface) */
+  u64 router_id;
+  u16 update_seqno;			/* To be increased on request */
+  u8 triggered;				/* For triggering global updates */
+
+  slab *route_slab;
+  slab *source_slab;
+  slab *msg_slab;
+
+  slab *seqno_slab;
+  list seqno_cache;			/* Seqno requests in the cache (struct babel_seqno_request) */
+
+  struct tbf log_pkt_tbf;		/* TBF for packet messages */
+};
+
+struct babel_iface {
+  node n;
+
+  struct babel_proto *proto;
+  struct iface *iface;
+
+  struct babel_iface_config *cf;
+
+  u8 up;
+
+  pool *pool;
+  char *ifname;
+  sock *sk;
+  ip_addr addr;
+  int tx_length;
+  list neigh_list;			/* List of neighbors seen on this iface (struct babel_neighbor) */
+  list msg_queue;
+
+  u16 hello_seqno;			/* To be increased on each hello */
+
+  bird_clock_t next_hello;
+  bird_clock_t next_regular;
+  bird_clock_t next_triggered;
+  bird_clock_t want_triggered;
+
+  timer *timer;
+  event *send_event;
+};
+
+struct babel_neighbor {
+  node n;
+  struct babel_iface *ifa;
+
+  ip_addr addr;
+  u16 txcost;
+  u8 hello_cnt;
+  u16 hello_map;
+  u16 next_hello_seqno;
+  /* expiry timers */
+  bird_clock_t hello_expiry;
+  bird_clock_t ihu_expiry;
+
+  list routes;				/* Routes this neighbour has sent us (struct babel_route) */
+};
+
+struct babel_source {
+  node n;
+
+  u64 router_id;
+  u16 seqno;
+  u16 metric;
+  bird_clock_t expires;
+};
+
+struct babel_route {
+  node n;
+  node neigh_route;
+  struct babel_entry    *e;
+  struct babel_neighbor *neigh;
+
+  u16 seqno;
+  u16 advert_metric;
+  u16 metric;
+  u64 router_id;
+  ip_addr next_hop;
+  bird_clock_t refresh_time;
+  bird_clock_t expires;
+  u16 expiry_interval;
+};
+
+struct babel_entry {
+  struct fib_node n;
+  struct babel_proto *proto;
+  struct babel_route *selected_in;
+  struct babel_route *selected_out;
+
+  bird_clock_t updated;
+
+  list sources;				/* Source entries for this prefix (struct babel_source). */
+  list routes;				/* Routes for this prefix (struct babel_route) */
+};
+
+/* Stores forwarded seqno requests for duplicate suppression. */
+struct babel_seqno_request {
+  node n;
+  ip_addr prefix;
+  u8  plen;
+  u64 router_id;
+  u16 seqno;
+  bird_clock_t updated;
+};
+
+
+/*
+ *	Internal TLV messages
+ */
+
+struct babel_msg_ack_req {
+  u8 type;
+  u16 nonce;
+  u16 interval;
+  ip_addr sender;
+};
+
+struct babel_msg_ack {
+  u8 type;
+  u16 nonce;
+};
+
+struct babel_msg_hello {
+  u8 type;
+  u16 seqno;
+  u16 interval;
+  ip_addr sender;
+};
+
+struct babel_msg_ihu {
+  u8 type;
+  u8 ae;
+  u16 rxcost;
+  u16 interval;
+  ip_addr addr;
+  ip_addr sender;
+};
+
+struct babel_msg_update {
+  u8 type;
+  u8 ae;
+  u8 plen;
+  u16 interval;
+  u16 seqno;
+  u16 metric;
+  ip_addr prefix;
+  u64 router_id;
+  ip_addr next_hop;
+  ip_addr sender;
+};
+
+struct babel_msg_route_request {
+  u8 type;
+  u8 full;
+  u8 plen;
+  ip_addr prefix;
+};
+
+struct babel_msg_seqno_request {
+  u8 type;
+  u8 plen;
+  u16 seqno;
+  u8 hop_count;
+  u64 router_id;
+  ip_addr prefix;
+  ip_addr sender;
+};
+
+union babel_msg {
+  u8 type;
+  struct babel_msg_ack_req ack_req;
+  struct babel_msg_ack ack;
+  struct babel_msg_hello hello;
+  struct babel_msg_ihu ihu;
+  struct babel_msg_update update;
+  struct babel_msg_route_request route_request;
+  struct babel_msg_seqno_request seqno_request;
+};
+
+struct babel_msg_node {
+  node n;
+  union babel_msg msg;
+};
+
+
+/* babel.c */
+void babel_handle_ack_req(union babel_msg *msg, struct babel_iface *ifa);
+void babel_handle_ack(union babel_msg *msg, struct babel_iface *ifa);
+void babel_handle_hello(union babel_msg *msg, struct babel_iface *ifa);
+void babel_handle_ihu(union babel_msg *msg, struct babel_iface *ifa);
+void babel_handle_router_id(union babel_msg *msg, struct babel_iface *ifa);
+void babel_handle_update(union babel_msg *msg, struct babel_iface *ifa);
+void babel_handle_route_request(union babel_msg *msg, struct babel_iface *ifa);
+void babel_handle_seqno_request(union babel_msg *msg, struct babel_iface *ifa);
+
+void babel_show_interfaces(struct proto *P, char *iff);
+void babel_show_neighbors(struct proto *P, char *iff);
+void babel_show_entries(struct proto *P);
+
+/* packets.c */
+void babel_enqueue(union babel_msg *msg, struct babel_iface *ifa);
+void babel_send_unicast(union babel_msg *msg, struct babel_iface *ifa, ip_addr dest);
+int babel_open_socket(struct babel_iface *ifa);
+void babel_send_queue(void *arg);
+
+
+#endif
diff --git a/proto/babel/config.Y b/proto/babel/config.Y
new file mode 100644
index 00000000..e7ce6a93
--- /dev/null
+++ b/proto/babel/config.Y
@@ -0,0 +1,129 @@
+/*
+ *	BIRD -- Babel Configuration
+ *
+ *	Copyright (c) 2015-2016 Toke Hoiland-Jorgensen
+ *
+ *	Can be freely distributed and used under the terms of the GNU GPL.
+ */
+
+
+
+CF_HDR
+
+#include "proto/babel/babel.h"
+#include "nest/iface.h"
+
+CF_DEFINES
+
+#define BABEL_CFG ((struct babel_config *) this_proto)
+#define BABEL_IFACE ((struct babel_iface_config *) this_ipatt)
+
+CF_DECLS
+
+CF_KEYWORDS(BABEL, METRIC, RXCOST, HELLO, UPDATE, INTERVAL, PORT, WIRED,
+WIRELESS, RX, TX, BUFFER, LENGTH, CHECK, LINK, BABEL_METRIC)
+
+CF_GRAMMAR
+
+CF_ADDTO(proto, babel_proto)
+
+babel_proto_start: proto_start BABEL
+{
+  this_proto = proto_config_new(&proto_babel, $1);
+  init_list(&BABEL_CFG->iface_list);
+};
+
+babel_proto_item:
+   proto_item
+ | INTERFACE babel_iface
+ ;
+
+babel_proto_opts:
+   /* empty */
+ | babel_proto_opts babel_proto_item ';'
+ ;
+
+babel_proto:
+   babel_proto_start proto_name '{' babel_proto_opts '}';
+
+
+babel_iface_start:
+{
+  this_ipatt = cfg_allocz(sizeof(struct babel_iface_config));
+  add_tail(&BABEL_CFG->iface_list, NODE this_ipatt);
+  init_list(&this_ipatt->ipn_list);
+  BABEL_IFACE->port = BABEL_PORT;
+  BABEL_IFACE->type = BABEL_IFACE_TYPE_WIRED;
+  BABEL_IFACE->tx_tos = IP_PREC_INTERNET_CONTROL;
+  BABEL_IFACE->tx_priority = sk_priority_control;
+  BABEL_IFACE->check_link = 1;
+};
+
+
+babel_iface_finish:
+{
+  if (BABEL_IFACE->type == BABEL_IFACE_TYPE_WIRELESS)
+  {
+    if (!BABEL_IFACE->hello_interval)
+      BABEL_IFACE->hello_interval = BABEL_HELLO_INTERVAL_WIRELESS;
+    if (!BABEL_IFACE->rxcost)
+      BABEL_IFACE->rxcost = BABEL_RXCOST_WIRELESS;
+  }
+  else
+  {
+    if (!BABEL_IFACE->hello_interval)
+      BABEL_IFACE->hello_interval = BABEL_HELLO_INTERVAL_WIRED;
+    if (!BABEL_IFACE->rxcost)
+      BABEL_IFACE->rxcost = BABEL_RXCOST_WIRED;
+  }
+
+  if (!BABEL_IFACE->update_interval)
+    BABEL_IFACE->update_interval = BABEL_IFACE->hello_interval*BABEL_UPDATE_INTERVAL_FACTOR;
+  BABEL_IFACE->ihu_interval = BABEL_IFACE->hello_interval*BABEL_IHU_INTERVAL_FACTOR;
+};
+
+
+babel_iface_item:
+ | PORT expr { BABEL_IFACE->port = $2; if (($2<1) || ($2>65535)) cf_error("Invalid port number"); }
+ | RXCOST expr { BABEL_IFACE->rxcost = $2; if (($2<1) || ($2>65535)) cf_error("Invalid rxcost"); }
+ | HELLO INTERVAL expr { BABEL_IFACE->hello_interval = $3; if (($3<1) || ($3>65535)) cf_error("Invalid hello interval"); }
+ | UPDATE INTERVAL expr { BABEL_IFACE->update_interval = $3; if (($3<1) || ($3>65535)) cf_error("Invalid hello interval"); }
+ | TYPE WIRED { BABEL_IFACE->type = BABEL_IFACE_TYPE_WIRED; }
+ | TYPE WIRELESS { BABEL_IFACE->type = BABEL_IFACE_TYPE_WIRELESS; }
+ | RX BUFFER expr { BABEL_IFACE->rx_buffer = $3; if (($3<256) || ($3>65535)) cf_error("RX buffer must be in range 256-65535"); }
+ | TX LENGTH expr { BABEL_IFACE->tx_length = $3; if (($3<256) || ($3>65535)) cf_error("TX length must be in range 256-65535"); }
+ | TX tos { BABEL_IFACE->tx_tos = $2; }
+ | TX PRIORITY expr { BABEL_IFACE->tx_priority = $3; }
+ | CHECK LINK bool { BABEL_IFACE->check_link = $3; }
+ ;
+
+babel_iface_opts:
+   /* empty */
+ | babel_iface_opts babel_iface_item ';'
+ ;
+
+babel_iface_opt_list:
+   /* empty */
+ | '{' babel_iface_opts '}'
+ ;
+
+
+babel_iface:
+  babel_iface_start iface_patt_list_nopx babel_iface_opt_list babel_iface_finish;
+
+CF_ADDTO(dynamic_attr, BABEL_METRIC { $$ = f_new_dynamic_attr(EAF_TYPE_INT | EAF_TEMP, T_INT, EA_BABEL_METRIC); })
+
+CF_CLI_HELP(SHOW BABEL, ..., [[Show information about Babel protocol]]);
+
+CF_CLI(SHOW BABEL INTERFACES, optsym opttext, [<name>] [\"<interface>\"], [[Show information about Babel interfaces]])
+{ babel_show_interfaces(proto_get_named($4, &proto_babel), $5); };
+
+CF_CLI(SHOW BABEL NEIGHBORS, optsym opttext, [<name>] [\"<interface>\"], [[Show information about Babel neighbors]])
+{ babel_show_neighbors(proto_get_named($4, &proto_babel), $5); };
+
+CF_CLI(SHOW BABEL ENTRIES, optsym opttext, [<name>], [[Show information about Babel prefix entries]])
+{ babel_show_entries(proto_get_named($4, &proto_babel)); };
+
+CF_CODE
+
+CF_END
diff --git a/proto/babel/packets.c b/proto/babel/packets.c
new file mode 100644
index 00000000..be47aa75
--- /dev/null
+++ b/proto/babel/packets.c
@@ -0,0 +1,1093 @@
+/*
+ *	BIRD -- The Babel protocol
+ *
+ *	Copyright (c) 2015--2016 Toke Hoiland-Jorgensen
+ *
+ *	Can be freely distributed and used under the terms of the GNU GPL.
+ *
+ *	This file contains the packet and TLV handling code for the protocol.
+ */
+
+#include "babel.h"
+
+
+struct babel_pkt_header {
+  u8 magic;
+  u8 version;
+  u16 length;
+} PACKED;
+
+struct babel_tlv {
+  u8 type;
+  u8 length;
+  u8 value[0];
+} PACKED;
+
+struct babel_tlv_ack_req {
+  u8 type;
+  u8 length;
+  u16 reserved;
+  u16 nonce;
+  u16 interval;
+} PACKED;
+
+struct babel_tlv_ack {
+  u8 type;
+  u8 length;
+  u16 nonce;
+} PACKED;
+
+struct babel_tlv_hello {
+  u8 type;
+  u8 length;
+  u16 reserved;
+  u16 seqno;
+  u16 interval;
+} PACKED;
+
+struct babel_tlv_ihu {
+  u8 type;
+  u8 length;
+  u8 ae;
+  u8 reserved;
+  u16 rxcost;
+  u16 interval;
+  u8 addr[0];
+} PACKED;
+
+struct babel_tlv_router_id {
+  u8 type;
+  u8 length;
+  u16 reserved;
+  u64 router_id;
+} PACKED;
+
+struct babel_tlv_next_hop {
+  u8 type;
+  u8 length;
+  u8 ae;
+  u8 reserved;
+  u8 addr[0];
+} PACKED;
+
+struct babel_tlv_update {
+  u8 type;
+  u8 length;
+  u8 ae;
+  u8 flags;
+  u8 plen;
+  u8 omitted;
+  u16 interval;
+  u16 seqno;
+  u16 metric;
+  u8 addr[0];
+} PACKED;
+
+struct babel_tlv_route_request {
+  u8 type;
+  u8 length;
+  u8 ae;
+  u8 plen;
+  u8 addr[0];
+} PACKED;
+
+struct babel_tlv_seqno_request {
+  u8 type;
+  u8 length;
+  u8 ae;
+  u8 plen;
+  u16 seqno;
+  u8 hop_count;
+  u8 reserved;
+  u64 router_id;
+  u8 addr[0];
+} PACKED;
+
+
+#define BABEL_FLAG_DEF_PREFIX	0x80
+#define BABEL_FLAG_ROUTER_ID	0x40
+
+
+struct babel_parse_state {
+  struct babel_proto *proto;
+  struct babel_iface *ifa;
+  ip_addr saddr;
+  ip_addr next_hop;
+  u64 router_id;		/* Router ID used in subsequent updates */
+  u8 def_ip6_prefix[16];	/* Implicit IPv6 prefix in network order */
+  u8 def_ip4_prefix[4];		/* Implicit IPv4 prefix in network order */
+  u8 router_id_seen;		/* router_id field is valid */
+  u8 def_ip6_prefix_seen;	/* def_ip6_prefix is valid */
+  u8 def_ip4_prefix_seen;	/* def_ip4_prefix is valid */
+};
+
+enum parse_result {
+  PARSE_SUCCESS,
+  PARSE_ERROR,
+  PARSE_IGNORE,
+};
+
+struct babel_write_state {
+  u64 router_id;
+  u8 router_id_seen;
+//  ip_addr next_hop;
+};
+
+
+#define DROP(DSC,VAL) do { err_dsc = DSC; err_val = VAL; goto drop; } while(0)
+#define DROP1(DSC) do { err_dsc = DSC; goto drop; } while(0)
+#define LOG_PKT(msg, args...) \
+  log_rl(&p->log_pkt_tbf, L_REMOTE "%s: " msg, p->p.name, args)
+
+#define FIRST_TLV(p) ((struct babel_tlv *) (((struct babel_pkt_header *) p) + 1))
+#define NEXT_TLV(t) ((struct babel_tlv *) (((byte *) t) + TLV_LENGTH(t)))
+#define TLV_LENGTH(t) (t->type == BABEL_TLV_PAD1 ? 1 : t->length + sizeof(struct babel_tlv))
+#define TLV_OPT_LENGTH(t) (t->length + sizeof(struct babel_tlv) - sizeof(*t))
+#define TLV_HDR(tlv,t,l) ({ tlv->type = t; tlv->length = l - sizeof(struct babel_tlv); })
+#define TLV_HDR0(tlv,t) TLV_HDR(tlv, t, tlv_data[t].min_length)
+
+
+static inline u16
+get_time16(const void *p)
+{
+  u16 v = get_u16(p) / BABEL_TIME_UNITS;
+  return MAX(1, v);
+}
+
+static inline void
+put_time16(void *p, u16 v)
+{
+  put_u16(p, v * BABEL_TIME_UNITS);
+}
+
+static inline ip6_addr
+get_ip6_px(const void *p, int plen)
+{
+  ip6_addr addr = IPA_NONE;
+  memcpy(&addr, p, (plen + 7) / 8);
+  return ip6_ntoh(addr);
+}
+
+static inline void
+put_ip6_px(void *p, ip6_addr addr, int plen)
+{
+  addr = ip6_hton(addr);
+  memcpy(p, &addr, (plen + 7) / 8);
+}
+
+static inline ip6_addr
+get_ip6_ll(const void *p)
+{
+  return ip6_build(0xfe800000, 0, get_u32(p+0), get_u32(p+4));
+}
+
+static inline void
+put_ip6_ll(void *p, ip6_addr addr)
+{
+  put_u32(p+0, _I2(addr));
+  put_u32(p+4, _I3(addr));
+}
+
+
+/*
+ *	TLV read/write functions
+ */
+
+static int babel_read_ack_req(struct babel_tlv *hdr, union babel_msg *msg, struct babel_parse_state *state);
+static int babel_read_hello(struct babel_tlv *hdr, union babel_msg *msg, struct babel_parse_state *state);
+static int babel_read_ihu(struct babel_tlv *hdr, union babel_msg *msg, struct babel_parse_state *state);
+static int babel_read_router_id(struct babel_tlv *hdr, union babel_msg *msg, struct babel_parse_state *state);
+static int babel_read_next_hop(struct babel_tlv *hdr, union babel_msg *msg, struct babel_parse_state *state);
+static int babel_read_update(struct babel_tlv *hdr, union babel_msg *msg, struct babel_parse_state *state);
+static int babel_read_route_request(struct babel_tlv *hdr, union babel_msg *msg, struct babel_parse_state *state);
+static int babel_read_seqno_request(struct babel_tlv *hdr, union babel_msg *msg, struct babel_parse_state *state);
+
+static int babel_write_ack(struct babel_tlv *hdr, union babel_msg *msg, struct babel_write_state *state, int max_len);
+static int babel_write_hello(struct babel_tlv *hdr, union babel_msg *msg, struct babel_write_state *state, int max_len);
+static int babel_write_ihu(struct babel_tlv *hdr, union babel_msg *msg, struct babel_write_state *state, int max_len);
+static int babel_write_update(struct babel_tlv *hdr, union babel_msg *msg, struct babel_write_state *state, int max_len);
+static int babel_write_route_request(struct babel_tlv *hdr, union babel_msg *msg, struct babel_write_state *state, int max_len);
+static int babel_write_seqno_request(struct babel_tlv *hdr, union babel_msg *msg, struct babel_write_state *state, int max_len);
+
+struct babel_tlv_data {
+  u8 min_length;
+  int (*read_tlv)(struct babel_tlv *hdr, union babel_msg *m, struct babel_parse_state *state);
+  int (*write_tlv)(struct babel_tlv *hdr, union babel_msg *m, struct babel_write_state *state, int max_len);
+  void (*handle_tlv)(union babel_msg *m, struct babel_iface *ifa);
+};
+
+const static struct babel_tlv_data tlv_data[BABEL_TLV_MAX] = {
+  [BABEL_TLV_ACK_REQ] = {
+    sizeof(struct babel_tlv_ack_req),
+    babel_read_ack_req,
+    NULL,
+    babel_handle_ack_req
+  },
+  [BABEL_TLV_ACK] = {
+    sizeof(struct babel_tlv_ack),
+    NULL,
+    babel_write_ack,
+    NULL
+  },
+  [BABEL_TLV_HELLO] = {
+    sizeof(struct babel_tlv_hello),
+    babel_read_hello,
+    babel_write_hello,
+    babel_handle_hello
+  },
+  [BABEL_TLV_IHU] = {
+    sizeof(struct babel_tlv_ihu),
+    babel_read_ihu,
+    babel_write_ihu,
+    babel_handle_ihu
+  },
+  [BABEL_TLV_ROUTER_ID] = {
+    sizeof(struct babel_tlv_router_id),
+    babel_read_router_id,
+    NULL,
+    NULL
+  },
+  [BABEL_TLV_NEXT_HOP] = {
+    sizeof(struct babel_tlv_next_hop),
+    babel_read_next_hop,
+    NULL,
+    NULL
+  },
+  [BABEL_TLV_UPDATE] = {
+    sizeof(struct babel_tlv_update),
+    babel_read_update,
+    babel_write_update,
+    babel_handle_update
+  },
+  [BABEL_TLV_ROUTE_REQUEST] = {
+    sizeof(struct babel_tlv_route_request),
+    babel_read_route_request,
+    babel_write_route_request,
+    babel_handle_route_request
+  },
+  [BABEL_TLV_SEQNO_REQUEST] = {
+    sizeof(struct babel_tlv_seqno_request),
+    babel_read_seqno_request,
+    babel_write_seqno_request,
+    babel_handle_seqno_request
+  },
+};
+
+static int
+babel_read_ack_req(struct babel_tlv *hdr, union babel_msg *m,
+		   struct babel_parse_state *state)
+{
+  struct babel_tlv_ack_req *tlv = (void *) hdr;
+  struct babel_msg_ack_req *msg = &m->ack_req;
+
+  msg->type = BABEL_TLV_ACK_REQ;
+  msg->nonce = get_u16(&tlv->nonce);
+  msg->interval = get_time16(&tlv->interval);
+  msg->sender = state->saddr;
+
+  if (!msg->interval)
+    return PARSE_ERROR;
+
+  return PARSE_SUCCESS;
+}
+
+static int
+babel_write_ack(struct babel_tlv *hdr, union babel_msg *m,
+                struct babel_write_state *state, int max_len)
+{
+  struct babel_tlv_ack *tlv = (void *) hdr;
+  struct babel_msg_ack *msg = &m->ack;
+
+  TLV_HDR0(tlv, BABEL_TLV_ACK);
+  put_u16(&tlv->nonce, msg->nonce);
+
+  return sizeof(struct babel_tlv_ack);
+}
+
+static int
+babel_read_hello(struct babel_tlv *hdr, union babel_msg *m,
+                 struct babel_parse_state *state)
+{
+  struct babel_tlv_hello *tlv = (void *) hdr;
+  struct babel_msg_hello *msg = &m->hello;
+
+  msg->type = BABEL_TLV_HELLO;
+  msg->seqno = get_u16(&tlv->seqno);
+  msg->interval = get_time16(&tlv->interval);
+  msg->sender = state->saddr;
+
+  return PARSE_SUCCESS;
+}
+
+static int
+babel_write_hello(struct babel_tlv *hdr, union babel_msg *m,
+                  struct babel_write_state *state, int max_len)
+{
+  struct babel_tlv_hello *tlv = (void *) hdr;
+  struct babel_msg_hello *msg = &m->hello;
+
+  TLV_HDR0(tlv, BABEL_TLV_HELLO);
+  put_u16(&tlv->seqno, msg->seqno);
+  put_time16(&tlv->interval, msg->interval);
+
+  return sizeof(struct babel_tlv_hello);
+}
+
+static int
+babel_read_ihu(struct babel_tlv *hdr, union babel_msg *m,
+               struct babel_parse_state *state)
+{
+  struct babel_tlv_ihu *tlv = (void *) hdr;
+  struct babel_msg_ihu *msg = &m->ihu;
+
+  msg->type = BABEL_TLV_IHU;
+  msg->ae = tlv->ae;
+  msg->rxcost = get_u16(&tlv->rxcost);
+  msg->interval = get_time16(&tlv->interval);
+  msg->addr = IPA_NONE;
+  msg->sender = state->saddr;
+
+  if (msg->ae >= BABEL_AE_MAX)
+    return PARSE_IGNORE;
+
+  // We handle link-local IPs. In every other case, the addr field will be 0 but
+  // validation will succeed. The handler takes care of these cases.
+  if (msg->ae == BABEL_AE_IP6_LL)
+  {
+    if (TLV_OPT_LENGTH(tlv) < 8)
+      return PARSE_ERROR;
+
+    msg->addr = ipa_from_ip6(get_ip6_ll(&tlv->addr));
+  }
+
+  return PARSE_SUCCESS;
+}
+
+static int
+babel_write_ihu(struct babel_tlv *hdr, union babel_msg *m,
+                struct babel_write_state *state, int max_len)
+{
+  struct babel_tlv_ihu *tlv = (void *) hdr;
+  struct babel_msg_ihu *msg = &m->ihu;
+
+  if (ipa_is_link_local(msg->addr) && max_len < sizeof(struct babel_tlv_ihu) + 8)
+    return 0;
+
+  TLV_HDR0(tlv, BABEL_TLV_IHU);
+  put_u16(&tlv->rxcost, msg->rxcost);
+  put_time16(&tlv->interval, msg->interval);
+
+  if (!ipa_is_link_local(msg->addr))
+  {
+    tlv->ae = BABEL_AE_WILDCARD;
+    return sizeof(struct babel_tlv_ihu);
+  }
+  put_ip6_ll(&tlv->addr, msg->addr);
+  tlv->ae = BABEL_AE_IP6_LL;
+  hdr->length += 8;
+  return sizeof(struct babel_tlv_ihu) + 8;
+}
+
+static int
+babel_read_router_id(struct babel_tlv *hdr, union babel_msg *m UNUSED,
+                     struct babel_parse_state *state)
+{
+  struct babel_tlv_router_id *tlv = (void *) hdr;
+
+  state->router_id = get_u64(&tlv->router_id);
+  state->router_id_seen = 1;
+
+  return PARSE_IGNORE;
+}
+
+/* This is called directly from babel_write_update() */
+static int
+babel_write_router_id(struct babel_tlv *hdr, u64 router_id,
+		      struct babel_write_state *state, int max_len UNUSED)
+{
+  struct babel_tlv_router_id *tlv = (void *) hdr;
+
+  /* We still assume that first min_length bytes are available and zeroed */
+
+  TLV_HDR0(tlv, BABEL_TLV_ROUTER_ID);
+  put_u64(&tlv->router_id, router_id);
+
+  state->router_id = router_id;
+  state->router_id_seen = 1;
+
+  return sizeof(struct babel_tlv_router_id);
+}
+
+static int
+babel_read_next_hop(struct babel_tlv *hdr, union babel_msg *m UNUSED,
+                    struct babel_parse_state *state)
+{
+  struct babel_tlv_next_hop *tlv = (void *) hdr;
+
+  switch (tlv->ae)
+  {
+  case BABEL_AE_WILDCARD:
+    return PARSE_ERROR;
+
+  case BABEL_AE_IP4:
+    /* TODO */
+    return PARSE_IGNORE;
+
+  case BABEL_AE_IP6:
+    if (TLV_OPT_LENGTH(tlv) < sizeof(ip6_addr))
+      return PARSE_ERROR;
+
+    state->next_hop = ipa_from_ip6(get_ip6(&tlv->addr));
+    return PARSE_IGNORE;
+
+  case BABEL_AE_IP6_LL:
+    if (TLV_OPT_LENGTH(tlv) < 8)
+      return PARSE_ERROR;
+
+    state->next_hop = ipa_from_ip6(get_ip6_ll(&tlv->addr));
+    return PARSE_IGNORE;
+
+  default:
+    return PARSE_IGNORE;
+  }
+
+  return PARSE_IGNORE;
+}
+
+static int
+babel_read_update(struct babel_tlv *hdr, union babel_msg *m,
+                  struct babel_parse_state *state)
+{
+  struct babel_tlv_update *tlv = (void *) hdr;
+  struct babel_msg_update *msg = &m->update;
+
+  msg->type = BABEL_TLV_UPDATE;
+  msg->ae = tlv->ae;
+  msg->interval = get_time16(&tlv->interval);
+  msg->seqno = get_u16(&tlv->seqno);
+  msg->metric = get_u16(&tlv->metric);
+
+  /* Length of received prefix data without omitted part */
+  int len = (tlv->plen + 7)/8 - (int) tlv->omitted;
+  u8 buf[16] = {};
+
+  if ((len < 0) || (len > TLV_OPT_LENGTH(tlv)))
+    return PARSE_ERROR;
+
+  switch (tlv->ae)
+  {
+  case BABEL_AE_WILDCARD:
+    if (tlv->plen > 0)
+      return PARSE_ERROR;
+
+    msg->prefix = IPA_NONE;
+    break;
+
+  case BABEL_AE_IP4:
+    /* TODO */
+    return PARSE_IGNORE;
+
+  case BABEL_AE_IP6:
+    if (tlv->plen > MAX_PREFIX_LENGTH)
+      return PARSE_ERROR;
+
+    /* Cannot omit data if there is no saved prefix */
+    if (tlv->omitted && !state->def_ip6_prefix_seen)
+      return PARSE_ERROR;
+
+    /* Merge saved prefix and received prefix parts */
+    memcpy(buf, state->def_ip6_prefix, tlv->omitted);
+    memcpy(buf + tlv->omitted, tlv->addr, len);
+
+    msg->plen = tlv->plen;
+    msg->prefix = ipa_from_ip6(get_ip6(buf));
+
+    if (tlv->flags & BABEL_FLAG_DEF_PREFIX)
+    {
+      put_ip6(state->def_ip6_prefix, msg->prefix);
+      state->def_ip6_prefix_seen = 1;
+    }
+
+    if (tlv->flags & BABEL_FLAG_ROUTER_ID)
+    {
+      state->router_id = ((u64) _I2(msg->prefix)) << 32 | _I3(msg->prefix);
+      state->router_id_seen = 1;
+    }
+    break;
+
+  case BABEL_AE_IP6_LL:
+    /* ??? */
+    return PARSE_IGNORE;
+
+  default:
+    return PARSE_IGNORE;
+  }
+
+  if (!state->router_id_seen)
+  {
+    DBG("Babel: No router ID seen before update\n");
+    return PARSE_ERROR;
+  }
+
+  msg->router_id = state->router_id;
+  msg->next_hop = state->next_hop;
+  msg->sender = state->saddr;
+
+  return PARSE_SUCCESS;
+}
+
+static int
+babel_write_update(struct babel_tlv *hdr, union babel_msg *m,
+                   struct babel_write_state *state, int max_len)
+{
+  struct babel_tlv_update *tlv = (void *) hdr;
+  struct babel_msg_update *msg = &m->update;
+  int len0 = 0;
+
+  /*
+   * When needed, we write Router-ID TLV before Update TLV and return size of
+   * both of them. There is enough space for the Router-ID TLV, because
+   * sizeof(struct babel_tlv_router_id) == sizeof(struct babel_tlv_update).
+   */
+  if (!state->router_id_seen || (msg->router_id != state->router_id))
+  {
+    len0 = babel_write_router_id(hdr, msg->router_id, state, max_len);
+    tlv = (struct babel_tlv_update *) NEXT_TLV(tlv);
+  }
+
+  int len = sizeof(struct babel_tlv_update) + (msg->plen + 7)/8;
+
+  if (len0 + len > max_len)
+    return 0;
+
+  memset(tlv, 0, sizeof(struct babel_tlv_update));
+  TLV_HDR(tlv, BABEL_TLV_UPDATE, len);
+  tlv->ae = BABEL_AE_IP6;
+  tlv->plen = msg->plen;
+  put_time16(&tlv->interval, msg->interval);
+  put_u16(&tlv->seqno, msg->seqno);
+  put_u16(&tlv->metric, msg->metric);
+  put_ip6_px(tlv->addr, msg->prefix, msg->plen);
+
+  return len0 + len;
+}
+
+static int
+babel_read_route_request(struct babel_tlv *hdr, union babel_msg *m,
+                         struct babel_parse_state *state)
+{
+  struct babel_tlv_route_request *tlv = (void *) hdr;
+  struct babel_msg_route_request *msg = &m->route_request;
+
+  msg->type = BABEL_TLV_ROUTE_REQUEST;
+
+  switch (tlv->ae)
+  {
+  case BABEL_AE_WILDCARD:
+    /* Wildcard requests must have plen 0 */
+    if (tlv->plen > 0)
+      return PARSE_ERROR;
+
+    msg->full = 1;
+    return PARSE_SUCCESS;
+
+  case BABEL_AE_IP4:
+    /* TODO */
+    return PARSE_IGNORE;
+
+  case BABEL_AE_IP6:
+    if (tlv->plen > MAX_PREFIX_LENGTH)
+      return PARSE_ERROR;
+
+    if (TLV_OPT_LENGTH(tlv) < (tlv->plen + 7)/8)
+      return PARSE_ERROR;
+
+    msg->plen = tlv->plen;
+    msg->prefix = get_ip6_px(tlv->addr, tlv->plen);
+    return PARSE_SUCCESS;
+
+  case BABEL_AE_IP6_LL:
+    return PARSE_ERROR;
+
+  default:
+    return PARSE_IGNORE;
+  }
+
+  return PARSE_IGNORE;
+}
+
+static int
+babel_write_route_request(struct babel_tlv *hdr, union babel_msg *m,
+			  struct babel_write_state *state, int max_len)
+{
+  struct babel_tlv_route_request *tlv = (void *) hdr;
+  struct babel_msg_route_request *msg = &m->route_request;
+
+  int len = sizeof(struct babel_tlv_route_request) + (msg->plen + 7)/8;
+
+  if (len > max_len)
+    return 0;
+
+  TLV_HDR(tlv, BABEL_TLV_ROUTE_REQUEST, len);
+
+  if (msg->full)
+  {
+    tlv->ae = BABEL_AE_WILDCARD;
+    tlv->plen = 0;
+  }
+  else
+  {
+    tlv->ae = BABEL_AE_IP6;
+    tlv->plen = msg->plen;
+    put_ip6_px(tlv->addr, msg->prefix, msg->plen);
+  }
+
+  return len;
+}
+
+static int
+babel_read_seqno_request(struct babel_tlv *hdr, union babel_msg *m,
+                         struct babel_parse_state *state)
+{
+  struct babel_tlv_seqno_request *tlv = (void *) hdr;
+  struct babel_msg_seqno_request *msg = &m->seqno_request;
+
+  msg->type = BABEL_TLV_SEQNO_REQUEST;
+  msg->seqno = get_u16(&tlv->seqno);
+  msg->hop_count = tlv->hop_count;
+  msg->router_id = get_u64(&tlv->router_id);
+  msg->sender = state->saddr;
+
+  if (tlv->hop_count == 0)
+    return PARSE_ERROR;
+
+  switch (tlv->ae)
+  {
+  case BABEL_AE_WILDCARD:
+    return PARSE_ERROR;
+
+  case BABEL_AE_IP4:
+    /* TODO */
+    return PARSE_IGNORE;
+
+  case BABEL_AE_IP6:
+    if (tlv->plen > MAX_PREFIX_LENGTH)
+      return PARSE_ERROR;
+
+    if (TLV_OPT_LENGTH(tlv) < (tlv->plen + 7)/8)
+      return PARSE_ERROR;
+
+    msg->plen = tlv->plen;
+    msg->prefix = get_ip6_px(tlv->addr, tlv->plen);
+    return PARSE_SUCCESS;
+
+  case BABEL_AE_IP6_LL:
+    return PARSE_ERROR;
+
+  default:
+    return PARSE_IGNORE;
+  }
+
+  return PARSE_IGNORE;
+}
+
+static int
+babel_write_seqno_request(struct babel_tlv *hdr, union babel_msg *m,
+			  struct babel_write_state *state, int max_len)
+{
+  struct babel_tlv_seqno_request *tlv = (void *) hdr;
+  struct babel_msg_seqno_request *msg = &m->seqno_request;
+
+  int len = sizeof(struct babel_tlv_seqno_request) + (msg->plen + 7)/8;
+
+  if (len > max_len)
+    return 0;
+
+  TLV_HDR(tlv, BABEL_TLV_SEQNO_REQUEST, len);
+  tlv->ae = BABEL_AE_IP6;
+  tlv->plen = msg->plen;
+  put_u16(&tlv->seqno, msg->seqno);
+  tlv->hop_count = msg->hop_count;
+  put_u64(&tlv->router_id, msg->router_id);
+  put_ip6_px(tlv->addr, msg->prefix, msg->plen);
+
+  return len;
+}
+
+static inline int
+babel_read_tlv(struct babel_tlv *hdr,
+               union babel_msg *msg,
+               struct babel_parse_state *state)
+{
+  if ((hdr->type <= BABEL_TLV_PADN) ||
+      (hdr->type >= BABEL_TLV_MAX) ||
+      !tlv_data[hdr->type].read_tlv)
+    return PARSE_IGNORE;
+
+  if (TLV_LENGTH(hdr) < tlv_data[hdr->type].min_length)
+    return PARSE_ERROR;
+
+  memset(msg, 0, sizeof(*msg));
+  return tlv_data[hdr->type].read_tlv(hdr, msg, state);
+}
+
+static int
+babel_write_tlv(struct babel_tlv *hdr,
+		union babel_msg *msg,
+		struct babel_write_state *state,
+		int max_len)
+{
+  if ((msg->type <= BABEL_TLV_PADN) ||
+      (msg->type >= BABEL_TLV_MAX) ||
+      !tlv_data[msg->type].write_tlv)
+    return 0;
+
+  if (tlv_data[msg->type].min_length > max_len)
+    return 0;
+
+  memset(hdr, 0, tlv_data[msg->type].min_length);
+  return tlv_data[msg->type].write_tlv(hdr, msg, state, max_len);
+}
+
+
+/*
+ *	Packet RX/TX functions
+ */
+
+static int
+babel_send_to(struct babel_iface *ifa, ip_addr dest)
+{
+  sock *sk = ifa->sk;
+  struct babel_pkt_header *hdr = (void *) sk->tbuf;
+  int len = get_u16(&hdr->length) + sizeof(struct babel_pkt_header);
+
+  DBG("Babel: Sending %d bytes to %I\n", len, dest);
+  return sk_send_to(sk, len, dest, 0);
+}
+
+/**
+ * babel_write_queue - Write a TLV queue to a transmission buffer
+ * @ifa: Interface holding the transmission buffer
+ * @queue: TLV queue to write (containing internal-format TLVs)
+ *
+ * This function writes a packet to the interface transmission buffer with as
+ * many TLVs from the &queue as will fit in the buffer. It returns the number of
+ * bytes written (NOT counting the packet header). The function is called by
+ * babel_send_queue() and babel_send_unicast() to construct packets for
+ * transmission, and uses per-TLV helper functions to convert the
+ * internal-format TLVs to their wire representations.
+ *
+ * The TLVs in the queue are freed after they are written to the buffer.
+ */
+static int
+babel_write_queue(struct babel_iface *ifa, list *queue)
+{
+  struct babel_proto *p = ifa->proto;
+  struct babel_write_state state = {};
+
+  if (EMPTY_LIST(*queue))
+    return 0;
+
+  byte *pos = ifa->sk->tbuf;
+  byte *end = pos + ifa->tx_length;
+
+  struct babel_pkt_header *pkt = (void *) pos;
+  pkt->magic = BABEL_MAGIC;
+  pkt->version = BABEL_VERSION;
+  pkt->length = 0;
+  pos += sizeof(struct babel_pkt_header);
+
+  struct babel_msg_node *msg;
+  WALK_LIST_FIRST(msg, *queue)
+  {
+    int len = babel_write_tlv((struct babel_tlv *) pos, &msg->msg, &state, end - pos);
+
+    if (!len)
+      break;
+
+    pos += len;
+    rem_node(NODE msg);
+    sl_free(p->msg_slab, msg);
+  }
+
+  int plen = pos - (byte *) pkt;
+  put_u16(&pkt->length, plen - sizeof(struct babel_pkt_header));
+
+  return plen;
+}
+
+void
+babel_send_queue(void *arg)
+{
+  struct babel_iface *ifa = arg;
+  while ((babel_write_queue(ifa, &ifa->msg_queue) > 0) &&
+	 (babel_send_to(ifa, IP6_BABEL_ROUTERS) > 0));
+}
+
+static inline void
+babel_kick_queue(struct babel_iface *ifa)
+{
+  /*
+   * Only schedule send event if there is not already data in the socket buffer.
+   * Otherwise we may overwrite the data already in the buffer.
+   */
+
+  if ((ifa->sk->tpos == ifa->sk->tbuf) && !ev_active(ifa->send_event))
+    ev_schedule(ifa->send_event);
+}
+
+/**
+ * babel_send_unicast - send a single TLV via unicast to a destination
+ * @msg: TLV to send
+ * @ifa: Interface to send via
+ * @dest: Destination of the TLV
+ *
+ * This function is used to send a single TLV via unicast to a designated
+ * receiver. This is used for replying to certain incoming requests, and for
+ * sending unicast requests to refresh routes before they expire.
+ */
+void
+babel_send_unicast(union babel_msg *msg, struct babel_iface *ifa, ip_addr dest)
+{
+  struct babel_proto *p = ifa->proto;
+  struct babel_msg_node *msgn = sl_alloc(p->msg_slab);
+  list queue;
+
+  msgn->msg = *msg;
+  init_list(&queue);
+  add_tail(&queue, NODE msgn);
+  babel_write_queue(ifa, &queue);
+  babel_send_to(ifa, dest);
+
+  /* We could overwrite waiting packet here, we may have to kick TX queue */
+  if (!EMPTY_LIST(ifa->msg_queue))
+    babel_kick_queue(ifa);
+}
+
+/**
+ * babel_enqueue - enqueue a TLV for transmission on an interface
+ * @msg: TLV to enqueue (in internal TLV format)
+ * @ifa: Interface to enqueue to
+ *
+ * This function is called to enqueue a TLV for subsequent transmission on an
+ * interface. The transmission event is triggered whenever a TLV is enqueued;
+ * this ensures that TLVs will be transmitted in a timely manner, but that TLVs
+ * which are enqueued in rapid succession can be transmitted together in one
+ * packet.
+ */
+void
+babel_enqueue(union babel_msg *msg, struct babel_iface *ifa)
+{
+  struct babel_proto *p = ifa->proto;
+  struct babel_msg_node *msgn = sl_alloc(p->msg_slab);
+  msgn->msg = *msg;
+  add_tail(&ifa->msg_queue, NODE msgn);
+  babel_kick_queue(ifa);
+}
+
+/**
+ * babel_process_packet - process incoming data packet
+ * @pkt: Pointer to the packet data
+ * @len: Length of received packet
+ * @saddr: Address of packet sender
+ * @ifa: Interface packet was received on.
+ *
+ * This function is the main processing hook of incoming Babel packets. It
+ * checks that the packet header is well-formed, then processes the TLVs
+ * contained in the packet. This is done in two passes: First all TLVs are
+ * parsed into the internal TLV format. If a TLV parser fails, processing of the
+ * rest of the packet is aborted.
+ *
+ * After the parsing step, the TLV handlers are called for each parsed TLV in
+ * order.
+ */
+static void
+babel_process_packet(struct babel_pkt_header *pkt, int len,
+                     ip_addr saddr, struct babel_iface *ifa)
+{
+  struct babel_proto *p = ifa->proto;
+  struct babel_tlv *tlv;
+  struct babel_msg_node *msg;
+  list msgs;
+  int res;
+
+  int plen = sizeof(struct babel_pkt_header) + get_u16(&pkt->length);
+  byte *pos;
+  byte *end = (byte *)pkt + plen;
+
+  struct babel_parse_state state = {
+    .proto	= p,
+    .ifa	= ifa,
+    .saddr	= saddr,
+    .next_hop	= saddr,
+  };
+
+  if ((pkt->magic != BABEL_MAGIC) || (pkt->version != BABEL_VERSION))
+  {
+    TRACE(D_PACKETS, "Strange packet from %I via %s - magic %d version %d",
+	  saddr, ifa->iface->name, pkt->magic, pkt->version);
+    return;
+  }
+
+  if (plen > len)
+  {
+    LOG_PKT("Bad packet from %I via %s - %s (%u)",
+	    saddr, ifa->iface->name, "length mismatch", plen);
+    return;
+  }
+
+  TRACE(D_PACKETS, "Packet received from %I via %s",
+        saddr, ifa->iface->name);
+
+  init_list(&msgs);
+
+  /* First pass through the packet TLV by TLV, parsing each into internal data
+     structures. */
+  for (tlv = FIRST_TLV(pkt);
+       (byte *)tlv < end;
+       tlv = NEXT_TLV(tlv))
+  {
+    /* Ugly special case */
+    if (tlv->type == BABEL_TLV_PAD1)
+      continue;
+
+    /* The end of the common TLV header */
+    pos = (byte *)tlv + sizeof(struct babel_tlv);
+    if ((pos > end) || (pos + tlv->length > end))
+    {
+      LOG_PKT("Bad TLV from %I via %s type %d pos %d - framing error",
+	      saddr, ifa->iface->name, tlv->type, (byte *)tlv - (byte *)pkt);
+      break;
+    }
+
+    msg = sl_alloc(p->msg_slab);
+    res = babel_read_tlv(tlv, &msg->msg, &state);
+    if (res == PARSE_SUCCESS)
+    {
+      add_tail(&msgs, NODE msg);
+    }
+    else if (res == PARSE_IGNORE)
+    {
+      DBG("Babel: Ignoring TLV of type %d\n", tlv->type);
+      sl_free(p->msg_slab, msg);
+    }
+    else /* PARSE_ERROR */
+    {
+      LOG_PKT("Bad TLV from %I via %s type %d pos %d - parse error",
+	      saddr, ifa->iface->name, tlv->type, (byte *)tlv - (byte *)pkt);
+      sl_free(p->msg_slab, msg);
+      break;
+    }
+  }
+
+  /* Parsing done, handle all parsed TLVs */
+  WALK_LIST_FIRST(msg, msgs)
+  {
+    if (tlv_data[msg->msg.type].handle_tlv)
+      tlv_data[msg->msg.type].handle_tlv(&msg->msg, ifa);
+    rem_node(NODE msg);
+    sl_free(p->msg_slab, msg);
+  }
+}
+
+static void
+babel_err_hook(sock *sk, int err)
+{
+  struct babel_iface *ifa = sk->data;
+  struct babel_proto *p = ifa->proto;
+
+  log(L_ERR "%s: Socket error on %s: %M", p->p.name, ifa->iface->name, err);
+  /* FIXME: Drop queued TLVs here? */
+}
+
+
+static void
+babel_tx_hook(sock *sk)
+{
+  struct babel_iface *ifa = sk->data;
+
+  DBG("Babel: TX hook called (iface %s, src %I, dst %I)\n",
+      sk->iface->name, sk->saddr, sk->daddr);
+
+  babel_send_queue(ifa);
+}
+
+
+static int
+babel_rx_hook(sock *sk, int len)
+{
+  struct babel_iface *ifa = sk->data;
+  struct babel_proto *p = ifa->proto;
+  const char *err_dsc = NULL;
+  uint err_val = 0;
+
+  if (sk->lifindex != ifa->iface->index)
+    return 1;
+
+  DBG("Babel: RX hook called (iface %s, src %I, dst %I)\n",
+      sk->iface->name, sk->faddr, sk->laddr);
+
+  /* Silently ignore my own packets */
+  if (ipa_equal(ifa->iface->addr->ip, sk->faddr))
+    return 1;
+
+  if (!ipa_is_link_local(sk->faddr))
+    DROP1("wrong src address");
+
+  if (sk->fport != ifa->cf->port)
+    DROP("wrong src port", sk->fport);
+
+  if (len < sizeof(struct babel_pkt_header))
+    DROP("too short", len);
+
+  if (sk->flags & SKF_TRUNCATED)
+    DROP("truncated", len);
+
+  babel_process_packet((struct babel_pkt_header *) sk->rbuf, len, sk->faddr, ifa);
+  return 1;
+
+drop:
+  LOG_PKT("Bad packet from %I via %s - %s (%u)",
+	  sk->faddr, sk->iface->name, err_dsc, err_val);
+  return 1;
+}
+
+int
+babel_open_socket(struct babel_iface *ifa)
+{
+  struct babel_proto *p = ifa->proto;
+
+  sock *sk;
+  sk = sk_new(ifa->pool);
+  sk->type = SK_UDP;
+  sk->sport = ifa->cf->port;
+  sk->dport = ifa->cf->port;
+  sk->iface = ifa->iface;
+
+  sk->rx_hook = babel_rx_hook;
+  sk->tx_hook = babel_tx_hook;
+  sk->err_hook = babel_err_hook;
+  sk->data = ifa;
+
+  sk->tos = ifa->cf->tx_tos;
+  sk->priority = ifa->cf->tx_priority;
+  sk->ttl = 1;
+  sk->flags = SKF_LADDR_RX;
+
+  if (sk_open(sk) < 0)
+    goto err;
+
+  if (sk_setup_multicast(sk) < 0)
+    goto err;
+
+  if (sk_join_group(sk, IP6_BABEL_ROUTERS) < 0)
+    goto err;
+
+  ifa->sk = sk;
+  return 1;
+
+err:
+  sk_log_error(sk, p->p.name);
+  rfree(sk);
+  return 0;
+}
diff --git a/sysdep/autoconf.h.in b/sysdep/autoconf.h.in
index a9e46e27..c73270c3 100644
--- a/sysdep/autoconf.h.in
+++ b/sysdep/autoconf.h.in
@@ -43,6 +43,7 @@
 #undef CONFIG_BGP
 #undef CONFIG_OSPF
 #undef CONFIG_PIPE
+#undef CONFIG_BABEL
 
 /* We use multithreading */
 #undef USE_PTHREADS

From 52bae25580e6e0edae8384885818044ef89103e3 Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Fri, 29 Apr 2016 13:07:21 +0200
Subject: [PATCH 071/165] NEWS and version update

---
 NEWS            | 17 +++++++++++++++++
 misc/bird.spec  |  2 +-
 sysdep/config.h |  2 +-
 3 files changed, 19 insertions(+), 2 deletions(-)

diff --git a/NEWS b/NEWS
index f7e384b4..f689d195 100644
--- a/NEWS
+++ b/NEWS
@@ -1,3 +1,20 @@
+Version 1.6.0 (2016-04-29)
+  o Major RIP protocol redesign
+  o New Babel routing protocol
+  o BGP multipath support
+  o KRT: Add support for plenty of kernel route metrics
+  o KRT: Allow more than 256 routing tables
+  o Static: Allow to specify attributes for static routes
+  o Static: Support for BFD controlled static routes
+  o FreeBSD: Setup password for BGP MD5 authentication
+  o IO: Remove socket number limit
+  o Plenty of bug fixes
+
+  Upgrade notes:
+
+  For RIP, most protocol options were moved to interface blocks.
+
+
 Version 1.5.0 (2015-04-20)
   o Major OSPF protocol redesign.
   o OSPFv2 multi-instance extension (RFC 6549).
diff --git a/misc/bird.spec b/misc/bird.spec
index e6b699a0..857f03e5 100644
--- a/misc/bird.spec
+++ b/misc/bird.spec
@@ -1,6 +1,6 @@
 Summary: BIRD Internet Routing Daemon
 Name: bird
-Version: 1.5.0
+Version: 1.6.0
 Release: 1
 Copyright: GPL
 Group: Networking/Daemons
diff --git a/sysdep/config.h b/sysdep/config.h
index 08c15fe9..a8d58349 100644
--- a/sysdep/config.h
+++ b/sysdep/config.h
@@ -7,7 +7,7 @@
 #define _BIRD_CONFIG_H_
 
 /* BIRD version */
-#define BIRD_VERSION "1.5.0"
+#define BIRD_VERSION "1.6.0"
 
 /* Include parameters determined by configure script */
 #include "sysdep/autoconf.h"

From 1e3810f9f8e251d82a8157b39df9be196315c43e Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Fri, 29 Apr 2016 13:25:46 +0200
Subject: [PATCH 072/165] Doc: Minor fix

---
 doc/bird.sgml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc/bird.sgml b/doc/bird.sgml
index 6c6ff3db..a0b45f49 100644
--- a/doc/bird.sgml
+++ b/doc/bird.sgml
@@ -3673,9 +3673,9 @@ definition of the protocol contains mainly a list of static routes.
 	interface can be specified as a part of the address (e.g.,
 	<cf/via fe80::1234%eth0/).
 
-	<tag>route <m/prefix/ multipath via <m/ip/ [weight <m/num/] [bfd </m/switch/] [via ...]</tag>
+	<tag>route <m/prefix/ multipath via <m/ip/ [weight <m/num/] [bfd <m/switch/] [via ...]</tag>
 	Static multipath route. Contains several nexthops (gateways), possibly
- 	with their weights.
+	with their weights.
 
 	<tag>route <m/prefix/ via <m/"interface"/</tag>
 	Static device route through an interface to hosts on a directly

From f7a99acb4eac23223f51ce83b8081cc9695fef1e Mon Sep 17 00:00:00 2001
From: Pavel Tvrdik <pawel.tvrdik@gmail.com>
Date: Tue, 3 May 2016 09:32:49 +0200
Subject: [PATCH 073/165] Initialize variable ifr in sk_setup()

==00:00:00:02.831 2468== Syscall param socketcall.setsockopt(optval) points to uninitialised byte(s)
==00:00:00:02.831 2468==    at 0x513BDEA: setsockopt (in /usr/lib/libc-2.23.so)
==00:00:00:02.831 2468==    by 0x45C7AF: sk_setup (io.c:1216)
==00:00:00:02.831 2468==    by 0x45CDFF: sk_open (io.c:1417)
==00:00:00:02.831 2468==    by 0x44B562: rip_open_socket (packets.c:740)
==00:00:00:02.831 2468==    by 0x4481A7: rip_iface_locked (rip.c:616)
==00:00:00:02.831 2468==    by 0x4133E4: olock_run_event (locks.c:177)
==00:00:00:02.831 2468==    by 0x45A6DE: ev_run (event.c:85)
==00:00:00:02.831 2468==    by 0x45A7AD: ev_run_list (event.c:142)
==00:00:00:02.831 2468==    by 0x45E0FC: io_loop (io.c:2066)
==00:00:00:02.831 2468==    by 0x463B56: main (main.c:845)
==00:00:00:02.831 2468==  Address 0xffefffd24 is on thread 1's stack
==00:00:00:02.831 2468==  in frame #1, created by sk_setup (io.c:1188)
==00:00:00:02.831 2468==  Uninitialised value was created by a stack allocation
==00:00:00:02.831 2468==    at 0x45C6BB: sk_setup (io.c:1188)
---
 sysdep/unix/io.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sysdep/unix/io.c b/sysdep/unix/io.c
index d918d321..82f6c69e 100644
--- a/sysdep/unix/io.c
+++ b/sysdep/unix/io.c
@@ -1211,7 +1211,7 @@ sk_setup(sock *s)
   if (s->iface)
   {
 #ifdef SO_BINDTODEVICE
-    struct ifreq ifr;
+    struct ifreq ifr = {};
     strcpy(ifr.ifr_name, s->iface->name);
     if (setsockopt(s->fd, SOL_SOCKET, SO_BINDTODEVICE, &ifr, sizeof(ifr)) < 0)
       ERR("SO_BINDTODEVICE");

From 31e9e10144a6994773a04d94903fa3bdde6de91e Mon Sep 17 00:00:00 2001
From: Stijn Tintel <stijn@linux-ipv6.be>
Date: Tue, 10 May 2016 16:45:35 +0300
Subject: [PATCH 074/165] netlink: update struct msghdr

The netlink code assumes an order for the members of struct msghdr.
This breaks recvmsg and sendmsg with musl libc on mips64. Fix this by
using designated initializers instead.

Signed-off-by: Stijn Tintel <stijn@linux-ipv6.be>
---
 sysdep/linux/netlink.c | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/sysdep/linux/netlink.c b/sysdep/linux/netlink.c
index 1ffdff07..b42e7b6f 100644
--- a/sysdep/linux/netlink.c
+++ b/sysdep/linux/netlink.c
@@ -125,7 +125,12 @@ nl_get_reply(struct nl_sock *nl)
 	{
 	  struct iovec iov = { nl->rx_buffer, NL_RX_SIZE };
 	  struct sockaddr_nl sa;
-	  struct msghdr m = { (struct sockaddr *) &sa, sizeof(sa), &iov, 1, NULL, 0, 0 };
+	  struct msghdr m = {
+	    .msg_name = &sa,
+	    .msg_namelen = sizeof(sa),
+	    .msg_iov = &iov,
+	    .msg_iovlen = 1,
+	  };
 	  int x = recvmsg(nl->fd, &m, 0);
 	  if (x < 0)
 	    die("nl_get_reply: %m");
@@ -1231,7 +1236,12 @@ nl_async_hook(sock *sk, int size UNUSED)
 {
   struct iovec iov = { nl_async_rx_buffer, NL_RX_SIZE };
   struct sockaddr_nl sa;
-  struct msghdr m = { (struct sockaddr *) &sa, sizeof(sa), &iov, 1, NULL, 0, 0 };
+  struct msghdr m = {
+    .msg_name = &sa,
+    .msg_namelen = sizeof(sa),
+    .msg_iov = &iov,
+    .msg_iovlen = 1,
+  };
   struct nlmsghdr *h;
   int x;
   uint len;

From fff7498d6a54d4bcce4bd56db7ef3fb28be35578 Mon Sep 17 00:00:00 2001
From: Pavel Tvrdik <pawel.tvrdik@gmail.com>
Date: Thu, 12 May 2016 13:37:23 +0200
Subject: [PATCH 075/165] User Doc: Fix several typing error

---
 doc/bird.sgml | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/doc/bird.sgml b/doc/bird.sgml
index a0b45f49..014225d1 100644
--- a/doc/bird.sgml
+++ b/doc/bird.sgml
@@ -195,7 +195,7 @@ privileges (capabilities CAP_NET_*). Note that the control socket is created
 before the privileges are dropped, but the config file is read after that. The
 privilege restriction is not implemented in BSD port of BIRD.
 
-<p>A nonprivileged user (as an argument to <cf/-u/ options) may be the user
+<p>An unprivileged user (as an argument to <cf/-u/ options) may be the user
 <cf/nobody/, but it is suggested to use a new dedicated user account (like
 <cf/bird/). The similar considerations apply for the group option, but there is
 one more condition -- the users in the same group can use <file/birdc/ to
@@ -288,7 +288,7 @@ extensive way.
 a comment, whitespace characters are treated as a single space. If there's a
 variable number of options, they are grouped using the <cf/{ }/ brackets. Each
 option is terminated by a <cf/;/. Configuration is case sensitive. There are two
-ways how to name symbols (like protocol names, filter names, constats etc.). You
+ways how to name symbols (like protocol names, filter names, constants etc.). You
 can either use a simple string starting with a letter followed by any
 combination of letters and numbers (e.g. "R123", "myfilter", "bgp5") or you can
 enclose the name into apostrophes (<cf/'/) and than you can use any combination
@@ -835,7 +835,7 @@ This argument can be omitted if there exists only a single instance.
 	configuration could be either confirmed using <cf/configure confirm/
 	command, or it will be reverted to the old one when the config timer
 	expires. This is useful for cases when reconfiguration breaks current
-	routing and a router becames inaccessible for an administrator. The
+	routing and a router becomes inaccessible for an administrator. The
 	config timeout expiration is equivalent to <cf/configure undo/
 	command. The timeout duration could be specified, default is 300 s.
 
@@ -1016,7 +1016,7 @@ foot).
 	of type <cf/string/, print such variables, use standard string
 	comparison operations (e.g. <cf/=, !=, &lt;, &gt;, &lt;=, &gt;=/), but
 	you can't concatenate two strings. String literals are written as
-	<cf/"This is a string constant"/. Additionaly matching <cf/&tilde;/
+	<cf/"This is a string constant"/. Additionally matching <cf/&tilde;/
 	operator could be used to match a string value against a shell pattern
 	(represented also as a string).
 
@@ -1579,7 +1579,7 @@ protocol bfd [&lt;name&gt;] {
 
 	The session is identified by the IP address of the neighbor, with
 	optional specification of used interface and local IP. By default
-	the neighbor must be directly connected, unless the the session is
+	the neighbor must be directly connected, unless the session is
 	configured as multihop. Note that local IP must be specified for
 	multihop sessions.
 </descrip>
@@ -1622,7 +1622,7 @@ protocol bfd [&lt;name&gt;] {
 	Default: 5.
 
 	<tag>passive <m/switch/</tag>
-	Generally, both BFD session endpoinds try to establish the session by
+	Generally, both BFD session endpoints try to establish the session by
 	sending control packets to the other side. This option allows to enable
 	passive mode, which means that the router does not send BFD packets
 	until it has received one from the other side. Default: disabled.
@@ -2758,7 +2758,7 @@ protocol ospf &lt;name&gt; {
 	<tag>dead <M>num</M></tag>
 	When the router does not receive any messages from a neighbor in
 	<m/dead/ seconds, it will consider the neighbor down. If both directives
-	<cf/dead count/ and <cf/dead/ are used, <cf/dead/ has precendence.
+	<cf/dead count/ and <cf/dead/ are used, <cf/dead/ has precedence.
 
 	<tag>secondary <M>switch</M></tag>
 	On BSD systems, older versions of BIRD supported OSPFv2 only for the

From 8e433d6a529a883d566dc1d5a4afe0f1e2750baf Mon Sep 17 00:00:00 2001
From: Pavel Tvrdik <pawel.tvrdik@gmail.com>
Date: Thu, 12 May 2016 15:49:44 +0200
Subject: [PATCH 076/165] Prog Doc: Complete several missing parameters

---
 conf/cf-lex.l       | 1 +
 lib/Doc             | 2 +-
 nest/neighbor.c     | 2 +-
 nest/proto-hooks.c  | 1 +
 nest/proto.c        | 1 +
 nest/rt-attr.c      | 2 +-
 nest/rt-table.c     | 9 +++++++--
 proto/babel/Doc     | 2 +-
 proto/ospf/dbdes.c  | 1 +
 proto/ospf/lsalib.c | 3 ++-
 proto/ospf/packet.c | 2 +-
 sysdep/unix/io.c    | 1 +
 sysdep/unix/log.c   | 1 +
 13 files changed, 20 insertions(+), 8 deletions(-)

diff --git a/conf/cf-lex.l b/conf/cf-lex.l
index 5a2a4d6b..727dc017 100644
--- a/conf/cf-lex.l
+++ b/conf/cf-lex.l
@@ -575,6 +575,7 @@ cf_lex_init_kh(void)
 /**
  * cf_lex_init - initialize the lexer
  * @is_cli: true if we're going to parse CLI command, false for configuration
+ * @c: configuration structure
  *
  * cf_lex_init() initializes the lexical analyzer and prepares it for
  * parsing of a new input.
diff --git a/lib/Doc b/lib/Doc
index 8f513821..8af1c669 100644
--- a/lib/Doc
+++ b/lib/Doc
@@ -1,5 +1,5 @@
 H Library functions
-S ip.c ipv4.c ipv6.c
+S ip.c
 S lists.c
 S checksum.c bitops.c patmatch.c printf.c xmalloc.c tbf.c
 D resource.sgml
diff --git a/nest/neighbor.c b/nest/neighbor.c
index 1685d67e..d974fa51 100644
--- a/nest/neighbor.c
+++ b/nest/neighbor.c
@@ -339,7 +339,7 @@ neigh_if_link(struct iface *i)
 
 /**
  * neigh_ifa_update: notify neighbor cache about interface address add or remove event
- * @ifa: interface address in question
+ * @a: interface address in question
  *
  * Tell the neighbor cache that an address was added or removed.
  *
diff --git a/nest/proto-hooks.c b/nest/proto-hooks.c
index e80f87ea..7395b45e 100644
--- a/nest/proto-hooks.c
+++ b/nest/proto-hooks.c
@@ -148,6 +148,7 @@ void get_route_info(rte *e, byte *buf, ea_list *attrs)
  * get_attr - get attribute information
  * @a: an extended attribute
  * @buf: buffer to be filled with attribute information
+ * @buflen: a length of the @buf parameter
  *
  * The get_attr() hook is called by the core to obtain a user friendly
  * representation of an extended route attribute. It can either leave
diff --git a/nest/proto.c b/nest/proto.c
index 3e97e9da..1091b321 100644
--- a/nest/proto.c
+++ b/nest/proto.c
@@ -718,6 +718,7 @@ graceful_restart_init(void)
 
 /**
  * graceful_restart_done - finalize graceful restart
+ * @t: unused
  *
  * When there are no locks on graceful restart, the functions finalizes the
  * graceful restart recovery. Protocols postponing route export until the end of
diff --git a/nest/rt-attr.c b/nest/rt-attr.c
index 7fa05d6d..f181b452 100644
--- a/nest/rt-attr.c
+++ b/nest/rt-attr.c
@@ -405,7 +405,7 @@ ea_find(ea_list *e, unsigned id)
  * for first occurrences of attributes with ID in specified interval from @id to
  * (@id + @max - 1), returning pointers to found &eattr structures, storing its
  * walk state in @s for subsequent calls.
-
+ *
  * The function ea_walk() is supposed to be called in a loop, with initially
  * zeroed walk state structure @s with filled the initial extended attribute
  * list, returning one found attribute in each call or %NULL when no other
diff --git a/nest/rt-table.c b/nest/rt-table.c
index 57c8b8e0..c02e6dc9 100644
--- a/nest/rt-table.c
+++ b/nest/rt-table.c
@@ -717,16 +717,20 @@ rt_notify_merged(struct announce_hook *ah, net *net, rte *new_changed, rte *old_
  * @net: network in question
  * @new: the new route to be announced
  * @old: the previous route for the same network
+ * @new_best: the new best route for the same network
+ * @old_best: the previous best route for the same network
+ * @before_old: The previous route before @old for the same network.
+ * 		If @before_old is NULL @old was the first.
  *
  * This function gets a routing table update and announces it
  * to all protocols that acccepts given type of route announcement
  * and are connected to the same table by their announcement hooks.
  *
- * Route announcement of type RA_OPTIMAL si generated when optimal
+ * Route announcement of type %RA_OPTIMAL si generated when optimal
  * route (in routing table @tab) changes. In that case @old stores the
  * old optimal route.
  *
- * Route announcement of type RA_ANY si generated when any route (in
+ * Route announcement of type %RA_ANY si generated when any route (in
  * routing table @tab) changes In that case @old stores the old route
  * from the same protocol.
  *
@@ -1616,6 +1620,7 @@ rt_prune_step(rtable *tab, int *limit)
 
 /**
  * rt_prune_table - prune a routing table
+ * @tab: a routing table for pruning
  *
  * This function scans the routing table @tab and removes routes belonging to
  * flushing protocols, discarded routes and also stale network entries, in a
diff --git a/proto/babel/Doc b/proto/babel/Doc
index 2480239e..80026f91 100644
--- a/proto/babel/Doc
+++ b/proto/babel/Doc
@@ -1,2 +1,2 @@
 S babel.c
-S packet.c
+S packets.c
diff --git a/proto/ospf/dbdes.c b/proto/ospf/dbdes.c
index 65bdb3ec..195b03ad 100644
--- a/proto/ospf/dbdes.c
+++ b/proto/ospf/dbdes.c
@@ -192,6 +192,7 @@ ospf_do_send_dbdes(struct ospf_proto *p, struct ospf_neighbor *n)
 
 /**
  * ospf_send_dbdes - transmit database description packet
+ * @p: OSPF protocol instance
  * @n: neighbor
  *
  * Sending of a database description packet is described in 10.8 of RFC 2328.
diff --git a/proto/ospf/lsalib.c b/proto/ospf/lsalib.c
index 66a3a23d..1bbd1372 100644
--- a/proto/ospf/lsalib.c
+++ b/proto/ospf/lsalib.c
@@ -554,12 +554,13 @@ lsa_validate_prefix(struct ospf_lsa_header *lsa, struct ospf_lsa_prefix *body)
 /**
  * lsa_validate - check whether given LSA is valid
  * @lsa: LSA header
+ * @lsa_type: one of %LSA_T_xxx
+ * @ospf2: %true means OSPF version 2, %false means OSPF version 3
  * @body: pointer to LSA body
  *
  * Checks internal structure of given LSA body (minimal length,
  * consistency). Returns true if valid.
  */
-
 int
 lsa_validate(struct ospf_lsa_header *lsa, u32 lsa_type, int ospf2, void *body)
 {
diff --git a/proto/ospf/packet.c b/proto/ospf/packet.c
index faa33664..04f0d47c 100644
--- a/proto/ospf/packet.c
+++ b/proto/ospf/packet.c
@@ -207,7 +207,7 @@ ospf_pkt_checkauth(struct ospf_neighbor *n, struct ospf_iface *ifa, struct ospf_
 /**
  * ospf_rx_hook
  * @sk: socket we received the packet.
- * @size: size of the packet
+ * @len: size of the packet
  *
  * This is the entry point for messages from neighbors. Many checks (like
  * authentication, checksums, size) are done before the packet is passed to
diff --git a/sysdep/unix/io.c b/sysdep/unix/io.c
index 82f6c69e..486319ff 100644
--- a/sysdep/unix/io.c
+++ b/sysdep/unix/io.c
@@ -448,6 +448,7 @@ tm_format_reltime(char *x, struct tm *tm, bird_clock_t delta)
 /**
  * tm_format_datetime - convert date and time to textual representation
  * @x: destination buffer of size %TM_DATETIME_BUFFER_SIZE
+ * @fmt_spec: specification of resulting textual representation of the time
  * @t: time
  *
  * This function formats the given relative time value @t to a textual
diff --git a/sysdep/unix/log.c b/sysdep/unix/log.c
index b90bbbd2..6665d035 100644
--- a/sysdep/unix/log.c
+++ b/sysdep/unix/log.c
@@ -89,6 +89,7 @@ static char *class_names[] = {
 /**
  * log_commit - commit a log message
  * @class: message class information (%L_DEBUG to %L_BUG, see |lib/birdlib.h|)
+ * @buf: message to write
  *
  * This function writes a message prepared in the log buffer to the
  * log file (as specified in the configuration). The log buffer is

From 3f2c7600fa2e35b1028c755aa06092b5991e1a8e Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Thu, 12 May 2016 21:29:04 +0200
Subject: [PATCH 077/165] We don't need bvsnprintf() in BIRD client

---
 client/birdc.c    |  2 +-
 client/birdcl.c   |  7 ++++---
 client/client.c   | 29 ++++++++---------------------
 client/client.h   |  3 +++
 client/commands.c |  4 ++--
 client/util.c     |  7 +++++--
 6 files changed, 23 insertions(+), 29 deletions(-)

diff --git a/client/birdc.c b/client/birdc.c
index ccf758be..8aa01c17 100644
--- a/client/birdc.c
+++ b/client/birdc.c
@@ -153,7 +153,7 @@ input_init(void)
 
   // readline library does strange things when stdin is nonblocking.
   // if (fcntl(0, F_SETFL, O_NONBLOCK) < 0)
-  //   die("fcntl: %m");
+  //   DIE("fcntl");
 }
 
 static void
diff --git a/client/birdcl.c b/client/birdcl.c
index 2d5e1067..7b567a9f 100644
--- a/client/birdcl.c
+++ b/client/birdcl.c
@@ -11,6 +11,7 @@
 #include <stdlib.h>
 #include <unistd.h>
 #include <termios.h>
+#include <errno.h>
 
 #include <sys/ioctl.h>
 #include <signal.h>
@@ -109,7 +110,7 @@ more_begin(void)
   tty.c_lflag &= (~ICANON);
 
   if (tcsetattr (0, TCSANOW, &tty) < 0)
-    die("tcsetattr: %m");
+    DIE("tcsetattr");
 
   more_active = 1;
 }
@@ -120,7 +121,7 @@ more_end(void)
   more_active = 0;
 
   if (tcsetattr (0, TCSANOW, &stored_tty) < 0)
-    die("tcsetattr: %m");
+    DIE("tcsetattr");
 }
 
 static void
@@ -137,7 +138,7 @@ input_init(void)
     return;
 
   if (tcgetattr(0, &stored_tty) < 0)
-    die("tcgetattr: %m");
+    DIE("tcgetattr");
 
   if (signal(SIGINT, sig_handler) == SIG_IGN)
     signal(SIGINT, SIG_IGN);
diff --git a/client/client.c b/client/client.c
index 4075b9e6..0d4bdf3e 100644
--- a/client/client.c
+++ b/client/client.c
@@ -248,7 +248,7 @@ server_connect(void)
 
   server_fd = socket(AF_UNIX, SOCK_STREAM, 0);
   if (server_fd < 0)
-    die("Cannot create socket: %m");
+    DIE("Cannot create socket");
 
   if (strlen(server_path) >= sizeof(sa.sun_path))
     die("server_connect: path too long");
@@ -257,9 +257,9 @@ server_connect(void)
   sa.sun_family = AF_UNIX;
   strcpy(sa.sun_path, server_path);
   if (connect(server_fd, (struct sockaddr *) &sa, SUN_LEN(&sa)) < 0)
-    die("Unable to connect to server control socket (%s): %m", server_path);
+    DIE("Unable to connect to server control socket (%s)", server_path);
   if (fcntl(server_fd, F_SETFL, O_NONBLOCK) < 0)
-    die("fcntl: %m");
+    DIE("fcntl");
 }
 
 
@@ -309,13 +309,13 @@ server_read(void)
  redo:
   c = read(server_fd, server_read_pos, server_read_buf + sizeof(server_read_buf) - server_read_pos);
   if (!c)
-    die("Connection closed by server.");
+    die("Connection closed by server");
   if (c < 0)
     {
       if (errno == EINTR)
 	goto redo;
       else
-	die("Server read error: %m");
+	DIE("Server read error");
     }
 
   start = server_read_buf;
@@ -366,7 +366,7 @@ select_loop(void)
 	  if (errno == EINTR)
 	    continue;
 	  else
-	    die("select: %m");
+	    DIE("select");
 	}
 
       if (FD_ISSET(0, &select_fds))
@@ -399,7 +399,7 @@ wait_for_write(int fd)
 	  if (errno == EINTR)
 	    continue;
 	  else
-	    die("select: %m");
+	    DIE("select");
 	}
 
       if (FD_ISSET(server_fd, &set))
@@ -426,7 +426,7 @@ server_send(char *cmd)
 	  else if (errno == EINTR)
 	    continue;
 	  else
-	    die("Server write error: %m");
+	    DIE("Server write error");
 	}
       else
 	{
@@ -436,19 +436,6 @@ server_send(char *cmd)
     }
 }
 
-
-/* XXXX
-
-      get_term_size();
-
-      if (tcgetattr(0, &tty_save) != 0)
-        {
-          perror("tcgetattr error");
-          return(EXIT_FAILURE);
-        }
-    }
-
- */
 int
 main(int argc, char **argv)
 {
diff --git a/client/client.h b/client/client.h
index b194a772..f9693def 100644
--- a/client/client.h
+++ b/client/client.h
@@ -34,3 +34,6 @@ char *cmd_expand(char *cmd);
 /* client.c */
 
 void submit_command(char *cmd_raw);
+
+/* die() with system error messages */
+#define DIE(x, y...) die(x ": %s", ##y, strerror(errno))
diff --git a/client/commands.c b/client/commands.c
index 226ae048..2dae23e1 100644
--- a/client/commands.c
+++ b/client/commands.c
@@ -60,7 +60,7 @@ cmd_build_tree(void)
 	  if (!new)
 	    {
 	      int size = sizeof(struct cmd_node) + c-d;
-	      new = xmalloc(size);
+	      new = malloc(size);
 	      bzero(new, size);
 	      *old->plastson = new;
 	      old->plastson = &new->sibling;
@@ -314,7 +314,7 @@ cmd_expand(char *cmd)
       puts("No such command. Press `?' for help.");
       return NULL;
     }
-  b = xmalloc(strlen(n->cmd->command) + strlen(args) + 1);
+  b = malloc(strlen(n->cmd->command) + strlen(args) + 1);
   sprintf(b, "%s%s", n->cmd->command, args);
   return b;
 }
diff --git a/client/util.c b/client/util.c
index 050224b9..c35cf8f4 100644
--- a/client/util.c
+++ b/client/util.c
@@ -21,8 +21,11 @@ vlog(const char *msg, va_list args)
 {
   char buf[1024];
 
-  if (bvsnprintf(buf, sizeof(buf)-1, msg, args) < 0)
-    bsprintf(buf + sizeof(buf) - 100, " ... <too long>");
+  int n = vsnprintf(buf, sizeof(buf), msg, args);
+  if (n < 0)
+    snprintf(buf, sizeof(buf), "???");
+  if (n >= sizeof(buf))
+    snprintf(buf + sizeof(buf) - 100, 100, " ... <too long>");
   fputs(buf, stderr);
   fputc('\n', stderr);
 }

From 9dbcb11cb50167e959536e5a564ee9aafae509c6 Mon Sep 17 00:00:00 2001
From: Jan Moskyto Matejka <mq@ucw.cz>
Date: Mon, 30 May 2016 14:28:22 +0200
Subject: [PATCH 078/165] Unix IO: Tried to fix strange behavior after POLLHUP
 or POLLERR.

---
 sysdep/unix/io.c | 29 ++++++++++++++++++++++++++---
 1 file changed, 26 insertions(+), 3 deletions(-)

diff --git a/sysdep/unix/io.c b/sysdep/unix/io.c
index 486319ff..8198743d 100644
--- a/sysdep/unix/io.c
+++ b/sysdep/unix/io.c
@@ -1853,6 +1853,20 @@ sk_write(sock *s)
   }
 }
 
+void
+sk_err(sock *s, int revents)
+{
+  int se = 0, sse = sizeof(se);
+  if (revents & POLLERR)
+    if (getsockopt(s->fd, SOL_SOCKET, SO_ERROR, &se, &sse) < 0)
+    {
+      log(L_ERR "IO: Socket error: SO_ERROR: %m");
+      se = 0;
+    }
+
+  s->err_hook(s, se);
+}
+
 void
 sk_dump_all(void)
 {
@@ -2163,7 +2177,7 @@ io_loop(void)
 	      int steps;
 
 	      steps = MAX_STEPS;
-	      if (s->fast_rx && (pfd[s->index].revents & (POLLIN | POLLHUP | POLLERR)) && s->rx_hook)
+	      if (s->fast_rx && (pfd[s->index].revents & POLLIN) && s->rx_hook)
 		do
 		  {
 		    steps--;
@@ -2185,6 +2199,7 @@ io_loop(void)
 		      goto next;
 		  }
 		while (e && steps);
+
 	      current_sock = sk_next(s);
 	    next: ;
 	    }
@@ -2208,18 +2223,26 @@ io_loop(void)
 		  goto next2;
 		}
 
-	      if (!s->fast_rx && (pfd[s->index].revents & (POLLIN | POLLHUP | POLLERR)) && s->rx_hook)
+	      if (!s->fast_rx && (pfd[s->index].revents & POLLIN) && s->rx_hook)
 		{
 		  count++;
 		  io_log_event(s->rx_hook, s->data);
 		  sk_read(s, pfd[s->index].revents);
 		  if (s != current_sock)
-		      goto next2;
+		    goto next2;
+		}
+
+	      if (pfd[s->index].revents & (POLLHUP | POLLERR))
+		{
+		  sk_err(s, pfd[s->index].revents);
+		    goto next2;
 		}
+
 	      current_sock = sk_next(s);
 	    next2: ;
 	    }
 
+
 	  stored_sock = current_sock;
 	}
     }

From 90dc0f08434323535f84d64e113dae84675c46b2 Mon Sep 17 00:00:00 2001
From: Ondrej Filip <feela@network.cz>
Date: Sat, 4 Jun 2016 12:38:06 +0200
Subject: [PATCH 079/165] Small typo in documentation example, submitted by
 Felix Eckhofer.

---
 doc/bird.sgml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/bird.sgml b/doc/bird.sgml
index 014225d1..f3c34a14 100644
--- a/doc/bird.sgml
+++ b/doc/bird.sgml
@@ -1035,7 +1035,7 @@ foot).
 	or <cf><m>ipaddress</m>/<m>netmask</m></cf>. There are two special
 	operators on prefixes: <cf/.ip/ which extracts the IP address from the
 	pair, and <cf/.len/, which separates prefix length from the pair.
-	So <cf>1.2.0.0/16.pxlen = 16</cf> is true.
+	So <cf>1.2.0.0/16.len = 16</cf> is true.
 
 	<tag/ec/
 	This is a specialized type used to represent BGP extended community

From a0fe1944d12771d60986a352552e5f4b306e5f7f Mon Sep 17 00:00:00 2001
From: Ondrej Filip <feela@network.cz>
Date: Wed, 8 Jun 2016 16:22:44 +0200
Subject: [PATCH 080/165] Add AS# ranges to bgpmask.

---
 doc/bird.sgml    |  6 ++++--
 filter/config.Y  |  1 +
 filter/filter.c  |  4 ++++
 filter/test.conf |  9 ++++++---
 nest/a-path.c    | 26 ++++++++++++++++++--------
 nest/attrs.h     |  2 ++
 6 files changed, 35 insertions(+), 13 deletions(-)

diff --git a/doc/bird.sgml b/doc/bird.sgml
index f3c34a14..de7041a9 100644
--- a/doc/bird.sgml
+++ b/doc/bird.sgml
@@ -1165,8 +1165,10 @@ foot).
  	is 4 3 2 1, then: <tt>bgp_path &tilde; [= * 4 3 * =]</tt> is true,
 	but <tt>bgp_path &tilde; [= * 4 5 * =]</tt> is false. BGP mask
 	expressions can also contain integer expressions enclosed in parenthesis
-	and integer variables, for example <tt>[= * 4 (1+2) a =]</tt>. There is
-	also old syntax that uses / .. / instead of [= .. =] and ? instead of *.
+	and integer variables, for example <tt>[= * 4 (1+2) a =]</tt>. You can
+        also use ranges, for example <tt>[= * 3..5 2 100..200 * =]</tt>.
+        There is also old (deprecated) syntax that uses / .. / instead of [= .. =]
+        and ? instead of *.
 
 	<tag/clist/
 	Clist is similar to a set, except that unlike other sets, it can be
diff --git a/filter/config.Y b/filter/config.Y
index b94f5dff..e53d8def 100644
--- a/filter/config.Y
+++ b/filter/config.Y
@@ -627,6 +627,7 @@ bgp_path:
 
 bgp_path_tail1:
    NUM bgp_path_tail1 { $$ = cfg_alloc(sizeof(struct f_path_mask)); $$->next = $2; $$->kind = PM_ASN;      $$->val = $1; }
+ | NUM DDOT NUM bgp_path_tail1 { $$ = cfg_alloc(sizeof(struct f_path_mask)); $$->next = $4; $$->kind = PM_ASN_RANGE;      $$->val = $1; $$->val2 = $3; }
  | '*' bgp_path_tail1 { $$ = cfg_alloc(sizeof(struct f_path_mask)); $$->next = $2; $$->kind = PM_ASTERISK; $$->val  = 0; }
  | '?' bgp_path_tail1 { $$ = cfg_alloc(sizeof(struct f_path_mask)); $$->next = $2; $$->kind = PM_QUESTION; $$->val  = 0; }
  | bgp_path_expr bgp_path_tail1 { $$ = cfg_alloc(sizeof(struct f_path_mask)); $$->next = $2; $$->kind = PM_ASN_EXPR; $$->val = (uintptr_t) $1; }
diff --git a/filter/filter.c b/filter/filter.c
index eddf4228..dce98e4d 100644
--- a/filter/filter.c
+++ b/filter/filter.c
@@ -79,6 +79,10 @@ pm_format(struct f_path_mask *p, buffer *buf)
       buffer_puts(buf, "* ");
       break;
 
+    case PM_ASN_RANGE:
+      buffer_print(buf, "%u..%u ", p->val, p->val2);
+      break;
+
     case PM_ASN_EXPR:
       buffer_print(buf, "%u ", f_eval_asn((struct f_inst *) p->val));
       break;
diff --git a/filter/test.conf b/filter/test.conf
index a99d0a51..ad8f9386 100644
--- a/filter/test.conf
+++ b/filter/test.conf
@@ -90,20 +90,23 @@ clist l2;
 eclist el;
 eclist el2;
 {
+	print "Entering path test...";
 	pm1 =  / 4 3 2 1 /;
-	pm2 = [= 4 3 2 1 =];
+	pm2 = [= 3..6 3 2 1..2 =];
 	print "Testing path masks: ", pm1, " ", pm2;
 	p2 = prepend( + empty +, 1 );
 	p2 = prepend( p2, 2 );
 	p2 = prepend( p2, 3 );
 	p2 = prepend( p2, 4 );
-	print "Testing paths: ", p2;
+	print "Testing path: (4 3 2 1) = ", p2;
 	print "Should be true: ", p2 ~ pm1, " ", p2 ~ pm2, " ", 3 ~ p2, " ", p2 ~ [2, 10..20], " ", p2 ~ [4, 10..20];
 	print "4 = ", p2.len;
 	p2 = prepend( p2, 5 );
-	print "Should be false: ", p2 ~ pm1, " ", p2 ~ pm2, " ", 10 ~ p2, " ", p2 ~ [8, ten..(2*ten)];
+	print "Testing path: (5 4 3 2 1) = ", p2;
+	print "Should be false: ", p2 ~ pm1, " ", p2 ~ pm2, " ", 10 ~ p2, " ", p2 ~ [8, ten..(2*ten)], " ", p2 ~ [= 1..4 4 3 2 1 =], " ",  p2 ~ [= 5 4 4..100 2 1 =];
 	print "Should be true: ", p2 ~  / ? 4 3 2 1 /,  " ", p2, " ",  / ? 4 3 2 1 /;
 	print "Should be true: ", p2 ~ [= * 4 3 * 1 =], " ", p2, " ", [= * 4 3 * 1 =];
+	print "Should be true: ", p2 ~ [= 5..6 4..10 1..3 1..3 1..65536 =];
 	print "Should be true: ", p2 ~ [= (3+2) (2*2) 3 2 1 =], " ", p2 ~ mkpath(5, 4);
 	print "Should be true: ", p2.len = 5, " ", p2.first = 5, " ", p2.last = 1;
 	print "5 = ", p2.len;
diff --git a/nest/a-path.c b/nest/a-path.c
index 32e2d27e..e1031b7b 100644
--- a/nest/a-path.c
+++ b/nest/a-path.c
@@ -435,18 +435,23 @@ parse_path(struct adata *path, struct pm_pos *pos)
 
 
 static int
-pm_match(struct pm_pos *pos, u32 asn)
+pm_match(struct pm_pos *pos, u32 asn, u32 asn2)
 {
+  u32 gas;
   if (! pos->set)
-    return pos->val.asn == asn;
+    return ((pos->val.asn >= asn) && (pos->val.asn <= asn2));
 
   u8 *p = pos->val.sp;
   int len = *p++;
   int i;
 
   for (i = 0; i < len; i++)
-    if (get_as(p + i * BS) == asn)
+  {
+    gas = get_as(p + i * BS);
+
+    if ((gas >= asn) && (gas <= asn2))
       return 1;
+  }
 
   return 0;
 }
@@ -490,7 +495,7 @@ pm_mark(struct pm_pos *pos, int i, int plen, int *nl, int *nh)
  * next part of mask, we advance each marked state.
  * We start with marked first position, when we
  * run out of marked positions, we reject. When
- * we process the whole mask, we accept iff final position
+ * we process the whole mask, we accept if final position
  * (auxiliary position after last real position in AS path)
  * is marked.
  */
@@ -502,6 +507,7 @@ as_path_match(struct adata *path, struct f_path_mask *mask)
   int plen = parse_path(path, pos);
   int l, h, i, nh, nl;
   u32 val = 0;
+  u32 val2 = 0;
 
   /* l and h are bound of interval of positions where
      are marked states */
@@ -525,12 +531,16 @@ as_path_match(struct adata *path, struct f_path_mask *mask)
 	  h = plen;
 	  break;
 
-	case PM_ASN:
-	  val = mask->val;
+	case PM_ASN:	/* Define single ASN as ASN..ASN - very narrow interval */
+	  val2 = val = mask->val;
 	  goto step;
 	case PM_ASN_EXPR:
-	  val = f_eval_asn((struct f_inst *) mask->val);
+	  val2 = val = f_eval_asn((struct f_inst *) mask->val);
 	  goto step;
+	case PM_ASN_RANGE:
+	  val = mask->val;
+	  val2 = mask->val2;
+          goto step;
 	case PM_QUESTION:
 	step:
 	  nh = nl = -1;
@@ -538,7 +548,7 @@ as_path_match(struct adata *path, struct f_path_mask *mask)
 	    if (pos[i].mark)
 	      {
 		pos[i].mark = 0;
-		if ((mask->kind == PM_QUESTION) || pm_match(pos + i, val))
+		if ((mask->kind == PM_QUESTION) || pm_match(pos + i, val, val2))
 		  pm_mark(pos, i, plen, &nl, &nh);
 	      }
 
diff --git a/nest/attrs.h b/nest/attrs.h
index 0171c6a8..670b048f 100644
--- a/nest/attrs.h
+++ b/nest/attrs.h
@@ -45,11 +45,13 @@ struct adata *as_path_filter(struct linpool *pool, struct adata *path, struct f_
 #define PM_QUESTION	1
 #define PM_ASTERISK	2
 #define PM_ASN_EXPR	3
+#define PM_ASN_RANGE	4
 
 struct f_path_mask {
   struct f_path_mask *next;
   int kind;
   uintptr_t val;
+  uintptr_t val2;
 };
 
 int as_path_match(struct adata *path, struct f_path_mask *mask);

From 122deb6d5b14f46f3cfb25bf3f5726005d6a3b3e Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Thu, 9 Jun 2016 00:30:41 +0200
Subject: [PATCH 081/165] Filters: Fixes pm_same() w.r.t. ASN ranges and ASN
 expressions

This is necessary for proper detection of filter changes during
reconfigurations.
---
 filter/config.Y  | 16 ++++++++--------
 filter/filter.c  | 17 ++++++++++++++---
 filter/test.conf |  3 +++
 3 files changed, 25 insertions(+), 11 deletions(-)

diff --git a/filter/config.Y b/filter/config.Y
index e53d8def..da605710 100644
--- a/filter/config.Y
+++ b/filter/config.Y
@@ -626,17 +626,17 @@ bgp_path:
  ;
 
 bgp_path_tail1:
-   NUM bgp_path_tail1 { $$ = cfg_alloc(sizeof(struct f_path_mask)); $$->next = $2; $$->kind = PM_ASN;      $$->val = $1; }
- | NUM DDOT NUM bgp_path_tail1 { $$ = cfg_alloc(sizeof(struct f_path_mask)); $$->next = $4; $$->kind = PM_ASN_RANGE;      $$->val = $1; $$->val2 = $3; }
- | '*' bgp_path_tail1 { $$ = cfg_alloc(sizeof(struct f_path_mask)); $$->next = $2; $$->kind = PM_ASTERISK; $$->val  = 0; }
- | '?' bgp_path_tail1 { $$ = cfg_alloc(sizeof(struct f_path_mask)); $$->next = $2; $$->kind = PM_QUESTION; $$->val  = 0; }
- | bgp_path_expr bgp_path_tail1 { $$ = cfg_alloc(sizeof(struct f_path_mask)); $$->next = $2; $$->kind = PM_ASN_EXPR; $$->val = (uintptr_t) $1; }
- |  		      { $$ = NULL; }
+   NUM bgp_path_tail1		{ $$ = cfg_allocz(sizeof(struct f_path_mask)); $$->next = $2; $$->kind = PM_ASN; $$->val = $1; }
+ | NUM DDOT NUM bgp_path_tail1	{ $$ = cfg_allocz(sizeof(struct f_path_mask)); $$->next = $4; $$->kind = PM_ASN_RANGE; $$->val = $1; $$->val2 = $3; }
+ | '*' bgp_path_tail1		{ $$ = cfg_allocz(sizeof(struct f_path_mask)); $$->next = $2; $$->kind = PM_ASTERISK; }
+ | '?' bgp_path_tail1		{ $$ = cfg_allocz(sizeof(struct f_path_mask)); $$->next = $2; $$->kind = PM_QUESTION; }
+ | bgp_path_expr bgp_path_tail1	{ $$ = cfg_allocz(sizeof(struct f_path_mask)); $$->next = $2; $$->kind = PM_ASN_EXPR; $$->val = (uintptr_t) $1; }
+ | 				{ $$ = NULL; }
  ;
 
 bgp_path_tail2:
-   NUM bgp_path_tail2 { $$ = cfg_alloc(sizeof(struct f_path_mask)); $$->next = $2; $$->kind = PM_ASN;      $$->val = $1; }
- | '?' bgp_path_tail2 { $$ = cfg_alloc(sizeof(struct f_path_mask)); $$->next = $2; $$->kind = PM_ASTERISK; $$->val  = 0; }
+   NUM bgp_path_tail2 { $$ = cfg_allocz(sizeof(struct f_path_mask)); $$->next = $2; $$->kind = PM_ASN; $$->val = $1; }
+ | '?' bgp_path_tail2 { $$ = cfg_allocz(sizeof(struct f_path_mask)); $$->next = $2; $$->kind = PM_ASTERISK; }
  | 		      { $$ = NULL; }
  ;
 
diff --git a/filter/filter.c b/filter/filter.c
index dce98e4d..c61377b7 100644
--- a/filter/filter.c
+++ b/filter/filter.c
@@ -163,13 +163,24 @@ val_compare(struct f_val v1, struct f_val v2)
 }
 
 static int
-pm_path_same(struct f_path_mask *m1, struct f_path_mask *m2)
+pm_same(struct f_path_mask *m1, struct f_path_mask *m2)
 {
   while (m1 && m2)
   {
-    if ((m1->kind != m2->kind) || (m1->val != m2->val))
+    if (m1->kind != m2->kind)
       return 0;
 
+    if (m1->kind == PM_ASN_EXPR)
+    {
+      if (!i_same((struct f_inst *) m1->val, (struct f_inst *) m2->val))
+	return 0;
+    }
+    else
+    {
+      if ((m1->val != m2->val) || (m1->val2 != m2->val2))
+	return 0;
+    }
+
     m1 = m1->next;
     m2 = m2->next;
   }
@@ -199,7 +210,7 @@ val_same(struct f_val v1, struct f_val v2)
 
   switch (v1.type) {
   case T_PATH_MASK:
-    return pm_path_same(v1.val.path_mask, v2.val.path_mask);
+    return pm_same(v1.val.path_mask, v2.val.path_mask);
   case T_PATH:
   case T_CLIST:
   case T_ECLIST:
diff --git a/filter/test.conf b/filter/test.conf
index ad8f9386..f61f0658 100644
--- a/filter/test.conf
+++ b/filter/test.conf
@@ -109,6 +109,9 @@ eclist el2;
 	print "Should be true: ", p2 ~ [= 5..6 4..10 1..3 1..3 1..65536 =];
 	print "Should be true: ", p2 ~ [= (3+2) (2*2) 3 2 1 =], " ", p2 ~ mkpath(5, 4);
 	print "Should be true: ", p2.len = 5, " ", p2.first = 5, " ", p2.last = 1;
+	print "Should be true: ", pm1 = [= 4 3 2 1 =], " ", pm1 != [= 4 3 1 2 =], " ",
+				pm2 = [= 3..6 3 2 1..2 =], " ", pm2 != [= 3..6 3 2 1..3 =], " ",
+				[= 1 2 (1+2) =] = [= 1 2 (1+2) =], " ", [= 1 2 (1+2) =] != [= 1 2 (2+1) =];
 	print "5 = ", p2.len;
 	print "Delete 3:   ", delete(p2, 3);
 	print "Filter 1-3: ", filter(p2, [1..3]);

From 8f01879c5629bd714dfeec968337cfcd4dbe6a87 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pavel=20Tvrd=C3=ADk?= <pawel.tvrdik@gmail.com>
Date: Tue, 29 Mar 2016 10:37:31 +0200
Subject: [PATCH 082/165] cppcheck: fix va_end() functions

---
 client/util.c     | 2 ++
 conf/conf.c       | 1 +
 sysdep/unix/log.c | 2 ++
 3 files changed, 5 insertions(+)

diff --git a/client/util.c b/client/util.c
index c35cf8f4..2d6c074d 100644
--- a/client/util.c
+++ b/client/util.c
@@ -40,6 +40,7 @@ bug(const char *msg, ...)
   fputs("Internal error: ", stderr);
   vlog(msg, args);
   vfprintf(stderr, msg, args);
+  va_end(args);
   exit(1);
 }
 
@@ -51,5 +52,6 @@ die(const char *msg, ...)
   va_start(args, msg);
   cleanup();
   vlog(msg, args);
+  va_end(args);
   exit(1);
 }
diff --git a/conf/conf.c b/conf/conf.c
index 825a8e9f..efaeedeb 100644
--- a/conf/conf.c
+++ b/conf/conf.c
@@ -512,6 +512,7 @@ cf_error(char *msg, ...)
   va_start(args, msg);
   if (bvsnprintf(buf, sizeof(buf), msg, args) < 0)
     strcpy(buf, "<bug: error message too long>");
+  va_end(args);
   new_config->err_msg = cfg_strdup(buf);
   new_config->err_lino = ifs->lino;
   new_config->err_file_name = ifs->file_name;
diff --git a/sysdep/unix/log.c b/sysdep/unix/log.c
index 6665d035..631bd691 100644
--- a/sysdep/unix/log.c
+++ b/sysdep/unix/log.c
@@ -209,6 +209,7 @@ bug(const char *msg, ...)
 
   va_start(args, msg);
   vlog(L_BUG[0], msg, args);
+  va_end(args);
   abort();
 }
 
@@ -226,6 +227,7 @@ die(const char *msg, ...)
 
   va_start(args, msg);
   vlog(L_FATAL[0], msg, args);
+  va_end(args);
   exit(1);
 }
 

From 775a5a81958e66a69663803dd2e731e3800da9e7 Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Wed, 29 Jun 2016 14:11:03 +0200
Subject: [PATCH 083/165] BGP: Skip empty path segments in received AS_PATH

Although RFC 4271 does not forbid empty path segments, they are useless
and some implementations consider them invalid. It is clarified in RFC 7606,
specifying that AS_PATH with empty segment is considered malformed.
---
 proto/bgp/attrs.c | 24 +++++++++++++-----------
 1 file changed, 13 insertions(+), 11 deletions(-)

diff --git a/proto/bgp/attrs.c b/proto/bgp/attrs.c
index d85afa8f..b8371f32 100644
--- a/proto/bgp/attrs.c
+++ b/proto/bgp/attrs.c
@@ -118,7 +118,7 @@ validate_path(struct bgp_proto *p, int as_path, int bs, byte *idata, uint *ileng
 {
   int res = 0;
   u8 *a, *dst;
-  int len, plen, copy;
+  int len, plen;
 
   dst = a = idata;
   len = *ilength;
@@ -132,15 +132,20 @@ validate_path(struct bgp_proto *p, int as_path, int bs, byte *idata, uint *ileng
       if (len < plen)
 	return -1;
 
+      if (a[1] == 0)
+        {
+	  log(L_WARN "%s: %s_PATH attribute contains empty segment, skipping it",
+	      p->p.name, as_path ? "AS" : "AS4");
+	  goto skip;
+	}
+
       switch (a[0])
 	{
 	case AS_PATH_SET:
-	  copy = 1;
 	  res++;
 	  break;
 
 	case AS_PATH_SEQUENCE:
-	  copy = 1;
 	  res += a[1];
 	  break;
 
@@ -154,20 +159,17 @@ validate_path(struct bgp_proto *p, int as_path, int bs, byte *idata, uint *ileng
 
 	  log(L_WARN "%s: %s_PATH attribute contains AS_CONFED_* segment, skipping segment",
 	      p->p.name, as_path ? "AS" : "AS4");
-	  copy = 0;
-	  break;
+	  goto skip;
 
 	default:
 	  return -1;
 	}
 
-      if (copy)
-	{
-	  if (dst != a)
-	    memmove(dst, a, plen);
-	  dst += plen;
-	}
+      if (dst != a)
+	memmove(dst, a, plen);
+      dst += plen;
 
+    skip:
       len -= plen;
       a += plen;
     }

From f1f39bb9d8e2260fe181240dd8194b06bdcfb54f Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Fri, 1 Jul 2016 11:03:13 +0200
Subject: [PATCH 084/165] Filter: Fixes reconfiguration with last_nonaggregated
 operator

---
 filter/filter.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/filter/filter.c b/filter/filter.c
index c61377b7..30571e5a 100644
--- a/filter/filter.c
+++ b/filter/filter.c
@@ -1461,7 +1461,8 @@ i_same(struct f_inst *f1, struct f_inst *f2)
   case P('A','p'): TWOARGS; break;
   case P('C','a'): TWOARGS; break;
   case P('a','f'):
-  case P('a','l'): ONEARG; break;
+  case P('a','l'):
+  case P('a','L'): ONEARG; break;
   case P('R','C'):
     TWOARGS;
     /* Does not really make sense - ROA check resuls may change anyway */

From f0b822a831d0f0f593bbedf0a7f15b94c3ca1d43 Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Mon, 11 Jul 2016 20:22:55 +0200
Subject: [PATCH 085/165] Log: Fix error handling of debug file open

Logging is not yet initialized, we have to use fprintf() here.

Thanks to Pavel Tvrdik for noticing and debugging it.
---
 sysdep/unix/log.c | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/sysdep/unix/log.c b/sysdep/unix/log.c
index 631bd691..1fd64426 100644
--- a/sysdep/unix/log.c
+++ b/sysdep/unix/log.c
@@ -20,6 +20,7 @@
 #include <stdarg.h>
 #include <time.h>
 #include <unistd.h>
+#include <errno.h>
 
 #include "nest/bird.h"
 #include "nest/cli.h"
@@ -314,7 +315,11 @@ log_init_debug(char *f)
   else if (!*f)
     dbgf = stderr;
   else if (!(dbgf = fopen(f, "a")))
-    log(L_ERR "Error opening debug file `%s': %m", f);
+  {
+    /* Cannot use die() nor log() here, logging is not yet initialized */
+    fprintf(stderr, "bird: Unable to open debug file %s: %s\n", f, strerror(errno));
+    exit(1);
+  }
   if (dbgf)
     setvbuf(dbgf, NULL, _IONBF, 0);
 }

From ea0cb652e91d871e7808e93aa15ef34fc453c4fc Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Mon, 11 Jul 2016 20:41:32 +0200
Subject: [PATCH 086/165] BGP: Fix extended messages

Change attribute length limit to handle extended (64 kB) messages.

Do not mix updates and withdraws (RFC 7606).
---
 proto/bgp/packets.c | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/proto/bgp/packets.c b/proto/bgp/packets.c
index 72ca3728..0cf38edf 100644
--- a/proto/bgp/packets.c
+++ b/proto/bgp/packets.c
@@ -369,7 +369,7 @@ bgp_create_update(struct bgp_conn *conn, byte *buf)
     }
   put_u16(buf, wd_size);
 
-  if (remains >= 3072)
+  if (!wd_size)
     {
       while ((buck = (struct bgp_bucket *) HEAD(p->bucket_queue))->send_node.next)
 	{
@@ -382,7 +382,7 @@ bgp_create_update(struct bgp_conn *conn, byte *buf)
 	    }
 
 	  DBG("Processing bucket %p\n", buck);
-	  a_size = bgp_encode_attrs(p, w+2, buck->eattrs, 2048);
+	  a_size = bgp_encode_attrs(p, w+2, buck->eattrs, remains - 1024);
 
 	  if (a_size < 0)
 	    {
@@ -461,8 +461,7 @@ bgp_create_update(struct bgp_conn *conn, byte *buf)
       w += size;
       remains -= size;
     }
-
-  if (remains >= 3072)
+  else
     {
       while ((buck = (struct bgp_bucket *) HEAD(p->bucket_queue))->send_node.next)
 	{
@@ -478,7 +477,7 @@ bgp_create_update(struct bgp_conn *conn, byte *buf)
 	  rem_stored = remains;
 	  w_stored = w;
 
-	  size = bgp_encode_attrs(p, w, buck->eattrs, 2048);
+	  size = bgp_encode_attrs(p, w, buck->eattrs, remains - 1024);
 	  if (size < 0)
 	    {
 	      log(L_ERR "%s: Attribute list too long, skipping corresponding routes", p->p.name);

From 6887f409f0766c60dd8c3d3fdf01a1d989c090a5 Mon Sep 17 00:00:00 2001
From: Ondrej Filip <feela@network.cz>
Date: Sun, 17 Jul 2016 14:54:52 +0200
Subject: [PATCH 087/165] Prepare for longer interface names - clean up of the
 code.

---
 nest/rt-table.c | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/nest/rt-table.c b/nest/rt-table.c
index c02e6dc9..50c01c88 100644
--- a/nest/rt-table.c
+++ b/nest/rt-table.c
@@ -50,7 +50,7 @@ static linpool *rte_update_pool;
 
 static list routing_tables;
 
-static void rt_format_via(rte *e, byte *via);
+static byte *rt_format_via(rte *e);
 static void rt_free_hostcache(rtable *tab);
 static void rt_notify_hostcache(rtable *tab, net *net);
 static void rt_update_hostcache(rtable *tab);
@@ -227,10 +227,7 @@ rte_mergable(rte *pri, rte *sec)
 static void
 rte_trace(struct proto *p, rte *e, int dir, char *msg)
 {
-  byte via[STD_ADDRESS_P_LENGTH+32];
-
-  rt_format_via(e, via);
-  log(L_TRACE "%s %c %s %I/%d %s", p->name, dir, msg, e->net->n.prefix, e->net->n.pxlen, via);
+  log(L_TRACE "%s %c %s %I/%d %s", p->name, dir, msg, e->net->n.prefix, e->net->n.pxlen, rt_format_via(e));
 }
 
 static inline void
@@ -2364,11 +2361,14 @@ rta_set_recursive_next_hop(rtable *dep, rta *a, rtable *tab, ip_addr *gw, ip_add
  *  CLI commands
  */
 
-static void
-rt_format_via(rte *e, byte *via)
+static byte *
+rt_format_via(rte *e)
 {
   rta *a = e->attrs;
 
+  /* Max text length w/o IP addr and interface name is 16 */
+  static byte via[STD_ADDRESS_P_LENGTH+sizeof(a->iface->name)+16];
+
   switch (a->dest)
     {
     case RTD_ROUTER:	bsprintf(via, "via %I on %s", a->gw, a->iface->name); break;
@@ -2379,12 +2379,13 @@ rt_format_via(rte *e, byte *via)
     case RTD_MULTIPATH:	bsprintf(via, "multipath"); break;
     default:		bsprintf(via, "???");
     }
+  return via;
 }
 
 static void
 rt_show_rte(struct cli *c, byte *ia, rte *e, struct rt_show_data *d, ea_list *tmpa)
 {
-  byte via[STD_ADDRESS_P_LENGTH+32], from[STD_ADDRESS_P_LENGTH+8];
+  byte from[STD_ADDRESS_P_LENGTH+8];
   byte tm[TM_DATETIME_BUFFER_SIZE], info[256];
   rta *a = e->attrs;
   int primary = (e->net->routes == e);
@@ -2392,7 +2393,6 @@ rt_show_rte(struct cli *c, byte *ia, rte *e, struct rt_show_data *d, ea_list *tm
   void (*get_route_info)(struct rte *, byte *buf, struct ea_list *attrs);
   struct mpnh *nh;
 
-  rt_format_via(e, via);
   tm_format_datetime(tm, &config->tf_route, e->lastmod);
   if (ipa_nonzero(a->from) && !ipa_equal(a->from, a->gw))
     bsprintf(from, " from %I", a->from);
@@ -2413,7 +2413,7 @@ rt_show_rte(struct cli *c, byte *ia, rte *e, struct rt_show_data *d, ea_list *tm
     get_route_info(e, info, tmpa);
   else
     bsprintf(info, " (%d)", e->pref);
-  cli_printf(c, -1007, "%-18s %s [%s %s%s]%s%s", ia, via, a->src->proto->name,
+  cli_printf(c, -1007, "%-18s %s [%s %s%s]%s%s", ia, rt_format_via(e), a->src->proto->name,
 	     tm, from, primary ? (sync_error ? " !" : " *") : "", info);
   for (nh = a->nexthops; nh; nh = nh->next)
     cli_printf(c, -1007, "\tvia %I on %s weight %d", nh->gw, nh->iface->name, nh->weight + 1);

From 321ff8c4049ec6c2fa198858b4a7f1814ce05e39 Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Tue, 19 Jul 2016 11:57:20 +0200
Subject: [PATCH 088/165] Babel: Make sure intervals do not overflow
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Intervals are carried as 16-bit centisecond values, but kept internally
in 16-bit second values, which causes a potential for overflow. This adds
some checks to make sure this does not happen.

Signed-off-by: Toke Høiland-Jørgensen <toke@toke.dk>
---
 proto/babel/babel.h  | 4 +++-
 proto/babel/config.Y | 9 +++++----
 2 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/proto/babel/babel.h b/proto/babel/babel.h
index aea0dd88..7b5037ab 100644
--- a/proto/babel/babel.h
+++ b/proto/babel/babel.h
@@ -50,10 +50,12 @@
 #define BABEL_INITIAL_HOP_COUNT		255
 #define BABEL_MAX_SEND_INTERVAL		5
 #define BABEL_TIME_UNITS		100	/* On-wire times are counted in centiseconds */
-
 #define BABEL_SEQNO_REQUEST_EXPIRY	60
 #define BABEL_GARBAGE_INTERVAL		300
 
+/* Max interval that will not overflow when carried as 16-bit centiseconds */
+#define BABEL_MAX_INTERVAL		(0xFFFF/BABEL_TIME_UNITS)
+
 #define BABEL_OVERHEAD		(SIZE_OF_IP_HEADER+UDP_HEADER_LENGTH)
 #define BABEL_MIN_MTU		(512 + BABEL_OVERHEAD)
 
diff --git a/proto/babel/config.Y b/proto/babel/config.Y
index e7ce6a93..b6170852 100644
--- a/proto/babel/config.Y
+++ b/proto/babel/config.Y
@@ -77,17 +77,18 @@ babel_iface_finish:
       BABEL_IFACE->rxcost = BABEL_RXCOST_WIRED;
   }
 
+  /* Make sure we do not overflow the 16-bit centisec fields */
   if (!BABEL_IFACE->update_interval)
-    BABEL_IFACE->update_interval = BABEL_IFACE->hello_interval*BABEL_UPDATE_INTERVAL_FACTOR;
-  BABEL_IFACE->ihu_interval = BABEL_IFACE->hello_interval*BABEL_IHU_INTERVAL_FACTOR;
+    BABEL_IFACE->update_interval = MIN_(BABEL_IFACE->hello_interval*BABEL_UPDATE_INTERVAL_FACTOR, BABEL_MAX_INTERVAL);
+  BABEL_IFACE->ihu_interval = MIN_(BABEL_IFACE->hello_interval*BABEL_IHU_INTERVAL_FACTOR, BABEL_MAX_INTERVAL);
 };
 
 
 babel_iface_item:
  | PORT expr { BABEL_IFACE->port = $2; if (($2<1) || ($2>65535)) cf_error("Invalid port number"); }
  | RXCOST expr { BABEL_IFACE->rxcost = $2; if (($2<1) || ($2>65535)) cf_error("Invalid rxcost"); }
- | HELLO INTERVAL expr { BABEL_IFACE->hello_interval = $3; if (($3<1) || ($3>65535)) cf_error("Invalid hello interval"); }
- | UPDATE INTERVAL expr { BABEL_IFACE->update_interval = $3; if (($3<1) || ($3>65535)) cf_error("Invalid hello interval"); }
+ | HELLO INTERVAL expr { BABEL_IFACE->hello_interval = $3; if (($3<1) || ($3>BABEL_MAX_INTERVAL)) cf_error("Invalid hello interval"); }
+ | UPDATE INTERVAL expr { BABEL_IFACE->update_interval = $3; if (($3<1) || ($3>BABEL_MAX_INTERVAL)) cf_error("Invalid update interval"); }
  | TYPE WIRED { BABEL_IFACE->type = BABEL_IFACE_TYPE_WIRED; }
  | TYPE WIRELESS { BABEL_IFACE->type = BABEL_IFACE_TYPE_WIRELESS; }
  | RX BUFFER expr { BABEL_IFACE->rx_buffer = $3; if (($3<256) || ($3>65535)) cf_error("RX buffer must be in range 256-65535"); }

From 12640c149976e1eca54d9c22c593d07a27c49d42 Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Tue, 19 Jul 2016 12:16:51 +0200
Subject: [PATCH 089/165] Babel: Documentation updates
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This updates the documentation to correctly mention Babel when protocols
are listed, and adds examples and route attribute documentation to the
Babel section of the docs.

Signed-off-by: Toke Høiland-Jørgensen <toke@toke.dk>
---
 doc/bird.sgml  | 34 +++++++++++++++++++++++++++++++---
 nest/config.Y  |  2 +-
 nest/rt-attr.c |  2 +-
 3 files changed, 33 insertions(+), 5 deletions(-)

diff --git a/doc/bird.sgml b/doc/bird.sgml
index de7041a9..b90f65d1 100644
--- a/doc/bird.sgml
+++ b/doc/bird.sgml
@@ -610,8 +610,8 @@ agreement").
 	options, in that case for given interface the first matching interface
 	option is used.
 
-	This option is allowed in BFD, Direct, OSPF, RAdv and RIP protocols, but
-	in OSPF protocol it is used in the <cf/area/ subsection.
+	This option is allowed in Babel, BFD, Direct, OSPF, RAdv and RIP
+	protocols, but in OSPF protocol it is used in the <cf/area/ subsection.
 
 	Default: none.
 
@@ -1314,7 +1314,7 @@ clist for most purposes.
 	<cf/RTS_DUMMY/, <cf/RTS_STATIC/, <cf/RTS_INHERIT/, <cf/RTS_DEVICE/,
 	<cf/RTS_STATIC_DEVICE/, <cf/RTS_REDIRECT/, <cf/RTS_RIP/, <cf/RTS_OSPF/,
 	<cf/RTS_OSPF_IA/, <cf/RTS_OSPF_EXT1/, <cf/RTS_OSPF_EXT2/, <cf/RTS_BGP/,
-	<cf/RTS_PIPE/.
+	<cf/RTS_PIPE/, <cf/RTS_BABEL/.
 
 	<tag><m/enum/ cast</tag>
 	Route type (Currently <cf/RTC_UNICAST/ for normal routes,
@@ -1477,6 +1477,34 @@ protocol babel [<name>] {
       yes.
 </descrip>
 
+<sect1>Attributes
+
+<p>Babel defines just one attribute: the internal babel metric of the route. It
+is exposed as the <cf/babel_metric/ attribute and has range from 1 to infinity
+(65535).
+
+<sect1>Example
+
+<p><code>
+protocol babel {
+	interface "eth*" {
+		type wired;
+	};
+	interface "wlan0", "wlan1" {
+		type wireless;
+		hello interval 1;
+		rxcost 512;
+	};
+	interface "tap0";
+
+	# This matches the default of babeld: redistribute all addresses
+	# configured on local interfaces, plus re-distribute all routes received
+	# from other babel peers.
+
+	export where (source = RTS_DEVICE) || (source = RTS_BABEL);
+}
+</code>
+
 
 <sect><label id="sect-bfd">BFD
 
diff --git a/nest/config.Y b/nest/config.Y
index 4566971f..ca705640 100644
--- a/nest/config.Y
+++ b/nest/config.Y
@@ -63,7 +63,7 @@ CF_KEYWORDS(RELOAD, IN, OUT, MRTDUMP, MESSAGES, RESTRICT, MEMORY, IGP_METRIC, CL
 CF_KEYWORDS(GRACEFUL, RESTART, WAIT, MAX, FLUSH, AS)
 
 CF_ENUM(T_ENUM_RTS, RTS_, DUMMY, STATIC, INHERIT, DEVICE, STATIC_DEVICE, REDIRECT,
-	RIP, OSPF, OSPF_IA, OSPF_EXT1, OSPF_EXT2, BGP, PIPE)
+	RIP, OSPF, OSPF_IA, OSPF_EXT1, OSPF_EXT2, BGP, PIPE, BABEL)
 CF_ENUM(T_ENUM_SCOPE, SCOPE_, HOST, LINK, SITE, ORGANIZATION, UNIVERSE, UNDEFINED)
 CF_ENUM(T_ENUM_RTC, RTC_, UNICAST, BROADCAST, MULTICAST, ANYCAST)
 CF_ENUM(T_ENUM_RTD, RTD_, ROUTER, DEVICE, BLACKHOLE, UNREACHABLE, PROHIBIT, MULTIPATH)
diff --git a/nest/rt-attr.c b/nest/rt-attr.c
index f181b452..42b74f34 100644
--- a/nest/rt-attr.c
+++ b/nest/rt-attr.c
@@ -1160,7 +1160,7 @@ rta_dump(rta *a)
   static char *rts[] = { "RTS_DUMMY", "RTS_STATIC", "RTS_INHERIT", "RTS_DEVICE",
 			 "RTS_STAT_DEV", "RTS_REDIR", "RTS_RIP",
 			 "RTS_OSPF", "RTS_OSPF_IA", "RTS_OSPF_EXT1",
-                         "RTS_OSPF_EXT2", "RTS_BGP" };
+                         "RTS_OSPF_EXT2", "RTS_BGP", "RTS_PIPE", "RTS_BABEL" };
   static char *rtc[] = { "", " BC", " MC", " AC" };
   static char *rtd[] = { "", " DEV", " HOLE", " UNREACH", " PROHIBIT" };
 

From ecae2f43f37df642e5098201a0472802e6a70e78 Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Tue, 19 Jul 2016 13:33:02 +0200
Subject: [PATCH 090/165] Babel: Rework handling of retractions
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

An update with wildcard AE and infinite metric should be treated as a
global retraction of all prefixes announced by that neighbour, per
section 4.4.9 of the RFC. In addition, router ID and seqno in retraction
updates should be ignored. This reworks the handling of retractions and
adjusts the parser to handle all this correctly.

Signed-off-by: Toke Høiland-Jørgensen <toke@toke.dk>
---
 proto/babel/babel.c   | 82 ++++++++++++++++++++++++++++++-------------
 proto/babel/packets.c |  4 ++-
 2 files changed, 61 insertions(+), 25 deletions(-)

diff --git a/proto/babel/babel.c b/proto/babel/babel.c
index 8e104d60..8204838b 100644
--- a/proto/babel/babel.c
+++ b/proto/babel/babel.c
@@ -1040,17 +1040,18 @@ babel_handle_update(union babel_msg *m, struct babel_iface *ifa)
   struct babel_proto *p = ifa->proto;
   struct babel_msg_update *msg = &m->update;
 
-  struct babel_neighbor *n;
+  struct babel_neighbor *nbr;
   struct babel_entry *e;
   struct babel_source *s;
   struct babel_route *r;
+  node *n;
   int feasible;
 
   TRACE(D_PACKETS, "Handling update for %I/%d with seqno %d metric %d",
 	msg->prefix, msg->plen, msg->seqno, msg->metric);
 
-  n = babel_find_neighbor(ifa, msg->sender);
-  if (!n)
+  nbr = babel_find_neighbor(ifa, msg->sender);
+  if (!nbr)
   {
     DBG("Babel: Haven't heard from neighbor %I; ignoring update.\n", msg->sender);
     return;
@@ -1095,55 +1096,88 @@ babel_handle_update(union babel_msg *m, struct babel_iface *ifa)
    *   of the Interval value included in the update.
    */
 
+  /* Retraction */
   if (msg->metric == BABEL_INFINITY)
-    e = babel_find_entry(p, msg->prefix, msg->plen);
-  else
-    e = babel_get_entry(p, msg->prefix, msg->plen);
+  {
+    if (msg->ae == BABEL_AE_WILDCARD)
+    {
+      /*
+       * Special case: This is a retraction of all prefixes announced by this
+       * neighbour (see second-to-last paragraph of section 4.4.9 in the RFC).
+       */
+      WALK_LIST(n, nbr->routes)
+      {
+	r = SKIP_BACK(struct babel_route, neigh_route, n);
+	r->metric = BABEL_INFINITY;
+	babel_select_route(r->e);
+      }
+    }
+    else
+    {
+      e = babel_find_entry(p, msg->prefix, msg->plen);
 
-  if (!e)
+      if (!e)
+	return;
+
+      /* The route entry indexed by neighbour */
+      r = babel_find_route(e, nbr);
+
+      if (!r)
+	return;
+
+      r->metric = BABEL_INFINITY;
+      babel_select_route(e);
+    }
+
+    /* Done with retractions */
     return;
+  }
 
+  e = babel_get_entry(p, msg->prefix, msg->plen);
+  r = babel_find_route(e, nbr); /* the route entry indexed by neighbour */
   s = babel_find_source(e, msg->router_id); /* for feasibility */
-  r = babel_find_route(e, n); /* the route entry indexed by neighbour */
   feasible = babel_is_feasible(s, msg->seqno, msg->metric);
 
   if (!r)
   {
-    if (!feasible || (msg->metric == BABEL_INFINITY))
+    if (!feasible)
       return;
 
-    r = babel_get_route(e, n);
+    r = babel_get_route(e, nbr);
     r->advert_metric = msg->metric;
     r->router_id = msg->router_id;
-    r->metric = babel_compute_metric(n, msg->metric);
+    r->metric = babel_compute_metric(nbr, msg->metric);
     r->next_hop = msg->next_hop;
     r->seqno = msg->seqno;
   }
   else if (r == r->e->selected_in && !feasible)
   {
-    /* Route is installed and update is infeasible - we may lose the route, so
-       send a unicast seqno request (section 3.8.2.2 second paragraph). */
+    /*
+     * Route is installed and update is infeasible - we may lose the route,
+     * so send a unicast seqno request (section 3.8.2.2 second paragraph).
+     */
     babel_unicast_seqno_request(r);
 
-    if (msg->router_id == r->router_id) return;
-    r->metric = BABEL_INFINITY; /* retraction */
+    if (msg->router_id == r->router_id)
+      return;
+
+    /* Treat as retraction */
+    r->metric = BABEL_INFINITY;
   }
   else
   {
     /* Last paragraph above - update the entry */
     r->advert_metric = msg->metric;
-    r->metric = babel_compute_metric(n, msg->metric);
-    r->router_id = msg->router_id;
+    r->metric = babel_compute_metric(nbr, msg->metric);
     r->next_hop = msg->next_hop;
+
+    r->router_id = msg->router_id;
     r->seqno = msg->seqno;
 
-    if (msg->metric != BABEL_INFINITY)
-    {
-      r->expiry_interval = BABEL_ROUTE_EXPIRY_FACTOR(msg->interval);
-      r->expires = now + r->expiry_interval;
-      if (r->expiry_interval > BABEL_ROUTE_REFRESH_INTERVAL)
-        r->refresh_time = now + r->expiry_interval - BABEL_ROUTE_REFRESH_INTERVAL;
-    }
+    r->expiry_interval = BABEL_ROUTE_EXPIRY_FACTOR(msg->interval);
+    r->expires = now + r->expiry_interval;
+    if (r->expiry_interval > BABEL_ROUTE_REFRESH_INTERVAL)
+      r->refresh_time = now + r->expiry_interval - BABEL_ROUTE_REFRESH_INTERVAL;
 
     /* If the route is not feasible at this point, it means it is from another
        neighbour than the one currently selected; so send a unicast seqno
diff --git a/proto/babel/packets.c b/proto/babel/packets.c
index be47aa75..d0cc613e 100644
--- a/proto/babel/packets.c
+++ b/proto/babel/packets.c
@@ -480,6 +480,7 @@ babel_read_update(struct babel_tlv *hdr, union babel_msg *m,
     if (tlv->plen > 0)
       return PARSE_ERROR;
 
+    msg->plen = 0;
     msg->prefix = IPA_NONE;
     break;
 
@@ -523,7 +524,8 @@ babel_read_update(struct babel_tlv *hdr, union babel_msg *m,
     return PARSE_IGNORE;
   }
 
-  if (!state->router_id_seen)
+  /* Update must have Router ID, unless it is retraction */
+  if (!state->router_id_seen && (msg->metric != BABEL_INFINITY))
   {
     DBG("Babel: No router ID seen before update\n");
     return PARSE_ERROR;

From 5d6ca220850c615126ea6820f8c05528269feec6 Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Tue, 19 Jul 2016 14:23:41 +0200
Subject: [PATCH 091/165] Babel: Send wildcard retractions on shutdown and
 startup
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This makes BIRD send a wildcard retraction on all interfaces before
shutting down and right after starting up. This helps ensure that
neighbours will discard the announced routes as soon as possible,
rather than only after the normal timeout procedures.

Signed-off-by: Toke Høiland-Jørgensen <toke@toke.dk>
---
 proto/babel/babel.c   | 50 +++++++++++++++++++++++++++++++++++++++----
 proto/babel/babel.h   |  2 +-
 proto/babel/packets.c | 25 ++++++++++++++++------
 3 files changed, 65 insertions(+), 12 deletions(-)

diff --git a/proto/babel/babel.c b/proto/babel/babel.c
index 8204838b..67e1d8be 100644
--- a/proto/babel/babel.c
+++ b/proto/babel/babel.c
@@ -834,8 +834,8 @@ babel_send_retraction(struct babel_iface *ifa, ip_addr prefix, int plen)
   struct babel_proto *p = ifa->proto;
   union babel_msg msg = {};
 
-  TRACE(D_PACKETS, "Sending retraction for %I/%d router-id %lR seqno %d",
-	prefix, plen, p->router_id, p->update_seqno);
+  TRACE(D_PACKETS, "Sending retraction for %I/%d seqno %d",
+	prefix, plen, p->update_seqno);
 
   msg.type = BABEL_TLV_UPDATE;
   msg.update.plen = plen;
@@ -843,7 +843,23 @@ babel_send_retraction(struct babel_iface *ifa, ip_addr prefix, int plen)
   msg.update.seqno = p->update_seqno;
   msg.update.metric = BABEL_INFINITY;
   msg.update.prefix = prefix;
-  msg.update.router_id = p->router_id;
+
+  babel_enqueue(&msg, ifa);
+}
+
+static void
+babel_send_wildcard_retraction(struct babel_iface *ifa)
+{
+  struct babel_proto *p = ifa->proto;
+  union babel_msg msg = {};
+
+  TRACE(D_PACKETS, "Sending wildcard retraction on %s", ifa->ifname);
+
+  msg.type = BABEL_TLV_UPDATE;
+  msg.update.wildcard = 1;
+  msg.update.interval = ifa->cf->update_interval;
+  msg.update.seqno = p->update_seqno;
+  msg.update.metric = BABEL_INFINITY;
 
   babel_enqueue(&msg, ifa);
 }
@@ -1099,7 +1115,7 @@ babel_handle_update(union babel_msg *m, struct babel_iface *ifa)
   /* Retraction */
   if (msg->metric == BABEL_INFINITY)
   {
-    if (msg->ae == BABEL_AE_WILDCARD)
+    if (msg->wildcard)
     {
       /*
        * Special case: This is a retraction of all prefixes announced by this
@@ -1347,6 +1363,7 @@ babel_iface_start(struct babel_iface *ifa)
   ifa->up = 1;
 
   babel_send_hello(ifa, 0);
+  babel_send_wildcard_retraction(ifa);
   babel_send_wildcard_request(ifa);
   babel_send_update(ifa, 0);	/* Full update */
 }
@@ -2056,6 +2073,30 @@ babel_start(struct proto *P)
   return PS_UP;
 }
 
+static inline void
+babel_iface_shutdown(struct babel_iface *ifa)
+{
+  if (ifa->sk)
+  {
+    babel_send_wildcard_retraction(ifa);
+    babel_send_queue(ifa);
+  }
+}
+
+static int
+babel_shutdown(struct proto *P)
+{
+  struct babel_proto *p = (void *) P;
+  struct babel_iface *ifa;
+
+  TRACE(D_EVENTS, "Shutdown requested");
+
+  WALK_LIST(ifa, p->interfaces)
+    babel_iface_shutdown(ifa);
+
+  return PS_DOWN;
+}
+
 static int
 babel_reconfigure(struct proto *P, struct proto_config *c)
 {
@@ -2083,6 +2124,7 @@ struct protocol proto_babel = {
   .init =		babel_init,
   .dump =		babel_dump,
   .start =		babel_start,
+  .shutdown =		babel_shutdown,
   .reconfigure =	babel_reconfigure,
   .get_route_info =	babel_get_route_info,
   .get_attr =		babel_get_attr
diff --git a/proto/babel/babel.h b/proto/babel/babel.h
index 7b5037ab..481c88a7 100644
--- a/proto/babel/babel.h
+++ b/proto/babel/babel.h
@@ -268,7 +268,7 @@ struct babel_msg_ihu {
 
 struct babel_msg_update {
   u8 type;
-  u8 ae;
+  u8 wildcard;
   u8 plen;
   u16 interval;
   u16 seqno;
diff --git a/proto/babel/packets.c b/proto/babel/packets.c
index d0cc613e..65dd6853 100644
--- a/proto/babel/packets.c
+++ b/proto/babel/packets.c
@@ -462,7 +462,6 @@ babel_read_update(struct babel_tlv *hdr, union babel_msg *m,
   struct babel_msg_update *msg = &m->update;
 
   msg->type = BABEL_TLV_UPDATE;
-  msg->ae = tlv->ae;
   msg->interval = get_time16(&tlv->interval);
   msg->seqno = get_u16(&tlv->seqno);
   msg->metric = get_u16(&tlv->metric);
@@ -480,8 +479,7 @@ babel_read_update(struct babel_tlv *hdr, union babel_msg *m,
     if (tlv->plen > 0)
       return PARSE_ERROR;
 
-    msg->plen = 0;
-    msg->prefix = IPA_NONE;
+    msg->wildcard = 1;
     break;
 
   case BABEL_AE_IP4:
@@ -550,8 +548,11 @@ babel_write_update(struct babel_tlv *hdr, union babel_msg *m,
    * When needed, we write Router-ID TLV before Update TLV and return size of
    * both of them. There is enough space for the Router-ID TLV, because
    * sizeof(struct babel_tlv_router_id) == sizeof(struct babel_tlv_update).
+   *
+   * Router ID is not used for retractions, so do not us it in such case.
    */
-  if (!state->router_id_seen || (msg->router_id != state->router_id))
+  if ((msg->metric < BABEL_INFINITY) &&
+      (!state->router_id_seen || (msg->router_id != state->router_id)))
   {
     len0 = babel_write_router_id(hdr, msg->router_id, state, max_len);
     tlv = (struct babel_tlv_update *) NEXT_TLV(tlv);
@@ -564,12 +565,22 @@ babel_write_update(struct babel_tlv *hdr, union babel_msg *m,
 
   memset(tlv, 0, sizeof(struct babel_tlv_update));
   TLV_HDR(tlv, BABEL_TLV_UPDATE, len);
-  tlv->ae = BABEL_AE_IP6;
-  tlv->plen = msg->plen;
+
+  if (msg->wildcard)
+  {
+    tlv->ae = BABEL_AE_WILDCARD;
+    tlv->plen = 0;
+  }
+  else
+  {
+    tlv->ae = BABEL_AE_IP6;
+    tlv->plen = msg->plen;
+    put_ip6_px(tlv->addr, msg->prefix, msg->plen);
+  }
+
   put_time16(&tlv->interval, msg->interval);
   put_u16(&tlv->seqno, msg->seqno);
   put_u16(&tlv->metric, msg->metric);
-  put_ip6_px(tlv->addr, msg->prefix, msg->plen);
 
   return len0 + len;
 }

From 0f673666017bfc9c05c9495ae53bc323b9dc6660 Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Tue, 19 Jul 2016 14:28:53 +0200
Subject: [PATCH 092/165] Babel: Do not keep an infeasible route as selected
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

When a route becomes infeasible it should not be kept as selected; this
is forbidden by section 3.6 of the RFC and prevents subsequent updates
from the same router ID from replacing it.

Signed-off-by: Toke Høiland-Jørgensen <toke@toke.dk>
---
 proto/babel/babel.c | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/proto/babel/babel.c b/proto/babel/babel.c
index 67e1d8be..3b3b9870 100644
--- a/proto/babel/babel.c
+++ b/proto/babel/babel.c
@@ -565,6 +565,11 @@ babel_select_route(struct babel_entry *e)
 
       babel_send_seqno_request(e);
       babel_announce_rte(p, e);
+
+      /* Section 3.6 of the RFC forbids an infeasible from being selected. This
+	 is cleared after announcing the route to the core to make sure an
+	 unreachable route is propagated first. */
+      e->selected_in = NULL;
     }
     else
     {

From c6ed5a0f9925476714d6b351c61dbce704a4f09d Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Tue, 19 Jul 2016 14:38:36 +0200
Subject: [PATCH 093/165] Babel: Do not maintain feasibility distance for our
 own routes
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

We do not need to maintain feasibility distances for our own router
ID (we ignore the updates anyway). Not doing so makes the routes be
garbage collected sooner when export filters change.

Signed-off-by: Toke Høiland-Jørgensen <toke@toke.dk>
---
 proto/babel/babel.c | 21 +++++++++++++--------
 1 file changed, 13 insertions(+), 8 deletions(-)

diff --git a/proto/babel/babel.c b/proto/babel/babel.c
index 3b3b9870..8164f2f3 100644
--- a/proto/babel/babel.c
+++ b/proto/babel/babel.c
@@ -788,16 +788,21 @@ babel_send_update(struct babel_iface *ifa, bird_clock_t changed)
     msg.update.prefix = e->n.prefix;
     msg.update.router_id = r->router_id;
 
-    /* Update feasibility distance */
-    struct babel_source *s = babel_get_source(e, r->router_id);
-    s->expires = now + BABEL_GARBAGE_INTERVAL;
-    if ((msg.update.seqno > s->seqno) ||
-	((msg.update.seqno == s->seqno) && (msg.update.metric < s->metric)))
+    babel_enqueue(&msg, ifa);
+
+    /* Update feasibility distance for redistributed routes */
+    if (!OUR_ROUTE(r))
     {
-      s->seqno = msg.update.seqno;
-      s->metric = msg.update.metric;
+      struct babel_source *s = babel_get_source(e, r->router_id);
+      s->expires = now + BABEL_GARBAGE_INTERVAL;
+
+      if ((msg.update.seqno > s->seqno) ||
+	  ((msg.update.seqno == s->seqno) && (msg.update.metric < s->metric)))
+      {
+	s->seqno = msg.update.seqno;
+	s->metric = msg.update.metric;
+      }
     }
-    babel_enqueue(&msg, ifa);
   }
   FIB_WALK_END;
 }

From 0a21c21112eff1286a0a2a7f7afc812f8d16cfa2 Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Tue, 19 Jul 2016 15:40:57 +0200
Subject: [PATCH 094/165] Doc: Fix password ID option description

Thanks to Alexander Velkov for noticing it
---
 doc/bird.sgml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/bird.sgml b/doc/bird.sgml
index b90f65d1..1af7f2c1 100644
--- a/doc/bird.sgml
+++ b/doc/bird.sgml
@@ -667,7 +667,7 @@ agreement").
 
 <descrip>
 	<tag>id <M>num</M></tag>
-	ID of the password, (0-255). If it's not used, BIRD will choose ID based
+	ID of the password, (1-255). If it is not used, BIRD will choose ID based
 	on an order of the password item in the interface. For example, second
 	password item in one interface will have default ID 2. ID is used by
 	some routing protocols to identify which password was used to

From e37d2e3e708db78f9b8f15eb34bb266cfae7bb42 Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Wed, 20 Jul 2016 15:06:57 +0200
Subject: [PATCH 095/165] Netlink: Ignore tentative addresses

Ignore tentative IPv6 addresses and wait until finish of Duplicate
Address Detection (We got notification when an address is no longer
tentative) to avoid problems when protocols try to use interfaces
with tentative link-local addresses.

Based on patch from Jan Moskyto Matejka
---
 sysdep/linux/netlink.c | 18 ++++++++++++++++--
 1 file changed, 16 insertions(+), 2 deletions(-)

diff --git a/sysdep/linux/netlink.c b/sysdep/linux/netlink.c
index b42e7b6f..f6cedbd8 100644
--- a/sysdep/linux/netlink.c
+++ b/sysdep/linux/netlink.c
@@ -247,18 +247,20 @@ static struct nl_want_attrs ifla_attr_want[BIRD_IFLA_MAX] = {
 };
 
 
-#define BIRD_IFA_MAX  (IFA_ANYCAST+1)
+#define BIRD_IFA_MAX  (IFA_FLAGS+1)
 
 #ifndef IPV6
 static struct nl_want_attrs ifa_attr_want4[BIRD_IFA_MAX] = {
   [IFA_ADDRESS]	  = { 1, 1, sizeof(ip4_addr) },
   [IFA_LOCAL]	  = { 1, 1, sizeof(ip4_addr) },
   [IFA_BROADCAST] = { 1, 1, sizeof(ip4_addr) },
+  [IFA_FLAGS]	  = { 1, 1, sizeof(u32) },
 };
 #else
 static struct nl_want_attrs ifa_attr_want6[BIRD_IFA_MAX] = {
   [IFA_ADDRESS]	  = { 1, 1, sizeof(ip6_addr) },
   [IFA_LOCAL]	  = { 1, 1, sizeof(ip6_addr) },
+  [IFA_FLAGS]	  = { 1, 1, sizeof(u32) },
 };
 #endif
 
@@ -611,6 +613,7 @@ nl_parse_addr(struct nlmsghdr *h, int scan)
   struct ifa ifa;
   struct iface *ifi;
   int scope;
+  u32 ifa_flags;
 
   if (!(i = nl_checkin(h, sizeof(*i))))
     return;
@@ -643,6 +646,11 @@ nl_parse_addr(struct nlmsghdr *h, int scan)
       return;
     }
 
+  if (a[IFA_FLAGS])
+    ifa_flags = rta_get_u32(a[IFA_FLAGS]);
+  else
+    ifa_flags = i->ifa_flags;
+
   ifi = if_find_by_index(i->ifa_index);
   if (!ifi)
     {
@@ -652,9 +660,15 @@ nl_parse_addr(struct nlmsghdr *h, int scan)
 
   bzero(&ifa, sizeof(ifa));
   ifa.iface = ifi;
-  if (i->ifa_flags & IFA_F_SECONDARY)
+  if (ifa_flags & IFA_F_SECONDARY)
     ifa.flags |= IA_SECONDARY;
 
+#ifdef IPV6
+  /* Ignore tentative addresses silently */
+  if (ifa_flags & IFA_F_TENTATIVE)
+    return;
+#endif
+
   /* IFA_LOCAL can be unset for IPv6 interfaces */
   memcpy(&ifa.ip, RTA_DATA(a[IFA_LOCAL] ? : a[IFA_ADDRESS]), sizeof(ifa.ip));
   ipa_ntoh(ifa.ip);

From a08a81c6b40dcf07e786b67e5015fc91a44333ca Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Wed, 20 Jul 2016 15:31:25 +0200
Subject: [PATCH 096/165] Netlink: Fix build with older headers missing
 IFA_FLAGS

---
 sysdep/linux/netlink.c | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/sysdep/linux/netlink.c b/sysdep/linux/netlink.c
index f6cedbd8..fa9013bd 100644
--- a/sysdep/linux/netlink.c
+++ b/sysdep/linux/netlink.c
@@ -38,6 +38,10 @@
 #define MSG_TRUNC 0x20
 #endif
 
+#ifndef IFA_FLAGS
+#define IFA_FLAGS 8
+#endif
+
 #ifndef IFF_LOWER_UP
 #define IFF_LOWER_UP 0x10000
 #endif

From 13a31a4001e02ea7c84d26cbeaaa9fea816736f7 Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Wed, 20 Jul 2016 15:55:45 +0200
Subject: [PATCH 097/165] Babel: Immediately update hello interval on interface
 reconfigure
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

An interface reconfiguration may change both the hello and update
intervals. An update interval change is immediately put into effect,
while a hello interval change is not. This also updates the hello
interval immediately (if the new interval is shorter than the old one),
and sends a hello to notify peers of the change.

Signed-off-by: Toke Høiland-Jørgensen <toke@toke.dk>
---
 proto/babel/babel.c | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/proto/babel/babel.c b/proto/babel/babel.c
index 8164f2f3..9d73a264 100644
--- a/proto/babel/babel.c
+++ b/proto/babel/babel.c
@@ -1590,6 +1590,9 @@ babel_reconfigure_iface(struct babel_proto *p, struct babel_iface *ifa, struct b
 
   ifa->cf = new;
 
+  if (ifa->next_hello > (now + new->hello_interval))
+    ifa->next_hello = now + (random() % new->hello_interval) + 1;
+
   if (ifa->next_regular > (now + new->update_interval))
     ifa->next_regular = now + (random() % new->update_interval) + 1;
 

From 0ea2afe67150661328c93679587740fbd8928b2a Mon Sep 17 00:00:00 2001
From: Pavel Tvrdik <pawel.tvrdik@gmail.com>
Date: Mon, 15 Aug 2016 16:16:36 +0200
Subject: [PATCH 098/165] Adds mailing list address at the top of README file

---
 README | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/README b/README
index 5d4bd9b2..7564a1c3 100644
--- a/README
+++ b/README
@@ -1,5 +1,10 @@
 		       BIRD Internet Routing Daemon
 
+                Mailing list    bird-users@network.cz
+                                http://bird.network.cz/mailman/listinfo/bird-users
+
+                Home page       http://bird.network.cz/
+
 		(c) 1998--2008  Martin Mares <mj@ucw.cz>
                 (c) 1998--2000  Pavel Machek <pavel@ucw.cz>
                 (c) 1998--2008  Ondrej Filip <feela@network.cz>
@@ -13,10 +18,10 @@ routing protocols, easy to use configuration interface and powerful route
 filtering language.
 
 If you want to help us debugging, enhancing and porting BIRD or just lurk
-around to see what's going to develop from this strange creature, feel free
-to subscribe to the BIRD users mailing list (bird-users@bird.network.cz),
-send subscribes to majordomo at the same machine).  Bug reports, suggestions,
-feature requests (: and code :) are welcome.
+around to see what's going to develop from this strange creature, feel free to
+subscribe to the BIRD users mailing list (bird-users@bird.network.cz), send
+subscribes to majordomo at the same machine). Bug reports, suggestions, feature
+requests (: and code :) are welcome. We don't use gitlab issues reporting, sorry.
 
 You can download the latest version from ftp://bird.network.cz/pub/bird/
 and look at the BIRD home page at http://bird.network.cz/.

From 61e6725335fbba86175ec770c1e94c5f60e76d5c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ond=C5=99ej=20Sur=C3=BD?= <ondrej@sury.org>
Date: Tue, 16 Aug 2016 09:23:55 +0200
Subject: [PATCH 099/165] Include <stdint.h> in cf-lex.l to avoid UINTx_MAX
 redefinition

---
 conf/cf-lex.l | 1 +
 1 file changed, 1 insertion(+)

diff --git a/conf/cf-lex.l b/conf/cf-lex.l
index 727dc017..61ea4527 100644
--- a/conf/cf-lex.l
+++ b/conf/cf-lex.l
@@ -30,6 +30,7 @@
 #include <errno.h>
 #include <stdlib.h>
 #include <stdarg.h>
+#include <stdint.h>
 #include <unistd.h>
 #include <libgen.h>
 #include <glob.h>

From 33d22f0e9e79c387c492d1cf16bdb723ca1d588a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ond=C5=99ej=20Sur=C3=BD?= <ondrej@sury.org>
Date: Tue, 16 Aug 2016 09:24:12 +0200
Subject: [PATCH 100/165] whitespace fixes

---
 filter/filter.c  | 2 +-
 filter/tree.c    | 4 ++--
 sysdep/unix/io.c | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/filter/filter.c b/filter/filter.c
index 30571e5a..ccdfed36 100644
--- a/filter/filter.c
+++ b/filter/filter.c
@@ -185,7 +185,7 @@ pm_same(struct f_path_mask *m1, struct f_path_mask *m2)
     m2 = m2->next;
   }
 
- return !m1 && !m2;
+  return !m1 && !m2;
 }
 
 /**
diff --git a/filter/tree.c b/filter/tree.c
index ee9f448a..59ebf579 100644
--- a/filter/tree.c
+++ b/filter/tree.c
@@ -163,9 +163,9 @@ tree_format(struct f_tree *t, buffer *buf)
 {
   buffer_puts(buf, "[");
  
- tree_node_format(t, buf);
+  tree_node_format(t, buf);
 
- /* Undo last separator */
+  /* Undo last separator */
   if (buf->pos[-1] != '[')
     buf->pos -= 2;
  
diff --git a/sysdep/unix/io.c b/sysdep/unix/io.c
index 8198743d..120eb906 100644
--- a/sysdep/unix/io.c
+++ b/sysdep/unix/io.c
@@ -2235,7 +2235,7 @@ io_loop(void)
 	      if (pfd[s->index].revents & (POLLHUP | POLLERR))
 		{
 		  sk_err(s, pfd[s->index].revents);
-		    goto next2;
+		  goto next2;
 		}
 
 	      current_sock = sk_next(s);

From 671ddd5b05cf35b2ab7b80f1d13641c875f22e77 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ond=C5=99ej=20Sur=C3=BD?= <ondrej@sury.org>
Date: Tue, 16 Aug 2016 09:25:50 +0200
Subject: [PATCH 101/165] Add .gitignore to ignore generated files

---
 .gitignore | 8 ++++++++
 1 file changed, 8 insertions(+)
 create mode 100644 .gitignore

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 00000000..77dea498
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,8 @@
+/Makefile
+/bird
+/birdc
+/birdcl
+/config.log
+/config.status
+/configure
+/obj/

From 9b3d2464cd6dafdd3021f4513f24d19d56d42d3d Mon Sep 17 00:00:00 2001
From: Pavel Tvrdik <pawel.tvrdik@gmail.com>
Date: Tue, 16 Aug 2016 10:15:58 +0200
Subject: [PATCH 102/165] Rewrote README file

* Made structure with headlines,
* reordered,
* kicked out 'What is missing' part,
* Updated content by home page site and user docs
---
 README | 151 ++++++++++++++++++++++++++++++++-------------------------
 1 file changed, 84 insertions(+), 67 deletions(-)

diff --git a/README b/README
index 7564a1c3..d419755f 100644
--- a/README
+++ b/README
@@ -1,87 +1,104 @@
-		       BIRD Internet Routing Daemon
+                       BIRD Internet Routing Daemon
 
-                Mailing list    bird-users@network.cz
-                                http://bird.network.cz/mailman/listinfo/bird-users
+                     Home page  http://bird.network.cz/
+                  Mailing list  bird-users@network.cz
 
-                Home page       http://bird.network.cz/
-
-		(c) 1998--2008  Martin Mares <mj@ucw.cz>
+                (c) 1998--2008  Martin Mares <mj@ucw.cz>
                 (c) 1998--2000  Pavel Machek <pavel@ucw.cz>
                 (c) 1998--2008  Ondrej Filip <feela@network.cz>
-                (c) 2009--2013  CZ.NIC z.s.p.o.
+                (c) 2009--2016  CZ.NIC z.s.p.o.
 
 ================================================================================
 
-The BIRD project is an attempt to create a routing daemon running on UNIX-like
-systems (but not necessarily limited to them) with full support of all modern
-routing protocols, easy to use configuration interface and powerful route
-filtering language.
-
-If you want to help us debugging, enhancing and porting BIRD or just lurk
-around to see what's going to develop from this strange creature, feel free to
-subscribe to the BIRD users mailing list (bird-users@bird.network.cz), send
-subscribes to majordomo at the same machine). Bug reports, suggestions, feature
-requests (: and code :) are welcome. We don't use gitlab issues reporting, sorry.
+The BIRD project aims to develop a dynamic IP routing daemon with full support
+of all modern routing protocols, easy to use configuration interface and
+powerful route filtering language, primarily targeted on (but not limited to)
+Linux and other UNIX-like systems and distributed under the GNU General
+Public License.
 
-You can download the latest version from ftp://bird.network.cz/pub/bird/
-and look at the BIRD home page at http://bird.network.cz/.
+What do we support
+==================
 
-BIRD development started as a student project at the Faculty of Math
-and Physics, Charles University, Prague, Czech Republic under supervision
-of RNDr. Libor Forst <forst@cuni.cz>. BIRD has been developed and supported
-by CZ.NIC z.s.p.o. http://www.nic.cz/ since 2009.
-
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
+	o  Both IPv4 and IPv6 (use --enable-ipv6 when configuring)
+	o  Multiple routing tables
+	o  Border Gateway Protocol (BGPv4)
+	o  Routing Information Protocol (RIPv2)
+	o  Open Shortest Path First protocol (OSPFv2, OSPFv3)
+	o  Bidirectional Forwarding Detection (BFD)
+	o  IPv6 router advertisements
+	o  Static routes
+	o  Inter-table protocol
+	o  Command-line interface allowing on-line control and inspection of
+	   status of the daemon
+	o  Soft reconfiguration, no need to use complex online commands to
+	   change the configuration, just edit the configuration file and notify
+	   BIRD to re-read it and it will smoothly switch itself to the new
+	   configuration, not disturbing routing protocols unless they are
+	   affected by the configuration changes
+	o  Powerful language for route filtering, see doc/bird.conf.example
+	o  Linux, FreeBSD, NetBSD and OpenBSD ports
+
+How to install BIRD
+===================
+
+	o  From standard distribution package of your OS (recommended)
+	o  From source code of the latest stable release version
+	   ftp://bird.network.cz/pub/bird/
+	o  From source code of the actual development version
+	   https://gitlab.labs.nic.cz/labs/bird
+
+How to compile BIRD from source code
+------------------------------------
+
+	$  ./configure
+	$  make
+	$  sudo make install
+	$  sudo vi /usr/local/etc/bird.conf
+	$  bird
+
+Documentation
+=============
+
+Online documentation is available at http://bird.network.cz/?get_doc or as HTML
+files in the doc directory, you can install it by `make install-docs' and
+rebuild it by `make docs', but you'll need SGMLtools and LaTeX to be installed
+on your machine. You can also download a neatly formatted PostScript version as
+a separate archive (bird-doc-*.tar.gz) from ftp://bird.network.cz/pub/bird/
+
+User support
+============
 
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
+If you want to help us debugging, enhancing and porting BIRD or just lurk
+around to see what's going to develop, feel free to subscribe to the BIRD users
+mailing list bird-users@bird.network.cz, just send `subscribe bird-users' to
+majordomo@network.cz. Bug reports, suggestions, feature requests and code are
+welcome! We don't use gitlab issues for reporting, sorry.
 
-    You should have received a copy of the GNU General Public License
-    along with this program; if not, write to the Free Software
-    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+Licence
+=======
 
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
 
-How to install BIRD:
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
 
-	./configure
-	make
-	make install
-	vi /usr/local/etc/bird.conf
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
-Online documentation is available as HTML files in the doc directory,
-you can install it by `make install-docs' and rebuild it by `make docs',
-but for the latter you need SGMLtools and LaTeX to be installed on your
-machine. You can also download a neatly formatted PostScript version
-as a separate archive (bird-doc-*.tar.gz).
+History
+=======
 
-What do we support:
+BIRD development started as a student project at the Faculty of Math
+and Physics, Charles University, Prague, Czech Republic under supervision
+of RNDr. Libor Forst <forst@cuni.cz>. BIRD has been developed and supported
+by CZ.NIC z.s.p.o. http://www.nic.cz/ since 2009.
 
-	o  Both IPv4 and IPv6 (use --enable-ipv6 when configuring)
-	o  Multiple routing tables
-	o  BGP
-	o  RIP
-	o  OSPF
-	o  Static routes
-	o  Inter-table protocol
-	o  IPv6 router advertisements
-	o  Bidirectional Forwarding Detection (BFD)
-	o  Command-line interface (using the `birdc' client; to get
-	   some help, just press `?')
-	o  Soft reconfiguration -- no online commands for changing the
-	   configuration in very limited ways, just edit the configuration
-	   file and issue a `configure' command or send SIGHUP and BIRD
-	   will start using the new configuration, possibly restarting
-	   protocols affected by the configuration changes.
-	o  Powerful language for route filtering (see doc/bird.conf.example).
-
-What is missing:
-
-	o  See the TODO list
 
 Good Luck and enjoy the BIRD :)
 						The BIRD Team

From dbac8793bd88279fd8956ce42db7bd2230965948 Mon Sep 17 00:00:00 2001
From: Pavel Tvrdik <pawel.tvrdik@gmail.com>
Date: Tue, 16 Aug 2016 10:42:12 +0200
Subject: [PATCH 103/165] Add link to INSTALL in README file

---
 README | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/README b/README
index d419755f..9f1c3161 100644
--- a/README
+++ b/README
@@ -47,15 +47,17 @@ How to install BIRD
 	o  From source code of the actual development version
 	   https://gitlab.labs.nic.cz/labs/bird
 
-How to compile BIRD from source code
+How to install BIRD from source code
 ------------------------------------
-
 	$  ./configure
 	$  make
 	$  sudo make install
 	$  sudo vi /usr/local/etc/bird.conf
 	$  bird
 
+Look at the file INSTALL for more information about installation using source
+code.
+
 Documentation
 =============
 

From d107ef78df2564cba75af1a6dcc9894c4468b207 Mon Sep 17 00:00:00 2001
From: Pavel Tvrdik <pawel.tvrdik@gmail.com>
Date: Tue, 16 Aug 2016 13:02:32 +0200
Subject: [PATCH 104/165] Whitespace fixes

---
 lib/printf.c    | 2 +-
 nest/rt-table.c | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/lib/printf.c b/lib/printf.c
index a067fe98..4fd75c9b 100644
--- a/lib/printf.c
+++ b/lib/printf.c
@@ -169,7 +169,7 @@ int bvsnprintf(char *buf, int size, const char *fmt, va_list args)
 				case ' ': flags |= SPACE; goto repeat;
 				case '#': flags |= SPECIAL; goto repeat;
 				case '0': flags |= ZEROPAD; goto repeat;
-				}
+			}
 		
 		/* get field width */
 		field_width = -1;
diff --git a/nest/rt-table.c b/nest/rt-table.c
index 50c01c88..9baf2849 100644
--- a/nest/rt-table.c
+++ b/nest/rt-table.c
@@ -1777,7 +1777,7 @@ rt_next_hop_update_net(rtable *tab, net *n)
   /* FIXME: Better announcement of merged routes */
   rte_announce_i(tab, RA_MERGED, n, new, old_best, new, old_best);
 
-   if (free_old_best)
+  if (free_old_best)
     rte_free_quick(old_best);
 
   return count;

From 678c97f21ef15c98546f41647f3244799a37db1f Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Tue, 23 Aug 2016 17:33:00 +0200
Subject: [PATCH 105/165] Minor README update

---
 README | 30 +++++++++++++++++++-----------
 1 file changed, 19 insertions(+), 11 deletions(-)

diff --git a/README b/README
index 9f1c3161..5a6d934d 100644
--- a/README
+++ b/README
@@ -22,8 +22,9 @@ What do we support
 	o  Both IPv4 and IPv6 (use --enable-ipv6 when configuring)
 	o  Multiple routing tables
 	o  Border Gateway Protocol (BGPv4)
-	o  Routing Information Protocol (RIPv2)
+	o  Routing Information Protocol (RIPv2, RIPng)
 	o  Open Shortest Path First protocol (OSPFv2, OSPFv3)
+	o  Babel Routing Protocol (Babel)
 	o  Bidirectional Forwarding Detection (BFD)
 	o  IPv6 router advertisements
 	o  Static routes
@@ -42,21 +43,25 @@ How to install BIRD
 ===================
 
 	o  From standard distribution package of your OS (recommended)
+	o  From official binary packages for Debian and Red Hat Linux
+	   ftp://bird.network.cz/pub/bird/debian/
+	   ftp://bird.network.cz/pub/bird/redhat/
 	o  From source code of the latest stable release version
 	   ftp://bird.network.cz/pub/bird/
 	o  From source code of the actual development version
-	   https://gitlab.labs.nic.cz/labs/bird
+	   git://git.nic.cz/bird.git
+	   https://gitlab.labs.nic.cz/labs/bird/
 
 How to install BIRD from source code
 ------------------------------------
+
 	$  ./configure
 	$  make
-	$  sudo make install
-	$  sudo vi /usr/local/etc/bird.conf
-	$  bird
+	$  su
+	#  make install
+	#  vi /usr/local/etc/bird.conf
 
-Look at the file INSTALL for more information about installation using source
-code.
+See the file INSTALL for more information about installation from source code.
 
 Documentation
 =============
@@ -71,10 +76,13 @@ User support
 ============
 
 If you want to help us debugging, enhancing and porting BIRD or just lurk
-around to see what's going to develop, feel free to subscribe to the BIRD users
-mailing list bird-users@bird.network.cz, just send `subscribe bird-users' to
-majordomo@network.cz. Bug reports, suggestions, feature requests and code are
-welcome! We don't use gitlab issues for reporting, sorry.
+around to see what's going to develop, feel free to subscribe to the BIRD
+users mailing list bird-users@network.cz, just send `subscribe' to
+bird-request@network.cz. Bug reports, suggestions, feature requests and
+code are welcome! We don't use gitlab issues for reporting, sorry.
+
+Subscribe:	http://bird.network.cz/mailman/listinfo/bird-users/
+Archive:	http://bird.network.cz/pipermail/bird-users/
 
 Licence
 =======

From f9f2e280ea4fa1af19d8ce9e54abeb495694c0d5 Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Tue, 30 Aug 2016 12:43:46 +0200
Subject: [PATCH 106/165] KRT: Forbid path merging on BSD

We support ECMP routes only on Linux. Exported routes are checked in
krt_capable(), but a route generated during path merging avoids this
check.
---
 sysdep/linux/krt-sys.h |  2 ++
 sysdep/unix/krt.Y      | 18 +++++++++++++++---
 2 files changed, 17 insertions(+), 3 deletions(-)

diff --git a/sysdep/linux/krt-sys.h b/sysdep/linux/krt-sys.h
index 7fd5f139..076870f5 100644
--- a/sysdep/linux/krt-sys.h
+++ b/sysdep/linux/krt-sys.h
@@ -32,6 +32,8 @@ static inline struct ifa * kif_get_primary_ip(struct iface *i) { return NULL; }
 
 /* Kernel routes */
 
+#define KRT_ALLOW_MERGE_PATHS	1
+
 #define EA_KRT_PREFSRC		EA_CODE(EAP_KRT, 0x10)
 #define EA_KRT_REALM		EA_CODE(EAP_KRT, 0x11)
 
diff --git a/sysdep/unix/krt.Y b/sysdep/unix/krt.Y
index e036081d..2ef6e3c4 100644
--- a/sysdep/unix/krt.Y
+++ b/sysdep/unix/krt.Y
@@ -19,6 +19,8 @@ CF_DECLS
 
 CF_KEYWORDS(KERNEL, PERSIST, SCAN, TIME, LEARN, DEVICE, ROUTES, GRACEFUL, RESTART, KRT_SOURCE, KRT_METRIC, MERGE, PATHS)
 
+%type <i> kern_mp_limit
+
 CF_GRAMMAR
 
 /* Kernel syncer protocol */
@@ -32,6 +34,11 @@ CF_ADDTO(kern_proto, kern_proto_start proto_name '{')
 CF_ADDTO(kern_proto, kern_proto proto_item ';')
 CF_ADDTO(kern_proto, kern_proto kern_item ';')
 
+kern_mp_limit:
+   /* empty */ { $$ = KRT_DEFAULT_ECMP_LIMIT; }
+ | LIMIT expr  { $$ = $2; if (($2 <= 0) || ($2 > 255)) cf_error("Merge paths limit must be in range 1-255"); }
+ ;
+
 kern_item:
    PERSIST bool { THIS_KRT->persist = $2; }
  | SCAN TIME expr {
@@ -42,13 +49,18 @@ kern_item:
       THIS_KRT->learn = $2;
 #ifndef KRT_ALLOW_LEARN
       if ($2)
-	cf_error("Learning of kernel routes not supported in this configuration");
+	cf_error("Learning of kernel routes not supported on this platform");
 #endif
    }
  | DEVICE ROUTES bool { THIS_KRT->devroutes = $3; }
  | GRACEFUL RESTART bool { THIS_KRT->graceful_restart = $3; }
- | MERGE PATHS bool { THIS_KRT->merge_paths = $3 ? KRT_DEFAULT_ECMP_LIMIT : 0; }
- | MERGE PATHS bool LIMIT expr { THIS_KRT->merge_paths = $3 ? $5 : 0; if (($5 <= 0) || ($5 > 255)) cf_error("Merge paths limit must be in range 1-255"); }
+ | MERGE PATHS bool kern_mp_limit {
+      THIS_KRT->merge_paths = $3 ? $4 : 0;
+#ifndef KRT_ALLOW_LEARN
+      if ($3)
+	cf_error("Path merging not supported on this platform");
+#endif
+   }
  ;
 
 /* Kernel interface protocol */

From a1839f3c61af66814a8c52b9ad28e59aab4ede0e Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Wed, 31 Aug 2016 14:02:41 +0200
Subject: [PATCH 107/165] KRT: Fix trivial error

---
 sysdep/unix/krt.Y | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sysdep/unix/krt.Y b/sysdep/unix/krt.Y
index 2ef6e3c4..6fe39fa9 100644
--- a/sysdep/unix/krt.Y
+++ b/sysdep/unix/krt.Y
@@ -56,7 +56,7 @@ kern_item:
  | GRACEFUL RESTART bool { THIS_KRT->graceful_restart = $3; }
  | MERGE PATHS bool kern_mp_limit {
       THIS_KRT->merge_paths = $3 ? $4 : 0;
-#ifndef KRT_ALLOW_LEARN
+#ifndef KRT_ALLOW_MERGE_PATHS
       if ($3)
 	cf_error("Path merging not supported on this platform");
 #endif

From 84cac51a51fc29349077e8cecadf1aed11f9b824 Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Tue, 30 Aug 2016 17:17:27 +0200
Subject: [PATCH 108/165] Nest: Keep multipath next hops sorted

---
 nest/route.h          |  2 ++
 nest/rt-attr.c        | 28 ++++++++++++++++++++++++++++
 nest/rt-table.c       |  7 +++++++
 proto/rip/rip.c       |  5 +----
 proto/static/static.c |  5 +----
 5 files changed, 39 insertions(+), 8 deletions(-)

diff --git a/nest/route.h b/nest/route.h
index 3969db6b..bb4674b9 100644
--- a/nest/route.h
+++ b/nest/route.h
@@ -506,6 +506,8 @@ int mpnh__same(struct mpnh *x, struct mpnh *y); /* Compare multipath nexthops */
 static inline int mpnh_same(struct mpnh *x, struct mpnh *y)
 { return (x == y) || mpnh__same(x, y); }
 struct mpnh *mpnh_merge(struct mpnh *x, struct mpnh *y, int rx, int ry, int max, linpool *lp);
+void mpnh_insert(struct mpnh **n, struct mpnh *y);
+int mpnh_is_sorted(struct mpnh *x);
 
 void rta_init(void);
 rta *rta_lookup(rta *);			/* Get rta equivalent to this one, uc++ */
diff --git a/nest/rt-attr.c b/nest/rt-attr.c
index 42b74f34..ab0069b5 100644
--- a/nest/rt-attr.c
+++ b/nest/rt-attr.c
@@ -302,6 +302,34 @@ mpnh_merge(struct mpnh *x, struct mpnh *y, int rx, int ry, int max, linpool *lp)
   return root;
 }
 
+void
+mpnh_insert(struct mpnh **n, struct mpnh *x)
+{
+  for (; *n; n = &((*n)->next))
+  {
+    int cmp = mpnh_compare_node(*n, x);
+
+    if (cmp < 0)
+      continue;
+    else if (cmp > 0)
+      break;
+    else
+      return;
+  }
+
+  x->next = *n;
+  *n = x;
+}
+
+int
+mpnh_is_sorted(struct mpnh *x)
+{
+  for (; x && x->next; x = x->next)
+    if (mpnh_compare_node(x, x->next) >= 0)
+      return 0;
+
+  return 1;
+}
 
 static struct mpnh *
 mpnh_copy(struct mpnh *o)
diff --git a/nest/rt-table.c b/nest/rt-table.c
index 9baf2849..f4df22aa 100644
--- a/nest/rt-table.c
+++ b/nest/rt-table.c
@@ -804,6 +804,13 @@ rte_validate(rte *e)
       return 0;
     }
 
+  if ((e->attrs->dest == RTD_MULTIPATH) && !mpnh_is_sorted(e->attrs->nexthops))
+    {
+      log(L_WARN "Ignoring unsorted multipath route %I/%d received via %s",
+	  n->n.prefix, n->n.pxlen, e->sender->proto->name);
+      return 0;
+    }
+
   return 1;
 }
 
diff --git a/proto/rip/rip.c b/proto/rip/rip.c
index c85fd69b..36527253 100644
--- a/proto/rip/rip.c
+++ b/proto/rip/rip.c
@@ -173,7 +173,6 @@ rip_announce_rte(struct rip_proto *p, struct rip_entry *en)
     {
       /* ECMP route */
       struct mpnh *nhs = NULL;
-      struct mpnh **nhp = &nhs;
       int num = 0;
 
       for (rt = en->routes; rt && (num < p->ecmp); rt = rt->next)
@@ -185,9 +184,7 @@ rip_announce_rte(struct rip_proto *p, struct rip_entry *en)
 	nh->gw = rt->next_hop;
 	nh->iface = rt->from->nbr->iface;
 	nh->weight = rt->from->ifa->cf->ecmp_weight;
-	nh->next = NULL;
-	*nhp = nh;
-	nhp = &(nh->next);
+	mpnh_insert(&nhs, nh);
 	num++;
 
 	if (rt->tag != rt_tag)
diff --git a/proto/static/static.c b/proto/static/static.c
index be808593..d54302a8 100644
--- a/proto/static/static.c
+++ b/proto/static/static.c
@@ -81,7 +81,6 @@ static_install(struct proto *p, struct static_route *r, struct iface *ifa)
     {
       struct static_route *r2;
       struct mpnh *nhs = NULL;
-      struct mpnh **nhp = &nhs;
 
       for (r2 = r->mp_next; r2; r2 = r2->mp_next)
 	if (r2->installed)
@@ -90,9 +89,7 @@ static_install(struct proto *p, struct static_route *r, struct iface *ifa)
 	    nh->gw = r2->via;
 	    nh->iface = r2->neigh->iface;
 	    nh->weight = r2->masklen; /* really */
-	    nh->next = NULL;
-	    *nhp = nh;
-	    nhp = &(nh->next);
+	    mpnh_insert(&nhs, nh);
 	  }
 
       /* There is at least one nexthop */

From 2feaa6931bfe39eba696b33b0c8aac13d313b223 Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Wed, 14 Sep 2016 11:40:15 +0200
Subject: [PATCH 109/165] KRT: Support for IPv6 ECMP

Linux represents IPv6 ECMP routes as a sequence of unipath routes with
the same prefix. We have to translate between our representation (one
route with multipath next hop) and the Linux representation in both
directions.

Proper learning of alien IPv6 ECMP routes still not supported.

Thanks to Mikhail Sennikovskii for the original patch.
---
 sysdep/linux/netlink.c | 354 ++++++++++++++++++++++++++++++++---------
 1 file changed, 277 insertions(+), 77 deletions(-)

diff --git a/sysdep/linux/netlink.c b/sysdep/linux/netlink.c
index fa9013bd..1ab1cda1 100644
--- a/sysdep/linux/netlink.c
+++ b/sysdep/linux/netlink.c
@@ -19,7 +19,6 @@
 #include "nest/route.h"
 #include "nest/protocol.h"
 #include "nest/iface.h"
-#include "lib/alloca.h"
 #include "lib/timer.h"
 #include "lib/unix.h"
 #include "lib/krt.h"
@@ -51,6 +50,49 @@
 #endif
 
 
+#ifdef IPV6
+#define krt_ecmp6(X) 1
+#else
+#define krt_ecmp6(X) 0
+#endif
+
+/*
+ * Structure nl_parse_state keeps state of received route processing. Ideally,
+ * we could just independently parse received Netlink messages and immediately
+ * propagate received routes to the rest of BIRD, but Linux kernel represents
+ * and announces IPv6 ECMP routes not as one route with multiple next hops (like
+ * RTA_MULTIPATH in IPv4 ECMP), but as a set of routes with the same prefix.
+ *
+ * Therefore, BIRD keeps currently processed route in nl_parse_state structure
+ * and postpones its propagation until we expect it to be final; i.e., when
+ * non-matching route is received or when the scan ends. When another matching
+ * route is received, it is merged with the already processed route to form an
+ * ECMP route. Note that merging is done only for IPv6 (merge == 1), but the
+ * postponing is done in both cases (for simplicity). All IPv4 routes are just
+ * considered non-matching.
+ *
+ * This is ignored for asynchronous notifications (every notification is handled
+ * as a separate route). It is not an issue for our routes, as we ignore such
+ * notifications anyways. But importing alien IPv6 ECMP routes does not work
+ * properly.
+ */
+
+struct nl_parse_state
+{
+  struct linpool *pool;
+  int scan;
+  int merge;
+
+  net *net;
+  rta *attrs;
+  struct krt_proto *proto;
+  s8 new;
+  s8 krt_src;
+  u8 krt_type;
+  u8 krt_proto;
+  u32 krt_metric;
+};
+
 /*
  *	Synchronous Netlink interface
  */
@@ -66,6 +108,13 @@ struct nl_sock
 
 #define NL_RX_SIZE 8192
 
+#define NL_OP_DELETE	0
+#define NL_OP_ADD	(NLM_F_CREATE|NLM_F_EXCL)
+#define NL_OP_REPLACE	(NLM_F_CREATE|NLM_F_REPLACE)
+#define NL_OP_APPEND	(NLM_F_CREATE|NLM_F_APPEND)
+
+static linpool *nl_linpool;
+
 static struct nl_sock nl_scan = {.fd = -1};	/* Netlink socket for synchronous scan */
 static struct nl_sock nl_req  = {.fd = -1};	/* Netlink socket for requests */
 
@@ -169,7 +218,7 @@ nl_get_reply(struct nl_sock *nl)
 static struct tbf rl_netlink_err = TBF_DEFAULT_LOG_LIMITS;
 
 static int
-nl_error(struct nlmsghdr *h)
+nl_error(struct nlmsghdr *h, int ignore_esrch)
 {
   struct nlmsgerr *e;
   int ec;
@@ -181,7 +230,7 @@ nl_error(struct nlmsghdr *h)
     }
   e = (struct nlmsgerr *) NLMSG_DATA(h);
   ec = -e->error;
-  if (ec)
+  if (ec && !(ignore_esrch && (ec == ESRCH)))
     log_rl(&rl_netlink_err, L_WARN "Netlink: %s", strerror(ec));
   return ec;
 }
@@ -195,14 +244,14 @@ nl_get_scan(void)
     return NULL;
   if (h->nlmsg_type == NLMSG_ERROR)
     {
-      nl_error(h);
+      nl_error(h, 0);
       return NULL;
     }
   return h;
 }
 
 static int
-nl_exchange(struct nlmsghdr *pkt)
+nl_exchange(struct nlmsghdr *pkt, int ignore_esrch)
 {
   struct nlmsghdr *h;
 
@@ -214,7 +263,7 @@ nl_exchange(struct nlmsghdr *pkt)
 	break;
       log(L_WARN "nl_exchange: Unexpected reply received");
     }
-  return nl_error(h) ? -1 : 0;
+  return nl_error(h, ignore_esrch) ? -1 : 0;
 }
 
 /*
@@ -826,7 +875,7 @@ nh_bufsize(struct mpnh *nh)
 }
 
 static int
-nl_send_route(struct krt_proto *p, rte *e, struct ea_list *eattrs, int new)
+nl_send_route(struct krt_proto *p, rte *e, struct ea_list *eattrs, int op, int dest, ip_addr gw, struct iface *iface)
 {
   eattr *ea;
   net *net = e->net;
@@ -837,13 +886,13 @@ nl_send_route(struct krt_proto *p, rte *e, struct ea_list *eattrs, int new)
     char buf[128 + KRT_METRICS_MAX*8 + nh_bufsize(a->nexthops)];
   } r;
 
-  DBG("nl_send_route(%I/%d,new=%d)\n", net->n.prefix, net->n.pxlen, new);
+  DBG("nl_send_route(%I/%d,op=%x)\n", net->n.prefix, net->n.pxlen, op);
 
   bzero(&r.h, sizeof(r.h));
   bzero(&r.r, sizeof(r.r));
-  r.h.nlmsg_type = new ? RTM_NEWROUTE : RTM_DELROUTE;
+  r.h.nlmsg_type = op ? RTM_NEWROUTE : RTM_DELROUTE;
   r.h.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
-  r.h.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK | (new ? NLM_F_CREATE|NLM_F_EXCL : 0);
+  r.h.nlmsg_flags = op | NLM_F_REQUEST | NLM_F_ACK;
 
   r.r.rtm_family = BIRD_AF;
   r.r.rtm_dst_len = net->n.pxlen;
@@ -851,15 +900,21 @@ nl_send_route(struct krt_proto *p, rte *e, struct ea_list *eattrs, int new)
   r.r.rtm_scope = RT_SCOPE_UNIVERSE;
   nl_add_attr_ipa(&r.h, sizeof(r), RTA_DST, net->n.prefix);
 
+  /*
+   * Strange behavior for RTM_DELROUTE:
+   * 1) rtm_family is ignored in IPv6, works for IPv4
+   * 2) not setting RTA_PRIORITY is different from setting default value (on IPv6)
+   * 3) not setting RTA_PRIORITY is equivalent to setting 0, which is wildcard
+   */
+
   if (krt_table_id(p) < 256)
     r.r.rtm_table = krt_table_id(p);
   else
     nl_add_attr_u32(&r.h, sizeof(r), RTA_TABLE, krt_table_id(p));
 
-  /* For route delete, we do not specify route attributes */
-  if (!new)
-    return nl_exchange(&r.h);
-
+  /* For route delete, we do not specify remaining route attributes */
+  if (op == NL_OP_DELETE)
+    goto dest;
 
   if (ea = ea_find(eattrs, EA_KRT_METRIC))
     nl_add_attr_u32(&r.h, sizeof(r), RTA_PRIORITY, ea->u.data);
@@ -886,18 +941,18 @@ nl_send_route(struct krt_proto *p, rte *e, struct ea_list *eattrs, int new)
     nl_add_metrics(&r.h, sizeof(r), metrics, KRT_METRICS_MAX);
 
 
+dest:
   /* a->iface != NULL checked in krt_capable() for router and device routes */
-
-  switch (a->dest)
+  switch (dest)
     {
     case RTD_ROUTER:
       r.r.rtm_type = RTN_UNICAST;
-      nl_add_attr_u32(&r.h, sizeof(r), RTA_OIF, a->iface->index);
-      nl_add_attr_ipa(&r.h, sizeof(r), RTA_GATEWAY, a->gw);
+      nl_add_attr_u32(&r.h, sizeof(r), RTA_OIF, iface->index);
+      nl_add_attr_ipa(&r.h, sizeof(r), RTA_GATEWAY, gw);
       break;
     case RTD_DEVICE:
       r.r.rtm_type = RTN_UNICAST;
-      nl_add_attr_u32(&r.h, sizeof(r), RTA_OIF, a->iface->index);
+      nl_add_attr_u32(&r.h, sizeof(r), RTA_OIF, iface->index);
       break;
     case RTD_BLACKHOLE:
       r.r.rtm_type = RTN_BLACKHOLE;
@@ -912,11 +967,50 @@ nl_send_route(struct krt_proto *p, rte *e, struct ea_list *eattrs, int new)
       r.r.rtm_type = RTN_UNICAST;
       nl_add_multipath(&r.h, sizeof(r), a->nexthops);
       break;
+    case RTD_NONE:
+      break;
     default:
       bug("krt_capable inconsistent with nl_send_route");
     }
 
-  return nl_exchange(&r.h);
+  /* Ignore missing for DELETE */
+  return nl_exchange(&r.h, (op == NL_OP_DELETE));
+}
+
+static inline int
+nl_add_rte(struct krt_proto *p, rte *e, struct ea_list *eattrs)
+{
+  rta *a = e->attrs;
+  int err = 0;
+
+  if (krt_ecmp6(p) && (a->dest == RTD_MULTIPATH))
+  {
+    struct mpnh *nh = a->nexthops;
+
+    err = nl_send_route(p, e, eattrs, NL_OP_ADD, RTD_ROUTER, nh->gw, nh->iface);
+    if (err < 0)
+      return err;
+
+    for (nh = nh->next; nh; nh = nh->next)
+      err += nl_send_route(p, e, eattrs, NL_OP_APPEND, RTD_ROUTER, nh->gw, nh->iface);
+
+    return err;
+  }
+
+  return nl_send_route(p, e, eattrs, NL_OP_ADD, a->dest, a->gw, a->iface);
+}
+
+static inline int
+nl_delete_rte(struct krt_proto *p, rte *e, struct ea_list *eattrs)
+{
+  int err = 0;
+
+  /* For IPv6, we just repeatedly request DELETE until we get error */
+  do
+    err = nl_send_route(p, e, eattrs, NL_OP_DELETE, RTD_NONE, IPA_NONE, NULL);
+  while (krt_ecmp6(p) && !err);
+
+  return err;
 }
 
 void
@@ -925,17 +1019,21 @@ krt_replace_rte(struct krt_proto *p, net *n, rte *new, rte *old, struct ea_list
   int err = 0;
 
   /*
-   * NULL for eattr of the old route is a little hack, but we don't
-   * get proper eattrs for old in rt_notify() anyway. NULL means no
-   * extended route attributes and therefore matches if the kernel
-   * route has any of them.
+   * We could use NL_OP_REPLACE, but route replace on Linux has some problems:
+   *
+   * 1) Does not check for matching rtm_protocol
+   * 2) Has broken semantics for IPv6 ECMP
+   * 3) Crashes some kernel version when used for IPv6 ECMP
+   *
+   * So we use NL_OP_DELETE and then NL_OP_ADD. We also do not trust the old
+   * route value, so we do not try to optimize IPv6 ECMP reconfigurations.
    */
 
   if (old)
-    nl_send_route(p, old, NULL, 0);
+    nl_delete_rte(p, old, eattrs);
 
   if (new)
-    err = nl_send_route(p, new, eattrs, 1);
+    err = nl_add_rte(p, new, eattrs);
 
   if (err < 0)
     n->n.flags |= KRF_SYNC_ERROR;
@@ -944,10 +1042,80 @@ krt_replace_rte(struct krt_proto *p, net *n, rte *new, rte *old, struct ea_list
 }
 
 
+static inline struct mpnh *
+nl_alloc_mpnh(struct nl_parse_state *s, ip_addr gw, struct iface *iface, byte weight)
+{
+  struct mpnh *nh = lp_alloc(s->pool, sizeof(struct mpnh));
+
+  nh->gw = gw;
+  nh->iface = iface;
+  nh->next = NULL;
+  nh->weight = weight;
+
+  return nh;
+}
+
+static int
+nl_mergable_route(struct nl_parse_state *s, net *net, struct krt_proto *p, uint priority, uint krt_type)
+{
+  /* Route merging must be active */
+  if (!s->merge)
+    return 0;
+
+  /* Saved and new route must have same network, proto/table, and priority */
+  if ((s->net != net) || (s->proto != p) || (s->krt_metric != priority))
+    return 0;
+
+  /* Both must be regular unicast routes */
+  if ((s->krt_type != RTN_UNICAST) || (krt_type != RTN_UNICAST))
+    return 0;
+
+  return 1;
+}
+
+static void
+nl_announce_route(struct nl_parse_state *s)
+{
+  rte *e = rte_get_temp(s->attrs);
+  e->net = s->net;
+  e->u.krt.src = s->krt_src;
+  e->u.krt.proto = s->krt_proto;
+  e->u.krt.seen = 0;
+  e->u.krt.best = 0;
+  e->u.krt.metric = s->krt_metric;
+
+  if (s->scan)
+    krt_got_route(s->proto, e);
+  else
+    krt_got_route_async(s->proto, e, s->new);
+
+  s->net = NULL;
+  s->attrs = NULL;
+  s->proto = NULL;
+  lp_flush(s->pool);
+}
+
+static inline void
+nl_parse_begin(struct nl_parse_state *s, int scan, int merge)
+{
+  memset(s, 0, sizeof (struct nl_parse_state));
+  s->pool = nl_linpool;
+  s->scan = scan;
+  s->merge = merge;
+}
+
+static inline void
+nl_parse_end(struct nl_parse_state *s)
+{
+  if (s->net)
+    nl_announce_route(s);
+}
+
+
 #define SKIP(ARG...) do { DBG("KRT: Ignoring route - " ARG); return; } while(0)
 
 static void
-nl_parse_route(struct nlmsghdr *h, int scan)
+nl_parse_route(struct nl_parse_state *s, struct nlmsghdr *h)
 {
   struct krt_proto *p;
   struct rtmsg *i;
@@ -957,6 +1125,7 @@ nl_parse_route(struct nlmsghdr *h, int scan)
   ip_addr dst = IPA_NONE;
   u32 oif = ~0;
   u32 table;
+  u32 priority = 0;
   int src;
 
   if (!(i = nl_checkin(h, sizeof(*i))))
@@ -999,7 +1168,6 @@ nl_parse_route(struct nlmsghdr *h, int scan)
   if (!p)
     SKIP("unknown table %d\n", table);
 
-
 #ifdef IPV6
   if (a[RTA_IIF])
     SKIP("IIF set\n");
@@ -1008,9 +1176,12 @@ nl_parse_route(struct nlmsghdr *h, int scan)
     SKIP("TOS %02x\n", i->rtm_tos);
 #endif
 
-  if (scan && !new)
+  if (s->scan && !new)
     SKIP("RTM_DELROUTE in scan\n");
 
+  if (a[RTA_PRIORITY])
+    priority = rta_get_u32(a[RTA_PRIORITY]);
+
   int c = ipa_classify_net(dst);
   if ((c < 0) || !(c & IADDR_HOST) || ((c & IADDR_SCOPE_MASK) <= SCOPE_LINK))
     SKIP("strange class/scope\n");
@@ -1019,6 +1190,7 @@ nl_parse_route(struct nlmsghdr *h, int scan)
   // if (i->rtm_scope != RT_SCOPE_UNIVERSE)
   //   SKIP("scope %u\n", i->rtm_scope);
 
+
   switch (i->rtm_protocol)
     {
     case RTPROT_UNSPEC:
@@ -1033,7 +1205,7 @@ nl_parse_route(struct nlmsghdr *h, int scan)
       return;
 
     case RTPROT_BIRD:
-      if (!scan)
+      if (!s->scan)
 	SKIP("echo\n");
       src = KRT_SRC_BIRD;
       break;
@@ -1045,12 +1217,14 @@ nl_parse_route(struct nlmsghdr *h, int scan)
 
   net *net = net_get(p->p.table, dst, i->rtm_dst_len);
 
-  rta ra = {
-    .src= p->p.main_source,
-    .source = RTS_INHERIT,
-    .scope = SCOPE_UNIVERSE,
-    .cast = RTC_UNICAST
-  };
+  if (s->net && !nl_mergable_route(s, net, p, priority, i->rtm_type))
+    nl_announce_route(s);
+
+  rta *ra = lp_allocz(s->pool, sizeof(rta));
+  ra->src = p->p.main_source;
+  ra->source = RTS_INHERIT;
+  ra->scope = SCOPE_UNIVERSE;
+  ra->cast = RTC_UNICAST;
 
   switch (i->rtm_type)
     {
@@ -1058,9 +1232,9 @@ nl_parse_route(struct nlmsghdr *h, int scan)
 
       if (a[RTA_MULTIPATH] && (i->rtm_family == AF_INET))
 	{
-	  ra.dest = RTD_MULTIPATH;
-	  ra.nexthops = nl_parse_multipath(p, a[RTA_MULTIPATH]);
-	  if (!ra.nexthops)
+	  ra->dest = RTD_MULTIPATH;
+	  ra->nexthops = nl_parse_multipath(p, a[RTA_MULTIPATH]);
+	  if (!ra->nexthops)
 	    {
 	      log(L_ERR "KRT: Received strange multipath route %I/%d",
 		  net->n.prefix, net->n.pxlen);
@@ -1070,8 +1244,8 @@ nl_parse_route(struct nlmsghdr *h, int scan)
 	  break;
 	}
 
-      ra.iface = if_find_by_index(oif);
-      if (!ra.iface)
+      ra->iface = if_find_by_index(oif);
+      if (!ra->iface)
 	{
 	  log(L_ERR "KRT: Received route %I/%d with unknown ifindex %u",
 	      net->n.prefix, net->n.pxlen, oif);
@@ -1081,39 +1255,39 @@ nl_parse_route(struct nlmsghdr *h, int scan)
       if (a[RTA_GATEWAY])
 	{
 	  neighbor *ng;
-	  ra.dest = RTD_ROUTER;
-	  memcpy(&ra.gw, RTA_DATA(a[RTA_GATEWAY]), sizeof(ra.gw));
-	  ipa_ntoh(ra.gw);
+	  ra->dest = RTD_ROUTER;
+	  memcpy(&ra->gw, RTA_DATA(a[RTA_GATEWAY]), sizeof(ra->gw));
+	  ipa_ntoh(ra->gw);
 
 #ifdef IPV6
 	  /* Silently skip strange 6to4 routes */
-	  if (ipa_in_net(ra.gw, IPA_NONE, 96))
+	  if (ipa_in_net(ra->gw, IPA_NONE, 96))
 	    return;
 #endif
 
-	  ng = neigh_find2(&p->p, &ra.gw, ra.iface,
+	  ng = neigh_find2(&p->p, &ra->gw, ra->iface,
 			   (i->rtm_flags & RTNH_F_ONLINK) ? NEF_ONLINK : 0);
 	  if (!ng || (ng->scope == SCOPE_HOST))
 	    {
 	      log(L_ERR "KRT: Received route %I/%d with strange next-hop %I",
-		  net->n.prefix, net->n.pxlen, ra.gw);
+		  net->n.prefix, net->n.pxlen, ra->gw);
 	      return;
 	    }
 	}
       else
 	{
-	  ra.dest = RTD_DEVICE;
+	  ra->dest = RTD_DEVICE;
 	}
 
       break;
     case RTN_BLACKHOLE:
-      ra.dest = RTD_BLACKHOLE;
+      ra->dest = RTD_BLACKHOLE;
       break;
     case RTN_UNREACHABLE:
-      ra.dest = RTD_UNREACHABLE;
+      ra->dest = RTD_UNREACHABLE;
       break;
     case RTN_PROHIBIT:
-      ra.dest = RTD_PROHIBIT;
+      ra->dest = RTD_PROHIBIT;
       break;
     /* FIXME: What about RTN_THROW? */
     default:
@@ -1121,41 +1295,30 @@ nl_parse_route(struct nlmsghdr *h, int scan)
       return;
     }
 
-  rte *e = rte_get_temp(&ra);
-  e->net = net;
-  e->u.krt.src = src;
-  e->u.krt.proto = i->rtm_protocol;
-  e->u.krt.seen = 0;
-  e->u.krt.best = 0;
-  e->u.krt.metric = 0;
-
-  if (a[RTA_PRIORITY])
-    e->u.krt.metric = rta_get_u32(a[RTA_PRIORITY]);
-
   if (a[RTA_PREFSRC])
     {
       ip_addr ps;
       memcpy(&ps, RTA_DATA(a[RTA_PREFSRC]), sizeof(ps));
       ipa_ntoh(ps);
 
-      ea_list *ea = alloca(sizeof(ea_list) + sizeof(eattr));
-      ea->next = ra.eattrs;
-      ra.eattrs = ea;
+      ea_list *ea = lp_alloc(s->pool, sizeof(ea_list) + sizeof(eattr));
+      ea->next = ra->eattrs;
+      ra->eattrs = ea;
       ea->flags = EALF_SORTED;
       ea->count = 1;
       ea->attrs[0].id = EA_KRT_PREFSRC;
       ea->attrs[0].flags = 0;
       ea->attrs[0].type = EAF_TYPE_IP_ADDRESS;
-      ea->attrs[0].u.ptr = alloca(sizeof(struct adata) + sizeof(ps));
+      ea->attrs[0].u.ptr = lp_alloc(s->pool, sizeof(struct adata) + sizeof(ps));
       ea->attrs[0].u.ptr->length = sizeof(ps);
       memcpy(ea->attrs[0].u.ptr->data, &ps, sizeof(ps));
     }
 
   if (a[RTA_FLOW])
     {
-      ea_list *ea = alloca(sizeof(ea_list) + sizeof(eattr));
-      ea->next = ra.eattrs;
-      ra.eattrs = ea;
+      ea_list *ea = lp_alloc(s->pool, sizeof(ea_list) + sizeof(eattr));
+      ea->next = ra->eattrs;
+      ra->eattrs = ea;
       ea->flags = EALF_SORTED;
       ea->count = 1;
       ea->attrs[0].id = EA_KRT_REALM;
@@ -1167,7 +1330,7 @@ nl_parse_route(struct nlmsghdr *h, int scan)
   if (a[RTA_METRICS])
     {
       u32 metrics[KRT_METRICS_MAX];
-      ea_list *ea = alloca(sizeof(ea_list) + KRT_METRICS_MAX * sizeof(eattr));
+      ea_list *ea = lp_alloc(s->pool, sizeof(ea_list) + KRT_METRICS_MAX * sizeof(eattr));
       int t, n = 0;
 
       if (nl_parse_metrics(a[RTA_METRICS], metrics, ARRAY_SIZE(metrics)) < 0)
@@ -1189,30 +1352,62 @@ nl_parse_route(struct nlmsghdr *h, int scan)
 
       if (n > 0)
         {
-	  ea->next = ra.eattrs;
+	  ea->next = ra->eattrs;
 	  ea->flags = EALF_SORTED;
 	  ea->count = n;
-	  ra.eattrs = ea;
+	  ra->eattrs = ea;
 	}
     }
 
-  if (scan)
-    krt_got_route(p, e);
+  /*
+   * Ideally, now we would send the received route to the rest of kernel code.
+   * But IPv6 ECMP routes are sent as a sequence of routes, so we postpone it
+   * and merge next hops until the end of the sequence.
+   */
+
+  if (!s->net)
+  {
+    /* Store the new route */
+    s->net = net;
+    s->attrs = ra;
+    s->proto = p;
+    s->new = new;
+    s->krt_src = src;
+    s->krt_type = i->rtm_type;
+    s->krt_proto = i->rtm_protocol;
+    s->krt_metric = priority;
+  }
   else
-    krt_got_route_async(p, e, new);
+  {
+    /* Merge next hops with the stored route */
+    rta *a = s->attrs;
+
+    if (a->dest != RTD_MULTIPATH)
+    {
+      a->dest = RTD_MULTIPATH;
+      a->nexthops = nl_alloc_mpnh(s, a->gw, a->iface, 0);
+    }
+
+    mpnh_insert(&a->nexthops, nl_alloc_mpnh(s, ra->gw, ra->iface, 0));
+  }
 }
 
 void
 krt_do_scan(struct krt_proto *p UNUSED)	/* CONFIG_ALL_TABLES_AT_ONCE => p is NULL */
 {
   struct nlmsghdr *h;
+  struct nl_parse_state s;
+
+  nl_parse_begin(&s, 1, krt_ecmp6(p));
 
   nl_request_dump(BIRD_AF, RTM_GETROUTE);
   while (h = nl_get_scan())
     if (h->nlmsg_type == RTM_NEWROUTE || h->nlmsg_type == RTM_DELROUTE)
-      nl_parse_route(h, 1);
+      nl_parse_route(&s, h);
     else
       log(L_DEBUG "nl_scan_fire: Unknown packet received (type=%d)", h->nlmsg_type);
+
+  nl_parse_end(&s);
 }
 
 /*
@@ -1225,12 +1420,16 @@ static byte *nl_async_rx_buffer;	/* Receive buffer */
 static void
 nl_async_msg(struct nlmsghdr *h)
 {
+  struct nl_parse_state s;
+
   switch (h->nlmsg_type)
     {
     case RTM_NEWROUTE:
     case RTM_DELROUTE:
       DBG("KRT: Received async route notification (%d)\n", h->nlmsg_type);
-      nl_parse_route(h, 0);
+      nl_parse_begin(&s, 0, 0);
+      nl_parse_route(&s, h);
+      nl_parse_end(&s);
       break;
     case RTM_NEWLINK:
     case RTM_DELLINK:
@@ -1353,6 +1552,7 @@ nl_open_async(void)
 void
 krt_sys_io_init(void)
 {
+  nl_linpool = lp_new(krt_pool, 4080);
   HASH_INIT(nl_table_map, krt_pool, 6);
 }
 

From 4adcb9df1bf551cc5fd1145c09af1843fdc4fe85 Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Thu, 15 Sep 2016 14:59:06 +0200
Subject: [PATCH 110/165] KRT: Add kernel metric protocol option

Kernel routes with different metrics do not clash with each other,
therefore using dedicated metric value is a reliable way to avoid
overwriting routes from other sources (e.g. kernel device routes).

Although kernel route metric could already be set as a route attribute by
filters, that is not consistent with the way how Linux kernel handles
route metric - not just a route attribute, but a part of a route key.
---
 doc/bird.sgml          | 15 ++++++++++++++-
 sysdep/linux/krt-sys.h |  1 +
 sysdep/linux/netlink.Y |  9 ++++-----
 sysdep/linux/netlink.c | 19 +++++++++++++++----
 4 files changed, 34 insertions(+), 10 deletions(-)

diff --git a/doc/bird.sgml b/doc/bird.sgml
index 1af7f2c1..9bd7df86 100644
--- a/doc/bird.sgml
+++ b/doc/bird.sgml
@@ -2388,6 +2388,17 @@ limitations can be overcome using another routing table and the pipe protocol.
 	protocol work with. Available only on systems supporting multiple
 	routing tables.
 
+	<tag>metric <m/number/</tag> (Linux)
+	Use specified value as a kernel metric (priority) for all routes sent to
+	the kernel. When multiple routes for the same network are in the kernel
+	routing table, the Linux kernel chooses one with lower metric. Also,
+	routes with different metrics do not clash with each other, therefore
+	using dedicated metric value is a reliable way to avoid overwriting
+	routes from other sources (e.g. kernel device routes). Metric 0 has a
+	special meaning of undefined metric, in which either OS default is used,
+	or per-route metric can be set using <cf/krt_metric/ attribute. Default:
+	0 (undefined).
+
 	<tag>graceful restart <m/switch/</tag>
 	Participate in graceful restart recovery. If this option is enabled and
 	a graceful restart recovery is active, the Kernel protocol will defer
@@ -2420,9 +2431,11 @@ these attributes:
 	route. See /etc/iproute2/rt_protos for common values. On BSD, it is
 	based on STATIC and PROTOx flags. The attribute is read-only.
 
-	<tag>int <cf/krt_metric/</tag>
+	<tag>int <cf/krt_metric/</tag> (Linux)
 	The kernel metric of the route. When multiple same routes are in a
 	kernel routing table, the Linux kernel chooses one with lower metric.
+	Note that preferred way to set kernel metric is to use protocol option
+	<cf/metric/, unless per-route metric values are needed.
 
 	<tag>ip <cf/krt_prefsrc/</tag> (Linux)
 	The preferred source address. Used in source address selection for
diff --git a/sysdep/linux/krt-sys.h b/sysdep/linux/krt-sys.h
index 076870f5..96688e34 100644
--- a/sysdep/linux/krt-sys.h
+++ b/sysdep/linux/krt-sys.h
@@ -88,6 +88,7 @@ static inline struct ifa * kif_get_primary_ip(struct iface *i) { return NULL; }
 
 struct krt_params {
   u32 table_id;				/* Kernel table ID we sync with */
+  u32 metric;				/* Kernel metric used for all routes */
 };
 
 struct krt_state {
diff --git a/sysdep/linux/netlink.Y b/sysdep/linux/netlink.Y
index e9c225a2..a1c22f3e 100644
--- a/sysdep/linux/netlink.Y
+++ b/sysdep/linux/netlink.Y
@@ -10,8 +10,8 @@ CF_HDR
 
 CF_DECLS
 
-CF_KEYWORDS(KERNEL, TABLE, KRT_PREFSRC, KRT_REALM, KRT_MTU, KRT_WINDOW, KRT_RTT,
-	    KRT_RTTVAR, KRT_SSTRESH, KRT_CWND, KRT_ADVMSS, KRT_REORDERING,
+CF_KEYWORDS(KERNEL, TABLE, METRIC, KRT_PREFSRC, KRT_REALM, KRT_MTU, KRT_WINDOW,
+	    KRT_RTT, KRT_RTTVAR, KRT_SSTRESH, KRT_CWND, KRT_ADVMSS, KRT_REORDERING,
 	    KRT_HOPLIMIT, KRT_INITCWND, KRT_RTO_MIN, KRT_INITRWND, KRT_QUICKACK,
 	    KRT_LOCK_MTU, KRT_LOCK_WINDOW, KRT_LOCK_RTT, KRT_LOCK_RTTVAR,
 	    KRT_LOCK_SSTRESH, KRT_LOCK_CWND, KRT_LOCK_ADVMSS, KRT_LOCK_REORDERING,
@@ -22,9 +22,8 @@ CF_GRAMMAR
 CF_ADDTO(kern_proto, kern_proto kern_sys_item ';')
 
 kern_sys_item:
-   KERNEL TABLE expr {
-	THIS_KRT->sys.table_id = $3;
-   }
+   KERNEL TABLE expr { THIS_KRT->sys.table_id = $3; }
+ | METRIC expr { THIS_KRT->sys.metric = $2; }
  ;
 
 CF_ADDTO(dynamic_attr, KRT_PREFSRC	{ $$ = f_new_dynamic_attr(EAF_TYPE_IP_ADDRESS, T_IP, EA_KRT_PREFSRC); })
diff --git a/sysdep/linux/netlink.c b/sysdep/linux/netlink.c
index 1ab1cda1..9bdcc0d2 100644
--- a/sysdep/linux/netlink.c
+++ b/sysdep/linux/netlink.c
@@ -880,6 +880,8 @@ nl_send_route(struct krt_proto *p, rte *e, struct ea_list *eattrs, int op, int d
   eattr *ea;
   net *net = e->net;
   rta *a = e->attrs;
+  u32 priority = 0;
+
   struct {
     struct nlmsghdr h;
     struct rtmsg r;
@@ -912,13 +914,20 @@ nl_send_route(struct krt_proto *p, rte *e, struct ea_list *eattrs, int op, int d
   else
     nl_add_attr_u32(&r.h, sizeof(r), RTA_TABLE, krt_table_id(p));
 
+  if (a->source == RTS_DUMMY)
+    priority = e->u.krt.metric;
+  else if (KRT_CF->sys.metric)
+    priority = KRT_CF->sys.metric;
+  else if ((op != NL_OP_DELETE) && (ea = ea_find(eattrs, EA_KRT_METRIC)))
+    priority = ea->u.data;
+
+  if (priority)
+    nl_add_attr_u32(&r.h, sizeof(r), RTA_PRIORITY, priority);
+
   /* For route delete, we do not specify remaining route attributes */
   if (op == NL_OP_DELETE)
     goto dest;
 
-  if (ea = ea_find(eattrs, EA_KRT_METRIC))
-    nl_add_attr_u32(&r.h, sizeof(r), RTA_PRIORITY, ea->u.data);
-
   if (ea = ea_find(eattrs, EA_KRT_PREFSRC))
     nl_add_attr_ipa(&r.h, sizeof(r), RTA_PREFSRC, *(ip_addr *)ea->u.ptr->data);
 
@@ -1585,19 +1594,21 @@ krt_sys_shutdown(struct krt_proto *p)
 int
 krt_sys_reconfigure(struct krt_proto *p UNUSED, struct krt_config *n, struct krt_config *o)
 {
-  return n->sys.table_id == o->sys.table_id;
+  return (n->sys.table_id == o->sys.table_id) && (n->sys.metric == o->sys.metric);
 }
 
 void
 krt_sys_init_config(struct krt_config *cf)
 {
   cf->sys.table_id = RT_TABLE_MAIN;
+  cf->sys.metric = 0;
 }
 
 void
 krt_sys_copy_config(struct krt_config *d, struct krt_config *s)
 {
   d->sys.table_id = s->sys.table_id;
+  d->sys.metric = s->sys.metric;
 }
 
 static const char *krt_metrics_names[KRT_METRICS_MAX] = {

From bc00f058154bb4a630d24d64a55b5f181d235c63 Mon Sep 17 00:00:00 2001
From: Pavel Tvrdik <pawel.tvrdik@gmail.com>
Date: Tue, 6 Sep 2016 17:18:15 +0200
Subject: [PATCH 111/165] Filter: Prefer xmalloc/xfree to malloc/free

---
 filter/tree.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/filter/tree.c b/filter/tree.c
index 59ebf579..328c7184 100644
--- a/filter/tree.c
+++ b/filter/tree.c
@@ -82,7 +82,7 @@ build_tree(struct f_tree *from)
   if (len <= 1024)
     buf = alloca(len * sizeof(struct f_tree *));
   else
-    buf = malloc(len * sizeof(struct f_tree *));
+    buf = xmalloc(len * sizeof(struct f_tree *));
 
   /* Convert a degenerated tree into an sorted array */
   i = 0;
@@ -94,7 +94,7 @@ build_tree(struct f_tree *from)
   root = build_tree_rec(buf, 0, len);
 
   if (len > 1024)
-    free(buf);
+    xfree(buf);
 
   return root;
 }

From a290da25a16b7c79d4a7a87f522b4068bca04979 Mon Sep 17 00:00:00 2001
From: Pavel Tvrdik <pawel.tvrdik@gmail.com>
Date: Tue, 6 Sep 2016 17:08:45 +0200
Subject: [PATCH 112/165] rt-table: Fix kernel protocol export filter memory
 bug

Kernel protocol calls rt_export_merged(), which used @rte_update_pool for
temporary allocations, supposing it is called from other functions from
rt-table.c that handles locking and flushing of the linpool. Therefore,
linpool was not flushed properly and memory leaked.

Add linpool argument to rt_export_merged() and use @krt_filter_lp when
called from kernel protocol.

Thanks to Justin Cattle and Alexander Frolkin for the bugreport.

(Commit squashed and updated by Ondrej Zajicek)
---
 nest/route.h      |  2 +-
 nest/rt-table.c   | 32 +++++++++++++++++++-------------
 sysdep/unix/krt.c |  2 +-
 3 files changed, 21 insertions(+), 15 deletions(-)

diff --git a/nest/route.h b/nest/route.h
index bb4674b9..2fcb189a 100644
--- a/nest/route.h
+++ b/nest/route.h
@@ -276,7 +276,7 @@ void rte_update2(struct announce_hook *ah, net *net, rte *new, struct rte_src *s
 static inline void rte_update(struct proto *p, net *net, rte *new) { rte_update2(p->main_ahook, net, new, p->main_source); }
 void rte_discard(rtable *tab, rte *old);
 int rt_examine(rtable *t, ip_addr prefix, int pxlen, struct proto *p, struct filter *filter);
-rte *rt_export_merged(struct announce_hook *ah, net *net, rte **rt_free, struct ea_list **tmpa, int silent);
+rte *rt_export_merged(struct announce_hook *ah, net *net, rte **rt_free, struct ea_list **tmpa, linpool *pool, int silent);
 void rt_refresh_begin(rtable *t, struct announce_hook *ah);
 void rt_refresh_end(rtable *t, struct announce_hook *ah);
 void rte_dump(rte *);
diff --git a/nest/rt-table.c b/nest/rt-table.c
index f4df22aa..d3aba085 100644
--- a/nest/rt-table.c
+++ b/nest/rt-table.c
@@ -245,7 +245,7 @@ rte_trace_out(uint flag, struct proto *p, rte *e, char *msg)
 }
 
 static rte *
-export_filter(struct announce_hook *ah, rte *rt0, rte **rt_free, ea_list **tmpa, int silent)
+export_filter_(struct announce_hook *ah, rte *rt0, rte **rt_free, ea_list **tmpa, linpool *pool, int silent)
 {
   struct proto *p = ah->proto;
   struct filter *filter = ah->out_filter;
@@ -260,9 +260,9 @@ export_filter(struct announce_hook *ah, rte *rt0, rte **rt_free, ea_list **tmpa,
   if (!tmpa)
     tmpa = &tmpb;
 
-  *tmpa = make_tmp_attrs(rt, rte_update_pool);
+  *tmpa = make_tmp_attrs(rt, pool);
 
-  v = p->import_control ? p->import_control(p, &rt, tmpa, rte_update_pool) : 0;
+  v = p->import_control ? p->import_control(p, &rt, tmpa, pool) : 0;
   if (v < 0)
     {
       if (silent)
@@ -281,7 +281,7 @@ export_filter(struct announce_hook *ah, rte *rt0, rte **rt_free, ea_list **tmpa,
     }
 
   v = filter && ((filter == FILTER_REJECT) ||
-		 (f_run(filter, &rt, tmpa, rte_update_pool, FF_FORCE_TMPATTR) > F_ACCEPT));
+		 (f_run(filter, &rt, tmpa, pool, FF_FORCE_TMPATTR) > F_ACCEPT));
   if (v)
     {
       if (silent)
@@ -304,6 +304,12 @@ export_filter(struct announce_hook *ah, rte *rt0, rte **rt_free, ea_list **tmpa,
   return NULL;
 }
 
+static inline rte *
+export_filter(struct announce_hook *ah, rte *rt0, rte **rt_free, ea_list **tmpa, int silent)
+{
+  return export_filter_(ah, rt0, rt_free, tmpa, rte_update_pool, silent);
+}
+
 static void
 do_rt_notify(struct announce_hook *ah, net *net, rte *new, rte *old, ea_list *tmpa, int refeed)
 {
@@ -586,7 +592,7 @@ rt_notify_accepted(struct announce_hook *ah, net *net, rte *new_changed, rte *ol
 
 
 static struct mpnh *
-mpnh_merge_rta(struct mpnh *nhs, rta *a, int max)
+mpnh_merge_rta(struct mpnh *nhs, rta *a, linpool *pool, int max)
 {
   struct mpnh nh = { .gw = a->gw, .iface = a->iface };
   struct mpnh *nh2 = (a->dest == RTD_MULTIPATH) ? a->nexthops : &nh;
@@ -594,7 +600,7 @@ mpnh_merge_rta(struct mpnh *nhs, rta *a, int max)
 }
 
 rte *
-rt_export_merged(struct announce_hook *ah, net *net, rte **rt_free, ea_list **tmpa, int silent)
+rt_export_merged(struct announce_hook *ah, net *net, rte **rt_free, ea_list **tmpa, linpool *pool, int silent)
 {
   // struct proto *p = ah->proto;
   struct mpnh *nhs = NULL;
@@ -606,7 +612,7 @@ rt_export_merged(struct announce_hook *ah, net *net, rte **rt_free, ea_list **tm
   if (!rte_is_valid(best0))
     return NULL;
 
-  best = export_filter(ah, best0, rt_free, tmpa, silent);
+  best = export_filter_(ah, best0, rt_free, tmpa, pool, silent);
 
   if (!best || !rte_is_reachable(best))
     return best;
@@ -616,13 +622,13 @@ rt_export_merged(struct announce_hook *ah, net *net, rte **rt_free, ea_list **tm
     if (!rte_mergable(best0, rt0))
       continue;
 
-    rt = export_filter(ah, rt0, &tmp, NULL, 1);
+    rt = export_filter_(ah, rt0, &tmp, NULL, pool, 1);
 
     if (!rt)
       continue;
 
     if (rte_is_reachable(rt))
-      nhs = mpnh_merge_rta(nhs, rt->attrs, ah->proto->merge_limit);
+      nhs = mpnh_merge_rta(nhs, rt->attrs, pool, ah->proto->merge_limit);
 
     if (tmp)
       rte_free(tmp);
@@ -630,11 +636,11 @@ rt_export_merged(struct announce_hook *ah, net *net, rte **rt_free, ea_list **tm
 
   if (nhs)
   {
-    nhs = mpnh_merge_rta(nhs, best->attrs, ah->proto->merge_limit);
+    nhs = mpnh_merge_rta(nhs, best->attrs, pool, ah->proto->merge_limit);
 
     if (nhs->next)
     {
-      best = rte_cow_rta(best, rte_update_pool);
+      best = rte_cow_rta(best, pool);
       best->attrs->dest = RTD_MULTIPATH;
       best->attrs->nexthops = nhs;
     }
@@ -685,7 +691,7 @@ rt_notify_merged(struct announce_hook *ah, net *net, rte *new_changed, rte *old_
 
   /* Prepare new merged route */
   if (new_best)
-    new_best = rt_export_merged(ah, net, &new_best_free, &tmpa, 0);
+    new_best = rt_export_merged(ah, net, &new_best_free, &tmpa, rte_update_pool, 0);
 
   /* Prepare old merged route (without proper merged next hops) */
   /* There are some issues with running filter on old route - see rt_notify_basic() */
@@ -2470,7 +2476,7 @@ rt_show_net(struct cli *c, net *n, struct rt_show_data *d)
       if ((d->export_mode == RSEM_EXPORT) && (d->export_protocol->accept_ra_types == RA_MERGED))
         {
 	  rte *rt_free;
-	  e = rt_export_merged(a, n, &rt_free, &tmpa, 1);
+	  e = rt_export_merged(a, n, &rt_free, &tmpa, rte_update_pool, 1);
 	  pass = 1;
 
 	  if (!e)
diff --git a/sysdep/unix/krt.c b/sysdep/unix/krt.c
index f5dee877..ef98cb3a 100644
--- a/sysdep/unix/krt.c
+++ b/sysdep/unix/krt.c
@@ -613,7 +613,7 @@ krt_export_net(struct krt_proto *p, net *net, rte **rt_free, ea_list **tmpa)
   rte *rt;
 
   if (p->p.accept_ra_types == RA_MERGED)
-    return rt_export_merged(ah, net, rt_free, tmpa, 1);
+    return rt_export_merged(ah, net, rt_free, tmpa, krt_filter_lp, 1);
 
   rt = net->routes;
   *rt_free = NULL;

From 0f5054f6850c7419933a6337a34263f565663ee3 Mon Sep 17 00:00:00 2001
From: Pavel Tvrdik <pawel.tvrdik@gmail.com>
Date: Thu, 8 Sep 2016 13:45:36 +0200
Subject: [PATCH 113/165] BFD: Fix invalid read from pollfd array

It is possible that sockets_add() are called between sockets_prepare()
and sockets_fire() during poll loop in birdloop_main(), so we need to
use loop->poll_fd.used instead of loop->sock_num to find the last field.
---
 proto/bfd/io.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/proto/bfd/io.c b/proto/bfd/io.c
index 79ed9af7..8f4f5007 100644
--- a/proto/bfd/io.c
+++ b/proto/bfd/io.c
@@ -589,7 +589,7 @@ sockets_fire(struct birdloop *loop)
   times_update(loop);
 
   /* Last fd is internal wakeup fd */
-  if (pfd[loop->sock_num].revents & POLLIN)
+  if (pfd[poll_num].revents & POLLIN)
     wakeup_drain(loop);
 
   int i;

From 6273fcf072fc5789ebabf4f1acd6fc6c9fa143ee Mon Sep 17 00:00:00 2001
From: Pavel Tvrdik <pawel.tvrdik@gmail.com>
Date: Wed, 7 Sep 2016 14:58:51 +0200
Subject: [PATCH 114/165] Add stdlib.h to client/commands.c

---
 client/commands.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/client/commands.c b/client/commands.c
index 2dae23e1..29e71418 100644
--- a/client/commands.c
+++ b/client/commands.c
@@ -8,6 +8,7 @@
 
 #include <stdio.h>
 #include <ctype.h>
+#include <stdlib.h>
 
 #include "nest/bird.h"
 #include "lib/resource.h"

From 292f7858e60b0dffd8c06f6818d90ccf3b34e0b2 Mon Sep 17 00:00:00 2001
From: Pavel Tvrdik <pawel.tvrdik@gmail.com>
Date: Thu, 8 Sep 2016 16:27:40 +0200
Subject: [PATCH 115/165] Main: Improve BIRD help messages

---
 sysdep/unix/main.c | 60 +++++++++++++++++++++++++++++++++++++---------
 1 file changed, 49 insertions(+), 11 deletions(-)

diff --git a/sysdep/unix/main.c b/sysdep/unix/main.c
index 11a4acc6..a7989920 100644
--- a/sysdep/unix/main.c
+++ b/sysdep/unix/main.c
@@ -617,7 +617,7 @@ signal_init(void)
  *	Parsing of command-line arguments
  */
 
-static char *opt_list = "c:dD:ps:P:u:g:flR";
+static char *opt_list = "c:dD:ps:P:u:g:flRh";
 static int parse_and_exit;
 char *bird_name;
 static char *use_user;
@@ -625,10 +625,43 @@ static char *use_group;
 static int run_in_foreground = 0;
 
 static void
-usage(void)
+display_usage(void)
 {
-  fprintf(stderr, "Usage: %s [-c <config-file>] [-d] [-D <debug-file>] [-p] [-s <control-socket>] [-P <pid-file>] [-u <user>] [-g <group>] [-f] [-l] [-R]\n", bird_name);
-  exit(1);
+  fprintf(stderr, "Usage: %s [--version] [--help] [-c <config-file>] [OPTIONS]\n", bird_name);
+}
+
+static void
+display_help(void)
+{
+  display_usage();
+
+  fprintf(stderr,
+    "\n"
+    "Options: \n"
+    "  -c <config-file>     Use given configuration file instead\n"
+    "                       of prefix/etc/bird.conf\n"
+    "  -d                   Enable debug messages and run bird in foreground\n"
+    "  -D <debug-file>      Log debug messages to given file instead of stderr\n"
+    "  -f                   Run bird in foreground\n"
+    "  -g <group>           Use given group ID\n"
+    "  -h, --help           Display this information\n"
+    "  -l                   Look for a configuration file and a communication socket\n"
+    "                       file in the current working directory\n"
+    "  -p                   Test configuration file and exit without start\n"
+    "  -P <pid-file>        Create a PID file with given filename\n"
+    "  -R                   Apply graceful restart recovery after start\n"
+    "  -s <control-socket>  Use given filename for a control socket\n"
+    "  -u <user>            Drop privileges and use given user ID\n"
+    "  --version            Display version of BIRD\n");
+
+  exit(0);
+}
+
+static void
+display_version(void)
+{
+  fprintf(stderr, "BIRD version " BIRD_VERSION "\n");
+  exit(0);
 }
 
 static inline char *
@@ -702,12 +735,9 @@ parse_args(int argc, char **argv)
   if (argc == 2)
     {
       if (!strcmp(argv[1], "--version"))
-	{
-	  fprintf(stderr, "BIRD version " BIRD_VERSION "\n");
-	  exit(0);
-	}
+	display_version();
       if (!strcmp(argv[1], "--help"))
-	usage();
+	display_help();
     }
   while ((c = getopt(argc, argv, opt_list)) >= 0)
     switch (c)
@@ -751,11 +781,19 @@ parse_args(int argc, char **argv)
       case 'R':
 	graceful_restart_recovery();
 	break;
+      case 'h':
+	display_help();
+	break;
       default:
-	usage();
+	fputc('\n', stderr);
+	display_usage();
+	exit(1);
       }
   if (optind < argc)
-    usage();
+   {
+     display_usage();
+     exit(1);
+   }
 }
 
 /*

From 6e75d0d27fe85f12a22928e5729465823704281e Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Mon, 19 Sep 2016 12:29:56 +0200
Subject: [PATCH 116/165] KRT: Add krt_scope attribute

Add a new route attribute, krt_scope, to expose the Linux kernel route
scope. Constants from /etc/iproute2/rt_scopes (prefixed by "ips_") are
expected to be used with the attribute. Both import and export are
supported.

Also, the patch fixes device route export to the kernel, by setting link
scope automatically.
---
 doc/bird.sgml          |  9 +++++++++
 sysdep/linux/krt-sys.h |  1 +
 sysdep/linux/netlink.Y |  3 ++-
 sysdep/linux/netlink.c | 33 ++++++++++++++++++++++++++-------
 4 files changed, 38 insertions(+), 8 deletions(-)

diff --git a/doc/bird.sgml b/doc/bird.sgml
index 9bd7df86..af5b7980 100644
--- a/doc/bird.sgml
+++ b/doc/bird.sgml
@@ -2443,6 +2443,15 @@ these attributes:
 
 	<tag>int <cf/krt_realm/</tag> (Linux)
 	The realm of the route. Can be used for traffic classification.
+
+	<tag>int <cf/krt_scope/</tag> (Linux IPv4)
+	The scope of the route. Valid values are 0-254, although Linux kernel
+	may reject some values depending on route type and nexthop. It is
+	supposed to represent `indirectness' of the route, where nexthops of
+	routes are resolved through routes with a higher scope, but in current
+	kernels anything below <it/link/ (253) is treated as <it/global/ (0).
+	When not present, global scope is implied for all routes except device
+	routes, where link scope is used by default.
 </descrip>
 
 <p>In Linux, there is also a plenty of obscure route attributes mostly focused
diff --git a/sysdep/linux/krt-sys.h b/sysdep/linux/krt-sys.h
index 96688e34..6d6586d1 100644
--- a/sysdep/linux/krt-sys.h
+++ b/sysdep/linux/krt-sys.h
@@ -36,6 +36,7 @@ static inline struct ifa * kif_get_primary_ip(struct iface *i) { return NULL; }
 
 #define EA_KRT_PREFSRC		EA_CODE(EAP_KRT, 0x10)
 #define EA_KRT_REALM		EA_CODE(EAP_KRT, 0x11)
+#define EA_KRT_SCOPE		EA_CODE(EAP_KRT, 0x12)
 
 
 #define KRT_METRICS_MAX		0x10	/* RTAX_QUICKACK+1 */
diff --git a/sysdep/linux/netlink.Y b/sysdep/linux/netlink.Y
index a1c22f3e..f577244d 100644
--- a/sysdep/linux/netlink.Y
+++ b/sysdep/linux/netlink.Y
@@ -10,7 +10,7 @@ CF_HDR
 
 CF_DECLS
 
-CF_KEYWORDS(KERNEL, TABLE, METRIC, KRT_PREFSRC, KRT_REALM, KRT_MTU, KRT_WINDOW,
+CF_KEYWORDS(KERNEL, TABLE, METRIC, KRT_PREFSRC, KRT_REALM, KRT_SCOPE, KRT_MTU, KRT_WINDOW,
 	    KRT_RTT, KRT_RTTVAR, KRT_SSTRESH, KRT_CWND, KRT_ADVMSS, KRT_REORDERING,
 	    KRT_HOPLIMIT, KRT_INITCWND, KRT_RTO_MIN, KRT_INITRWND, KRT_QUICKACK,
 	    KRT_LOCK_MTU, KRT_LOCK_WINDOW, KRT_LOCK_RTT, KRT_LOCK_RTTVAR,
@@ -28,6 +28,7 @@ kern_sys_item:
 
 CF_ADDTO(dynamic_attr, KRT_PREFSRC	{ $$ = f_new_dynamic_attr(EAF_TYPE_IP_ADDRESS, T_IP, EA_KRT_PREFSRC); })
 CF_ADDTO(dynamic_attr, KRT_REALM	{ $$ = f_new_dynamic_attr(EAF_TYPE_INT, T_INT, EA_KRT_REALM); })
+CF_ADDTO(dynamic_attr, KRT_SCOPE	{ $$ = f_new_dynamic_attr(EAF_TYPE_INT, T_INT, EA_KRT_SCOPE); })
 
 CF_ADDTO(dynamic_attr, KRT_MTU		{ $$ = f_new_dynamic_attr(EAF_TYPE_INT, T_INT, EA_KRT_MTU); })
 CF_ADDTO(dynamic_attr, KRT_WINDOW	{ $$ = f_new_dynamic_attr(EAF_TYPE_INT, T_INT, EA_KRT_WINDOW); })
diff --git a/sysdep/linux/netlink.c b/sysdep/linux/netlink.c
index 9bdcc0d2..1490213e 100644
--- a/sysdep/linux/netlink.c
+++ b/sysdep/linux/netlink.c
@@ -899,7 +899,7 @@ nl_send_route(struct krt_proto *p, rte *e, struct ea_list *eattrs, int op, int d
   r.r.rtm_family = BIRD_AF;
   r.r.rtm_dst_len = net->n.pxlen;
   r.r.rtm_protocol = RTPROT_BIRD;
-  r.r.rtm_scope = RT_SCOPE_UNIVERSE;
+  r.r.rtm_scope = RT_SCOPE_NOWHERE;
   nl_add_attr_ipa(&r.h, sizeof(r), RTA_DST, net->n.prefix);
 
   /*
@@ -928,6 +928,12 @@ nl_send_route(struct krt_proto *p, rte *e, struct ea_list *eattrs, int op, int d
   if (op == NL_OP_DELETE)
     goto dest;
 
+  /* Default scope is LINK for device routes, UNIVERSE otherwise */
+  if (ea = ea_find(eattrs, EA_KRT_SCOPE))
+    r.r.rtm_scope = ea->u.data;
+  else
+    r.r.rtm_scope = (dest == RTD_DEVICE) ? RT_SCOPE_LINK : RT_SCOPE_UNIVERSE;
+
   if (ea = ea_find(eattrs, EA_KRT_PREFSRC))
     nl_add_attr_ipa(&r.h, sizeof(r), RTA_PREFSRC, *(ip_addr *)ea->u.ptr->data);
 
@@ -1135,6 +1141,7 @@ nl_parse_route(struct nl_parse_state *s, struct nlmsghdr *h)
   u32 oif = ~0;
   u32 table;
   u32 priority = 0;
+  u32 def_scope = RT_SCOPE_UNIVERSE;
   int src;
 
   if (!(i = nl_checkin(h, sizeof(*i))))
@@ -1157,7 +1164,6 @@ nl_parse_route(struct nl_parse_state *s, struct nlmsghdr *h)
 	return;
     }
 
-
   if (a[RTA_DST])
     {
       memcpy(&dst, RTA_DATA(a[RTA_DST]), sizeof(dst));
@@ -1195,11 +1201,6 @@ nl_parse_route(struct nl_parse_state *s, struct nlmsghdr *h)
   if ((c < 0) || !(c & IADDR_HOST) || ((c & IADDR_SCOPE_MASK) <= SCOPE_LINK))
     SKIP("strange class/scope\n");
 
-  // ignore rtm_scope, it is not a real scope
-  // if (i->rtm_scope != RT_SCOPE_UNIVERSE)
-  //   SKIP("scope %u\n", i->rtm_scope);
-
-
   switch (i->rtm_protocol)
     {
     case RTPROT_UNSPEC:
@@ -1286,6 +1287,7 @@ nl_parse_route(struct nl_parse_state *s, struct nlmsghdr *h)
       else
 	{
 	  ra->dest = RTD_DEVICE;
+	  def_scope = RT_SCOPE_LINK;
 	}
 
       break;
@@ -1304,6 +1306,19 @@ nl_parse_route(struct nl_parse_state *s, struct nlmsghdr *h)
       return;
     }
 
+  if (i->rtm_scope != def_scope)
+    {
+      ea_list *ea = lp_alloc(s->pool, sizeof(ea_list) + sizeof(eattr));
+      ea->next = ra->eattrs;
+      ra->eattrs = ea;
+      ea->flags = EALF_SORTED;
+      ea->count = 1;
+      ea->attrs[0].id = EA_KRT_SCOPE;
+      ea->attrs[0].flags = 0;
+      ea->attrs[0].type = EAF_TYPE_INT;
+      ea->attrs[0].u.data = i->rtm_scope;
+    }
+
   if (a[RTA_PREFSRC])
     {
       ip_addr ps;
@@ -1633,6 +1648,10 @@ krt_sys_get_attr(eattr *a, byte *buf, int buflen UNUSED)
     bsprintf(buf, "realm");
     return GA_NAME;
 
+  case EA_KRT_SCOPE:
+    bsprintf(buf, "scope");
+    return GA_NAME;
+
   case EA_KRT_LOCK:
     buf += bsprintf(buf, "lock:");
     ea_format_bitfield(a, buf, buflen, krt_metrics_names, 2, KRT_METRICS_MAX);

From 75ac3d199d1fd5b199dd753915234b8634c272e5 Mon Sep 17 00:00:00 2001
From: Ondrej Zajicek <santiago@crfreenet.org>
Date: Wed, 21 Sep 2016 12:07:59 +0200
Subject: [PATCH 117/165] Remove cvsignore

We have gitignore
---
 .cvsignore | 1 -
 .gitignore | 6 +++++-
 2 files changed, 5 insertions(+), 2 deletions(-)
 delete mode 100644 .cvsignore

diff --git a/.cvsignore b/.cvsignore
deleted file mode 100644
index dc557db3..00000000
--- a/.cvsignore
+++ /dev/null
@@ -1 +0,0 @@
-bird.conf
diff --git a/.gitignore b/.gitignore
index 77dea498..52510836 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,6 @@
+/autom4te.cache/
+/doc/*.html
+/obj/
 /Makefile
 /bird
 /birdc
@@ -5,4 +8,5 @@
 /config.log
 /config.status
 /configure
-/obj/
+/bird.conf
+/bird.log

From 768d5e1058693d2bfb7c3bcbe04306097c3246a0 Mon Sep 17 00:00:00 2001
From: Pavel Tvrdik <pawel.tvrdik@gmail.com>
Date: Tue, 20 Sep 2016 15:13:01 +0200
Subject: [PATCH 118/165] Add !~ operator to filter grammar

---
 conf/cf-lex.l   |  1 +
 conf/confbase.Y |  2 +-
 doc/bird.sgml   | 38 +++++++++++++++++++-------------------
 filter/config.Y |  1 +
 filter/filter.c | 10 ++++++++++
 5 files changed, 32 insertions(+), 20 deletions(-)

diff --git a/conf/cf-lex.l b/conf/cf-lex.l
index 61ea4527..d2aa6402 100644
--- a/conf/cf-lex.l
+++ b/conf/cf-lex.l
@@ -246,6 +246,7 @@ else: {
 <CCOMM>.
 
 \!\= return NEQ;
+\!\~ return NMA;
 \<\= return LEQ;
 \>\= return GEQ;
 \&\& return AND;
diff --git a/conf/confbase.Y b/conf/confbase.Y
index 5f487c1d..c14c23c7 100644
--- a/conf/confbase.Y
+++ b/conf/confbase.Y
@@ -82,7 +82,7 @@ CF_DECLS
 
 %nonassoc PREFIX_DUMMY
 %left AND OR
-%nonassoc '=' '<' '>' '~' GEQ LEQ NEQ PO PC
+%nonassoc '=' '<' '>' '~' GEQ LEQ NEQ NMA PO PC
 %left '+' '-'
 %left '*' '/' '%'
 %left '!'
diff --git a/doc/bird.sgml b/doc/bird.sgml
index af5b7980..07a2d470 100644
--- a/doc/bird.sgml
+++ b/doc/bird.sgml
@@ -1016,9 +1016,9 @@ foot).
 	of type <cf/string/, print such variables, use standard string
 	comparison operations (e.g. <cf/=, !=, &lt;, &gt;, &lt;=, &gt;=/), but
 	you can't concatenate two strings. String literals are written as
-	<cf/"This is a string constant"/. Additionally matching <cf/&tilde;/
-	operator could be used to match a string value against a shell pattern
-	(represented also as a string).
+	<cf/"This is a string constant"/. Additionally matching (<cf/&tilde;,
+	!&tilde;/) operators could be used to match a string value against
+	a shell pattern (represented also as a string).
 
 	<tag/ip/
 	This type can hold a single IP address. Depending on the compile-time
@@ -1202,9 +1202,9 @@ foot).
 	<tag/eclist/
 	Eclist is a data type used for BGP extended community lists. Eclists
 	are very similar to clists, but they are sets of ECs instead of pairs.
-	The same operations (like <cf/add/, <cf/delete/, or <cf/&tilde;/
-	membership operator) can be used to modify or test eclists, with ECs
-	instead of pairs as arguments.
+	The same operations (like <cf/add/, <cf/delete/ or <cf/&tilde;/ and
+	<cf/!&tilde;/ membership operators) can be used to modify or test
+	eclists, with ECs instead of pairs as arguments.
 </descrip>
 
 
@@ -1213,19 +1213,19 @@ foot).
 <p>The filter language supports common integer operators <cf>(+,-,*,/)</cf>,
 parentheses <cf/(a*(b+c))/, comparison <cf/(a=b, a!=b, a&lt;b, a&gt;=b)/.
 Logical operations include unary not (<cf/!/), and (<cf/&amp;&amp;/) and or
-(<cf/&verbar;&verbar;/). Special operators include <cf/&tilde;/ for "is element
-of a set" operation - it can be used on element and set of elements of the same
-type (returning true if element is contained in the given set), or on two
-strings (returning true if first string matches a shell-like pattern stored in
-second string) or on IP and prefix (returning true if IP is within the range
-defined by that prefix), or on prefix and prefix (returning true if first prefix
-is more specific than second one) or on bgppath and bgpmask (returning true if
-the path matches the mask) or on number and bgppath (returning true if the
-number is in the path) or on bgppath and int (number) set (returning true if any
-ASN from the path is in the set) or on pair/quad and clist (returning true if
-the pair/quad is element of the clist) or on clist and pair/quad set (returning
-true if there is an element of the clist that is also a member of the pair/quad
-set).
+(<cf/&verbar;&verbar;/). Special operators include (<cf/&tilde;/,
+<cf/!&tilde;/) for "is (not) element of a set" operation - it can be used on
+element and set of elements of the same type (returning true if element is
+contained in the given set), or on two strings (returning true if first string
+matches a shell-like pattern stored in second string) or on IP and prefix
+(returning true if IP is within the range defined by that prefix), or on prefix
+and prefix (returning true if first prefix is more specific than second one) or
+on bgppath and bgpmask (returning true if the path matches the mask) or on
+number and bgppath (returning true if the number is in the path) or on bgppath
+and int (number) set (returning true if any ASN from the path is in the set) or
+on pair/quad and clist (returning true if the pair/quad is element of the
+clist) or on clist and pair/quad set (returning true if there is an element of
+the clist that is also a member of the pair/quad set).
 
 <p>There is one operator related to ROA infrastructure - <cf/roa_check()/. It
 examines a ROA table and does RFC 6483 route origin validation for a given
diff --git a/filter/config.Y b/filter/config.Y
index da605710..9fffd651 100644
--- a/filter/config.Y
+++ b/filter/config.Y
@@ -735,6 +735,7 @@ term:
  | term '>' term     { $$ = f_new_inst(); $$->code = '<';        $$->a1.p = $3; $$->a2.p = $1; }
  | term GEQ term { $$ = f_new_inst(); $$->code = P('<','=');     $$->a1.p = $3; $$->a2.p = $1; }
  | term '~' term     { $$ = f_new_inst(); $$->code = '~';        $$->a1.p = $1; $$->a2.p = $3; }
+ | term NMA term { $$ = f_new_inst(); $$->code = P('!','~');     $$->a1.p = $1; $$->a2.p = $3; }
  | '!' term { $$ = f_new_inst(); $$->code = '!'; $$->a1.p = $2; }
  | DEFINED '(' term ')' { $$ = f_new_inst(); $$->code = P('d','e');  $$->a1.p = $3; }
 
diff --git a/filter/filter.c b/filter/filter.c
index ccdfed36..2f5f00d8 100644
--- a/filter/filter.c
+++ b/filter/filter.c
@@ -716,6 +716,16 @@ interpret(struct f_inst *what)
       runtime( "~ applied on unknown type pair" );
     res.val.i = !!res.val.i;
     break;
+
+  case P('!','~'):
+    TWOARGS;
+    res.type = T_BOOL;
+    res.val.i = val_in_range(v1, v2);
+    if (res.val.i == CMP_ERROR)
+      runtime( "!~ applied on unknown type pair" );
+    res.val.i = !res.val.i;
+    break;
+
   case P('d','e'):
     ONEARG;
     res.type = T_BOOL;

From 79e2293ab2abbd92bb3326a95759a4ca32d9af81 Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Thu, 22 Sep 2016 13:34:56 +0200
Subject: [PATCH 119/165] NEWS and version update

---
 NEWS            | 13 +++++++++++++
 misc/bird.spec  |  2 +-
 sysdep/config.h |  2 +-
 3 files changed, 15 insertions(+), 2 deletions(-)

diff --git a/NEWS b/NEWS
index f689d195..525d7007 100644
--- a/NEWS
+++ b/NEWS
@@ -1,3 +1,16 @@
+Version 1.6.1 (2016-09-22)
+  o Support for IPv6 ECMP
+  o Better handling of IPv6 tentative addresses
+  o Several updates and fixes in Babel protocol
+  o Filter: New !~ operator
+  o Filter: ASN ranges in bgpmask
+  o KRT: New kernel protocol option 'metric'
+  o KRT: New route attribute 'krt_scope'
+  o Improved BIRD help messages
+  o Fixes memory leak in BGP multipath
+  o Fixes handling of empty path segments in BGP AS_PATH
+  o Several bug fixes
+
 Version 1.6.0 (2016-04-29)
   o Major RIP protocol redesign
   o New Babel routing protocol
diff --git a/misc/bird.spec b/misc/bird.spec
index 857f03e5..89531d64 100644
--- a/misc/bird.spec
+++ b/misc/bird.spec
@@ -1,6 +1,6 @@
 Summary: BIRD Internet Routing Daemon
 Name: bird
-Version: 1.6.0
+Version: 1.6.1
 Release: 1
 Copyright: GPL
 Group: Networking/Daemons
diff --git a/sysdep/config.h b/sysdep/config.h
index a8d58349..e83a934f 100644
--- a/sysdep/config.h
+++ b/sysdep/config.h
@@ -7,7 +7,7 @@
 #define _BIRD_CONFIG_H_
 
 /* BIRD version */
-#define BIRD_VERSION "1.6.0"
+#define BIRD_VERSION "1.6.1"
 
 /* Include parameters determined by configure script */
 #include "sysdep/autoconf.h"

From ccd2a3eda24230df550e9880f4340fc6341c8f52 Mon Sep 17 00:00:00 2001
From: Jan Moskyto Matejka <mq@ucw.cz>
Date: Thu, 29 Sep 2016 12:00:53 +0200
Subject: [PATCH 120/165] Kernel socket missing err_hook fix

Thanks to Tim Weippert for bugreport.
---
 sysdep/bsd/krt-sock.c  | 7 +++++++
 sysdep/linux/netlink.c | 7 +++++++
 sysdep/unix/io.c       | 2 +-
 3 files changed, 15 insertions(+), 1 deletion(-)

diff --git a/sysdep/bsd/krt-sock.c b/sysdep/bsd/krt-sock.c
index 6ff3b2b7..f2ae81c3 100644
--- a/sysdep/bsd/krt-sock.c
+++ b/sysdep/bsd/krt-sock.c
@@ -911,6 +911,12 @@ krt_sock_hook(sock *sk, int size UNUSED)
   return 0;
 }
 
+static void
+krt_sock_err_hook(sock *sk, int e UNUSED)
+{
+  krt_sock_hook(sk, 0);
+}
+
 static sock *
 krt_sock_open(pool *pool, void *data, int table_id)
 {
@@ -932,6 +938,7 @@ krt_sock_open(pool *pool, void *data, int table_id)
   sk = sk_new(pool);
   sk->type = SK_MAGIC;
   sk->rx_hook = krt_sock_hook;
+  sk->err_hook = krt_sock_err_hook;
   sk->fd = fd;
   sk->data = data;
 
diff --git a/sysdep/linux/netlink.c b/sysdep/linux/netlink.c
index 1490213e..79dd1405 100644
--- a/sysdep/linux/netlink.c
+++ b/sysdep/linux/netlink.c
@@ -1525,6 +1525,12 @@ nl_async_hook(sock *sk, int size UNUSED)
   return 1;
 }
 
+static void
+nl_async_err_hook(sock *sk, int e UNUSED)
+{
+  nl_async_hook(sk, 0);
+}
+
 static void
 nl_open_async(void)
 {
@@ -1563,6 +1569,7 @@ nl_open_async(void)
   sk = nl_async_sk = sk_new(krt_pool);
   sk->type = SK_MAGIC;
   sk->rx_hook = nl_async_hook;
+  sk->err_hook = nl_async_err_hook;
   sk->fd = fd;
   if (sk_open(sk) < 0)
     bug("Netlink: sk_open failed");
diff --git a/sysdep/unix/io.c b/sysdep/unix/io.c
index 120eb906..3ceadd98 100644
--- a/sysdep/unix/io.c
+++ b/sysdep/unix/io.c
@@ -1857,7 +1857,7 @@ void
 sk_err(sock *s, int revents)
 {
   int se = 0, sse = sizeof(se);
-  if (revents & POLLERR)
+  if ((s->type != SK_MAGIC) && (revents & POLLERR))
     if (getsockopt(s->fd, SOL_SOCKET, SO_ERROR, &se, &sse) < 0)
     {
       log(L_ERR "IO: Socket error: SO_ERROR: %m");

From 5bf35a9aee448ce7e3493ec7b80c84c8f5f39242 Mon Sep 17 00:00:00 2001
From: Pavel Tvrdik <pawel.tvrdik@gmail.com>
Date: Thu, 29 Sep 2016 13:28:18 +0200
Subject: [PATCH 121/165] Docs: fix BFD label

BFD headline will appear in Table of Contents again.
---
 doc/bird.sgml | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/doc/bird.sgml b/doc/bird.sgml
index 07a2d470..26673f03 100644
--- a/doc/bird.sgml
+++ b/doc/bird.sgml
@@ -1506,7 +1506,8 @@ protocol babel {
 </code>
 
 
-<sect><label id="sect-bfd">BFD
+<sect>BFD
+<label id="sect-bfd">
 
 <sect1>Introduction
 

From f51b1f556595108d53b9f4580bfcb96bfbc85442 Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Thu, 29 Sep 2016 15:06:19 +0200
Subject: [PATCH 122/165] NEWS and version update

---
 NEWS            | 3 +++
 misc/bird.spec  | 2 +-
 sysdep/config.h | 2 +-
 3 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/NEWS b/NEWS
index 525d7007..26314d82 100644
--- a/NEWS
+++ b/NEWS
@@ -1,3 +1,6 @@
+Version 1.6.2 (2016-09-29)
+  o Fixes serious bug introduced in the previous version
+
 Version 1.6.1 (2016-09-22)
   o Support for IPv6 ECMP
   o Better handling of IPv6 tentative addresses
diff --git a/misc/bird.spec b/misc/bird.spec
index 89531d64..ebc0c942 100644
--- a/misc/bird.spec
+++ b/misc/bird.spec
@@ -1,6 +1,6 @@
 Summary: BIRD Internet Routing Daemon
 Name: bird
-Version: 1.6.1
+Version: 1.6.2
 Release: 1
 Copyright: GPL
 Group: Networking/Daemons
diff --git a/sysdep/config.h b/sysdep/config.h
index e83a934f..c7f63e69 100644
--- a/sysdep/config.h
+++ b/sysdep/config.h
@@ -7,7 +7,7 @@
 #define _BIRD_CONFIG_H_
 
 /* BIRD version */
-#define BIRD_VERSION "1.6.1"
+#define BIRD_VERSION "1.6.2"
 
 /* Include parameters determined by configure script */
 #include "sysdep/autoconf.h"

From 66dbdbd993115c57acafdb776d2165d0b4a90a45 Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Sat, 1 Oct 2016 12:50:29 +0200
Subject: [PATCH 123/165] BGP: Support for large communities

Add support for large communities (draft-ietf-idr-large-community),
96bit alternative to RFC 1997 communities.

Thanks to Matt Griswold for the original patch.
---
 filter/config.Y    |  43 +++++++++++-
 filter/filter.c    | 171 ++++++++++++++++++++++++++++++++++++++++++++-
 filter/filter.h    |  18 ++++-
 filter/test.conf   |  17 +++++
 nest/a-set.c       | 127 ++++++++++++++++++++++++++++++++-
 nest/attrs.h       |  32 +++++++++
 nest/route.h       |   5 +-
 nest/rt-attr.c     |  15 ++++
 proto/bgp/attrs.c  |  42 ++++++++++-
 proto/bgp/bgp.h    |   1 +
 proto/bgp/config.Y |   4 +-
 11 files changed, 462 insertions(+), 13 deletions(-)

diff --git a/filter/config.Y b/filter/config.Y
index 9fffd651..79e274ab 100644
--- a/filter/config.Y
+++ b/filter/config.Y
@@ -36,6 +36,7 @@ f_valid_set_type(int type)
   case T_ENUM:
   case T_IP:
   case T_EC:
+  case T_LC:
     return 1;
 
   default:
@@ -148,6 +149,9 @@ f_generate_empty(struct f_inst *dyn)
     case EAF_TYPE_EC_SET:
       e->aux = T_ECLIST;
       break;
+    case EAF_TYPE_LC_SET:
+      e->aux = T_LCLIST;
+      break;
     default:
       cf_error("Can't empty that attribute");
   }
@@ -268,14 +272,44 @@ f_generate_ec(u16 kind, struct f_inst *tk, struct f_inst *tv)
   return rv;
 }
 
+static inline struct f_inst *
+f_generate_lc(struct f_inst *t1, struct f_inst *t2, struct f_inst *t3)
+{
+  struct f_inst *rv;
+
+  if ((t1->code == 'c') && (t2->code == 'c') && (t3->code == 'c')) {
+    if ((t1->aux != T_INT) || (t2->aux != T_INT) || (t3->aux != T_INT))
+      cf_error( "LC - Can't operate with value of non-integer type in tuple constructor");
+
+    rv = f_new_inst();
+    rv->code = 'C';
+
+    NEW_F_VAL;
+    rv->a1.p = val;
+    val->type = T_LC;
+    val->val.lc = (lcomm) { t1->a2.i, t2->a2.i, t3->a2.i };
+  }
+  else
+  {
+    rv = cfg_allocz(sizeof(struct f_inst3));
+    rv->lineno = ifs->lino;
+    rv->code = P('m','l');
+    rv->a1.p = t1;
+    rv->a2.p = t2;
+    INST3(rv).p = t3;
+  }
+
+  return rv;
+}
+
 
 
 CF_DECLS
 
 CF_KEYWORDS(FUNCTION, PRINT, PRINTN, UNSET, RETURN,
 	ACCEPT, REJECT, ERROR, QUITBIRD,
-	INT, BOOL, IP, PREFIX, PAIR, QUAD, EC,
-	SET, STRING, BGPMASK, BGPPATH, CLIST, ECLIST,
+	INT, BOOL, IP, PREFIX, PAIR, QUAD, EC, LC,
+	SET, STRING, BGPMASK, BGPPATH, CLIST, ECLIST, LCLIST,
 	IF, THEN, ELSE, CASE,
 	TRUE, FALSE, RT, RO, UNKNOWN, GENERIC,
 	FROM, GW, NET, MASK, PROTO, SOURCE, SCOPE, CAST, DEST, IFNAME, IFINDEX,
@@ -327,17 +361,20 @@ type:
  | PAIR { $$ = T_PAIR; }
  | QUAD { $$ = T_QUAD; }
  | EC { $$ = T_EC; }
+ | LC { $$ = T_LC; }
  | STRING { $$ = T_STRING; }
  | BGPMASK { $$ = T_PATH_MASK; }
  | BGPPATH { $$ = T_PATH; }
  | CLIST { $$ = T_CLIST; }
  | ECLIST { $$ = T_ECLIST; }
+ | LCLIST { $$ = T_LCLIST; }
  | type SET { 
 	switch ($1) {
 	  case T_INT:
 	  case T_PAIR:
 	  case T_QUAD:
 	  case T_EC:
+	  case T_LC:
 	  case T_IP:
 	       $$ = T_SET;
 	       break;
@@ -657,6 +694,7 @@ constant:
 constructor:
    '(' term ',' term ')' { $$ = f_generate_dpair($2, $4); }
  | '(' ec_kind ',' term ',' term ')' { $$ = f_generate_ec($2, $4, $6); }
+ | '(' term ',' term ',' term ')' { $$ = f_generate_lc($2, $4, $6); }
  ;
 
 
@@ -767,6 +805,7 @@ term:
  | '+' EMPTY '+' { $$ = f_new_inst(); $$->code = 'E'; $$->aux = T_PATH; }
  | '-' EMPTY '-' { $$ = f_new_inst(); $$->code = 'E'; $$->aux = T_CLIST; }
  | '-' '-' EMPTY '-' '-' { $$ = f_new_inst(); $$->code = 'E'; $$->aux = T_ECLIST; }
+ | '-' '-' '-' EMPTY '-' '-' '-' { $$ = f_new_inst(); $$->code = 'E'; $$->aux = T_LCLIST; }
  | PREPEND '(' term ',' term ')' { $$ = f_new_inst(); $$->code = P('A','p'); $$->a1.p = $3; $$->a2.p = $5; } 
  | ADD '(' term ',' term ')' { $$ = f_new_inst(); $$->code = P('C','a'); $$->a1.p = $3; $$->a2.p = $5; $$->aux = 'a'; } 
  | DELETE '(' term ',' term ')' { $$ = f_new_inst(); $$->code = P('C','a'); $$->a1.p = $3; $$->a2.p = $5; $$->aux = 'd'; }
diff --git a/filter/filter.c b/filter/filter.c
index 2f5f00d8..510303a7 100644
--- a/filter/filter.c
+++ b/filter/filter.c
@@ -106,6 +106,18 @@ u64_cmp(u64 i1, u64 i2)
   return (int)(i1 > i2) - (int)(i1 < i2);
 }
 
+static inline int
+lcomm_cmp(lcomm v1, lcomm v2)
+{
+  if (v1.asn != v2.asn)
+    return (v1.asn > v2.asn) ? 1 : -1;
+  if (v1.ldp1 != v2.ldp1)
+    return (v1.ldp1 > v2.ldp1) ? 1 : -1;
+  if (v1.ldp2 != v2.ldp2)
+    return (v1.ldp2 > v2.ldp2) ? 1 : -1;
+  return 0;
+}
+
 /**
  * val_compare - compare two values
  * @v1: first value
@@ -149,6 +161,8 @@ val_compare(struct f_val v1, struct f_val v2)
     return uint_cmp(v1.val.i, v2.val.i);
   case T_EC:
     return u64_cmp(v1.val.ec, v2.val.ec);
+  case T_LC:
+    return lcomm_cmp(v1.val.lc, v2.val.lc);
   case T_IP:
     return ipa_compare(v1.val.px.ip, v2.val.px.ip);
   case T_PREFIX:
@@ -214,6 +228,7 @@ val_same(struct f_val v1, struct f_val v2)
   case T_PATH:
   case T_CLIST:
   case T_ECLIST:
+  case T_LCLIST:
     return adata_same(v1.val.ad, v2.val.ad);
   case T_SET:
     return same_tree(v1.val.t, v2.val.t);
@@ -266,6 +281,10 @@ static inline int
 eclist_set_type(struct f_tree *set)
 { return set->from.type == T_EC; }
 
+static inline int
+lclist_set_type(struct f_tree *set)
+{ return set->from.type == T_LC; }
+
 static int
 clist_match_set(struct adata *clist, struct f_tree *set)
 {
@@ -311,6 +330,30 @@ eclist_match_set(struct adata *list, struct f_tree *set)
   return 0;
 }
 
+static int
+lclist_match_set(struct adata *list, struct f_tree *set)
+{
+  if (!list)
+    return 0;
+
+  if (!lclist_set_type(set))
+    return CMP_ERROR;
+
+  struct f_val v;
+  u32 *l = int_set_get_data(list);
+  int len = int_set_get_size(list);
+  int i;
+
+  v.type = T_LC;
+  for (i = 0; i < len; i += 3) {
+    v.val.lc = lc_get(l, i);
+    if (find_tree(set, v))
+      return 1;
+  }
+
+  return 0;
+}
+
 static struct adata *
 clist_filter(struct linpool *pool, struct adata *list, struct f_val set, int pos)
 {
@@ -380,6 +423,38 @@ eclist_filter(struct linpool *pool, struct adata *list, struct f_val set, int po
   return res;
 }
 
+static struct adata *
+lclist_filter(struct linpool *pool, struct adata *list, struct f_val set, int pos)
+{
+  if (!list)
+    return NULL;
+
+  int tree = (set.type == T_SET);	/* 1 -> set is T_SET, 0 -> set is T_CLIST */
+  struct f_val v;
+
+  int len = int_set_get_size(list);
+  u32 *l = int_set_get_data(list);
+  u32 tmp[len];
+  u32 *k = tmp;
+  int i;
+
+  v.type = T_LC;
+  for (i = 0; i < len; i += 3) {
+    v.val.lc = lc_get(l, i);
+    /* pos && member(val, set) || !pos && !member(val, set),  member() depends on tree */
+    if ((tree ? !!find_tree(set.val.t, v) : lc_set_contains(set.val.ad, v.val.lc)) == pos)
+      k = lc_copy(k, l+i);
+  }
+
+  int nl = (k - tmp) * 4;
+  if (nl == list->length)
+    return list;
+
+  struct adata *res = adata_empty(pool, nl);
+  memcpy(res->data, tmp, nl);
+  return res;
+}
+
 /**
  * val_in_range - implement |~| operator
  * @v1: element
@@ -407,6 +482,9 @@ val_in_range(struct f_val v1, struct f_val v2)
   if ((v1.type == T_EC) && (v2.type == T_ECLIST))
     return ec_set_contains(v2.val.ad, v1.val.ec);
 
+  if ((v1.type == T_LC) && (v2.type == T_LCLIST))
+    return lc_set_contains(v2.val.ad, v1.val.lc);
+
   if ((v1.type == T_STRING) && (v2.type == T_STRING))
     return patmatch(v2.val.s, v1.val.s);
 
@@ -433,6 +511,9 @@ val_in_range(struct f_val v1, struct f_val v2)
   if (v1.type == T_ECLIST)
     return eclist_match_set(v1.val.ad, v2.val.t);
 
+  if (v1.type == T_LCLIST)
+    return lclist_match_set(v1.val.ad, v2.val.t);
+
   if (v1.type == T_PATH)
     return as_path_match_set(v1.val.ad, v2.val.t);
 
@@ -457,12 +538,14 @@ val_format(struct f_val v, buffer *buf)
   case T_PAIR:	buffer_print(buf, "(%u,%u)", v.val.i >> 16, v.val.i & 0xffff); return;
   case T_QUAD:	buffer_print(buf, "%R", v.val.i); return;
   case T_EC:	ec_format(buf2, v.val.ec); buffer_print(buf, "%s", buf2); return;
+  case T_LC:	lc_format(buf2, v.val.lc); buffer_print(buf, "%s", buf2); return;
   case T_PREFIX_SET: trie_format(v.val.ti, buf); return;
   case T_SET:	tree_format(v.val.t, buf); return;
   case T_ENUM:	buffer_print(buf, "(enum %x)%u", v.type, v.val.i); return;
   case T_PATH:	as_path_format(v.val.ad, buf2, 1000); buffer_print(buf, "(path %s)", buf2); return;
   case T_CLIST:	int_set_format(v.val.ad, 1, -1, buf2, 1000); buffer_print(buf, "(clist %s)", buf2); return;
   case T_ECLIST: ec_set_format(v.val.ad, -1, buf2, 1000); buffer_print(buf, "(eclist %s)", buf2); return;
+  case T_LCLIST: lc_set_format(v.val.ad, -1, buf2, 1000); buffer_print(buf, "(lclist %s)", buf2); return;
   case T_PATH_MASK: pm_format(v.val.path_mask, buf); return;
   default:	buffer_print(buf, "[unknown type %x]", v.type); return;
   }
@@ -656,6 +739,7 @@ interpret(struct f_inst *what)
 	runtime("Can't operate with value of non-integer type in EC constructor");
       val = v2.val.i;
 
+      /* XXXX */
       res.type = T_EC;
 
       if (what->aux == EC_GENERIC) {
@@ -677,6 +761,24 @@ interpret(struct f_inst *what)
       break;
     }
 
+  case P('m','l'):
+    {
+      TWOARGS;
+
+      /* Third argument hack */
+      struct f_val v3 = interpret(INST3(what).p);
+      if (v3.type & T_RETURN)
+	return v3;
+
+      if ((v1.type != T_INT) || (v2.type != T_INT) || (v3.type != T_INT))
+	runtime( "Can't operate with value of non-integer type in LC constructor" );
+
+      res.type = T_LC;
+      res.val.lc = (lcomm) { v1.val.i, v2.val.i, v3.val.i };
+
+      break;
+    }
+
 /* Relational operators */
 
 #define COMPARE(x) \
@@ -912,6 +1014,13 @@ interpret(struct f_inst *what)
 	  break;
 	}
 
+	/* The same special case for lc_set */
+	if ((what->aux & EAF_TYPE_MASK) == EAF_TYPE_LC_SET) {
+	  res.type = T_LCLIST;
+	  res.val.ad = adata_empty(f_pool, 0);
+	  break;
+	}
+
 	/* Undefined value */
 	res.type = T_VOID;
 	break;
@@ -951,6 +1060,10 @@ interpret(struct f_inst *what)
 	res.type = T_ECLIST;
 	res.val.ad = e->u.ptr;
 	break;
+      case EAF_TYPE_LC_SET:
+	res.type = T_LCLIST;
+	res.val.ad = e->u.ptr;
+	break;
       case EAF_TYPE_UNDEF:
 	res.type = T_VOID;
 	break;
@@ -1041,6 +1154,11 @@ interpret(struct f_inst *what)
 	  runtime( "Setting eclist attribute to non-eclist value" );
 	l->attrs[0].u.ptr = v1.val.ad;
 	break;
+      case EAF_TYPE_LC_SET:
+	if (v1.type != T_LCLIST)
+	  runtime( "Setting lclist attribute to non-lclist value" );
+	l->attrs[0].u.ptr = v1.val.ad;
+	break;
       case EAF_TYPE_UNDEF:
 	if (v1.type != T_VOID)
 	  runtime( "Setting void attribute to non-void value" );
@@ -1082,6 +1200,7 @@ interpret(struct f_inst *what)
     case T_PATH:   res.val.i = as_path_getlen(v1.val.ad); break;
     case T_CLIST:  res.val.i = int_set_get_size(v1.val.ad); break;
     case T_ECLIST: res.val.i = ec_set_get_size(v1.val.ad); break;
+    case T_LCLIST: res.val.i = lc_set_get_size(v1.val.ad); break;
     default: runtime( "Prefix, path, clist or eclist expected" );
     }
     break;
@@ -1277,7 +1396,7 @@ interpret(struct f_inst *what)
       else if (v2.type == T_ECLIST)
 	arg_set = 2;
       else if (v2.type != T_EC)
-	runtime("Can't add/delete non-pair");
+	runtime("Can't add/delete non-ec");
 
       res.type = T_ECLIST;
       switch (what->aux)
@@ -1308,8 +1427,50 @@ interpret(struct f_inst *what)
 	bug("unknown Ca operation");
       }
     }
+    else if (v1.type == T_LCLIST)
+    {
+      /* Large community list */
+      int arg_set = 0;
+
+      /* v2.val is either LC or LC-set */
+      if ((v2.type == T_SET) && lclist_set_type(v2.val.t))
+	arg_set = 1;
+      else if (v2.type == T_LCLIST)
+	arg_set = 2;
+      else if (v2.type != T_LC)
+	runtime("Can't add/delete non-lc");
+
+      res.type = T_LCLIST;
+      switch (what->aux)
+      {
+      case 'a':
+	if (arg_set == 1)
+	  runtime("Can't add set");
+	else if (!arg_set)
+	  res.val.ad = lc_set_add(f_pool, v1.val.ad, v2.val.lc);
+	else
+	  res.val.ad = lc_set_union(f_pool, v1.val.ad, v2.val.ad);
+	break;
+
+      case 'd':
+	if (!arg_set)
+	  res.val.ad = lc_set_del(f_pool, v1.val.ad, v2.val.lc);
+	else
+	  res.val.ad = lclist_filter(f_pool, v1.val.ad, v2, 0);
+	break;
+
+      case 'f':
+	if (!arg_set)
+	  runtime("Can't filter lc");
+	res.val.ad = lclist_filter(f_pool, v1.val.ad, v2, 1);
+	break;
+
+      default:
+	bug("unknown Ca operation");
+      }
+    }
     else
-      runtime("Can't add/delete to non-(e)clist");
+      runtime("Can't add/delete to non-[e|l]clist");
 
     break;
 
@@ -1401,6 +1562,12 @@ i_same(struct f_inst *f1, struct f_inst *f2)
   case '~': TWOARGS; break;
   case P('d','e'): ONEARG; break;
 
+  case P('m','l'):
+    TWOARGS;
+    if (!i_same(INST3(f1).p, INST3(f2).p))
+      return 0;
+    break;
+
   case 's':
     ARG(v2, a2.p);
     {
diff --git a/filter/filter.h b/filter/filter.h
index e59c8226..e0f34e4f 100644
--- a/filter/filter.h
+++ b/filter/filter.h
@@ -38,6 +38,17 @@ struct f_inst_roa_check {
   struct roa_table_config *rtc;	
 };
 
+struct f_inst3 {
+  struct f_inst i;
+  union {
+    int i;
+    void *p;
+  } a3;
+};
+
+#define INST3(x) (((struct f_inst3 *) x)->a3)
+
+
 struct f_prefix {
   ip_addr ip;
   int len;
@@ -53,6 +64,7 @@ struct f_val {
   union {
     uint i;
     u64 ec;
+    lcomm lc;
     /*    ip_addr ip; Folded into prefix */	
     struct f_prefix px;
     char *s;
@@ -168,8 +180,10 @@ void val_format(struct f_val v, buffer *buf);
 #define T_PATH_MASK 0x23	/* mask for BGP path */
 #define T_PATH 0x24		/* BGP path */
 #define T_CLIST 0x25		/* Community list */
-#define T_ECLIST 0x26		/* Extended community list */
-#define T_EC 0x27		/* Extended community value, u64 */
+#define T_EC 0x26		/* Extended community value, u64 */
+#define T_ECLIST 0x27		/* Extended community list */
+#define T_LC 0x28		/* Large community value, lcomm */
+#define T_LCLIST 0x29		/* Large community list */
 
 #define T_RETURN 0x40
 #define T_SET 0x80
diff --git a/filter/test.conf b/filter/test.conf
index f61f0658..e8873fbf 100644
--- a/filter/test.conf
+++ b/filter/test.conf
@@ -27,6 +27,11 @@ function 'mkpair-a'(int a)
 	return (1, a);
 }
 
+function mktrip(int a)
+{
+	return (a, 2*a, 3*a);
+}
+
 function mkpath(int a; int b)
 {
 	return [= a b 3 2 1 =];
@@ -89,6 +94,7 @@ clist l;
 clist l2;
 eclist el;
 eclist el2;
+lclist ll;
 {
 	print "Entering path test...";
 	pm1 =  / 4 3 2 1 /;
@@ -203,6 +209,17 @@ eclist el2;
 	print "eclist A isect B: ", filter( el, el2 );
 	print "eclist A \  B: ", delete( el, el2 );
 
+	ll = --- empty ---;
+	ll = add(ll, (ten, 20, 30));
+	ll = add(ll, (1000, 2000, 3000));
+	ll = add(ll, mktrip(100000));
+	print "LC list (10, 20, 30) (1000, 2000, 3000) (100000, 200000, 300000):";
+	print ll;
+	print "LC len: ", el.len;
+	print "Should be true: ", mktrip(1000) ~ ll, " ", ll ~ [(5,10,15), (10,20,30)], " ", ll ~ [(10,15..25,*)], " ", ll ~ [(ten, *, *)];
+	print "Should be false: ", mktrip(100) ~ ll, " ", ll ~ [(5,10,15), (10,21,30)], " ", ll ~ [(10,21..25,*)], " ", ll ~ [(11, *, *)];
+	print "LC filtered: ", filter(ll, [(5..15, *, *), (100000, 500..500000, *)]);
+
 #	test_roa();
 }
 
diff --git a/nest/a-set.c b/nest/a-set.c
index a6116022..0484ab98 100644
--- a/nest/a-set.c
+++ b/nest/a-set.c
@@ -116,7 +116,7 @@ int
 ec_set_format(struct adata *set, int from, byte *buf, uint size)
 {
   u32 *z = int_set_get_data(set);
-  byte *end = buf + size - 24;
+  byte *end = buf + size - 64;
   int from2 = MAX(from, 0);
   int to = int_set_get_size(set);
   int i;
@@ -141,6 +141,43 @@ ec_set_format(struct adata *set, int from, byte *buf, uint size)
   return 0;
 }
 
+int
+lc_format(byte *buf, lcomm lc)
+{
+  return bsprintf(buf, "(%d, %d, %d)", lc.asn, lc.ldp1, lc.ldp2);
+}
+
+int
+lc_set_format(struct adata *set, int from, byte *buf, uint bufsize)
+{
+  u32 *d = (u32 *) set->data;
+  byte *end = buf + bufsize - 64;
+  int from2 = MAX(from, 0);
+  int to = set->length / 4;
+  int i;
+
+  for (i = from2; i < to; i += 3)
+    {
+      if (buf > end)
+	{
+	  if (from < 0)
+	    strcpy(buf, "...");
+	  else
+	    buf[-1] = 0;
+	  return i;
+	}
+
+      buf += bsprintf(buf, "(%d, %d, %d)", d[i], d[i+1], d[i+2]);
+      *buf++ = ' ';
+    }
+
+  if (i != from2)
+    buf--;
+
+  *buf = 0;
+  return 0;
+}
+
 int
 int_set_contains(struct adata *list, u32 val)
 {
@@ -177,6 +214,24 @@ ec_set_contains(struct adata *list, u64 val)
   return 0;
 }
 
+int
+lc_set_contains(struct adata *list, lcomm val)
+{
+  if (!list)
+    return 0;
+
+  u32 *l = int_set_get_data(list);
+  int len = int_set_get_size(list);
+  int i;
+
+  for (i = 0; i < len; i += 3)
+    if (lc_match(l, i, val))
+      return 1;
+
+  return 0;
+}
+
+
 struct adata *
 int_set_add(struct linpool *pool, struct adata *list, u32 val)
 {
@@ -208,13 +263,30 @@ ec_set_add(struct linpool *pool, struct adata *list, u64 val)
   if (list)
     memcpy(res->data, list->data, list->length);
 
-  u32 *l = (u32 *) (res->data + res->length - 8);
+  u32 *l = (u32 *) (res->data + olen);
   l[0] = ec_hi(val);
   l[1] = ec_lo(val);
 
   return res;
 }
 
+struct adata *
+lc_set_add(struct linpool *pool, struct adata *list, lcomm val)
+{
+  if (lc_set_contains(list, val))
+    return list;
+
+  int olen = list ? list->length : 0;
+  struct adata *res = lp_alloc(pool, sizeof(struct adata) + olen + LCOMM_LENGTH);
+  res->length = olen + LCOMM_LENGTH;
+
+  if (list)
+    memcpy(res->data, list->data, list->length);
+
+  lc_put((u32 *) (res->data + olen), val);
+
+  return res;
+}
 
 struct adata *
 int_set_del(struct linpool *pool, struct adata *list, u32 val)
@@ -265,6 +337,27 @@ ec_set_del(struct linpool *pool, struct adata *list, u64 val)
   return res;
 }
 
+struct adata *
+lc_set_del(struct linpool *pool, struct adata *list, lcomm val)
+{
+  if (!lc_set_contains(list, val))
+    return list;
+
+  struct adata *res;
+  res = lp_alloc(pool, sizeof(struct adata) + list->length - LCOMM_LENGTH);
+  res->length = list->length - LCOMM_LENGTH;
+
+  u32 *l = int_set_get_data(list);
+  u32 *k = int_set_get_data(res);
+  int len = int_set_get_size(list);
+  int i;
+
+  for (i=0; i < len; i += 3)
+    if (! lc_match(l, i, val))
+      k = lc_copy(k, l+i);
+
+  return res;
+}
 
 struct adata *
 int_set_union(struct linpool *pool, struct adata *l1, struct adata *l2)
@@ -328,3 +421,33 @@ ec_set_union(struct linpool *pool, struct adata *l1, struct adata *l2)
   memcpy(res->data + l1->length, tmp, len);
   return res;
 }
+
+struct adata *
+lc_set_union(struct linpool *pool, struct adata *l1, struct adata *l2)
+{
+  if (!l1)
+    return l2;
+  if (!l2)
+    return l1;
+
+  struct adata *res;
+  int len = int_set_get_size(l2);
+  u32 *l = int_set_get_data(l2);
+  u32 tmp[len];
+  u32 *k = tmp;
+  int i;
+
+  for (i = 0; i < len; i += 3)
+    if (!lc_set_contains(l1, lc_get(l, i)))
+      k = lc_copy(k, l+i);
+
+  if (k == tmp)
+    return l1;
+
+  len = (k - tmp) * 4;
+  res = lp_alloc(pool, sizeof(struct adata) + l1->length + len);
+  res->length = l1->length + len;
+  memcpy(res->data, l1->data, l1->length);
+  memcpy(res->data + l1->length, tmp, len);
+  return res;
+}
diff --git a/nest/attrs.h b/nest/attrs.h
index 670b048f..548d71a9 100644
--- a/nest/attrs.h
+++ b/nest/attrs.h
@@ -68,6 +68,7 @@ int as_path_match(struct adata *path, struct f_path_mask *mask);
 /* Transitive bit (for first u32 half of EC) */
 #define EC_TBIT 0x40000000
 
+#define ECOMM_LENGTH 8
 
 static inline int int_set_get_size(struct adata *list)
 { return list->length / 4; }
@@ -75,6 +76,9 @@ static inline int int_set_get_size(struct adata *list)
 static inline int ec_set_get_size(struct adata *list)
 { return list->length / 8; }
 
+static inline int lc_set_get_size(struct adata *list)
+{ return list->length / 12; }
+
 static inline u32 *int_set_get_data(struct adata *list)
 { return (u32 *) list->data; }
 
@@ -98,17 +102,45 @@ static inline u64 ec_ip4(u64 kind, u64 key, u64 val)
 static inline u64 ec_generic(u64 key, u64 val)
 { return (key << 32) | val; }
 
+/* Large community value */
+typedef struct lcomm {
+  u32 asn;
+  u32 ldp1;
+  u32 ldp2;
+} lcomm;
+
+#define LCOMM_LENGTH 12
+
+static inline lcomm lc_get(const u32 *l, int i)
+{ return (lcomm) { l[i], l[i+1], l[i+2] }; }
+
+static inline void lc_put(u32 *l, lcomm v)
+{ l[0] = v.asn; l[1] = v.ldp1; l[2] = v.ldp2; }
+
+static inline int lc_match(const u32 *l, int i, lcomm v)
+{ return (l[i] == v.asn && l[i+1] == v.ldp1 && l[i+2] == v.ldp2); }
+
+static inline u32 *lc_copy(u32 *dst, const u32 *src)
+{ memcpy(dst, src, LCOMM_LENGTH); return dst + 3; }
+
+
 int int_set_format(struct adata *set, int way, int from, byte *buf, uint size);
 int ec_format(byte *buf, u64 ec);
 int ec_set_format(struct adata *set, int from, byte *buf, uint size);
+int lc_format(byte *buf, lcomm lc);
+int lc_set_format(struct adata *set, int from, byte *buf, uint size);
 int int_set_contains(struct adata *list, u32 val);
 int ec_set_contains(struct adata *list, u64 val);
+int lc_set_contains(struct adata *list, lcomm val);
 struct adata *int_set_add(struct linpool *pool, struct adata *list, u32 val);
 struct adata *ec_set_add(struct linpool *pool, struct adata *list, u64 val);
+struct adata *lc_set_add(struct linpool *pool, struct adata *list, lcomm val);
 struct adata *int_set_del(struct linpool *pool, struct adata *list, u32 val);
 struct adata *ec_set_del(struct linpool *pool, struct adata *list, u64 val);
+struct adata *lc_set_del(struct linpool *pool, struct adata *list, lcomm val);
 struct adata *int_set_union(struct linpool *pool, struct adata *l1, struct adata *l2);
 struct adata *ec_set_union(struct linpool *pool, struct adata *l1, struct adata *l2);
+struct adata *lc_set_union(struct linpool *pool, struct adata *l1, struct adata *l2);
 
 
 #endif
diff --git a/nest/route.h b/nest/route.h
index 2fcb189a..07320566 100644
--- a/nest/route.h
+++ b/nest/route.h
@@ -442,7 +442,7 @@ typedef struct eattr {
 #define EA_ALLOW_UNDEF 0x10000		/* ea_find: allow EAF_TYPE_UNDEF */
 #define EA_BIT(n) ((n) << 24)		/* Used in bitfield accessors */
 
-#define EAF_TYPE_MASK 0x0f		/* Mask with this to get type */
+#define EAF_TYPE_MASK 0x1f		/* Mask with this to get type */
 #define EAF_TYPE_INT 0x01		/* 32-bit unsigned integer number */
 #define EAF_TYPE_OPAQUE 0x02		/* Opaque byte string (not filterable) */
 #define EAF_TYPE_IP_ADDRESS 0x04	/* IP address */
@@ -451,7 +451,8 @@ typedef struct eattr {
 #define EAF_TYPE_BITFIELD 0x09		/* 32-bit embedded bitfield */
 #define EAF_TYPE_INT_SET 0x0a		/* Set of u32's (e.g., a community list) */
 #define EAF_TYPE_EC_SET 0x0e		/* Set of pairs of u32's - ext. community list */
-#define EAF_TYPE_UNDEF 0x0f		/* `force undefined' entry */
+#define EAF_TYPE_LC_SET 0x12		/* Set of triplets of u32's - large community list */
+#define EAF_TYPE_UNDEF 0x1f		/* `force undefined' entry */
 #define EAF_EMBEDDED 0x01		/* Data stored in eattr.u.data (part of type spec) */
 #define EAF_VAR_LENGTH 0x02		/* Attribute length is variable (part of type spec) */
 #define EAF_ORIGINATED 0x40		/* The attribute has originated locally */
diff --git a/nest/rt-attr.c b/nest/rt-attr.c
index ab0069b5..9aeca846 100644
--- a/nest/rt-attr.c
+++ b/nest/rt-attr.c
@@ -828,6 +828,18 @@ ea_show_ec_set(struct cli *c, struct adata *ad, byte *pos, byte *buf, byte *end)
     }
 }
 
+static inline void
+ea_show_lc_set(struct cli *c, struct adata *ad, byte *pos, byte *buf, byte *end)
+{
+  int i = lc_set_format(ad, 0, pos, end - pos);
+  cli_printf(c, -1012, "\t%s", buf);
+  while (i)
+    {
+      i = lc_set_format(ad, i, buf, end - buf - 1);
+      cli_printf(c, -1012, "\t\t%s", buf);
+    }
+}
+
 /**
  * ea_show - print an &eattr to CLI
  * @c: destination CLI
@@ -892,6 +904,9 @@ ea_show(struct cli *c, eattr *e)
 	case EAF_TYPE_EC_SET:
 	  ea_show_ec_set(c, ad, pos, buf, end);
 	  return;
+	case EAF_TYPE_LC_SET:
+	  ea_show_lc_set(c, ad, pos, buf, end);
+	  return;
 	case EAF_TYPE_UNDEF:
 	default:
 	  bsprintf(pos, "<type %02x>", e->type);
diff --git a/proto/bgp/attrs.c b/proto/bgp/attrs.c
index b8371f32..6fe34e56 100644
--- a/proto/bgp/attrs.c
+++ b/proto/bgp/attrs.c
@@ -289,6 +289,12 @@ bgp_check_ext_community(struct bgp_proto *p UNUSED, byte *a UNUSED, int len)
   return ((len % 8) == 0) ? 0 : WITHDRAW;
 }
 
+static int
+bgp_check_large_community(struct bgp_proto *p UNUSED, byte *a UNUSED, int len)
+{
+  return ((len % 12) == 0) ? 0 : WITHDRAW;
+}
+
 
 static struct attr_desc bgp_attr_table[] = {
   { NULL, -1, 0, 0, 0,								/* Undefined */
@@ -325,7 +331,10 @@ static struct attr_desc bgp_attr_table[] = {
   { "as4_path", -1, BAF_OPTIONAL | BAF_TRANSITIVE, EAF_TYPE_OPAQUE, 1,		/* BA_AS4_PATH */
     NULL, NULL },
   { "as4_aggregator", -1, BAF_OPTIONAL | BAF_TRANSITIVE, EAF_TYPE_OPAQUE, 1,	/* BA_AS4_PATH */
-    NULL, NULL }
+    NULL, NULL },
+  [BA_LARGE_COMMUNITY] =
+  { "large_community", -1, BAF_OPTIONAL | BAF_TRANSITIVE, EAF_TYPE_LC_SET, 1,
+    bgp_check_large_community, NULL }
 };
 
 /* BA_AS4_PATH is type EAF_TYPE_OPAQUE and not type EAF_TYPE_AS_PATH.
@@ -575,7 +584,7 @@ bgp_encode_attrs(struct bgp_proto *p, byte *w, ea_list *attrs, int remains)
       len = bgp_get_attr_len(a);
 
       /* Skip empty sets */ 
-      if (((type == EAF_TYPE_INT_SET) || (type == EAF_TYPE_EC_SET)) && (len == 0))
+      if (((type == EAF_TYPE_INT_SET) || (type == EAF_TYPE_EC_SET) || (type == EAF_TYPE_LC_SET)) && (len == 0))
 	continue; 
 
       if (remains < len + 4)
@@ -601,6 +610,7 @@ bgp_encode_attrs(struct bgp_proto *p, byte *w, ea_list *attrs, int remains)
 	    break;
 	  }
 	case EAF_TYPE_INT_SET:
+	case EAF_TYPE_LC_SET:
 	case EAF_TYPE_EC_SET:
 	  {
 	    u32 *z = int_set_get_data(a->u.ptr);
@@ -683,6 +693,25 @@ bgp_normalize_ec_set(struct adata *ad, u32 *src, int internal)
   qsort(dst, ad->length / 8, 8, (int(*)(const void *, const void *)) bgp_compare_ec);
 }
 
+static int
+bgp_compare_lc(const u32 *x, const u32 *y)
+{
+  if (x[0] != y[0])
+    return (x[0] > y[0]) ? 1 : -1;
+  if (x[1] != y[1])
+    return (x[1] > y[1]) ? 1 : -1;
+  if (x[2] != y[2])
+    return (x[2] > y[2]) ? 1 : -1;
+  return 0;
+}
+
+static inline void
+bgp_normalize_lc_set(u32 *dest, u32 *src, unsigned cnt)
+{
+  memcpy(dest, src, LCOMM_LENGTH * cnt);
+  qsort(dest, cnt, LCOMM_LENGTH, (int(*)(const void *, const void *)) bgp_compare_lc);
+}
+
 static void
 bgp_rehash_buckets(struct bgp_proto *p)
 {
@@ -827,6 +856,14 @@ bgp_get_bucket(struct bgp_proto *p, net *n, ea_list *attrs, int originate)
 	    d->u.ptr = z;
 	    break;
 	  }
+	case EAF_TYPE_LC_SET:
+	  {
+	    struct adata *z = alloca(sizeof(struct adata) + d->u.ptr->length);
+	    z->length = d->u.ptr->length;
+	    bgp_normalize_lc_set((u32 *) z->data, (u32 *) d->u.ptr->data, z->length / LCOMM_LENGTH);
+	    d->u.ptr = z;
+	    break;
+	  }
 	default: ;
 	}
       d++;
@@ -1797,6 +1834,7 @@ bgp_decode_attrs(struct bgp_conn *conn, byte *attr, uint len, struct linpool *po
 	  ipa_ntoh(*(ip_addr *)ad->data);
 	  break;
 	case EAF_TYPE_INT_SET:
+	case EAF_TYPE_LC_SET:
 	case EAF_TYPE_EC_SET:
 	  {
 	    u32 *z = (u32 *) ad->data;
diff --git a/proto/bgp/bgp.h b/proto/bgp/bgp.h
index b1cca2d9..d5747c18 100644
--- a/proto/bgp/bgp.h
+++ b/proto/bgp/bgp.h
@@ -308,6 +308,7 @@ void bgp_log_error(struct bgp_proto *p, u8 class, char *msg, unsigned code, unsi
 #define BA_EXT_COMMUNITY	0x10	/* [RFC4360] */
 #define BA_AS4_PATH             0x11    /* [RFC4893] */
 #define BA_AS4_AGGREGATOR       0x12
+#define BA_LARGE_COMMUNITY	0x1e	/* [draft-ietf-idr-large-community] */
 
 /* BGP connection states */
 
diff --git a/proto/bgp/config.Y b/proto/bgp/config.Y
index f3ba0e16..32ae88a3 100644
--- a/proto/bgp/config.Y
+++ b/proto/bgp/config.Y
@@ -27,7 +27,7 @@ CF_KEYWORDS(BGP, LOCAL, NEIGHBOR, AS, HOLD, TIME, CONNECT, RETRY,
 	INTERPRET, COMMUNITIES, BGP_ORIGINATOR_ID, BGP_CLUSTER_LIST, IGP,
 	TABLE, GATEWAY, DIRECT, RECURSIVE, MED, TTL, SECURITY, DETERMINISTIC,
 	SECONDARY, ALLOW, BFD, ADD, PATHS, RX, TX, GRACEFUL, RESTART, AWARE,
-	CHECK, LINK, PORT, EXTENDED, MESSAGES, SETKEY)
+	CHECK, LINK, PORT, EXTENDED, MESSAGES, SETKEY, BGP_LARGE_COMMUNITY)
 
 CF_GRAMMAR
 
@@ -159,6 +159,8 @@ CF_ADDTO(dynamic_attr, BGP_CLUSTER_LIST
 	{ $$ = f_new_dynamic_attr(EAF_TYPE_INT_SET, T_CLIST, EA_CODE(EAP_BGP, BA_CLUSTER_LIST)); })
 CF_ADDTO(dynamic_attr, BGP_EXT_COMMUNITY
 	{ $$ = f_new_dynamic_attr(EAF_TYPE_EC_SET, T_ECLIST, EA_CODE(EAP_BGP, BA_EXT_COMMUNITY)); })
+CF_ADDTO(dynamic_attr, BGP_LARGE_COMMUNITY
+	{ $$ = f_new_dynamic_attr(EAF_TYPE_LC_SET, T_LCLIST, EA_CODE(EAP_BGP, BA_LARGE_COMMUNITY)); })
 
 
 

From 60566c5c804070c145fafd75ef2c17efb489a1eb Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Sat, 1 Oct 2016 22:31:01 +0200
Subject: [PATCH 124/165] Filter: large community sets

Add support for lc sets to filter code. Grammar of (small) community sets
has to be updated to avoid parser collisions.
---
 filter/config.Y | 94 ++++++++++++++++++++++++++++++++-----------------
 1 file changed, 62 insertions(+), 32 deletions(-)

diff --git a/filter/config.Y b/filter/config.Y
index 79e274ab..29e3a734 100644
--- a/filter/config.Y
+++ b/filter/config.Y
@@ -67,6 +67,14 @@ f_merge_items(struct f_tree *a, struct f_tree *b)
 static inline struct f_tree *
 f_new_pair_item(int fa, int ta, int fb, int tb)
 {
+  check_u16(fa);
+  check_u16(ta);
+  check_u16(fb);
+  check_u16(tb);
+
+  if ((ta < fa) || (tb < fb))
+    cf_error( "From value cannot be higher that To value in pair sets");
+
   struct f_tree *t = f_new_tree();
   t->right = t;
   t->from.type = t->to.type = T_PAIR;
@@ -78,22 +86,26 @@ f_new_pair_item(int fa, int ta, int fb, int tb)
 static inline struct f_tree *
 f_new_pair_set(int fa, int ta, int fb, int tb)
 {
-  struct f_tree *lst = NULL;
-  int i;
+  check_u16(fa);
+  check_u16(ta);
+  check_u16(fb);
+  check_u16(tb);
 
-  if ((fa == ta) || ((fb == 0) && (tb == 0xFFFF)))
-    return f_new_pair_item(fa, ta, fb, tb);
-  
   if ((ta < fa) || (tb < fb))
     cf_error( "From value cannot be higher that To value in pair sets");
 
+  struct f_tree *lst = NULL;
+  int i;
+
   for (i = fa; i <= ta; i++)
     lst = f_merge_items(lst, f_new_pair_item(i, i, fb, tb));
 
   return lst;
 }
 
+#define CC_ALL 0xFFFF
 #define EC_ALL 0xFFFFFFFF
+#define LC_ALL 0xFFFFFFFF
 
 static struct f_tree *
 f_new_ec_item(u32 kind, u32 ipv4_used, u32 key, u32 vf, u32 vt)
@@ -133,6 +145,17 @@ f_new_ec_item(u32 kind, u32 ipv4_used, u32 key, u32 vf, u32 vt)
   return t;
 }
 
+static struct f_tree *
+f_new_lc_item(u32 f1, u32 t1, u32 f2, u32 t2, u32 f3, u32 t3)
+{
+  struct f_tree *t = f_new_tree();
+  t->right = t;
+  t->from.type = t->to.type = T_LC;
+  t->from.val.lc = (lcomm) {f1, f2, f3};
+  t->to.val.lc = (lcomm) {t1, t2, t3};
+  return t;
+}
+
 static inline struct f_inst *
 f_generate_empty(struct f_inst *dyn)
 { 
@@ -327,9 +350,9 @@ CF_KEYWORDS(FUNCTION, PRINT, PRINTN, UNSET, RETURN,
 
 %type <x> term block cmds cmds_int cmd function_body constant constructor print_one print_list var_list var_listn dynamic_attr static_attr function_call symbol bgp_path_expr
 %type <f> filter filter_body where_filter
-%type <i> type break_command pair_expr ec_kind
-%type <i32> pair_atom ec_expr
-%type <e> pair_item ec_item set_item switch_item set_items switch_items switch_body
+%type <i> type break_command ec_kind
+%type <i32> cnum
+%type <e> pair_item ec_item lc_item set_item switch_item set_items switch_items switch_body
 %type <trie> fprefix_set
 %type <v> set_atom switch_atom fprefix fprefix_s fipa
 %type <s> decls declsn one_decl function_params 
@@ -550,30 +573,23 @@ switch_atom:
  | ENUM  { $$.type = pair_a($1); $$.val.i = pair_b($1); }
  ;
 
-pair_expr:
-   term { $$ = f_eval_int($1); check_u16($$); }
-
-pair_atom:
-   pair_expr { $$ = pair($1, $1); }
- | pair_expr DDOT pair_expr { $$ = pair($1, $3); }
- | '*' { $$ = 0xFFFF; }
- ;
+cnum:
+   term { $$ = f_eval_int($1); }
 
 pair_item:
-   '(' pair_atom ',' pair_atom ')' {
-     $$ = f_new_pair_set(pair_a($2), pair_b($2), pair_a($4), pair_b($4));
-   }
- | '(' pair_atom ',' pair_atom ')' DDOT '(' pair_expr ',' pair_expr ')' {
-     /* Hack: $2 and $4 should be pair_expr, but that would cause shift/reduce conflict */
-     if ((pair_a($2) != pair_b($2)) || (pair_a($4) != pair_b($4)))
-       cf_error("syntax error");
-     $$ = f_new_pair_item(pair_b($2), $8, pair_b($4), $10); 
-   }
+   '(' cnum ',' cnum ')'		{ $$ = f_new_pair_item($2, $2, $4, $4); }
+ | '(' cnum ',' cnum DDOT cnum ')'	{ $$ = f_new_pair_item($2, $2, $4, $6); }
+ | '(' cnum ',' '*' ')'			{ $$ = f_new_pair_item($2, $2, 0, CC_ALL); }
+ | '(' cnum DDOT cnum ',' cnum ')'	{ $$ = f_new_pair_set($2, $4, $6, $6); }
+ | '(' cnum DDOT cnum ',' cnum DDOT cnum ')' { $$ = f_new_pair_set($2, $4, $6, $8); }
+ | '(' cnum DDOT cnum ',' '*' ')'	{ $$ = f_new_pair_item($2, $4, 0, CC_ALL); }
+ | '(' '*' ',' cnum ')'			{ $$ = f_new_pair_set(0, CC_ALL, $4, $4); }
+ | '(' '*' ',' cnum DDOT cnum ')'	{ $$ = f_new_pair_set(0, CC_ALL, $4, $6); }
+ | '(' '*' ',' '*' ')'			{ $$ = f_new_pair_item(0, CC_ALL, 0, CC_ALL); }
+ | '(' cnum ',' cnum ')' DDOT '(' cnum ',' cnum ')'
+   { $$ = f_new_pair_item($2, $8, $4, $10); }
  ;
 
-ec_expr:
-   term { $$ = f_eval_int($1); }
-
 ec_kind:
    RT { $$ = EC_RT; }
  | RO { $$ = EC_RO; }
@@ -582,14 +598,27 @@ ec_kind:
  ;
 
 ec_item:
-   '(' ec_kind ',' ec_expr ',' ec_expr ')' { $$ = f_new_ec_item($2, 0, $4, $6, $6); }
- | '(' ec_kind ',' ec_expr ',' ec_expr DDOT ec_expr ')' { $$ = f_new_ec_item($2, 0, $4, $6, $8); }
- | '(' ec_kind ',' ec_expr ',' '*' ')' {  $$ = f_new_ec_item($2, 0, $4, 0, EC_ALL); }
- ;
+   '(' ec_kind ',' cnum ',' cnum ')'		{ $$ = f_new_ec_item($2, 0, $4, $6, $6); }
+ | '(' ec_kind ',' cnum ',' cnum DDOT cnum ')'	{ $$ = f_new_ec_item($2, 0, $4, $6, $8); }
+ | '(' ec_kind ',' cnum ',' '*' ')'		{ $$ = f_new_ec_item($2, 0, $4, 0, EC_ALL); }
+ ;
+
+lc_item:
+   '(' cnum ',' cnum ',' cnum ')'	    { $$ = f_new_lc_item($2, $2, $4, $4, $6, $6); }
+ | '(' cnum ',' cnum ',' cnum DDOT cnum ')' { $$ = f_new_lc_item($2, $2, $4, $4, $6, $8); }
+ | '(' cnum ',' cnum ',' '*' ')'	    { $$ = f_new_lc_item($2, $2, $4, $4, 0, LC_ALL); }
+ | '(' cnum ',' cnum DDOT cnum ',' '*' ')'  { $$ = f_new_lc_item($2, $2, $4, $6, 0, LC_ALL); }
+ | '(' cnum ',' '*' ',' '*' ')'		    { $$ = f_new_lc_item($2, $2, 0, LC_ALL, 0, LC_ALL); }
+ | '(' cnum DDOT cnum ',' '*' ',' '*' ')'   { $$ = f_new_lc_item($2, $4, 0, LC_ALL, 0, LC_ALL); }
+ | '(' '*' ',' '*' ',' '*' ')'		    { $$ = f_new_lc_item(0, LC_ALL, 0, LC_ALL, 0, LC_ALL); }
+ | '(' cnum ',' cnum ',' cnum ')' DDOT '(' cnum ',' cnum ',' cnum ')'
+   { $$ = f_new_lc_item($2, $10, $4, $12, $6, $14); }
+;
 
 set_item:
    pair_item
  | ec_item
+ | lc_item
  | set_atom { $$ = f_new_item($1, $1); }
  | set_atom DDOT set_atom { $$ = f_new_item($1, $3); }
  ;
@@ -597,6 +626,7 @@ set_item:
 switch_item:
    pair_item
  | ec_item
+ | lc_item
  | switch_atom { $$ = f_new_item($1, $1); }
  | switch_atom DDOT switch_atom { $$ = f_new_item($1, $3); }
  ;

From cec4a73ccb22ed412e87560e4210b6df40832aad Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Tue, 4 Oct 2016 00:31:43 +0200
Subject: [PATCH 125/165] Doc: Documentation for large communities

---
 doc/bird.sgml | 38 ++++++++++++++++++++++++++++++++++----
 1 file changed, 34 insertions(+), 4 deletions(-)

diff --git a/doc/bird.sgml b/doc/bird.sgml
index 26673f03..bb88dc61 100644
--- a/doc/bird.sgml
+++ b/doc/bird.sgml
@@ -1048,7 +1048,16 @@ foot).
 	for <cf/key/ and <cf/value/ parts, (e.g. <cf/(ro, myas, 3*10)/, where
 	<cf/myas/ is an integer variable).
 
-	<tag/int|pair|quad|ip|prefix|ec|enum set/
+	<tag/lc/
+	This is a specialized type used to represent BGP large community
+	values. It is essentially a triplet of 32bit values, where the first
+	value is reserved for the AS number of the issuer, while meaning of
+	remaining parts is defined by the issuer. Literals of this type are
+	written as <cf/(123, 456, 789)/, with any integer values. Similarly to
+	pairs, LCs can be constructed using expressions for its parts, (e.g.
+	<cf/(myas, 10+20, 3*10)/, where <cf/myas/ is an integer variable).
+
+	<tag/int|pair|quad|ip|prefix|ec|lc|enum set/
 	Filters recognize four types of sets. Sets are similar to strings: you
 	can pass them around but you can't modify them. Literals of type <cf>int
 	set</cf> look like <cf> [ 1, 2, 5..7 ]</cf>. As you can see, both simple
@@ -1067,9 +1076,15 @@ foot).
 	(like <cf/(rt, *, 3)/) are not allowed (as they usually have 4B range
 	for ASNs).
 
-	You can also use expressions for int, pair and EC set values. However it
-	must be possible to evaluate these expressions before daemon boots. So
-	you can use only constants inside them. E.g.
+	Also LC sets use similar expressions like pair sets. You can use ranges
+	and wildcards, but if one field uses that, more specific (later) fields
+	must be wildcards. E.g., <cf/(10, 20..30, *)/ or <cf/(10, 20, 30..40)/
+	is valid, while <cf/(10, *, 20..30)/ or <cf/(10, 20..30, 40)/ is not
+	valid.
+
+	You can also use expressions for int, pair, EC and LC set values.
+	However, it must be possible to evaluate these expressions before daemon
+	boots. So you can use only constants inside them. E.g.
 
 	<code>
 	 define one=1;
@@ -1205,6 +1220,13 @@ foot).
 	The same operations (like <cf/add/, <cf/delete/ or <cf/&tilde;/ and
 	<cf/!&tilde;/ membership operators) can be used to modify or test
 	eclists, with ECs instead of pairs as arguments.
+
+	<tag/lclist/
+	Lclist is a data type used for BGP large community lists. Like eclists,
+	lclists are very similar to clists, but they are sets of LCs instead of
+	pairs. The same operations (like <cf/add/, <cf/delete/ or <cf/&tilde;/
+	and <cf/!&tilde;/ membership operators) can be used to modify or test
+	lclists, with LCs instead of pairs as arguments.
 </descrip>
 
 
@@ -2193,6 +2215,14 @@ some of them (marked with `<tt/O/') are optional.
 	field. Individual community values are represented using an <cf/ec/ data
 	type inside the filters.
 
+	<tag>lclist <cf/bgp_large_community/ [O]</tag>
+	List of large community values associated with the route. Large BGP
+	communities is another variant of communities, but contrary to extended
+	communities they behave very much the same way as regular communities,
+	just larger -- they are uniform untyped triplets of 32bit numbers.
+	Individual community values are represented using an <cf/lc/ data type
+	inside the filters.
+
 	<tag>quad <cf/bgp_originator_id/ [I, O]</tag>
 	This attribute is created by the route reflector when reflecting the
 	route and contains the router ID of the originator of the route in the

From a46e01eeef17a7efe876618623397f60e62afe37 Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Tue, 4 Oct 2016 12:45:39 +0200
Subject: [PATCH 126/165] Nest: Fix signedness of large communities

---
 nest/a-set.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/nest/a-set.c b/nest/a-set.c
index 0484ab98..fde34cab 100644
--- a/nest/a-set.c
+++ b/nest/a-set.c
@@ -144,7 +144,7 @@ ec_set_format(struct adata *set, int from, byte *buf, uint size)
 int
 lc_format(byte *buf, lcomm lc)
 {
-  return bsprintf(buf, "(%d, %d, %d)", lc.asn, lc.ldp1, lc.ldp2);
+  return bsprintf(buf, "(%u, %u, %u)", lc.asn, lc.ldp1, lc.ldp2);
 }
 
 int
@@ -167,7 +167,7 @@ lc_set_format(struct adata *set, int from, byte *buf, uint bufsize)
 	  return i;
 	}
 
-      buf += bsprintf(buf, "(%d, %d, %d)", d[i], d[i+1], d[i+2]);
+      buf += bsprintf(buf, "(%u, %u, %u)", d[i], d[i+1], d[i+2]);
       *buf++ = ' ';
     }
 

From a998836d4bd4df8820e67f51e16d81a5a8dc9e9b Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Tue, 4 Oct 2016 23:19:35 +0200
Subject: [PATCH 127/165] Filter: fix missing separator

---
 filter/trie.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/filter/trie.c b/filter/trie.c
index 8af9015e..fba395d1 100644
--- a/filter/trie.c
+++ b/filter/trie.c
@@ -297,7 +297,7 @@ trie_format(struct f_trie *t, buffer *buf)
   buffer_puts(buf, "[");
 
   if (t->zero)
-    buffer_print(buf, "%I/%d", IPA_NONE, 0);
+    buffer_print(buf, "%I/%d, ", IPA_NONE, 0);
   trie_node_format(t->root, buf);
 
   /* Undo last separator */

From 9faf72c8cc9a099b41c90ee1822e8bca22fd0596 Mon Sep 17 00:00:00 2001
From: Pavel Tvrdik <pawel.tvrdik@gmail.com>
Date: Thu, 29 Sep 2016 11:20:04 +0200
Subject: [PATCH 128/165] Doc: Fix whitespaces

---
 doc/sbase/dist/birddoc/groff/mapping   | 144 ++++++++++++-------------
 doc/sbase/dist/birddoc/html/mapping    |  60 +++++------
 doc/sbase/dist/birddoc/latex2e/mapping |  42 ++++----
 doc/sbase/dtd/birddoc.dtd              | 102 +++++++++---------
 4 files changed, 174 insertions(+), 174 deletions(-)

diff --git a/doc/sbase/dist/birddoc/groff/mapping b/doc/sbase/dist/birddoc/groff/mapping
index 71d2c935..3861a28d 100644
--- a/doc/sbase/dist/birddoc/groff/mapping
+++ b/doc/sbase/dist/birddoc/groff/mapping
@@ -6,7 +6,7 @@
 % Based on qwertz replacement file by Tom Gordon
 % linuxdoc mods by mdw
 
-% Groff dependencies are few.  To port to another roff: 
+% Groff dependencies are few.  To port to another roff:
 % 1. Check and modify, if necessary, font changes.  (e.g. In psroff the
 % same fonts have other names.)
 % 2. Check the code for including Encapsulated PostScript, generated
@@ -19,13 +19,13 @@
 
 			% Hacked by mdw
 			".nr PI 3n\n"
-			".ds CF \\\\n\%\n"	
+			".ds CF \\\\n\%\n"
 			".ds CH \\&\n"
 			".ds dR $\n"   % dollar, to avoid EQN conflicts
 
 			% Start with no TOC
 			".ds printtoc\n"
-			
+
 			% Footnote style
 			".nr FF 1\n"
 
@@ -51,16 +51,16 @@
                         ".nr HM 0i\n"
                         ".nr FM 0i\n"
 
-			% Turn off right-margin filling 
+			% Turn off right-margin filling
 			".na\n"
-			
+
 			% h is 1 if first paragraph after heading
 
-			".nr h 0\n" 
+			".nr h 0\n"
 
 			% initialize heading level
-			
-			".nr il 1\n"	
+
+			".nr il 1\n"
 
 			% Number registers for list
 
@@ -68,20 +68,20 @@
 			".nr ll 0\n"  % list level, stores current level
 			".nr el 0\n"  % current enumeration level
 
-			% Not all list levels are enumerations, as 
+			% Not all list levels are enumerations, as
 			% itemizations can be embedded within enumerations
 			% and vice versa
-			
+
 			% type of list level is in \n(t\n(ll, where
 			% 0 : itemize, 1 : enumerate, 2: description
 
 			% enumerator for an enumeration level is in
 			% \n(e\n(el -- i.e. \n(e1=2 means current item of
 			% enumeration level 1 is 2
-			
+
 			% context-sensitive paragraph macro
 
-% Bug: There's some problem using this to re-start paragraphs after the 
+% Bug: There's some problem using this to re-start paragraphs after the
 % </verb> and </code>, so after verb and code I insert .LP. That's fine
 % except that is loses indentation when using verb or code inside of a list.
 
@@ -95,21 +95,21 @@
 % for this enumeration level
 ".if \\\\n(t\\\\n(ll=1 \\{.IP \\\\n+(e\\\\n(el.\\}\n"
 % if first par element of descrip, do nothing
-".\\}\n"  
+".\\}\n"
 ".el .sp \n"		% subsequent par element of item
 ".\\}\n"
 ".el \\{\\\n"		     	% not within list
-".ie \\\\nh=1 \\{\\\n"	% first par after heading  
-".LP\n"	
+".ie \\\\nh=1 \\{\\\n"	% first par after heading
+".LP\n"
 ".nr h 0\n"	% reset h flag
-".\\}\n"	        
+".\\}\n"
 ".el .LP \n"   % Changed from .PP, mdw
 ".\\}\n"
 ".nh\n"
-"..\n"	
+"..\n"
+
+
 
-			
-			
 			% for each level, a number register is created
 			% to store its type and current item number, where
 			% -1=bullet of an itemized list.
@@ -141,7 +141,7 @@
 % set initial level of headings, in register il
 
 <article>		+	".nr il 0"		+
-</article>		+	".if '\\*[printtoc]'true' .PX\n" 
+</article>		+	".if '\\*[printtoc]'true' .PX\n"
 
 <report>		+ 	".nr il 1"		+
 </report>	+	".bp\n"
@@ -153,23 +153,23 @@
 			".bp\n"
 			".TC"			+
 
-<notes>		
+<notes>
 </notes>
 
 <manpage>	+	".nr il -1"		+
-</manpage>	
+</manpage>
 
 <progdoc>
 </progdoc>
 
 % Hacked up titlepag stuff to look more reasonable. Titles and author
 % names are now stored in strings, printed by the end of </titlepag>.
-% Wake up! This uses groff-like long string names. You must use groff 
+% Wake up! This uses groff-like long string names. You must use groff
 % to format this.
 
 <titlepag>	+	".ds mdwtitle\n"
 			".ds mdwsubtitle\n"
-			".ds mdwdate\n"		
+			".ds mdwdate\n"
 			".de printabstract\n"
 			"..\n"			+
 </titlepag>	+	"\\*[mdwtitle]\n"
@@ -181,10 +181,10 @@
 			"\\*[mdwdate]\n"
 			".br\n"
 			".printabstract\n"
-			".br\n"	
+			".br\n"
 
 %<title>		+	".TL"			+
-%</title>	
+%</title>
 
 <title>		+	".ds mdwtitle "
 </title>	+
@@ -194,13 +194,13 @@
 %			".SM"		+
 %</subtitle>	+	".LG"			+
 
-<subtitle>	+	".ds mdwsubtitle "	
+<subtitle>	+	".ds mdwsubtitle "
 </subtitle>	+
 
-<date>		+	".ds mdwdate "	
+<date>		+	".ds mdwdate "
 </date>		+
 
-<abstract>	+ 	".de printabstract\n"	
+<abstract>	+ 	".de printabstract\n"
 			".LP\n"
 </abstract>	+	".."			+
 
@@ -215,10 +215,10 @@
 <name>		+	".br"			+
 </name>
 
-<and>		
+<and>
 </and>
 
-<thanks>			"\\**\n"	
+<thanks>			"\\**\n"
 			".FS"			+
 </thanks>	+	".FE"			+
 
@@ -229,11 +229,11 @@
 <newline>	+	".br"
 </newline>
 
-<label>		
-</label>	
+<label>
+</label>
 
-<header>	
-</header>	
+<header>
+</header>
 
 <lhead>		+	".EH '"
 </lhead>		"'''"		+
@@ -263,13 +263,13 @@
 <toc>
 </toc>
 
-<lof>	
+<lof>
 </lof>
 
-<lot>	
+<lot>
 </lot>
 
-<chapt>		+	".bp\n"	
+<chapt>		+	".bp\n"
 			".NH \\n(il "		+
 </chapt>
 
@@ -283,7 +283,7 @@
 </sect2>
 
 <sect3>		+	".NH 4+\\n(il"		+
-</sect3>	
+</sect3>
 
 <sect4>		+	".NH 5+\\n(il"		+
 </sect4>
@@ -292,10 +292,10 @@
 </heading>	+	"\\*h\n"
 			".XS \\n%\n"
 			"\\*(SN \\*h\n"
-			".XE\n"		
+			".XE\n"
 			".nr h 1\n"  % set heading flag to true
 
-<p>		+	".Pp"			+   
+<p>		+	".Pp"			+
 </p>
 
 <itemize>	+	".nr ll +1\n"	   % increment list level
@@ -309,9 +309,9 @@
 			".af e\\n(el \\*(f\\n(el\n" % style of enumerator
 			".if \\n(ll>1 .RS"  +
 </enum>		+	".if \\n(ll>1 .RE\n"
-			".br\n"			
+			".br\n"
 			".nr el -1\n"	    % decrement enumeration level
-			".nr ll -1\n"	    % decrement list level 
+			".nr ll -1\n"	    % decrement list level
 
 <descrip>	+	".RS\n"
 			".nr ll +1\n"	    % increment list level
@@ -324,7 +324,7 @@
 % If bi=1 then the paragraph is the first one of the item.
 
 <item>		+	".nr bi 1\n.Pp"		+
-</item>	
+</item>
 
 <tag>		+	".IP \"\\fB"
 </tag>			"\\fR\"\n"
@@ -337,12 +337,12 @@
 </cf>			""
 
 <cite>		+	".\[\n[ID]\n.\]"	+
-</cite>	
+</cite>
 
 <ncite>		+	".\[\n[ID]\n.\]\n([NOTE])"
 </ncite>
 
-<footnote>		" (-- "	
+<footnote>		" (-- "
 </footnote>		"--)"			+
 
 <sq>			"\\*Q"
@@ -353,20 +353,20 @@
 </lq>		+	".nr LL \\n(LL+\\n(PI\n"
 			".RE"			+
 
-<em>			"\\fI"			
-</em>		 	"\\fP"			
+<em>			"\\fI"
+</em>		 	"\\fP"
 
-<bf>			"\\fB"			
-</bf>			"\\fR"			
+<bf>			"\\fB"
+</bf>			"\\fR"
 
-<it>			"\\fI"			
-</it>			"\\fR"		
+<it>			"\\fI"
+</it>			"\\fR"
 
-<sf>			"\\fR"		
-</sf>			"\\fR"			
+<sf>			"\\fR"
+</sf>			"\\fR"
 
-<sl>			"\\fI"		
-</sl>			"\\fR"			
+<sl>			"\\fI"
+</sl>			"\\fR"
 
 % Changed by mdw
 <tt>			"\\fC"
@@ -394,10 +394,10 @@
 <pageref>		"??"
 </pageref>
 
-<x>	
+<x>
 </x>
 
-<mc>			
+<mc>
 </mc>
 
 <biblio>	+	".\[\n"
@@ -423,7 +423,7 @@
 	 	%	".Pp"	+  % continue previous paragraph (changed mdw)
 			".LP"
 
-% tscreen added by mdw 
+% tscreen added by mdw
 <tscreen>       +       ".br\n"
                         ".po 0.75i\n"
                         ".ll 6.0i\n"
@@ -487,8 +487,8 @@
 
 % mathematics -- this nroff version needs work.
 
-<f>					
-</f>			
+<f>
+</f>
 
 <dm>		+	".DS L"		        +
 </dm>		+	".DE"			+
@@ -496,8 +496,8 @@
 <eq>		+	".DS L"			+
 </eq>		+	".DE"			+
 
-<fr>			
-</fr>		
+<fr>
+</fr>
 
 <nu>			"{"
 </nu>			"} over "
@@ -505,7 +505,7 @@
 <de>			"{"
 </de>			"}"
 
-<lim>			
+<lim>
 </lim>
 
 <op>
@@ -527,7 +527,7 @@
 </in>
 
 <sum>			" sum "
-</sum>		
+</sum>
 
 % limitation: eqn only does square roots!
 
@@ -539,7 +539,7 @@
 			"[ca]."			+
 </ar>		+	".TE"			+
 
-<arr>   		"\n"			
+<arr>   		"\n"
 </arr>
 
 <arc>   		"|"
@@ -567,8 +567,8 @@
 
 % limitation: no calligraphic characters, using helvetica italics instead.  Is there a better font?
 
-<fi>			"\\fI"	
-</fi>			"\\fP"	
+<fi>			"\\fI"
+</fi>			"\\fP"
 
 <phr>			" roman }"
 </phr>			"}"
@@ -584,12 +584,12 @@
 
 <eps>		+  	".if t .PSPIC [file].ps\n"
 			".if n .sp 4"	  	+
-</eps>                	
-            	
+</eps>
+
 % Are TeX units properly handled by this translation of ph?
 
 <ph>		+	".sp [VSPACE]"		+
-</ph>	
+</ph>
 
 <caption>	+	".sp\n.ce"		+
 </caption>
@@ -619,7 +619,7 @@
 <slides>	+ 	".nr PS 18"		+
 </slides>
 
-<slide>	
+<slide>
 </slide>	+	".bp\n\\&"			+
 
 % letters -- replacement for email, using mh format.
diff --git a/doc/sbase/dist/birddoc/html/mapping b/doc/sbase/dist/birddoc/html/mapping
index 353d7774..d95b1759 100644
--- a/doc/sbase/dist/birddoc/html/mapping
+++ b/doc/sbase/dist/birddoc/html/mapping
@@ -21,7 +21,7 @@
 </notes>	+	"<@@enddoc>"		+
 
 % Manual Pages are expected to be formatted using nroff (or groff), unless
-% they are included  as sections of other qwertz documents.  
+% they are included  as sections of other qwertz documents.
 
 <manpage>
 </manpage>
@@ -35,7 +35,7 @@
 <title>		+	"<@@title>"
 </title>
 
-<subtitle>	+	"<H2>"	
+<subtitle>	+	"<H2>"
 </subtitle>		"</H2>"			+
 
 <author>
@@ -48,26 +48,26 @@
 </and>
 
 <thanks>	+	"Thanks "
-</thanks>		
+</thanks>
 
 <inst>		+	"<H3>"
 </inst>			"</H3>"			+
 
 <newline>		"<BR>"
-	
+
 <label>		+	"<@@label>[ID]"		+
-	
-<header>	
-</header>	
+
+<header>
+</header>
 
 <lhead>		+	"<!-- "
-</lhead>		" -->"			+			
+</lhead>		" -->"			+
 
 <rhead>		+	"<!-- "
 </rhead>		" -->"			+
 
 <comment>	+	"<H4>Comment</H4>"	+
-</comment>		
+</comment>
 
 <abstract>	+	"<P><HR>\n<EM>"
 </abstract>		"</EM>\n<HR>"		+
@@ -99,7 +99,7 @@
 <sect3>		+	"<@@head>"
 </sect3>
 
-<sect4>		+	"<@@head>"		
+<sect4>		+	"<@@head>"
 </sect4>
 
 <heading>
@@ -203,7 +203,7 @@
 			"<@@endurl>"		+
 </htmlurl>
 
-% ref modified to have an optional name field 
+% ref modified to have an optional name field
 <ref>		+	"<@@ref>[ID]\n"
 			"[NAME]</A>\n"
 			"<@@endref>"		+
@@ -228,7 +228,7 @@
 </mc>			"</MC>"
 
 <biblio>	+	"<BIBLIO STYLE=\"[STYLE]\" FILES=\"[FILES]\">" +
-</biblio>	
+</biblio>
 
 <code>		+	"<HR>\n<PRE>"		+
 </code>		+	"</PRE>\n<HR>"		+
@@ -244,28 +244,28 @@
 
 % theorems and such
 
-<def>		+	"<DEF>"			
+<def>		+	"<DEF>"
 </def>		+	"</DEF>"		+
 
-<prop>		+	"<PROP>"		
+<prop>		+	"<PROP>"
 </prop>		+	"</PROP>"		+
 
-<lemma>		+	"<LEMMA>"		
+<lemma>		+	"<LEMMA>"
 </lemma>	+	"</LEMMA>"		+
 
-<coroll>	+	"<COROLL>"		
+<coroll>	+	"<COROLL>"
 </coroll>	+	"</COROLL>"		+
 
-<proof>		+	"<PROOF>"		
+<proof>		+	"<PROOF>"
 </proof>	+	"</PROOF>"		+
 
-<theorem>	+	"<THEOREM>"		
+<theorem>	+	"<THEOREM>"
 </theorem>	+	"</THEOREM>"		+
 
 <thtag>			"<THTAG>"
 </thtag>		"</THTAG>"
 
-% mathematics 
+% mathematics
 
 <f>
 </f>
@@ -315,11 +315,11 @@
 <ar>			"<AR>"
 </ar>			"</AR>"
 
-<arr>                   "<ARR>" 
-</arr>			
+<arr>                   "<ARR>"
+</arr>
 
 <arc>                   "<ARC>"
-</arc>		
+</arc>
 
 <sup>			"<SUP>"
 </sup>			"</SUP>"
@@ -354,13 +354,13 @@
 </figure>	+	"</FIGURE>"			+
 
 <eps>		+   	"<EPS FILE=\"[FILE]\">"  +
-</eps>                	
-            	
+</eps>
+
 <img>		+	"<IMG SRC=\"[SRC]\">"	+
 </img>
 
 <ph>		+	"<PH VSPACE=\"[VSPACE]\">"	+
-</ph>	
+</ph>
 
 <caption>	+	"<CAPTION>"
 </caption>		"</CAPTION>" 	+
@@ -403,7 +403,7 @@
 </opening>		"</OPENING>"		+
 
 
-<from>		+	"<FROM>"			
+<from>		+	"<FROM>"
 </from>		+	"</FROM>"	+
 
 
@@ -419,7 +419,7 @@
 <email>		+	"<EMAIL>"
 </email>		"</EMAIL>"	+
 
-<phone>		+	"<PHONE>"	
+<phone>		+	"<PHONE>"
 </phone>		"</PHONE>"	+
 
 
@@ -430,16 +430,16 @@
 </subject>		"</SUBJECT>"	+
 
 
-<sref>		+	"<SREF>"	
+<sref>		+	"<SREF>"
 </sref>			"</SREF>"	+
 
-<rref>		+	"<RREF>"	
+<rref>		+	"<RREF>"
 </rref>			"</RREF>"	+
 
 <rdate>		+	"<RDATE>"
 </rdate>		"</RDATE>"	+
 
-<closing>	+	"<CLOSING>"	
+<closing>	+	"<CLOSING>"
 </closing>		"</CLOSING>"	+
 
 <cc>		+	"<CC>"
diff --git a/doc/sbase/dist/birddoc/latex2e/mapping b/doc/sbase/dist/birddoc/latex2e/mapping
index 747d0d33..97ca1753 100644
--- a/doc/sbase/dist/birddoc/latex2e/mapping
+++ b/doc/sbase/dist/birddoc/latex2e/mapping
@@ -14,7 +14,7 @@
 </book>		+	"\\end{document}"	+
 
 % Manual Pages are expected to be formatted using nroff (or groff), unless
-% they are included  as sections of other qwertz documents.  
+% they are included  as sections of other qwertz documents.
 
 <manpage>
 </manpage>
@@ -26,17 +26,17 @@
 </titlepag>	+	"\n\n\\begin{document}\n"
 			"\\maketitle\n"		+
 
-<title>		+	"\\title{"	
+<title>		+	"\\title{"
 </title>		"}"		+
 
 <subtitle>		"\\\\\n"
 			"{\\large "
 </subtitle>		"}" +
 
-<author>	+	"\\author{"	
+<author>	+	"\\author{"
 </author>		"}"	+
 
-<name>		
+<name>
 </name>
 
 <and>			"\\and "	+
@@ -51,14 +51,14 @@
 <date>		+	"\\date{"
 </date>			"}"		  +
 
-<newline>		"\\\\ "		  
+<newline>		"\\\\ "
 </newline>
 
 <label>			"\\label{[ID]}"
 </label>	
 
 <header>	+	"\\markboth"
-</header>	
+</header>
 
 <lhead>			"{"
 </lhead>		"}"
@@ -73,7 +73,7 @@
 </comment>		"}"
 
 % Hacked by mdw to use linuxdoc-sgml \abstract{...}
-<abstract>	+	"\\abstract{"	
+<abstract>	+	"\\abstract{"
 </abstract>	 	"}"	+
 
 <appendix>	+	"\n \\appendix \n"	+
@@ -101,15 +101,15 @@
 </sect2>
 
 <sect3>		+	"\n\\paragraph"
-</sect3>	
+</sect3>
 
 <sect4>		+	"\n\\subparagraph"
 </sect4>
 
 <heading>		"{"
-</heading>		"}\n\n" 
+</heading>		"}\n\n"
 
-<p>		
+<p>
 </p>			"\n\n"
 
 <itemize>	+	"\\begin{itemize}"	+
@@ -236,16 +236,16 @@
 <htmlurl>		"\\onlynameurl{[NAME]}"
 </htmlurl>
 
-<x>	
+<x>
 </x>
 
-<mc>			
+<mc>
 </mc>
 
 <biblio>	+	"\\bibliographystyle{[STYLE]}\n"
 			"\\bibliography{[FILES]}\n"
 			"\\addbibtoc{}"	+
-</biblio>	
+</biblio>
 
 % <macro>		+	"\\macro{[ID]}{\\qw[ID]}"
 % </macro>
@@ -300,19 +300,19 @@
 <thtag>			"\["
 </thtag>		"\]"			+
 
-% mathematics 
+% mathematics
 
 <f>			"$"
 </f>			"$"
 
-<dm>		+	"\\\["	
+<dm>		+	"\\\["
 </dm>			"\\\]"  +
 
 <eq>		+	"\\begin{equation}"	+
 </eq>		+	"\\end{equation}\n"	+
 
 <fr>			"\\frac"
-</fr>		
+</fr>
 
 <nu>			"{"
 </nu>			"}"
@@ -320,7 +320,7 @@
 <de>			"{"
 </de>			"}"
 
-<lim>			
+<lim>
 </lim>
 
 <op>
@@ -342,7 +342,7 @@
 </in>
 
 <sum>			"\\sum"
-</sum>		
+</sum>
 
 <root>			"\\sqrt\[[n]\]{"
 </root>			"}"
@@ -390,11 +390,11 @@
 </figure>	+	"\\end{figure}\n"		+
 
 <eps>		+   	"\\centerline{\\epsfig{file=[FILE],height=[HEIGHT],angle=[ANGLE]}}"  +
-</eps>                	
-            	
+</eps>
+
 
 <ph>		+	"\\vspace{[VSPACE]}\n\\par"	+
-</ph>	
+</ph>
 
 <caption>	+	"\\caption{"
 </caption>		"}" 	+
diff --git a/doc/sbase/dtd/birddoc.dtd b/doc/sbase/dtd/birddoc.dtd
index 9cedcacc..1654b0e5 100644
--- a/doc/sbase/dtd/birddoc.dtd
+++ b/doc/sbase/dtd/birddoc.dtd
@@ -1,6 +1,6 @@
 <!-- This is a DTD, but will be read as -*- sgml -*-   -->
 <!-- ================================================= -->
-<!-- $Id$ 
+<!-- $Id$
 
 This was heavilly modified for use with bird! Don't you dare to use it
 anywhere else. <pavel@ucw.cz>
@@ -79,7 +79,7 @@ anywhere else. <pavel@ucw.cz>
      weren't in the original linuxdoc 1.3 DTD, and are
      superseded by the new if/unless facility.         -->
 <!-- BK/97/05/09: this is the original Linuxdoc DTD,
-     as of SGML Tools 0.99.0. It is not longer 
+     as of SGML Tools 0.99.0. It is not longer
      supported. Use only if in dire need, for backwards
      compabitlity. Backend support for undocumented
      QWERTZ leftovers not in the strict Linuxdoc DTD's
@@ -92,7 +92,7 @@ anywhere else. <pavel@ucw.cz>
      any changes to this, just replacing.              -->
 <!-- ================================================= -->
 
-<!entity % emph 
+<!entity % emph
 	" em|it|bf|sf|sl|tt|cf|m|cparam|const|func|struct|param|type|funcdef " >
 
 <!entity % index "idx|cdx|nidx|ncdx" >
@@ -101,27 +101,27 @@ anywhere else. <pavel@ucw.cz>
 <!entity % xref
 	" label|ref|pageref|cite|url|htmlurl|ncite " >
 
-<!entity % inline 
+<!entity % inline
 	" (#pcdata | f| x| %emph; |sq| %xref | %index | file )* " >
 
-<!entity % list 
+<!entity % list
         " list | itemize | enum | descrip " >
 
-<!entity % par 	
+<!entity % par
 	"  %list; | comment | lq | quote | tscreen | hrule " >
 
 <!entity % mathpar " dm | eq " >
 
-<!entity % thrm 
+<!entity % thrm
         " def | prop | lemma | coroll | proof | theorem " >
 
 <!entity % litprog " code | verb " >
 
-<!entity % sectpar 
-        " %par; | figure | tabular | table | %mathpar; | 
+<!entity % sectpar
+        " %par; | figure | tabular | table | %mathpar; |
 	  %thrm; | %litprog; | function ">
-<!element birddoc o o 
-        (sect | chapt | article | report | 
+<!element birddoc o o
+        (sect | chapt | article | report |
 	 book | letter | telefax | slides | notes | manpage ) >
 
 <!-- `general' entity replaced with ISO entities - kwm -->
@@ -150,7 +150,7 @@ anywhere else. <pavel@ucw.cz>
 <!element hrule - - EMPTY>
 
 <!shortref pmap
-	"&#RS;B" null 
+	"&#RS;B" null
 	"&#RS;B&#RE;" psplit
 	"&#RS;&#RE;" psplit
 --	'"' qtag  --
@@ -189,7 +189,7 @@ anywhere else. <pavel@ucw.cz>
 <!entity   ftag     '<f>'    -- formula begin -- >
 <!entity   qendtag  '</sq>'>
 
-<!shortref sqmap 
+<!shortref sqmap
       "&#RS;B" null
 --      '"' qendtag  --
       "[" lsqb
@@ -249,7 +249,7 @@ anywhere else. <pavel@ucw.cz>
 <!shortref bodymap
      "&#RS;B&#RE;" ptag
      "&#RS;&#RE;" ptag
-      '"' qtag 
+      '"' qtag
       "[" lsqb
       "~" nbsp
       "_" lowbar
@@ -285,7 +285,7 @@ anywhere else. <pavel@ucw.cz>
 
 <!shortref oneline
      "B&#RE;" space
-     "&#RS;&#RE;" null 
+     "&#RS;&#RE;" null
      "&#RS;B&#RE;" null
 --      '"' qtag  --
       "[" ftag
@@ -302,7 +302,7 @@ anywhere else. <pavel@ucw.cz>
 <!usemap oneline caption>
 
 <!entity % tabrow "(%inline, (colsep, %inline)*)" >
-<!element tabular - - 
+<!element tabular - -
        (hline?, %tabrow, (rowsep, hline?, %tabrow)*, caption?) >
 
 <!attlist tabular
@@ -323,7 +323,7 @@ anywhere else. <pavel@ucw.cz>
       "B&#RE;" null
       "BB"  space
       "@" rowsep
-      "|" colsep 
+      "|" colsep
       "[" ftag
 --      '"' qtag --
       "_" thinsp
@@ -344,7 +344,7 @@ anywhere else. <pavel@ucw.cz>
 
 <!shortref ttmap     -- also on one-line --
         "B&#RE;" space
-        "&#RS;&#RE;" null 
+        "&#RS;&#RE;" null
         "&#RS;B&#RE;" null
 	"&#RS;B" null
         '#'     num
@@ -365,14 +365,14 @@ anywhere else. <pavel@ucw.cz>
 <!entity % limits    "pr|in|sum" >
 <!entity % fbu       "fr|lim|ar|root" >
 <!entity % fph       "unl|ovl|sup|inf" >
-<!entity % fbutxt    "(%fbu;) | (%limits;) | 
+<!entity % fbutxt    "(%fbu;) | (%limits;) |
                       (%fcstxt;)|(%fscs;)|(%fph;)" >
 <!entity % fphtxt    "p|#pcdata" >
 <!element  f        - - ((%fbutxt;)*) >
 
 <!entity   fendtag  '</f>'   -- formula end -- >
 
-<!shortref fmap 
+<!shortref fmap
       "&#RS;B" null
       "&#RS;B&#RE;" null
       "&#RS;&#RE;" null
@@ -432,7 +432,7 @@ anywhere else. <pavel@ucw.cz>
 <!shortref arrmap
      "&#RE;" space
       "@" arr
-      "|" arc 
+      "|" arc
       "_" thinsp
       "~" nbsp
       "#" num
@@ -448,7 +448,7 @@ anywhere else. <pavel@ucw.cz>
 <!element  ovl - - ((%fbutxt;)*) >
 <!element  rf  - o (#pcdata) >
 <!element  phr - o ((%fphtxt;)*) >
-<!element  v   - o ((%fcstxt;)*) 
+<!element  v   - o ((%fcstxt;)*)
 	-(tu|%limits;|%fbu;|%fph;) >
 <!element  fi  - o (#pcdata) >
 <!element  tu  - o empty >
@@ -468,7 +468,7 @@ anywhere else. <pavel@ucw.cz>
 
 <!shortref global
       "&#RS;B" null  -- delete leading blanks --
-  --    '"' qtag -- 
+  --    '"' qtag --
       "[" ftag
       "~" nbsp
       "_" lowbar
@@ -485,19 +485,19 @@ anywhere else. <pavel@ucw.cz>
 
 <!-- ref modified to have an optional name field HG -->
 <!element ref - o empty>
-<!attlist ref   
+<!attlist ref
         id cdata #required
         name cdata "&refnam">
 
 <!-- url entity added to have direct url references HG -->
 <!element url - o empty>
-<!attlist url   
+<!attlist url
         url cdata #required
         name cdata "&urlnam" >
 
 <!-- htmlurl entity added to have quieter url references esr -->
 <!element htmlurl - o empty>
-<!attlist htmlurl   
+<!attlist htmlurl
         url cdata #required
         name cdata "&urlnam" >
 
@@ -510,22 +510,22 @@ anywhere else. <pavel@ucw.cz>
 
 <!-- Hacked by mdw to exclude abstract; abstract now part of titlepag -->
 <!element article - -
-        (titlepag, header?, 
-         toc?, lof?, lot?, p*, sect*, 
+        (titlepag, header?,
+         toc?, lof?, lot?, p*, sect*,
          (appendix, sect+)?, biblio?) +(footnote)>
 
 <!attlist article
         opts cdata "null">
 
 <!-- Hacked by mdw to exclude abstract; abstract now part of titlepag -->
-<!element report - - 
+<!element report - -
         (titlepag, header?, toc?, lof?, lot?, p*,
          chapt*, (appendix, chapt+)?, biblio?) +(footnote)>
 
 <!attlist report
         opts cdata "null">
-<!element book  - - 
-        (titlepag, header?, toc?, lof?, lot?, p*, chapt*, 
+<!element book  - -
+        (titlepag, header?, toc?, lof?, lot?, p*, chapt*,
          (appendix, chapt+)?, biblio?) +(footnote) >
 
 <!attlist book
@@ -536,7 +536,7 @@ anywhere else. <pavel@ucw.cz>
 <!element title - o (%inline, subtitle?) +(newline)>
 <!element subtitle - o (%inline)>
 <!usemap oneline titlepag>
-<!element author - o (name, thanks?, inst?, 
+<!element author - o (name, thanks?, inst?,
                         (and, name, thanks?, inst?)*)>
 <!element name o o (%inline) +(newline)>
 <!element and - o empty>
@@ -545,9 +545,9 @@ anywhere else. <pavel@ucw.cz>
 <!element date - o (#pcdata) >
 
 <!usemap global thanks>
- 
+
 <!element newline - o empty >
-<!entity nl "<newline>"> 
+<!entity nl "<newline>">
 
 <!element progdoc - o empty>
 
@@ -575,11 +575,11 @@ anywhere else. <pavel@ucw.cz>
 <!element footnote - - (%inline)>
 <!usemap global footnote>
 <!element cite - o empty>
-<!attlist cite 
+<!attlist cite
         id cdata #required>
 
 <!element ncite - o empty>
-<!attlist ncite 
+<!attlist ncite
         id cdata #required
 	note cdata #required>
 
@@ -599,41 +599,41 @@ anywhere else. <pavel@ucw.cz>
 <!attlist slides
 	opts cdata "null">
 <!element slide - o (title?, p+) >
-<!entity  % addr "(address?, email?, phone?, fax?)" >  
-	
-<!element letter - - 
+<!entity  % addr "(address?, email?, phone?, fax?)" >
+
+<!element letter - -
 	(from, %addr, to, %addr, cc?, subject?, sref?, rref?,
          rdate?, opening, p+, closing, encl?, ps?)>
 
 <!attlist letter
 	opts cdata "null">
-	
+
 <!element from		- o (#pcdata) >
 <!element to		- o (#pcdata) >
-	
+
 <!usemap oneline (from,to)>
-	
+
 <!element address 	- o (#pcdata) +(newline) >
 <!element email		- o (#pcdata) >
 <!element phone		- o (#pcdata) >
 <!element fax 		- o (#pcdata) >
-	
+
 <!element subject 	- o (%inline;) >
 <!element sref		- o (#pcdata) >
 <!element rref          - o (#pcdata) >
 <!element rdate         - o (#pcdata) >
-	
+
 <!element opening 	- o (%inline;) >
 <!usemap oneline opening>
-	
+
 <!element closing - o (%inline;) >
 <!element cc - o (%inline;) +(newline) >
 <!element encl - o (%inline;) +(newline) >
-	
+
 <!element ps - o (p+) >
 
-<!element telefax - - 
-	(from, %addr, to, address, email?, 
+<!element telefax - -
+	(from, %addr, to, address, email?,
          phone?, fax, cc?, subject?,
          opening, p+, closing, ps?)>
 
@@ -644,8 +644,8 @@ anywhere else. <pavel@ucw.cz>
 <!element notes - - (title?, p+) >
 <!attlist notes
 	opts cdata "null" >
-<!element manpage - - (sect1*) 
-	-(sect2 | f | %mathpar | figure | tabular | 
+<!element manpage - - (sect1*)
+	-(sect2 | f | %mathpar | figure | tabular |
           table | %xref | %thrm )>
 
 
@@ -673,5 +673,5 @@ anywhere else. <pavel@ucw.cz>
 <!--
      Local Variables:
      mode: sgml
-     End:                                              -->                 
+     End:                                              -->
 <!-- ================================================= -->

From a2df7c0303d235f4122969243e9df152a8a16dcb Mon Sep 17 00:00:00 2001
From: Pavel Tvrdik <pawel.tvrdik@gmail.com>
Date: Thu, 29 Sep 2016 14:05:25 +0200
Subject: [PATCH 129/165] Doc: Generate clickable PDF

---
 doc/Makefile                           | 6 +++++-
 doc/sbase/dist/birddoc/latex2e/mapping | 1 +
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/doc/Makefile b/doc/Makefile
index f88c3205..70b73943 100644
--- a/doc/Makefile
+++ b/doc/Makefile
@@ -13,7 +13,7 @@ endif
 
 docs: progdocs userdocs
 progdocs: prog.html prog.ps
-userdocs: bird.html bird.ps
+userdocs: bird.html bird.pdf
 
 prog.sgml:
 	$(srcdir)/tools/progdoc $(srcdir_abs)
@@ -28,6 +28,10 @@ prog.sgml:
 %.ps: %.dvi
 	dvips -D600 -ta4 -o $@ $<
 
+%.pdf: %.tex
+	pdflatex $<
+	pdflatex $<
+
 %.tex: %.sgml
 	./sgml2latex --output=tex $<
 
diff --git a/doc/sbase/dist/birddoc/latex2e/mapping b/doc/sbase/dist/birddoc/latex2e/mapping
index 97ca1753..bd11b2d0 100644
--- a/doc/sbase/dist/birddoc/latex2e/mapping
+++ b/doc/sbase/dist/birddoc/latex2e/mapping
@@ -3,6 +3,7 @@
 
 % The \relax is there to avoid sgml2latex rewriting the class
 <book>		+ "\\relax\\documentclass\[a4paper,10pt,openany\]{book}\n"
+			"\\usepackage\[colorlinks=true,linkcolor=blue,pdftitle={BIRD User's Guide}\]{hyperref}\n"
 			"\\usepackage{birddoc}\n"
 			"\\usepackage{qwertz}\n"
 			"\\usepackage{url}\n"

From b9864aa87193ac1a5ebbc04d24ec782a1fe9637a Mon Sep 17 00:00:00 2001
From: Pavel Tvrdik <pawel.tvrdik@gmail.com>
Date: Mon, 26 Sep 2016 18:00:59 +0200
Subject: [PATCH 130/165] Doc: Add labels to all chapters and options

---
 doc/bird.sgml                          | 776 +++++++++++++------------
 doc/sbase/dist/birddoc/html/mapping    |   1 +
 doc/sbase/dist/birddoc/latex2e/mapping |  12 +-
 doc/sbase/dtd/birddoc.dtd              |   4 +-
 4 files changed, 428 insertions(+), 365 deletions(-)

diff --git a/doc/bird.sgml b/doc/bird.sgml
index bb88dc61..f2001e75 100644
--- a/doc/bird.sgml
+++ b/doc/bird.sgml
@@ -39,11 +39,12 @@ This document contains user documentation for the BIRD Internet Routing Daemon p
 
 
 <chapt>Introduction
+<label id="intro">
 
 <sect>What is BIRD
+<label id="what-is-bird">
 
-<p><label id="intro">
-The name `BIRD' is actually an acronym standing for `BIRD Internet Routing
+<p>The name `BIRD' is actually an acronym standing for `BIRD Internet Routing
 Daemon'. Let's take a closer look at the meaning of the name:
 
 <p><em/BIRD/: Well, we think we have already explained that. It's an acronym
@@ -118,6 +119,7 @@ files, tools ...).
 
 
 <sect>Installing BIRD
+<label id="install">
 
 <p>On a recent UNIX system with GNU development tools (GCC, binutils, m4, make)
 and Perl, installing BIRD should be as easy as:
@@ -138,45 +140,46 @@ BIRD executable by configuring out routing protocols you don't use, and
 
 
 <sect>Running BIRD
+<label id="argv">
 
 <p>You can pass several command-line options to bird:
 
 <descrip>
-	<tag>-c <m/config name/</tag>
+	<tag><label id="argv-config">-c <m/config name/</tag>
 	use given configuration file instead of <it/prefix/<file>/etc/bird.conf</file>.
 
-	<tag>-d</tag>
+	<tag><label id="argv-debug">-d</tag>
 	enable debug messages and run bird in foreground.
 
-	<tag>-D <m/filename of debug log/</tag>
+	<tag><label id="argv-log-file">-D <m/filename of debug log/</tag>
 	log debugging information to given file instead of stderr.
 
-	<tag>-p</tag>
+	<tag><label id="argv-parse">-p</tag>
 	just parse the config file and exit. Return value is zero if the config
 	file is valid, nonzero if there are some errors.
 
-	<tag>-s <m/name of communication socket/</tag>
+	<tag><label id="argv-socket">-s <m/name of communication socket/</tag>
 	use given filename for a socket for communications with the client,
 	default is <it/prefix/<file>/var/run/bird.ctl</file>.
 
-	<tag>-P <m/name of PID file/</tag>
+	<tag><label id="argv-pid">-P <m/name of PID file/</tag>
 	create a PID file with given filename.
 
-	<tag>-u <m/user/</tag>
+	<tag><label id="argv-user">-u <m/user/</tag>
 	drop privileges and use that user ID, see the next section for details.
 
-	<tag>-g <m/group/</tag>
+	<tag><label id="argv-group">-g <m/group/</tag>
 	use that group ID, see the next section for details.
 
-	<tag>-f</tag>
+	<tag><label id="argv-foreground">-f</tag>
 	run bird in foreground.
 
-	<tag>-l</tag>
+	<tag><label id="argv-local">-l</tag>
 	look for a configuration file and a communication socket in the current
 	working directory instead of in default system locations. However, paths
 	specified by options <cf/-c/, <cf/-s/ have higher priority.
 
-	<tag>-R</tag>
+	<tag><label id="argv-recovery">-R</tag>
 	apply graceful restart recovery after start.
 </descrip>
 
@@ -184,6 +187,7 @@ BIRD executable by configuring out routing protocols you don't use, and
 
 
 <sect>Privileges
+<label id="privileges">
 
 <p>BIRD, as a routing daemon, uses several privileged operations (like setting
 routing table and using raw sockets). Traditionally, BIRD is executed and runs
@@ -208,6 +212,7 @@ the config file and create the control socket and the CAP_NET_* capabilities.
 
 
 <chapt>About routing tables
+<label id="routing-tables">
 
 <p>BIRD has one or more routing tables which may or may not be synchronized with
 OS kernel and which may or may not be synchronized with each other (see the Pipe
@@ -245,7 +250,7 @@ network. Note that although most protocols are interested in receiving just
 selected routes, some protocols (e.g. the <cf/Pipe/ protocol) receive and
 process all entries in routing tables (accepted by filters).
 
-<p><label id="dsc-sorted">Usually, a routing table just chooses a selected route
+<p><label id="dsc-table-sorted">Usually, a routing table just chooses a selected route
 from a list of entries for one network. But if the <cf/sorted/ option is
 activated, these lists of entries are kept completely sorted (according to
 preference or some protocol-dependent metric). This is needed for some features
@@ -259,6 +264,7 @@ is that it is slightly more computationally expensive.
 
 
 <sect>Graceful restart
+<label id="graceful-restart">
 
 <p>When BIRD is started after restart or crash, it repopulates routing tables in
 an uncoordinated manner, like after clean start. This may be impractical in some
@@ -274,8 +280,10 @@ particular boot by option <cf/-R/.
 
 
 <chapt>Configuration
+<label id="config">
 
 <sect>Introduction
+<label id="config-intro">
 
 <p>BIRD is configured using a text configuration file. Upon startup, BIRD reads
 <it/prefix/<file>/etc/bird.conf</file> (unless the <tt/-c/ command line option
@@ -319,15 +327,16 @@ protocol rip {
 
 
 <sect>Global options
+<label id="global-opts">
 
 <p><descrip>
-	<tag>include "<m/filename/"</tag>
+	<tag><label id="opt-include">include "<m/filename/"</tag>
 	This statement causes inclusion of a new file. <m/Filename/ could also
 	be a wildcard, in that case matching files are included in alphabetic
 	order. The maximal depth is 8. Note that this statement could be used
 	anywhere in the config file, not just as a top-level option.
 
-	<tag><label id="dsc-log">log "<m/filename/"|syslog [name <m/name/]|stderr all|{ <m/list of classes/ }</tag>
+	<tag><label id="opt-log">log "<m/filename/"|syslog [name <m/name/]|stderr all|{ <m/list of classes/ }</tag>
 	Set logging of messages having the given class (either <cf/all/ or
 	<cf/{ error, trace }/ etc.) into selected destination (a file specified
 	as a filename string, syslog with optional name argument, or the stderr
@@ -341,48 +350,48 @@ protocol rip {
 	You may specify more than one <cf/log/ line to establish logging to
 	multiple destinations. Default: log everything to the system log.
 
-	<tag>debug protocols all|off|{ states, routes, filters, interfaces, events, packets }</tag>
+	<tag><label id="opt-debug-protocols">debug protocols all|off|{ states, routes, filters, interfaces, events, packets }</tag>
 	Set global defaults of protocol debugging options. See <cf/debug/ in the
 	following section. Default: off.
 
-	<tag>debug commands <m/number/</tag>
+	<tag><label id="opt-debug-commands">debug commands <m/number/</tag>
 	Control logging of client connections (0 for no logging, 1 for logging
 	of connects and disconnects, 2 and higher for logging of all client
 	commands). Default: 0.
 
-	<tag>debug latency <m/switch/</tag>
+	<tag><label id="opt-debug-latency">debug latency <m/switch/</tag>
 	Activate tracking of elapsed time for internal events. Recent events
 	could be examined using <cf/dump events/ command. Default: off.
 
-	<tag>debug latency limit <m/time/</tag>
+	<tag><label id="opt-debug-latency-limit">debug latency limit <m/time/</tag>
 	If <cf/debug latency/ is enabled, this option allows to specify a limit
 	for elapsed time. Events exceeding the limit are logged. Default: 1 s.
 
-	<tag>watchdog warning <m/time/</tag>
+	<tag><label id="opt-watchdog-warn">watchdog warning <m/time/</tag>
 	Set time limit for I/O loop cycle. If one iteration took more time to
 	complete, a warning is logged. Default: 5 s.
 
-	<tag>watchdog timeout <m/time/</tag>
+	<tag><label id="opt-watchdog-timeout">watchdog timeout <m/time/</tag>
 	Set time limit for I/O loop cycle. If the limit is breached, BIRD is
 	killed by abort signal. The timeout has effective granularity of
 	seconds, zero means disabled. Default: disabled (0).
 
-	<tag>mrtdump "<m/filename/"</tag>
+	<tag><label id="opt-mrtdump">mrtdump "<m/filename/"</tag>
 	Set MRTdump file name. This option must be specified to allow MRTdump
 	feature. Default: no dump file.
 
-	<tag>mrtdump protocols all|off|{ states, messages }</tag>
+	<tag><label id="opt-mrtdump-protocols">mrtdump protocols all|off|{ states, messages }</tag>
 	Set global defaults of MRTdump options. See <cf/mrtdump/ in the
 	following section. Default: off.
 
-	<tag>filter <m/name local variables/{ <m/commands/ }</tag>
+	<tag><label id="opt-filter">filter <m/name local variables/{ <m/commands/ }</tag>
 	Define a filter. You can learn more about filters in the following
 	chapter.
 
-	<tag>function <m/name/ (<m/parameters/) <m/local variables/ { <m/commands/ }</tag>
+	<tag><label id="opt-function">function <m/name/ (<m/parameters/) <m/local variables/ { <m/commands/ }</tag>
 	Define a function. You can learn more about functions in the following chapter.
 
-	<tag>protocol rip|ospf|bgp|... [<m/name/ [from <m/name2/]] { <m>protocol options</m> }</tag>
+	<tag><label id="opt-protocol">protocol rip|ospf|bgp|... [<m/name/ [from <m/name2/]] { <m>protocol options</m> }</tag>
 	Define a protocol instance called <cf><m/name/</cf> (or with a name like
 	"rip5" generated automatically if you don't specify any
 	<cf><m/name/</cf>). You can learn more about configuring protocols in
@@ -391,7 +400,7 @@ protocol rip {
 	<cf><m/name2/</cf> You can run more than one instance of most protocols
 	(like RIP or BGP). By default, no instances are configured.
 
-	<tag>template rip|bgp|... [<m/name/ [from <m/name2/]] { <m>protocol options</m> }</tag>
+	<tag><label id="opt-template">template rip|bgp|... [<m/name/ [from <m/name2/]] { <m>protocol options</m> }</tag>
 	Define a protocol template instance called <m/name/ (or with a name like
 	"bgp1" generated automatically if you don't specify any	<m/name/).
 	Protocol templates can be used to group common options when many
@@ -400,25 +409,25 @@ protocol rip {
 	expression and the name of the template. At the moment templates (and
 	<cf/from/ expression) are not implemented for OSPF protocol.
 
-	<tag>define <m/constant/ = <m/expression/</tag>
+	<tag><label id="opt-define">define <m/constant/ = <m/expression/</tag>
 	Define a constant. You can use it later in every place you could use a
 	value of the same type. Besides, there are some predefined numeric
 	constants based on /etc/iproute2/rt_* files. A list of defined constants
 	can be seen (together with other symbols) using 'show symbols' command.
 
-	<tag>router id <m/IPv4 address/</tag>
- 	Set BIRD's router ID. It's a world-wide unique identification of your
+	<tag><label id="opt-router-id">router id <m/IPv4 address/</tag>
+	Set BIRD's router ID. It's a world-wide unique identification of your
 	router, usually one of router's IPv4 addresses. Default: in IPv4
 	version, the lowest IP address of a non-loopback interface. In IPv6
 	version, this option is mandatory.
 
-	<tag>router id from [-] [ "<m/mask/" ] [ <m/prefix/ ] [, ...]</tag>
+	<tag><label id="opt-router-id-from">router id from [-] [ "<m/mask/" ] [ <m/prefix/ ] [, ...]</tag>
 	Set BIRD's router ID based on an IP address of an interface specified by
 	an interface pattern. The option is applicable for IPv4 version only.
-	See <ref id="dsc-iface" name="interface"> section for detailed
+	See <ref id="proto-iface" name="interface"> section for detailed
 	description of interface patterns with extended clauses.
 
-	<tag>listen bgp [address <m/address/] [port <m/port/] [dual]</tag>
+	<tag><label id="opt-listen-bgp">listen bgp [address <m/address/] [port <m/port/] [dual]</tag>
 	This option allows to specify address and port where BGP protocol should
 	listen. It is global option as listening socket is common to all BGP
 	instances. Default is to listen on all addresses (0.0.0.0) and port 179.
@@ -427,13 +436,13 @@ protocol rip {
 	BIRD would accept IPv6 routes only). Such behavior was default in older
 	versions of BIRD.
 
-	<tag>graceful restart wait <m/number/</tag>
+	<tag><label id="opt-graceful-restart">graceful restart wait <m/number/</tag>
 	During graceful restart recovery, BIRD waits for convergence of routing
 	protocols. This option allows to specify a timeout for the recovery to
 	prevent waiting indefinitely if some protocols cannot converge. Default:
 	240 seconds.
 
-	<tag>timeformat route|protocol|base|log "<m/format1/" [<m/limit/ "<m/format2/"]</tag>
+	<tag><label id="opt-timeformat">timeformat route|protocol|base|log "<m/format1/" [<m/limit/ "<m/format2/"]</tag>
 	This option allows to specify a format of date/time used by BIRD. The
 	first argument specifies for which purpose such format is used.
 	<cf/route/ is a format used in 'show route' command output,
@@ -459,13 +468,13 @@ protocol rip {
 	hh:mm:ss) for <cf/base/ and <cf/log/. These timeformats could be set by
 	<cf/old short/ and <cf/old long/ compatibility shorthands.
 
-	<tag>table <m/name/ [sorted]</tag>
+	<tag><label id="opt-table">table <m/name/ [sorted]</tag>
 	Create a new routing table. The default routing table is created
 	implicitly, other routing tables have to be added by this command.
 	Option <cf/sorted/ can be used to enable sorting of routes, see
-	<ref id="dsc-sorted" name="sorted table"> description for details.
+	<ref id="dsc-table-sorted" name="sorted table"> description for details.
 
-	<tag>roa table <m/name/ [ { roa table options ... } ]</tag>
+	<tag><label id="opt-roa-table">roa table <m/name/ [ { roa table options ... } ]</tag>
 	Create a new ROA (Route Origin Authorization) table. ROA tables can be
 	used to validate route origination of BGP routes. A ROA table contains
 	ROA entries, each consist of a network prefix, a max prefix length and
@@ -479,12 +488,13 @@ protocol rip {
 	ROA entries. The option may be used multiple times. Other entries can be
 	added dynamically by <cf/add roa/ command.
 
-	<tag>eval <m/expr/</tag>
+	<tag><label id="opt-eval">eval <m/expr/</tag>
 	Evaluates given filter expression. It is used by us for	testing of filters.
 </descrip>
 
 
 <sect>Protocol options
+<label id="protocol-opts">
 
 <p>For each protocol instance, you can configure a bunch of options. Some of
 them (those described in this section) are generic, some are specific to the
@@ -497,16 +507,16 @@ disable it. An empty <m/switch/ is equivalent to <cf/on/ ("silence means
 agreement").
 
 <descrip>
-	<tag>preference <m/expr/</tag>
+	<tag><label id="proto-preference">preference <m/expr/</tag>
 	Sets the preference of routes generated by this protocol. Default:
 	protocol dependent.
 
-	<tag>disabled <m/switch/</tag>
+	<tag><label id="proto-disabled">disabled <m/switch/</tag>
 	Disables the protocol. You can change the disable/enable status from the
 	command line interface without needing to touch the configuration.
 	Disabled protocols are not activated. Default: protocol is enabled.
 
-	<tag>debug all|off|{ states, routes, filters, interfaces, events, packets }</tag>
+	<tag><label id="proto-debug">debug all|off|{ states, routes, filters, interfaces, events, packets }</tag>
 	Set protocol debugging options. If asked, each protocol is capable of
 	writing trace messages about its work to the log (with category
 	<cf/trace/). You can either request printing of <cf/all/ trace messages
@@ -517,7 +527,7 @@ agreement").
 	protocol, <cf/events/ for events internal to the protocol and <cf/packets/
 	for packets sent and received by the protocol. Default: off.
 
-	<tag>mrtdump all|off|{ states, messages }</tag>
+	<tag><label id="proto-mrtdump">mrtdump all|off|{ states, messages }</tag>
 	Set protocol MRTdump flags. MRTdump is a standard binary format for
 	logging information from routing protocols and daemons. These flags
 	control what kind of information is logged from the protocol to the
@@ -527,27 +537,27 @@ agreement").
 	BGP protocol, <cf/states/ logs BGP state changes and <cf/messages/ logs
 	received BGP messages. Other protocols does not support MRTdump yet.
 
-	<tag>router id <m/IPv4 address/</tag>
+	<tag><label id="proto-router-id">router id <m/IPv4 address/</tag>
 	This option can be used to override global router id for a given
 	protocol. Default: uses global router id.
 
-	<tag>import all | none | filter <m/name/ | filter { <m/filter commands/ } | where <m/filter expression/</tag>
+	<tag><label id="proto-import">import all | none | filter <m/name/ | filter { <m/filter commands/ } | where <m/filter expression/</tag>
 	Specify a filter to be used for filtering routes coming from the
 	protocol to the routing table. <cf/all/ is shorthand for <cf/where true/
 	and <cf/none/ is shorthand for <cf/where false/. Default: <cf/all/.
 
-	<tag>export <m/filter/</tag>
+	<tag><label id="proto-export">export <m/filter/</tag>
 	This is similar to the <cf>import</cf> keyword, except that it works in
 	the direction from the routing table to the protocol. Default: <cf/none/.
 
-	<tag>import keep filtered <m/switch/</tag>
+	<tag><label id="proto-import-keep-filtered">import keep filtered <m/switch/</tag>
 	Usually, if an import filter rejects a route, the route is forgotten.
 	When this option is active, these routes are kept in the routing table,
 	but they are hidden and not propagated to other protocols. But it is
 	possible to show them using <cf/show route filtered/. Note that this
 	option does not work for the pipe protocol. Default: off.
 
-	<tag><label id="import-limit">import limit [<m/number/ | off ] [action warn | block | restart | disable]</tag>
+	<tag><label id="proto-import-limit">import limit [<m/number/ | off ] [action warn | block | restart | disable]</tag>
 	Specify an import route limit (a maximum number of routes imported from
 	the protocol) and optionally the action to be taken when the limit is
 	hit. Warn action just prints warning log message. Block action discards
@@ -556,7 +566,7 @@ agreement").
 	action if an action is not explicitly specified. Note that limits are
 	reset during protocol reconfigure, reload or restart. Default: <cf/off/.
 
-	<tag>receive limit [<m/number/ | off ] [action warn | block | restart | disable]</tag>
+	<tag><label id="proto-receive-limit">receive limit [<m/number/ | off ] [action warn | block | restart | disable]</tag>
 	Specify an receive route limit (a maximum number of routes received from
 	the protocol and remembered). It works almost identically to <cf>import
 	limit</cf> option, the only difference is that if <cf/import keep
@@ -566,7 +576,7 @@ agreement").
 	on the contrary, counts accepted routes only and routes blocked by the
 	limit are handled like filtered routes. Default: <cf/off/.
 
-	<tag>export limit [ <m/number/ | off ] [action warn | block | restart | disable]</tag>
+	<tag><label id="proto-export-limit">export limit [ <m/number/ | off ] [action warn | block | restart | disable]</tag>
 	Specify an export route limit, works similarly to the <cf>import
 	limit</cf> option, but for the routes exported to the protocol. This
 	option is experimental, there are some problems in details of its
@@ -576,18 +586,18 @@ agreement").
 	updates of already accepted routes -- and these details will probably
 	change in the future. Default: <cf/off/.
 
-	<tag>description "<m/text/"</tag>
+	<tag><label id="proto-description">description "<m/text/"</tag>
 	This is an optional description of the protocol. It is displayed as a
 	part of the output of 'show route all' command.
 
-	<tag>table <m/name/</tag>
+	<tag><label id="proto-table">table <m/name/</tag>
 	Connect this protocol to a non-default routing table.
 </descrip>
 
 <p>There are several options that give sense only with certain protocols:
 
 <descrip>
-	<tag><label id="dsc-iface">interface [-] [ "<m/mask/" ] [ <m/prefix/ ] [, ...] [ { <m/option/ ; [...] } ]</tag>
+	<tag><label id="proto-iface">interface [-] [ "<m/mask/" ] [ <m/prefix/ ] [, ...] [ { <m/option/ ; [...] } ]</tag>
 	Specifies a set of interfaces on which the protocol is activated with
 	given interface-specific options. A set of interfaces specified by one
 	interface option is described using an interface pattern. The interface
@@ -634,7 +644,7 @@ agreement").
 	<cf>interface "eth*" 192.168.1.0/24;</cf> - start the protocol on all
 	ethernet interfaces that have address from 192.168.1.0/24.
 
-	<tag><label id="dsc-prio">tx class|dscp <m/num/</tag>
+	<tag><label id="proto-tx-class">tx class|dscp <m/num/</tag>
 	This option specifies the value of ToS/DS/Class field in IP headers of
 	the outgoing protocol packets. This may affect how the protocol packets
 	are processed by the network relative to the other network traffic. With
@@ -643,12 +653,12 @@ agreement").
 	keyword, the value (0-63) is used just for the DS field in the octet.
 	Default value is 0xc0 (DSCP 0x30 - CS6).
 
-	<tag>tx priority <m/num/</tag>
+	<tag><label id="proto-tx-priority">tx priority <m/num/</tag>
 	This option specifies the local packet priority. This may affect how the
 	protocol packets are processed in the local TX queues. This option is
 	Linux specific. Default value is 7 (highest priority, privileged traffic).
 
-	<tag><label id="dsc-pass">password "<m/password/" [ { id <m/num/; generate from <m/time/; generate to <m/time/; accept from <m/time/; accept to <m/time/; } ]</tag>
+	<tag><label id="proto-pass">password "<m/password/" [ { id <m/num/; generate from <m/time/; generate to <m/time/; accept from <m/time/; accept to <m/time/; } ]</tag>
 	Specifies a password that can be used by the protocol. Password option
 	can be used more times to specify more passwords. If more passwords are
 	specified, it is a protocol-dependent decision which one is really
@@ -659,35 +669,35 @@ agreement").
 	This option is allowed in OSPF and RIP protocols. BGP has also
 	<cf/password/ option, but it is slightly different and described
 	separately.
-
 	Default: none.
 </descrip>
 
 <p>Password option can contain section with some (not necessary all) password sub-options:
 
 <descrip>
-	<tag>id <M>num</M></tag>
+	<tag><label id="proto-pass-id">id <M>num</M></tag>
 	ID of the password, (1-255). If it is not used, BIRD will choose ID based
 	on an order of the password item in the interface. For example, second
 	password item in one interface will have default ID 2. ID is used by
 	some routing protocols to identify which password was used to
 	authenticate protocol packets.
 
-	<tag>generate from "<m/time/"</tag>
+	<tag><label id="proto-pass-gen-from">generate from "<m/time/"</tag>
 	The start time of the usage of the password for packet signing.
 	The format of <cf><m/time/</cf> is <tt>dd-mm-yyyy HH:MM:SS</tt>.
 
-	<tag>generate to "<m/time/"</tag>
+	<tag><label id="proto-pass-gen-to">generate to "<m/time/"</tag>
 	The last time of the usage of the password for packet signing.
 
-	<tag>accept from "<m/time/"</tag>
+	<tag><label id="proto-pass-accept-from">accept from "<m/time/"</tag>
 	The start time of the usage of the password for packet verification.
 
-	<tag>accept to "<m/time/"</tag>
+	<tag><label id="proto-pass-accept-to">accept to "<m/time/"</tag>
 	The last time of the usage of the password for packet verification.
 </descrip>
 
 <chapt>Remote control
+<label id="remote-control">
 
 <p>You can use the command-line client <file>birdc</file> to talk with a running
 BIRD. Communication is done using a <file/bird.ctl/ UNIX domain socket (unless
@@ -713,26 +723,26 @@ This argument can be omitted if there exists only a single instance.
 <p>Here is a brief list of supported functions:
 
 <descrip>
-	<tag>show status</tag>
+	<tag><label id="cli-show-status">show status</tag>
 	Show router status, that is BIRD version, uptime and time from last
 	reconfiguration.
 
-	<tag>show interfaces [summary]</tag>
+	<tag><label id="cli-show-interfaces">show interfaces [summary]</tag>
 	Show the list of interfaces. For each interface, print its type, state,
 	MTU and addresses assigned.
 
-	<tag>show protocols [all]</tag>
+	<tag><label id="cli-show-protocols">show protocols [all]</tag>
 	Show list of protocol instances along with tables they are connected to
 	and protocol status, possibly giving verbose information, if <cf/all/ is
 	specified.
 
-	<tag>show ospf interface [<m/name/] ["<m/interface/"]</tag>
+	<tag><label id="cli-show-ospf-iface">show ospf interface [<m/name/] ["<m/interface/"]</tag>
 	Show detailed information about OSPF interfaces.
 
-	<tag>show ospf neighbors [<m/name/] ["<m/interface/"]</tag>
+	<tag><label id="cli-show-ospf-neighbors">show ospf neighbors [<m/name/] ["<m/interface/"]</tag>
 	Show a list of OSPF neighbors and a state of adjacency to them.
 
-	<tag>show ospf state [all] [<m/name/]</tag>
+	<tag><label id="cli-show-ospf-state">show ospf state [all] [<m/name/]</tag>
 	Show detailed information about OSPF areas based on a content of the
 	link-state database. It shows network topology, stub networks,
 	aggregated networks and routers from other areas and external routes.
@@ -740,31 +750,31 @@ This argument can be omitted if there exists only a single instance.
 	<cf/all/ to show information about all network nodes in the link-state
 	database.
 
-	<tag>show ospf topology [all] [<m/name/]</tag>
+	<tag><label id="cli-show-ospf-topology">show ospf topology [all] [<m/name/]</tag>
 	Show a topology of OSPF areas based on a content of the link-state
 	database. It is just a stripped-down version of 'show ospf state'.
 
-	<tag>show ospf lsadb [global | area <m/id/ | link] [type <m/num/] [lsid <m/id/] [self | router <m/id/] [<m/name/] </tag>
+	<tag><label id="cli-show-ospf-lsadb">show ospf lsadb [global | area <m/id/ | link] [type <m/num/] [lsid <m/id/] [self | router <m/id/] [<m/name/] </tag>
 	Show contents of an OSPF LSA database. Options could be used to filter
 	entries.
 
-	<tag>show rip interfaces [<m/name/] ["<m/interface/"]</tag>
+	<tag><label id="cli-show-rip-interfaces">show rip interfaces [<m/name/] ["<m/interface/"]</tag>
 	Show detailed information about RIP interfaces.
 
-	<tag>show rip neighbors [<m/name/] ["<m/interface/"]</tag>
+	<tag><label id="cli-show-rip-neighbors">show rip neighbors [<m/name/] ["<m/interface/"]</tag>
 	Show a list of RIP neighbors and associated state.
 
-	<tag>show static [<m/name/]</tag>
+	<tag><label id="cli-show-static">show static [<m/name/]</tag>
 	Show detailed information about static routes.
 
-	<tag>show bfd sessions [<m/name/]</tag>
+	<tag><label id="cli-show-bfd-sessions">show bfd sessions [<m/name/]</tag>
 	Show information about BFD sessions.
 
-	<tag>show symbols [table|filter|function|protocol|template|roa|<m/symbol/]</tag>
+	<tag><label id="cli-show-symbols">show symbols [table|filter|function|protocol|template|roa|<m/symbol/]</tag>
 	Show the list of symbols defined in the configuration (names of
 	protocols, routing tables etc.).
 
-	<tag>show route [[for] <m/prefix/|<m/IP/] [table <m/sym/] [filter <m/f/|where <m/c/] [(export|preexport|noexport) <m/p/] [protocol <m/p/] [<m/options/]</tag>
+	<tag><label id="cli-show-route">show route [[for] <m/prefix/|<m/IP/] [table <m/sym/] [filter <m/f/|where <m/c/] [(export|preexport|noexport) <m/p/] [protocol <m/p/] [<m/options/]</tag>
 	Show contents of a routing table (by default of the main one or the
 	table attached to a respective protocol), that is routes, their metrics
 	and (in case the <cf/all/ switch is given) all their attributes.
@@ -799,7 +809,7 @@ This argument can be omitted if there exists only a single instance.
 	number of networks, number of routes before and after filtering). If
 	you use <cf/count/ instead, only the statistics will be printed.
 
-	<tag>show roa [<m/prefix/ | in <m/prefix/ | for <m/prefix/] [as <m/num/] [table <m/t/>]</tag>
+	<tag><label id="cli-show-roa">show roa [<m/prefix/ | in <m/prefix/ | for <m/prefix/] [as <m/num/] [table <m/t/>]</tag>
 	Show contents of a ROA table (by default of the first one). You can
 	specify a <m/prefix/ to print ROA entries for a specific network. If you
 	use <cf>for <m/prefix/</cf>, you'll get all entries relevant for route
@@ -808,19 +818,19 @@ This argument can be omitted if there exists only a single instance.
 	entries covered by the network prefix. You could also use <cf/as/ option
 	to show just entries for given AS.
 
-	<tag>add roa <m/prefix/ max <m/num/] as <m/num/ [table <m/t/>]</tag>
+	<tag><label id="cli-add-roa">add roa <m/prefix/ max <m/num/] as <m/num/ [table <m/t/>]</tag>
 	Add a new ROA entry to a ROA table. Such entry is called <it/dynamic/
 	compared to <it/static/ entries specified in the config file. These
 	dynamic entries survive reconfiguration.
 
-	<tag>delete roa <m/prefix/ max <m/num/] as <m/num/ [table <m/t/>]</tag>
+	<tag><label id="cli-delete-roa">delete roa <m/prefix/ max <m/num/] as <m/num/ [table <m/t/>]</tag>
 	Delete the specified ROA entry from a ROA table. Only dynamic ROA
 	entries (i.e., the ones added by <cf/add roa/ command) can be deleted.
 
-	<tag>flush roa [table <m/t/>]</tag>
+	<tag><label id="cli-flush-roa">flush roa [table <m/t/>]</tag>
 	Remove all dynamic ROA entries from a ROA table.
 
-	<tag>configure [soft] ["<m/config file/"] [timeout [<m/num/]]</tag>
+	<tag><label id="cli-configure">configure [soft] ["<m/config file/"] [timeout [<m/num/]]</tag>
 	Reload configuration from a given file. BIRD will smoothly switch itself
 	to the new configuration, protocols are reconfigured if possible,
 	restarted otherwise. Changes in filters usually lead to restart of
@@ -839,11 +849,11 @@ This argument can be omitted if there exists only a single instance.
 	config timeout expiration is equivalent to <cf/configure undo/
 	command. The timeout duration could be specified, default is 300 s.
 
-	<tag>configure confirm</tag>
+	<tag><label id="cli-configure-confirm">configure confirm</tag>
 	Deactivate the config undo timer and therefore confirm the current
 	configuration.
 
-	<tag>configure undo</tag>
+	<tag><label id="cli-configure-undo">configure undo</tag>
 	Undo the last configuration change and smoothly switch back to the
 	previous (stored) configuration. If the last configuration change was
 	soft, the undo change is also soft. There is only one level of undo, but
@@ -851,15 +861,15 @@ This argument can be omitted if there exists only a single instance.
 	immediately in a row and the intermediate ones are skipped then the undo
 	also skips them back.
 
-	<tag>configure check ["<m/config file/"]</tag>
+	<tag><label id="cli-configure-check">configure check ["<m/config file/"]</tag>
 	Read and parse given config file, but do not use it. useful for checking
 	syntactic and some semantic validity of an config file.
 
-	<tag>enable|disable|restart <m/name/|"<m/pattern/"|all</tag>
+	<tag><label id="cli-enable-disable-restart">enable|disable|restart <m/name/|"<m/pattern/"|all</tag>
 	Enable, disable or restart a given protocol instance, instances matching
 	the <cf><m/pattern/</cf> or <cf/all/ instances.
 
-	<tag>reload [in|out] <m/name/|"<m/pattern/"|all</tag>
+	<tag><label id="cli-reload">reload [in|out] <m/name/|"<m/pattern/"|all</tag>
 	Reload a given protocol instance, that means re-import routes from the
 	protocol instance and re-export preferred routes to the instance. If
 	<cf/in/ or <cf/out/ options are used, the command is restricted to one
@@ -876,27 +886,29 @@ This argument can be omitted if there exists only a single instance.
 	pipe protocol, both directions are always reloaded together (<cf/in/ or
 	<cf/out/ options are ignored in that case).
 
-	<tag/down/
+	<tag><label id="cli-down">down</tag>
 	Shut BIRD down.
 
-	<tag>debug <m/protocol/|<m/pattern/|all all|off|{ states | routes | filters | events | packets }</tag>
+	<tag><label id="cli-debug">debug <m/protocol/|<m/pattern/|all all|off|{ states | routes | filters | events | packets }</tag>
 	Control protocol debugging.
 
-	<tag>dump resources|sockets|interfaces|neighbors|attributes|routes|protocols</tag>
+	<tag><label id="cli-dump">dump resources|sockets|interfaces|neighbors|attributes|routes|protocols</tag>
 	Dump contents of internal data structures to the debugging output.
 
-	<tag>echo all|off|{ <m/list of log classes/ } [ <m/buffer-size/ ]</tag>
+	<tag><label id="cli-echo">echo all|off|{ <m/list of log classes/ } [ <m/buffer-size/ ]</tag>
 	Control echoing of log messages to the command-line output.
-	See <ref id="dsc-log" name="log option"> for a list of log classes.
+	See <ref id="opt-log" name="log option"> for a list of log classes.
 
-	<tag>eval <m/expr/</tag>
+	<tag><label id="cli-eval">eval <m/expr/</tag>
 	Evaluate given expression.
 </descrip>
 
 
 <chapt>Filters
+<label id="filters">
 
 <sect>Introduction
+<label id="filters-intro">
 
 <p>BIRD contains a simple programming language. (No, it can't yet read mail :-).
 There are two objects in this language: filters and functions. Filters are
@@ -984,33 +996,34 @@ bird>
 
 
 <sect>Data types
+<label id="data-types">
 
 <p>Each variable and each value has certain type. Booleans, integers and enums
 are incompatible with each other (that is to prevent you from shooting in the
 foot).
 
 <descrip>
-	<tag/bool/
+	<tag><label id="type-bool">bool</tag>
 	This is a boolean type, it can have only two values, <cf/true/ and
 	<cf/false/. Boolean is the only type you can use in <cf/if/ statements.
 
-	<tag/int/
+	<tag><label id="type-int">int</tag>
 	This is a general integer type. It is an unsigned 32bit type; i.e., you
 	can expect it to store values from 0 to 4294967295. Overflows are not
 	checked. You can use <cf/0x1234/ syntax to write hexadecimal values.
 
-	<tag/pair/
+	<tag><label id="type-pair">pair</tag>
 	This is a pair of two short integers. Each component can have values
 	from 0 to 65535. Literals of this type are written as <cf/(1234,5678)/.
 	The same syntax can also be used to construct a pair from two arbitrary
 	integer expressions (for example <cf/(1+2,a)/).
 
-	<tag/quad/
+	<tag><label id="type-quad">quad</tag>
 	This is a dotted quad of numbers used to represent router IDs (and
 	others). Each component can have a value from 0 to 255. Literals of
 	this type are written like IPv4 addresses.
 
-	<tag/string/
+	<tag><label id="type-string">string</tag>
 	This is a string of characters. There are no ways to modify strings in
 	filters. You can pass them between functions, assign them to variables
 	of type <cf/string/, print such variables, use standard string
@@ -1020,7 +1033,7 @@ foot).
 	!&tilde;/) operators could be used to match a string value against
 	a shell pattern (represented also as a string).
 
-	<tag/ip/
+	<tag><label id="type-ip">ip</tag>
 	This type can hold a single IP address. Depending on the compile-time
 	configuration of BIRD you are using, it is either an IPv4 or IPv6
 	address. IP addresses are written in the standard notation
@@ -1029,7 +1042,7 @@ foot).
 	first <cf><M>num</M></cf> bits from the IP address. So
 	<cf/1.2.3.4.mask(8) = 1.0.0.0/ is true.
 
-	<tag/prefix/
+	<tag><label id="type-prefix">prefix</tag>
 	This type can hold a network prefix consisting of IP address and prefix
 	length. Prefix literals are written as <cf><m/ipaddress//<m/pxlen/</cf>,
 	or <cf><m>ipaddress</m>/<m>netmask</m></cf>. There are two special
@@ -1037,7 +1050,7 @@ foot).
 	pair, and <cf/.len/, which separates prefix length from the pair.
 	So <cf>1.2.0.0/16.len = 16</cf> is true.
 
-	<tag/ec/
+	<tag><label id="type-ec">ec</tag>
 	This is a specialized type used to represent BGP extended community
 	values. It is essentially a 64bit value, literals of this type are
 	usually written as <cf>(<m/kind/, <m/key/, <m/value/)</cf>, where
@@ -1048,7 +1061,7 @@ foot).
 	for <cf/key/ and <cf/value/ parts, (e.g. <cf/(ro, myas, 3*10)/, where
 	<cf/myas/ is an integer variable).
 
-	<tag/lc/
+	<tag><label id="type-lc">lc</tag>
 	This is a specialized type used to represent BGP large community
 	values. It is essentially a triplet of 32bit values, where the first
 	value is reserved for the AS number of the issuer, while meaning of
@@ -1057,7 +1070,7 @@ foot).
 	pairs, LCs can be constructed using expressions for its parts, (e.g.
 	<cf/(myas, 10+20, 3*10)/, where <cf/myas/ is an integer variable).
 
-	<tag/int|pair|quad|ip|prefix|ec|lc|enum set/
+	<tag><label id="type-set">int|pair|quad|ip|prefix|ec|lc|enum set</tag>
 	Filters recognize four types of sets. Sets are similar to strings: you
 	can pass them around but you can't modify them. Literals of type <cf>int
 	set</cf> look like <cf> [ 1, 2, 5..7 ]</cf>. As you can see, both simple
@@ -1133,12 +1146,12 @@ foot).
 	<cf>192.168.0.0/16{16,24}</cf> and <cf>192.168.0.0/16 ge 24</cf> as
 	<cf>192.168.0.0/16{24,32}</cf>.
 
-	<tag/enum/
+	<tag><label id="type-enum">enum</tag>
 	Enumeration types are fixed sets of possibilities. You can't define your
 	own variables of such type, but some route attributes are of enumeration
 	type. Enumeration types are incompatible with each other.
 
-	<tag/bgppath/
+	<tag><label id="type-bgppath">bgppath</tag>
 	BGP path is a list of autonomous system numbers. You can't write
 	literals of this type. There are several special operators on bgppaths:
 
@@ -1171,7 +1184,7 @@ foot).
 	<cf><m/P/.prepend(<m/A/);</cf> if <m/P/ is appropriate route attribute
 	(for example <cf/bgp_path/). Similarly for <cf/delete/ and <cf/filter/.
 
-	<tag/bgpmask/
+	<tag><label id="type-bgpmask">bgpmask</tag>
 	BGP masks are patterns used for BGP path matching (using <cf>path
 	&tilde; [= 2 3 5 * =]</cf> syntax). The masks resemble wildcard patterns
 	as used by UNIX shells. Autonomous system numbers match themselves,
@@ -1185,7 +1198,7 @@ foot).
         There is also old (deprecated) syntax that uses / .. / instead of [= .. =]
         and ? instead of *.
 
-	<tag/clist/
+	<tag><label id="type-clist">clist</tag>
 	Clist is similar to a set, except that unlike other sets, it can be
 	modified. The type is used for community list (a set of pairs) and for
 	cluster list (a set of quads). There exist no literals of this type.
@@ -1214,7 +1227,7 @@ foot).
 	<cf><m/C/.add(<m/P/);</cf> if <m/C/ is appropriate route attribute (for
 	example <cf/bgp_community/). Similarly for <cf/delete/ and <cf/filter/.
 
-	<tag/eclist/
+	<tag><label id="type-eclist">eclist</tag>
 	Eclist is a data type used for BGP extended community lists. Eclists
 	are very similar to clists, but they are sets of ECs instead of pairs.
 	The same operations (like <cf/add/, <cf/delete/ or <cf/&tilde;/ and
@@ -1231,6 +1244,7 @@ foot).
 
 
 <sect>Operators
+<label id="operators">
 
 <p>The filter language supports common integer operators <cf>(+,-,*,/)</cf>,
 parentheses <cf/(a*(b+c))/, comparison <cf/(a=b, a!=b, a&lt;b, a&gt;=b)/.
@@ -1261,6 +1275,7 @@ prefix and an ASN as arguments.
 
 
 <sect>Control structures
+<label id="control-structures">
 
 <p>Filters support two control structures: conditions and case switches.
 
@@ -1296,6 +1311,7 @@ if 1234 = i then printn "."; else {
 
 
 <sect>Route attributes
+<label id="route-attributes">
 
 <p>A filter is implicitly passed a route, and it can access its attributes just
 like it accesses variables. Attempts to access undefined attribute result in a
@@ -1305,11 +1321,11 @@ rule are attributes of clist type, where undefined value is regarded as empty
 clist for most purposes.
 
 <descrip>
-	<tag><m/prefix/ net</tag>
+	<tag><label id="rta-net"><m/prefix/ net</tag>
 	Network the route is talking about. Read-only. (See the chapter about
 	routing tables.)
 
-	<tag><m/enum/ scope</tag>
+	<tag><label id="rta-scope"><m/enum/ scope</tag>
 	The scope of the route. Possible values: <cf/SCOPE_HOST/ for routes
 	local to this host, <cf/SCOPE_LINK/ for those specific for a physical
 	link, <cf/SCOPE_SITE/ and <cf/SCOPE_ORGANIZATION/ for private routes and
@@ -1317,33 +1333,33 @@ clist for most purposes.
 	interpreted by BIRD and can be used to mark routes in filters. The
 	default value for new routes is <cf/SCOPE_UNIVERSE/.
 
-	<tag><m/int/ preference</tag>
+	<tag><label id="rta-preference"><m/int/ preference</tag>
 	Preference of the route. Valid values are 0-65535. (See the chapter
 	about routing tables.)
 
-	<tag><m/ip/ from</tag>
+	<tag><label id="rta-from"><m/ip/ from</tag>
 	The router which the route has originated from.
 
-	<tag><m/ip/ gw</tag>
+	<tag><label id="rta-gw"><m/ip/ gw</tag>
 	Next hop packets routed using this route should be forwarded to.
 
-	<tag><m/string/ proto</tag>
+	<tag><label id="rta-proto"><m/string/ proto</tag>
 	The name of the protocol which the route has been imported from.
 	Read-only.
 
-	<tag><m/enum/ source</tag>
+	<tag><label id="rta-source"><m/enum/ source</tag>
 	what protocol has told me about this route. Possible values:
 	<cf/RTS_DUMMY/, <cf/RTS_STATIC/, <cf/RTS_INHERIT/, <cf/RTS_DEVICE/,
 	<cf/RTS_STATIC_DEVICE/, <cf/RTS_REDIRECT/, <cf/RTS_RIP/, <cf/RTS_OSPF/,
 	<cf/RTS_OSPF_IA/, <cf/RTS_OSPF_EXT1/, <cf/RTS_OSPF_EXT2/, <cf/RTS_BGP/,
 	<cf/RTS_PIPE/, <cf/RTS_BABEL/.
 
-	<tag><m/enum/ cast</tag>
+	<tag><label id="rta-cast"><m/enum/ cast</tag>
 	Route type (Currently <cf/RTC_UNICAST/ for normal routes,
 	<cf/RTC_BROADCAST/, <cf/RTC_MULTICAST/, <cf/RTC_ANYCAST/ will be used in
 	the future for broadcast, multicast and anycast routes). Read-only.
 
-	<tag><m/enum/ dest</tag>
+	<tag><label id="rta-dest"><m/enum/ dest</tag>
 	Type of destination the packets should be sent to
 	(<cf/RTD_ROUTER/ for forwarding to a neighboring router,
 	<cf/RTD_DEVICE/ for routing to a directly-connected network,
@@ -1354,18 +1370,18 @@ clist for most purposes.
 	messages). Can be changed, but only to <cf/RTD_BLACKHOLE/,
 	<cf/RTD_UNREACHABLE/ or <cf/RTD_PROHIBIT/.
 
-	<tag><m/string/ ifname</tag>
+	<tag><label id="rta-ifname"><m/string/ ifname</tag>
 	Name of the outgoing interface. Sink routes (like blackhole, unreachable
 	or prohibit) and multipath routes have no interface associated with
 	them, so <cf/ifname/ returns an empty string for such routes. Read-only.
 
-	<tag><m/int/ ifindex</tag>
+	<tag><label id="rta-ifindex"><m/int/ ifindex</tag>
 	Index of the outgoing interface. System wide index of the interface. May
 	be used for interface matching, however indexes might change on interface
 	creation/removal. Zero is returned for routes with undefined outgoing
 	interfaces. Read-only.
 
-	<tag><m/int/ igp_metric</tag>
+	<tag><label id="rta-igp-metric"><m/int/ igp_metric</tag>
 	The optional attribute that can be used to specify a distance to the
 	network for routes that do not have a native protocol metric attribute
 	(like <cf/ospf_metric1/ for OSPF routes). It is used mainly by BGP to
@@ -1379,34 +1395,38 @@ corresponding protocol sections.
 
 
 <sect>Other statements
+<label id="other-statements">
 
 <p>The following statements are available:
 
 <descrip>
-	<tag><m/variable/ = <m/expr/</tag>
+	<tag><label id="assignment"><m/variable/ = <m/expr/</tag>
 	Set variable to a given value.
 
-	<tag>accept|reject [ <m/expr/ ]</tag>
+	<tag><label id="filter-accept-reject">accept|reject [ <m/expr/ ]</tag>
 	Accept or reject the route, possibly printing <cf><m>expr</m></cf>.
 
-	<tag>return <m/expr/</tag>
+	<tag><label id="return">return <m/expr/</tag>
 	Return <cf><m>expr</m></cf> from the current function, the function ends
 	at this point.
 
-	<tag>print|printn <m/expr/ [<m/, expr.../]</tag>
+	<tag><label id="print">print|printn <m/expr/ [<m/, expr.../]</tag>
 	Prints given expressions; useful mainly while debugging filters. The
 	<cf/printn/ variant does not terminate the line.
 
-	<tag>quitbird</tag>
+	<tag><label id="quitbird">quitbird</tag>
 	Terminates BIRD. Useful when debugging the filter interpreter.
 </descrip>
 
 
 <chapt>Protocols
+<label id="protocols">
 
 <sect>Babel
+<label id="babel">
 
 <sect1>Introduction
+<label id="babel-intro">
 
 <p>The Babel protocol (RFC6126) is a loop-avoiding distance-vector routing
 protocol that is robust and efficient both in ordinary wired networks and in
@@ -1423,6 +1443,7 @@ just ignore extension messages).
 <p>The Babel protocol implementation in BIRD is currently in alpha stage.
 
 <sect1>Configuration
+<label id="babel-config">
 
 <p>Babel supports no global configuration options apart from those common to all
 other protocols, but supports the following per-interface configuration options:
@@ -1445,7 +1466,7 @@ protocol babel [<name>] {
 </code>
 
 <descrip>
-      <tag>type wired|wireless </tag>
+      <tag><label id="babel-type">type wired|wireless </tag>
       This option specifies the interface type: Wired or wireless. Wired
       interfaces are considered more reliable, and so the default hello
       interval is higher, and a neighbour is considered unreachable after only
@@ -1456,41 +1477,41 @@ protocol babel [<name>] {
       when packets are lost rather than the more binary up/down mechanism of
       wired type links. Default: <cf/wired/.
 
-      <tag>rxcost <m/num/</tag>
+      <tag><label id="babel-rxcost">rxcost <m/num/</tag>
       This specifies the RX cost of the interface. The route metrics will be
       computed from this value with a mechanism determined by the interface
       <cf/type/. Default: 96 for wired interfaces, 256 for wireless.
 
-      <tag>hello interval <m/num/</tag>
+      <tag><label id="babel-hello">hello interval <m/num/</tag>
       Interval at which periodic "hello" messages are sent on this interface,
       in seconds. Default: 4 seconds.
 
-      <tag>update interval <m/num/</tag>
+      <tag><label id="babel-update">update interval <m/num/</tag>
       Interval at which periodic (full) updates are sent. Default: 4 times the
       hello interval.
 
-      <tag>port <m/number/</tag>
+      <tag><label id="babel-port">port <m/number/</tag>
       This option selects an UDP port to operate on. The default is to operate
       on port 6696 as specified in the Babel RFC.
 
-      <tag>tx class|dscp|priority <m/number/</tag>
+      <tag><label id="babel-tx-class">tx class|dscp|priority <m/number/</tag>
       These options specify the ToS/DiffServ/Traffic class/Priority of the
-      outgoing Babel packets. See <ref id="dsc-prio" name="tx class"> common
+      outgoing Babel packets. See <ref id="proto-tx-class" name="tx class"> common
       option for detailed description.
 
-      <tag>rx buffer <m/number/</tag>
+      <tag><label id="babel-rx-buffer">rx buffer <m/number/</tag>
       This option specifies the size of buffers used for packet processing.
       The buffer size should be bigger than maximal size of received packets.
       The default value is the interface MTU, and the value will be clamped to a
       minimum of 512 bytes + IP packet overhead.
 
-      <tag>tx length <m/number/</tag>
+      <tag><label id="babel-tx-length">tx length <m/number/</tag>
       This option specifies the maximum length of generated Babel packets. To
       avoid IP fragmentation, it should not exceed the interface MTU value.
       The default value is the interface MTU value, and the value will be
       clamped to a minimum of 512 bytes + IP packet overhead.
 
-      <tag>check link <m/switch/</tag>
+      <tag><label id="babel-check-link">check link <m/switch/</tag>
       If set, the hardware link state (as reported by OS) is taken into
       consideration. When the link disappears (e.g. an ethernet cable is
       unplugged), neighbors are immediately considered unreachable and all
@@ -1500,12 +1521,14 @@ protocol babel [<name>] {
 </descrip>
 
 <sect1>Attributes
+<label id="babel-attr">
 
 <p>Babel defines just one attribute: the internal babel metric of the route. It
 is exposed as the <cf/babel_metric/ attribute and has range from 1 to infinity
 (65535).
 
 <sect1>Example
+<label id="babel-exam">
 
 <p><code>
 protocol babel {
@@ -1529,9 +1552,10 @@ protocol babel {
 
 
 <sect>BFD
-<label id="sect-bfd">
+<label id="bfd">
 
 <sect1>Introduction
+<label id="bfd-intro">
 
 <p>Bidirectional Forwarding Detection (BFD) is not a routing protocol itself, it
 is an independent tool providing liveness and failure detection. Routing
@@ -1569,6 +1593,7 @@ default a bit different dynamic port range than the IANA approved one
 <cf>/proc/sys/net/ipv4/ip_local_port_range</cf>
 
 <sect1>Configuration
+<label id="bfd-config">
 
 <p>BFD configuration consists mainly of multiple definitions of interfaces.
 Most BFD config options are session specific. When a new session is requested
@@ -1610,22 +1635,22 @@ protocol bfd [&lt;name&gt;] {
 </code>
 
 <descrip>
-	<tag>interface <m/pattern [, ...]/ { <m/options/ }</tag>
+	<tag><label id="bfd-iface">interface <m/pattern [, ...]/ { <m/options/ }</tag>
 	Interface definitions allow to specify options for sessions associated
 	with such interfaces and also may contain interface specific options.
-	See <ref id="dsc-iface" name="interface"> common option for a detailed
+	See <ref id="proto-iface" name="interface"> common option for a detailed
 	description of interface patterns. Note that contrary to the behavior of
 	<cf/interface/ definitions of other protocols, BFD protocol would accept
 	sessions (in default configuration) even on interfaces not covered by
 	such definitions.
 
-	<tag>multihop { <m/options/ }</tag>
+	<tag><label id="bfd-multihop">multihop { <m/options/ }</tag>
 	Multihop definitions allow to specify options for multihop BFD sessions,
 	in the same manner as <cf/interface/ definitions are used for directly
 	connected sessions. Currently only one such definition (for all multihop
 	sessions) could be used.
 
-	<tag>neighbor <m/ip/ [dev "<m/interface/"] [local <m/ip/] [multihop <m/switch/]</tag>
+	<tag><label id="bfd-neighbor">neighbor <m/ip/ [dev "<m/interface/"] [local <m/ip/] [multihop <m/switch/]</tag>
 	BFD sessions are usually created on demand as requested by other
 	protocols (like OSPF or BGP). This option allows to explicitly add
 	a BFD session to the specified neighbor regardless of such requests.
@@ -1640,33 +1665,33 @@ protocol bfd [&lt;name&gt;] {
 <p>Session specific options (part of <cf/interface/ and <cf/multihop/ definitions):
 
 <descrip>
-	<tag>interval <m/time/</tag>
+	<tag><label id="bfd-interval">interval <m/time/</tag>
 	BFD ensures availability of the forwarding path associated with the
 	session by periodically sending BFD control packets in both
 	directions. The rate of such packets is controlled by two options,
 	<cf/min rx interval/ and <cf/min tx interval/ (see below). This option
 	is just a shorthand to set both of these options together.
 
-	<tag>min rx interval <m/time/</tag>
+	<tag><label id="bfd-min-rx-interval">min rx interval <m/time/</tag>
 	This option specifies the minimum RX interval, which is announced to the
 	neighbor and used there to limit the neighbor's rate of generated BFD
 	control packets. Default: 10 ms.
 
-	<tag>min tx interval <m/time/</tag>
+	<tag><label id="bfd-min-tx-interval">min tx interval <m/time/</tag>
 	This option specifies the desired TX interval, which controls the rate
 	of generated BFD control packets (together with <cf/min rx interval/
 	announced by the neighbor). Note that this value is used only if the BFD
 	session is up, otherwise the value of <cf/idle tx interval/ is used
 	instead. Default: 100 ms.
 
-	<tag>idle tx interval <m/time/</tag>
+	<tag><label id="bfd-idle-tx-interval">idle tx interval <m/time/</tag>
 	In order to limit unnecessary traffic in cases where a neighbor is not
 	available or not running BFD, the rate of generated BFD control packets
 	is lower when the BFD session is not up. This option specifies the
 	desired TX interval in such cases instead of <cf/min tx interval/.
 	Default: 1 s.
 
-	<tag>multiplier <m/num/</tag>
+	<tag><label id="bfd-multiplier">multiplier <m/num/</tag>
 	Failure detection time for BFD sessions is based on established rate of
 	BFD control packets (<cf>min rx/tx interval</cf>) multiplied by this
 	multiplier, which is essentially (ignoring jitter) a number of missed
@@ -1674,7 +1699,7 @@ protocol bfd [&lt;name&gt;] {
 	multipliers could be different in each direction of a BFD session.
 	Default: 5.
 
-	<tag>passive <m/switch/</tag>
+	<tag><label id="bfd-passive">passive <m/switch/</tag>
 	Generally, both BFD session endpoints try to establish the session by
 	sending control packets to the other side. This option allows to enable
 	passive mode, which means that the router does not send BFD packets
@@ -1682,6 +1707,7 @@ protocol bfd [&lt;name&gt;] {
 </descrip>
 
 <sect1>Example
+<label id="bfd-exam">
 
 <p><code>
 protocol bfd {
@@ -1708,6 +1734,7 @@ protocol bfd {
 
 
 <sect>BGP
+<label id="bgp">
 
 <p>The Border Gateway Protocol is the routing protocol used for backbone level
 routing in the today's Internet. Contrary to other protocols, its convergence
@@ -1758,6 +1785,7 @@ and applied to IPv6 according to
 RFC 2545<htmlurl url="ftp://ftp.rfc-editor.org/in-notes/rfc2545.txt">.
 
 <sect1>Route selection rules
+<label id="bgp-route-select-rules">
 
 <p>BGP doesn't have any simple metric, so the rules for selection of an optimal
 route among multiple BGP routes with the same preference are a bit more complex
@@ -1777,6 +1805,7 @@ choose among them and so on.
 </itemize>
 
 <sect1>IGP routing table
+<label id="bgp-igp-routing-table">
 
 <p>BGP is mainly concerned with global network reachability and with routes to
 other autonomous systems. When such routes are redistributed to routers in the
@@ -1787,13 +1816,14 @@ boundary routers for the purpose of BGP route selection. In BIRD, there is
 usually one routing table used for both IGP routes and BGP routes.
 
 <sect1>Configuration
+<label id="bgp-config">
 
 <p>Each instance of the BGP corresponds to one neighboring router. This allows
 to set routing policy and all the other parameters differently for each neighbor
 using the following configuration parameters:
 
 <descrip>
-	<tag>local [<m/ip/] as <m/number/</tag>
+	<tag><label id="bgp-local">local [<m/ip/] as <m/number/</tag>
 	Define which AS we are part of. (Note that contrary to other IP routers,
 	BIRD is able to act as a router located in multiple AS'es simultaneously,
 	but in such cases you need to tweak the BGP paths manually in the filters
@@ -1801,7 +1831,7 @@ using the following configuration parameters:
 	address, equivalent to the <cf/source address/ option (see below). This
 	parameter is mandatory.
 
-	<tag>neighbor [<m/ip/] [port <m/number/] [as <m/number/]</tag>
+	<tag><label id="bgp-neighbor">neighbor [<m/ip/] [port <m/number/] [as <m/number/]</tag>
 	Define neighboring router this instance will be talking to and what AS
 	it is located in. In case the neighbor is in the same AS as we are, we
 	automatically switch to iBGP. Optionally, the remote port may also be
@@ -1810,20 +1840,20 @@ using the following configuration parameters:
 	<cf/neighbor 10.0.0.1; neighbor as 65000;/ are valid). This parameter is
 	mandatory.
 
-	<tag>interface <m/string/</tag>
+	<tag><label id="bgp-iface">interface <m/string/</tag>
 	Define interface we should use for link-local BGP IPv6 sessions.
 	Interface can also be specified as a part of <cf/neighbor address/
 	(e.g., <cf/neighbor fe80::1234%eth0 as 65000;/). It is an error to use
 	this parameter for non link-local sessions.
 
-	<tag>direct</tag>
+	<tag><label id="bgp-direct">direct</tag>
 	Specify that the neighbor is directly connected. The IP address of the
 	neighbor must be from a directly reachable IP range (i.e. associated
 	with one of your router's interfaces), otherwise the BGP session
 	wouldn't start but it would wait for such interface to appear. The
 	alternative is the <cf/multihop/ option. Default: enabled for eBGP.
 
-	<tag>multihop [<m/number/]</tag>
+	<tag><label id="bgp-multihop">multihop [<m/number/]</tag>
 	Configure multihop BGP session to a neighbor that isn't directly
 	connected. Accurately, this option should be used if the configured
 	neighbor IP address does not match with any local network subnets. Such
@@ -1835,22 +1865,22 @@ using the following configuration parameters:
 	path is counted; i.e., if two BGP speakers are separated by one router,
 	the number of hops is 2. Default: enabled for iBGP.
 
-	<tag>source address <m/ip/</tag>
+	<tag><label id="bgp-source-address">source address <m/ip/</tag>
 	Define local address we should use for next hop calculation and as a
 	source address for the BGP session. Default: the address of the local
 	end of the interface our neighbor is connected to.
 
-	<tag>next hop self</tag>
+	<tag><label id="bgp-next-hop-self">next hop self</tag>
 	Avoid calculation of the Next Hop attribute and always advertise our own
 	source address as a next hop. This needs to be used only occasionally to
 	circumvent misconfigurations of other routers. Default: disabled.
 
-	<tag>next hop keep</tag>
+	<tag><label id="bgp-next-hop-keep">next hop keep</tag>
 	Forward the received Next Hop attribute even in situations where the
 	local address should be used instead, like when the route is sent to an
 	interface with a different subnet. Default: disabled.
 
-	<tag>missing lladdr self|drop|ignore</tag>
+	<tag><label id="bgp-missing-lladdr">missing lladdr self|drop|ignore</tag>
 	Next Hop attribute in BGP-IPv6 sometimes contains just the global IPv6
 	address, but sometimes it has to contain both global and link-local IPv6
 	addresses. This option specifies what to do if BIRD have to send both
@@ -1864,7 +1894,7 @@ using the following configuration parameters:
 	route server (option <cf/rs client/), in that case default is <cf/ignore/,
 	because route servers usually do not forward packets themselves.
 
-	<tag>gateway direct|recursive</tag>
+	<tag><label id="bgp-gateway">gateway direct|recursive</tag>
 	For received routes, their <cf/gw/ (immediate next hop) attribute is
 	computed from received <cf/bgp_next_hop/ attribute. This option
 	specifies how it is computed. Direct mode means that the IP address from
@@ -1879,31 +1909,31 @@ using the following configuration parameters:
 	standard. Direct mode is simpler, does not require any routes in a
 	routing table, and was used in older versions of BIRD, but does not
 	handle well nontrivial iBGP setups and multihop. Recursive mode is
-	incompatible with <ref id="dsc-sorted" name="sorted tables">. Default:
+	incompatible with <ref id="dsc-table-sorted" name="sorted tables">. Default:
 	<cf/direct/ for direct sessions, <cf/recursive/ for multihop sessions.
 
-	<tag>igp table <m/name/</tag>
+	<tag><label id="bgp-igp-table">igp table <m/name/</tag>
 	Specifies a table that is used as an IGP routing table. Default: the
 	same as the table BGP is connected to.
 
-	<tag>check link <M>switch</M></tag>
+	<tag><label id="bgp-check-link">check link <M>switch</M></tag>
 	BGP could use hardware link state into consideration.  If enabled,
 	BIRD tracks the link state of the associated interface and when link
 	disappears (e.g. an ethernet cable is unplugged), the BGP session is
 	immediately shut down. Note that this option cannot be used with
 	multihop BGP. Default: disabled.
 
-	<tag>bfd <M>switch</M></tag>
+	<tag><label id="bgp-bfd">bfd <M>switch</M></tag>
 	BGP could use BFD protocol as an advisory mechanism for neighbor
 	liveness and failure detection. If enabled, BIRD setups a BFD session
 	for the BGP neighbor and tracks its liveness by it. This has an
 	advantage of an order of magnitude lower detection times in case of
 	failure. Note that BFD protocol also has to be configured, see
-	<ref id="sect-bfd" name="BFD"> section for details. Default: disabled.
+	<ref id="bfd" name="BFD"> section for details. Default: disabled.
 
-	<tag>ttl security <m/switch/</tag>
+	<tag><label id="bgp-ttl-security">ttl security <m/switch/</tag>
 	Use GTSM (RFC 5082 - the generalized TTL security mechanism). GTSM
-	protects against spoofed packets by ignoring received packets with a
+	protects against spoofed packets by ignoring doc/bird.sgmlreceived packets with a
 	smaller than expected TTL. To work properly, GTSM have to be enabled on
 	both sides of a BGP session. If both <cf/ttl security/ and <cf/multihop/
 	options are enabled, <cf/multihop/ option should specify proper hop
@@ -1912,12 +1942,12 @@ using the following configuration parameters:
 	(ICMP protection, for example) RFC 5082 support is provided by Linux
 	only. Default: disabled.
 
-	<tag>password <m/string/</tag>
+	<tag><label id="bgp-pass">password <m/string/</tag>
 	Use this password for MD5 authentication of BGP sessions (RFC 2385).
 	When used on BSD systems, see also <cf/setkey/ option below. Default:
 	no authentication.
 
-	<tag>setkey <m/switch/</tag>
+	<tag><label id="bgp-setkey">setkey <m/switch/</tag>
 	On BSD systems, keys for TCP MD5 authentication are stored in the global
 	SA/SP database, which can be accessed by external utilities (e.g.
 	setkey(8)). BIRD configures security associations in the SA/SP database
@@ -1928,16 +1958,16 @@ using the following configuration parameters:
 	set manually by an external utility on NetBSD and OpenBSD. Default:
 	enabled (ignored on non-FreeBSD).
 
-	<tag>passive <m/switch/</tag>
+	<tag><label id="bgp-passive">passive <m/switch/</tag>
 	Standard BGP behavior is both initiating outgoing connections and
-	accepting incoming connections. In passive mode, outgoing connections
+	accepting incoming connections. In passive modoc/bird.sgmlde, outgoing connections
 	are not initiated. Default: off.
 
-	<tag>rr client</tag>
+	<tag><label id="bgp-rr-client">rr client</tag>
 	Be a route reflector and treat the neighbor as a route reflection
 	client. Default: disabled.
 
-	<tag>rr cluster id <m/IPv4 address/</tag>
+	<tag><label id="bgp-rr-cluster-id">rr cluster id <m/IPv4 address/</tag>
 	Route reflectors use cluster id to avoid route reflection loops. When
 	there is one route reflector in a cluster it usually uses its router id
 	as a cluster id, but when there are more route reflectors in a cluster,
@@ -1945,7 +1975,7 @@ using the following configuration parameters:
 	id. Clients in a cluster need not know their cluster id and this option
 	is not allowed for them. Default: the same as router id.
 
-	<tag>rs client</tag>
+	<tag><label id="bgp-rs-client">rs client</tag>
 	Be a route server and treat the neighbor as a route server client.
 	A route server is used as a replacement for full mesh EBGP routing in
 	Internet exchange points in a similar way to route reflectors used in
@@ -1955,16 +1985,16 @@ using the following configuration parameters:
 	example does not prepend its AS number to AS PATH attribute and keeps
 	MED attribute). Default: disabled.
 
-	<tag>secondary <m/switch/</tag>
+	<tag><label id="bgp-secondary">secondary <m/switch/</tag>
 	Usually, if an export filter rejects a selected route, no other route is
 	propagated for that network. This option allows to try the next route in
 	order until one that is accepted is found or all routes for that network
 	are rejected. This can be used for route servers that need to propagate
 	different tables to each client but do not want to have these tables
 	explicitly (to conserve memory). This option requires that the connected
-	routing table is <ref id="dsc-sorted" name="sorted">. Default: off.
+	routing table is <ref id="dsc-table-sorted" name="sorted">. Default: off.
 
-	<tag>add paths <m/switch/|rx|tx</tag>
+	<tag><label id="bgp-add-paths">add paths <m/switch/|rx|tx</tag>
 	Standard BGP can propagate only one path (route) per destination network
 	(usually the selected one). This option controls the add-path protocol
 	extension, which allows to advertise any number of paths to a
@@ -1973,7 +2003,7 @@ using the following configuration parameters:
 	TX direction. When active, all available routes accepted by the export
 	filter are advertised to the neighbor. Default: off.
 
-	<tag>allow local as [<m/number/]</tag>
+	<tag><label id="bgp-allow-local-as">allow local as [<m/number/]</tag>
 	BGP prevents routing loops by rejecting received routes with the local
 	AS number in the AS path. This option allows to loose or disable the
 	check. Optional <cf/number/ argument can be used to specify the maximum
@@ -1982,7 +2012,7 @@ using the following configuration parameters:
 	completely disabled and you should ensure loop-free behavior by some
 	other means. Default: 0 (no local AS number allowed).
 
-	<tag>enable route refresh <m/switch/</tag>
+	<tag><label id="bgp-enable-route-refresh">enable route refresh <m/switch/</tag>
 	After the initial route exchange, BGP protocol uses incremental updates
 	to keep BGP speakers synchronized. Sometimes (e.g., if BGP speaker
 	changes its import filter, or if there is suspicion of inconsistency) it
@@ -1995,7 +2025,7 @@ using the following configuration parameters:
 	capabilities and supports related procedures. Note that even when
 	disabled, BIRD can send route refresh requests. Default: on.
 
-	<tag>graceful restart <m/switch/|aware</tag>
+	<tag><label id="bgp-graceful-restart">graceful restart <m/switch/|aware</tag>
 	When a BGP speaker restarts or crashes, neighbors will discard all
 	received paths from the speaker, which disrupts packet forwarding even
 	when the forwarding plane of the speaker remains intact. RFC 4724
@@ -2009,13 +2039,13 @@ using the following configuration parameters:
 	local graceful restart requires also configuration of other protocols.
 	Default: aware.
 
-	<tag>graceful restart time <m/number/</tag>
+	<tag><label id="bgp-graceful-restart-time">graceful restart time <m/number/</tag>
 	The restart time is announced in the BGP graceful restart capability
 	and specifies how long the neighbor would wait for the BGP session to
 	re-establish after a restart before deleting stale routes. Default:
 	120 seconds.
 
-	<tag>interpret communities <m/switch/</tag>
+	<tag><label id="bgp-interpret-communities">interpret communities <m/switch/</tag>
 	RFC 1997 demands that BGP speaker should process well-known communities
 	like no-export (65535, 65281) or no-advertise (65535, 65282). For
 	example, received route carrying a no-adverise community should not be
@@ -2026,7 +2056,7 @@ using the following configuration parameters:
 	disabled. In that case, similar behavior can be implemented in the
 	export filter. Default: on.
 
-	<tag>enable as4 <m/switch/</tag>
+	<tag><label id="bgp-enable-as4">enable as4 <m/switch/</tag>
 	BGP protocol was designed to use 2B AS numbers and was extended later to
 	allow 4B AS number. BIRD supports 4B AS extension, but by disabling this
 	option it can be persuaded not to advertise it and to maintain old-style
@@ -2034,12 +2064,12 @@ using the following configuration parameters:
 	in neighbor's implementation of 4B AS extension. Even when disabled
 	(off), BIRD behaves internally as AS4-aware BGP router. Default: on.
 
-	<tag>enable extended messages <m/switch/</tag>
+	<tag><label id="bgp-enable-extended-messages">enable extended messages <m/switch/</tag>
 	The BGP protocol uses maximum message length of 4096 bytes. This option
 	provides an extension to allow extended messages with length up
 	to 65535 bytes. Default: off.
 
-	<tag>capabilities <m/switch/</tag>
+	<tag><label id="bgp-capabilities">capabilities <m/switch/</tag>
 	Use capability advertisement to advertise optional capabilities. This is
 	standard behavior for newer BGP implementations, but there might be some
 	older BGP implementations that reject such connection attempts. When
@@ -2047,64 +2077,64 @@ using the following configuration parameters:
 	disabled. Default: on, with automatic fallback to off when received
 	capability-related error.
 
-	<tag>advertise ipv4 <m/switch/</tag>
+	<tag><label id="bgp-advertise-ipv4">advertise ipv4 <m/switch/</tag>
 	Advertise IPv4 multiprotocol capability. This is not a correct behavior
 	according to the strict interpretation of RFC 4760, but it is widespread
 	and required by some BGP implementations (Cisco and Quagga). This option
 	is relevant to IPv4 mode with enabled capability advertisement
 	only. Default: on.
 
-	<tag>route limit <m/number/</tag>
+	<tag><label id="bgp-route-limit">route limit <m/number/</tag>
 	The maximal number of routes that may be imported from the protocol. If
 	the route limit is exceeded, the connection is closed with an error.
 	Limit is currently implemented as <cf>import limit <m/number/ action
 	restart</cf>. This option is obsolete and it is replaced by
-	<ref id="import-limit" name="import limit option">. Default: no	limit.
+	<ref id="proto-import-limit" name="import limit option">. Default: no	limit.
 
-	<tag>disable after error <m/switch/</tag>
+	<tag><label id="bgp-disable-after-error">disable after error <m/switch/</tag>
 	When an error is encountered (either locally or by the other side),
 	disable the instance automatically and wait for an administrator to fix
 	the problem manually. Default: off.
 
-	<tag>hold time <m/number/</tag>
+	<tag><label id="bgp-hold-time">hold time <m/number/</tag>
 	Time in seconds to wait for a Keepalive message from the other side
 	before considering the connection stale. Default: depends on agreement
 	with the neighboring router, we prefer 240 seconds if the other side is
 	willing to accept it.
 
-	<tag>startup hold time <m/number/</tag>
+	<tag><label id="bgp-startup-hold-time">startup hold time <m/number/</tag>
 	Value of the hold timer used before the routers have a chance to exchange
 	open messages and agree on the real value. Default: 240	seconds.
 
-	<tag>keepalive time <m/number/</tag>
+	<tag><label id="bgp-keepalive-time">keepalive time <m/number/</tag>
 	Delay in seconds between sending of two consecutive Keepalive messages.
 	Default: One third of the hold time.
 
-	<tag>connect delay time <m/number/</tag>
+	<tag><label id="bgp-connect-delay-time">connect delay time <m/number/</tag>
 	Delay in seconds between protocol startup and the first attempt to
 	connect. Default: 5 seconds.
 
-	<tag>connect retry time <m/number/</tag>
+	<tag><label id="bgp-connect-retry-time">connect retry time <m/number/</tag>
 	Time in seconds to wait before retrying a failed attempt to connect.
 	Default: 120 seconds.
 
-	<tag>error wait time <m/number/,<m/number/</tag>
+	<tag><label id="bgp-error-wait-time">error wait time <m/number/,<m/number/</tag>
 	Minimum and maximum delay in seconds between a protocol failure (either
 	local or reported by the peer) and automatic restart. Doesn't apply
 	when <cf/disable after error/ is configured. If consecutive errors
 	happen, the delay is increased exponentially until it reaches the
 	maximum. Default: 60, 300.
 
-	<tag>error forget time <m/number/</tag>
+	<tag><label id="bgp-error-forget-time">error forget time <m/number/</tag>
 	Maximum time in seconds between two protocol failures to treat them as a
 	error sequence which makes <cf/error wait time/ increase exponentially.
 	Default: 300 seconds.
 
-	<tag>path metric <m/switch/</tag>
+	<tag><label id="bgp-path-metric">path metric <m/switch/</tag>
 	Enable comparison of path lengths when deciding which BGP route is the
 	best one. Default: on.
 
-	<tag>med metric <m/switch/</tag>
+	<tag><label id="bgp-med-metric">med metric <m/switch/</tag>
 	Enable comparison of MED attributes (during best route selection) even
 	between routes received from different ASes. This may be useful if all
 	MED attributes contain some consistent metric, perhaps enforced in
@@ -2112,7 +2142,7 @@ using the following configuration parameters:
 	attributes are compared only if routes are received from the same AS
 	(which is the standard behavior). Default: off.
 
-	<tag>deterministic med <m/switch/</tag>
+	<tag><label id="bgp-deterministic-med">deterministic med <m/switch/</tag>
 	BGP route selection algorithm is often viewed as a comparison between
 	individual routes (e.g. if a new route appears and is better than the
 	current best one, it is chosen as the new best one). But the proper
@@ -2124,23 +2154,23 @@ using the following configuration parameters:
 	option enables a different (and slower) algorithm implementing proper
 	RFC 4271 route selection, which is deterministic. Alternative way how to
 	get deterministic behavior is to use <cf/med metric/ option. This option
-	is incompatible with <ref id="dsc-sorted" name="sorted tables">.
+	is incompatible with <ref id="dsc-table-sorted" name="sorted tables">.
 	Default: off.
 
-	<tag>igp metric <m/switch/</tag>
+	<tag><label id="bgp-igp-metric">igp metric <m/switch/</tag>
 	Enable comparison of internal distances to boundary routers during best
  	route selection. Default: on.
 
-	<tag>prefer older <m/switch/</tag>
+	<tag><label id="bgp-prefer-older">prefer older <m/switch/</tag>
 	Standard route selection algorithm breaks ties by comparing router IDs.
 	This changes the behavior to prefer older routes (when both are external
 	and from different peer). For details, see RFC 5004. Default: off.
 
-	<tag>default bgp_med <m/number/</tag>
+	<tag><label id="bgp-default-med">default bgp_med <m/number/</tag>
 	Value of the Multiple Exit Discriminator to be used during route
 	selection when the MED attribute is missing. Default: 0.
 
-	<tag>default bgp_local_pref <m/number/</tag>
+	<tag><label id="bgp-default-local-pref">default bgp_local_pref <m/number/</tag>
 	A default value for the Local Preference attribute. It is used when
 	a new Local Preference attribute is attached to a route by the BGP
 	protocol itself (for example, if a route is received through eBGP and
@@ -2149,23 +2179,24 @@ using the following configuration parameters:
 </descrip>
 
 <sect1>Attributes
+<label id="bgp-attr">
 
 <p>BGP defines several route attributes. Some of them (those marked with
 `<tt/I/' in the table below) are available on internal BGP connections only,
 some of them (marked with `<tt/O/') are optional.
 
 <descrip>
-	<tag>bgppath <cf/bgp_path/</tag>
+	<tag><label id="rta-bgp-path">bgppath bgp_path/</tag>
 	Sequence of AS numbers describing the AS path the packet will travel
 	through when forwarded according to the particular route. In case of
 	internal BGP it doesn't contain the number of the local AS.
 
-	<tag>int <cf/bgp_local_pref/ [I]</tag>
+	<tag><label id="rta-bgp-local-pref">int bgp_local_pref/ [I]</tag>
 	Local preference value used for selection among multiple BGP routes (see
 	the selection rules above). It's used as an additional metric which is
 	propagated through the whole local AS.
 
-	<tag>int <cf/bgp_med/ [O]</tag>
+	<tag><label id="rta-bgp-med">int bgp_med/ [O]</tag>
 	The Multiple Exit Discriminator of the route is an optional attribute
 	which is used on external (inter-AS) links to convey to an adjacent AS
 	the optimal entry point into the local AS. The received attribute is
@@ -2176,20 +2207,20 @@ some of them (marked with `<tt/O/') are optional.
 	external BGP instance. See RFC 4451<htmlurl url="ftp://ftp.rfc-editor.org/in-notes/rfc4451.txt">
 	for further discussion of BGP MED attribute.
 
-	<tag>enum <cf/bgp_origin/</tag>
+	<tag><label id="rta-bgp-origin">enum bgp_origin/</tag>
 	Origin of the route: either <cf/ORIGIN_IGP/ if the route has originated
 	in an interior routing protocol or <cf/ORIGIN_EGP/ if it's been imported
 	from the <tt>EGP</tt> protocol (nowadays it seems to be obsolete) or
 	<cf/ORIGIN_INCOMPLETE/ if the origin is unknown.
 
-	<tag>ip <cf/bgp_next_hop/</tag>
+	<tag><label id="rta-bgp-next-hop">ip bgp_next_hop/</tag>
 	Next hop to be used for forwarding of packets to this destination. On
 	internal BGP connections, it's an address of the originating router if
 	it's inside the local AS or a boundary router the packet will leave the
 	AS through if it's an exterior route, so each BGP speaker within the AS
 	has a chance to use the shortest interior path possible to this point.
 
-	<tag>void <cf/bgp_atomic_aggr/ [O]</tag>
+	<tag><label id="rta-bgp-atomic-aggr">void bgp_atomic_aggr/ [O]</tag>
 	This is an optional attribute which carries no value, but the sole
 	presence of which indicates that the route has been aggregated from
 	multiple routes by some router on the path from the originator.
@@ -2197,7 +2228,7 @@ some of them (marked with `<tt/O/') are optional.
 <!-- we don't handle aggregators right since they are of a very obscure type
 	<tag>bgp_aggregator</tag>
 -->
-	<tag>clist <cf/bgp_community/ [O]</tag>
+	<tag><label id="rta-bgp-community">clist bgp_community/ [O]</tag>
 	List of community values associated with the route. Each such value is a
 	pair (represented as a <cf/pair/ data type inside the filters) of 16-bit
 	integers, the first of them containing the number of the AS which
@@ -2208,14 +2239,14 @@ some of them (marked with `<tt/O/') are optional.
 	freedom about which community attributes it defines and what will their
 	semantics be.
 
-	<tag>eclist <cf/bgp_ext_community/ [O]</tag>
+	<tag><label id="rta-bgp-ext-community">eclist bgp_ext_community/ [O]</tag>
 	List of extended community values associated with the route. Extended
 	communities have similar usage as plain communities, but they have an
 	extended range (to allow 4B ASNs) and a nontrivial structure with a type
 	field. Individual community values are represented using an <cf/ec/ data
 	type inside the filters.
 
-	<tag>lclist <cf/bgp_large_community/ [O]</tag>
+	<tag><label id="rta-bgp-large-community">lclist <cf/bgp_large_community/ [O]</tag>
 	List of large community values associated with the route. Large BGP
 	communities is another variant of communities, but contrary to extended
 	communities they behave very much the same way as regular communities,
@@ -2223,17 +2254,18 @@ some of them (marked with `<tt/O/') are optional.
 	Individual community values are represented using an <cf/lc/ data type
 	inside the filters.
 
-	<tag>quad <cf/bgp_originator_id/ [I, O]</tag>
+	<tag><label id="rta-bgp-originator-id">quad bgp_originator_id/ [I, O]</tag>
 	This attribute is created by the route reflector when reflecting the
 	route and contains the router ID of the originator of the route in the
 	local AS.
 
-	<tag>clist <cf/bgp_cluster_list/ [I, O]</tag>
+	<tag><label id="rta-bgp-cluster-list">clist bgp_cluster_list/ [I, O]</tag>
 	This attribute contains a list of cluster IDs of route reflectors. Each
 	route reflector prepends its cluster ID when reflecting the route.
 </descrip>
 
 <sect1>Example
+<label id="bgp-exam">
 
 <p><code>
 protocol bgp {
@@ -2259,6 +2291,7 @@ protocol bgp {
 
 
 <sect>Device
+<label id="device">
 
 <p>The Device protocol is not a real routing protocol. It doesn't generate any
 routes and it only serves as a module for getting information about network
@@ -2269,17 +2302,18 @@ protocol in the configuration since almost all other protocols require network
 interfaces to be defined for them to work with.
 
 <sect1>Configuration
+<label id="device-config">
 
 <p><descrip>
 
-	<tag>scan time <m/number/</tag>
+	<tag><label id="device-scan-time">scan time <m/number/</tag>
 	Time in seconds between two scans of the network interface list. On
 	systems where we are notified about interface status changes
 	asynchronously (such as newer versions of Linux), we need to scan the
 	list only in order to avoid confusion by lost notification messages,
 	so the default time is set to a large value.
 
-	<tag>primary [ "<m/mask/" ] <m/prefix/</tag>
+	<tag><label id="device-primary">primary [ "<m/mask/" ] <m/prefix/</tag>
 	If a network interface has more than one network address, BIRD has to
 	choose one of them as a primary one. By default, BIRD chooses the
 	lexicographically smallest address as the primary one.
@@ -2307,6 +2341,7 @@ protocol device {
 
 
 <sect>Direct
+<label id="direct">
 
 <p>The Direct protocol is a simple generator of device routes for all the
 directly connected networks according to the list of interfaces provided by the
@@ -2332,16 +2367,16 @@ on Linux systems BIRD cannot change non-BIRD route in the kernel routing table.
 <p>There are just few configuration options for the Direct protocol:
 
 <p><descrip>
-	<tag>interface <m/pattern [, ...]/</tag>
+	<tag><label id="direct-iface">interface <m/pattern [, ...]/</tag>
 	By default, the Direct protocol will generate device routes for all the
 	interfaces available. If you want to restrict it to some subset of
 	interfaces or addresses (e.g. if you're using multiple routing tables
 	for policy routing and some of the policy domains don't contain all
-	interfaces), just use this clause. See <ref id="dsc-iface" name="interface">
+	interfaces), just use this clause. See <ref id="proto-iface" name="interface">
 	common option for detailed description. The Direct protocol uses
 	extended interface clauses.
 
-	<tag>check link <m/switch/</tag>
+	<tag><label id="direct-check-link">check link <m/switch/</tag>
 	If enabled, a hardware link state (reported by OS) is taken into
 	consideration. Routes for directly connected networks are generated only
 	if link up is reported and they are withdrawn when link disappears
@@ -2360,6 +2395,7 @@ protocol direct {
 
 
 <sect>Kernel
+<label id="krt">
 
 <p>The Kernel protocol is not a real routing protocol. Instead of communicating
 with other routers in the network, it performs synchronization of BIRD's routing
@@ -2392,34 +2428,35 @@ kernel protocols to the same routing table and changing route destination
 limitations can be overcome using another routing table and the pipe protocol.
 
 <sect1>Configuration
+<label id="krt-config">
 
 <p><descrip>
-	<tag>persist <m/switch/</tag>
+	<tag><label id="krt-persist">persist <m/switch/</tag>
 	Tell BIRD to leave all its routes in the routing tables when it exits
 	(instead of cleaning them up).
 
-	<tag>scan time <m/number/</tag>
+	<tag><label id="krt-scan-time">scan time <m/number/</tag>
 	Time in seconds between two consecutive scans of the kernel routing
 	table.
 
-	<tag>learn <m/switch/</tag>
+	<tag><label id="krt-learn">learn <m/switch/</tag>
 	Enable learning of routes added to the kernel routing tables by other
 	routing daemons or by the system administrator. This is possible only on
 	systems which support identification of route authorship.
 
-	<tag>device routes <m/switch/</tag>
+	<tag><label id="krt-device-routes">device routes <m/switch/</tag>
 	Enable export of device routes to the kernel routing table. By default,
 	such routes are rejected (with the exception of explicitly configured
 	device routes from the static protocol) regardless of the export filter
 	to protect device routes in kernel routing table (managed by OS itself)
 	from accidental overwriting or erasing.
 
-	<tag>kernel table <m/number/</tag>
+	<tag><label id="krt-kernel-table">kernel table <m/number/</tag>
 	Select which kernel table should this particular instance of the Kernel
 	protocol work with. Available only on systems supporting multiple
 	routing tables.
 
-	<tag>metric <m/number/</tag> (Linux)
+	<tag><label id="krt-metric">metric <m/number/</tag> (Linux)
 	Use specified value as a kernel metric (priority) for all routes sent to
 	the kernel. When multiple routes for the same network are in the kernel
 	routing table, the Linux kernel chooses one with lower metric. Also,
@@ -2430,13 +2467,13 @@ limitations can be overcome using another routing table and the pipe protocol.
 	or per-route metric can be set using <cf/krt_metric/ attribute. Default:
 	0 (undefined).
 
-	<tag>graceful restart <m/switch/</tag>
+	<tag><label id="krt-graceful-restart">graceful restart <m/switch/</tag>
 	Participate in graceful restart recovery. If this option is enabled and
 	a graceful restart recovery is active, the Kernel protocol will defer
 	synchronization of routing tables until the end of the recovery. Note
 	that import of kernel routes to BIRD is not affected.
 
-	<tag>merge paths <M>switch</M> [limit <M>number</M>]</tag>
+	<tag><label id="krt-merge-paths">merge paths <M>switch</M> [limit <M>number</M>]</tag>
 	Usually, only best routes are exported to the kernel protocol. With path
 	merging enabled, both best routes and equivalent non-best routes are
 	merged during export to generate one ECMP (equal-cost multipath) route
@@ -2450,32 +2487,33 @@ limitations can be overcome using another routing table and the pipe protocol.
 </descrip>
 
 <sect1>Attributes
+<label id="krt-attr">
 
 <p>The Kernel protocol defines several attributes. These attributes are
 translated to appropriate system (and OS-specific) route attributes. We support
 these attributes:
 
 <descrip>
-	<tag>int <cf/krt_source/</tag>
+	<tag><label id="rta-krt-source">int krt_source/</tag>
 	The original source of the imported kernel route. The value is
 	system-dependent. On Linux, it is a value of the protocol field of the
 	route. See /etc/iproute2/rt_protos for common values. On BSD, it is
 	based on STATIC and PROTOx flags. The attribute is read-only.
 
-	<tag>int <cf/krt_metric/</tag> (Linux)
+	<tag><label id="rta-krt-metric">int krt_metric/</tag> (Linux)
 	The kernel metric of the route. When multiple same routes are in a
 	kernel routing table, the Linux kernel chooses one with lower metric.
 	Note that preferred way to set kernel metric is to use protocol option
 	<cf/metric/, unless per-route metric values are needed.
 
-	<tag>ip <cf/krt_prefsrc/</tag> (Linux)
+	<tag><label id="rta-krt-prefsrc">ip krt_prefsrc/</tag> (Linux)
 	The preferred source address. Used in source address selection for
 	outgoing packets. Has to be one of the IP addresses of the router.
 
-	<tag>int <cf/krt_realm/</tag> (Linux)
+	<tag><label id="rta-krt-realm">int krt_realm/</tag> (Linux)
 	The realm of the route. Can be used for traffic classification.
 
-	<tag>int <cf/krt_scope/</tag> (Linux IPv4)
+	<tag><label id="rta-krt-scope">int krt_scope/</tag> (Linux IPv4)
 	The scope of the route. Valid values are 0-254, although Linux kernel
 	may reject some values depending on route type and nexthop. It is
 	supposed to represent `indirectness' of the route, where nexthops of
@@ -2500,6 +2538,7 @@ Supported attributes are:
 <cf/krt_feature_ecn/, <cf/krt_feature_allfrag/
 
 <sect1>Example
+<label id="krt-exam">
 
 <p>A simple configuration can look this way:
 
@@ -2529,8 +2568,10 @@ protocol kernel {		# Secondary routing table
 
 
 <sect>OSPF
+<label id="ospf">
 
 <sect1>Introduction
+<label id="ospf-intro">
 
 <p>Open Shortest Path First (OSPF) is a quite complex interior gateway
 protocol. The current IPv4 version (OSPFv2) is defined in RFC 2328
@@ -2565,6 +2606,7 @@ identical by flooding updates. The flooding process is reliable and ensures that
 each router detects all changes.
 
 <sect1>Configuration
+<label id="ospf-config">
 
 <p>In the main part of configuration, there can be multiple definitions of OSPF
 areas, each with a different id. These definitions includes many other switches
@@ -2658,12 +2700,12 @@ protocol ospf &lt;name&gt; {
 </code>
 
 <descrip>
-	<tag>rfc1583compat <M>switch</M></tag>
+	<tag><label id="ospf-rfc1583compat">rfc1583compat <M>switch</M></tag>
 	This option controls compatibility of routing table calculation with
 	RFC 1583 <htmlurl url="ftp://ftp.rfc-editor.org/in-notes/rfc1583.txt">.
 	Default	value is no.
 
-	<tag>instance id <m/num/</tag>
+	<tag><label id="ospf-instance-id">instance id <m/num/</tag>
 	When multiple OSPF protocol instances are active on the same links, they
 	should use different instance IDs to distinguish their packets. Although
 	it could be done on per-interface basis, it is often preferred to set
@@ -2673,7 +2715,7 @@ protocol ospf &lt;name&gt; {
 	interfaces of the OSPF instance. Note that this option, if used, must
 	precede interface definitions. Default value is 0.
 
-	<tag>stub router <M>switch</M></tag>
+	<tag><label id="ospf-stub-router">stub router <M>switch</M></tag>
 	This option configures the router to be a stub router, i.e., a router
 	that participates in the OSPF topology but does not allow transit
 	traffic. In OSPFv2, this is implemented by advertising maximum metric
@@ -2682,13 +2724,13 @@ protocol ospf &lt;name&gt; {
 	<htmlurl url="ftp://ftp.rfc-editor.org/in-notes/rfc6987.txt"> for
 	details. Default value is no.
 
-	<tag>tick <M>num</M></tag>
+	<tag><label id="ospf-tick">tick <M>num</M></tag>
 	The routing table calculation and clean-up of areas' databases is not
 	performed when a single link state change arrives. To lower the CPU
 	utilization, it's processed later at periodical intervals of <m/num/
 	seconds. The default value is 1.
 
-	<tag>ecmp <M>switch</M> [limit <M>number</M>]</tag>
+	<tag><label id="ospf-ecmp">ecmp <M>switch</M> [limit <M>number</M>]</tag>
 	This option specifies whether OSPF is allowed to generate ECMP
 	(equal-cost multipath) routes. Such routes are used when there are
 	several directions to the destination, each with the same (computed)
@@ -2696,7 +2738,7 @@ protocol ospf &lt;name&gt; {
 	nexthops in one route. By default, ECMP is disabled. If enabled,
 	default	value of the limit is 16.
 
-	<tag>merge external <M>switch</M></tag>
+	<tag><label id="ospf-merge-external">merge external <M>switch</M></tag>
 	This option specifies whether OSPF should merge external routes from
 	different routers/LSAs for the same destination. When enabled together
 	with <cf/ecmp/, equal-cost external routes will be combined to multipath
@@ -2704,18 +2746,18 @@ protocol ospf &lt;name&gt; {
 	from different LSAs are treated as separate even if they represents the
 	same destination. Default value is no.
 
-	<tag>area <M>id</M></tag>
+	<tag><label id="ospf-area">area <M>id</M></tag>
 	This defines an OSPF area with given area ID (an integer or an IPv4
 	address, similarly to a router ID). The most important area is the
 	backbone (ID 0) to which every other area must be connected.
 
-	<tag>stub</tag>
+	<tag><label id="ospf-stub">stub</tag>
 	This option configures the area to be a stub area. External routes are
 	not flooded into stub areas. Also summary LSAs can be limited in stub
 	areas (see option <cf/summary/). By default, the area is not a stub
 	area.
 
-	<tag>nssa</tag>
+	<tag><label id="ospf-nssa">nssa</tag>
 	This option configures the area to be a NSSA (Not-So-Stubby Area). NSSA
 	is a variant of a stub area which allows a limited way of external route
 	propagation. Global external routes are not propagated into a NSSA, but
@@ -2723,7 +2765,7 @@ protocol ospf &lt;name&gt; {
 	(and possibly translated and/or aggregated on area boundary). By
 	default, the area is not NSSA.
 
-	<tag>summary <M>switch</M></tag>
+	<tag><label id="ospf-summary">summary <M>switch</M></tag>
 	This option controls propagation of summary LSAs into stub or NSSA
 	areas. If enabled, summary LSAs are propagated as usual, otherwise just
 	the default summary route (0.0.0.0/0) is propagated (this is sometimes
@@ -2731,43 +2773,43 @@ protocol ospf &lt;name&gt; {
 	routers, propagating summary LSAs could lead to more efficient routing
 	at the cost of larger link state database. Default value is no.
 
-	<tag>default nssa <M>switch</M></tag>
+	<tag><label id="ospf-default-nssa">default nssa <M>switch</M></tag>
 	When <cf/summary/ option is enabled, default summary route is no longer
 	propagated to the NSSA. In that case, this option allows to originate
 	default route as NSSA-LSA to the NSSA. Default value is no.
 
-	<tag>default cost <M>num</M></tag>
+	<tag><label id="ospf-default-cost">default cost <M>num</M></tag>
 	This option controls the cost of a default route propagated to stub and
 	NSSA areas. Default value is 1000.
 
-	<tag>default cost2 <M>num</M></tag>
+	<tag><label id="ospf-default-cost2">default cost2 <M>num</M></tag>
 	When a default route is originated as NSSA-LSA, its cost can use either
 	type 1 or type 2 metric. This option allows to specify the cost of a
 	default route in type 2 metric. By default, type 1 metric (option
 	<cf/default cost/) is used.
 
-	<tag>translator <M>switch</M></tag>
+	<tag><label id="ospf-translator">translator <M>switch</M></tag>
 	This option controls translation of NSSA-LSAs into external LSAs. By
 	default, one translator per NSSA is automatically elected from area
 	boundary routers. If enabled, this area boundary router would
 	unconditionally translate all NSSA-LSAs regardless of translator
 	election. Default value is no.
 
-	<tag>translator stability <M>num</M></tag>
+	<tag><label id="ospf-translator-stability">translator stability <M>num</M></tag>
 	This option controls the translator stability interval (in seconds).
 	When the new translator is elected, the old one keeps translating until
 	the interval is over. Default value is 40.
 
-	<tag>networks { <m/set/ }</tag>
+	<tag><label id="ospf-networks">networks { <m/set/ }</tag>
 	Definition of area IP ranges. This is used in summary LSA origination.
 	Hidden networks are not propagated into other areas.
 
-	<tag>external { <m/set/ }</tag>
+	<tag><label id="ospf-external">external { <m/set/ }</tag>
 	Definition of external area IP ranges for NSSAs. This is used for
 	NSSA-LSA translation. Hidden networks are not translated into external
 	LSAs. Networks can have configured route tag.
 
-	<tag>stubnet <m/prefix/ { <m/options/ }</tag>
+	<tag><label id="ospf-stubnet">stubnet <m/prefix/ { <m/options/ }</tag>
 	Stub networks are networks that are not transit networks between OSPF
 	routers. They are also propagated through an OSPF area as a part of a
 	link state database. By default, BIRD generates a stub network record
@@ -2783,9 +2825,9 @@ protocol ospf &lt;name&gt; {
 	that are subnetworks of given stub network are suppressed. This might be
 	used, for example, to aggregate generated stub networks.
 
-	<tag>interface <M>pattern</M> [instance <m/num/]</tag>
+	<tag><label id="ospf-iface">interface <M>pattern</M> [instance <m/num/]</tag>
 	Defines that the specified interfaces belong to the area being defined.
-	See <ref id="dsc-iface" name="interface"> common option for detailed
+	See <ref id="proto-iface" name="interface"> common option for detailed
 	description. In OSPFv2, extended interface clauses are used, because
 	each network prefix is handled as a separate virtual interface.
 
@@ -2796,54 +2838,54 @@ protocol ospf &lt;name&gt; {
 	<htmlurl url="ftp://ftp.rfc-editor.org/in-notes/rfc6549.txt">) and is
 	supposed to be set per-protocol. For OSPFv3, it is an integral feature.
 
-	<tag>virtual link <M>id</M> [instance <m/num/]</tag>
+	<tag><label id="ospf-virtual-link">virtual link <M>id</M> [instance <m/num/]</tag>
 	Virtual link to router with the router id. Virtual link acts as a
 	point-to-point interface belonging to backbone. The actual area is used
 	as a transport area. This item cannot be in the backbone. Like with
 	<cf/interface/ option, you could also use several virtual links to one
 	destination with different instance IDs.
 
-	<tag>cost <M>num</M></tag>
+	<tag><label id="ospf-cost">cost <M>num</M></tag>
 	Specifies output cost (metric) of an interface. Default value is 10.
 
-	<tag>stub <M>switch</M></tag>
+	<tag><label id="ospf-stub-iface">stub <M>switch</M></tag>
 	If set to interface it does not listen to any packet and does not send
 	any hello. Default value is no.
 
-	<tag>hello <M>num</M></tag>
+	<tag><label id="ospf-hello">hello <M>num</M></tag>
 	Specifies interval in seconds between sending of Hello messages. Beware,
 	all routers on the same network need to have the same hello interval.
 	Default value is 10.
 
-	<tag>poll <M>num</M></tag>
+	<tag><label id="ospf-poll">poll <M>num</M></tag>
 	Specifies interval in seconds between sending of Hello messages for some
 	neighbors on NBMA network. Default value is 20.
 
-	<tag>retransmit <M>num</M></tag>
+	<tag><label id="ospf-retransmit">retransmit <M>num</M></tag>
 	Specifies interval in seconds between retransmissions of unacknowledged
 	updates. Default value is 5.
 
-	<tag>priority <M>num</M></tag>
+	<tag><label id="ospf-priority">priority <M>num</M></tag>
 	On every multiple access network (e.g., the Ethernet) Designated Router
 	and Backup Designated router are elected. These routers have some special
 	functions in the flooding process. Higher priority increases preferences
 	in this election. Routers with priority 0 are not eligible. Default
 	value is 1.
 
-	<tag>wait <M>num</M></tag>
+	<tag><label id="ospf-wait">wait <M>num</M></tag>
 	After start, router waits for the specified number of seconds between
 	starting election and building adjacency. Default value is 4*<m/hello/.
 
-	<tag>dead count <M>num</M></tag>
+	<tag><label id="ospf-dead-count">dead count <M>num</M></tag>
 	When the router does not receive any messages from a neighbor in
 	<m/dead count/*<m/hello/ seconds, it will consider the neighbor down.
 
-	<tag>dead <M>num</M></tag>
+	<tag><label id="ospf-dead">dead <M>num</M></tag>
 	When the router does not receive any messages from a neighbor in
 	<m/dead/ seconds, it will consider the neighbor down. If both directives
 	<cf/dead count/ and <cf/dead/ are used, <cf/dead/ has precedence.
 
-	<tag>secondary <M>switch</M></tag>
+	<tag><label id="ospf-secondary">secondary <M>switch</M></tag>
 	On BSD systems, older versions of BIRD supported OSPFv2 only for the
 	primary IP address of an interface, other IP ranges on the interface
 	were handled as stub networks. Since v1.4.1, regular operation on
@@ -2853,14 +2895,14 @@ protocol ospf &lt;name&gt; {
 	behavior will be changed. On Linux systems, the option is irrelevant, as
 	operation on non-primary addresses is already the regular behavior.
 
-	<tag>rx buffer <M>num</M></tag>
+	<tag><label id="ospf-rx-buffer">rx buffer <M>num</M></tag>
 	This option allows to specify the size of buffers used for packet
 	processing. The buffer size should be bigger than maximal size of any
 	packets. By default, buffers are dynamically resized as needed, but a
 	fixed value could be specified. Value <cf/large/ means maximal allowed
 	packet size - 65535.
 
-	<tag>tx length <M>num</M></tag>
+	<tag><label id="ospf-tx-length">tx length <M>num</M></tag>
 	Transmitted OSPF messages that contain large amount of information are
 	segmented to separate OSPF packets to avoid IP fragmentation. This
 	option specifies the soft ceiling for the length of generated OSPF
@@ -2868,7 +2910,7 @@ protocol ospf &lt;name&gt; {
 	larger OSPF packets may still be generated if underlying OSPF messages
 	cannot be splitted (e.g. when one large LSA is propagated).
 
-	<tag>type broadcast|bcast</tag>
+	<tag><label id="ospf-type-bcast">type broadcast|bcast</tag>
 	BIRD detects a type of a connected network automatically, but sometimes
 	it's convenient to force use of a different type manually. On broadcast
 	networks (like ethernet), flooding and Hello messages are sent using
@@ -2878,7 +2920,7 @@ protocol ospf &lt;name&gt; {
 	on physically NBMA networks and on unnumbered networks (networks without
 	proper IP prefix).
 
-	<tag>type pointopoint|ptp</tag>
+	<tag><label id="ospf-type-ptp">type pointopoint|ptp</tag>
 	Point-to-point networks connect just 2 routers together. No election is
 	performed and no network LSA is originated, which makes it simpler and
 	faster to establish. This network type is useful not only for physically
@@ -2886,31 +2928,31 @@ protocol ospf &lt;name&gt; {
 	as PtP links. This network type cannot be used on physically NBMA
 	networks.
 
-	<tag>type nonbroadcast|nbma</tag>
+	<tag><label id="ospf-type-nbma">type nonbroadcast|nbma</tag>
 	On NBMA networks, the packets are sent to each neighbor separately
 	because of lack of multicast capabilities. Like on broadcast networks,
 	a designated router is elected, which plays a central role in propagation
 	of LSAs. This network type cannot be used on unnumbered networks.
 
-	<tag>type pointomultipoint|ptmp</tag>
+	<tag><label id="ospf-type-ptmp">type pointomultipoint|ptmp</tag>
 	This is another network type designed to handle NBMA networks. In this
 	case the NBMA network is treated as a collection of PtP links. This is
 	useful if not every pair of routers on the NBMA network has direct
 	communication, or if the NBMA network is used as an (possibly
 	unnumbered) PtP link.
 
-	<tag>link lsa suppression <m/switch/</tag>
+	<tag><label id="ospf-link-lsa-suppression">link lsa suppression <m/switch/</tag>
 	In OSPFv3, link LSAs are generated for each link, announcing link-local
 	IPv6 address of the router to its local neighbors. These are useless on
 	PtP or PtMP networks and this option allows to suppress the link LSA
 	origination for such interfaces. The option is ignored on other than PtP
 	or PtMP interfaces. Default value is no.
 
-	<tag>strict nonbroadcast <m/switch/</tag>
+	<tag><label id="ospf-strict-nonbroadcast">strict nonbroadcast <m/switch/</tag>
 	If set, don't send hello to any undefined neighbor. This switch is
 	ignored on other than NBMA or PtMP interfaces. Default value is no.
 
-	<tag>real broadcast <m/switch/</tag>
+	<tag><label id="ospf-real-broadcast">real broadcast <m/switch/</tag>
 	In <cf/type broadcast/ or <cf/type ptp/ network configuration, OSPF
 	packets are sent as IP multicast packets. This option changes the
 	behavior to using old-fashioned IP broadcast packets. This may be useful
@@ -2918,7 +2960,7 @@ protocol ospf &lt;name&gt; {
 	not work reliably. This is a non-standard option and probably is not
 	interoperable with other OSPF implementations. Default value is no.
 
-	<tag>ptp netmask <m/switch/</tag>
+	<tag><label id="ospf-ptp-netmask">ptp netmask <m/switch/</tag>
 	In <cf/type ptp/ network configurations, OSPFv2 implementations should
 	ignore received netmask field in hello packets and should send hello
 	packets with zero netmask field on unnumbered PtP links. But some OSPFv2
@@ -2928,7 +2970,7 @@ protocol ospf &lt;name&gt; {
 	compatibility problems related to this issue. Default value is no for
 	unnumbered PtP links, yes otherwise.
 
-	<tag>check link <M>switch</M></tag>
+	<tag><label id="ospf-check-link">check link <M>switch</M></tag>
 	If set, a hardware link state (reported by OS) is taken into consideration.
 	When a link disappears (e.g. an ethernet cable is unplugged), neighbors
 	are immediately considered unreachable and only the address of the iface
@@ -2936,15 +2978,15 @@ protocol ospf &lt;name&gt; {
 	some hardware drivers or platforms do not implement this feature.
 	Default value is no.
 
-	<tag>bfd <M>switch</M></tag>
+	<tag><label id="ospf-bfd">bfd <M>switch</M></tag>
 	OSPF could use BFD protocol as an advisory mechanism for neighbor
 	liveness and failure detection. If enabled, BIRD setups a BFD session
 	for each OSPF neighbor and tracks its liveness by it. This has an
 	advantage of an order of magnitude lower detection times in case of
 	failure. Note that BFD protocol also has to be configured, see
-	<ref id="sect-bfd" name="BFD"> section for details. Default value is no.
+	<ref id="bfd" name="BFD"> section for details. Default value is no.
 
-	<tag>ttl security [<m/switch/ | tx only]</tag>
+	<tag><label id="ospf-ttl-security">ttl security [<m/switch/ | tx only]</tag>
 	TTL security is a feature that protects routing protocols from remote
 	spoofed packets by using TTL 255 instead of TTL 1 for protocol packets
 	destined to neighbors. Because TTL is decremented when packets are
@@ -2957,35 +2999,35 @@ protocol ospf &lt;name&gt; {
 	set to <cf/tx only/, TTL 255 is used for sent packets, but is not
 	checked for received packets. Default value is no.
 
-	<tag>tx class|dscp|priority <m/num/</tag>
+	<tag><label id="ospf-tx-class">tx class|dscp|priority <m/num/</tag>
 	These options specify the ToS/DiffServ/Traffic class/Priority of the
-	outgoing OSPF packets. See <ref id="dsc-prio" name="tx class"> common
+	outgoing OSPF packets. See <ref id="proto-tx-class" name="tx class"> common
 	option for detailed description.
 
-	<tag>ecmp weight <M>num</M></tag>
+	<tag><label id="ospf-ecmp-weight">ecmp weight <M>num</M></tag>
 	When ECMP (multipath) routes are allowed, this value specifies a
 	relative weight used for nexthops going through the iface. Allowed
 	values are 1-256. Default value is 1.
 
-	<tag>authentication none</tag>
+	<tag><label id="ospf-auth-none">authentication none</tag>
 	No passwords are sent in OSPF packets. This is the default value.
 
-	<tag>authentication simple</tag>
+	<tag><label id="ospf-auth-simple">authentication simple</tag>
 	Every packet carries 8 bytes of password. Received packets lacking this
 	password are ignored. This authentication mechanism is very weak.
 
-	<tag>authentication cryptographic</tag>
+	<tag><label id="ospf-auth-cryptographic">authentication cryptographic</tag>
 	16-byte long MD5 digest is appended to every packet. For the digest
 	generation 16-byte long passwords are used. Those passwords are not sent
 	via network, so this mechanism is quite secure. Packets can still be
 	read by an attacker.
 
-	<tag>password "<M>text</M>"</tag>
+	<tag><label id="ospf-pass">password "<M>text</M>"</tag>
 	An 8-byte or 16-byte password used for authentication. See
-	<ref id="dsc-pass" name="password"> common option for detailed
+	<ref id="proto-pass" name="password"> common option for detailed
 	description.
 
-	<tag>neighbors { <m/set/ } </tag>
+	<tag><label id="ospf-neighbors">neighbors { <m/set/ } </tag>
 	A set of neighbors to which Hello messages on NBMA or PtMP networks are
 	to be sent. For NBMA networks, some of them could be marked as eligible.
 	In OSPFv3, link-local addresses should be used, using global ones is
@@ -2994,6 +3036,7 @@ protocol ospf &lt;name&gt; {
 </descrip>
 
 <sect1>Attributes
+<label id="ospf-attr">
 
 <p>OSPF defines four route attributes. Each internal route has a <cf/metric/.
 
@@ -3013,6 +3056,7 @@ network. This attribute is read-only. Default is <cf/ospf_metric2 = 10000/ and
 <cf/ospf_tag = 0/.
 
 <sect1>Example
+<label id="ospf-exam">
 
 <p><code>
 protocol ospf MyOSPF {
@@ -3079,8 +3123,10 @@ protocol ospf MyOSPF {
 
 
 <sect>Pipe
+<label id="pipe">
 
 <sect1>Introduction
+<label id="pipe-intro">
 
 <p>The Pipe protocol serves as a link between two routing tables, allowing
 routes to be passed from a table declared as primary (i.e., the one the pipe is
@@ -3115,21 +3161,24 @@ routes appear in which tables and also you can employ the Pipe protocol for
 exporting a selected subset of one table to another one.
 
 <sect1>Configuration
+<label id="pipe-config">
 
 <p><descrip>
-	<tag>peer table <m/table/</tag>
+	<tag><label id="pipe-peer-table">peer table <m/table/</tag>
 	Defines secondary routing table to connect to. The primary one is
 	selected by the <cf/table/ keyword.
 
-	<tag>mode opaque|transparent</tag>
+	<tag><label id="pipe-mode">mode opaque|transparent</tag>
 	Specifies the mode for the pipe to work in. Default is transparent.
 </descrip>
 
 <sect1>Attributes
+<label id="pipe-attr">
 
 <p>The Pipe protocol doesn't define any route attributes.
 
 <sect1>Example
+<label id="pipe-exam">
 
 <p>Let's consider a router which serves as a boundary router of two different
 autonomous systems, each of them connected to a subset of interfaces of the
@@ -3200,8 +3249,10 @@ protocol pipe {				# The Pipe
 
 
 <sect>RAdv
+<label id="radv">
 
 <sect1>Introduction
+<label id="radv-intro">
 
 <p>The RAdv protocol is an implementation of Router Advertisements, which are
 used in the IPv6 stateless autoconfiguration. IPv6 routers send (in irregular
@@ -3214,18 +3265,19 @@ and also the DNS extensions from
 RFC 6106<htmlurl url="ftp://ftp.rfc-editor.org/in-notes/rfc6106.txt">.
 
 <sect1>Configuration
+<label id="radv-config">
 
 <p>There are several classes of definitions in RAdv configuration -- interface
 definitions, prefix definitions and DNS definitions:
 
 <descrip>
-	<tag>interface <m/pattern [, ...]/ { <m/options/ }</tag>
+	<tag><label id="radv-iface">interface <m/pattern [, ...]/ { <m/options/ }</tag>
 	Interface definitions specify a set of interfaces on which the
 	protocol is activated and contain interface specific options.
-	See <ref id="dsc-iface" name="interface"> common options for
+	See <ref id="proto-iface" name="interface"> common options for
 	detailed description.
 
-	<tag>prefix <m/prefix/ { <m/options/ }</tag>
+	<tag><label id="radv-prefix">prefix <m/prefix/ { <m/options/ }</tag>
 	Prefix definitions allow to modify a list of advertised prefixes. By
 	default, the advertised prefixes are the same as the network prefixes
 	assigned to the interface. For each network prefix, the matching prefix
@@ -3239,7 +3291,7 @@ definitions, prefix definitions and DNS definitions:
 	prefix definition is matching if the network prefix is a subnet of the
 	prefix in prefix definition.
 
-	<tag>rdnss { <m/options/ }</tag>
+	<tag><label id="radv-rdnss">rdnss { <m/options/ }</tag>
 	RDNSS definitions allow to specify a list of advertised recursive DNS
 	servers together with their options. As options are seldom necessary,
 	there is also a short variant <cf>rdnss <m/address/</cf> that just
@@ -3247,15 +3299,15 @@ definitions, prefix definitions and DNS definitions:
 	definitions may also be interface-specific when used inside interface
 	options. By default, interface uses both global and interface-specific
 	options, but that can be changed by <cf/rdnss local/ option.
-
-	<tag>dnssl { <m/options/ }</tag>
+dsc-iface
+	<tag><label id="radv-dnssl">dnssl { <m/options/ }</tag>
 	DNSSL definitions allow to specify a list of advertised DNS search
 	domains together with their options. Like <cf/rdnss/ above, multiple
 	definitions are cumulative, they can be used also as interface-specific
 	options and there is a short variant <cf>dnssl <m/domain/</cf> that just
 	specifies one DNS search domain.
 
-	<label id="dsc-trigger"> <tag>trigger <m/prefix/</tag>
+	<tag><label id="radv-trigger">trigger <m/prefix/</tag>
 	RAdv protocol could be configured to change its behavior based on
 	availability of routes. When this option is used, the protocol waits in
 	suppressed state until a <it/trigger route/ (for the specified network)
@@ -3277,99 +3329,99 @@ definitions, prefix definitions and DNS definitions:
 <p>Interface specific options:
 
 <descrip>
-	<tag>max ra interval <m/expr/</tag>
+	<tag><label id="radv-iface-max-ra-interval">max ra interval <m/expr/</tag>
 	Unsolicited router advertisements are sent in irregular time intervals.
 	This option specifies the maximum length of these intervals, in seconds.
 	Valid values are 4-1800. Default: 600
 
-	<tag>min ra interval <m/expr/</tag>
+	<tag><label id="radv-iface-min-ra-interval">min ra interval <m/expr/</tag>
 	This option specifies the minimum length of that intervals, in seconds.
 	Must be at least 3 and at most 3/4 * <cf/max ra interval/. Default:
 	about 1/3 * <cf/max ra interval/.
 
-	<tag>min delay <m/expr/</tag>
+	<tag><label id="radv-iface-min-delay">min delay <m/expr/</tag>
 	The minimum delay between two consecutive router advertisements, in
 	seconds. Default: 3
 
-	<tag>managed <m/switch/</tag>
+	<tag><label id="radv-iface-managed">managed <m/switch/</tag>
 	This option specifies whether hosts should use DHCPv6 for IP address
 	configuration. Default: no
 
-	<tag>other config <m/switch/</tag>
+	<tag><label id="radv-iface-other-config">other config <m/switch/</tag>
 	This option specifies whether hosts should use DHCPv6 to receive other
 	configuration information. Default: no
 
-	<tag>link mtu <m/expr/</tag>
+	<tag><label id="radv-iface-link-mtu">link mtu <m/expr/</tag>
 	This option specifies which value of MTU should be used by hosts. 0
 	means unspecified. Default: 0
 
-	<tag>reachable time <m/expr/</tag>
+	<tag><label id="radv-iface-reachable-time">reachable time <m/expr/</tag>
 	This option specifies the time (in milliseconds) how long hosts should
 	assume a neighbor is reachable (from the last confirmation). Maximum is
 	3600000, 0 means unspecified. Default 0.
 
-	<tag>retrans timer <m/expr/</tag>
+	<tag><label id="radv-iface-retrans-timer">retrans timer <m/expr/</tag>
 	This option specifies the time (in milliseconds) how long hosts should
 	wait before retransmitting Neighbor Solicitation messages. 0 means
 	unspecified. Default 0.
 
-	<tag>current hop limit <m/expr/</tag>
+	<tag><label id="radv-iface-current-hop-limit">current hop limit <m/expr/</tag>
 	This option specifies which value of Hop Limit should be used by
 	hosts. Valid values are 0-255, 0 means unspecified. Default: 64
 
-	<tag>default lifetime <m/expr/ [sensitive <m/switch/]</tag>
+	<tag><label id="radv-iface-default-lifetime">default lifetime <m/expr/ [sensitive <m/switch/]</tag>
 	This option specifies the time (in seconds) how long (after the receipt
 	of RA) hosts may use the router as a default router. 0 means do not use
-	as a default router. For <cf/sensitive/ option, see <ref id="dsc-trigger" name="trigger">.
+	as a default router. For <cf/sensitive/ option, see <ref id="radv-trigger" name="trigger">.
 	Default: 3 * <cf/max ra	interval/, <cf/sensitive/ yes.
 
-	<tag>default preference low|medium|high</tag>
+	<tag><label id="radv-iface-default-preference-low">default preference low|medium|high</tag>
 	This option specifies the Default Router Preference value to advertise
 	to hosts. Default: medium.
 
-	<tag>rdnss local <m/switch/</tag>
+	<tag><label id="radv-iface-rdnss-local">rdnss local <m/switch/</tag>
 	Use only local (interface-specific) RDNSS definitions for this
 	interface. Otherwise, both global and local definitions are used. Could
 	also be used to disable RDNSS for given interface if no local definitons
 	are specified. Default: no.
 
-	<tag>dnssl local <m/switch/</tag>
+	<tag><label id="radv-iface-dnssl-local">dnssl local <m/switch/</tag>
 	Use only local DNSSL definitions for this interface. See <cf/rdnss local/
 	option above. Default: no.
 </descrip>
 
 
-<p>Prefix specific options:
+<p>Prefix specific options
 
 <descrip>
-	<tag>skip <m/switch/</tag>
+	<tag><label id="radv-prefix-skip">skip <m/switch/</tag>
 	This option allows to specify that given prefix should not be
 	advertised. This is useful for making exceptions from a default policy
 	of advertising all prefixes. Note that for withdrawing an already
 	advertised prefix it is more useful to advertise it with zero valid
 	lifetime. Default: no
 
-	<tag>onlink <m/switch/</tag>
+	<tag><label id="radv-prefix-onlink">onlink <m/switch/</tag>
 	This option specifies whether hosts may use the advertised prefix for
 	onlink determination. Default: yes
 
-	<tag>autonomous <m/switch/</tag>
+	<tag><label id="radv-prefix-autonomous">autonomous <m/switch/</tag>
 	This option specifies whether hosts may use the advertised prefix for
 	stateless autoconfiguration. Default: yes
 
-	<tag>valid lifetime <m/expr/ [sensitive <m/switch/]</tag>
+	<tag><label id="radv-prefix-valid-lifetime">valid lifetime <m/expr/ [sensitive <m/switch/]</tag>
 	This option specifies the time (in seconds) how long (after the
 	receipt of RA) the prefix information is valid, i.e., autoconfigured
 	IP addresses can be assigned and hosts with that IP addresses are
 	considered directly reachable. 0 means the prefix is no longer
-	valid. For <cf/sensitive/ option, see <ref id="dsc-trigger" name="trigger">.
+	valid. For <cf/sensitive/ option, see <ref id="radv-trigger" name="trigger">.
 	Default: 86400 (1 day), <cf/sensitive/ no.
 
-	<tag>preferred lifetime <m/expr/ [sensitive <m/switch/]</tag>
+	<tag><label id="radv-prefix-preferred-lifetime">preferred lifetime <m/expr/ [sensitive <m/switch/]</tag>
 	This option specifies the time (in seconds) how long (after the
 	receipt of RA) IP addresses generated from the prefix using stateless
 	autoconfiguration remain preferred. For <cf/sensitive/ option,
-	see <ref id="dsc-trigger" name="trigger">. Default: 14400 (4 hours),
+	see <ref id="radv-trigger" name="trigger">. Default: 14400 (4 hours),
 	<cf/sensitive/ no.
 </descrip>
 
@@ -3377,12 +3429,12 @@ definitions, prefix definitions and DNS definitions:
 <p>RDNSS specific options:
 
 <descrip>
-	<tag>ns <m/address/</tag>
+	<tag><label id="radv-rdnss-ns">ns <m/address/</tag>
 	This option specifies one recursive DNS server. Can be used multiple
 	times for multiple servers. It is mandatory to have at least one
 	<cf/ns/ option in <cf/rdnss/ definition.
 
-	<tag>lifetime [mult] <m/expr/</tag>
+	<tag><label id="radv-rdnss-lifetime">lifetime [mult] <m/expr/</tag>
 	This option specifies the time how long the RDNSS information may be
 	used by clients after the receipt of RA. It is expressed either in
 	seconds or (when <cf/mult/ is used) in multiples of <cf/max ra
@@ -3395,12 +3447,12 @@ definitions, prefix definitions and DNS definitions:
 <p>DNSSL specific options:
 
 <descrip>
-	<tag>domain <m/address/</tag>
+	<tag><label id="radv-dnssl-domain">domain <m/address/</tag>
 	This option specifies one DNS search domain. Can be used multiple times
 	for multiple domains. It is mandatory to have at least one <cf/domain/
 	option in <cf/dnssl/ definition.
 
-	<tag>lifetime [mult] <m/expr/</tag>
+	<tag><label id="radv-dnssl-lifetime">lifetime [mult] <m/expr/</tag>
 	This option specifies the time how long the DNSSL information may be
 	used by clients after the receipt of RA. Details are the same as for
 	RDNSS <cf/lifetime/ option above. Default: 3 * <cf/max ra interval/.
@@ -3408,6 +3460,7 @@ definitions, prefix definitions and DNS definitions:
 
 
 <sect1>Example
+<label id="radv-exam">
 
 <p><code>
 protocol radv {
@@ -3447,8 +3500,10 @@ protocol radv {
 
 
 <sect>RIP
+<label id="rip">
 
 <sect1>Introduction
+<label id="rip-intro">
 
 <p>The RIP protocol (also sometimes called Rest In Pieces) is a simple protocol,
 where each router broadcasts (to all its neighbors) distances to all networks it
@@ -3474,6 +3529,7 @@ convergence, big network load and inability to handle larger networks makes it
 pretty much obsolete. It is still usable on very small networks.
 
 <sect1>Configuration
+<label id="rip-config">
 
 <p>RIP configuration consists mainly of common protocol options and interface
 definitions, most RIP options are interface specific.
@@ -3516,11 +3572,11 @@ protocol rip [&lt;name&gt;] {
 </code>
 
 <descrip>
-	<tag>infinity <M>number</M></tag>
+	<tag><label id="rip-infinity">infinity <M>number</M></tag>
 	Selects the distance of infinity. Bigger values will make
 	protocol convergence even slower. The default value is 16.
 
-	<tag>ecmp <M>switch</M> [limit <M>number</M>]</tag>
+	<tag><label id="rip-ecmp">ecmp <M>switch</M> [limit <M>number</M>]</tag>
 	This option specifies whether RIP is allowed to generate ECMP
 	(equal-cost multipath) routes. Such routes are used when there are
 	several directions to the destination, each with the same (computed)
@@ -3528,42 +3584,42 @@ protocol rip [&lt;name&gt;] {
 	nexthops in one route. By default, ECMP is disabled. If enabled,
 	default	value of the limit is 16.
 
-	<tag>interface <m/pattern [, ...]/ { <m/options/ }</tag>
+	<tag><label id="rip-iface">interface <m/pattern [, ...]/ { <m/options/ }</tag>
 	Interface definitions specify a set of interfaces on which the
 	protocol is activated and contain interface specific options.
-	See <ref id="dsc-iface" name="interface"> common options for
+	See <ref id="proto-iface" name="interface"> common options for
 	detailed description.
 </descrip>
 
 <p>Interface specific options:
 
 <descrip>
-	<tag>metric <m/num/</tag>
+	<tag><label id="rip-iface-metric">metric <m/num/</tag>
 	This option specifies the metric of the interface. When a route is
 	received from the interface, its metric is increased by this value
 	before further processing. Valid values are 1-255, but values higher
 	than infinity has no further meaning. Default: 1.
 
-	<tag>mode multicast|broadcast</tag>
+	<tag><label id="rip-iface-mode">mode multicast|broadcast</tag>
 	This option selects the mode for RIP to use on the interface. The
 	default is multicast mode for RIPv2 and broadcast mode for RIPv1.
 	RIPng always uses the multicast mode.
 
-	<tag>passive <m/switch/</tag>
+	<tag><label id="rip-iface-passive">passive <m/switch/</tag>
 	Passive interfaces receive routing updates but do not transmit any
 	messages. Default: no.
 
-	<tag>address <m/ip/</tag>
+	<tag><label id="rip-iface-address">address <m/ip/</tag>
 	This option specifies a destination address used for multicast or
 	broadcast messages, the default is the official RIP (224.0.0.9) or RIPng
 	(ff02::9) multicast address, or an appropriate broadcast address in the
 	broadcast mode.
 
-	<tag>port <m/number/</tag>
+	<tag><label id="rip-iface-port">port <m/number/</tag>
 	This option selects an UDP port to operate on, the default is the
 	official RIP (520) or RIPng (521) port.
 
-	<tag>version 1|2</tag>
+	<tag><label id="rip-iface-version">version 1|2</tag>
 	This option selects the version of RIP used on the interface. For RIPv1,
 	automatic subnet aggregation is not implemented, only classful network
 	routes and host routes are propagated. Note that BIRD allows RIPv1 to be
@@ -3572,12 +3628,12 @@ protocol rip [&lt;name&gt;] {
 	RIP, the option is not supported for RIPng, as no further versions are
 	defined.
 
-	<tag>version only <m/switch/</tag>
+	<tag><label id="rip-iface-version-only">version only <m/switch/</tag>
 	Regardless of RIP version configured for the interface, BIRD accepts
 	incoming packets of any RIP version. This option restrict accepted
 	packets to the configured version. Default: no.
 
-	<tag>split horizon <m/switch/</tag>
+	<tag><label id="rip-iface-split-horizon">split horizon <m/switch/</tag>
 	Split horizon is a scheme for preventing routing loops. When split
 	horizon is active, routes are not regularly propagated back to the
 	interface from which they were received. They are either not propagated
@@ -3586,40 +3642,40 @@ protocol rip [&lt;name&gt;] {
 	on the interface will not consider the router as a part of an
 	independent path to the destination of the route. Default: yes.
 
-	<tag>poison reverse <m/switch/</tag>
+	<tag><label id="rip-iface-poison-reverse">poison reverse <m/switch/</tag>
 	When split horizon is active, this option specifies whether the poisoned
 	reverse variant (propagating routes back with an infinity metric) is
 	used. The poisoned reverse has some advantages in faster convergence,
 	but uses more network traffic. Default: yes.
 
-	<tag>check zero <m/switch/</tag>
+	<tag><label id="rip-iface-check-zero">check zero <m/switch/</tag>
 	Received RIPv1 packets with non-zero values in reserved fields should
 	be discarded. This option specifies whether the check is performed or
 	such packets are just processed as usual. Default: yes.
 
-	<tag>update time <m/number/</tag>
+	<tag><label id="rip-iface-update-time">update time <m/number/</tag>
 	Specifies the number of seconds between periodic updates. A lower number
 	will mean faster convergence but bigger network load. Default: 30.
 
-	<tag>timeout time <m/number/</tag>
+	<tag><label id="rip-iface-timeout-time">timeout time <m/number/</tag>
 	Specifies the time interval (in seconds) between the last received route
 	announcement and the route expiration. After that, the network is
 	considered unreachable, but still is propagated with infinity distance.
 	Default: 180.
 
-	<tag>garbage time <m/number/</tag>
+	<tag><label id="rip-iface-garbage-time">garbage time <m/number/</tag>
 	Specifies the time interval (in seconds) between the route expiration
 	and the removal of the unreachable network entry. The garbage interval,
 	when a route with infinity metric is propagated, is used for both
 	internal (after expiration) and external (after withdrawal) routes.
 	Default: 120.
 
-	<tag>ecmp weight <m/number/</tag>
+	<tag><label id="rip-iface-ecmp-weight">ecmp weight <m/number/</tag>
 	When ECMP (multipath) routes are allowed, this value specifies a
 	relative weight used for nexthops going through the iface. Valid
 	values are 1-256. Default value is 1.
 
-	<tag>authentication none|plaintext|cryptographic</tag>
+	<tag><label id="rip-iface-auth">authentication none|plaintext|cryptographic</tag>
 	Selects authentication method to be used. <cf/none/ means that packets
 	are not authenticated at all, <cf/plaintext/ means that a plaintext
 	password is embedded into each packet, and <cf/cryptographic/ means that
@@ -3627,11 +3683,11 @@ protocol rip [&lt;name&gt;] {
 	authentication to not-none, it is a good idea to add <cf>password</cf>
 	section. Default: none.
 
-	<tag>password "<m/text/"</tag>
-	Specifies a password used for authentication. See <ref id="dsc-pass"
+	<tag><label id="rip-iface-pass">password "<m/text/"</tag>
+	Specifies a password used for authentication. See <ref id="proto-pass"
 	name="password"> common option for detailed description.
 
-	<tag>ttl security [<m/switch/ | tx only]</tag>
+	<tag><label id="rip-iface-ttl-security">ttl security [<m/switch/ | tx only]</tag>
 	TTL security is a feature that protects routing protocols from remote
 	spoofed packets by using TTL 255 instead of TTL 1 for protocol packets
 	destined to neighbors. Because TTL is decremented when packets are
@@ -3648,22 +3704,22 @@ protocol rip [&lt;name&gt;] {
 	For RIPng, TTL security is a standard behavior (required by RFC 2080)
 	and therefore default value is yes. For IPv4 RIP, default value is no.
 
-	<tag>tx class|dscp|priority <m/number/</tag>
+	<tag><label id="rip-iface-tx-class">tx class|dscp|priority <m/number/</tag>
 	These options specify the ToS/DiffServ/Traffic class/Priority of the
-	outgoing RIP packets. See <ref id="dsc-prio" name="tx class"> common
+	outgoing RIP packets. See <ref id="proto-tx-class" name="tx class"> common
 	option for detailed description.
 
-	<tag>rx buffer <m/number/</tag>
+	<tag><label id="rip-iface-rx-buffer">rx buffer <m/number/</tag>
 	This option specifies the size of buffers used for packet processing.
 	The buffer size should be bigger than maximal size of received packets.
 	The default value is 532 for IPv4 RIP and interface MTU value for RIPng.
 
-	<tag>tx length <m/number/</tag>
+	<tag><label id="rip-iface-tx-length">tx length <m/number/</tag>
 	This option specifies the maximum length of generated RIP packets. To
 	avoid IP fragmentation, it should not exceed the interface MTU value.
 	The default value is 532 for IPv4 RIP and interface MTU value for RIPng.
 
-	<tag>check link <m/switch/</tag>
+	<tag><label id="rip-iface-check-link">check link <m/switch/</tag>
 	If set, the hardware link state (as reported by OS) is taken into
 	consideration. When the link disappears (e.g. an ethernet cable is
 	unplugged), neighbors are immediately considered unreachable and all
@@ -3673,17 +3729,18 @@ protocol rip [&lt;name&gt;] {
 </descrip>
 
 <sect1>Attributes
+<label id="rip-attr">
 
 <p>RIP defines two route attributes:
 
 <descrip>
-	<tag>int <cf/rip_metric/</tag>
+	<tag><label id="rta-rip-metric">int rip_metric/</tag>
 	RIP metric of the route (ranging from 0 to <cf/infinity/).  When routes
 	from different RIP instances are available and all of them have the same
 	preference, BIRD prefers the route with lowest <cf/rip_metric/. When a
 	non-RIP route is exported to RIP, the default metric is 1.
 
-	<tag>int <cf/rip_tag/</tag>
+	<tag><label id="rta-rip-tag">int rip_tag/</tag>
 	RIP route tag: a 16-bit number which can be used to carry additional
 	information with the route (for example, an originating AS number in
 	case of external routes). When a non-RIP route is exported to RIP, the
@@ -3691,6 +3748,7 @@ protocol rip [&lt;name&gt;] {
 </descrip>
 
 <sect1>Example
+<label id="rip-exam">
 
 <p><code>
 protocol rip {
@@ -3708,6 +3766,7 @@ protocol rip {
 
 
 <sect>Static
+<label id="static">
 
 <p>The Static protocol doesn't communicate with other routers in the network,
 but instead it allows you to define routes manually. This is often used for
@@ -3736,14 +3795,14 @@ definition of the protocol contains mainly a list of static routes.
 <p>Global options:
 
 <descrip>
-	<tag>check link <m/switch/</tag>
+	<tag><label id="static-check-link">check link <m/switch/</tag>
 	If set, hardware link states of network interfaces are taken into
 	consideration.  When link disappears (e.g. ethernet cable is unplugged),
 	static routes directing to that interface are removed. It is possible
 	that some hardware drivers or platforms do not implement this feature.
 	Default: off.
 
-	<tag>igp table <m/name/</tag>
+	<tag><label id="static-igp-table">igp table <m/name/</tag>
 	Specifies a table that is used for route table lookups of recursive
 	routes. Default: the same table as the protocol is connected to.
 </descrip>
@@ -3751,24 +3810,24 @@ definition of the protocol contains mainly a list of static routes.
 <p>Route definitions (each may also contain a block of per-route options):
 
 <descrip>
-	<tag>route <m/prefix/ via <m/ip/</tag>
+	<tag><label id="static-route-via-ip">route <m/prefix/ via <m/ip/</tag>
 	Static route through a neighboring router. For link-local next hops,
 	interface can be specified as a part of the address (e.g.,
 	<cf/via fe80::1234%eth0/).
 
-	<tag>route <m/prefix/ multipath via <m/ip/ [weight <m/num/] [bfd <m/switch/] [via ...]</tag>
+	<tag><label id="static-route-via-mpath">route <m/prefix/ multipath via <m/ip/ [weight <m/num/] [bfd <m/switch/] [via ...]</tag>
 	Static multipath route. Contains several nexthops (gateways), possibly
 	with their weights.
 
-	<tag>route <m/prefix/ via <m/"interface"/</tag>
+	<tag><label id="static-route-via-iface">route <m/prefix/ via <m/"interface"/</tag>
 	Static device route through an interface to hosts on a directly
 	connected network.
 
-	<tag>route <m/prefix/ recursive <m/ip/</tag>
+	<tag><label id="static-route-recursive">route <m/prefix/ recursive <m/ip/</tag>
 	Static recursive route, its nexthop depends on a route table lookup for
 	given IP address.
 
-	<tag>route <m/prefix/ blackhole|unreachable|prohibit</tag>
+	<tag><label id="static-route-drop">route <m/prefix/ blackhole|unreachable|prohibit</tag>
 	Special routes specifying to silently drop the packet, return it as
 	unreachable or return it as administratively prohibited. First two
 	targets are also known as <cf/drop/ and <cf/reject/.
@@ -3777,7 +3836,7 @@ definition of the protocol contains mainly a list of static routes.
 <p>Per-route options:
 
 <descrip>
-	<tag>bfd <m/switch/</tag>
+	<tag><label id="static-route-bfd">bfd <m/switch/</tag>
 	The Static protocol could use BFD protocol for next hop liveness
 	detection. If enabled, a BFD session to the route next hop is created
 	and the static route is BFD-controlled -- the static route is announced
@@ -3790,9 +3849,9 @@ definition of the protocol contains mainly a list of static routes.
 	This option can be used for static routes with a direct next hop, or
 	also for for individual next hops in a static multipath route (see
 	above). Note that BFD protocol also has to be configured, see
-	<ref id="sect-bfd" name="BFD"> section for details. Default value is no.
+	<ref id="bfd" name="BFD"> section for details. Default value is no.
 
-	<tag><m/filter expression/</tag>
+	<tag><label id="static-route-filter"><m/filter expression/</tag>
 	This is a special option that allows filter expressions to be configured
 	on per-route basis. Can be used multiple times. These expressions are
 	evaluated when the route is originated, similarly to the import filter
@@ -3829,8 +3888,10 @@ protocol static {
 
 
 <chapt>Conclusions
+<label id="conclusion">
 
 <sect>Future work
+<label id="future-work">
 
 <p>Although BIRD supports all the commonly used routing protocols, there are
 still some features which would surely deserve to be implemented in future
@@ -3846,6 +3907,7 @@ versions of BIRD:
 
 
 <sect>Getting more help
+<label id="help">
 
 <p>If you use BIRD, you're welcome to join the bird-users mailing list
 (<HTMLURL URL="mailto:bird-users@network.cz" name="bird-users@network.cz">)
diff --git a/doc/sbase/dist/birddoc/html/mapping b/doc/sbase/dist/birddoc/html/mapping
index d95b1759..d2370d29 100644
--- a/doc/sbase/dist/birddoc/html/mapping
+++ b/doc/sbase/dist/birddoc/html/mapping
@@ -56,6 +56,7 @@
 <newline>		"<BR>"
 
 <label>		+	"<@@label>[ID]"		+
+</label>
 
 <header>
 </header>
diff --git a/doc/sbase/dist/birddoc/latex2e/mapping b/doc/sbase/dist/birddoc/latex2e/mapping
index bd11b2d0..9b8962d8 100644
--- a/doc/sbase/dist/birddoc/latex2e/mapping
+++ b/doc/sbase/dist/birddoc/latex2e/mapping
@@ -56,7 +56,7 @@
 </newline>
 
 <label>			"\\label{[ID]}"
-</label>	
+</label>
 
 <header>	+	"\\markboth"
 </header>
@@ -110,7 +110,7 @@
 <heading>		"{"
 </heading>		"}\n\n"
 
-<p>
+<p>			"\\phantomsection{}"
 </p>			"\n\n"
 
 <itemize>	+	"\\begin{itemize}"	+
@@ -128,7 +128,7 @@
 <item>		+	"\\item "
 </item>
 
-<tag>		+	"\\item\[{\\ttfamily "
+<tag>		+	"\\phantomsection\\item\[{\\ttfamily "
 </tag>			"}\] \\hfil\\break\n"	+
 
 <tagp>		+	"\\item\[ "
@@ -224,17 +224,17 @@
 <cparam>		"\\cparam{"
 </cparam>		"}"
 
-<ref>			"\\ref{[ID]} {([NAME])}"
+<ref>			"\\hyperref\[[ID]\]{[NAME]} (p.\\,\\getpagerefnumber{[ID]})"
 </ref>
 
 <pageref>		"\\pageref{[ID]}"
 </pageref>
 
 %url added by HG
-<url>			"\\nameurl{[URL]}{[NAME]}"
+<url>			"\\href{[URL]}{[NAME]}"
 </url>
 
-<htmlurl>		"\\onlynameurl{[NAME]}"
+<htmlurl>		"\\href{[URL]}{[NAME]}"
 </htmlurl>
 
 <x>
diff --git a/doc/sbase/dtd/birddoc.dtd b/doc/sbase/dtd/birddoc.dtd
index 1654b0e5..6db5066a 100644
--- a/doc/sbase/dtd/birddoc.dtd
+++ b/doc/sbase/dtd/birddoc.dtd
@@ -564,9 +564,9 @@ anywhere else. <pavel@ucw.cz>
 <!element rhead - o (%inline)>
 <!entity % sect "heading, header?, p* " >
 <!element heading o o (%inline)>
-<!element chapt - o (%sect, sect*) +(footnote)> 
+<!element chapt - o (%sect, sect*) +(footnote)>
 <!element sect  - o (%sect, sect1*) +(footnote)>
-<!element sect1 - o (%sect, sect2*)>
+<!element sect1 - o (%sect, sect2*) +(footnote)>
 <!element sect2 - o (%sect, sect3*)>
 <!element sect3 - o (%sect, sect4*)>
 <!element sect4 - o (%sect)>

From 22558357d45c27583156f8c11412e37ce48a42e0 Mon Sep 17 00:00:00 2001
From: Pavel Tvrdik <pawel.tvrdik@gmail.com>
Date: Mon, 3 Oct 2016 10:22:24 +0200
Subject: [PATCH 131/165] Doc: Add command-line options --version, --help

---
 doc/bird.sgml | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/doc/bird.sgml b/doc/bird.sgml
index f2001e75..5cc12b28 100644
--- a/doc/bird.sgml
+++ b/doc/bird.sgml
@@ -181,6 +181,12 @@ BIRD executable by configuring out routing protocols you don't use, and
 
 	<tag><label id="argv-recovery">-R</tag>
 	apply graceful restart recovery after start.
+
+	<tag><label id="argv-version">--version</tag>
+	display bird version.
+
+	<tag><label id="argv-help">-h, --help</tag>
+	display command-line options to bird.
 </descrip>
 
 <p>BIRD writes messages about its work to log files or syslog (according to config).

From f5952c7343841fe4b7b63b7a56e95aba104f2e82 Mon Sep 17 00:00:00 2001
From: Pavel Tvrdik <pawel.tvrdik@gmail.com>
Date: Mon, 3 Oct 2016 10:32:28 +0200
Subject: [PATCH 132/165] Doc: Daemon command-line options alphabet order

---
 doc/bird.sgml | 36 ++++++++++++++++++------------------
 1 file changed, 18 insertions(+), 18 deletions(-)

diff --git a/doc/bird.sgml b/doc/bird.sgml
index 5cc12b28..68851e3a 100644
--- a/doc/bird.sgml
+++ b/doc/bird.sgml
@@ -154,39 +154,39 @@ BIRD executable by configuring out routing protocols you don't use, and
 	<tag><label id="argv-log-file">-D <m/filename of debug log/</tag>
 	log debugging information to given file instead of stderr.
 
-	<tag><label id="argv-parse">-p</tag>
-	just parse the config file and exit. Return value is zero if the config
-	file is valid, nonzero if there are some errors.
-
-	<tag><label id="argv-socket">-s <m/name of communication socket/</tag>
-	use given filename for a socket for communications with the client,
-	default is <it/prefix/<file>/var/run/bird.ctl</file>.
-
-	<tag><label id="argv-pid">-P <m/name of PID file/</tag>
-	create a PID file with given filename.
-
-	<tag><label id="argv-user">-u <m/user/</tag>
-	drop privileges and use that user ID, see the next section for details.
+	<tag><label id="argv-foreground">-f</tag>
+	run bird in foreground.
 
 	<tag><label id="argv-group">-g <m/group/</tag>
 	use that group ID, see the next section for details.
 
-	<tag><label id="argv-foreground">-f</tag>
-	run bird in foreground.
+	<tag><label id="argv-help">-h, --help</tag>
+	display command-line options to bird.
 
 	<tag><label id="argv-local">-l</tag>
 	look for a configuration file and a communication socket in the current
 	working directory instead of in default system locations. However, paths
 	specified by options <cf/-c/, <cf/-s/ have higher priority.
 
+	<tag><label id="argv-parse">-p</tag>
+	just parse the config file and exit. Return value is zero if the config
+	file is valid, nonzero if there are some errors.
+
+	<tag><label id="argv-pid">-P <m/name of PID file/</tag>
+	create a PID file with given filename.
+
 	<tag><label id="argv-recovery">-R</tag>
 	apply graceful restart recovery after start.
 
+	<tag><label id="argv-socket">-s <m/name of communication socket/</tag>
+	use given filename for a socket for communications with the client,
+	default is <it/prefix/<file>/var/run/bird.ctl</file>.
+
+	<tag><label id="argv-user">-u <m/user/</tag>
+	drop privileges and use that user ID, see the next section for details.
+
 	<tag><label id="argv-version">--version</tag>
 	display bird version.
-
-	<tag><label id="argv-help">-h, --help</tag>
-	display command-line options to bird.
 </descrip>
 
 <p>BIRD writes messages about its work to log files or syslog (according to config).

From f15dc6813870565d01378265ab20e017757af220 Mon Sep 17 00:00:00 2001
From: Pavel Tvrdik <pawel.tvrdik@gmail.com>
Date: Mon, 3 Oct 2016 10:59:43 +0200
Subject: [PATCH 133/165] Doc: Enable break lines in <tag></tag>

---
 doc/sbase/dist/birddoc/latex2e/mapping | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/doc/sbase/dist/birddoc/latex2e/mapping b/doc/sbase/dist/birddoc/latex2e/mapping
index 9b8962d8..161227d2 100644
--- a/doc/sbase/dist/birddoc/latex2e/mapping
+++ b/doc/sbase/dist/birddoc/latex2e/mapping
@@ -4,6 +4,7 @@
 % The \relax is there to avoid sgml2latex rewriting the class
 <book>		+ "\\relax\\documentclass\[a4paper,10pt,openany\]{book}\n"
 			"\\usepackage\[colorlinks=true,linkcolor=blue,pdftitle={BIRD User's Guide}\]{hyperref}\n"
+			"\\usepackage{enumitem}\n"
 			"\\usepackage{birddoc}\n"
 			"\\usepackage{qwertz}\n"
 			"\\usepackage{url}\n"
@@ -122,7 +123,7 @@
 <list>		+	"\\begin{list}{}{}\n"     +
 </list>		+	"\\end{list}"		+
 
-<descrip>	+	"\\begin{description}"	+
+<descrip>	+	"\\begin{description}\[style=unboxed\]"	+
 </descrip>	+	"\\end{description}"	+
 
 <item>		+	"\\item "

From 74d76f6c3877e4a745fb63b55486810322076153 Mon Sep 17 00:00:00 2001
From: Pavel Tvrdik <pawel.tvrdik@gmail.com>
Date: Mon, 3 Oct 2016 11:36:44 +0200
Subject: [PATCH 134/165] Doc: Fix unnecessary special chars

---
 doc/bird.sgml | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/doc/bird.sgml b/doc/bird.sgml
index 68851e3a..591bb87a 100644
--- a/doc/bird.sgml
+++ b/doc/bird.sgml
@@ -815,7 +815,7 @@ This argument can be omitted if there exists only a single instance.
 	number of networks, number of routes before and after filtering). If
 	you use <cf/count/ instead, only the statistics will be printed.
 
-	<tag><label id="cli-show-roa">show roa [<m/prefix/ | in <m/prefix/ | for <m/prefix/] [as <m/num/] [table <m/t/>]</tag>
+	<tag><label id="cli-show-roa">show roa [<m/prefix/ | in <m/prefix/ | for <m/prefix/] [as <m/num/] [table <m/t/]</tag>
 	Show contents of a ROA table (by default of the first one). You can
 	specify a <m/prefix/ to print ROA entries for a specific network. If you
 	use <cf>for <m/prefix/</cf>, you'll get all entries relevant for route
@@ -824,16 +824,16 @@ This argument can be omitted if there exists only a single instance.
 	entries covered by the network prefix. You could also use <cf/as/ option
 	to show just entries for given AS.
 
-	<tag><label id="cli-add-roa">add roa <m/prefix/ max <m/num/] as <m/num/ [table <m/t/>]</tag>
+	<tag><label id="cli-add-roa">add roa <m/prefix/ max <m/num/ as <m/num/ [table <m/t/]</tag>
 	Add a new ROA entry to a ROA table. Such entry is called <it/dynamic/
 	compared to <it/static/ entries specified in the config file. These
 	dynamic entries survive reconfiguration.
 
-	<tag><label id="cli-delete-roa">delete roa <m/prefix/ max <m/num/] as <m/num/ [table <m/t/>]</tag>
+	<tag><label id="cli-delete-roa">delete roa <m/prefix/ max <m/num/ as <m/num/ [table <m/t/]</tag>
 	Delete the specified ROA entry from a ROA table. Only dynamic ROA
 	entries (i.e., the ones added by <cf/add roa/ command) can be deleted.
 
-	<tag><label id="cli-flush-roa">flush roa [table <m/t/>]</tag>
+	<tag><label id="cli-flush-roa">flush roa [table <m/t/]</tag>
 	Remove all dynamic ROA entries from a ROA table.
 
 	<tag><label id="cli-configure">configure [soft] ["<m/config file/"] [timeout [<m/num/]]</tag>

From f9bd11c337afcc3e95b459e3901a4ca28cb14b85 Mon Sep 17 00:00:00 2001
From: Pavel Tvrdik <pawel.tvrdik@gmail.com>
Date: Mon, 3 Oct 2016 11:39:56 +0200
Subject: [PATCH 135/165] Doc: Use [table t] or [table name]

---
 doc/bird.sgml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/bird.sgml b/doc/bird.sgml
index 591bb87a..159cac46 100644
--- a/doc/bird.sgml
+++ b/doc/bird.sgml
@@ -780,7 +780,7 @@ This argument can be omitted if there exists only a single instance.
 	Show the list of symbols defined in the configuration (names of
 	protocols, routing tables etc.).
 
-	<tag><label id="cli-show-route">show route [[for] <m/prefix/|<m/IP/] [table <m/sym/] [filter <m/f/|where <m/c/] [(export|preexport|noexport) <m/p/] [protocol <m/p/] [<m/options/]</tag>
+	<tag><label id="cli-show-route">show route [[for] <m/prefix/|<m/IP/] [table <m/t/] [filter <m/f/|where <m/c/] [(export|preexport|noexport) <m/p/] [protocol <m/p/] [<m/options/]</tag>
 	Show contents of a routing table (by default of the main one or the
 	table attached to a respective protocol), that is routes, their metrics
 	and (in case the <cf/all/ switch is given) all their attributes.

From 70104ef4fb5f8105422d6eb811a93b68aeae709d Mon Sep 17 00:00:00 2001
From: Pavel Tvrdik <pawel.tvrdik@gmail.com>
Date: Mon, 3 Oct 2016 11:46:40 +0200
Subject: [PATCH 136/165] Doc: Generate one-sided version

This removes jumping offset for odd and even pages for binding book.
---
 doc/sbase/dist/birddoc/latex2e/mapping | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/sbase/dist/birddoc/latex2e/mapping b/doc/sbase/dist/birddoc/latex2e/mapping
index 161227d2..7653cb78 100644
--- a/doc/sbase/dist/birddoc/latex2e/mapping
+++ b/doc/sbase/dist/birddoc/latex2e/mapping
@@ -2,7 +2,7 @@
 % birddoc to LaTeX replacement file
 
 % The \relax is there to avoid sgml2latex rewriting the class
-<book>		+ "\\relax\\documentclass\[a4paper,10pt,openany\]{book}\n"
+<book>		+ "\\relax\\documentclass\[a4paper,10pt,openany,oneside\]{book}\n"
 			"\\usepackage\[colorlinks=true,linkcolor=blue,pdftitle={BIRD User's Guide}\]{hyperref}\n"
 			"\\usepackage{enumitem}\n"
 			"\\usepackage{birddoc}\n"

From 963929df021ae54d8ff4cd18ca228932fc89dc13 Mon Sep 17 00:00:00 2001
From: Pavel Tvrdik <pawel.tvrdik@gmail.com>
Date: Mon, 3 Oct 2016 12:04:44 +0200
Subject: [PATCH 137/165] Doc: Do not use symlinks for files

---
 doc/sbase/dist/birddoc/html/mapping    | 3 +++
 doc/sbase/dist/birddoc/latex2e/mapping | 2 +-
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/doc/sbase/dist/birddoc/html/mapping b/doc/sbase/dist/birddoc/html/mapping
index d2370d29..6d080738 100644
--- a/doc/sbase/dist/birddoc/html/mapping
+++ b/doc/sbase/dist/birddoc/html/mapping
@@ -135,6 +135,9 @@
 <ncite>			"[<I>[NOTE] ([ID])</I>]"
 </ncite>
 
+<file>			"<CODE>"
+</file>			"</CODE>"
+
 <footnote>	+	"<BLOCKQUOTE>"
 </footnote>		"</BLOCKQUOTE>"		+
 
diff --git a/doc/sbase/dist/birddoc/latex2e/mapping b/doc/sbase/dist/birddoc/latex2e/mapping
index 7653cb78..e7c62e0a 100644
--- a/doc/sbase/dist/birddoc/latex2e/mapping
+++ b/doc/sbase/dist/birddoc/latex2e/mapping
@@ -156,7 +156,7 @@
 % The idea here is to automatically insert soft hyphens after every slash in
 % the filename, so long filenames will break naturally.  The url{} macro is
 % a kluge but it works,
-<file>			"\\url{"
+<file>			"{\\tt "
 </file>			"}"
 
 <footnote>		"\\footnote{"

From 9c20a8b7ae69487397392c720a5e75087c343df1 Mon Sep 17 00:00:00 2001
From: Pavel Tvrdik <pawel.tvrdik@gmail.com>
Date: Mon, 3 Oct 2016 12:35:36 +0200
Subject: [PATCH 138/165] Doc: Fix inline <htmlurl></htmlurl>

Don't make space before or after link name.
---
 doc/sbase/dist/birddoc/html/mapping | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/doc/sbase/dist/birddoc/html/mapping b/doc/sbase/dist/birddoc/html/mapping
index 6d080738..5ce36066 100644
--- a/doc/sbase/dist/birddoc/html/mapping
+++ b/doc/sbase/dist/birddoc/html/mapping
@@ -202,9 +202,7 @@
 			"<@@endurl>"		+
 </url>
 
-<htmlurl>	+	"<@@url>[URL]\n"
-			"[NAME]</A>\n"
-			"<@@endurl>"		+
+<htmlurl>		"<A HREF=\"[URL]\">[NAME]</A>"
 </htmlurl>
 
 % ref modified to have an optional name field

From 7935b9d21228dcd1eb95ebcb056b2a815e3e854b Mon Sep 17 00:00:00 2001
From: Pavel Tvrdik <pawel.tvrdik@gmail.com>
Date: Thu, 29 Sep 2016 18:08:40 +0200
Subject: [PATCH 139/165] Doc: Add tag for links to RFCs

---
 doc/bird.sgml                          | 238 +++++++++++--------------
 doc/sbase/dist/birddoc/html/mapping    |   4 +
 doc/sbase/dist/birddoc/latex2e/mapping |   3 +
 doc/sbase/dtd/birddoc.dtd              |   6 +-
 4 files changed, 118 insertions(+), 133 deletions(-)

diff --git a/doc/bird.sgml b/doc/bird.sgml
index 159cac46..24be3de0 100644
--- a/doc/bird.sgml
+++ b/doc/bird.sgml
@@ -73,8 +73,8 @@ running on background which does the dynamic part of Internet routing, that is
 it communicates with the other routers, calculates routing tables and sends them
 to the OS kernel which does the actual packet forwarding. There already exist
 other such routing daemons: routed (RIP only), GateD (non-free),
-Zebra <HTMLURL URL="http://www.zebra.org"> and
-MRTD <HTMLURL URL="http://sourceforge.net/projects/mrt">,
+<HTMLURL URL="http://www.zebra.org" name="Zebra"> and
+<HTMLURL URL="http://sourceforge.net/projects/mrt" name="MRTD">,
 but their capabilities are limited and they are relatively hard to configure
 and maintain.
 
@@ -485,9 +485,9 @@ protocol rip {
 	used to validate route origination of BGP routes. A ROA table contains
 	ROA entries, each consist of a network prefix, a max prefix length and
 	an AS number. A ROA entry specifies prefixes which could be originated
-	by that AS number. ROA tables could be filled with data from RPKI (RFC
-	6480) or from public databases like Whois. ROA tables are examined by
-	<cf/roa_check()/ operator in filters.
+	by that AS number. ROA tables could be filled with data from RPKI (<rfc
+	id="6480">) or from public databases like Whois. ROA tables are
+	examined by <cf/roa_check()/ operator in filters.
 
 	Currently, there is just one option, <cf>roa <m/prefix/ max <m/num/ as
 	<m/num/</cf>, which can be used to populate the ROA table with static
@@ -1270,9 +1270,9 @@ clist) or on clist and pair/quad set (returning true if there is an element of
 the clist that is also a member of the pair/quad set).
 
 <p>There is one operator related to ROA infrastructure - <cf/roa_check()/. It
-examines a ROA table and does RFC 6483 route origin validation for a given
-network prefix. The basic usage is <cf>roa_check(<m/table/)</cf>, which checks
-current route (which should be from BGP to have AS_PATH argument) in the
+examines a ROA table and does <rfc id="6483"> route origin validation for a
+given network prefix. The basic usage is <cf>roa_check(<m/table/)</cf>, which
+checks current route (which should be from BGP to have AS_PATH argument) in the
 specified ROA table and returns ROA_UNKNOWN if there is no relevant ROA,
 ROA_VALID if there is a matching ROA, or ROA_INVALID if there are some relevant
 ROAs but none of them match. There is also an extended variant
@@ -1434,11 +1434,12 @@ corresponding protocol sections.
 <sect1>Introduction
 <label id="babel-intro">
 
-<p>The Babel protocol (RFC6126) is a loop-avoiding distance-vector routing
-protocol that is robust and efficient both in ordinary wired networks and in
-wireless mesh networks. Babel is conceptually very simple in its operation and
-"just works" in its default configuration, though some configuration is possible
-and in some cases desirable.
+<p>The Babel protocol
+(<rfc id="6126">) is a loop-avoiding distance-vector routing protocol that is
+robust and efficient both in ordinary wired networks and in wireless mesh
+networks. Babel is conceptually very simple in its operation and "just works"
+in its default configuration, though some configuration is possible and in some
+cases desirable.
 
 <p>While the Babel protocol is dual stack (i.e., can carry both IPv4 and IPv6
 routes over the same IPv6 transport), BIRD presently implements only the IPv6
@@ -1580,14 +1581,10 @@ addresses and associated interfaces. When a session changes its state, these
 protocols are notified and act accordingly (e.g. break an OSPF adjacency when
 the BFD session went down).
 
-<p>BIRD implements basic BFD behavior as defined in
-RFC 5880<htmlurl url="ftp://ftp.rfc-editor.org/in-notes/rfc5880.txt">
-(some advanced features like the echo mode or authentication are not implemented),
-IP transport for BFD as defined in
-RFC 5881<htmlurl url="ftp://ftp.rfc-editor.org/in-notes/rfc5881.txt"> and
-RFC 5883<htmlurl url="ftp://ftp.rfc-editor.org/in-notes/rfc5883.txt">
-and interaction with client protocols as defined in
-RFC 5882<htmlurl url="ftp://ftp.rfc-editor.org/in-notes/rfc5882.txt">.
+<p>BIRD implements basic BFD behavior as defined in <rfc id="5880"> (some
+advanced features like the echo mode or authentication are not implemented), IP
+transport for BFD as defined in <rfc id="5881"> and <rfc id="5883"> and
+interaction with client protocols as defined in <rfc id="5882">.
 
 <p>Note that BFD implementation in BIRD is currently a new feature in
 development, expect some rough edges and possible UI and configuration changes
@@ -1764,31 +1761,16 @@ the packet will travel through if it uses the particular route) in order to
 avoid routing loops.
 
 <p>BIRD supports all requirements of the BGP4 standard as defined in
-RFC 4271<htmlurl url="ftp://ftp.rfc-editor.org/in-notes/rfc4271.txt">
-It also supports the community attributes
-(RFC 1997<htmlurl url="ftp://ftp.rfc-editor.org/in-notes/rfc1997.txt">),
-capability negotiation
-(RFC 5492<htmlurl url="ftp://ftp.rfc-editor.org/in-notes/rfc5492.txt">),
-MD5 password authentication
-(RFC 2385<htmlurl url="ftp://ftp.rfc-editor.org/in-notes/rfc2385.txt">),
-extended communities
-(RFC 4360<htmlurl url="ftp://ftp.rfc-editor.org/in-notes/rfc4360.txt">),
-route reflectors
-(RFC 4456<htmlurl url="ftp://ftp.rfc-editor.org/in-notes/rfc4456.txt">),
-graceful restart
-(RFC 4724<htmlurl url="ftp://ftp.rfc-editor.org/in-notes/rfc4724.txt">),
-multiprotocol extensions
-(RFC 4760<htmlurl url="ftp://ftp.rfc-editor.org/in-notes/rfc4760.txt">),
-4B AS numbers
-(RFC 4893<htmlurl url="ftp://ftp.rfc-editor.org/in-notes/rfc4893.txt">),
-and 4B AS numbers in extended communities
-(RFC 5668<htmlurl url="ftp://ftp.rfc-editor.org/in-notes/rfc5668.txt">).
+<rfc id="4271"> It also supports the community attributes (<rfc id="1997">),
+capability negotiation (<rfc id="5492">), MD5 password authentication (<rfc
+id="2385">), extended communities (<rfc id="4360">), route reflectors (<rfc
+id="4456">), graceful restart (<rfc id="4724">), multiprotocol extensions
+(<rfc id="4760">), 4B AS numbers (<rfc id="4893">), and 4B AS numbers in
+extended communities (<rfc id="5668">).
 
 
 For IPv6, it uses the standard multiprotocol extensions defined in
-RFC 4760<htmlurl url="ftp://ftp.rfc-editor.org/in-notes/rfc4760.txt">
-and applied to IPv6 according to
-RFC 2545<htmlurl url="ftp://ftp.rfc-editor.org/in-notes/rfc2545.txt">.
+<rfc id="4760"> and applied to IPv6 according to <rfc id="2545">.
 
 <sect1>Route selection rules
 <label id="bgp-route-select-rules">
@@ -1938,20 +1920,20 @@ using the following configuration parameters:
 	<ref id="bfd" name="BFD"> section for details. Default: disabled.
 
 	<tag><label id="bgp-ttl-security">ttl security <m/switch/</tag>
-	Use GTSM (RFC 5082 - the generalized TTL security mechanism). GTSM
-	protects against spoofed packets by ignoring doc/bird.sgmlreceived packets with a
+	Use GTSM (<rfc id="5082"> - the generalized TTL security mechanism). GTSM
+	protects against spoofed packets by ignoring received packets with a
 	smaller than expected TTL. To work properly, GTSM have to be enabled on
-	both sides of a BGP session. If both <cf/ttl security/ and <cf/multihop/
-	options are enabled, <cf/multihop/ option should specify proper hop
-	value to compute expected TTL. Kernel support required: Linux: 2.6.34+
-	(IPv4), 2.6.35+ (IPv6), BSD: since long ago, IPv4 only. Note that full
-	(ICMP protection, for example) RFC 5082 support is provided by Linux
-	only. Default: disabled.
+	both sides of a BGP session. If both <cf/ttl security/ and
+	<cf/multihop/ options are enabled, <cf/multihop/ option should specify
+	proper hop value to compute expected TTL. Kernel support required:
+	Linux: 2.6.34+ (IPv4), 2.6.35+ (IPv6), BSD: since long ago, IPv4 only.
+	Note that full (ICMP protection, for example) <rfc id="5082"> support is
+	provided by Linux only. Default: disabled.
 
 	<tag><label id="bgp-pass">password <m/string/</tag>
-	Use this password for MD5 authentication of BGP sessions (RFC 2385).
-	When used on BSD systems, see also <cf/setkey/ option below. Default:
-	no authentication.
+	Use this password for MD5 authentication of BGP sessions (<rfc id="2385">). When
+	used on BSD systems, see also <cf/setkey/ option below. Default: no
+	authentication.
 
 	<tag><label id="bgp-setkey">setkey <m/switch/</tag>
 	On BSD systems, keys for TCP MD5 authentication are stored in the global
@@ -1966,7 +1948,7 @@ using the following configuration parameters:
 
 	<tag><label id="bgp-passive">passive <m/switch/</tag>
 	Standard BGP behavior is both initiating outgoing connections and
-	accepting incoming connections. In passive modoc/bird.sgmlde, outgoing connections
+	accepting incoming connections. In passive mode, outgoing connections
 	are not initiated. Default: off.
 
 	<tag><label id="bgp-rr-client">rr client</tag>
@@ -1985,11 +1967,11 @@ using the following configuration parameters:
 	Be a route server and treat the neighbor as a route server client.
 	A route server is used as a replacement for full mesh EBGP routing in
 	Internet exchange points in a similar way to route reflectors used in
-	IBGP routing. BIRD does not implement obsoleted RFC 1863, but uses
-	ad-hoc implementation, which behaves like plain EBGP but reduces
+	IBGP routing. BIRD does not implement obsoleted <rfc id="1863">, but
+	uses ad-hoc implementation, which behaves like plain EBGP but reduces
 	modifications to advertised route attributes to be transparent (for
-	example does not prepend its AS number to AS PATH attribute and keeps
-	MED attribute). Default: disabled.
+	example does not prepend its AS number to AS PATH attribute and
+	keeps MED attribute). Default: disabled.
 
 	<tag><label id="bgp-secondary">secondary <m/switch/</tag>
 	Usually, if an export filter rejects a selected route, no other route is
@@ -2023,27 +2005,28 @@ using the following configuration parameters:
 	to keep BGP speakers synchronized. Sometimes (e.g., if BGP speaker
 	changes its import filter, or if there is suspicion of inconsistency) it
 	is necessary to do a new complete route exchange. BGP protocol extension
-	Route Refresh (RFC 2918) allows BGP speaker to request re-advertisement
-	of all routes from its neighbor. BGP protocol extension Enhanced Route
-	Refresh (RFC 7313) specifies explicit begin and end for such exchanges,
-	therefore the receiver can remove stale routes that were not advertised
-	during the exchange. This option specifies whether BIRD advertises these
-	capabilities and supports related procedures. Note that even when
-	disabled, BIRD can send route refresh requests. Default: on.
+	Route Refresh (<rfc id="2918">) allows BGP speaker to request
+	re-advertisement of all routes from its neighbor. BGP protocol
+	extension Enhanced Route Refresh (<rfc id="7313">) specifies explicit
+	begin and end for such exchanges, therefore the receiver can remove
+	stale routes that were not advertised during the exchange. This option
+	specifies whether BIRD advertises these capabilities and supports
+	related procedures. Note that even when disabled, BIRD can send route
+	refresh requests.  Default: on.
 
 	<tag><label id="bgp-graceful-restart">graceful restart <m/switch/|aware</tag>
 	When a BGP speaker restarts or crashes, neighbors will discard all
 	received paths from the speaker, which disrupts packet forwarding even
-	when the forwarding plane of the speaker remains intact. RFC 4724
-	specifies an optional graceful restart mechanism to alleviate this
-	issue. This option controls the mechanism. It has three states:
-	Disabled, when no support is provided. Aware, when the graceful restart
-	support is announced and the support for restarting neighbors is
-	provided, but no local graceful restart is allowed (i.e. receiving-only
-	role). Enabled, when the full graceful restart support is provided
-	(i.e. both restarting and receiving role). Note that proper support for
-	local graceful restart requires also configuration of other protocols.
-	Default: aware.
+	when the forwarding plane of the speaker remains intact. <rfc
+	id="4724"> specifies an optional graceful restart mechanism to
+	alleviate this issue. This option controls the mechanism. It has three
+	states: Disabled, when no support is provided. Aware, when the graceful
+	restart support is announced and the support for restarting neighbors
+	is provided, but no local graceful restart is allowed (i.e.
+	receiving-only role). Enabled, when the full graceful restart
+	support is provided (i.e. both restarting and receiving role). Note
+	that proper support for local graceful restart requires also
+	configuration of other protocols.  Default: aware.
 
 	<tag><label id="bgp-graceful-restart-time">graceful restart time <m/number/</tag>
 	The restart time is announced in the BGP graceful restart capability
@@ -2052,15 +2035,15 @@ using the following configuration parameters:
 	120 seconds.
 
 	<tag><label id="bgp-interpret-communities">interpret communities <m/switch/</tag>
-	RFC 1997 demands that BGP speaker should process well-known communities
-	like no-export (65535, 65281) or no-advertise (65535, 65282). For
-	example, received route carrying a no-adverise community should not be
-	advertised to any of its neighbors. If this option is enabled (which is
-	by default), BIRD has such behavior automatically (it is evaluated when
-	a route is exported to the BGP protocol just before the export filter).
-	Otherwise, this integrated processing of well-known communities is
-	disabled. In that case, similar behavior can be implemented in the
-	export filter. Default: on.
+	<rfc id="1997"> demands that BGP speaker should process well-known
+	communities like no-export (65535, 65281) or no-advertise (65535,
+	65282). For example, received route carrying a no-adverise community
+	should not be advertised to any of its neighbors. If this option is
+	enabled (which is by default), BIRD has such behavior automatically (it
+	is evaluated when a route is exported to the BGP protocol just before
+	the export filter).  Otherwise, this integrated processing of
+	well-known communities is disabled. In that case, similar behavior can
+	be implemented in the export filter.  Default: on.
 
 	<tag><label id="bgp-enable-as4">enable as4 <m/switch/</tag>
 	BGP protocol was designed to use 2B AS numbers and was extended later to
@@ -2085,17 +2068,17 @@ using the following configuration parameters:
 
 	<tag><label id="bgp-advertise-ipv4">advertise ipv4 <m/switch/</tag>
 	Advertise IPv4 multiprotocol capability. This is not a correct behavior
-	according to the strict interpretation of RFC 4760, but it is widespread
-	and required by some BGP implementations (Cisco and Quagga). This option
-	is relevant to IPv4 mode with enabled capability advertisement
-	only. Default: on.
+	according to the strict interpretation of <rfc id="4760">, but it is
+	widespread and required by some BGP implementations (Cisco and Quagga).
+	This option is relevant to IPv4 mode with enabled capability
+	advertisement only. Default: on.
 
 	<tag><label id="bgp-route-limit">route limit <m/number/</tag>
 	The maximal number of routes that may be imported from the protocol. If
 	the route limit is exceeded, the connection is closed with an error.
 	Limit is currently implemented as <cf>import limit <m/number/ action
 	restart</cf>. This option is obsolete and it is replaced by
-	<ref id="proto-import-limit" name="import limit option">. Default: no	limit.
+	<ref id="proto-import-limit" name="import limit option">. Default: no limit.
 
 	<tag><label id="bgp-disable-after-error">disable after error <m/switch/</tag>
 	When an error is encountered (either locally or by the other side),
@@ -2152,16 +2135,16 @@ using the following configuration parameters:
 	BGP route selection algorithm is often viewed as a comparison between
 	individual routes (e.g. if a new route appears and is better than the
 	current best one, it is chosen as the new best one). But the proper
-	route selection, as specified by RFC 4271, cannot be fully implemented
-	in that way. The problem is mainly in handling the MED attribute. BIRD,
-	by default, uses an simplification based on individual route comparison,
-	which in some cases may lead to temporally dependent behavior (i.e. the
-	selection is dependent on the order in which routes appeared). This
-	option enables a different (and slower) algorithm implementing proper
-	RFC 4271 route selection, which is deterministic. Alternative way how to
-	get deterministic behavior is to use <cf/med metric/ option. This option
-	is incompatible with <ref id="dsc-table-sorted" name="sorted tables">.
-	Default: off.
+	route selection, as specified by <rfc id="4271">, cannot be fully
+	implemented in that way. The problem is mainly in handling the MED
+	attribute. BIRD, by default, uses an simplification based on individual
+	route comparison, which in some cases may lead to temporally dependent
+	behavior (i.e. the selection is dependent on the order in which routes
+	appeared). This option enables a different (and slower) algorithm
+	implementing proper <rfc id="4271"> route selection, which is
+	deterministic. Alternative way how to get deterministic behavior is to
+	use <cf/med metric/ option. This option is incompatible with <ref
+	id="dsc-table-sorted" name="sorted tables">.  Default: off.
 
 	<tag><label id="bgp-igp-metric">igp metric <m/switch/</tag>
 	Enable comparison of internal distances to boundary routers during best
@@ -2170,7 +2153,7 @@ using the following configuration parameters:
 	<tag><label id="bgp-prefer-older">prefer older <m/switch/</tag>
 	Standard route selection algorithm breaks ties by comparing router IDs.
 	This changes the behavior to prefer older routes (when both are external
-	and from different peer). For details, see RFC 5004. Default: off.
+	and from different peer). For details, see <rfc id="5004">. Default: off.
 
 	<tag><label id="bgp-default-med">default bgp_med <m/number/</tag>
 	Value of the Multiple Exit Discriminator to be used during route
@@ -2210,8 +2193,8 @@ some of them (marked with `<tt/O/') are optional.
 	when a route is exported to an external BGP instance to ensure that the
 	attribute received from a neighboring AS is not propagated to other
 	neighboring ASes. A new value might be set in the export filter of an
-	external BGP instance. See RFC 4451<htmlurl url="ftp://ftp.rfc-editor.org/in-notes/rfc4451.txt">
-	for further discussion of BGP MED attribute.
+	external BGP instance. See <rfc id="4451"> for further discussion of
+	BGP MED attribute.
 
 	<tag><label id="rta-bgp-origin">enum bgp_origin/</tag>
 	Origin of the route: either <cf/ORIGIN_IGP/ if the route has originated
@@ -2580,15 +2563,13 @@ protocol kernel {		# Secondary routing table
 <label id="ospf-intro">
 
 <p>Open Shortest Path First (OSPF) is a quite complex interior gateway
-protocol. The current IPv4 version (OSPFv2) is defined in RFC 2328
-<htmlurl url="ftp://ftp.rfc-editor.org/in-notes/rfc2328.txt">
-and the current IPv6 version (OSPFv3) is defined in RFC 5340
-<htmlurl url="ftp://ftp.rfc-editor.org/in-notes/rfc5340.txt">
-It's a link state (a.k.a. shortest path first) protocol -- each router maintains
-a database describing the autonomous system's topology. Each participating
-router has an identical copy of the database and all routers run the same
-algorithm calculating a shortest path tree with themselves as a root. OSPF
-chooses the least cost path as the best path.
+protocol. The current IPv4 version (OSPFv2) is defined in <rfc id="2328"> and
+the current IPv6 version (OSPFv3) is defined in <rfc id="5340"> It's a link
+state (a.k.a. shortest path first) protocol -- each router maintains a database
+describing the autonomous system's topology. Each participating router has an
+identical copy of the database and all routers run the same algorithm
+calculating a shortest path tree with themselves as a root. OSPF chooses the
+least cost path as the best path.
 
 <p>In OSPF, the autonomous system can be split to several areas in order to
 reduce the amount of resources consumed for exchanging the routing information
@@ -2708,8 +2689,7 @@ protocol ospf &lt;name&gt; {
 <descrip>
 	<tag><label id="ospf-rfc1583compat">rfc1583compat <M>switch</M></tag>
 	This option controls compatibility of routing table calculation with
-	RFC 1583 <htmlurl url="ftp://ftp.rfc-editor.org/in-notes/rfc1583.txt">.
-	Default	value is no.
+	<rfc id="1583">. Default value is no.
 
 	<tag><label id="ospf-instance-id">instance id <m/num/</tag>
 	When multiple OSPF protocol instances are active on the same links, they
@@ -2726,9 +2706,8 @@ protocol ospf &lt;name&gt; {
 	that participates in the OSPF topology but does not allow transit
 	traffic. In OSPFv2, this is implemented by advertising maximum metric
 	for outgoing links. In OSPFv3, the stub router behavior is announced by
-	clearing the R-bit in the router LSA. See RFC 6987
-	<htmlurl url="ftp://ftp.rfc-editor.org/in-notes/rfc6987.txt"> for
-	details. Default value is no.
+	clearing the R-bit in the router LSA. See <rfc id="6987"> for details.
+	Default value is no.
 
 	<tag><label id="ospf-tick">tick <M>num</M></tag>
 	The routing table calculation and clean-up of areas' databases is not
@@ -2839,10 +2818,9 @@ protocol ospf &lt;name&gt; {
 
 	You can specify alternative instance ID for the interface definition,
 	therefore it is possible to have several instances of that interface
-	with different options or even in different areas. For OSPFv2,
-	instance ID support is an extension (RFC 6549
-	<htmlurl url="ftp://ftp.rfc-editor.org/in-notes/rfc6549.txt">) and is
-	supposed to be set per-protocol. For OSPFv3, it is an integral feature.
+	with different options or even in different areas. For OSPFv2, instance
+	ID support is an extension (<rfc id="6549">) and is supposed to be set
+	per-protocol. For OSPFv3, it is an integral feature.
 
 	<tag><label id="ospf-virtual-link">virtual link <M>id</M> [instance <m/num/]</tag>
 	Virtual link to router with the router id. Virtual link acts as a
@@ -3266,9 +3244,7 @@ time intervals or as an answer to a request) advertisement packets to connected
 networks. These packets contain basic information about a local network (e.g. a
 list of network prefixes), which allows network hosts to autoconfigure network
 addresses and choose a default route. BIRD implements router behavior as defined
-in RFC 4861<htmlurl url="ftp://ftp.rfc-editor.org/in-notes/rfc4861.txt">
-and also the DNS extensions from
-RFC 6106<htmlurl url="ftp://ftp.rfc-editor.org/in-notes/rfc6106.txt">.
+in <rfc id="4861"> and also the DNS extensions from <rfc id="6106">.
 
 <sect1>Configuration
 <label id="radv-config">
@@ -3523,12 +3499,9 @@ counting to infinity is necessary, because it is slow. Due to infinity being 16,
 you can't use RIP on networks where maximal distance is higher than 15
 hosts.
 
-<p>BIRD supports RIPv1
-(RFC 1058<htmlurl url="http://www.rfc-editor.org/rfc/rfc1058.txt">),
-RIPv2 (RFC 2453<htmlurl url="http://www.rfc-editor.org/rfc/rfc2453.txt">),
-RIPng (RFC 2080<htmlurl url="http://www.rfc-editor.org/rfc/rfc2080.txt">),
-and RIP cryptographic authentication (SHA-1 not implemented)
-(RFC 4822<htmlurl url="http://www.rfc-editor.org/rfc/rfc4822.txt">).
+<p>BIRD supports RIPv1 (<rfc id="1058">), RIPv2 (<rfc id="2453">), RIPng (<rfc
+id="2080">), and RIP cryptographic authentication (SHA-1 not implemented)
+(<rfc id="4822">).
 
 <p>RIP is a very simple protocol, and it has a lot of shortcomings. Slow
 convergence, big network load and inability to handle larger networks makes it
@@ -3707,8 +3680,9 @@ protocol rip [&lt;name&gt;] {
 	compatibility with neighbors regardless of whether they use ttl
 	security.
 
-	For RIPng, TTL security is a standard behavior (required by RFC 2080)
-	and therefore default value is yes. For IPv4 RIP, default value is no.
+	For RIPng, TTL security is a standard behavior (required by <rfc
+	id="2080">) and therefore default value is yes. For IPv4 RIP, default
+	value is no.
 
 	<tag><label id="rip-iface-tx-class">tx class|dscp|priority <m/number/</tag>
 	These options specify the ToS/DiffServ/Traffic class/Priority of the
diff --git a/doc/sbase/dist/birddoc/html/mapping b/doc/sbase/dist/birddoc/html/mapping
index 5ce36066..1f05070c 100644
--- a/doc/sbase/dist/birddoc/html/mapping
+++ b/doc/sbase/dist/birddoc/html/mapping
@@ -205,6 +205,10 @@
 <htmlurl>		"<A HREF=\"[URL]\">[NAME]</A>"
 </htmlurl>
 
+<rfc>			"<A HREF=\"http://www.rfc-editor.org/info/rfc[ID]\">RFC [ID]</A>"
+</rfc>
+
+
 % ref modified to have an optional name field
 <ref>		+	"<@@ref>[ID]\n"
 			"[NAME]</A>\n"
diff --git a/doc/sbase/dist/birddoc/latex2e/mapping b/doc/sbase/dist/birddoc/latex2e/mapping
index e7c62e0a..f53bbbe4 100644
--- a/doc/sbase/dist/birddoc/latex2e/mapping
+++ b/doc/sbase/dist/birddoc/latex2e/mapping
@@ -238,6 +238,9 @@
 <htmlurl>		"\\href{[URL]}{[NAME]}"
 </htmlurl>
 
+<rfc>			"\\href{http://www.rfc-editor.org/info/rfc[ID]}{RFC [ID]}"
+</rfc>
+
 <x>
 </x>
 
diff --git a/doc/sbase/dtd/birddoc.dtd b/doc/sbase/dtd/birddoc.dtd
index 6db5066a..1db2af6c 100644
--- a/doc/sbase/dtd/birddoc.dtd
+++ b/doc/sbase/dtd/birddoc.dtd
@@ -99,7 +99,7 @@ anywhere else. <pavel@ucw.cz>
 
 <!-- url added by HG; htmlurl added by esr -->
 <!entity % xref
-	" label|ref|pageref|cite|url|htmlurl|ncite " >
+	" label|ref|pageref|cite|url|htmlurl|rfc|ncite " >
 
 <!entity % inline
 	" (#pcdata | f| x| %emph; |sq| %xref | %index | file )* " >
@@ -501,6 +501,10 @@ anywhere else. <pavel@ucw.cz>
         url cdata #required
         name cdata "&urlnam" >
 
+<!element rfc - o empty>
+<!attlist rfc
+        id cdata #required>
+
 <!element pageref - o empty>
 <!attlist pageref
         id cdata #required>

From c2564d34af9e01a828c24b0be7f269e5b036b5da Mon Sep 17 00:00:00 2001
From: Pavel Tvrdik <pawel.tvrdik@gmail.com>
Date: Sat, 1 Oct 2016 12:50:29 +0200
Subject: [PATCH 140/165] Tree/Trie: Check the end of buffer

We set buffer->pos to buffer->end in function buffer_print() when
bvsnprintf() failed, so there would be uninitialized memory between
the old buffer->pos and the current buffer->pos.
---
 filter/tree.c | 3 +++
 filter/trie.c | 3 +++
 2 files changed, 6 insertions(+)

diff --git a/filter/tree.c b/filter/tree.c
index 328c7184..1196e630 100644
--- a/filter/tree.c
+++ b/filter/tree.c
@@ -165,6 +165,9 @@ tree_format(struct f_tree *t, buffer *buf)
  
   tree_node_format(t, buf);
 
+  if (buf->pos == buf->end)
+    return;
+
   /* Undo last separator */
   if (buf->pos[-1] != '[')
     buf->pos -= 2;
diff --git a/filter/trie.c b/filter/trie.c
index fba395d1..565ae82f 100644
--- a/filter/trie.c
+++ b/filter/trie.c
@@ -300,6 +300,9 @@ trie_format(struct f_trie *t, buffer *buf)
     buffer_print(buf, "%I/%d, ", IPA_NONE, 0);
   trie_node_format(t->root, buf);
 
+  if (buf->pos == buf->end)
+    return;
+
   /* Undo last separator */
   if (buf->pos[-1] != '[')
     buf->pos -= 2;

From 3d28f0145382feddcf7f66c0a20b6c5b3e0edbc9 Mon Sep 17 00:00:00 2001
From: Pavel Tvrdik <pawel.tvrdik@gmail.com>
Date: Mon, 26 Sep 2016 18:05:51 +0200
Subject: [PATCH 141/165] Doc: Fix deprecated unescaped braces in perl script

This commit should fix warning `make docs'

./sgml2html bird.sgml Unescaped left brace in regex is deprecated,
  passed through in regex; marked by <-- HERE in m/\\nameurl{ <-- HERE
    (.*)}{(.*)}/ at fmt_latex2e.pl line 287.
---
 doc/sbase/dist/fmt_latex2e.pl | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc/sbase/dist/fmt_latex2e.pl b/doc/sbase/dist/fmt_latex2e.pl
index 1f121743..d0656b7d 100644
--- a/doc/sbase/dist/fmt_latex2e.pl
+++ b/doc/sbase/dist/fmt_latex2e.pl
@@ -284,11 +284,11 @@ ($)
 	# for nameurl
 	   if ( /\\nameurl/ )
 	     {
-		($urlid, $urlnam) = ($_ =~ /\\nameurl{(.*)}{(.*)}/);
+		($urlid, $urlnam) = ($_ =~ /\\nameurl\{(.*)\}\{(.*)\}/);
 		print $urlnum . ": " . $urlid . "\n" if ( $global->{debug} );
 
 		$urldef = latex2e_defnam($urlnum) . "url";
-		s/\\nameurl{.*}{.*}/{\\em $urlnam} {\\tt \\$urldef}/;
+		s/\\nameurl\{.*\}\{.*\}/{\\em $urlnam} {\\tt \\$urldef}/;
 		push @urlnames, $_;
 		push @urldefines, "\\urldef{\\$urldef} \\url{$urlid}\n";
 		$urlnum++;

From 9fcb9637b55d234dfedfcb54bd76ed5a9570b7a1 Mon Sep 17 00:00:00 2001
From: Pavel Tvrdik <pawel.tvrdik@gmail.com>
Date: Mon, 19 Sep 2016 16:01:29 +0200
Subject: [PATCH 142/165] Nest: Remove trailing whitespaces

---
 nest/config.Y | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/nest/config.Y b/nest/config.Y
index ca705640..b03f1a7f 100644
--- a/nest/config.Y
+++ b/nest/config.Y
@@ -87,7 +87,7 @@ CF_GRAMMAR
 
 CF_ADDTO(conf, rtrid)
 
-rtrid: 
+rtrid:
    ROUTER ID idval ';' { new_config->router_id = $3; }
  | ROUTER ID FROM iface_patt ';' { new_config->router_id_from = this_ipatt; }
  ;
@@ -125,7 +125,7 @@ listen_opts:
  | listen_opts listen_opt
  ;
 
-listen_opt: 
+listen_opt:
    ADDRESS ipa { new_config->listen_bgp_addr = $2; }
  | PORT expr { new_config->listen_bgp_port = $2; }
  | V6ONLY { new_config->listen_bgp_flags = 0; }
@@ -293,7 +293,7 @@ iface_negate:
  ;
 
 iface_patt_node:
-   iface_patt_node_init iface_negate iface_patt_node_body 
+   iface_patt_node_init iface_negate iface_patt_node_body
  ;
 
 
@@ -397,7 +397,7 @@ password_list:
  | password_item
 ;
 
-password_items: 
+password_items:
     /* empty */
   | password_item ';' password_items
 ;
@@ -426,7 +426,7 @@ password_item_begin:
 ;
 
 password_item_params:
-   /* empty */ { } 
+   /* empty */ { }
  | GENERATE FROM datetime ';' password_item_params { this_p_item->genfrom = $3; }
  | GENERATE TO datetime ';' password_item_params { this_p_item->gento = $3; }
  | ACCEPT FROM datetime ';' password_item_params { this_p_item->accfrom = $3; }
@@ -602,7 +602,7 @@ sym_args:
 
 
 roa_table_arg:
-   /* empty */ { 
+   /* empty */ {
      if (roa_table_default == NULL)
        cf_error("No ROA table defined");
      $$ = roa_table_default;

From 9df52a98e2eae28f219510d4c3d65ec43a50c394 Mon Sep 17 00:00:00 2001
From: Pavel Tvrdik <pawel.tvrdik@gmail.com>
Date: Mon, 5 Sep 2016 11:20:28 +0200
Subject: [PATCH 143/165] Doc: Change debug to { flag1|flag2|flag3  [, ...] }
 style

Thanks to Micah Anderson for bug report and Ondrej Zajicek for the idea!
---
 doc/bird.sgml | 32 ++++++++++++++++----------------
 nest/config.Y |  6 +++---
 2 files changed, 19 insertions(+), 19 deletions(-)

diff --git a/doc/bird.sgml b/doc/bird.sgml
index 24be3de0..a07201ce 100644
--- a/doc/bird.sgml
+++ b/doc/bird.sgml
@@ -344,7 +344,7 @@ protocol rip {
 
 	<tag><label id="opt-log">log "<m/filename/"|syslog [name <m/name/]|stderr all|{ <m/list of classes/ }</tag>
 	Set logging of messages having the given class (either <cf/all/ or
-	<cf/{ error, trace }/ etc.) into selected destination (a file specified
+	<cf/{ error|trace [, <m/.../] }/ etc.) into selected destination (a file specified
 	as a filename string, syslog with optional name argument, or the stderr
 	output). Classes are:
 	<cf/info/, <cf/warning/, <cf/error/ and <cf/fatal/ for messages about local problems,
@@ -356,7 +356,7 @@ protocol rip {
 	You may specify more than one <cf/log/ line to establish logging to
 	multiple destinations. Default: log everything to the system log.
 
-	<tag><label id="opt-debug-protocols">debug protocols all|off|{ states, routes, filters, interfaces, events, packets }</tag>
+	<tag><label id="opt-debug-protocols">debug protocols all|off|{ states|routes|filters|interfaces|events|packets [, <m/.../] }</tag>
 	Set global defaults of protocol debugging options. See <cf/debug/ in the
 	following section. Default: off.
 
@@ -386,7 +386,7 @@ protocol rip {
 	Set MRTdump file name. This option must be specified to allow MRTdump
 	feature. Default: no dump file.
 
-	<tag><label id="opt-mrtdump-protocols">mrtdump protocols all|off|{ states, messages }</tag>
+	<tag><label id="opt-mrtdump-protocols">mrtdump protocols all|off|{ states|messages [, <m/.../] }</tag>
 	Set global defaults of MRTdump options. See <cf/mrtdump/ in the
 	following section. Default: off.
 
@@ -397,7 +397,7 @@ protocol rip {
 	<tag><label id="opt-function">function <m/name/ (<m/parameters/) <m/local variables/ { <m/commands/ }</tag>
 	Define a function. You can learn more about functions in the following chapter.
 
-	<tag><label id="opt-protocol">protocol rip|ospf|bgp|... [<m/name/ [from <m/name2/]] { <m>protocol options</m> }</tag>
+	<tag><label id="opt-protocol">protocol rip|ospf|bgp|<m/.../ [<m/name/ [from <m/name2/]] { <m>protocol options</m> }</tag>
 	Define a protocol instance called <cf><m/name/</cf> (or with a name like
 	"rip5" generated automatically if you don't specify any
 	<cf><m/name/</cf>). You can learn more about configuring protocols in
@@ -406,7 +406,7 @@ protocol rip {
 	<cf><m/name2/</cf> You can run more than one instance of most protocols
 	(like RIP or BGP). By default, no instances are configured.
 
-	<tag><label id="opt-template">template rip|bgp|... [<m/name/ [from <m/name2/]] { <m>protocol options</m> }</tag>
+	<tag><label id="opt-template">template rip|bgp|<m/.../ [<m/name/ [from <m/name2/]] { <m>protocol options</m> }</tag>
 	Define a protocol template instance called <m/name/ (or with a name like
 	"bgp1" generated automatically if you don't specify any	<m/name/).
 	Protocol templates can be used to group common options when many
@@ -427,7 +427,7 @@ protocol rip {
 	version, the lowest IP address of a non-loopback interface. In IPv6
 	version, this option is mandatory.
 
-	<tag><label id="opt-router-id-from">router id from [-] [ "<m/mask/" ] [ <m/prefix/ ] [, ...]</tag>
+	<tag><label id="opt-router-id-from">router id from [-] [ "<m/mask/" ] [ <m/prefix/ ] [, <m/.../]</tag>
 	Set BIRD's router ID based on an IP address of an interface specified by
 	an interface pattern. The option is applicable for IPv4 version only.
 	See <ref id="proto-iface" name="interface"> section for detailed
@@ -480,7 +480,7 @@ protocol rip {
 	Option <cf/sorted/ can be used to enable sorting of routes, see
 	<ref id="dsc-table-sorted" name="sorted table"> description for details.
 
-	<tag><label id="opt-roa-table">roa table <m/name/ [ { roa table options ... } ]</tag>
+	<tag><label id="opt-roa-table">roa table <m/name/ [ { <m/roa table options .../ } ]</tag>
 	Create a new ROA (Route Origin Authorization) table. ROA tables can be
 	used to validate route origination of BGP routes. A ROA table contains
 	ROA entries, each consist of a network prefix, a max prefix length and
@@ -522,7 +522,7 @@ agreement").
 	command line interface without needing to touch the configuration.
 	Disabled protocols are not activated. Default: protocol is enabled.
 
-	<tag><label id="proto-debug">debug all|off|{ states, routes, filters, interfaces, events, packets }</tag>
+	<tag><label id="proto-debug">debug all|off|{ states|routes|filters|interfaces|events|packets [, <m/.../] }</tag>
 	Set protocol debugging options. If asked, each protocol is capable of
 	writing trace messages about its work to the log (with category
 	<cf/trace/). You can either request printing of <cf/all/ trace messages
@@ -533,7 +533,7 @@ agreement").
 	protocol, <cf/events/ for events internal to the protocol and <cf/packets/
 	for packets sent and received by the protocol. Default: off.
 
-	<tag><label id="proto-mrtdump">mrtdump all|off|{ states, messages }</tag>
+	<tag><label id="proto-mrtdump">mrtdump all|off|{ states|messages [, <m/.../] }</tag>
 	Set protocol MRTdump flags. MRTdump is a standard binary format for
 	logging information from routing protocols and daemons. These flags
 	control what kind of information is logged from the protocol to the
@@ -603,7 +603,7 @@ agreement").
 <p>There are several options that give sense only with certain protocols:
 
 <descrip>
-	<tag><label id="proto-iface">interface [-] [ "<m/mask/" ] [ <m/prefix/ ] [, ...] [ { <m/option/ ; [...] } ]</tag>
+	<tag><label id="proto-iface">interface [-] [ "<m/mask/" ] [ <m/prefix/ ] [, <m/.../] [ { <m/option/; [<m/.../] } ]</tag>
 	Specifies a set of interfaces on which the protocol is activated with
 	given interface-specific options. A set of interfaces specified by one
 	interface option is described using an interface pattern. The interface
@@ -895,7 +895,7 @@ This argument can be omitted if there exists only a single instance.
 	<tag><label id="cli-down">down</tag>
 	Shut BIRD down.
 
-	<tag><label id="cli-debug">debug <m/protocol/|<m/pattern/|all all|off|{ states | routes | filters | events | packets }</tag>
+	<tag><label id="cli-debug">debug <m/protocol/|<m/pattern/|all all|off|{ states|routes|filters|events|packets [, <m/.../] }</tag>
 	Control protocol debugging.
 
 	<tag><label id="cli-dump">dump resources|sockets|interfaces|neighbors|attributes|routes|protocols</tag>
@@ -1638,7 +1638,7 @@ protocol bfd [&lt;name&gt;] {
 </code>
 
 <descrip>
-	<tag><label id="bfd-iface">interface <m/pattern [, ...]/ { <m/options/ }</tag>
+	<tag><label id="bfd-iface">interface <m/pattern/ [, <m/.../] { <m/options/ }</tag>
 	Interface definitions allow to specify options for sessions associated
 	with such interfaces and also may contain interface specific options.
 	See <ref id="proto-iface" name="interface"> common option for a detailed
@@ -2356,7 +2356,7 @@ on Linux systems BIRD cannot change non-BIRD route in the kernel routing table.
 <p>There are just few configuration options for the Direct protocol:
 
 <p><descrip>
-	<tag><label id="direct-iface">interface <m/pattern [, ...]/</tag>
+	<tag><label id="direct-iface">interface <m/pattern/ [, <m/.../]</tag>
 	By default, the Direct protocol will generate device routes for all the
 	interfaces available. If you want to restrict it to some subset of
 	interfaces or addresses (e.g. if you're using multiple routing tables
@@ -3253,7 +3253,7 @@ in <rfc id="4861"> and also the DNS extensions from <rfc id="6106">.
 definitions, prefix definitions and DNS definitions:
 
 <descrip>
-	<tag><label id="radv-iface">interface <m/pattern [, ...]/ { <m/options/ }</tag>
+	<tag><label id="radv-iface">interface <m/pattern/ [, <m/.../] { <m/options/ }</tag>
 	Interface definitions specify a set of interfaces on which the
 	protocol is activated and contain interface specific options.
 	See <ref id="proto-iface" name="interface"> common options for
@@ -3563,7 +3563,7 @@ protocol rip [&lt;name&gt;] {
 	nexthops in one route. By default, ECMP is disabled. If enabled,
 	default	value of the limit is 16.
 
-	<tag><label id="rip-iface">interface <m/pattern [, ...]/ { <m/options/ }</tag>
+	<tag><label id="rip-iface">interface <m/pattern/ [, <m/.../] { <m/options/ }</tag>
 	Interface definitions specify a set of interfaces on which the
 	protocol is activated and contain interface specific options.
 	See <ref id="proto-iface" name="interface"> common options for
@@ -3795,7 +3795,7 @@ definition of the protocol contains mainly a list of static routes.
 	interface can be specified as a part of the address (e.g.,
 	<cf/via fe80::1234%eth0/).
 
-	<tag><label id="static-route-via-mpath">route <m/prefix/ multipath via <m/ip/ [weight <m/num/] [bfd <m/switch/] [via ...]</tag>
+	<tag><label id="static-route-via-mpath">route <m/prefix/ multipath via <m/ip/ [weight <m/num/] [bfd <m/switch/] [via <m/.../]</tag>
 	Static multipath route. Contains several nexthops (gateways), possibly
 	with their weights.
 
diff --git a/nest/config.Y b/nest/config.Y
index b03f1a7f..3e76581a 100644
--- a/nest/config.Y
+++ b/nest/config.Y
@@ -658,7 +658,7 @@ CF_CLI(EVAL, term, <expr>, [[Evaluate an expression]])
 { cmd_eval($2); } ;
 
 CF_CLI_HELP(ECHO, ..., [[Control echoing of log messages]])
-CF_CLI(ECHO, echo_mask echo_size, (all | off | { debug | trace | info | remote | warning | error | auth }) [<buffer-size>], [[Control echoing of log messages]]) {
+CF_CLI(ECHO, echo_mask echo_size, (all | off | { debug|trace|info|remote|warning|error|auth [, ...] }) [<buffer-size>], [[Control echoing of log messages]]) {
   cli_set_log_echo(this_cli, $2, $3);
   cli_msg(0, "");
 } ;
@@ -691,11 +691,11 @@ CF_CLI(RELOAD OUT, proto_patt, <protocol> | \"<pattern>\" | all, [[Reload protoc
 { proto_apply_cmd($3, proto_cmd_reload, 1, CMD_RELOAD_OUT); } ;
 
 CF_CLI_HELP(DEBUG, ..., [[Control protocol debugging via BIRD logs]])
-CF_CLI(DEBUG, proto_patt debug_mask, (<protocol> | <pattern> | all) (all | off | { states | routes | filters | interfaces | events | packets }), [[Control protocol debugging via BIRD logs]])
+CF_CLI(DEBUG, proto_patt debug_mask, (<protocol> | \"<pattern>\" | all) (all | off | { states|routes|filters|interfaces|events|packets [, ...] }), [[Control protocol debugging via BIRD logs]])
 { proto_apply_cmd($2, proto_cmd_debug, 1, $3); } ;
 
 CF_CLI_HELP(MRTDUMP, ..., [[Control protocol debugging via MRTdump files]])
-CF_CLI(MRTDUMP, proto_patt mrtdump_mask, (<protocol> | <pattern> | all) (all | off | { states | messages }), [[Control protocol debugging via MRTdump format]])
+CF_CLI(MRTDUMP, proto_patt mrtdump_mask, (<protocol> | \"<pattern>\" | all) (all | off | { states|messages [, ...] }), [[Control protocol debugging via MRTdump format]])
 { proto_apply_cmd($2, proto_cmd_mrtdump, 1, $3); } ;
 
 CF_CLI(RESTRICT,,,[[Restrict current CLI session to safe commands]])

From 2e7fb11a6e31324151c6db98df2fe26d2d6cffab Mon Sep 17 00:00:00 2001
From: Jan Moskyto Matejka <mq@ucw.cz>
Date: Wed, 12 Oct 2016 14:16:34 +0200
Subject: [PATCH 144/165] Fixed memory bloating on kernel merge paths together
 with export filter.

Some memory was being allocated from bad linpool, not from the given one
as they should.

Thanks to Madhu and Justin Cattle for reporting this.
---
 nest/rt-table.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/nest/rt-table.c b/nest/rt-table.c
index d3aba085..00476069 100644
--- a/nest/rt-table.c
+++ b/nest/rt-table.c
@@ -65,7 +65,7 @@ make_tmp_attrs(struct rte *rt, struct linpool *pool)
 {
   struct ea_list *(*mta)(struct rte *rt, struct linpool *pool);
   mta = rt->attrs->src->proto->make_tmp_attrs;
-  return mta ? mta(rt, rte_update_pool) : NULL;
+  return mta ? mta(rt, pool) : NULL;
 }
 
 /* Like fib_route(), but skips empty net entries */
@@ -596,7 +596,7 @@ mpnh_merge_rta(struct mpnh *nhs, rta *a, linpool *pool, int max)
 {
   struct mpnh nh = { .gw = a->gw, .iface = a->iface };
   struct mpnh *nh2 = (a->dest == RTD_MULTIPATH) ? a->nexthops : &nh;
-  return mpnh_merge(nhs, nh2, 1, 0, max, rte_update_pool);
+  return mpnh_merge(nhs, nh2, 1, 0, max, pool);
 }
 
 rte *

From 5fd7dacadc3cd8f91f66cb56e3a9ef81028aa102 Mon Sep 17 00:00:00 2001
From: Pavel Tvrdik <pawel.tvrdik@gmail.com>
Date: Thu, 13 Oct 2016 15:17:41 +0200
Subject: [PATCH 145/165] Filter: Expand testing of large community sets

---
 filter/test.conf | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/filter/test.conf b/filter/test.conf
index e8873fbf..7623953a 100644
--- a/filter/test.conf
+++ b/filter/test.conf
@@ -95,6 +95,7 @@ clist l2;
 eclist el;
 eclist el2;
 lclist ll;
+lclist ll2;
 {
 	print "Entering path test...";
 	pm1 =  / 4 3 2 1 /;
@@ -220,6 +221,22 @@ lclist ll;
 	print "Should be false: ", mktrip(100) ~ ll, " ", ll ~ [(5,10,15), (10,21,30)], " ", ll ~ [(10,21..25,*)], " ", ll ~ [(11, *, *)];
 	print "LC filtered: ", filter(ll, [(5..15, *, *), (100000, 500..500000, *)]);
 
+	ll = --- empty ---;
+	ll = add(ll, (10, 10, 10));
+	ll = add(ll, (20, 20, 20));
+	ll = add(ll, (30, 30, 30));
+
+	ll2 = --- empty ---;
+	ll2 = add(ll2, (20, 20, 20));
+	ll2 = add(ll2, (30, 30, 30));
+	ll2 = add(ll2, (40, 40, 40));
+
+	print "lclist A (10,20,30): ", ll;
+	print "lclist B (30,40,50): ", ll2;
+	print "lclist A union B: ", add(ll, ll2);
+	print "lclist A isect B: ", filter(ll, ll2);
+	print "lclist A \  B: ", delete(ll, ll2);
+
 #	test_roa();
 }
 

From 3c09af416939d26c252aa1b339b52fd8f9f8e774 Mon Sep 17 00:00:00 2001
From: Pavel Tvrdik <pawel.tvrdik@gmail.com>
Date: Thu, 13 Oct 2016 16:57:21 +0200
Subject: [PATCH 146/165] Clist: The add() function will append a new value

The add() function used to prepend a new community to clist, but after
this fix the add() function appends new community.
---
 nest/a-set.c | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/nest/a-set.c b/nest/a-set.c
index fde34cab..bd244e2e 100644
--- a/nest/a-set.c
+++ b/nest/a-set.c
@@ -244,9 +244,13 @@ int_set_add(struct linpool *pool, struct adata *list, u32 val)
   len = list ? list->length : 0;
   res = lp_alloc(pool, sizeof(struct adata) + len + 4);
   res->length = len + 4;
-  * (u32 *) res->data = val;
+
   if (list)
-    memcpy((char *) res->data + 4, list->data, list->length);
+    memcpy(res->data, list->data, list->length);
+
+  u32 *c = (u32 *) (res->data + len);
+  *c = val;
+
   return res;
 }
 

From c68e8cd374f16a1d659c80f9ebe503f2dd0d4acb Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Tue, 18 Oct 2016 13:06:05 +0200
Subject: [PATCH 147/165] Filter: Minor formatting changes in test.conf

---
 filter/test.conf | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/filter/test.conf b/filter/test.conf
index 7623953a..676b47d1 100644
--- a/filter/test.conf
+++ b/filter/test.conf
@@ -161,7 +161,7 @@ lclist ll2;
 	print "Community list (1,2) (3,1) (3,5) ", l, " len: ", l.len;
 	l = add( l, (3,2) );
 	l = add( l, (4,5) );
-	print "Community list (1,2) (3,1) (3,2) (3,5) (4,5) ", l, " len: ", l.len;
+	print "Community list (1,2) (3,1) (3,5) (3,2) (4,5) ", l, " len: ", l.len;
 	print "Should be true: ", l ~ [(*,2)], " ", l ~ [(*,5)], " ", l ~ [(*, one)];
 	print "Should be false: ", l ~ [(*,3)], " ", l ~ [(*,(one+6))], " ", l ~ [(*, (one+one+one))];
 	l = delete( l, [(*,(one+onef(3)))] );
@@ -176,7 +176,7 @@ lclist ll2;
 	print "clist B (3..6): ", l2;
 	print "clist A union B: ", add( l2, l );
 	print "clist A isect B: ", filter( l, l2 );
-	print "clist A \  B: ", delete( l, l2 );
+	print "clist A \ B: ", delete( l, l2 );
 
 	el = -- empty --;
 	el = add(el, (rt, 10, 20));
@@ -208,7 +208,7 @@ lclist ll2;
 	print "eclist B (30,40,50): ", el2;
 	print "eclist A union B: ", add( el2, el );
 	print "eclist A isect B: ", filter( el, el2 );
-	print "eclist A \  B: ", delete( el, el2 );
+	print "eclist A \ B: ", delete( el, el2 );
 
 	ll = --- empty ---;
 	ll = add(ll, (ten, 20, 30));
@@ -232,10 +232,10 @@ lclist ll2;
 	ll2 = add(ll2, (40, 40, 40));
 
 	print "lclist A (10,20,30): ", ll;
-	print "lclist B (30,40,50): ", ll2;
+	print "lclist B (20,30,40): ", ll2;
 	print "lclist A union B: ", add(ll, ll2);
 	print "lclist A isect B: ", filter(ll, ll2);
-	print "lclist A \  B: ", delete(ll, ll2);
+	print "lclist A \ B: ", delete(ll, ll2);
 
 #	test_roa();
 }

From 3213273d8261c69a343fcd7d4c9607385dfdbb65 Mon Sep 17 00:00:00 2001
From: Ondrej Filip <feela@network.cz>
Date: Thu, 27 Oct 2016 11:08:28 +0200
Subject: [PATCH 148/165] IANA assigned a different number to large BGP
 communities - changed.

---
 proto/bgp/bgp.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/proto/bgp/bgp.h b/proto/bgp/bgp.h
index d5747c18..a865b99d 100644
--- a/proto/bgp/bgp.h
+++ b/proto/bgp/bgp.h
@@ -308,7 +308,7 @@ void bgp_log_error(struct bgp_proto *p, u8 class, char *msg, unsigned code, unsi
 #define BA_EXT_COMMUNITY	0x10	/* [RFC4360] */
 #define BA_AS4_PATH             0x11    /* [RFC4893] */
 #define BA_AS4_AGGREGATOR       0x12
-#define BA_LARGE_COMMUNITY	0x1e	/* [draft-ietf-idr-large-community] */
+#define BA_LARGE_COMMUNITY	0x20	/* [draft-ietf-idr-large-community] */
 
 /* BGP connection states */
 

From 17fe57d8dcc89aea520788914b252cf49cf060ff Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Tue, 1 Nov 2016 11:37:49 +0100
Subject: [PATCH 149/165] Log: Fix broken syslog name

BIRD passed string from configuration to openlog(), which kept it
internally. After reconfiguration the old string was freed, therefore
openlog had invalid copy.

Thanks to Chris Caputo for the original patch.
---
 lib/string.h      |  9 +++++++++
 sysdep/unix/log.c | 18 +++++++++++-------
 2 files changed, 20 insertions(+), 7 deletions(-)

diff --git a/lib/string.h b/lib/string.h
index 9af49b9e..bf0b7cb0 100644
--- a/lib/string.h
+++ b/lib/string.h
@@ -30,6 +30,15 @@ static inline char *xbasename(const char *str)
   return s ? s+1 : (char *) str;
 }
 
+static inline char *
+xstrdup(const char *c)
+{
+  size_t l = strlen(c) + 1;
+  char *z = xmalloc(l);
+  memcpy(z, c, l);
+  return z;
+}
+
 #define ROUTER_ID_64_LENGTH 23
 
 #endif
diff --git a/sysdep/unix/log.c b/sysdep/unix/log.c
index 1fd64426..b89e6b7a 100644
--- a/sysdep/unix/log.c
+++ b/sysdep/unix/log.c
@@ -288,18 +288,22 @@ log_switch(int debug, list *l, char *new_syslog_name)
   current_log_list = l;
 
 #ifdef HAVE_SYSLOG
-  char *old_syslog_name = current_syslog_name;
-  current_syslog_name = new_syslog_name;
-
-  if (old_syslog_name && new_syslog_name &&
-      !strcmp(old_syslog_name, new_syslog_name))
+  if (current_syslog_name && new_syslog_name &&
+      !strcmp(current_syslog_name, new_syslog_name))
     return;
 
-  if (old_syslog_name)
+  if (current_syslog_name)
+  {
     closelog();
+    xfree(current_syslog_name);
+    current_syslog_name = NULL;
+  }
 
   if (new_syslog_name)
-    openlog(new_syslog_name, LOG_CONS | LOG_NDELAY, LOG_DAEMON);
+  {
+    current_syslog_name = xstrdup(new_syslog_name);
+    openlog(current_syslog_name, LOG_CONS | LOG_NDELAY, LOG_DAEMON);
+  }
 #endif
 }
 

From 3e236955c9369475872b9b86a58502fa777b50b9 Mon Sep 17 00:00:00 2001
From: Jan Moskyto Matejka <mq@ucw.cz>
Date: Fri, 14 Oct 2016 15:37:04 +0200
Subject: [PATCH 150/165] Build: switch on -Wextra, get rid of most of the
 warnings

There are several unresolved -Wmissing-field-initializers on older
versions of GCC than 5.1, all of them false positive.
---
 client/birdcl.c        |  2 +-
 client/util.c          |  2 +-
 conf/Makefile          |  2 +
 conf/conf.c            |  2 +-
 configure.in           |  4 +-
 filter/filter.c        |  6 +--
 lib/birdlib.h          |  7 ++++
 lib/hash.h             |  8 ++--
 lib/socket.h           |  2 +-
 nest/a-path.c          |  2 +-
 nest/bfd.h             |  2 +-
 nest/iface.c           |  2 +-
 nest/locks.c           |  3 +-
 nest/route.h           |  1 -
 nest/rt-attr.c         |  4 +-
 nest/rt-table.c        | 18 ++++-----
 proto/babel/babel.c    |  4 +-
 proto/babel/babel.h    |  2 +-
 proto/babel/packets.c  | 84 ++++++++++++++++++++++--------------------
 proto/bfd/bfd.c        |  6 +--
 proto/bfd/packets.c    |  4 +-
 proto/bgp/attrs.c      |  2 +-
 proto/bgp/bgp.c        |  2 +-
 proto/bgp/bgp.h        |  4 +-
 proto/bgp/packets.c    | 29 +++++++--------
 proto/ospf/dbdes.c     |  2 +-
 proto/ospf/hello.c     |  5 ++-
 proto/ospf/lsalib.c    |  2 +-
 proto/ospf/lsalib.h    |  2 +-
 proto/ospf/lsupd.c     |  6 +--
 proto/ospf/neighbor.c  |  2 +-
 proto/ospf/ospf.h      |  8 ++--
 proto/ospf/packet.c    |  4 +-
 proto/ospf/rt.c        |  2 +-
 proto/ospf/topology.c  |  8 ++--
 proto/radv/packets.c   |  6 +--
 proto/radv/radv.c      |  2 +-
 proto/radv/radv.h      |  2 +-
 proto/rip/packets.c    |  8 ++--
 proto/rip/rip.c        |  4 +-
 proto/static/static.c  |  4 +-
 sysdep/bsd/krt-sock.c  |  6 +--
 sysdep/bsd/krt-sys.h   |  2 +-
 sysdep/bsd/sysio.h     | 19 ++++++----
 sysdep/linux/krt-sys.h |  2 +-
 sysdep/linux/netlink.c |  4 +-
 sysdep/unix/io.c       | 12 +++---
 sysdep/unix/krt.c      |  4 +-
 sysdep/unix/main.c     |  6 +--
 sysdep/unix/unix.h     | 10 ++---
 50 files changed, 179 insertions(+), 157 deletions(-)

diff --git a/client/birdcl.c b/client/birdcl.c
index 7b567a9f..4508185c 100644
--- a/client/birdcl.c
+++ b/client/birdcl.c
@@ -125,7 +125,7 @@ more_end(void)
 }
 
 static void
-sig_handler(int signal)
+sig_handler(int signal UNUSED)
 {
   cleanup();
   exit(0);
diff --git a/client/util.c b/client/util.c
index 2d6c074d..1d83e518 100644
--- a/client/util.c
+++ b/client/util.c
@@ -24,7 +24,7 @@ vlog(const char *msg, va_list args)
   int n = vsnprintf(buf, sizeof(buf), msg, args);
   if (n < 0)
     snprintf(buf, sizeof(buf), "???");
-  if (n >= sizeof(buf))
+  else if (n >= (int) sizeof(buf))
     snprintf(buf + sizeof(buf) - 100, 100, " ... <too long>");
   fputs(buf, stderr);
   fputc('\n', stderr);
diff --git a/conf/Makefile b/conf/Makefile
index 5d729a42..cd78c821 100644
--- a/conf/Makefile
+++ b/conf/Makefile
@@ -29,3 +29,5 @@ cf-lex.c: cf-lex.l
 	$(FLEX) $(FLEX_DEBUG) -s -B -8 -ocf-lex.c -Pcf_ cf-lex.l
 
 depend: keywords.h commands.h cf-parse.tab.c cf-lex.c
+
+cf-lex.o: CFLAGS+=-Wno-sign-compare -Wno-unused-function
diff --git a/conf/conf.c b/conf/conf.c
index efaeedeb..029814c6 100644
--- a/conf/conf.c
+++ b/conf/conf.c
@@ -450,7 +450,7 @@ config_undo(void)
 extern void cmd_reconfig_undo_notify(void);
 
 static void
-config_timeout(struct timer *t)
+config_timeout(struct timer *t UNUSED)
 {
   log(L_INFO "Config timeout expired, starting undo");
   cmd_reconfig_undo_notify();
diff --git a/configure.in b/configure.in
index 16a0b414..57fa0079 100644
--- a/configure.in
+++ b/configure.in
@@ -111,11 +111,13 @@ fi
 
 if test "$bird_cflags_default" = yes ; then
 	BIRD_CHECK_GCC_OPTION(bird_cv_c_option_wno_pointer_sign, -Wno-pointer-sign, -Wall)
+	BIRD_CHECK_GCC_OPTION(bird_cv_c_option_wno_missing_init, -Wno-missing-field-initializers, -Wall -Wextra)
 	BIRD_CHECK_GCC_OPTION(bird_cv_c_option_fno_strict_aliasing, -fno-strict-aliasing)
 	BIRD_CHECK_GCC_OPTION(bird_cv_c_option_fno_strict_overflow, -fno-strict-overflow)
 
-	CFLAGS="$CFLAGS -Wall -Wstrict-prototypes -Wno-parentheses"
+	CFLAGS="$CFLAGS -Wall -Wextra -Wstrict-prototypes -Wno-parentheses"
 	BIRD_ADD_GCC_OPTION(bird_cv_c_option_wno_pointer_sign, -Wno-pointer-sign)
+	BIRD_ADD_GCC_OPTION(bird_cv_c_option_wno_missing_init, -Wno-missing-field-initializers)
 	BIRD_ADD_GCC_OPTION(bird_cv_c_option_fno_strict_aliasing, -fno-strict-aliasing)
 	BIRD_ADD_GCC_OPTION(bird_cv_c_option_fno_strict_overflow, -fno-strict-overflow)
 fi
diff --git a/filter/filter.c b/filter/filter.c
index 510303a7..85a06258 100644
--- a/filter/filter.c
+++ b/filter/filter.c
@@ -380,7 +380,7 @@ clist_filter(struct linpool *pool, struct adata *list, struct f_val set, int pos
       *k++ = v.val.i;
   }
 
-  int nl = (k - tmp) * 4;
+  uint nl = (k - tmp) * sizeof(u32);
   if (nl == list->length)
     return list;
 
@@ -414,7 +414,7 @@ eclist_filter(struct linpool *pool, struct adata *list, struct f_val set, int po
     }
   }
 
-  int nl = (k - tmp) * 4;
+  uint nl = (k - tmp) * sizeof(u32);
   if (nl == list->length)
     return list;
 
@@ -446,7 +446,7 @@ lclist_filter(struct linpool *pool, struct adata *list, struct f_val set, int po
       k = lc_copy(k, l+i);
   }
 
-  int nl = (k - tmp) * 4;
+  uint nl = (k - tmp) * sizeof(u32);
   if (nl == list->length)
     return list;
 
diff --git a/lib/birdlib.h b/lib/birdlib.h
index 904544cb..37337078 100644
--- a/lib/birdlib.h
+++ b/lib/birdlib.h
@@ -62,6 +62,13 @@
 #define UNUSED __attribute__((unused))
 #define PACKED __attribute__((packed))
 
+#ifdef IPV6
+#define UNUSED4
+#define UNUSED6 UNUSED
+#else
+#define UNUSED4 UNUSED
+#define UNUSED6
+#endif
 
 /* Microsecond time */
 
diff --git a/lib/hash.h b/lib/hash.h
index a73f647a..fc5fea14 100644
--- a/lib/hash.h
+++ b/lib/hash.h
@@ -2,7 +2,7 @@
 
 #define HASH(type)		struct { type **data; uint count, order; }
 #define HASH_TYPE(v)		typeof(** (v).data)
-#define HASH_SIZE(v)		(1 << (v).order)
+#define HASH_SIZE(v)		(1U << (v).order)
 
 #define HASH_EQ(v,id,k1,k2...)	(id##_EQ(k1, k2))
 #define HASH_FN(v,id,key...)	((u32) (id##_FN(key)) >> (32 - (v).order))
@@ -116,12 +116,12 @@
 
 #define HASH_MAY_RESIZE_DOWN_(v,pool,rehash_fn,args)			\
   ({                                                                    \
-    int _o = (v).order;							\
-    while (((v).count < ((1 << _o) REHASH_LO_MARK(args))) &&		\
+    uint _o = (v).order;							\
+    while (((v).count < ((1U << _o) REHASH_LO_MARK(args))) &&		\
 	   (_o > (REHASH_LO_BOUND(args))))				\
       _o -= (REHASH_LO_STEP(args));					\
     if (_o < (v).order)							\
-      rehash_fn(&(v), pool, _o - (int) (v).order);			\
+      rehash_fn(&(v), pool, _o - (v).order);				\
   })
 
 
diff --git a/lib/socket.h b/lib/socket.h
index 6babfa7b..2da52127 100644
--- a/lib/socket.h
+++ b/lib/socket.h
@@ -30,7 +30,7 @@ typedef struct birdsock {
   byte *rbuf, *rpos;			/* NULL=allocate automatically */
   uint fast_rx;				/* RX has higher priority in event loop */
   uint rbsize;
-  int (*rx_hook)(struct birdsock *, int size); /* NULL=receiving turned off, returns 1 to clear rx buffer */
+  int (*rx_hook)(struct birdsock *, uint size); /* NULL=receiving turned off, returns 1 to clear rx buffer */
 
   byte *tbuf, *tpos;			/* NULL=allocate automatically */
   byte *ttx;				/* Internal */
diff --git a/nest/a-path.c b/nest/a-path.c
index e1031b7b..b453f702 100644
--- a/nest/a-path.c
+++ b/nest/a-path.c
@@ -370,7 +370,7 @@ as_path_filter(struct linpool *pool, struct adata *path, struct f_tree *set, u32
 	}
   }
 
-  int nl = d - buf;
+  uint nl = d - buf;
   if (nl == path->length)
     return path;
 
diff --git a/nest/bfd.h b/nest/bfd.h
index f1e95cb2..b0ebe31d 100644
--- a/nest/bfd.h
+++ b/nest/bfd.h
@@ -42,7 +42,7 @@ struct bfd_request {
 
 struct bfd_request * bfd_request_session(pool *p, ip_addr addr, ip_addr local, struct iface *iface, void (*hook)(struct bfd_request *), void *data);
 
-static inline void cf_check_bfd(int use) { }
+static inline void cf_check_bfd(int use UNUSED) { }
 
 #else
 
diff --git a/nest/iface.c b/nest/iface.c
index 4d73c2a4..a23cdf4f 100644
--- a/nest/iface.c
+++ b/nest/iface.c
@@ -584,7 +584,7 @@ ifa_delete(struct ifa *a)
 }
 
 u32
-if_choose_router_id(struct iface_patt *mask, u32 old_id)
+if_choose_router_id(struct iface_patt *mask UNUSED6, u32 old_id UNUSED6)
 {
 #ifndef IPV6
   struct iface *i;
diff --git a/nest/locks.c b/nest/locks.c
index ad2af493..84b8b0ae 100644
--- a/nest/locks.c
+++ b/nest/locks.c
@@ -100,7 +100,8 @@ static struct resclass olock_class = {
   sizeof(struct object_lock),
   olock_free,
   olock_dump,
-  NULL
+  NULL,
+  NULL,
 };
 
 /**
diff --git a/nest/route.h b/nest/route.h
index 07320566..383f4def 100644
--- a/nest/route.h
+++ b/nest/route.h
@@ -274,7 +274,6 @@ rte *rte_find(net *net, struct rte_src *src);
 rte *rte_get_temp(struct rta *);
 void rte_update2(struct announce_hook *ah, net *net, rte *new, struct rte_src *src);
 static inline void rte_update(struct proto *p, net *net, rte *new) { rte_update2(p->main_ahook, net, new, p->main_source); }
-void rte_discard(rtable *tab, rte *old);
 int rt_examine(rtable *t, ip_addr prefix, int pxlen, struct proto *p, struct filter *filter);
 rte *rt_export_merged(struct announce_hook *ah, net *net, rte **rt_free, struct ea_list **tmpa, linpool *pool, int silent);
 void rt_refresh_begin(rtable *t, struct announce_hook *ah);
diff --git a/nest/rt-attr.c b/nest/rt-attr.c
index 9aeca846..edf27d44 100644
--- a/nest/rt-attr.c
+++ b/nest/rt-attr.c
@@ -103,7 +103,7 @@ static inline int u32_cto(uint x) { return ffs(~x) - 1; }
 static inline u32
 rte_src_alloc_id(void)
 {
-  int i, j;
+  uint i, j;
   for (i = src_id_pos; i < src_id_size; i++)
     if (src_ids[i] != 0xffffffff)
       goto found;
@@ -785,7 +785,7 @@ static inline void
 opaque_format(struct adata *ad, byte *buf, uint size)
 {
   byte *bound = buf + size - 10;
-  int i;
+  uint i;
 
   for(i = 0; i < ad->length; i++)
     {
diff --git a/nest/rt-table.c b/nest/rt-table.c
index 00476069..c6e48c38 100644
--- a/nest/rt-table.c
+++ b/nest/rt-table.c
@@ -1282,8 +1282,8 @@ rte_announce_i(rtable *tab, unsigned type, net *net, rte *new, rte *old,
   rte_update_unlock();
 }
 
-void
-rte_discard(rtable *t, rte *old)	/* Non-filtered route deletion, used during garbage collection */
+static inline void
+rte_discard(rte *old)	/* Non-filtered route deletion, used during garbage collection */
 {
   rte_update_lock();
   rte_recalculate(old->sender, old->net, NULL, old->attrs->src);
@@ -1606,7 +1606,7 @@ rt_prune_step(rtable *tab, int *limit)
 		return 0;
 	      }
 
-	    rte_discard(tab, e);
+	    rte_discard(e);
 	    (*limit)--;
 
 	    goto rescan;
@@ -1712,7 +1712,7 @@ rta_apply_hostentry(rta *a, struct hostentry *he)
 }
 
 static inline rte *
-rt_next_hop_update_rte(rtable *tab, rte *old)
+rt_next_hop_update_rte(rtable *tab UNUSED, rte *old)
 {
   rta a;
   memcpy(&a, old->attrs, sizeof(rta));
@@ -2104,11 +2104,11 @@ hc_remove(struct hostcache *hc, struct hostentry *he)
 static void
 hc_alloc_table(struct hostcache *hc, unsigned order)
 {
-  unsigned hsize = 1 << order;
+  uint hsize = 1 << order;
   hc->hash_order = order;
   hc->hash_shift = 16 - order;
-  hc->hash_max = (order >= HC_HI_ORDER) ? ~0 : (hsize HC_HI_MARK);
-  hc->hash_min = (order <= HC_LO_ORDER) ?  0 : (hsize HC_LO_MARK);
+  hc->hash_max = (order >= HC_HI_ORDER) ? ~0U : (hsize HC_HI_MARK);
+  hc->hash_min = (order <= HC_LO_ORDER) ?  0U : (hsize HC_LO_MARK);
 
   hc->hash_table = mb_allocz(rt_table_pool, hsize * sizeof(struct hostentry *));
 }
@@ -2116,10 +2116,10 @@ hc_alloc_table(struct hostcache *hc, unsigned order)
 static void
 hc_resize(struct hostcache *hc, unsigned new_order)
 {
-  unsigned old_size = 1 << hc->hash_order;
   struct hostentry **old_table = hc->hash_table;
   struct hostentry *he, *hen;
-  int i;
+  uint old_size = 1 << hc->hash_order;
+  uint i;
 
   hc_alloc_table(hc, new_order);
   for (i = 0; i < old_size; i++)
diff --git a/proto/babel/babel.c b/proto/babel/babel.c
index 9d73a264..38be6909 100644
--- a/proto/babel/babel.c
+++ b/proto/babel/babel.c
@@ -1723,7 +1723,7 @@ babel_dump(struct proto *P)
 }
 
 static void
-babel_get_route_info(rte *rte, byte *buf, ea_list *attrs)
+babel_get_route_info(rte *rte, byte *buf, ea_list *attrs UNUSED)
 {
   buf += bsprintf(buf, " (%d/%d) [%lR]", rte->pref, rte->u.babel.metric, rte->u.babel.router_id);
 }
@@ -1965,7 +1965,7 @@ babel_store_tmp_attrs(struct rte *rt, struct ea_list *attrs)
  */
 static void
 babel_rt_notify(struct proto *P, struct rtable *table UNUSED, struct network *net,
-		struct rte *new, struct rte *old, struct ea_list *attrs)
+		struct rte *new, struct rte *old UNUSED, struct ea_list *attrs UNUSED)
 {
   struct babel_proto *p = (void *) P;
   struct babel_entry *e;
diff --git a/proto/babel/babel.h b/proto/babel/babel.h
index 481c88a7..6a95d82f 100644
--- a/proto/babel/babel.h
+++ b/proto/babel/babel.h
@@ -111,7 +111,7 @@ struct babel_iface_config {
   u16 rxcost;
   u8 type;
   u8 check_link;
-  int port;
+  uint port;
   u16 hello_interval;
   u16 ihu_interval;
   u16 update_interval;
diff --git a/proto/babel/packets.c b/proto/babel/packets.c
index 65dd6853..08054832 100644
--- a/proto/babel/packets.c
+++ b/proto/babel/packets.c
@@ -146,6 +146,7 @@ struct babel_write_state {
 #define TLV_HDR(tlv,t,l) ({ tlv->type = t; tlv->length = l - sizeof(struct babel_tlv); })
 #define TLV_HDR0(tlv,t) TLV_HDR(tlv, t, tlv_data[t].min_length)
 
+#define BYTES(n) ((((uint) n) + 7) / 8)
 
 static inline u16
 get_time16(const void *p)
@@ -161,18 +162,18 @@ put_time16(void *p, u16 v)
 }
 
 static inline ip6_addr
-get_ip6_px(const void *p, int plen)
+get_ip6_px(const void *p, uint plen)
 {
   ip6_addr addr = IPA_NONE;
-  memcpy(&addr, p, (plen + 7) / 8);
+  memcpy(&addr, p, BYTES(plen));
   return ip6_ntoh(addr);
 }
 
 static inline void
-put_ip6_px(void *p, ip6_addr addr, int plen)
+put_ip6_px(void *p, ip6_addr addr, uint plen)
 {
   addr = ip6_hton(addr);
-  memcpy(p, &addr, (plen + 7) / 8);
+  memcpy(p, &addr, BYTES(plen));
 }
 
 static inline ip6_addr
@@ -202,21 +203,21 @@ static int babel_read_update(struct babel_tlv *hdr, union babel_msg *msg, struct
 static int babel_read_route_request(struct babel_tlv *hdr, union babel_msg *msg, struct babel_parse_state *state);
 static int babel_read_seqno_request(struct babel_tlv *hdr, union babel_msg *msg, struct babel_parse_state *state);
 
-static int babel_write_ack(struct babel_tlv *hdr, union babel_msg *msg, struct babel_write_state *state, int max_len);
-static int babel_write_hello(struct babel_tlv *hdr, union babel_msg *msg, struct babel_write_state *state, int max_len);
-static int babel_write_ihu(struct babel_tlv *hdr, union babel_msg *msg, struct babel_write_state *state, int max_len);
-static int babel_write_update(struct babel_tlv *hdr, union babel_msg *msg, struct babel_write_state *state, int max_len);
-static int babel_write_route_request(struct babel_tlv *hdr, union babel_msg *msg, struct babel_write_state *state, int max_len);
-static int babel_write_seqno_request(struct babel_tlv *hdr, union babel_msg *msg, struct babel_write_state *state, int max_len);
+static uint babel_write_ack(struct babel_tlv *hdr, union babel_msg *msg, struct babel_write_state *state, uint max_len);
+static uint babel_write_hello(struct babel_tlv *hdr, union babel_msg *msg, struct babel_write_state *state, uint max_len);
+static uint babel_write_ihu(struct babel_tlv *hdr, union babel_msg *msg, struct babel_write_state *state, uint max_len);
+static uint babel_write_update(struct babel_tlv *hdr, union babel_msg *msg, struct babel_write_state *state, uint max_len);
+static uint babel_write_route_request(struct babel_tlv *hdr, union babel_msg *msg, struct babel_write_state *state, uint max_len);
+static uint babel_write_seqno_request(struct babel_tlv *hdr, union babel_msg *msg, struct babel_write_state *state, uint max_len);
 
 struct babel_tlv_data {
   u8 min_length;
   int (*read_tlv)(struct babel_tlv *hdr, union babel_msg *m, struct babel_parse_state *state);
-  int (*write_tlv)(struct babel_tlv *hdr, union babel_msg *m, struct babel_write_state *state, int max_len);
+  uint (*write_tlv)(struct babel_tlv *hdr, union babel_msg *m, struct babel_write_state *state, uint max_len);
   void (*handle_tlv)(union babel_msg *m, struct babel_iface *ifa);
 };
 
-const static struct babel_tlv_data tlv_data[BABEL_TLV_MAX] = {
+static const struct babel_tlv_data tlv_data[BABEL_TLV_MAX] = {
   [BABEL_TLV_ACK_REQ] = {
     sizeof(struct babel_tlv_ack_req),
     babel_read_ack_req,
@@ -291,9 +292,9 @@ babel_read_ack_req(struct babel_tlv *hdr, union babel_msg *m,
   return PARSE_SUCCESS;
 }
 
-static int
+static uint
 babel_write_ack(struct babel_tlv *hdr, union babel_msg *m,
-                struct babel_write_state *state, int max_len)
+                struct babel_write_state *state UNUSED, uint max_len UNUSED)
 {
   struct babel_tlv_ack *tlv = (void *) hdr;
   struct babel_msg_ack *msg = &m->ack;
@@ -319,9 +320,9 @@ babel_read_hello(struct babel_tlv *hdr, union babel_msg *m,
   return PARSE_SUCCESS;
 }
 
-static int
+static uint
 babel_write_hello(struct babel_tlv *hdr, union babel_msg *m,
-                  struct babel_write_state *state, int max_len)
+                  struct babel_write_state *state UNUSED, uint max_len UNUSED)
 {
   struct babel_tlv_hello *tlv = (void *) hdr;
   struct babel_msg_hello *msg = &m->hello;
@@ -363,9 +364,9 @@ babel_read_ihu(struct babel_tlv *hdr, union babel_msg *m,
   return PARSE_SUCCESS;
 }
 
-static int
+static uint
 babel_write_ihu(struct babel_tlv *hdr, union babel_msg *m,
-                struct babel_write_state *state, int max_len)
+                struct babel_write_state *state UNUSED, uint max_len)
 {
   struct babel_tlv_ihu *tlv = (void *) hdr;
   struct babel_msg_ihu *msg = &m->ihu;
@@ -401,9 +402,9 @@ babel_read_router_id(struct babel_tlv *hdr, union babel_msg *m UNUSED,
 }
 
 /* This is called directly from babel_write_update() */
-static int
+static uint
 babel_write_router_id(struct babel_tlv *hdr, u64 router_id,
-		      struct babel_write_state *state, int max_len UNUSED)
+		      struct babel_write_state *state, uint max_len UNUSED)
 {
   struct babel_tlv_router_id *tlv = (void *) hdr;
 
@@ -467,10 +468,10 @@ babel_read_update(struct babel_tlv *hdr, union babel_msg *m,
   msg->metric = get_u16(&tlv->metric);
 
   /* Length of received prefix data without omitted part */
-  int len = (tlv->plen + 7)/8 - (int) tlv->omitted;
+  int len = BYTES(tlv->plen) - (int) tlv->omitted;
   u8 buf[16] = {};
 
-  if ((len < 0) || (len > TLV_OPT_LENGTH(tlv)))
+  if ((len < 0) || ((uint) len > TLV_OPT_LENGTH(tlv)))
     return PARSE_ERROR;
 
   switch (tlv->ae)
@@ -536,13 +537,13 @@ babel_read_update(struct babel_tlv *hdr, union babel_msg *m,
   return PARSE_SUCCESS;
 }
 
-static int
+static uint
 babel_write_update(struct babel_tlv *hdr, union babel_msg *m,
-                   struct babel_write_state *state, int max_len)
+                   struct babel_write_state *state, uint max_len)
 {
   struct babel_tlv_update *tlv = (void *) hdr;
   struct babel_msg_update *msg = &m->update;
-  int len0 = 0;
+  uint len0 = 0;
 
   /*
    * When needed, we write Router-ID TLV before Update TLV and return size of
@@ -558,7 +559,7 @@ babel_write_update(struct babel_tlv *hdr, union babel_msg *m,
     tlv = (struct babel_tlv_update *) NEXT_TLV(tlv);
   }
 
-  int len = sizeof(struct babel_tlv_update) + (msg->plen + 7)/8;
+  uint len = sizeof(struct babel_tlv_update) + BYTES(msg->plen);
 
   if (len0 + len > max_len)
     return 0;
@@ -587,7 +588,7 @@ babel_write_update(struct babel_tlv *hdr, union babel_msg *m,
 
 static int
 babel_read_route_request(struct babel_tlv *hdr, union babel_msg *m,
-                         struct babel_parse_state *state)
+                         struct babel_parse_state *state UNUSED)
 {
   struct babel_tlv_route_request *tlv = (void *) hdr;
   struct babel_msg_route_request *msg = &m->route_request;
@@ -612,7 +613,7 @@ babel_read_route_request(struct babel_tlv *hdr, union babel_msg *m,
     if (tlv->plen > MAX_PREFIX_LENGTH)
       return PARSE_ERROR;
 
-    if (TLV_OPT_LENGTH(tlv) < (tlv->plen + 7)/8)
+    if (TLV_OPT_LENGTH(tlv) < BYTES(tlv->plen))
       return PARSE_ERROR;
 
     msg->plen = tlv->plen;
@@ -629,14 +630,14 @@ babel_read_route_request(struct babel_tlv *hdr, union babel_msg *m,
   return PARSE_IGNORE;
 }
 
-static int
+static uint
 babel_write_route_request(struct babel_tlv *hdr, union babel_msg *m,
-			  struct babel_write_state *state, int max_len)
+			  struct babel_write_state *state UNUSED, uint max_len)
 {
   struct babel_tlv_route_request *tlv = (void *) hdr;
   struct babel_msg_route_request *msg = &m->route_request;
 
-  int len = sizeof(struct babel_tlv_route_request) + (msg->plen + 7)/8;
+  uint len = sizeof(struct babel_tlv_route_request) + BYTES(msg->plen);
 
   if (len > max_len)
     return 0;
@@ -687,7 +688,7 @@ babel_read_seqno_request(struct babel_tlv *hdr, union babel_msg *m,
     if (tlv->plen > MAX_PREFIX_LENGTH)
       return PARSE_ERROR;
 
-    if (TLV_OPT_LENGTH(tlv) < (tlv->plen + 7)/8)
+    if (TLV_OPT_LENGTH(tlv) < BYTES(tlv->plen))
       return PARSE_ERROR;
 
     msg->plen = tlv->plen;
@@ -704,14 +705,14 @@ babel_read_seqno_request(struct babel_tlv *hdr, union babel_msg *m,
   return PARSE_IGNORE;
 }
 
-static int
+static uint
 babel_write_seqno_request(struct babel_tlv *hdr, union babel_msg *m,
-			  struct babel_write_state *state, int max_len)
+			  struct babel_write_state *state UNUSED, uint max_len)
 {
   struct babel_tlv_seqno_request *tlv = (void *) hdr;
   struct babel_msg_seqno_request *msg = &m->seqno_request;
 
-  int len = sizeof(struct babel_tlv_seqno_request) + (msg->plen + 7)/8;
+  uint len = sizeof(struct babel_tlv_seqno_request) + BYTES(msg->plen);
 
   if (len > max_len)
     return 0;
@@ -744,11 +745,11 @@ babel_read_tlv(struct babel_tlv *hdr,
   return tlv_data[hdr->type].read_tlv(hdr, msg, state);
 }
 
-static int
+static uint
 babel_write_tlv(struct babel_tlv *hdr,
 		union babel_msg *msg,
 		struct babel_write_state *state,
-		int max_len)
+		uint max_len)
 {
   if ((msg->type <= BABEL_TLV_PADN) ||
       (msg->type >= BABEL_TLV_MAX) ||
@@ -792,7 +793,7 @@ babel_send_to(struct babel_iface *ifa, ip_addr dest)
  *
  * The TLVs in the queue are freed after they are written to the buffer.
  */
-static int
+static uint
 babel_write_queue(struct babel_iface *ifa, list *queue)
 {
   struct babel_proto *p = ifa->proto;
@@ -813,6 +814,9 @@ babel_write_queue(struct babel_iface *ifa, list *queue)
   struct babel_msg_node *msg;
   WALK_LIST_FIRST(msg, *queue)
   {
+    if (pos >= end)
+      break;
+
     int len = babel_write_tlv((struct babel_tlv *) pos, &msg->msg, &state, end - pos);
 
     if (!len)
@@ -823,7 +827,7 @@ babel_write_queue(struct babel_iface *ifa, list *queue)
     sl_free(p->msg_slab, msg);
   }
 
-  int plen = pos - (byte *) pkt;
+  uint plen = pos - (byte *) pkt;
   put_u16(&pkt->length, plen - sizeof(struct babel_pkt_header));
 
   return plen;
@@ -1027,7 +1031,7 @@ babel_tx_hook(sock *sk)
 
 
 static int
-babel_rx_hook(sock *sk, int len)
+babel_rx_hook(sock *sk, uint len)
 {
   struct babel_iface *ifa = sk->data;
   struct babel_proto *p = ifa->proto;
diff --git a/proto/bfd/bfd.c b/proto/bfd/bfd.c
index 5de2f556..e7be6a8a 100644
--- a/proto/bfd/bfd.c
+++ b/proto/bfd/bfd.c
@@ -796,7 +796,7 @@ bfd_start_neighbor(struct bfd_proto *p, struct bfd_neighbor *n)
 }
 
 static void
-bfd_stop_neighbor(struct bfd_proto *p, struct bfd_neighbor *n)
+bfd_stop_neighbor(struct bfd_proto *p UNUSED, struct bfd_neighbor *n)
 {
   if (n->neigh)
     n->neigh->data = NULL;
@@ -853,7 +853,7 @@ void pipe_drain(int fd);
 void pipe_kick(int fd);
 
 static int
-bfd_notify_hook(sock *sk, int len)
+bfd_notify_hook(sock *sk, uint len UNUSED)
 {
   struct bfd_proto *p = sk->data;
   struct bfd_session *s;
@@ -1060,7 +1060,7 @@ bfd_preconfig(struct protocol *P UNUSED, struct config *c UNUSED)
 }
 
 static void
-bfd_copy_config(struct proto_config *dest, struct proto_config *src)
+bfd_copy_config(struct proto_config *dest, struct proto_config *src UNUSED)
 {
   struct bfd_config *d = (struct bfd_config *) dest;
   // struct bfd_config *s = (struct bfd_config *) src;
diff --git a/proto/bfd/packets.c b/proto/bfd/packets.c
index cb40bcda..deb501fc 100644
--- a/proto/bfd/packets.c
+++ b/proto/bfd/packets.c
@@ -39,7 +39,7 @@ static inline u8 bfd_pkt_get_diag(struct bfd_ctl_packet *pkt)
 static inline u8 bfd_pkt_get_state(struct bfd_ctl_packet *pkt)
 { return pkt->flags >> 6; }
 
-static inline void bfd_pkt_set_state(struct bfd_ctl_packet *pkt, u8 val)
+static inline void UNUSED bfd_pkt_set_state(struct bfd_ctl_packet *pkt, u8 val)
 { pkt->flags = val << 6; }
 
 
@@ -97,7 +97,7 @@ bfd_send_ctl(struct bfd_proto *p, struct bfd_session *s, int final)
 #define DROP(DSC,VAL) do { err_dsc = DSC; err_val = VAL; goto drop; } while(0)
 
 static int
-bfd_rx_hook(sock *sk, int len)
+bfd_rx_hook(sock *sk, uint len)
 {
   struct bfd_proto *p =  sk->data;
   struct bfd_ctl_packet *pkt = (struct bfd_ctl_packet *) sk->rbuf;
diff --git a/proto/bgp/attrs.c b/proto/bgp/attrs.c
index 6fe34e56..0309c1f7 100644
--- a/proto/bgp/attrs.c
+++ b/proto/bgp/attrs.c
@@ -191,7 +191,7 @@ validate_as4_path(struct bgp_proto *p, struct adata *path)
 }
 
 static int
-bgp_check_next_hop(struct bgp_proto *p UNUSED, byte *a, int len)
+bgp_check_next_hop(struct bgp_proto *p UNUSED, byte *a UNUSED6, int len UNUSED6)
 {
 #ifdef IPV6
   return IGNORE;
diff --git a/proto/bgp/bgp.c b/proto/bgp/bgp.c
index 2014525e..8ef4b990 100644
--- a/proto/bgp/bgp.c
+++ b/proto/bgp/bgp.c
@@ -807,7 +807,7 @@ bgp_find_proto(sock *sk)
  * closes the new connection by sending a Notification message.
  */
 static int
-bgp_incoming_connection(sock *sk, int dummy UNUSED)
+bgp_incoming_connection(sock *sk, uint dummy UNUSED)
 {
   struct bgp_proto *p;
   int acc, hops;
diff --git a/proto/bgp/bgp.h b/proto/bgp/bgp.h
index a865b99d..b4067f3a 100644
--- a/proto/bgp/bgp.h
+++ b/proto/bgp/bgp.h
@@ -191,7 +191,7 @@ struct bgp_bucket {
 #define BGP_RX_BUFFER_EXT_SIZE	65535
 #define BGP_TX_BUFFER_EXT_SIZE	65535
 
-static inline int bgp_max_packet_length(struct bgp_proto *p)
+static inline uint bgp_max_packet_length(struct bgp_proto *p)
 { return p->ext_messages ? BGP_MAX_EXT_MSG_LENGTH : BGP_MAX_MESSAGE_LENGTH; }
 
 extern struct linpool *bgp_linpool;
@@ -268,7 +268,7 @@ void mrt_dump_bgp_state_change(struct bgp_conn *conn, unsigned old, unsigned new
 void bgp_schedule_packet(struct bgp_conn *conn, int type);
 void bgp_kick_tx(void *vconn);
 void bgp_tx(struct birdsock *sk);
-int bgp_rx(struct birdsock *sk, int size);
+int bgp_rx(struct birdsock *sk, uint size);
 const char * bgp_error_dsc(unsigned code, unsigned subcode);
 void bgp_log_error(struct bgp_proto *p, u8 class, char *msg, unsigned code, unsigned subcode, byte *data, unsigned len);
 
diff --git a/proto/bgp/packets.c b/proto/bgp/packets.c
index 0cf38edf..3e816839 100644
--- a/proto/bgp/packets.c
+++ b/proto/bgp/packets.c
@@ -191,7 +191,7 @@ bgp_put_cap_gr1(struct bgp_proto *p, byte *buf)
 }
 
 static byte *
-bgp_put_cap_gr2(struct bgp_proto *p, byte *buf)
+bgp_put_cap_gr2(struct bgp_proto *p UNUSED, byte *buf)
 {
   *buf++ = 64;		/* Capability 64: Support for graceful restart */
   *buf++ = 2;		/* Capability data length */
@@ -931,7 +931,7 @@ bgp_parse_options(struct bgp_conn *conn, byte *opt, int len)
 }
 
 static void
-bgp_rx_open(struct bgp_conn *conn, byte *pkt, int len)
+bgp_rx_open(struct bgp_conn *conn, byte *pkt, uint len)
 {
   struct bgp_conn *other;
   struct bgp_proto *p = conn->bgp;
@@ -944,7 +944,7 @@ bgp_rx_open(struct bgp_conn *conn, byte *pkt, int len)
     { bgp_error(conn, 5, fsm_err_subcode[conn->state], NULL, 0); return; }
 
   /* Check message contents */
-  if (len < 29 || len != 29 + pkt[28])
+  if (len < 29 || len != 29U + pkt[28])
     { bgp_error(conn, 1, 2, pkt+16, 2); return; }
   if (pkt[19] != BGP_VERSION)
     { bgp_error(conn, 2, 1, pkt+19, 1); return; } /* RFC 1771 says 16 bits, draft-09 tells to use 8 */
@@ -1256,16 +1256,15 @@ bgp_do_rx_update(struct bgp_conn *conn,
 #else			/* IPv6 version */
 
 #define DO_NLRI(name)					\
-  start = x = p->name##_start;				\
+  x = p->name##_start;				\
   len = len0 = p->name##_len;				\
   if (len)						\
     {							\
       if (len < 3) { err=9; goto done; }		\
       af = get_u16(x);					\
-      sub = x[2];					\
       x += 3;						\
       len -= 3;						\
-      DBG("\tNLRI AF=%d sub=%d len=%d\n", af, sub, len);\
+      DBG("\tNLRI AF=%d sub=%d len=%d\n", af, x[-1], len);\
     }							\
   else							\
     af = 0;						\
@@ -1291,15 +1290,15 @@ bgp_attach_next_hop(rta *a0, byte *x)
 
 static void
 bgp_do_rx_update(struct bgp_conn *conn,
-		 byte *withdrawn, int withdrawn_len,
-		 byte *nlri, int nlri_len,
+		 byte *withdrawn UNUSED, int withdrawn_len,
+		 byte *nlri UNUSED, int nlri_len,
 		 byte *attrs, int attr_len)
 {
   struct bgp_proto *p = conn->bgp;
   struct rte_src *src = p->p.main_source;
-  byte *start, *x;
+  byte *x;
   int len, len0;
-  unsigned af, sub;
+  unsigned af;
   rta *a0, *a = NULL;
   ip_addr prefix;
   int pxlen, err = 0;
@@ -1375,11 +1374,11 @@ bgp_do_rx_update(struct bgp_conn *conn,
 #endif
 
 static void
-bgp_rx_update(struct bgp_conn *conn, byte *pkt, int len)
+bgp_rx_update(struct bgp_conn *conn, byte *pkt, uint len)
 {
   struct bgp_proto *p = conn->bgp;
   byte *withdrawn, *attrs, *nlri;
-  int withdrawn_len, attr_len, nlri_len;
+  uint withdrawn_len, attr_len, nlri_len;
 
   BGP_TRACE_RL(&rl_rcv_update, D_PACKETS, "Got UPDATE");
 
@@ -1525,7 +1524,7 @@ bgp_log_error(struct bgp_proto *p, u8 class, char *msg, unsigned code, unsigned
 }
 
 static void
-bgp_rx_notification(struct bgp_conn *conn, byte *pkt, int len)
+bgp_rx_notification(struct bgp_conn *conn, byte *pkt, uint len)
 {
   struct bgp_proto *p = conn->bgp;
   if (len < 21)
@@ -1591,7 +1590,7 @@ bgp_rx_keepalive(struct bgp_conn *conn)
 }
 
 static void
-bgp_rx_route_refresh(struct bgp_conn *conn, byte *pkt, int len)
+bgp_rx_route_refresh(struct bgp_conn *conn, byte *pkt, uint len)
 {
   struct bgp_proto *p = conn->bgp;
 
@@ -1680,7 +1679,7 @@ bgp_rx_packet(struct bgp_conn *conn, byte *pkt, unsigned len)
  * bgp_rx_packet().
  */
 int
-bgp_rx(sock *sk, int size)
+bgp_rx(sock *sk, uint size)
 {
   struct bgp_conn *conn = sk->data;
   struct bgp_proto *p = conn->bgp;
diff --git a/proto/ospf/dbdes.c b/proto/ospf/dbdes.c
index 195b03ad..d6904343 100644
--- a/proto/ospf/dbdes.c
+++ b/proto/ospf/dbdes.c
@@ -39,7 +39,7 @@ struct ospf_dbdes3_packet
 
 
 static inline uint
-ospf_dbdes_hdrlen(struct ospf_proto *p)
+ospf_dbdes_hdrlen(struct ospf_proto *p UNUSED4 UNUSED6)
 {
   return ospf_is_v2(p) ?
     sizeof(struct ospf_dbdes2_packet) : sizeof(struct ospf_dbdes3_packet);
diff --git a/proto/ospf/hello.c b/proto/ospf/hello.c
index 50cf1407..e00487dc 100644
--- a/proto/ospf/hello.c
+++ b/proto/ospf/hello.c
@@ -222,9 +222,12 @@ ospf_receive_hello(struct ospf_packet *pkt, struct ospf_iface *ifa,
     rcv_priority = ps->priority;
 
     int pxlen = u32_masklen(ntohl(ps->netmask));
+    if (pxlen < 0)
+      DROP("prefix garbled", ntohl(ps->netmask));
+
     if ((ifa->type != OSPF_IT_VLINK) &&
 	(ifa->type != OSPF_IT_PTP) &&
-	(pxlen != ifa->addr->pxlen))
+	((uint) pxlen != ifa->addr->pxlen))
       DROP("prefix length mismatch", pxlen);
 
     neighbors = ps->neighbors;
diff --git a/proto/ospf/lsalib.c b/proto/ospf/lsalib.c
index 1bbd1372..cb7b186a 100644
--- a/proto/ospf/lsalib.c
+++ b/proto/ospf/lsalib.c
@@ -463,7 +463,7 @@ lsa_validate_sum3_net(struct ospf_lsa_header *lsa, struct ospf_lsa_sum3_net *bod
 }
 
 static int
-lsa_validate_sum3_rt(struct ospf_lsa_header *lsa, struct ospf_lsa_sum3_rt *body)
+lsa_validate_sum3_rt(struct ospf_lsa_header *lsa, struct ospf_lsa_sum3_rt *body UNUSED)
 {
   if (lsa->length != (HDRLEN + sizeof(struct ospf_lsa_sum3_rt)))
     return 0;
diff --git a/proto/ospf/lsalib.h b/proto/ospf/lsalib.h
index ae6af044..638b3525 100644
--- a/proto/ospf/lsalib.h
+++ b/proto/ospf/lsalib.h
@@ -41,7 +41,7 @@ void lsa_get_type_domain_(u32 itype, struct ospf_iface *ifa, u32 *otype, u32 *do
 static inline void lsa_get_type_domain(struct ospf_lsa_header *lsa, struct ospf_iface *ifa, u32 *otype, u32 *domain)
 { lsa_get_type_domain_(lsa->type_raw, ifa, otype, domain); }
 
-static inline u32 lsa_get_etype(struct ospf_lsa_header *h, struct ospf_proto *p)
+static inline u32 lsa_get_etype(struct ospf_lsa_header *h, struct ospf_proto *p UNUSED4 UNUSED6)
 { return ospf_is_v2(p) ? (h->type_raw & LSA_T_V2_MASK) : h->type_raw; }
 
 
diff --git a/proto/ospf/lsupd.c b/proto/ospf/lsupd.c
index c6a734ca..157d9628 100644
--- a/proto/ospf/lsupd.c
+++ b/proto/ospf/lsupd.c
@@ -105,7 +105,7 @@ ospf_dump_lsupd(struct ospf_proto *p, struct ospf_packet *pkt)
 
 
 static inline void
-ospf_lsa_lsrq_down(struct top_hash_entry *req, struct ospf_neighbor *n, struct ospf_neighbor *from)
+ospf_lsa_lsrq_down(struct top_hash_entry *req, struct ospf_neighbor *n)
 {
   if (req == n->lsrqi)
     n->lsrqi = SNODE_NEXT(req);
@@ -188,7 +188,7 @@ ospf_enqueue_lsa(struct ospf_proto *p, struct top_hash_entry *en, struct ospf_if
   {
     /* If we already have full queue, we send some packets */
     uint sent = ospf_flood_lsupd(p, ifa->flood_queue, ifa->flood_queue_used, ifa->flood_queue_used / 2, ifa);
-    int i;
+    uint i;
 
     for (i = 0; i < sent; i++)
       ifa->flood_queue[i]->ret_count--;
@@ -275,7 +275,7 @@ ospf_flood_lsa(struct ospf_proto *p, struct top_hash_entry *en, struct ospf_neig
 
 	  /* If same or newer, remove LSA from the link state request list */
 	  if (cmp > CMP_OLDER)
-	    ospf_lsa_lsrq_down(req, n, from);
+	    ospf_lsa_lsrq_down(req, n);
 
 	  /* If older or same, skip processing of this neighbor */
 	  if (cmp < CMP_NEWER)
diff --git a/proto/ospf/neighbor.c b/proto/ospf/neighbor.c
index 0223ccdf..9fe3c028 100644
--- a/proto/ospf/neighbor.c
+++ b/proto/ospf/neighbor.c
@@ -359,7 +359,7 @@ can_do_adj(struct ospf_neighbor *n)
 }
 
 
-static inline u32 neigh_get_id(struct ospf_proto *p, struct ospf_neighbor *n)
+static inline u32 neigh_get_id(struct ospf_proto *p UNUSED4 UNUSED6, struct ospf_neighbor *n)
 { return ospf_is_v2(p) ? ipa_to_u32(n->ip) : n->rid; }
 
 static struct ospf_neighbor *
diff --git a/proto/ospf/ospf.h b/proto/ospf/ospf.h
index a4e525ec..ca30e4e0 100644
--- a/proto/ospf/ospf.h
+++ b/proto/ospf/ospf.h
@@ -766,7 +766,7 @@ lsa_get_ipv6_addr(u32 *buf, ip_addr *addr)
 }
 
 static inline u32 *
-put_ipv6_prefix(u32 *buf, ip_addr addr, u8 pxlen, u8 pxopts, u16 lh)
+put_ipv6_prefix(u32 *buf, ip_addr addr UNUSED4, u8 pxlen UNUSED4, u8 pxopts UNUSED4, u16 lh UNUSED4)
 {
 #ifdef IPV6
   *buf++ = ((pxlen << 24) | (pxopts << 16) | lh);
@@ -840,7 +840,7 @@ static inline int ospf_is_v2(struct ospf_proto *p)
 static inline int ospf_is_v3(struct ospf_proto *p)
 { return ! p->ospf2; }
 */
-static inline int ospf_get_version(struct ospf_proto *p)
+static inline int ospf_get_version(struct ospf_proto *p UNUSED4 UNUSED6)
 { return ospf_is_v2(p) ? 2 : 3; }
 
 struct ospf_area *ospf_find_area(struct ospf_proto *p, u32 aid);
@@ -897,7 +897,7 @@ void ospf_sh_neigh_info(struct ospf_neighbor *n);
 /* packet.c */
 void ospf_pkt_fill_hdr(struct ospf_iface *ifa, void *buf, u8 h_type);
 uint ospf_pkt_maxsize(struct ospf_iface *ifa);
-int ospf_rx_hook(sock * sk, int size);
+int ospf_rx_hook(sock * sk, uint size);
 // void ospf_tx_hook(sock * sk);
 void ospf_err_hook(sock * sk, int err);
 void ospf_verr_hook(sock *sk, int err);
@@ -922,7 +922,7 @@ static inline void ospf_send_to_des(struct ospf_iface *ifa)
 #define SKIP(DSC) do { err_dsc = DSC; goto skip; } while(0)
 #endif
 
-static inline uint ospf_pkt_hdrlen(struct ospf_proto *p)
+static inline uint ospf_pkt_hdrlen(struct ospf_proto *p UNUSED4 UNUSED6)
 { return ospf_is_v2(p) ? (sizeof(struct ospf_packet) + sizeof(union ospf_auth)) : sizeof(struct ospf_packet); }
 
 static inline void * ospf_tx_buffer(struct ospf_iface *ifa)
diff --git a/proto/ospf/packet.c b/proto/ospf/packet.c
index 04f0d47c..aa90aa51 100644
--- a/proto/ospf/packet.c
+++ b/proto/ospf/packet.c
@@ -124,7 +124,7 @@ ospf_pkt_finalize(struct ospf_iface *ifa, struct ospf_packet *pkt)
 
 /* We assume OSPFv2 in ospf_pkt_checkauth() */
 static int
-ospf_pkt_checkauth(struct ospf_neighbor *n, struct ospf_iface *ifa, struct ospf_packet *pkt, int len)
+ospf_pkt_checkauth(struct ospf_neighbor *n, struct ospf_iface *ifa, struct ospf_packet *pkt, uint len)
 {
   struct ospf_proto *p = ifa->oa->po;
   union ospf_auth *auth = (void *) (pkt + 1);
@@ -214,7 +214,7 @@ ospf_pkt_checkauth(struct ospf_neighbor *n, struct ospf_iface *ifa, struct ospf_
  * non generic functions.
  */
 int
-ospf_rx_hook(sock *sk, int len)
+ospf_rx_hook(sock *sk, uint len)
 {
   /* We want just packets from sk->iface. Unfortunately, on BSD we cannot filter
      out other packets at kernel level and we receive all packets on all sockets */
diff --git a/proto/ospf/rt.c b/proto/ospf/rt.c
index cdf8012a..8b3feda9 100644
--- a/proto/ospf/rt.c
+++ b/proto/ospf/rt.c
@@ -1049,7 +1049,7 @@ check_sum_rt_lsa(struct ospf_proto *p, ort *nf)
 }
 
 static inline int
-decide_nssa_lsa(struct ospf_proto *p, ort *nf, struct ospf_lsa_ext_local *rt)
+decide_nssa_lsa(struct ospf_proto *p UNUSED4 UNUSED6, ort *nf, struct ospf_lsa_ext_local *rt)
 {
   struct ospf_area *oa = nf->n.oa;
   struct top_hash_entry *en = nf->n.en;
diff --git a/proto/ospf/topology.c b/proto/ospf/topology.c
index 7558d4a0..341eff87 100644
--- a/proto/ospf/topology.c
+++ b/proto/ospf/topology.c
@@ -515,7 +515,7 @@ ospf_update_lsadb(struct ospf_proto *p)
 
 
 static inline u32
-ort_to_lsaid(struct ospf_proto *p, ort *nf)
+ort_to_lsaid(struct ospf_proto *p UNUSED4 UNUSED6, ort *nf)
 {
   /*
    * In OSPFv2, We have to map IP prefixes to u32 in such manner that resulting
@@ -607,7 +607,7 @@ lsab_offset(struct ospf_proto *p, uint offset)
   return ((byte *) p->lsab) + offset;
 }
 
-static inline void *
+static inline void * UNUSED
 lsab_end(struct ospf_proto *p)
 {
   return ((byte *) p->lsab) + p->lsab_used;
@@ -1545,7 +1545,7 @@ static void
 add_link_lsa(struct ospf_proto *p, struct ospf_lsa_link *ll, int offset, int *pxc)
 {
   u32 *pxb = ll->rest;
-  int j;
+  uint j;
 
   for (j = 0; j < ll->pxcount; pxb = prefix_advance(pxb), j++)
   {
@@ -1748,7 +1748,7 @@ ospf_top_hash(struct top_graph *f, u32 domain, u32 lsaid, u32 rtrid, u32 type)
  * and request lists of OSPF neighbors.
  */
 struct top_graph *
-ospf_top_new(struct ospf_proto *p, pool *pool)
+ospf_top_new(struct ospf_proto *p UNUSED4 UNUSED6, pool *pool)
 {
   struct top_graph *f;
 
diff --git a/proto/radv/packets.c b/proto/radv/packets.c
index 3862af8d..4bf960c3 100644
--- a/proto/radv/packets.c
+++ b/proto/radv/packets.c
@@ -157,12 +157,12 @@ radv_process_domain(struct radv_dnssl_config *cf)
   char *dom = cf->domain;
   char *dom_end = dom; /* Just to  */
   u8 *dlen_save = &cf->dlen_first;
-  int len;
+  uint len;
 
   while (dom_end)
   {
     dom_end = strchr(dom, '.');
-    len = dom_end ? (dom_end - dom) : strlen(dom);
+    len = dom_end ? (uint)(dom_end - dom) : strlen(dom);
 
     if (len < 1 || len > 63)
       return -1;
@@ -348,7 +348,7 @@ radv_send_ra(struct radv_iface *ifa, int shutdown)
 
 
 static int
-radv_rx_hook(sock *sk, int size)
+radv_rx_hook(sock *sk, uint size)
 {
   struct radv_iface *ifa = sk->data;
   struct proto_radv *ra = ifa->ra;
diff --git a/proto/radv/radv.c b/proto/radv/radv.c
index 6370e006..5c52217d 100644
--- a/proto/radv/radv.c
+++ b/proto/radv/radv.c
@@ -240,7 +240,7 @@ radv_if_notify(struct proto *p, unsigned flags, struct iface *iface)
 }
 
 static void
-radv_ifa_notify(struct proto *p, unsigned flags, struct ifa *a)
+radv_ifa_notify(struct proto *p, unsigned flags UNUSED, struct ifa *a)
 {
   struct proto_radv *ra = (struct proto_radv *) p;
 
diff --git a/proto/radv/radv.h b/proto/radv/radv.h
index 48ba9c1a..e2bf07ba 100644
--- a/proto/radv/radv.h
+++ b/proto/radv/radv.h
@@ -84,7 +84,7 @@ struct radv_prefix_config
 {
   node n;
   ip_addr prefix;
-  int pxlen;
+  uint pxlen;
 
   u8 skip;			/* Do not include this prefix to RA */
   u8 onlink;			/* Standard options from RFC 4261 */
diff --git a/proto/rip/packets.c b/proto/rip/packets.c
index 9f10fd67..e026eaea 100644
--- a/proto/rip/packets.c
+++ b/proto/rip/packets.c
@@ -108,7 +108,7 @@ static inline uint rip_pkt_hdrlen(struct rip_iface *ifa)
 { return sizeof(struct rip_packet) + (ifa->cf->auth_type ? RIP_BLOCK_LENGTH : 0); }
 
 static inline void
-rip_put_block(struct rip_proto *p, byte *pos, struct rip_block *rte)
+rip_put_block(struct rip_proto *p UNUSED4 UNUSED6, byte *pos, struct rip_block *rte)
 {
   if (rip_is_v2(p))
   {
@@ -131,7 +131,7 @@ rip_put_block(struct rip_proto *p, byte *pos, struct rip_block *rte)
 }
 
 static inline void
-rip_put_next_hop(struct rip_proto *p, byte *pos, struct rip_block *rte)
+rip_put_next_hop(struct rip_proto *p UNUSED, byte *pos, struct rip_block *rte UNUSED4)
 {
   struct rip_block_ng *block = (void *) pos;
   block->prefix = ip6_hton(ipa_to_ip6(rte->next_hop));
@@ -141,7 +141,7 @@ rip_put_next_hop(struct rip_proto *p, byte *pos, struct rip_block *rte)
 }
 
 static inline int
-rip_get_block(struct rip_proto *p, byte *pos, struct rip_block *rte)
+rip_get_block(struct rip_proto *p UNUSED4 UNUSED6, byte *pos, struct rip_block *rte)
 {
   if (rip_is_v2(p))
   {
@@ -630,7 +630,7 @@ rip_receive_response(struct rip_proto *p, struct rip_iface *ifa, struct rip_pack
 }
 
 static int
-rip_rx_hook(sock *sk, int len)
+rip_rx_hook(sock *sk, uint len)
 {
   struct rip_iface *ifa = sk->data;
   struct rip_proto *p = ifa->rip;
diff --git a/proto/rip/rip.c b/proto/rip/rip.c
index 36527253..37cfa9ac 100644
--- a/proto/rip/rip.c
+++ b/proto/rip/rip.c
@@ -1027,7 +1027,7 @@ rip_prepare_attrs(struct linpool *pool, ea_list *next, u8 metric, u16 tag)
 }
 
 static int
-rip_import_control(struct proto *P, struct rte **rt, struct ea_list **attrs, struct linpool *pool)
+rip_import_control(struct proto *P UNUSED, struct rte **rt, struct ea_list **attrs, struct linpool *pool)
 {
   /* Prepare attributes with initial values */
   if ((*rt)->attrs->source != RTS_RIP)
@@ -1144,7 +1144,7 @@ rip_reconfigure(struct proto *P, struct proto_config *c)
 }
 
 static void
-rip_get_route_info(rte *rte, byte *buf, ea_list *attrs)
+rip_get_route_info(rte *rte, byte *buf, ea_list *attrs UNUSED)
 {
   buf += bsprintf(buf, " (%d/%d)", rte->pref, rte->u.rip.metric);
 
diff --git a/proto/static/static.c b/proto/static/static.c
index d54302a8..0c088cd7 100644
--- a/proto/static/static.c
+++ b/proto/static/static.c
@@ -250,7 +250,7 @@ static_add(struct proto *p, struct static_config *cf, struct static_route *r)
 }
 
 static void
-static_rte_cleanup(struct proto *p, struct static_route *r)
+static_rte_cleanup(struct proto *p UNUSED, struct static_route *r)
 {
   struct static_route *r2;
 
@@ -435,7 +435,7 @@ static_if_notify(struct proto *p, unsigned flags, struct iface *i)
 }
 
 int
-static_rte_mergable(rte *pri, rte *sec)
+static_rte_mergable(rte *pri UNUSED, rte *sec UNUSED)
 {
   return 1;
 }
diff --git a/sysdep/bsd/krt-sock.c b/sysdep/bsd/krt-sock.c
index f2ae81c3..9c9df51d 100644
--- a/sysdep/bsd/krt-sock.c
+++ b/sysdep/bsd/krt-sock.c
@@ -898,7 +898,7 @@ kif_do_scan(struct kif_proto *p)
 /* Kernel sockets */
 
 static int
-krt_sock_hook(sock *sk, int size UNUSED)
+krt_sock_hook(sock *sk, uint size UNUSED)
 {
   struct ks_msg msg;
   int l = read(sk->fd, (char *)&msg, sizeof(msg));
@@ -918,7 +918,7 @@ krt_sock_err_hook(sock *sk, int e UNUSED)
 }
 
 static sock *
-krt_sock_open(pool *pool, void *data, int table_id)
+krt_sock_open(pool *pool, void *data, int table_id UNUSED)
 {
   sock *sk;
   int fd;
@@ -1074,7 +1074,7 @@ kif_sys_shutdown(struct kif_proto *p)
 
 
 struct ifa *
-kif_get_primary_ip(struct iface *i)
+kif_get_primary_ip(struct iface *i UNUSED6)
 {
 #ifndef IPV6
   static int fd = -1;
diff --git a/sysdep/bsd/krt-sys.h b/sysdep/bsd/krt-sys.h
index a63f8caf..353ffcec 100644
--- a/sysdep/bsd/krt-sys.h
+++ b/sysdep/bsd/krt-sys.h
@@ -45,7 +45,7 @@ struct krt_state {
 static inline void krt_sys_io_init(void) { }
 static inline void krt_sys_init(struct krt_proto *p UNUSED) { }
 
-static inline int krt_sys_get_attr(eattr *a UNUSED, byte *buf UNUSED, int buflen UNUSED) { }
+static inline int krt_sys_get_attr(eattr *a UNUSED, byte *buf UNUSED, int buflen UNUSED) { return 0; }
 
 
 #endif
diff --git a/sysdep/bsd/sysio.h b/sysdep/bsd/sysio.h
index 6c20733f..8d87a3c3 100644
--- a/sysdep/bsd/sysio.h
+++ b/sysdep/bsd/sysio.h
@@ -28,7 +28,9 @@
 #endif
 
 
+#ifndef SA_LEN
 #define SA_LEN(x) (x).sa.sa_len
+#endif
 
 
 /*
@@ -133,12 +135,12 @@ sk_process_cmsg4_ttl(sock *s, struct cmsghdr *cm)
     s->rcv_ttl = * (byte *) CMSG_DATA(cm);
 }
 
+#ifdef IP_SENDSRCADDR
 static inline void
 sk_prepare_cmsgs4(sock *s, struct msghdr *msg, void *cbuf, size_t cbuflen)
 {
   /* Unfortunately, IP_SENDSRCADDR does not work for raw IP sockets on BSD kernels */
 
-#ifdef IP_SENDSRCADDR
   struct cmsghdr *cm;
   struct in_addr *sa;
   int controllen = 0;
@@ -156,10 +158,13 @@ sk_prepare_cmsgs4(sock *s, struct msghdr *msg, void *cbuf, size_t cbuflen)
   *sa = ipa_to_in4(s->saddr);
 
   msg->msg_controllen = controllen;
-#endif
 }
+#else
+static inline void
+sk_prepare_cmsgs4(sock *s UNUSED, struct msghdr *msg UNUSED, void *cbuf UNUSED, size_t cbuflen UNUSED) { }
+#endif
 
-static void
+static void UNUSED
 sk_prepare_ip_header(sock *s, void *hdr, int dlen)
 {
   struct ip *ip = hdr;
@@ -200,7 +205,7 @@ sk_prepare_ip_header(sock *s, void *hdr, int dlen)
 #endif
 
 int
-sk_set_md5_auth(sock *s, ip_addr local, ip_addr remote, struct iface *ifa, char *passwd, int setkey UNUSED)
+sk_set_md5_auth(sock *s, ip_addr local UNUSED, ip_addr remote UNUSED, struct iface *ifa UNUSED, char *passwd, int setkey UNUSED)
 {
 #ifdef USE_MD5SIG_SETKEY
   if (setkey)
@@ -235,20 +240,20 @@ sk_set_min_ttl4(sock *s, int ttl)
 }
 
 static inline int
-sk_set_min_ttl6(sock *s, int ttl)
+sk_set_min_ttl6(sock *s, int ttl UNUSED)
 {
   ERR_MSG("Kernel does not support IPv6 TTL security");
 }
 
 static inline int
-sk_disable_mtu_disc4(sock *s)
+sk_disable_mtu_disc4(sock *s UNUSED)
 {
   /* TODO: Set IP_DONTFRAG to 0 ? */
   return 0;
 }
 
 static inline int
-sk_disable_mtu_disc6(sock *s)
+sk_disable_mtu_disc6(sock *s UNUSED)
 {
   /* TODO: Set IPV6_DONTFRAG to 0 ? */
   return 0;
diff --git a/sysdep/linux/krt-sys.h b/sysdep/linux/krt-sys.h
index 6d6586d1..76ae29b7 100644
--- a/sysdep/linux/krt-sys.h
+++ b/sysdep/linux/krt-sys.h
@@ -27,7 +27,7 @@ static inline void kif_sys_postconfig(struct kif_config *c UNUSED) { }
 static inline void kif_sys_init_config(struct kif_config *c UNUSED) { }
 static inline void kif_sys_copy_config(struct kif_config *d UNUSED, struct kif_config *s UNUSED) { }
 
-static inline struct ifa * kif_get_primary_ip(struct iface *i) { return NULL; }
+static inline struct ifa * kif_get_primary_ip(struct iface *i UNUSED) { return NULL; }
 
 
 /* Kernel routes */
diff --git a/sysdep/linux/netlink.c b/sysdep/linux/netlink.c
index 79dd1405..368e0ef9 100644
--- a/sysdep/linux/netlink.c
+++ b/sysdep/linux/netlink.c
@@ -487,7 +487,7 @@ nl_parse_multipath(struct krt_proto *p, struct rtattr *ra)
   struct rtattr *a[BIRD_RTA_MAX];
   struct rtnexthop *nh = RTA_DATA(ra);
   struct mpnh *rv, *first, **last;
-  int len = RTA_PAYLOAD(ra);
+  unsigned len = RTA_PAYLOAD(ra);
 
   first = NULL;
   last = &first;
@@ -1473,7 +1473,7 @@ nl_async_msg(struct nlmsghdr *h)
 }
 
 static int
-nl_async_hook(sock *sk, int size UNUSED)
+nl_async_hook(sock *sk, uint size UNUSED)
 {
   struct iovec iov = { nl_async_rx_buffer, NL_RX_SIZE };
   struct sockaddr_nl sa;
diff --git a/sysdep/unix/io.c b/sysdep/unix/io.c
index 3ceadd98..873b5805 100644
--- a/sysdep/unix/io.c
+++ b/sysdep/unix/io.c
@@ -507,11 +507,11 @@ tm_format_datetime(char *x, struct timeformat *fmt_spec, bird_clock_t t)
  *	Sockaddr helper functions
  */
 
-static inline int sockaddr_length(int af)
+static inline int UNUSED sockaddr_length(int af)
 { return (af == AF_INET) ? sizeof(struct sockaddr_in) : sizeof(struct sockaddr_in6); }
 
 static inline void
-sockaddr_fill4(struct sockaddr_in *sa, ip_addr a, struct iface *ifa, uint port)
+sockaddr_fill4(struct sockaddr_in *sa, ip_addr a, uint port)
 {
   memset(sa, 0, sizeof(struct sockaddr_in));
 #ifdef HAVE_SIN_LEN
@@ -542,7 +542,7 @@ void
 sockaddr_fill(sockaddr *sa, int af, ip_addr a, struct iface *ifa, uint port)
 {
   if (af == AF_INET)
-    sockaddr_fill4((struct sockaddr_in *) sa, a, ifa, port);
+    sockaddr_fill4((struct sockaddr_in *) sa, a, port);
   else if (af == AF_INET6)
     sockaddr_fill6((struct sockaddr_in6 *) sa, a, ifa, port);
   else
@@ -550,7 +550,7 @@ sockaddr_fill(sockaddr *sa, int af, ip_addr a, struct iface *ifa, uint port)
 }
 
 static inline void
-sockaddr_read4(struct sockaddr_in *sa, ip_addr *a, struct iface **ifa, uint *port)
+sockaddr_read4(struct sockaddr_in *sa, ip_addr *a, uint *port)
 {
   *port = ntohs(sa->sin_port);
   *a = ipa_from_in4(sa->sin_addr);
@@ -573,7 +573,7 @@ sockaddr_read(sockaddr *sa, int af, ip_addr *a, struct iface **ifa, uint *port)
     goto fail;
 
   if (af == AF_INET)
-    sockaddr_read4((struct sockaddr_in *) sa, a, ifa, port);
+    sockaddr_read4((struct sockaddr_in *) sa, a, port);
   else if (af == AF_INET6)
     sockaddr_read6((struct sockaddr_in6 *) sa, a, ifa, port);
   else
@@ -770,7 +770,7 @@ sk_set_tos6(sock *s, int tos)
 }
 
 static inline int
-sk_set_high_port(sock *s)
+sk_set_high_port(sock *s UNUSED)
 {
   /* Port range setting is optional, ignore it if not supported */
 
diff --git a/sysdep/unix/krt.c b/sysdep/unix/krt.c
index ef98cb3a..07a55c0d 100644
--- a/sysdep/unix/krt.c
+++ b/sysdep/unix/krt.c
@@ -909,7 +909,7 @@ krt_scan_timer_start(struct krt_proto *p)
 }
 
 static void
-krt_scan_timer_stop(struct krt_proto *p)
+krt_scan_timer_stop(struct krt_proto *p UNUSED)
 {
   krt_scan_count--;
 
@@ -998,7 +998,7 @@ krt_store_tmp_attrs(rte *rt, struct ea_list *attrs)
 }
 
 static int
-krt_import_control(struct proto *P, rte **new, ea_list **attrs, struct linpool *pool)
+krt_import_control(struct proto *P, rte **new, ea_list **attrs UNUSED, struct linpool *pool UNUSED)
 {
   struct krt_proto *p = (struct krt_proto *) P;
   rte *e = *new;
diff --git a/sysdep/unix/main.c b/sysdep/unix/main.c
index a7989920..35bc3fd1 100644
--- a/sysdep/unix/main.c
+++ b/sysdep/unix/main.c
@@ -73,7 +73,7 @@ async_dump(void)
 #else
 
 static inline void
-drop_uid(uid_t uid)
+drop_uid(uid_t uid UNUSED)
 {
   die("Cannot change user on this platform");
 }
@@ -419,7 +419,7 @@ cli_get_command(cli *c)
 }
 
 static int
-cli_rx(sock *s, int size UNUSED)
+cli_rx(sock *s, uint size UNUSED)
 {
   cli_kick(s->data);
   return 0;
@@ -439,7 +439,7 @@ cli_err(sock *s, int err)
 }
 
 static int
-cli_connect(sock *s, int size UNUSED)
+cli_connect(sock *s, uint size UNUSED)
 {
   cli *c;
 
diff --git a/sysdep/unix/unix.h b/sysdep/unix/unix.h
index 4e0ff841..3ef2e3ef 100644
--- a/sysdep/unix/unix.h
+++ b/sysdep/unix/unix.h
@@ -63,16 +63,16 @@ typedef struct sockaddr_bird {
 #endif
 
 
-static inline ip_addr ipa_from_in4(struct in_addr a)
+static inline ip_addr ipa_from_in4(struct in_addr a UNUSED6)
 { return ipa_from_u32(ntohl(a.s_addr)); }
 
-static inline ip_addr ipa_from_in6(struct in6_addr a)
+static inline ip_addr ipa_from_in6(struct in6_addr a UNUSED4)
 { return ipa_build6(ntohl(a.s6_addr32[0]), ntohl(a.s6_addr32[1]), ntohl(a.s6_addr32[2]), ntohl(a.s6_addr32[3])); }
 
-static inline ip_addr ipa_from_sa4(sockaddr *sa)
+static inline ip_addr ipa_from_sa4(sockaddr *sa UNUSED6)
 { return ipa_from_in4(((struct sockaddr_in *) sa)->sin_addr); }
 
-static inline ip_addr ipa_from_sa6(sockaddr *sa)
+static inline ip_addr ipa_from_sa6(sockaddr *sa UNUSED4)
 { return ipa_from_in6(((struct sockaddr_in6 *) sa)->sin6_addr); }
 
 static inline struct in_addr ipa_to_in4(ip_addr a)
@@ -83,7 +83,7 @@ static inline struct in6_addr ipa_to_in6(ip_addr a)
 { return (struct in6_addr) { .s6_addr32 = { htonl(_I0(a)), htonl(_I1(a)), htonl(_I2(a)), htonl(_I3(a)) } }; }
 #else
 /* Temporary dummy */
-static inline struct in6_addr ipa_to_in6(ip_addr a)
+static inline struct in6_addr ipa_to_in6(ip_addr a UNUSED)
 { return (struct in6_addr) { .s6_addr32 = { 0, 0, 0, 0 } }; }
 #endif
 

From 7eec3988758cb4c19a0ab3bf90cab2a4914165be Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Tue, 1 Nov 2016 16:18:27 +0100
Subject: [PATCH 151/165] BSD: Fix build on OpenBSD broken by previous commit

---
 sysdep/bsd/sysio.h | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/sysdep/bsd/sysio.h b/sysdep/bsd/sysio.h
index 8d87a3c3..2610a47b 100644
--- a/sysdep/bsd/sysio.h
+++ b/sysdep/bsd/sysio.h
@@ -28,9 +28,8 @@
 #endif
 
 
-#ifndef SA_LEN
+#undef  SA_LEN
 #define SA_LEN(x) (x).sa.sa_len
-#endif
 
 
 /*

From de2a27e255b6ec834d11c005909b28a150c7c0db Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Tue, 25 Oct 2016 17:04:17 +0200
Subject: [PATCH 152/165] Add generic message authentication interface

Add generic interface for generating and verifying MACs (message
authentication codes). Replace multiple HMAC implementation with
a generic one.
---
 lib/Doc             |   1 +
 lib/Modules         |   2 +
 lib/mac.c           | 289 ++++++++++++++++++++++++++++++++++++++++++++
 lib/mac.h           | 117 ++++++++++++++++++
 lib/md5.c           |  81 ++-----------
 lib/md5.h           |  21 +---
 lib/sha1.c          |  95 ++-------------
 lib/sha1.h          |  30 +----
 lib/sha256.c        | 150 +++--------------------
 lib/sha256.h        |  42 ++-----
 lib/sha512.c        | 150 +++--------------------
 lib/sha512.h        |  44 ++-----
 nest/password.c     |   2 +-
 nest/password.h     |   2 +-
 proto/ospf/packet.c |   5 +-
 proto/rip/packets.c |   5 +-
 16 files changed, 493 insertions(+), 543 deletions(-)
 create mode 100644 lib/mac.c
 create mode 100644 lib/mac.h

diff --git a/lib/Doc b/lib/Doc
index 8af1c669..632bf1f6 100644
--- a/lib/Doc
+++ b/lib/Doc
@@ -2,6 +2,7 @@ H Library functions
 S ip.c
 S lists.c
 S checksum.c bitops.c patmatch.c printf.c xmalloc.c tbf.c
+S mac.c
 D resource.sgml
 S resource.c
 S mempool.c
diff --git a/lib/Modules b/lib/Modules
index 745306d9..0e30b488 100644
--- a/lib/Modules
+++ b/lib/Modules
@@ -11,6 +11,8 @@ ip.h
 ip.c
 lists.c
 lists.h
+mac.c
+mac.h
 md5.c
 md5.h
 mempool.c
diff --git a/lib/mac.c b/lib/mac.c
new file mode 100644
index 00000000..977d6559
--- /dev/null
+++ b/lib/mac.c
@@ -0,0 +1,289 @@
+/*
+ *	BIRD Library -- Message Authentication Codes
+ *
+ *	(c) 2016 Ondrej Zajicek <santiago@crfreenet.org>
+ *	(c) 2016 CZ.NIC z.s.p.o.
+ *
+ *	Can be freely distributed and used under the terms of the GNU GPL.
+ */
+
+/**
+ * DOC: Message authentication codes
+ *
+ * MAC algorithms are simple cryptographic tools for message authentication.
+ * They use shared a secret key a and message text to generate authentication
+ * code, which is then passed with the message to the other side, where the code
+ * is verified. There are multiple families of MAC algorithms based on different
+ * cryptographic primitives, BIRD implements two MAC families which use hash
+ * functions.
+ *
+ * The first family is simply a cryptographic hash camouflaged as MAC algorithm.
+ * Originally supposed to be (m|k)-hash (message is concatenated with key, and
+ * that is hashed), but later it turned out that a raw hash is more practical.
+ * This is used for cryptographic authentication in OSPFv2, RIP and BFD.
+ *
+ * The second family is the standard HMAC (RFC 2104), using inner and outer hash
+ * to process key and message. HMAC (with SHA) is used in advanced OSPF and RIP
+ * authentication (RFC 5709, RFC 4822).
+ */
+
+#include "lib/mac.h"
+#include "lib/md5.h"
+#include "lib/sha1.h"
+#include "lib/sha256.h"
+#include "lib/sha512.h"
+
+
+/*
+ *	Internal hash calls
+ */
+
+static inline void
+hash_init(struct mac_context *mctx, struct hash_context *hctx)
+{ mctx->type->hash_init(hctx); }
+
+static inline void
+hash_update(struct mac_context *mctx, struct hash_context *hctx, const byte *buf, uint len)
+{ mctx->type->hash_update(hctx, buf, len); }
+
+static inline byte *
+hash_final(struct mac_context *mctx, struct hash_context *hctx)
+{ return mctx->type->hash_final(hctx); }
+
+static inline void
+hash_buffer(struct mac_context *mctx, byte *outbuf, const byte *buffer, uint length)
+{
+  struct hash_context hctx;
+
+  hash_init(mctx, &hctx);
+  hash_update(mctx, &hctx, buffer, length);
+  memcpy(outbuf, hash_final(mctx, &hctx), mctx->type->hash_size);
+}
+
+
+/*
+ *	(not-really-MAC) Hash
+ */
+
+static void
+nrmh_init(struct mac_context *ctx, const byte *key UNUSED, uint keylen UNUSED)
+{
+  struct nrmh_context *ct = (void *) ctx;
+  hash_init(ctx, &ct->ictx);
+}
+
+static void
+nrmh_update(struct mac_context *ctx, const byte *data, uint datalen)
+{
+  struct nrmh_context *ct = (void *) ctx;
+  hash_update(ctx, &ct->ictx, data, datalen);
+}
+
+static byte *
+nrmh_final(struct mac_context *ctx)
+{
+  struct nrmh_context *ct = (void *) ctx;
+  return hash_final(ctx, &ct->ictx);
+}
+
+
+/*
+ *	HMAC
+ */
+
+static void
+hmac_init(struct mac_context *ctx, const byte *key, uint keylen)
+{
+  struct hmac_context *ct = (void *) ctx;
+  uint block_size = ctx->type->block_size;
+  uint hash_size = ctx->type->hash_size;
+
+  byte *keybuf = alloca(block_size);
+  byte *buf = alloca(block_size);
+  uint i;
+
+  /* Hash the key if necessary */
+  if (keylen <= block_size)
+  {
+    memcpy(keybuf, key, keylen);
+    memset(keybuf + keylen, 0, block_size - keylen);
+  }
+  else
+  {
+    hash_buffer(ctx, keybuf, key, keylen);
+    memset(keybuf + hash_size, 0, block_size - hash_size);
+  }
+
+  /* Initialize the inner digest */
+  hash_init(ctx, &ct->ictx);
+  for (i = 0; i < block_size; i++)
+    buf[i] = keybuf[i] ^ 0x36;
+  hash_update(ctx, &ct->ictx, buf, block_size);
+
+  /* Initialize the outer digest */
+  hash_init(ctx, &ct->octx);
+  for (i = 0; i < block_size; i++)
+    buf[i] = keybuf[i] ^ 0x5c;
+  hash_update(ctx, &ct->octx, buf, block_size);
+}
+
+static void
+hmac_update(struct mac_context *ctx, const byte *data, uint datalen)
+{
+  struct hmac_context *ct = (void *) ctx;
+
+  /* Just update the inner digest */
+  hash_update(ctx, &ct->ictx, data, datalen);
+}
+
+static byte *
+hmac_final(struct mac_context *ctx)
+{
+  struct hmac_context *ct = (void *) ctx;
+
+  /* Finish the inner digest */
+  byte *isha = hash_final(ctx, &ct->ictx);
+
+  /* Finish the outer digest */
+  hash_update(ctx, &ct->octx, isha, ctx->type->hash_size);
+  return hash_final(ctx, &ct->octx);
+}
+
+
+/*
+ *	Common code
+ */
+
+#define HASH_DESC(name, px, PX) \
+  { name, PX##_SIZE, sizeof(struct nrmh_context), nrmh_init, nrmh_update, nrmh_final, \
+    PX##_SIZE, PX##_BLOCK_SIZE, px##_init, px##_update, px##_final }
+
+#define HMAC_DESC(name, px, PX)						\
+  { name, PX##_SIZE, sizeof(struct hmac_context), hmac_init, hmac_update, hmac_final, \
+    PX##_SIZE, PX##_BLOCK_SIZE, px##_init, px##_update, px##_final }
+
+const struct mac_desc mac_table[ALG_MAX] = {
+  [ALG_MD5] =		HASH_DESC("Keyed MD5",		md5,	MD5),
+  [ALG_SHA1] =		HASH_DESC("Keyed SHA-1",	sha1,	SHA1),
+  [ALG_SHA224] =	HASH_DESC("Keyed SHA-224",	sha224,	SHA224),
+  [ALG_SHA256] = 	HASH_DESC("Keyed SHA-256",	sha256,	SHA256),
+  [ALG_SHA384] = 	HASH_DESC("Keyed SHA-384",	sha384,	SHA384),
+  [ALG_SHA512] = 	HASH_DESC("Keyed SHA-512",	sha512,	SHA512),
+  [ALG_HMAC_MD5] = 	HMAC_DESC("HMAC-MD5",		md5,	MD5),
+  [ALG_HMAC_SHA1] = 	HMAC_DESC("HMAC-SHA-1",		sha1,	SHA1),
+  [ALG_HMAC_SHA224] = 	HMAC_DESC("HMAC-SHA-224",	sha224,	SHA224),
+  [ALG_HMAC_SHA256] = 	HMAC_DESC("HMAC-SHA-256",	sha256,	SHA256),
+  [ALG_HMAC_SHA384] = 	HMAC_DESC("HMAC-SHA-384",	sha384,	SHA384),
+  [ALG_HMAC_SHA512] = 	HMAC_DESC("HMAC-SHA-512",	sha512,	SHA512),
+};
+
+
+/**
+ * mac_init - initialize MAC algorithm
+ * @ctx: context to initialize
+ * @id: MAC algorithm ID
+ * @key: MAC key
+ * @keylen: MAC key length
+ *
+ * Initialize MAC context @ctx for algorithm @id (e.g., %ALG_HMAC_SHA1), with
+ * key @key of length @keylen. After that, message data could be added using
+ * mac_update() function.
+ */
+void
+mac_init(struct mac_context *ctx, uint id, const byte *key, uint keylen)
+{
+  ctx->type = &mac_table[id];
+  ctx->type->init(ctx, key, keylen);
+}
+
+#if 0
+/**
+ * mac_update - add more data to MAC algorithm
+ * @ctx: MAC context
+ * @data: data to add
+ * @datalen: length of data
+ *
+ * Push another @datalen bytes of data pointed to by @data into the MAC
+ * algorithm currently in @ctx. Can be called multiple times for the same MAC
+ * context. It has the same effect as concatenating all the data together and
+ * passing them at once.
+ */
+void mac_update(struct mac_context *ctx, const byte *data, uint datalen)
+{ DUMMY; }
+
+/**
+ * mac_final - finalize MAC algorithm
+ * @ctx: MAC context
+ *
+ * Finish MAC computation and return a pointer to the result. No more
+ * @mac_update() calls could be done, but the context may be reinitialized
+ * later.
+ *
+ * Note that the returned pointer points into data in the @ctx context. If it
+ * ceases to exist, the pointer becomes invalid.
+ */
+byte *mac_final(struct mac_context *ctx)
+{ DUMMY; }
+
+/**
+ * mac_cleanup - cleanup MAC context
+ * @ctx: MAC context
+ *
+ * Cleanup MAC context after computation (by filling with zeros). Not strictly
+ * necessary, just to erase sensitive data from stack. This also invalidates the
+ * pointer returned by @mac_final().
+ */
+void mac_cleanup(struct mac_context *ctx)
+{ DUMMY; }
+
+#endif
+
+/**
+ * mac_fill - compute and fill MAC
+ * @id: MAC algorithm ID
+ * @key: secret key
+ * @keylen: key length
+ * @data: message data
+ * @datalen: message length
+ * @mac: place to fill MAC
+ *
+ * Compute MAC for specified key @key and message @data using algorithm @id and
+ * copy it to buffer @mac. mac_fill() is a shortcut function doing all usual
+ * steps for transmitted messages.
+ */
+void
+mac_fill(uint id, const byte *key, uint keylen, const byte *data, uint datalen, byte *mac)
+{
+  struct mac_context ctx;
+
+  mac_init(&ctx, id, key, keylen);
+  mac_update(&ctx, data, datalen);
+  memcpy(mac, mac_final(&ctx), mac_get_length(&ctx));
+  mac_cleanup(&ctx);
+}
+
+/**
+ * mac_verify - compute and verify MAC
+ * @id: MAC algorithm ID
+ * @key: secret key
+ * @keylen: key length
+ * @data: message data
+ * @datalen: message length
+ * @mac: received MAC
+ *
+ * Compute MAC for specified key @key and message @data using algorithm @id and
+ * compare it with received @mac, return whether they are the same. mac_verify()
+ * is a shortcut function doing all usual steps for received messages.
+ */
+int
+mac_verify(uint id, const byte *key, uint keylen, const byte *data, uint datalen, const byte *mac)
+{
+  struct mac_context ctx;
+
+  mac_init(&ctx, id, key, keylen);
+  mac_update(&ctx, data, datalen);
+  int res = !memcmp(mac, mac_final(&ctx), mac_get_length(&ctx));
+  mac_cleanup(&ctx);
+
+  return res;
+}
diff --git a/lib/mac.h b/lib/mac.h
new file mode 100644
index 00000000..9dba8f89
--- /dev/null
+++ b/lib/mac.h
@@ -0,0 +1,117 @@
+/*
+ *	BIRD Library -- Message Authentication Codes
+ *
+ *	(c) 2016 Ondrej Zajicek <santiago@crfreenet.org>
+ *	(c) 2016 CZ.NIC z.s.p.o.
+ *
+ *	Can be freely distributed and used under the terms of the GNU GPL.
+ */
+
+#ifndef _BIRD_MAC_H_
+#define _BIRD_MAC_H_
+
+#include "nest/bird.h"
+#include "lib/sha512.h"
+
+
+#define ALG_UNDEFINED		0
+#define ALG_MD5			0x01
+#define ALG_SHA1		0x02
+#define ALG_SHA224		0x03
+#define ALG_SHA256		0x04
+#define ALG_SHA384		0x05
+#define ALG_SHA512		0x06
+#define ALG_HMAC_MD5		0x11
+#define ALG_HMAC_SHA1		0x12
+#define ALG_HMAC_SHA224		0x13
+#define ALG_HMAC_SHA256		0x14
+#define ALG_HMAC_SHA384		0x15
+#define ALG_HMAC_SHA512		0x16
+#define ALG_MAX			0x17
+
+/* These are maximums for HASH/MAC lengths and required context space */
+#define MAX_HASH_SIZE		SHA512_SIZE
+#define HASH_STORAGE		sizeof(struct sha512_context)
+#define MAC_STORAGE		sizeof(struct hmac_context)
+
+/* Generic context used by hash functions */
+struct hash_context
+{
+  u8 data[HASH_STORAGE];
+  u64 align[0];
+};
+
+/* Context for embedded hash (not-really-MAC hash) */
+struct nrmh_context {
+  const struct mac_desc *type;
+  struct hash_context ictx;
+};
+
+/* Context for hash based HMAC */
+struct hmac_context {
+  const struct mac_desc *type;
+  struct hash_context ictx;
+  struct hash_context octx;
+};
+
+/* Generic context used by MAC functions */
+struct mac_context
+{
+  const struct mac_desc *type;
+  u8 data[MAC_STORAGE - sizeof(void *)];
+  u64 align[0];
+};
+
+/* Union to satisfy C aliasing rules */
+union mac_context_union {
+  struct mac_context mac;
+  struct nrmh_context nrmh;
+  struct hmac_context hmac;
+};
+
+
+struct mac_desc {
+  const char *name;			/* Name of MAC algorithm */
+  uint mac_length;			/* Length of authentication code */
+  uint ctx_length;			/* Length of algorithm context */
+  void (*init)(struct mac_context *ctx, const byte *key, uint keylen);
+  void (*update)(struct mac_context *ctx, const byte *data, uint datalen);
+  byte *(*final)(struct mac_context *ctx);
+
+  uint hash_size;			/* Hash length, for hash-based MACs */
+  uint block_size;			/* Hash block size, for hash-based MACs */
+  void (*hash_init)(struct hash_context *ctx);
+  void (*hash_update)(struct hash_context *ctx, const byte *data, uint datalen);
+  byte *(*hash_final)(struct hash_context *ctx);
+};
+
+const struct mac_desc mac_table[ALG_MAX];
+
+static inline const char *mac_type_name(uint id)
+{ return mac_table[id].name; }
+
+static inline uint mac_type_length(uint id)
+{ return mac_table[id].mac_length; }
+
+static inline const char *mac_get_name(struct mac_context *ctx)
+{ return ctx->type->name; }
+
+static inline uint mac_get_length(struct mac_context *ctx)
+{ return ctx->type->mac_length; }
+
+void mac_init(struct mac_context *ctx, uint id, const byte *key, uint keylen);
+
+static inline void mac_update(struct mac_context *ctx, const byte *data, uint datalen)
+{ ctx->type->update(ctx, data, datalen); }
+
+static inline byte *mac_final(struct mac_context *ctx)
+{ return ctx->type->final(ctx); }
+
+static inline void mac_cleanup(struct mac_context *ctx)
+{ memset(ctx, 0, ctx->type->ctx_length); }
+
+void mac_fill(uint id, const byte *key, uint keylen, const byte *data, uint datalen, byte *mac);
+int mac_verify(uint id, const byte *key, uint keylen, const byte *data, uint datalen, const byte *mac);
+
+
+#endif /* _BIRD_MAC_H_ */
diff --git a/lib/md5.c b/lib/md5.c
index 8efa62d6..df49de5d 100644
--- a/lib/md5.c
+++ b/lib/md5.c
@@ -39,8 +39,10 @@ static void md5_transform(u32 buf[4], u32 const in[16]);
  * initialization constants.
  */
 void
-md5_init(struct md5_context *ctx)
+md5_init(struct hash_context *CTX)
 {
+  struct md5_context *ctx = (void *) CTX;
+
   ctx->buf[0] = 0x67452301;
   ctx->buf[1] = 0xefcdab89;
   ctx->buf[2] = 0x98badcfe;
@@ -55,8 +57,9 @@ md5_init(struct md5_context *ctx)
  * of bytes.
  */
 void
-md5_update(struct md5_context *ctx, const byte *buf, uint len)
+md5_update(struct hash_context *CTX, const byte *buf, uint len)
 {
+  struct md5_context *ctx = (void *) CTX;
   u32 t;
 
   /* Update bitcount */
@@ -105,8 +108,9 @@ md5_update(struct md5_context *ctx, const byte *buf, uint len)
  * 1 0* (64-bit count of bits processed, MSB-first)
  */
 byte *
-md5_final(struct md5_context *ctx)
+md5_final(struct hash_context *CTX)
 {
+  struct md5_context *ctx = (void *) CTX;
   uint count;
   byte *p;
 
@@ -149,13 +153,6 @@ md5_final(struct md5_context *ctx)
   return (byte*) ctx->buf;
 }
 
-/* I am a hard paranoid */
-void
-md5_erase_ctx(struct md5_context *ctx)
-{
-  memset((char *) ctx, 0, sizeof(*ctx));	/* In case it's sensitive */
-}
-
 /* The four core functions - F1 is optimized somewhat */
 
 /* #define F1(x, y, z) (x & y | ~x & z) */
@@ -256,67 +253,3 @@ md5_transform(u32 buf[4], u32 const in[16])
   buf[2] += c;
   buf[3] += d;
 }
-
-
-/*
- * 	MD5-HMAC
- */
-
-static void
-md5_hash_buffer(byte *outbuf, const byte *buffer, size_t length)
-{
-  struct md5_context hd_tmp;
-
-  md5_init(&hd_tmp);
-  md5_update(&hd_tmp, buffer, length);
-  memcpy(outbuf, md5_final(&hd_tmp), MD5_SIZE);
-}
-
-void
-md5_hmac_init(struct md5_hmac_context *ctx, const byte *key, size_t keylen)
-{
-  byte keybuf[MD5_BLOCK_SIZE], buf[MD5_BLOCK_SIZE];
-
-  /* Hash the key if necessary */
-  if (keylen <= MD5_BLOCK_SIZE)
-  {
-    memcpy(keybuf, key, keylen);
-    bzero(keybuf + keylen, MD5_BLOCK_SIZE - keylen);
-  }
-  else
-  {
-    md5_hash_buffer(keybuf, key, keylen);
-    bzero(keybuf + MD5_SIZE, MD5_BLOCK_SIZE - MD5_SIZE);
-  }
-
-  /* Initialize the inner digest */
-  md5_init(&ctx->ictx);
-  int i;
-  for (i = 0; i < MD5_BLOCK_SIZE; i++)
-    buf[i] = keybuf[i] ^ 0x36;
-  md5_update(&ctx->ictx, buf, MD5_BLOCK_SIZE);
-
-  /* Initialize the outer digest */
-  md5_init(&ctx->octx);
-  for (i = 0; i < MD5_BLOCK_SIZE; i++)
-    buf[i] = keybuf[i] ^ 0x5c;
-  md5_update(&ctx->octx, buf, MD5_BLOCK_SIZE);
-}
-
-void
-md5_hmac_update(struct md5_hmac_context *ctx, const byte *buf, size_t buflen)
-{
-  /* Just update the inner digest */
-  md5_update(&ctx->ictx, buf, buflen);
-}
-
-byte *
-md5_hmac_final(struct md5_hmac_context *ctx)
-{
-  /* Finish the inner digest */
-  byte *isha = md5_final(&ctx->ictx);
-
-  /* Finish the outer digest */
-  md5_update(&ctx->octx, isha, MD5_SIZE);
-  return md5_final(&ctx->octx);
-}
diff --git a/lib/md5.h b/lib/md5.h
index 034d764c..4e001851 100644
--- a/lib/md5.h
+++ b/lib/md5.h
@@ -19,29 +19,18 @@
 #define MD5_BLOCK_SIZE		64
 
 
+struct hash_context;
+
 struct md5_context {
   u32 buf[4];
   u32 bits[2];
   byte in[64];
 };
 
-void md5_init(struct md5_context *ctx);
-void md5_update(struct md5_context *ctx, const byte *buf, uint len);
-byte *md5_final(struct md5_context *ctx);
-
-
-/*
- *	HMAC-MD5
- */
-
-struct md5_hmac_context {
-  struct md5_context ictx;
-  struct md5_context octx;
-};
 
-void md5_hmac_init(struct md5_hmac_context *ctx, const byte *key, size_t keylen);
-void md5_hmac_update(struct md5_hmac_context *ctx, const byte *buf, size_t buflen);
-byte *md5_hmac_final(struct md5_hmac_context *ctx);
+void md5_init(struct hash_context *ctx);
+void md5_update(struct hash_context *ctx, const byte *buf, uint len);
+byte *md5_final(struct hash_context *ctx);
 
 
 #endif /* _BIRD_MD5_H_ */
diff --git a/lib/sha1.c b/lib/sha1.c
index 73b4b280..d6298b89 100644
--- a/lib/sha1.c
+++ b/lib/sha1.c
@@ -1,5 +1,5 @@
 /*
- *	BIRD Library -- SHA-1 Hash Function (FIPS 180-1, RFC 3174) and HMAC-SHA-1
+ *	BIRD Library -- SHA-1 Hash Function (FIPS 180-1, RFC 3174)
  *
  *	(c) 2015 CZ.NIC z.s.p.o.
  *
@@ -17,8 +17,10 @@
 
 
 void
-sha1_init(struct sha1_context *ctx)
+sha1_init(struct hash_context *CTX)
 {
+  struct sha1_context *ctx = (void *) CTX;
+
   ctx->h0 = 0x67452301;
   ctx->h1 = 0xefcdab89;
   ctx->h2 = 0x98badcfe;
@@ -167,8 +169,10 @@ sha1_transform(struct sha1_context *ctx, const byte *data)
  * Update the message digest with the contents of BUF with length LEN.
  */
 void
-sha1_update(struct sha1_context *ctx, const byte *buf, uint len)
+sha1_update(struct hash_context *CTX, const byte *buf, uint len)
 {
+  struct sha1_context *ctx = (void *) CTX;
+
   if (ctx->count)
   {
     /* Fill rest of internal buffer */
@@ -209,11 +213,12 @@ sha1_update(struct sha1_context *ctx, const byte *buf, uint len)
  * Returns: 20 bytes representing the digest.
  */
 byte *
-sha1_final(struct sha1_context *ctx)
+sha1_final(struct hash_context *CTX)
 {
+  struct sha1_context *ctx = (void *) CTX;
   u32 t, msb, lsb;
 
-  sha1_update(ctx, NULL, 0);	/* flush */
+  sha1_update(CTX, NULL, 0);	/* flush */
 
   t = ctx->nblocks;
   /* multiply by 64 to make a byte count */
@@ -242,7 +247,7 @@ sha1_final(struct sha1_context *ctx)
     ctx->buf[ctx->count++] = 0x80; /* pad character */
     while (ctx->count < 64)
       ctx->buf[ctx->count++] = 0;
-    sha1_update(ctx, NULL, 0);	/* flush */
+    sha1_update(CTX, NULL, 0);	/* flush */
     memset(ctx->buf, 0, 56); /* fill next block with zeroes */
   }
 
@@ -268,81 +273,3 @@ sha1_final(struct sha1_context *ctx)
 
   return ctx->buf;
 }
-
-
-/*
- *	SHA1-HMAC
- */
-
-/*
- * Shortcut function which puts the hash value of the supplied buffer
- * into outbuf which must have a size of 20 bytes.
- */
-void
-sha1_hash_buffer(byte *outbuf, const byte *buffer, uint length)
-{
-  struct sha1_context ctx;
-
-  sha1_init(&ctx);
-  sha1_update(&ctx, buffer, length);
-  memcpy(outbuf, sha1_final(&ctx), SHA1_SIZE);
-}
-
-void
-sha1_hmac_init(struct sha1_hmac_context *ctx, const byte *key, uint keylen)
-{
-  byte keybuf[SHA1_BLOCK_SIZE], buf[SHA1_BLOCK_SIZE];
-
-  /* Hash the key if necessary */
-  if (keylen <= SHA1_BLOCK_SIZE)
-  {
-    memcpy(keybuf, key, keylen);
-    memset(keybuf + keylen, 0, SHA1_BLOCK_SIZE - keylen);
-  }
-  else
-  {
-    sha1_hash_buffer(keybuf, key, keylen);
-    memset(keybuf + SHA1_SIZE, 0, SHA1_BLOCK_SIZE - SHA1_SIZE);
-  }
-
-  /* Initialize the inner digest */
-  sha1_init(&ctx->ictx);
-  int i;
-  for (i = 0; i < SHA1_BLOCK_SIZE; i++)
-    buf[i] = keybuf[i] ^ 0x36;
-  sha1_update(&ctx->ictx, buf, SHA1_BLOCK_SIZE);
-
-  /* Initialize the outer digest */
-  sha1_init(&ctx->octx);
-  for (i = 0; i < SHA1_BLOCK_SIZE; i++)
-    buf[i] = keybuf[i] ^ 0x5c;
-  sha1_update(&ctx->octx, buf, SHA1_BLOCK_SIZE);
-}
-
-void
-sha1_hmac_update(struct sha1_hmac_context *ctx, const byte *data, uint datalen)
-{
-  /* Just update the inner digest */
-  sha1_update(&ctx->ictx, data, datalen);
-}
-
-byte *
-sha1_hmac_final(struct sha1_hmac_context *ctx)
-{
-  /* Finish the inner digest */
-  byte *isha = sha1_final(&ctx->ictx);
-
-  /* Finish the outer digest */
-  sha1_update(&ctx->octx, isha, SHA1_SIZE);
-  return sha1_final(&ctx->octx);
-}
-
-void
-sha1_hmac(byte *outbuf, const byte *key, uint keylen, const byte *data, uint datalen)
-{
-  struct sha1_hmac_context ctx;
-
-  sha1_hmac_init(&ctx, key, keylen);
-  sha1_hmac_update(&ctx, data, datalen);
-  memcpy(outbuf, sha1_hmac_final(&ctx), SHA1_SIZE);
-}
diff --git a/lib/sha1.h b/lib/sha1.h
index c019bb49..8666a651 100644
--- a/lib/sha1.h
+++ b/lib/sha1.h
@@ -1,5 +1,5 @@
 /*
- *	BIRD Library -- SHA-1 Hash Function (FIPS 180-1, RFC 3174) and HMAC-SHA-1
+ *	BIRD Library -- SHA-1 Hash Function (FIPS 180-1, RFC 3174)
  *
  *	(c) 2015 CZ.NIC z.s.p.o.
  *
@@ -27,6 +27,8 @@
  * Internal SHA1 state.
  * You should use it just as an opaque handle only.
  */
+struct hash_context;
+
 struct sha1_context {
   u32 h0, h1, h2, h3, h4;
   byte buf[SHA1_BLOCK_SIZE];
@@ -34,15 +36,14 @@ struct sha1_context {
   uint count;
 };
 
-
-void sha1_init(struct sha1_context *ctx); /* Initialize new algorithm run in the @ctx context. **/
+void sha1_init(struct hash_context *ctx); /* Initialize new algorithm run in the @ctx context. **/
 /*
  * Push another @len bytes of data pointed to by @buf onto the SHA1 hash
  * currently in @ctx. You can call this any times you want on the same hash (and
  * you do not need to reinitialize it by @sha1_init()). It has the same effect
  * as concatenating all the data together and passing them at once.
  */
-void sha1_update(struct sha1_context *ctx, const byte *buf, uint len);
+void sha1_update(struct hash_context *ctx, const byte *buf, uint len);
 /*
  * No more @sha1_update() calls will be done. This terminates the hash and
  * returns a pointer to it.
@@ -50,7 +51,7 @@ void sha1_update(struct sha1_context *ctx, const byte *buf, uint len);
  * Note that the pointer points into data in the @ctx context. If it ceases to
  * exist, the pointer becomes invalid.
  */
-byte *sha1_final(struct sha1_context *ctx);
+byte *sha1_final(struct hash_context *ctx);
 
 /*
  * A convenience one-shot function for SHA1 hash. It is equivalent to this
@@ -63,24 +64,5 @@ byte *sha1_final(struct sha1_context *ctx);
  */
 void sha1_hash_buffer(byte *outbuf, const byte *buffer, uint length);
 
-/*
- * SHA1 HMAC message authentication. If you provide @key and @data, the result
- * will be stored in @outbuf.
- */
-void sha1_hmac(byte *outbuf, const byte *key, uint keylen, const byte *data, uint datalen);
-
-/*
- * The HMAC also exists in a stream version in a way analogous to the plain
- * SHA1. Pass this as a context.
- */
-struct sha1_hmac_context {
-  struct sha1_context ictx;
-  struct sha1_context octx;
-};
-
-void sha1_hmac_init(struct sha1_hmac_context *ctx, const byte *key, uint keylen);	/* Initialize HMAC with context @ctx and the given key. See sha1_init(). */
-void sha1_hmac_update(struct sha1_hmac_context *ctx, const byte *data, uint datalen);	/* Hash another @datalen bytes of data. See sha1_update(). */
-byte *sha1_hmac_final(struct sha1_hmac_context *ctx);					/* Terminate the HMAC and return a pointer to the allocated hash. See sha1_final(). */
-
 
 #endif /* _BIRD_SHA1_H_ */
diff --git a/lib/sha256.c b/lib/sha256.c
index 440245d5..11ff2b05 100644
--- a/lib/sha256.c
+++ b/lib/sha256.c
@@ -1,6 +1,5 @@
 /*
- *	BIRD Library -- SHA-256 and SHA-224 Hash Functions,
- *			HMAC-SHA-256 and HMAC-SHA-224 Functions
+ *	BIRD Library -- SHA-256 and SHA-224 Hash Functions
  *
  *	(c) 2015 CZ.NIC z.s.p.o.
  *
@@ -17,8 +16,10 @@
 // #define SHA256_UNROLLED
 
 void
-sha256_init(struct sha256_context *ctx)
+sha256_init(struct hash_context *CTX)
 {
+  struct sha256_context *ctx = (void *) CTX;
+
   ctx->h0 = 0x6a09e667;
   ctx->h1 = 0xbb67ae85;
   ctx->h2 = 0x3c6ef372;
@@ -33,8 +34,10 @@ sha256_init(struct sha256_context *ctx)
 }
 
 void
-sha224_init(struct sha224_context *ctx)
+sha224_init(struct hash_context *CTX)
 {
+  struct sha224_context *ctx = (void *) CTX;
+
   ctx->h0 = 0xc1059ed8;
   ctx->h1 = 0x367cd507;
   ctx->h2 = 0x3070dd17;
@@ -219,8 +222,10 @@ sha256_transform(struct sha256_context *ctx, const byte *data)
    not have any meaning but writing after finalize is sometimes
    helpful to mitigate timing attacks. */
 void
-sha256_update(struct sha256_context *ctx, const byte *buf, size_t len)
+sha256_update(struct hash_context *CTX, const byte *buf, uint len)
 {
+  struct sha256_context *ctx = (void *) CTX;
+
   if (ctx->count)
   {
     /* Fill rest of internal buffer */
@@ -261,11 +266,12 @@ sha256_update(struct sha256_context *ctx, const byte *buf, size_t len)
  * Returns: 32 bytes with the message the digest. 28 bytes for SHA-224.
  */
 byte *
-sha256_final(struct sha256_context *ctx)
+sha256_final(struct hash_context *CTX)
 {
+  struct sha256_context *ctx = (void *) CTX;
   u32 t, th, msb, lsb;
 
-  sha256_update(ctx, NULL, 0);	/* flush */
+  sha256_update(CTX, NULL, 0);	/* flush */
 
   t = ctx->nblocks;
   th = 0;
@@ -296,7 +302,7 @@ sha256_final(struct sha256_context *ctx)
     ctx->buf[ctx->count++] = 0x80; /* pad character */
     while (ctx->count < 64)
       ctx->buf[ctx->count++] = 0;
-    sha256_update(ctx, NULL, 0);  /* flush */;
+    sha256_update(CTX, NULL, 0);  /* flush */;
     memset(ctx->buf, 0, 56 ); /* fill next block with zeroes */
   }
 
@@ -319,131 +325,3 @@ sha256_final(struct sha256_context *ctx)
 
   return ctx->buf;
 }
-
-
-/*
- *	SHA256-HMAC
- */
-
-static void
-sha256_hash_buffer(byte *outbuf, const byte *buffer, size_t length)
-{
-  struct sha256_context ctx;
-
-  sha256_init(&ctx);
-  sha256_update(&ctx, buffer, length);
-  memcpy(outbuf, sha256_final(&ctx), SHA256_SIZE);
-}
-
-void
-sha256_hmac_init(struct sha256_hmac_context *ctx, const byte *key, size_t keylen)
-{
-  byte keybuf[SHA256_BLOCK_SIZE], buf[SHA256_BLOCK_SIZE];
-
-  /* Hash the key if necessary */
-  if (keylen <= SHA256_BLOCK_SIZE)
-  {
-    memcpy(keybuf, key, keylen);
-    memset(keybuf + keylen, 0, SHA256_BLOCK_SIZE - keylen);
-  }
-  else
-  {
-    sha256_hash_buffer(keybuf, key, keylen);
-    memset(keybuf + SHA256_SIZE, 0, SHA256_BLOCK_SIZE - SHA256_SIZE);
-  }
-
-  /* Initialize the inner digest */
-  sha256_init(&ctx->ictx);
-  int i;
-  for (i = 0; i < SHA256_BLOCK_SIZE; i++)
-    buf[i] = keybuf[i] ^ 0x36;
-  sha256_update(&ctx->ictx, buf, SHA256_BLOCK_SIZE);
-
-  /* Initialize the outer digest */
-  sha256_init(&ctx->octx);
-  for (i = 0; i < SHA256_BLOCK_SIZE; i++)
-    buf[i] = keybuf[i] ^ 0x5c;
-  sha256_update(&ctx->octx, buf, SHA256_BLOCK_SIZE);
-}
-
-void
-sha256_hmac_update(struct sha256_hmac_context *ctx, const byte *buf, size_t buflen)
-{
-  /* Just update the inner digest */
-  sha256_update(&ctx->ictx, buf, buflen);
-}
-
-byte *
-sha256_hmac_final(struct sha256_hmac_context *ctx)
-{
-  /* Finish the inner digest */
-  byte *isha = sha256_final(&ctx->ictx);
-
-  /* Finish the outer digest */
-  sha256_update(&ctx->octx, isha, SHA256_SIZE);
-  return sha256_final(&ctx->octx);
-}
-
-
-/*
- *	SHA224-HMAC
- */
-
-static void
-sha224_hash_buffer(byte *outbuf, const byte *buffer, size_t length)
-{
-  struct sha224_context ctx;
-
-  sha224_init(&ctx);
-  sha224_update(&ctx, buffer, length);
-  memcpy(outbuf, sha224_final(&ctx), SHA224_SIZE);
-}
-
-void
-sha224_hmac_init(struct sha224_hmac_context *ctx, const byte *key, size_t keylen)
-{
-  byte keybuf[SHA224_BLOCK_SIZE], buf[SHA224_BLOCK_SIZE];
-
-  /* Hash the key if necessary */
-  if (keylen <= SHA224_BLOCK_SIZE)
-  {
-    memcpy(keybuf, key, keylen);
-    memset(keybuf + keylen, 0, SHA224_BLOCK_SIZE - keylen);
-  }
-  else
-  {
-    sha224_hash_buffer(keybuf, key, keylen);
-    memset(keybuf + SHA224_SIZE, 0, SHA224_BLOCK_SIZE - SHA224_SIZE);
-  }
-
-  /* Initialize the inner digest */
-  sha224_init(&ctx->ictx);
-  int i;
-  for (i = 0; i < SHA224_BLOCK_SIZE; i++)
-    buf[i] = keybuf[i] ^ 0x36;
-  sha224_update(&ctx->ictx, buf, SHA224_BLOCK_SIZE);
-
-  /* Initialize the outer digest */
-  sha224_init(&ctx->octx);
-  for (i = 0; i < SHA224_BLOCK_SIZE; i++)
-    buf[i] = keybuf[i] ^ 0x5c;
-  sha224_update(&ctx->octx, buf, SHA224_BLOCK_SIZE);
-}
-
-void
-sha224_hmac_update(struct sha224_hmac_context *ctx, const byte *buf, size_t buflen)
-{
-  /* Just update the inner digest */
-  sha256_update(&ctx->ictx, buf, buflen);
-}
-
-byte *
-sha224_hmac_final(struct sha224_hmac_context *ctx)
-{
-  /* Finish the inner digest */
-  byte *isha = sha224_final(&ctx->ictx);
-
-  /* Finish the outer digest */
-  sha224_update(&ctx->octx, isha, SHA224_SIZE);
-  return sha224_final(&ctx->octx);
-}
diff --git a/lib/sha256.h b/lib/sha256.h
index 381200a9..88a948eb 100644
--- a/lib/sha256.h
+++ b/lib/sha256.h
@@ -1,6 +1,5 @@
 /*
- *	BIRD Library -- SHA-256 and SHA-224 Hash Functions,
- *			HMAC-SHA-256 and HMAC-SHA-224 Functions
+ *	BIRD Library -- SHA-256 and SHA-224 Hash Functions
  *
  *	(c) 2015 CZ.NIC z.s.p.o.
  *
@@ -25,6 +24,8 @@
 #define SHA256_BLOCK_SIZE 	64
 
 
+struct hash_context;
+
 struct sha256_context {
   u32  h0, h1, h2, h3, h4, h5, h6, h7;
   byte buf[SHA256_BLOCK_SIZE];
@@ -35,39 +36,14 @@ struct sha256_context {
 #define sha224_context sha256_context
 
 
-void sha256_init(struct sha256_context *ctx);
-void sha224_init(struct sha224_context *ctx);
-
-void sha256_update(struct sha256_context *ctx, const byte *buf, size_t len);
-static inline void sha224_update(struct sha224_context *ctx, const byte *buf, size_t len)
-{ sha256_update(ctx, buf, len); }
-
-byte *sha256_final(struct sha256_context *ctx);
-static inline byte *sha224_final(struct sha224_context *ctx)
-{ return sha256_final(ctx); }
-
-
-/*
- *	HMAC-SHA256, HMAC-SHA224
- */
-
-struct sha256_hmac_context
-{
-  struct sha256_context ictx;
-  struct sha256_context octx;
-};
-
-#define sha224_hmac_context sha256_hmac_context
-
-
-void sha256_hmac_init(struct sha256_hmac_context *ctx, const byte *key, size_t keylen);
-void sha224_hmac_init(struct sha224_hmac_context *ctx, const byte *key, size_t keylen);
+void sha256_init(struct hash_context *ctx);
+void sha224_init(struct hash_context *ctx);
 
-void sha256_hmac_update(struct sha256_hmac_context *ctx, const byte *buf, size_t buflen);
-void sha224_hmac_update(struct sha224_hmac_context *ctx, const byte *buf, size_t buflen);
+void sha256_update(struct hash_context *ctx, const byte *buf, uint len);
+#define sha224_update sha256_update
 
-byte *sha256_hmac_final(struct sha256_hmac_context *ctx);
-byte *sha224_hmac_final(struct sha224_hmac_context *ctx);
+byte *sha256_final(struct hash_context *ctx);
+#define sha224_final sha256_final
 
 
 #endif /* _BIRD_SHA256_H_ */
diff --git a/lib/sha512.c b/lib/sha512.c
index 37e660f7..576ae1e8 100644
--- a/lib/sha512.c
+++ b/lib/sha512.c
@@ -1,6 +1,5 @@
 /*
- *	BIRD Library -- SHA-512 and SHA-384 Hash Functions,
- *			HMAC-SHA-512 and HMAC-SHA-384 Functions
+ *	BIRD Library -- SHA-512 and SHA-384 Hash Functions
  *
  *	(c) 2015 CZ.NIC z.s.p.o.
  *
@@ -17,8 +16,10 @@
 // #define SHA512_UNROLLED
 
 void
-sha512_init(struct sha512_context *ctx)
+sha512_init(struct hash_context *CTX)
 {
+  struct sha512_context *ctx = (void *) CTX;
+
   ctx->h0 = U64(0x6a09e667f3bcc908);
   ctx->h1 = U64(0xbb67ae8584caa73b);
   ctx->h2 = U64(0x3c6ef372fe94f82b);
@@ -33,8 +34,10 @@ sha512_init(struct sha512_context *ctx)
 }
 
 void
-sha384_init(struct sha384_context *ctx)
+sha384_init(struct hash_context *CTX)
 {
+  struct sha384_context *ctx = (void *) CTX;
+
   ctx->h0 = U64(0xcbbb9d5dc1059ed8);
   ctx->h1 = U64(0x629a292a367cd507);
   ctx->h2 = U64(0x9159015a3070dd17);
@@ -389,8 +392,10 @@ sha512_transform(struct sha512_context *ctx, const byte *data)
 }
 
 void
-sha512_update(struct sha512_context *ctx, const byte *buf, size_t len)
+sha512_update(struct hash_context *CTX, const byte *buf, uint len)
 {
+  struct sha512_context *ctx = (void *) CTX;
+
   if (ctx->count)
   {
     /* Fill rest of internal buffer */
@@ -432,11 +437,12 @@ sha512_update(struct sha512_context *ctx, const byte *buf, size_t len)
  * first 48 of those bytes.
  */
 byte *
-sha512_final(struct sha512_context *ctx)
+sha512_final(struct hash_context *CTX)
 {
+  struct sha512_context *ctx = (void *) CTX;
   u64 t, th, msb, lsb;
 
-  sha512_update(ctx, NULL, 0);	/* flush */
+  sha512_update(CTX, NULL, 0);	/* flush */
 
   t = ctx->nblocks;
   th = 0;
@@ -467,7 +473,7 @@ sha512_final(struct sha512_context *ctx)
     ctx->buf[ctx->count++] = 0x80;	/* pad character */
     while(ctx->count < 128)
       ctx->buf[ctx->count++] = 0;
-    sha512_update(ctx, NULL, 0); 	/* flush */
+    sha512_update(CTX, NULL, 0); 	/* flush */
     memset(ctx->buf, 0, 112);		/* fill next block with zeroes */
   }
 
@@ -490,131 +496,3 @@ sha512_final(struct sha512_context *ctx)
 
   return ctx->buf;
 }
-
-
-/*
- *	SHA512-HMAC
- */
-
-static void
-sha512_hash_buffer(byte *outbuf, const byte *buffer, size_t length)
-{
-  struct sha512_context ctx;
-
-  sha512_init(&ctx);
-  sha512_update(&ctx, buffer, length);
-  memcpy(outbuf, sha512_final(&ctx), SHA512_SIZE);
-}
-
-void
-sha512_hmac_init(struct sha512_hmac_context *ctx, const byte *key, size_t keylen)
-{
-  byte keybuf[SHA512_BLOCK_SIZE], buf[SHA512_BLOCK_SIZE];
-
-  /* Hash the key if necessary */
-  if (keylen <= SHA512_BLOCK_SIZE)
-  {
-    memcpy(keybuf, key, keylen);
-    memset(keybuf + keylen, 0, SHA512_BLOCK_SIZE - keylen);
-  }
-  else
-  {
-    sha512_hash_buffer(keybuf, key, keylen);
-    memset(keybuf + SHA512_SIZE, 0, SHA512_BLOCK_SIZE - SHA512_SIZE);
-  }
-
-  /* Initialize the inner digest */
-  sha512_init(&ctx->ictx);
-  int i;
-  for (i = 0; i < SHA512_BLOCK_SIZE; i++)
-    buf[i] = keybuf[i] ^ 0x36;
-  sha512_update(&ctx->ictx, buf, SHA512_BLOCK_SIZE);
-
-  /* Initialize the outer digest */
-  sha512_init(&ctx->octx);
-  for (i = 0; i < SHA512_BLOCK_SIZE; i++)
-    buf[i] = keybuf[i] ^ 0x5c;
-  sha512_update(&ctx->octx, buf, SHA512_BLOCK_SIZE);
-}
-
-void
-sha512_hmac_update(struct sha512_hmac_context *ctx, const byte *buf, size_t buflen)
-{
-  /* Just update the inner digest */
-  sha512_update(&ctx->ictx, buf, buflen);
-}
-
-byte *
-sha512_hmac_final(struct sha512_hmac_context *ctx)
-{
-  /* Finish the inner digest */
-  byte *isha = sha512_final(&ctx->ictx);
-
-  /* Finish the outer digest */
-  sha512_update(&ctx->octx, isha, SHA512_SIZE);
-  return sha512_final(&ctx->octx);
-}
-
-
-/*
- *	SHA384-HMAC
- */
-
-static void
-sha384_hash_buffer(byte *outbuf, const byte *buffer, size_t length)
-{
-  struct sha384_context ctx;
-
-  sha384_init(&ctx);
-  sha384_update(&ctx, buffer, length);
-  memcpy(outbuf, sha384_final(&ctx), SHA384_SIZE);
-}
-
-void
-sha384_hmac_init(struct sha384_hmac_context *ctx, const byte *key, size_t keylen)
-{
-  byte keybuf[SHA384_BLOCK_SIZE], buf[SHA384_BLOCK_SIZE];
-
-  /* Hash the key if necessary */
-  if (keylen <= SHA384_BLOCK_SIZE)
-  {
-    memcpy(keybuf, key, keylen);
-    memset(keybuf + keylen, 0, SHA384_BLOCK_SIZE - keylen);
-  }
-  else
-  {
-    sha384_hash_buffer(keybuf, key, keylen);
-    memset(keybuf + SHA384_SIZE, 0, SHA384_BLOCK_SIZE - SHA384_SIZE);
-  }
-
-  /* Initialize the inner digest */
-  sha384_init(&ctx->ictx);
-  int i;
-  for (i = 0; i < SHA384_BLOCK_SIZE; i++)
-    buf[i] = keybuf[i] ^ 0x36;
-  sha384_update(&ctx->ictx, buf, SHA384_BLOCK_SIZE);
-
-  /* Initialize the outer digest */
-  sha384_init(&ctx->octx);
-  for (i = 0; i < SHA384_BLOCK_SIZE; i++)
-    buf[i] = keybuf[i] ^ 0x5c;
-  sha384_update(&ctx->octx, buf, SHA384_BLOCK_SIZE);
-}
-
-void
-sha384_hmac_update(struct sha384_hmac_context *ctx, const byte *buf, size_t buflen)
-{
-  /* Just update the inner digest */
-  sha384_update(&ctx->ictx, buf, buflen);
-}
-
-byte *
-sha384_hmac_final(struct sha384_hmac_context *ctx)
-{
-  /* Finish the inner digest */
-  byte *isha = sha384_final(&ctx->ictx);
-
-  /* Finish the outer digest */
-  sha384_update(&ctx->octx, isha, SHA384_SIZE);
-  return sha384_final(&ctx->octx);
-}
diff --git a/lib/sha512.h b/lib/sha512.h
index 1614a3ac..02220c93 100644
--- a/lib/sha512.h
+++ b/lib/sha512.h
@@ -1,6 +1,5 @@
 /*
- *	BIRD Library -- SHA-512 and SHA-384 Hash Functions,
- *			HMAC-SHA-512 and HMAC-SHA-384 Functions
+ *	BIRD Library -- SHA-512 and SHA-384 Hash Functions
  *
  *	(c) 2015 CZ.NIC z.s.p.o.
  *
@@ -25,8 +24,10 @@
 #define SHA512_BLOCK_SIZE	128
 
 
+struct hash_context;
+
 struct sha512_context {
-  u64 h0, h1, h2, h3, h4, h5, h6, h7;
+  u64  h0, h1, h2, h3, h4, h5, h6, h7;
   byte buf[SHA512_BLOCK_SIZE];
   uint nblocks;
   uint count;
@@ -35,39 +36,14 @@ struct sha512_context {
 #define sha384_context sha512_context
 
 
-void sha512_init(struct sha512_context *ctx);
-void sha384_init(struct sha384_context *ctx);
-
-void sha512_update(struct sha512_context *ctx, const byte *buf, size_t len);
-static inline void sha384_update(struct sha384_context *ctx, const byte *buf, size_t len)
-{ sha512_update(ctx, buf, len); }
-
-byte *sha512_final(struct sha512_context *ctx);
-static inline byte *sha384_final(struct sha384_context *ctx)
-{ return sha512_final(ctx); }
-
-
-/*
- *	HMAC-SHA512, HMAC-SHA384
- */
-
-struct sha512_hmac_context
-{
-  struct sha512_context ictx;
-  struct sha512_context octx;
-};
-
-#define sha384_hmac_context sha512_hmac_context
-
-
-void sha512_hmac_init(struct sha512_hmac_context *ctx, const byte *key, size_t keylen);
-void sha384_hmac_init(struct sha384_hmac_context *ctx, const byte *key, size_t keylen);
+void sha512_init(struct hash_context *ctx);
+void sha384_init(struct hash_context *ctx);
 
-void sha512_hmac_update(struct sha512_hmac_context *ctx, const byte *buf, size_t buflen);
-void sha384_hmac_update(struct sha384_hmac_context *ctx, const byte *buf, size_t buflen);
+void sha512_update(struct hash_context *ctx, const byte *buf, uint len);
+#define sha384_update sha512_update
 
-byte *sha512_hmac_final(struct sha512_hmac_context *ctx);
-byte *sha384_hmac_final(struct sha384_hmac_context *ctx);
+byte *sha512_final(struct hash_context *ctx);
+#define sha384_final sha512_final
 
 
 #endif /* _BIRD_SHA512_H_ */
diff --git a/nest/password.c b/nest/password.c
index 91aaa418..d6e2087f 100644
--- a/nest/password.c
+++ b/nest/password.c
@@ -37,7 +37,7 @@ password_find(list *l, int first_fit)
 }
 
 struct password_item *
-password_find_by_id(list *l, int id)
+password_find_by_id(list *l, uint id)
 {
   struct password_item *pi;
 
diff --git a/nest/password.h b/nest/password.h
index 1d9de53c..a45261e6 100644
--- a/nest/password.h
+++ b/nest/password.h
@@ -21,7 +21,7 @@ struct password_item {
 extern struct password_item *last_password_item;
 
 struct password_item *password_find(list *l, int first_fit);
-struct password_item *password_find_by_id(list *l, int id);
+struct password_item *password_find_by_id(list *l, uint id);
 struct password_item *password_find_by_value(list *l, char *pass, uint size);
 
 static inline int password_verify(struct password_item *p1, char *p2, uint size)
diff --git a/proto/ospf/packet.c b/proto/ospf/packet.c
index aa90aa51..a2fbd089 100644
--- a/proto/ospf/packet.c
+++ b/proto/ospf/packet.c
@@ -11,6 +11,7 @@
 #include "ospf.h"
 #include "nest/password.h"
 #include "lib/md5.h"
+#include "lib/mac.h"
 #include "lib/socket.h"
 
 void
@@ -109,7 +110,7 @@ ospf_pkt_finalize(struct ospf_iface *ifa, struct ospf_packet *pkt)
     char password[OSPF_AUTH_CRYPT_SIZE];
     strncpy(password, passwd->password, sizeof(password));
 
-    struct md5_context ctx;
+    struct hash_context ctx;
     md5_init(&ctx);
     md5_update(&ctx, (char *) pkt, plen);
     md5_update(&ctx, password, OSPF_AUTH_CRYPT_SIZE);
@@ -180,7 +181,7 @@ ospf_pkt_checkauth(struct ospf_neighbor *n, struct ospf_iface *ifa, struct ospf_
     memcpy(received, tail, OSPF_AUTH_CRYPT_SIZE);
     strncpy(tail, pass->password, OSPF_AUTH_CRYPT_SIZE);
 
-    struct md5_context ctx;
+    struct hash_context ctx;
     md5_init(&ctx);
     md5_update(&ctx, (byte *) pkt, plen + OSPF_AUTH_CRYPT_SIZE);
     char *computed = md5_final(&ctx);
diff --git a/proto/rip/packets.c b/proto/rip/packets.c
index e026eaea..381b4771 100644
--- a/proto/rip/packets.c
+++ b/proto/rip/packets.c
@@ -11,6 +11,7 @@
 
 #include "rip.h"
 #include "lib/md5.h"
+#include "lib/mac.h"
 
 
 #define RIP_CMD_REQUEST		1	/* want info */
@@ -241,7 +242,7 @@ rip_fill_authentication(struct rip_proto *p, struct rip_iface *ifa, struct rip_p
 
     *plen += sizeof(struct rip_auth_tail) + RIP_MD5_LENGTH;
 
-    struct md5_context ctx;
+    struct hash_context ctx;
     md5_init(&ctx);
     md5_update(&ctx, (byte *) pkt, *plen);
     memcpy(tail->auth_data, md5_final(&ctx), RIP_MD5_LENGTH);
@@ -315,7 +316,7 @@ rip_check_authentication(struct rip_proto *p, struct rip_iface *ifa, struct rip_
     memcpy(received, tail->auth_data, RIP_MD5_LENGTH);
     strncpy(tail->auth_data, pass->password, RIP_MD5_LENGTH);
 
-    struct md5_context ctx;
+    struct hash_context ctx;
     md5_init(&ctx);
     md5_update(&ctx, (byte *) pkt, *plen);
     char *computed = md5_final(&ctx);

From 56cb3bedc2634a44ea41587566c2889f5b5f5b5b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pavel=20Tvrd=C3=ADk?= <pawel.tvrdik@gmail.com>
Date: Tue, 26 Jan 2016 16:45:13 +0100
Subject: [PATCH 153/165] Nest: Add support for MAC algorithms in grammar

---
 nest/config.Y      | 22 ++++++++++++++++++++--
 nest/password.h    |  7 +++++--
 proto/rip/config.Y |  2 +-
 3 files changed, 26 insertions(+), 5 deletions(-)

diff --git a/nest/config.Y b/nest/config.Y
index 3e76581a..878224fe 100644
--- a/nest/config.Y
+++ b/nest/config.Y
@@ -13,6 +13,7 @@ CF_HDR
 #include "nest/password.h"
 #include "nest/cmds.h"
 #include "lib/lists.h"
+#include "lib/mac.h"
 
 CF_DEFINES
 
@@ -57,6 +58,7 @@ CF_KEYWORDS(ROUTER, ID, PROTOCOL, TEMPLATE, PREFERENCE, DISABLED, DEBUG, ALL, OF
 CF_KEYWORDS(INTERFACE, IMPORT, EXPORT, FILTER, NONE, TABLE, STATES, ROUTES, FILTERS)
 CF_KEYWORDS(RECEIVE, LIMIT, ACTION, WARN, BLOCK, RESTART, DISABLE, KEEP, FILTERED)
 CF_KEYWORDS(PASSWORD, FROM, PASSIVE, TO, ID, EVENTS, PACKETS, PROTOCOLS, INTERFACES)
+CF_KEYWORDS(ALGORITHM, KEYED, HMAC, MD5, SHA1, SHA256, SHA384, SHA512)
 CF_KEYWORDS(PRIMARY, STATS, COUNT, FOR, COMMANDS, PREEXPORT, NOEXPORT, GENERATE, ROA)
 CF_KEYWORDS(LISTEN, BGP, V6ONLY, DUAL, ADDRESS, PORT, PASSWORDS, DESCRIPTION, SORTED)
 CF_KEYWORDS(RELOAD, IN, OUT, MRTDUMP, MESSAGES, RESTRICT, MEMORY, IGP_METRIC, CLASS, DSCP)
@@ -77,7 +79,7 @@ CF_ENUM(T_ENUM_ROA, ROA_, UNKNOWN, VALID, INVALID)
 %type <ro> roa_args
 %type <rot> roa_table_arg
 %type <sd> sym_args
-%type <i> proto_start echo_mask echo_size debug_mask debug_list debug_flag mrtdump_mask mrtdump_list mrtdump_flag export_mode roa_mode limit_action tab_sorted tos
+%type <i> proto_start echo_mask echo_size debug_mask debug_list debug_flag mrtdump_mask mrtdump_list mrtdump_flag export_mode roa_mode limit_action tab_sorted tos password_algorithm
 %type <ps> proto_patt proto_patt2
 %type <g> limit_spec
 
@@ -416,11 +418,13 @@ password_item_begin:
      }
      this_p_item = cfg_alloc(sizeof (struct password_item));
      this_p_item->password = $2;
+     this_p_item->length = strlen($2);
      this_p_item->genfrom = 0;
      this_p_item->gento = TIME_INFINITY;
      this_p_item->accfrom = 0;
      this_p_item->accto = TIME_INFINITY;
      this_p_item->id = password_id++;
+     this_p_item->alg = ALG_UNDEFINED;
      add_tail(this_p_list, &this_p_item->n);
    }
 ;
@@ -431,10 +435,24 @@ password_item_params:
  | GENERATE TO datetime ';' password_item_params { this_p_item->gento = $3; }
  | ACCEPT FROM datetime ';' password_item_params { this_p_item->accfrom = $3; }
  | ACCEPT TO datetime ';' password_item_params { this_p_item->accto = $3; }
+ | FROM datetime ';' password_item_params { this_p_item->genfrom = this_p_item->accfrom = $2; }
+ | TO datetime ';' password_item_params { this_p_item->gento = this_p_item->accto = $2; }
  | ID expr ';' password_item_params { this_p_item->id = $2; if ($2 <= 0) cf_error("Password ID has to be greated than zero."); }
+ | ALGORITHM password_algorithm ';' password_item_params { this_p_item->alg = $2; }
  ;
 
-
+password_algorithm:
+   KEYED MD5	{ $$ = ALG_MD5; }
+ | KEYED SHA1	{ $$ = ALG_SHA1; }
+ | KEYED SHA256	{ $$ = ALG_SHA256; }
+ | KEYED SHA384	{ $$ = ALG_SHA384; }
+ | KEYED SHA512	{ $$ = ALG_SHA512; }
+ | HMAC MD5	{ $$ = ALG_HMAC_MD5; }
+ | HMAC SHA1	{ $$ = ALG_HMAC_SHA1; }
+ | HMAC SHA256	{ $$ = ALG_HMAC_SHA256; }
+ | HMAC SHA384	{ $$ = ALG_HMAC_SHA384; }
+ | HMAC SHA512	{ $$ = ALG_HMAC_SHA512; }
+ ;
 
 /* Core commands */
 CF_CLI_HELP(SHOW, ..., [[Show status information]])
diff --git a/nest/password.h b/nest/password.h
index a45261e6..7392389b 100644
--- a/nest/password.h
+++ b/nest/password.h
@@ -9,12 +9,15 @@
 
 #ifndef PASSWORD_H
 #define PASSWORD_H
+
 #include "lib/timer.h"
 
 struct password_item {
   node n;
-  char *password;
-  int id;
+  char *password;			/* Key data, null terminated */
+  uint length;				/* Key length, without null */
+  uint id;				/* Key ID */
+  uint alg;				/* MAC algorithm */
   bird_clock_t accfrom, accto, genfrom, gento;
 };
 
diff --git a/proto/rip/config.Y b/proto/rip/config.Y
index 083d2e91..e15599e0 100644
--- a/proto/rip/config.Y
+++ b/proto/rip/config.Y
@@ -147,7 +147,7 @@ rip_auth:
    NONE			{ $$ = RIP_AUTH_NONE; }
  | PLAINTEXT		{ $$ = RIP_AUTH_PLAIN; }
  | CRYPTOGRAPHIC	{ $$ = RIP_AUTH_CRYPTO; }
- | MD5			{ $$ = RIP_AUTH_CRYPTO; }
+ | MD5			{ $$ = RIP_AUTH_CRYPTO; }	/* For backward compatibility */
  ;
 
 rip_iface_opts:

From 64385aee0cc2dfae8297f29ce6724cedf7cc4736 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pavel=20Tvrd=C3=ADk?= <pawel.tvrdik@gmail.com>
Date: Thu, 28 Jan 2016 17:05:15 +0100
Subject: [PATCH 154/165] DOC: Password algorithm option

---
 doc/bird.sgml | 78 +++++++++++++++++++++++++++++++++++++--------------
 1 file changed, 57 insertions(+), 21 deletions(-)

diff --git a/doc/bird.sgml b/doc/bird.sgml
index a07201ce..7c34c208 100644
--- a/doc/bird.sgml
+++ b/doc/bird.sgml
@@ -664,13 +664,13 @@ agreement").
 	protocol packets are processed in the local TX queues. This option is
 	Linux specific. Default value is 7 (highest priority, privileged traffic).
 
-	<tag><label id="proto-pass">password "<m/password/" [ { id <m/num/; generate from <m/time/; generate to <m/time/; accept from <m/time/; accept to <m/time/; } ]</tag>
-	Specifies a password that can be used by the protocol. Password option
-	can be used more times to specify more passwords. If more passwords are
-	specified, it is a protocol-dependent decision which one is really
-	used. Specifying passwords does not mean that authentication is enabled,
-	authentication can be enabled by separate, protocol-dependent
-	<cf/authentication/ option.
+	<tag><label id="proto-pass">password "<m/password/" [ { <m>password options</m> } ]</tag>
+	Specifies a password that can be used by the protocol as a shared secret
+	key. Password option can be used more times to specify more passwords.
+	If more passwords are specified, it is a protocol-dependent decision
+	which one is really used. Specifying passwords does not mean that
+	authentication is enabled, authentication can be enabled by separate,
+	protocol-dependent <cf/authentication/ option.
 
 	This option is allowed in OSPF and RIP protocols. BGP has also
 	<cf/password/ option, but it is slightly different and described
@@ -700,6 +700,19 @@ agreement").
 
 	<tag><label id="proto-pass-accept-to">accept to "<m/time/"</tag>
 	The last time of the usage of the password for packet verification.
+
+	<tag><label id="proto-pass-from">from "<m/time/"</tag>
+	Shorthand for setting both <cf/generate from/ and <cf/accept from/.
+
+	<tag><label id="proto-pass-to">to "<m/time/"</tag>
+	Shorthand for setting both <cf/generate to/ and <cf/accept to/.
+
+	<tag><label id="proto-pass-algorithm">algorithm ( keyed md5 | keyed sha1 | hmac sha1 | hmac sha256 | hmac sha384 | hmac sha512 )</tag>
+	The message authentication algorithm for the password when cryptographic
+	authentication is enabled. The default value depends on the protocol.
+	For RIP and OSPFv2 it is Keyed-MD5 (for compatibility), for OSPFv3
+	protocol it is HMAC-SHA-256.
+
 </descrip>
 
 <chapt>Remote control
@@ -2659,7 +2672,7 @@ protocol ospf &lt;name&gt; {
 			ttl security [&lt;switch&gt;; | tx only]
 			tx class|dscp &lt;num&gt;;
 			tx priority &lt;num&gt;;
-			authentication [none|simple|cryptographic];
+			authentication none|simple|cryptographic;
 			password "&lt;text&gt;";
 			password "&lt;text&gt;" {
 				id &lt;num&gt;;
@@ -2667,6 +2680,9 @@ protocol ospf &lt;name&gt; {
 				generate to "&lt;date&gt;";
 				accept from "&lt;date&gt;";
 				accept to "&lt;date&gt;";
+				from "&lt;date&gt;";
+				to "&lt;date&gt;";
+				algorithm ( keyed md5 | keyed sha1 | hmac sha1 | hmac sha256 | hmac sha384 | hmac sha512 );
 			};
 			neighbors {
 				&lt;ip&gt;;
@@ -2679,8 +2695,18 @@ protocol ospf &lt;name&gt; {
 			wait &lt;num&gt;;
 			dead count &lt;num&gt;;
 			dead &lt;num&gt;;
-			authentication [none|simple|cryptographic];
+			authentication none|simple|cryptographic;
 			password "&lt;text&gt;";
+			password "&lt;text&gt;" {
+				id &lt;num&gt;;
+				generate from "&lt;date&gt;";
+				generate to "&lt;date&gt;";
+				accept from "&lt;date&gt;";
+				accept to "&lt;date&gt;";
+				from "&lt;date&gt;";
+				to "&lt;date&gt;";
+				algorithm ( keyed md5 | keyed sha1 | hmac sha1 | hmac sha256 | hmac sha384 | hmac sha512 );
+			};
 		};
 	};
 }
@@ -2999,15 +3025,18 @@ protocol ospf &lt;name&gt; {
 	<tag><label id="ospf-auth-simple">authentication simple</tag>
 	Every packet carries 8 bytes of password. Received packets lacking this
 	password are ignored. This authentication mechanism is very weak.
+	This option is not available in OSPFv3.
 
 	<tag><label id="ospf-auth-cryptographic">authentication cryptographic</tag>
-	16-byte long MD5 digest is appended to every packet. For the digest
-	generation 16-byte long passwords are used. Those passwords are not sent
-	via network, so this mechanism is quite secure. Packets can still be
-	read by an attacker.
+	An authentication code is appended to every packet. The specific
+	cryptographic algorithm is selected by option <cf/algorithm/ for each
+	key. The default cryptographic algorithm for OSPFv2 keys is Keyed-MD5
+	and for OSPFv3 keys is HMAC-SHA-256. Passwords are not sent open via
+	network, so this mechanism is quite secure. Packets can still be read by
+	an attacker.
 
 	<tag><label id="ospf-pass">password "<M>text</M>"</tag>
-	An 8-byte or 16-byte password used for authentication. See
+	Specifies a password used for authentication. See
 	<ref id="proto-pass" name="password"> common option for detailed
 	description.
 
@@ -3069,11 +3098,13 @@ protocol ospf MyOSPF {
 				id 1;
 				generate to "22-04-2003 11:00:06";
 				accept from "17-01-2001 12:01:05";
+				algorithm hmac sha384;
 			};
 			password "def" {
 				id 2;
 				generate to "22-07-2005 17:03:21";
 				accept from "22-02-2001 11:34:06";
+				algorithm hmac sha512;
 			};
 		};
 		interface "arc0" {
@@ -3500,8 +3531,7 @@ you can't use RIP on networks where maximal distance is higher than 15
 hosts.
 
 <p>BIRD supports RIPv1 (<rfc id="1058">), RIPv2 (<rfc id="2453">), RIPng (<rfc
-id="2080">), and RIP cryptographic authentication (SHA-1 not implemented)
-(<rfc id="4822">).
+id="2080">), and RIP cryptographic authentication (<rfc id="4822">).
 
 <p>RIP is a very simple protocol, and it has a lot of shortcomings. Slow
 convergence, big network load and inability to handle larger networks makes it
@@ -3545,6 +3575,9 @@ protocol rip [&lt;name&gt;] {
 			generate to "&lt;date&gt;";
 			accept from "&lt;date&gt;";
 			accept to "&lt;date&gt;";
+			from "&lt;date&gt;";
+			to "&lt;date&gt;";
+			algorithm ( keyed md5 | keyed sha1 | hmac sha1 | hmac sha256 | hmac sha384 | hmac sha512 );
 		};
 	};
 }
@@ -3658,7 +3691,9 @@ protocol rip [&lt;name&gt;] {
 	Selects authentication method to be used. <cf/none/ means that packets
 	are not authenticated at all, <cf/plaintext/ means that a plaintext
 	password is embedded into each packet, and <cf/cryptographic/ means that
-	packets are authenticated using a MD5 cryptographic hash. If you set
+	packets are authenticated using some cryptographic hash function
+	selected by option <cf/algorithm/ for each key. The default
+	cryptographic algorithm for RIP keys is Keyed-MD5. If you set
 	authentication to not-none, it is a good idea to add <cf>password</cf>
 	section. Default: none.
 
@@ -3704,8 +3739,8 @@ protocol rip [&lt;name&gt;] {
 	consideration. When the link disappears (e.g. an ethernet cable is
 	unplugged), neighbors are immediately considered unreachable and all
 	routes received from them are withdrawn. It is possible that some
-	hardware drivers or platforms do not implement this feature. Default:
-	no.
+	hardware drivers or platforms do not implement this feature.
+	Default: no.
 </descrip>
 
 <sect1>Attributes
@@ -3737,8 +3772,9 @@ protocol rip {
         period 12;
         garbage time 60;
         interface "eth0" { metric 3; mode multicast; };
-	interface "eth*" { metric 2; mode broadcast; };
-        authentication none;
+        interface "eth*" { metric 2; mode broadcast; };
+        authentication cryptographic;
+        password "secret-shared-key" { algorithm hmac sha256; };
         import filter { print "importing"; accept; };
         export filter { print "exporting"; accept; };
 }

From 390601f038b69d5de3841c691f92af0fcd088454 Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Wed, 26 Oct 2016 16:07:45 +0200
Subject: [PATCH 155/165] RIP: Use message authentication interface

Based on former commit from Pavel Tvrdik
---
 lib/mac.h           |  4 +++
 lib/string.h        | 10 +++++++
 nest/password.c     | 15 ++++++++++
 nest/password.h     |  2 ++
 proto/rip/config.Y  | 22 +++++++++++---
 proto/rip/packets.c | 72 +++++++++++++++++++++++++++++----------------
 proto/rip/rip.c     |  7 ++---
 proto/rip/rip.h     |  2 +-
 8 files changed, 100 insertions(+), 34 deletions(-)

diff --git a/lib/mac.h b/lib/mac.h
index 9dba8f89..5fc216fd 100644
--- a/lib/mac.h
+++ b/lib/mac.h
@@ -21,6 +21,7 @@
 #define ALG_SHA256		0x04
 #define ALG_SHA384		0x05
 #define ALG_SHA512		0x06
+#define ALG_HMAC		0x10
 #define ALG_HMAC_MD5		0x11
 #define ALG_HMAC_SHA1		0x12
 #define ALG_HMAC_SHA224		0x13
@@ -34,6 +35,9 @@
 #define HASH_STORAGE		sizeof(struct sha512_context)
 #define MAC_STORAGE		sizeof(struct hmac_context)
 
+/* This value is used by several IETF protocols for padding */
+#define HMAC_MAGIC		htonl(0x878FE1F3)
+
 /* Generic context used by hash functions */
 struct hash_context
 {
diff --git a/lib/string.h b/lib/string.h
index bf0b7cb0..75cb88dd 100644
--- a/lib/string.h
+++ b/lib/string.h
@@ -39,6 +39,16 @@ xstrdup(const char *c)
   return z;
 }
 
+static inline void
+memset32(void *D, u32 val, uint n)
+{
+  u32 *dst = D;
+  uint i;
+
+  for (i = 0; i < n; i++)
+    dst[i] = val;
+}
+
 #define ROUTER_ID_64_LENGTH 23
 
 #endif
diff --git a/nest/password.c b/nest/password.c
index d6e2087f..e4813741 100644
--- a/nest/password.c
+++ b/nest/password.c
@@ -10,6 +10,7 @@
 #include "nest/bird.h"
 #include "nest/password.h"
 #include "lib/string.h"
+#include "lib/mac.h"
 
 struct password_item *last_password_item = NULL;
 
@@ -66,3 +67,17 @@ password_find_by_value(list *l, char *pass, uint size)
   return NULL;
 }
 
+uint
+max_mac_length(list *l)
+{
+  struct password_item *pi;
+  uint val = 0;
+
+  if (!l)
+    return 0;
+
+  WALK_LIST(pi, *l)
+    val = MAX(val, mac_type_length(pi->alg));
+
+  return val;
+}
diff --git a/nest/password.h b/nest/password.h
index 7392389b..f21483c4 100644
--- a/nest/password.h
+++ b/nest/password.h
@@ -34,4 +34,6 @@ static inline int password_verify(struct password_item *p1, char *p2, uint size)
   return !memcmp(buf, p2, size);
 }
 
+uint max_mac_length(list *l);
+
 #endif
diff --git a/proto/rip/config.Y b/proto/rip/config.Y
index e15599e0..4ec45c7a 100644
--- a/proto/rip/config.Y
+++ b/proto/rip/config.Y
@@ -98,15 +98,29 @@ rip_iface_start:
 
 rip_iface_finish:
 {
+  /* Default mode is broadcast for RIPv1, multicast for RIPv2 and RIPng */
+  if (!RIP_IFACE->mode)
+    RIP_IFACE->mode = (rip_cfg_is_v2() && (RIP_IFACE->version == RIP_V1)) ?
+      RIP_IM_BROADCAST : RIP_IM_MULTICAST;
+
   RIP_IFACE->passwords = get_passwords();
 
   if (!RIP_IFACE->auth_type != !RIP_IFACE->passwords)
     log(L_WARN "Authentication and password options should be used together");
 
-  /* Default mode is broadcast for RIPv1, multicast for RIPv2 and RIPng */
-  if (!RIP_IFACE->mode)
-    RIP_IFACE->mode = (rip_cfg_is_v2() && (RIP_IFACE->version == RIP_V1)) ?
-      RIP_IM_BROADCAST : RIP_IM_MULTICAST;
+  if (RIP_IFACE->passwords)
+  {
+    struct password_item *pass;
+    WALK_LIST(pass, *RIP_IFACE->passwords)
+    {
+      if (pass->alg && (RIP_IFACE->auth_type != RIP_AUTH_CRYPTO))
+	cf_error("Password algorithm option requires cryptographic authentication");
+
+      /* Set default crypto algorithm (MD5) */
+      if (!pass->alg && (RIP_IFACE->auth_type == RIP_AUTH_CRYPTO))
+	pass->alg = ALG_MD5;
+    }
+  }
 
   RIP_CFG->min_timeout_time = MIN_(RIP_CFG->min_timeout_time, RIP_IFACE->timeout_time);
   RIP_CFG->max_garbage_time = MAX_(RIP_CFG->max_garbage_time, RIP_IFACE->garbage_time);
diff --git a/proto/rip/packets.c b/proto/rip/packets.c
index 381b4771..468927e6 100644
--- a/proto/rip/packets.c
+++ b/proto/rip/packets.c
@@ -10,7 +10,6 @@
  */
 
 #include "rip.h"
-#include "lib/md5.h"
 #include "lib/mac.h"
 
 
@@ -18,9 +17,7 @@
 #define RIP_CMD_RESPONSE	2	/* responding to request */
 
 #define RIP_BLOCK_LENGTH	20
-
 #define RIP_PASSWD_LENGTH	16
-#define RIP_MD5_LENGTH		16
 
 #define RIP_AF_IPV4		2
 #define RIP_AF_AUTH		0xffff
@@ -73,7 +70,7 @@ struct rip_auth_tail
 {
   u16 must_be_ffff;
   u16 must_be_0001;
-  byte auth_data[];
+  byte auth_data[0];
 };
 
 /* Internal representation of RTE block data */
@@ -221,16 +218,24 @@ rip_fill_authentication(struct rip_proto *p, struct rip_iface *ifa, struct rip_p
     auth->auth_type = htons(RIP_AUTH_CRYPTO);
     auth->packet_len = htons(*plen);
     auth->key_id = pass->id;
-    auth->auth_len = sizeof(struct rip_auth_tail) + RIP_MD5_LENGTH;
+    auth->auth_len = mac_type_length(pass->alg);
     auth->seq_num = ifa->csn_ready ? htonl(ifa->csn) : 0;
     auth->unused1 = 0;
     auth->unused2 = 0;
     ifa->csn_ready = 1;
 
+    if (pass->alg < ALG_HMAC)
+      auth->auth_len += sizeof(struct rip_auth_tail);
+
     /*
      * Note that RFC 4822 is unclear whether auth_len should cover whole
      * authentication trailer or just auth_data length.
      *
+     * FIXME: We should use just auth_data length by default. Currently we put
+     * the whole auth trailer length in keyed hash case to keep old behavior,
+     * but we put just auth_data length in the new HMAC case. Note that Quagga
+     * has config option for this.
+     *
      * Crypto sequence numbers are increased by sender in rip_update_csn().
      * First CSN should be zero, this is handled by csn_ready.
      */
@@ -238,14 +243,18 @@ rip_fill_authentication(struct rip_proto *p, struct rip_iface *ifa, struct rip_p
     struct rip_auth_tail *tail = (void *) ((byte *) pkt + *plen);
     tail->must_be_ffff = htons(0xffff);
     tail->must_be_0001 = htons(0x0001);
-    strncpy(tail->auth_data, pass->password, RIP_MD5_LENGTH);
 
-    *plen += sizeof(struct rip_auth_tail) + RIP_MD5_LENGTH;
+    uint auth_len = mac_type_length(pass->alg);
+    *plen += sizeof(struct rip_auth_tail) + auth_len;
 
-    struct hash_context ctx;
-    md5_init(&ctx);
-    md5_update(&ctx, (byte *) pkt, *plen);
-    memcpy(tail->auth_data, md5_final(&ctx), RIP_MD5_LENGTH);
+    /* Append key for keyed hash, append padding for HMAC (RFC 4822 2.5) */
+    if (pass->alg < ALG_HMAC)
+      strncpy(tail->auth_data, pass->password, auth_len);
+    else
+      memset32(tail->auth_data, HMAC_MAGIC, auth_len / 4);
+
+    mac_fill(pass->alg, pass->password, pass->length,
+	     (byte *) pkt, *plen, tail->auth_data);
     return;
 
   default:
@@ -288,13 +297,25 @@ rip_check_authentication(struct rip_proto *p, struct rip_iface *ifa, struct rip_
       DROP("no suitable password found", auth->key_id);
 
     uint data_len = ntohs(auth->packet_len);
-    uint auth_len = sizeof(struct rip_auth_tail) + RIP_MD5_LENGTH;
+    uint auth_len = mac_type_length(pass->alg);
+    uint auth_len2 = sizeof(struct rip_auth_tail) + auth_len;
 
-    if (data_len + auth_len != *plen)
-      DROP("packet length mismatch", data_len);
+    /*
+     * Ideally, first check should be check for internal consistency:
+     *   (data_len + sizeof(struct rip_auth_tail) + auth->auth_len) != *plen
+     *
+     * Second one should check expected code length:
+     *   auth->auth_len != auth_len
+     *
+     * But as auth->auth_len has two interpretations, we simplify this
+     */
 
-    if ((auth->auth_len != RIP_MD5_LENGTH) && (auth->auth_len != auth_len))
-      DROP("authentication data length mismatch", auth->auth_len);
+    if (data_len + auth_len2 != *plen)
+      DROP("packet length mismatch", *plen);
+
+    /* Warning: two interpretations of auth_len field */
+    if ((auth->auth_len != auth_len) && (auth->auth_len != auth_len2))
+      DROP("wrong authentication length", auth->auth_len);
 
     struct rip_auth_tail *tail = (void *) ((byte *) pkt + data_len);
     if ((tail->must_be_ffff != htons(0xffff)) || (tail->must_be_0001 != htons(0x0001)))
@@ -312,17 +333,18 @@ rip_check_authentication(struct rip_proto *p, struct rip_iface *ifa, struct rip_
       return 0;
     }
 
-    char received[RIP_MD5_LENGTH];
-    memcpy(received, tail->auth_data, RIP_MD5_LENGTH);
-    strncpy(tail->auth_data, pass->password, RIP_MD5_LENGTH);
+    byte *auth_data = alloca(auth_len);
+    memcpy(auth_data, tail->auth_data, auth_len);
 
-    struct hash_context ctx;
-    md5_init(&ctx);
-    md5_update(&ctx, (byte *) pkt, *plen);
-    char *computed = md5_final(&ctx);
+    /* Append key for keyed hash, append padding for HMAC (RFC 4822 2.5) */
+    if (pass->alg < ALG_HMAC)
+      strncpy(tail->auth_data, pass->password, auth_len);
+    else
+      memset32(tail->auth_data, HMAC_MAGIC, auth_len / 4);
 
-    if (memcmp(received, computed, RIP_MD5_LENGTH))
-      DROP("wrong MD5 digest", pass->id);
+    if (!mac_verify(pass->alg, pass->password, pass->length,
+		    (byte *) pkt, *plen, auth_data))
+      DROP("wrong authentication code", pass->id);
 
     *plen = data_len;
     n->csn = rcv_csn;
diff --git a/proto/rip/rip.c b/proto/rip/rip.c
index 37cfa9ac..7b380097 100644
--- a/proto/rip/rip.c
+++ b/proto/rip/rip.c
@@ -590,7 +590,7 @@ rip_iface_update_buffers(struct rip_iface *ifa)
   ifa->tx_plen = tbsize - headers;
 
   if (ifa->cf->auth_type == RIP_AUTH_CRYPTO)
-    ifa->tx_plen -= RIP_AUTH_TAIL_LENGTH;
+    ifa->tx_plen -= RIP_AUTH_TAIL_LENGTH + max_mac_length(ifa->cf->passwords);
 }
 
 static inline void
@@ -702,12 +702,11 @@ rip_reconfigure_iface(struct rip_proto *p, struct rip_iface *ifa, struct rip_ifa
 
   ifa->cf = new;
 
+  rip_iface_update_buffers(ifa);
+
   if (ifa->next_regular > (now + new->update_time))
     ifa->next_regular = now + (random() % new->update_time) + 1;
 
-  if ((new->tx_length != old->tx_length) || (new->rx_buffer != old->rx_buffer))
-    rip_iface_update_buffers(ifa);
-
   if (new->check_link != old->check_link)
     rip_iface_update_state(ifa);
 
diff --git a/proto/rip/rip.h b/proto/rip/rip.h
index f245e612..b24d9536 100644
--- a/proto/rip/rip.h
+++ b/proto/rip/rip.h
@@ -40,7 +40,7 @@
 #define RIP_NG_PORT		521	/* RIPng */
 
 #define RIP_MAX_PKT_LENGTH	532	/* 512 + IP4_HEADER_LENGTH */
-#define RIP_AUTH_TAIL_LENGTH	20	/* 4 + MD5 length */
+#define RIP_AUTH_TAIL_LENGTH	4	/* Without auth_data */
 
 #define RIP_DEFAULT_ECMP_LIMIT	16
 #define RIP_DEFAULT_INFINITY	16

From 29239ba2bbee3e9ec7d17793b25936a1bfc795ca Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Thu, 27 Oct 2016 20:58:21 +0200
Subject: [PATCH 156/165] OSPF: Use message authentication interface

Based on former commit from Pavel Tvrdik
---
 proto/ospf/config.Y |  14 ++++++
 proto/ospf/iface.c  |  24 ++++++++--
 proto/ospf/ospf.h   |  21 +++++----
 proto/ospf/packet.c | 108 ++++++++++++++++++++------------------------
 4 files changed, 94 insertions(+), 73 deletions(-)

diff --git a/proto/ospf/config.Y b/proto/ospf/config.Y
index c859960f..7b35b191 100644
--- a/proto/ospf/config.Y
+++ b/proto/ospf/config.Y
@@ -42,6 +42,20 @@ ospf_iface_finish(void)
 
   if ((ip->autype == OSPF_AUTH_NONE) && (ip->passwords != NULL))
     log(L_WARN "Password option without authentication option does not make sense");
+
+  if (ip->passwords)
+  {
+    struct password_item *pass;
+    WALK_LIST(pass, *ip->passwords)
+    {
+      if (pass->alg && (ip->autype != OSPF_AUTH_CRYPT))
+	cf_error("Password algorithm option requires cryptographic authentication");
+
+      /* Set default OSPF crypto algorithms */
+      if (!pass->alg && (ip->autype == OSPF_AUTH_CRYPT))
+	pass->alg = ospf_cfg_is_v2() ? ALG_MD5 : ALG_HMAC_SHA256;
+    }
+  }
 }
 
 static void
diff --git a/proto/ospf/iface.c b/proto/ospf/iface.c
index 67ae094d..280fa4c1 100644
--- a/proto/ospf/iface.c
+++ b/proto/ospf/iface.c
@@ -9,6 +9,7 @@
  */
 
 #include "ospf.h"
+#include "nest/password.h"
 
 
 const char *ospf_is_names[] = {
@@ -51,6 +52,18 @@ ifa_tx_length(struct ospf_iface *ifa)
   return ifa->cf->tx_length ?: ifa->iface->mtu;
 }
 
+static inline uint
+ifa_tx_hdrlen(struct ospf_iface *ifa)
+{
+  uint hlen = SIZE_OF_IP_HEADER;
+
+  /* Relevant just for OSPFv2 */
+  if (ifa->autype == OSPF_AUTH_CRYPT)
+    hlen += max_mac_length(ifa->passwords);
+
+  return hlen;
+}
+
 static inline uint
 ifa_bufsize(struct ospf_iface *ifa)
 {
@@ -67,11 +80,7 @@ ifa_flood_queue_size(struct ospf_iface *ifa)
 int
 ospf_iface_assure_bufsize(struct ospf_iface *ifa, uint plen)
 {
-  plen += SIZE_OF_IP_HEADER;
-
-  /* This is relevant just for OSPFv2 */
-  if (ifa->autype == OSPF_AUTH_CRYPT)
-    plen += OSPF_AUTH_CRYPT_SIZE;
+  plen += ifa->tx_hdrlen;
 
   if (plen <= ifa->sk->tbsize)
     return 0;
@@ -574,6 +583,7 @@ ospf_iface_new(struct ospf_area *oa, struct ifa *addr, struct ospf_iface_patt *i
   ifa->stub = ospf_iface_stubby(ip, addr);
   ifa->ioprob = OSPF_I_OK;
   ifa->tx_length = ifa_tx_length(ifa);
+  ifa->tx_hdrlen = ifa_tx_hdrlen(ifa);
   ifa->check_link = ip->check_link;
   ifa->ecmp_weight = ip->ecmp_weight;
   ifa->check_ttl = (ip->ttl_security == 1);
@@ -684,6 +694,7 @@ ospf_iface_new_vlink(struct ospf_proto *p, struct ospf_iface_patt *ip)
   ifa->deadint = ip->deadint;
   ifa->inftransdelay = ip->inftransdelay;
   ifa->tx_length = ospf_is_v2(p) ? IP4_MIN_MTU : IP6_MIN_MTU;
+  ifa->tx_hdrlen = ifa_tx_hdrlen(ifa);
   ifa->autype = ip->autype;
   ifa->passwords = ip->passwords;
   ifa->instance_id = ip->instance_id;
@@ -824,6 +835,9 @@ ospf_iface_reconfigure(struct ospf_iface *ifa, struct ospf_iface_patt *new)
   /* Update passwords */
   ifa->passwords = new->passwords;
 
+  /* Update header length */
+  ifa->tx_hdrlen = ifa_tx_hdrlen(ifa);
+
   /* Remaining options are just for proper interfaces */
   if (ifa->type == OSPF_IT_VLINK)
     return 1;
diff --git a/proto/ospf/ospf.h b/proto/ospf/ospf.h
index ca30e4e0..81c610d5 100644
--- a/proto/ospf/ospf.h
+++ b/proto/ospf/ospf.h
@@ -180,11 +180,7 @@ struct ospf_iface_patt
 
 #define OSPF_RXBUF_MINSIZE 256	/* Minimal allowed size */
   u8 instance_id;
-  u8 autype;			/* Not really used in OSPFv3 */
-#define OSPF_AUTH_NONE 0
-#define OSPF_AUTH_SIMPLE 1
-#define OSPF_AUTH_CRYPT 2
-#define OSPF_AUTH_CRYPT_SIZE 16
+  u8 autype;			/* OSPF_AUTH_*, not really used in OSPFv3 */
   u8 strictnbma;
   u8 check_link;
   u8 ecmp_weight;
@@ -334,6 +330,7 @@ struct ospf_iface
   u8 marked;			/* Used in OSPF reconfigure, 2 for force restart */
   u16 rxbuf;			/* Buffer size */
   u16 tx_length;		/* Soft TX packet length limit, usually MTU */
+  u16 tx_hdrlen;		/* Expected packet header length, less than tx_length */
   u8 check_link;		/* Whether iface link change is used */
   u8 ecmp_weight;		/* Weight used for ECMP */
   u8 link_lsa_suppression;	/* Suppression of Link-LSA origination */
@@ -424,6 +421,11 @@ struct ospf_neighbor
 #define ISM_UNLOOP	5	/* Link up */
 #define ISM_DOWN	6	/* Interface down */
 
+/* OSPF authentication types */
+#define OSPF_AUTH_NONE	0
+#define OSPF_AUTH_SIMPLE 1
+#define OSPF_AUTH_CRYPT	2
+
 
 /* OSPF neighbor states */
 #define NEIGHBOR_DOWN	0
@@ -455,7 +457,6 @@ struct ospf_neighbor
 #define TRANS_WAIT	2	/* Waiting before the end of translation */
 
 
-
 /* Generic option flags */
 #define OPT_V6		0x01	/* OSPFv3, LSA relevant for IPv6 routing calculation */
 #define OPT_E		0x02	/* Related to AS-external LSAs */
@@ -491,7 +492,7 @@ struct ospf_packet
   u8 autype;			/* Undefined for OSPFv3 */
 };
 
-struct ospf_md5
+struct ospf_auth_crypto
 {
   u16 zero;
   u8 keyid;
@@ -502,7 +503,7 @@ struct ospf_md5
 union ospf_auth
 {
   u8 password[8];
-  struct ospf_md5 md5;
+  struct ospf_auth_crypto c32;
 };
 
 /* Packet types */
@@ -896,7 +897,6 @@ void ospf_sh_neigh_info(struct ospf_neighbor *n);
 
 /* packet.c */
 void ospf_pkt_fill_hdr(struct ospf_iface *ifa, void *buf, u8 h_type);
-uint ospf_pkt_maxsize(struct ospf_iface *ifa);
 int ospf_rx_hook(sock * sk, uint size);
 // void ospf_tx_hook(sock * sk);
 void ospf_err_hook(sock * sk, int err);
@@ -905,6 +905,9 @@ void ospf_send_to(struct ospf_iface *ifa, ip_addr ip);
 void ospf_send_to_agt(struct ospf_iface *ifa, u8 state);
 void ospf_send_to_bdr(struct ospf_iface *ifa);
 
+static inline uint ospf_pkt_maxsize(struct ospf_iface *ifa)
+{ return ifa->tx_length - ifa->tx_hdrlen; }
+
 static inline void ospf_send_to_all(struct ospf_iface *ifa)
 { ospf_send_to(ifa, ifa->all_routers); }
 
diff --git a/proto/ospf/packet.c b/proto/ospf/packet.c
index a2fbd089..6b6a97a4 100644
--- a/proto/ospf/packet.c
+++ b/proto/ospf/packet.c
@@ -32,25 +32,12 @@ ospf_pkt_fill_hdr(struct ospf_iface *ifa, void *buf, u8 h_type)
   pkt->autype = ifa->autype;
 }
 
-uint
-ospf_pkt_maxsize(struct ospf_iface *ifa)
-{
-  uint headers = SIZE_OF_IP_HEADER;
-
-  /* Relevant just for OSPFv2 */
-  if (ifa->autype == OSPF_AUTH_CRYPT)
-    headers += OSPF_AUTH_CRYPT_SIZE;
-
-  return ifa->tx_length - headers;
-}
-
 /* We assume OSPFv2 in ospf_pkt_finalize() */
 static void
-ospf_pkt_finalize(struct ospf_iface *ifa, struct ospf_packet *pkt)
+ospf_pkt_finalize(struct ospf_iface *ifa, struct ospf_packet *pkt, uint *plen)
 {
-  struct password_item *passwd = NULL;
+  struct password_item *pass = NULL;
   union ospf_auth *auth = (void *) (pkt + 1);
-  uint plen = ntohs(pkt->length);
 
   pkt->checksum = 0;
   pkt->autype = ifa->autype;
@@ -62,25 +49,25 @@ ospf_pkt_finalize(struct ospf_iface *ifa, struct ospf_packet *pkt)
   switch (ifa->autype)
   {
   case OSPF_AUTH_SIMPLE:
-    passwd = password_find(ifa->passwords, 1);
-    if (!passwd)
+    pass = password_find(ifa->passwords, 1);
+    if (!pass)
     {
       log(L_ERR "No suitable password found for authentication");
       return;
     }
-    strncpy(auth->password, passwd->password, sizeof(auth->password));
+    strncpy(auth->password, pass->password, sizeof(auth->password));
 
   case OSPF_AUTH_NONE:
     {
       void *body = (void *) (auth + 1);
-      uint blen = plen - sizeof(struct ospf_packet) - sizeof(union ospf_auth);
+      uint blen = *plen - sizeof(struct ospf_packet) - sizeof(union ospf_auth);
       pkt->checksum = ipsum_calculate(pkt, sizeof(struct ospf_packet), body, blen, NULL);
     }
     break;
 
   case OSPF_AUTH_CRYPT:
-    passwd = password_find(ifa->passwords, 0);
-    if (!passwd)
+    pass = password_find(ifa->passwords, 0);
+    if (!pass)
     {
       log(L_ERR "No suitable password found for authentication");
       return;
@@ -101,20 +88,25 @@ ospf_pkt_finalize(struct ospf_iface *ifa, struct ospf_packet *pkt)
 
     ifa->csn_use = now;
 
-    auth->md5.zero = 0;
-    auth->md5.keyid = passwd->id;
-    auth->md5.len = OSPF_AUTH_CRYPT_SIZE;
-    auth->md5.csn = htonl(ifa->csn);
+    uint auth_len = mac_type_length(pass->alg);
+    byte *auth_tail = ((byte *) pkt + *plen);
+    *plen += auth_len;
+
+    ASSERT(*plen < ifa->sk->tbsize);
 
-    void *tail = ((void *) pkt) + plen;
-    char password[OSPF_AUTH_CRYPT_SIZE];
-    strncpy(password, passwd->password, sizeof(password));
+    auth->c32.zero = 0;
+    auth->c32.keyid = pass->id;
+    auth->c32.len = auth_len;
+    auth->c32.csn = htonl(ifa->csn);
 
-    struct hash_context ctx;
-    md5_init(&ctx);
-    md5_update(&ctx, (char *) pkt, plen);
-    md5_update(&ctx, password, OSPF_AUTH_CRYPT_SIZE);
-    memcpy((byte *) tail, md5_final(&ctx), MD5_SIZE);
+    /* Append key for keyed hash, append padding for HMAC (RFC 5709 3.3) */
+    if (pass->alg < ALG_HMAC)
+      strncpy(auth_tail, pass->password, auth_len);
+    else
+      memset32(auth_tail, HMAC_MAGIC, auth_len / 4);
+
+    mac_fill(pass->alg, pass->password, pass->length,
+	     (byte *) pkt, *plen, auth_tail);
     break;
 
   default:
@@ -155,13 +147,19 @@ ospf_pkt_checkauth(struct ospf_neighbor *n, struct ospf_iface *ifa, struct ospf_
     return 1;
 
   case OSPF_AUTH_CRYPT:
-    if (auth->md5.len != OSPF_AUTH_CRYPT_SIZE)
-      DROP("invalid MD5 digest length", auth->md5.len);
+    pass = password_find_by_id(ifa->passwords, auth->c32.keyid);
+    if (!pass)
+      DROP("no suitable password found", auth->c32.keyid);
+
+    uint auth_len = mac_type_length(pass->alg);
 
-    if (plen + OSPF_AUTH_CRYPT_SIZE > len)
-      DROP("length mismatch", len);
+    if (plen + auth->c32.len > len)
+      DROP("packet length mismatch", len);
 
-    u32 rcv_csn = ntohl(auth->md5.csn);
+    if (auth->c32.len != auth_len)
+      DROP("wrong authentication length", auth->c32.len);
+
+    u32 rcv_csn = ntohl(auth->c32.csn);
     if (n && (rcv_csn < n->csn))
       // DROP("lower sequence number", rcv_csn);
     {
@@ -172,22 +170,19 @@ ospf_pkt_checkauth(struct ospf_neighbor *n, struct ospf_iface *ifa, struct ospf_
       return 0;
     }
 
-    pass = password_find_by_id(ifa->passwords, auth->md5.keyid);
-    if (!pass)
-      DROP("no suitable password found", auth->md5.keyid);
-
-    byte *tail = ((byte *) pkt) + plen;
-    char received[OSPF_AUTH_CRYPT_SIZE];
-    memcpy(received, tail, OSPF_AUTH_CRYPT_SIZE);
-    strncpy(tail, pass->password, OSPF_AUTH_CRYPT_SIZE);
+    byte *auth_tail = ((byte *) pkt) + plen;
+    byte *auth_data = alloca(auth_len);
+    memcpy(auth_data, auth_tail, auth_len);
 
-    struct hash_context ctx;
-    md5_init(&ctx);
-    md5_update(&ctx, (byte *) pkt, plen + OSPF_AUTH_CRYPT_SIZE);
-    char *computed = md5_final(&ctx);
+    /* Append key for keyed hash, append padding for HMAC (RFC 5709 3.3) */
+    if (pass->alg < ALG_HMAC)
+      strncpy(auth_tail, pass->password, auth_len);
+    else
+      memset32(auth_tail, HMAC_MAGIC, auth_len / 4);
 
-    if (memcmp(received, computed, OSPF_AUTH_CRYPT_SIZE))
-      DROP("wrong MD5 digest", pass->id);
+    if (!mac_verify(pass->alg, pass->password, pass->length,
+		    (byte *) pkt, plen + auth_len, auth_data))
+      DROP("wrong authentication code", pass->id);
 
     if (n)
       n->csn = rcv_csn;
@@ -473,15 +468,10 @@ ospf_send_to(struct ospf_iface *ifa, ip_addr dst)
 {
   sock *sk = ifa->sk;
   struct ospf_packet *pkt = (struct ospf_packet *) sk->tbuf;
-  int plen = ntohs(pkt->length);
+  uint plen = ntohs(pkt->length);
 
   if (ospf_is_v2(ifa->oa->po))
-  {
-    if (ifa->autype == OSPF_AUTH_CRYPT)
-      plen += OSPF_AUTH_CRYPT_SIZE;
-
-    ospf_pkt_finalize(ifa, pkt);
-  }
+    ospf_pkt_finalize(ifa, pkt, &plen);
 
   int done = sk_send_to(sk, plen, dst, 0);
   if (!done)

From e03dc6a984555e3c943735d50376cada2220bac8 Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Sun, 30 Oct 2016 23:51:23 +0100
Subject: [PATCH 157/165] BFD: Authentication

Implement BFD authentication (part of RFC 5880). Supports plaintext
passwords and cryptographic MD5 / SHA-1 authentication.

Based on former commit from Pavel Tvrdik
---
 doc/bird.sgml       |  41 +++++++-
 proto/bfd/bfd.c     |   2 +
 proto/bfd/bfd.h     |  19 +++-
 proto/bfd/config.Y  |  46 ++++++++-
 proto/bfd/packets.c | 245 +++++++++++++++++++++++++++++++++++++++++---
 5 files changed, 333 insertions(+), 20 deletions(-)

diff --git a/doc/bird.sgml b/doc/bird.sgml
index 7c34c208..6af0e0f6 100644
--- a/doc/bird.sgml
+++ b/doc/bird.sgml
@@ -672,7 +672,7 @@ agreement").
 	authentication is enabled, authentication can be enabled by separate,
 	protocol-dependent <cf/authentication/ option.
 
-	This option is allowed in OSPF and RIP protocols. BGP has also
+	This option is allowed in BFD, OSPF and RIP protocols. BGP has also
 	<cf/password/ option, but it is slightly different and described
 	separately.
 	Default: none.
@@ -1637,6 +1637,19 @@ protocol bfd [&lt;name&gt;] {
 		idle tx interval &lt;time&gt;;
 		multiplier &lt;num&gt;;
 		passive &lt;switch&gt;;
+		authentication none;
+		authentication simple;
+		authentication [meticulous] keyed md5|sha1;
+		password "&lt;text&gt;";
+		password "&lt;text&gt;" {
+			id &lt;num&gt;;
+			generate from "&lt;date&gt;";
+			generate to "&lt;date&gt;";
+			accept from "&lt;date&gt;";
+			accept to "&lt;date&gt;";
+			from "&lt;date&gt;";
+			to "&lt;date&gt;";
+		};
 	};
 	multihop {
 		interval &lt;time&gt;;
@@ -1720,6 +1733,32 @@ protocol bfd [&lt;name&gt;] {
 	sending control packets to the other side. This option allows to enable
 	passive mode, which means that the router does not send BFD packets
 	until it has received one from the other side. Default: disabled.
+
+	<tag>authentication none</tag>
+	No passwords are sent in BFD packets. This is the default value.
+
+	<tag>authentication simple</tag>
+	Every packet carries 16 bytes of password. Received packets lacking this
+	password are ignored. This authentication mechanism is very weak.
+
+	<tag>authentication [meticulous] keyed md5|sha1</tag>
+	An authentication code is appended to each packet. The cryptographic
+	algorithm is keyed MD5 or keyed SHA-1. Note that the algorithm is common
+	for all keys (on one interface), in contrast to OSPF or RIP, where it
+	is a per-key option. Passwords (keys) are not sent open via network.
+
+	The <cf/meticulous/ variant means that cryptographic sequence numbers
+	are increased for each sent packet, while in the basic variant they are
+	increased about once per second. Generally, the <cf/meticulous/ variant
+	offers better resistance to replay attacks but may require more
+	computation.
+
+	<tag>password "<M>text</M>"</tag>
+	Specifies a password used for authentication. See <ref id="dsc-pass"
+	name="password"> common option for detailed description. Note that
+	password option <cf/algorithm/ is not available in BFD protocol. The
+	algorithm is selected by <cf/authentication/ option for all passwords.
+
 </descrip>
 
 <sect1>Example
diff --git a/proto/bfd/bfd.c b/proto/bfd/bfd.c
index e7be6a8a..79135fae 100644
--- a/proto/bfd/bfd.c
+++ b/proto/bfd/bfd.c
@@ -316,6 +316,7 @@ bfd_session_timeout(struct bfd_session *s)
   s->rem_min_rx_int = 1;
   s->rem_demand_mode = 0;
   s->rem_detect_mult = 0;
+  s->rx_csn_known = 0;
 
   s->poll_active = 0;
   s->poll_scheduled = 0;
@@ -429,6 +430,7 @@ bfd_add_session(struct bfd_proto *p, ip_addr addr, ip_addr local, struct iface *
   s->rem_min_rx_int = 1;
   s->detect_mult = ifa->cf->multiplier;
   s->passive = ifa->cf->passive;
+  s->tx_csn = random_u32();
 
   s->tx_timer = tm2_new_init(p->tpool, bfd_tx_timer_hook, s, 0, 0);
   s->hold_timer = tm2_new_init(p->tpool, bfd_hold_timer_hook, s, 0, 0);
diff --git a/proto/bfd/bfd.h b/proto/bfd/bfd.h
index 9b61be64..46e09879 100644
--- a/proto/bfd/bfd.h
+++ b/proto/bfd/bfd.h
@@ -14,6 +14,7 @@
 #include "nest/iface.h"
 #include "nest/protocol.h"
 #include "nest/route.h"
+#include "nest/password.h"
 #include "conf/conf.h"
 #include "lib/hash.h"
 #include "lib/resource.h"
@@ -52,6 +53,8 @@ struct bfd_iface_config
   u32 idle_tx_int;
   u8 multiplier;
   u8 passive;
+  u8 auth_type;				/* Authentication type (BFD_AUTH_*) */
+  list *passwords;			/* Passwords for authentication */
 };
 
 struct bfd_neighbor
@@ -114,7 +117,7 @@ struct bfd_session
   u8 passive;
   u8 poll_active;
   u8 poll_scheduled;
-  
+
   u8 loc_state;
   u8 rem_state;
   u8 loc_diag;
@@ -141,6 +144,11 @@ struct bfd_session
   list request_list;			/* List of client requests (struct bfd_request) */
   bird_clock_t last_state_change;	/* Time of last state change */
   u8 notify_running;			/* 1 if notify hooks are running */
+
+  u8 rx_csn_known;			/* Received crypto sequence number is known */
+  u32 rx_csn;				/* Last received crypto sequence number */
+  u32 tx_csn;				/* Last transmitted crypto sequence number */
+  u32 tx_csn_time;			/* Timestamp of last tx_csn change */
 };
 
 
@@ -172,6 +180,15 @@ extern const char *bfd_state_names[];
 #define BFD_FLAG_DEMAND		(1 << 1)
 #define BFD_FLAG_MULTIPOINT	(1 << 0)
 
+#define BFD_AUTH_NONE			0
+#define BFD_AUTH_SIMPLE			1
+#define BFD_AUTH_KEYED_MD5		2
+#define BFD_AUTH_METICULOUS_KEYED_MD5	3
+#define BFD_AUTH_KEYED_SHA1		4
+#define BFD_AUTH_METICULOUS_KEYED_SHA1	5
+
+extern const u8 bfd_auth_type_to_hash_alg[];
+
 
 static inline void bfd_lock_sessions(struct bfd_proto *p) { pthread_spin_lock(&p->lock); }
 static inline void bfd_unlock_sessions(struct bfd_proto *p) { pthread_spin_unlock(&p->lock); }
diff --git a/proto/bfd/config.Y b/proto/bfd/config.Y
index 4affb927..73414362 100644
--- a/proto/bfd/config.Y
+++ b/proto/bfd/config.Y
@@ -22,11 +22,12 @@ extern struct bfd_config *bfd_cf;
 CF_DECLS
 
 CF_KEYWORDS(BFD, MIN, IDLE, RX, TX, INTERVAL, MULTIPLIER, PASSIVE,
-	INTERFACE, MULTIHOP, NEIGHBOR, DEV, LOCAL)
+	INTERFACE, MULTIHOP, NEIGHBOR, DEV, LOCAL, AUTHENTICATION,
+	NONE, SIMPLE, METICULOUS, KEYED, MD5, SHA1)
 
 %type <iface> bfd_neigh_iface
 %type <a> bfd_neigh_local
-%type <i> bfd_neigh_multihop
+%type <i> bfd_neigh_multihop bfd_auth_type
 
 CF_GRAMMAR
 
@@ -62,12 +63,35 @@ bfd_proto:
 bfd_iface_start:
 {
   this_ipatt = cfg_allocz(sizeof(struct bfd_iface_config));
+  add_tail(&BFD_CFG->patt_list, NODE this_ipatt);
   init_list(&this_ipatt->ipn_list);
 
   BFD_IFACE->min_rx_int = BFD_DEFAULT_MIN_RX_INT;
   BFD_IFACE->min_tx_int = BFD_DEFAULT_MIN_TX_INT;
   BFD_IFACE->idle_tx_int = BFD_DEFAULT_IDLE_TX_INT;
   BFD_IFACE->multiplier = BFD_DEFAULT_MULTIPLIER;
+
+  reset_passwords();
+};
+
+bfd_iface_finish:
+{
+  BFD_IFACE->passwords = get_passwords();
+
+  if (!BFD_IFACE->auth_type != !BFD_IFACE->passwords)
+    log(L_WARN "Authentication and password options should be used together");
+
+  if (BFD_IFACE->passwords)
+  {
+    struct password_item *pass;
+    WALK_LIST(pass, *BFD_IFACE->passwords)
+    {
+      if (pass->alg)
+        cf_error("Password algorithm option not available in BFD protocol");
+
+      pass->alg = bfd_auth_type_to_hash_alg[BFD_IFACE->auth_type];
+    }
+  }
 };
 
 bfd_iface_item:
@@ -77,6 +101,17 @@ bfd_iface_item:
  | IDLE TX INTERVAL expr_us { BFD_IFACE->idle_tx_int = $4; }
  | MULTIPLIER expr { BFD_IFACE->multiplier = $2; }
  | PASSIVE bool { BFD_IFACE->passive = $2; }
+ | AUTHENTICATION bfd_auth_type { BFD_IFACE->auth_type = $2; }
+ | password_list {}
+ ;
+
+bfd_auth_type:
+   NONE			 { $$ = BFD_AUTH_NONE; }
+ | SIMPLE 		 { $$ = BFD_AUTH_SIMPLE; }
+ | KEYED MD5		 { $$ = BFD_AUTH_KEYED_MD5; }
+ | KEYED SHA1   	 { $$ = BFD_AUTH_KEYED_SHA1; }
+ | METICULOUS KEYED MD5	 { $$ = BFD_AUTH_METICULOUS_KEYED_MD5; }
+ | METICULOUS KEYED SHA1 { $$ = BFD_AUTH_METICULOUS_KEYED_SHA1; }
  ;
 
 bfd_iface_opts:
@@ -89,10 +124,11 @@ bfd_iface_opt_list:
  | '{' bfd_iface_opts '}'
  ;
 
-bfd_iface: bfd_iface_start iface_patt_list_nopx bfd_iface_opt_list
-{ add_tail(&BFD_CFG->patt_list, NODE this_ipatt); };
+bfd_iface:
+  bfd_iface_start iface_patt_list_nopx bfd_iface_opt_list bfd_iface_finish;
 
-bfd_multihop: bfd_iface_start bfd_iface_opt_list
+bfd_multihop:
+  bfd_iface_start bfd_iface_opt_list bfd_iface_finish
 { BFD_CFG->multihop = BFD_IFACE; };
 
 
diff --git a/proto/bfd/packets.c b/proto/bfd/packets.c
index deb501fc..129db72f 100644
--- a/proto/bfd/packets.c
+++ b/proto/bfd/packets.c
@@ -5,24 +5,60 @@
  */
 
 #include "bfd.h"
+#include "lib/mac.h"
 
 
 struct bfd_ctl_packet
 {
-  u8 vdiag;			/* version and diagnostic */
-  u8 flags;			/* state and flags */
+  u8 vdiag;				/* Version and diagnostic */
+  u8 flags;				/* State and flags */
   u8 detect_mult;
-  u8 length;
-  u32 snd_id;			/* sender ID, aka 'my discriminator' */
-  u32 rcv_id;			/* receiver ID, aka 'your discriminator' */
+  u8 length;				/* Whole packet length */
+  u32 snd_id;				/* Sender ID, aka 'my discriminator' */
+  u32 rcv_id;				/* Receiver ID, aka 'your discriminator' */
   u32 des_min_tx_int;
   u32 req_min_rx_int;
   u32 req_min_echo_rx_int;
 };
 
+struct bfd_auth
+{
+  u8 type;				/* Authentication type (BFD_AUTH_*) */
+  u8 length;				/* Authentication section length */
+};
+
+struct bfd_simple_auth
+{
+  u8 type;				/* BFD_AUTH_SIMPLE */
+  u8 length;				/* Length of bfd_simple_auth + pasword length */
+  u8 key_id;				/* Key ID */
+  byte password[0];			/* Password itself, variable length */
+};
+
+#define BFD_MAX_PASSWORD_LENGTH 16
+
+struct bfd_crypto_auth
+{
+  u8 type;				/* BFD_AUTH_*_MD5 or BFD_AUTH_*_SHA1 */
+  u8 length;				/* Length of bfd_crypto_auth + hash length */
+  u8 key_id;				/* Key ID */
+  u8 zero;				/* Reserved, zero on transmit */
+  u32 csn;				/* Cryptographic sequence number */
+  byte data[0];				/* Authentication key/hash, length 16 or 20 */
+};
+
 #define BFD_BASE_LEN	sizeof(struct bfd_ctl_packet)
 #define BFD_MAX_LEN	64
 
+#define DROP(DSC,VAL) do { err_dsc = DSC; err_val = VAL; goto drop; } while(0)
+
+#define LOG_PKT(msg, args...) \
+  log(L_REMOTE "%s: " msg, p->p.name, args)
+
+#define LOG_PKT_AUTH(msg, args...) \
+  log(L_AUTH "%s: " msg, p->p.name, args)
+
+
 static inline u8 bfd_pack_vdiag(u8 version, u8 diag)
 { return (version << 5) | diag; }
 
@@ -59,6 +95,189 @@ bfd_format_flags(u8 flags, char *buf)
   return buf;
 }
 
+const u8 bfd_auth_type_to_hash_alg[] = {
+    [BFD_AUTH_NONE] = 			ALG_UNDEFINED,
+    [BFD_AUTH_SIMPLE] = 		ALG_UNDEFINED,
+    [BFD_AUTH_KEYED_MD5] = 		ALG_MD5,
+    [BFD_AUTH_METICULOUS_KEYED_MD5] = 	ALG_MD5,
+    [BFD_AUTH_KEYED_SHA1] = 		ALG_SHA1,
+    [BFD_AUTH_METICULOUS_KEYED_SHA1] = 	ALG_SHA1,
+};
+
+
+/* Fill authentication section and modifies final length in control section packet */
+static void
+bfd_fill_authentication(struct bfd_proto *p, struct bfd_session *s, struct bfd_ctl_packet *pkt)
+{
+  struct bfd_iface_config *cf = s->ifa->cf;
+  struct password_item *pass = password_find(cf->passwords, 0);
+  uint meticulous = 0;
+
+  if (!pass)
+  {
+    /* FIXME: This should not happen */
+    log(L_ERR "%s: No suitable password found for authentication", p->p.name);
+    return;
+  }
+
+  switch (cf->auth_type)
+  {
+  case BFD_AUTH_SIMPLE:
+  {
+    struct bfd_simple_auth *auth = (void *) (pkt + 1);
+    uint pass_len = MIN(pass->length, BFD_MAX_PASSWORD_LENGTH);
+
+    auth->type = BFD_AUTH_SIMPLE;
+    auth->length = sizeof(struct bfd_simple_auth) + pass_len;
+    auth->key_id = pass->id;
+
+    pkt->flags |= BFD_FLAG_AP;
+    pkt->length += auth->length;
+
+    memcpy(auth->password, pass->password, pass_len);
+    return;
+  }
+
+  case BFD_AUTH_METICULOUS_KEYED_MD5:
+  case BFD_AUTH_METICULOUS_KEYED_SHA1:
+    meticulous = 1;
+
+  case BFD_AUTH_KEYED_MD5:
+  case BFD_AUTH_KEYED_SHA1:
+  {
+    struct bfd_crypto_auth *auth = (void *) (pkt + 1);
+    uint hash_alg = bfd_auth_type_to_hash_alg[cf->auth_type];
+    uint hash_len = mac_type_length(pass->alg);
+
+    /* Increase CSN about one time per second */
+    u32  new_time = (u64) current_time() >> 20;
+    if ((new_time != s->tx_csn_time) || meticulous)
+    {
+      s->tx_csn++;
+      s->tx_csn_time = new_time;
+    }
+
+    DBG("[%I] CSN: %u\n", s->addr, s->last_tx_csn);
+
+    auth->type = cf->auth_type;
+    auth->length = sizeof(struct bfd_crypto_auth) + hash_len;
+    auth->key_id = pass->id;
+    auth->zero = 0;
+    auth->csn = htonl(s->tx_csn);
+
+    pkt->flags |= BFD_FLAG_AP;
+    pkt->length += auth->length;
+
+    strncpy(auth->data, pass->password, hash_len);
+    mac_fill(hash_alg, NULL, 0, (byte *) pkt, pkt->length, auth->data);
+    return;
+  }
+  }
+}
+
+static int
+bfd_check_authentication(struct bfd_proto *p, struct bfd_session *s, struct bfd_ctl_packet *pkt)
+{
+  struct bfd_iface_config *cf = s->ifa->cf;
+  const char *err_dsc = NULL;
+  uint err_val = 0;
+  uint auth_type = 0;
+  uint meticulous = 0;
+
+  if (pkt->flags & BFD_FLAG_AP)
+  {
+    struct bfd_auth *auth = (void *) (pkt + 1);
+
+    if ((pkt->length < (BFD_BASE_LEN + sizeof(struct bfd_auth))) ||
+	(pkt->length < (BFD_BASE_LEN + auth->length)))
+      DROP("packet length mismatch", pkt->length);
+
+    /* Zero is reserved, we use it as BFD_AUTH_NONE internally */
+    if (auth->type == 0)
+      DROP("reserved authentication type", 0);
+
+    auth_type = auth->type;
+  }
+
+  if (auth_type != cf->auth_type)
+    DROP("authentication method mismatch", auth_type);
+
+  switch (auth_type)
+  {
+  case BFD_AUTH_NONE:
+    return 1;
+
+  case BFD_AUTH_SIMPLE:
+  {
+    struct bfd_simple_auth *auth = (void *) (pkt + 1);
+
+    if (auth->length < sizeof(struct bfd_simple_auth))
+      DROP("wrong authentication length", auth->length);
+
+    struct password_item *pass = password_find_by_id(cf->passwords, auth->key_id);
+    if (!pass)
+      DROP("no suitable password found", auth->key_id);
+
+    uint pass_len = MIN(pass->length, BFD_MAX_PASSWORD_LENGTH);
+    uint auth_len = sizeof(struct bfd_simple_auth) + pass_len;
+
+    if ((auth->length != auth_len) || memcmp(auth->password, pass->password, pass_len))
+      DROP("wrong password", pass->id);
+
+    return 1;
+  }
+
+  case BFD_AUTH_METICULOUS_KEYED_MD5:
+  case BFD_AUTH_METICULOUS_KEYED_SHA1:
+    meticulous = 1;
+
+  case BFD_AUTH_KEYED_MD5:
+  case BFD_AUTH_KEYED_SHA1:
+  {
+    struct bfd_crypto_auth *auth = (void *) (pkt + 1);
+    uint hash_alg = bfd_auth_type_to_hash_alg[cf->auth_type];
+    uint hash_len = mac_type_length(hash_alg);
+
+    if (auth->length != (sizeof(struct bfd_crypto_auth) + hash_len))
+      DROP("wrong authentication length", auth->length);
+
+    struct password_item *pass = password_find_by_id(cf->passwords, auth->key_id);
+    if (!pass)
+      DROP("no suitable password found", auth->key_id);
+
+    /* BFD CSNs are in 32-bit circular number space */
+    u32 csn = ntohl(auth->csn);
+    if (s->rx_csn_known &&
+	(((csn - s->rx_csn) > (3 * s->detect_mult)) ||
+	 (meticulous && (csn == s->rx_csn))))
+    {
+      /* We want to report both new and old CSN */
+      LOG_PKT_AUTH("Authentication failed for %I - "
+		   "wrong sequence number (rcv %u, old %u)",
+		   s->addr, csn, s->rx_csn);
+      return 0;
+    }
+
+    byte *auth_data = alloca(hash_len);
+    memcpy(auth_data, auth->data, hash_len);
+    strncpy(auth->data, pass->password, hash_len);
+
+    if (!mac_verify(hash_alg, NULL, 0, (byte *) pkt, pkt->length, auth_data))
+      DROP("wrong authentication code", pass->id);
+
+    s->rx_csn = csn;
+    s->rx_csn_known = 1;
+
+    return 1;
+  }
+  }
+
+drop:
+  LOG_PKT_AUTH("Authentication failed for %I - %s (%u)",
+	       s->addr, err_dsc, err_val);
+  return 0;
+}
+
 void
 bfd_send_ctl(struct bfd_proto *p, struct bfd_session *s, int final)
 {
@@ -85,6 +304,9 @@ bfd_send_ctl(struct bfd_proto *p, struct bfd_session *s, int final)
   else if (s->poll_active)
     pkt->flags |= BFD_FLAG_POLL;
 
+  if (s->ifa->cf->auth_type)
+    bfd_fill_authentication(p, s, pkt);
+
   if (sk->tbuf != sk->tpos)
     log(L_WARN "%s: Old packet overwritten in TX buffer", p->p.name);
 
@@ -94,8 +316,6 @@ bfd_send_ctl(struct bfd_proto *p, struct bfd_session *s, int final)
   sk_send_to(sk, pkt->length, s->addr, sk->dport);
 }
 
-#define DROP(DSC,VAL) do { err_dsc = DSC; err_val = VAL; goto drop; } while(0)
-
 static int
 bfd_rx_hook(sock *sk, uint len)
 {
@@ -151,10 +371,9 @@ bfd_rx_hook(sock *sk, uint len)
       return 1;
   }
 
-  /* FIXME: better authentication handling and message */
-  if (pkt->flags & BFD_FLAG_AP)
-    DROP("authentication not supported", 0);
-
+  /* bfd_check_authentication() has its own error logging */
+  if (!bfd_check_authentication(p, s, pkt))
+    return 1;
 
   u32 old_tx_int = s->des_min_tx_int;
   u32 old_rx_int = s->rem_min_rx_int;
@@ -173,8 +392,8 @@ bfd_rx_hook(sock *sk, uint len)
   bfd_session_process_ctl(s, pkt->flags, old_tx_int, old_rx_int);
   return 1;
 
- drop:
-  log(L_REMOTE "%s: Bad packet from %I - %s (%u)", p->p.name, sk->faddr, err_dsc, err_val);
+drop:
+  LOG_PKT("Bad packet from %I - %s (%u)", sk->faddr, err_dsc, err_val);
   return 1;
 }
 

From 920a86e8493fe25008f084f67f368aea9b197efd Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Thu, 3 Nov 2016 09:53:53 +0100
Subject: [PATCH 158/165] Add missing extern

---
 lib/mac.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/mac.h b/lib/mac.h
index 5fc216fd..b6f3af52 100644
--- a/lib/mac.h
+++ b/lib/mac.h
@@ -89,7 +89,7 @@ struct mac_desc {
   byte *(*hash_final)(struct hash_context *ctx);
 };
 
-const struct mac_desc mac_table[ALG_MAX];
+extern const struct mac_desc mac_table[ALG_MAX];
 
 static inline const char *mac_type_name(uint id)
 { return mac_table[id].name; }

From c8cafc8ebb5320ac7c6117c17e6460036f0fdf62 Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Tue, 8 Nov 2016 17:46:29 +0100
Subject: [PATCH 159/165] Minor code cleanups

---
 conf/cf-lex.l          |  2 +-
 conf/conf.c            |  6 +++---
 conf/conf.h            |  6 +++---
 conf/confbase.Y        |  2 +-
 filter/config.Y        | 26 +++++++++++++-------------
 filter/filter.h        | 24 ++++++++++++------------
 filter/tree.c          |  6 +++---
 lib/buffer.h           | 16 +++++++++++++++-
 lib/hash.h             | 13 ++++++++++++-
 proto/ospf/rt.c        |  4 ++--
 sysdep/linux/syspriv.h |  9 +++++++++
 sysdep/unix/io.c       |  5 ++++-
 sysdep/unix/main.c     |  4 +++-
 13 files changed, 81 insertions(+), 42 deletions(-)

diff --git a/conf/cf-lex.l b/conf/cf-lex.l
index d2aa6402..e9e385a6 100644
--- a/conf/cf-lex.l
+++ b/conf/cf-lex.l
@@ -589,7 +589,7 @@ cf_lex_init(int is_cli, struct config *c)
     cf_lex_init_kh();
 
   ifs_head = ifs = push_ifs(NULL);
-  if (!is_cli) 
+  if (!is_cli)
     {
       ifs->file_name = c->file_name;
       ifs->fd = c->file_fd;
diff --git a/conf/conf.c b/conf/conf.c
index 029814c6..0a4e3f8c 100644
--- a/conf/conf.c
+++ b/conf/conf.c
@@ -85,7 +85,7 @@ int undo_available;			/* Undo was not requested from last reconfiguration */
  * further use. Returns a pointer to the structure.
  */
 struct config *
-config_alloc(byte *name)
+config_alloc(const byte *name)
 {
   pool *p = rp_new(&root_pool, "Config");
   linpool *l = lp_new(p, 4080);
@@ -405,7 +405,7 @@ config_confirm(void)
  * if it's been queued due to another reconfiguration being in progress now,
  * %CONF_UNQUEUED if a scheduled reconfiguration is removed, %CONF_NOTHING
  * if there is no relevant configuration to undo (the previous config request
- * was config_undo() too)  or %CONF_SHUTDOWN if BIRD is in shutdown mode and 
+ * was config_undo() too)  or %CONF_SHUTDOWN if BIRD is in shutdown mode and
  * no new configuration changes  are accepted.
  */
 int
@@ -530,7 +530,7 @@ cf_error(char *msg, ...)
  * and we want to preserve it for further use.
  */
 char *
-cfg_strdup(char *c)
+cfg_strdup(const char *c)
 {
   int l = strlen(c) + 1;
   char *z = cfg_allocu(l);
diff --git a/conf/conf.h b/conf/conf.h
index 89a2c5b7..41cb434f 100644
--- a/conf/conf.h
+++ b/conf/conf.h
@@ -21,7 +21,7 @@ struct config {
   list protos;				/* Configured protocol instances (struct proto_config) */
   list tables;				/* Configured routing tables (struct rtable_config) */
   list roa_tables;			/* Configured ROA tables (struct roa_table_config) */
-  list logfiles;			/* Configured log fils (sysdep) */
+  list logfiles;			/* Configured log files (sysdep) */
 
   int mrtdump_file;			/* Configured MRTDump file (sysdep, fd in unix) */
   char *syslog_name;			/* Name used for syslog (NULL -> no syslog) */
@@ -61,7 +61,7 @@ struct config {
 extern struct config *config;		/* Currently active configuration */
 extern struct config *new_config;	/* Configuration being parsed */
 
-struct config *config_alloc(byte *name);
+struct config *config_alloc(const byte *name);
 int config_parse(struct config *);
 int cli_parse(struct config *);
 void config_free(struct config *);
@@ -95,7 +95,7 @@ extern linpool *cfg_mem;
 #define cfg_alloc(size) lp_alloc(cfg_mem, size)
 #define cfg_allocu(size) lp_allocu(cfg_mem, size)
 #define cfg_allocz(size) lp_allocz(cfg_mem, size)
-char *cfg_strdup(char *c);
+char *cfg_strdup(const char *c);
 void cfg_copy_list(list *dest, list *src, unsigned node_size);
 
 /* Lexer */
diff --git a/conf/confbase.Y b/conf/confbase.Y
index c14c23c7..96b32028 100644
--- a/conf/confbase.Y
+++ b/conf/confbase.Y
@@ -138,7 +138,7 @@ expr_us:
 /* Switches */
 
 bool:
-   expr {$$ = !!$1; }
+   expr { $$ = !!$1; }
  | ON { $$ = 1; }
  | YES { $$ = 1; }
  | OFF { $$ = 0; }
diff --git a/filter/config.Y b/filter/config.Y
index 29e3a734..5ea83f81 100644
--- a/filter/config.Y
+++ b/filter/config.Y
@@ -158,7 +158,7 @@ f_new_lc_item(u32 f1, u32 t1, u32 f2, u32 t2, u32 f3, u32 t3)
 
 static inline struct f_inst *
 f_generate_empty(struct f_inst *dyn)
-{ 
+{
   struct f_inst *e = f_new_inst();
   e->code = 'E';
 
@@ -261,7 +261,7 @@ f_generate_ec(u16 kind, struct f_inst *tk, struct f_inst *tv)
 
   if (c1 && c2) {
     u64 ec;
-  
+
     if (kind == EC_GENERIC) {
       ec = ec_generic(key, val2);
     }
@@ -280,7 +280,7 @@ f_generate_ec(u16 kind, struct f_inst *tk, struct f_inst *tv)
     NEW_F_VAL;
     rv = f_new_inst();
     rv->code = 'C';
-    rv->a1.p = val;    
+    rv->a1.p = val;
     val->type = T_EC;
     val->val.ec = ec;
   }
@@ -355,7 +355,7 @@ CF_KEYWORDS(FUNCTION, PRINT, PRINTN, UNSET, RETURN,
 %type <e> pair_item ec_item lc_item set_item switch_item set_items switch_items switch_body
 %type <trie> fprefix_set
 %type <v> set_atom switch_atom fprefix fprefix_s fipa
-%type <s> decls declsn one_decl function_params 
+%type <s> decls declsn one_decl function_params
 %type <h> bgp_path bgp_path_tail1 bgp_path_tail2
 
 CF_GRAMMAR
@@ -391,7 +391,7 @@ type:
  | CLIST { $$ = T_CLIST; }
  | ECLIST { $$ = T_ECLIST; }
  | LCLIST { $$ = T_LCLIST; }
- | type SET { 
+ | type SET {
 	switch ($1) {
 	  case T_INT:
 	  case T_PAIR:
@@ -506,7 +506,7 @@ function_def:
    } function_params function_body {
      $2->def = $5;
      $2->aux2 = $4;
-     DBG("Hmm, we've got one function here - %s\n", $2->name); 
+     DBG("Hmm, we've got one function here - %s\n", $2->name);
      cf_pop_scope();
    }
  ;
@@ -652,7 +652,7 @@ fprefix:
    fprefix_s { $$ = $1; }
  | fprefix_s '+' { $$ = $1; $$.val.px.len |= LEN_PLUS; }
  | fprefix_s '-' { $$ = $1; $$.val.px.len |= LEN_MINUS; }
- | fprefix_s '{' NUM ',' NUM '}' { 
+ | fprefix_s '{' NUM ',' NUM '}' {
      if (! ((0 <= $3) && ($3 <= $5) && ($5 <= MAX_PREFIX_LENGTH))) cf_error("Invalid prefix pattern range: {%d, %d}.", $3, $5);
      $$ = $1; $$.val.px.len |= LEN_RANGE | ($3 << 16) | ($5 << 8);
    }
@@ -671,7 +671,7 @@ switch_body: /* EMPTY */ { $$ = NULL; }
        t->data = $4;
      $$ = f_merge_items($1, $2);
    }
- | switch_body ELSECOL cmds { 
+ | switch_body ELSECOL cmds {
      struct f_tree *t = f_new_tree();
      t->from.type = t->to.type = T_VOID;
      t->right = t;
@@ -683,7 +683,7 @@ switch_body: /* EMPTY */ { $$ = NULL; }
 /* CONST '(' expr ')' { $$ = f_new_inst(); $$->code = 'c'; $$->aux = T_INT; $$->a2.i = $3; } */
 
 bgp_path_expr:
-   symbol       { $$ = $1; }   
+   symbol       { $$ = $1; }
  | '(' term ')' { $$ = $2; }
  ;
 
@@ -836,8 +836,8 @@ term:
  | '-' EMPTY '-' { $$ = f_new_inst(); $$->code = 'E'; $$->aux = T_CLIST; }
  | '-' '-' EMPTY '-' '-' { $$ = f_new_inst(); $$->code = 'E'; $$->aux = T_ECLIST; }
  | '-' '-' '-' EMPTY '-' '-' '-' { $$ = f_new_inst(); $$->code = 'E'; $$->aux = T_LCLIST; }
- | PREPEND '(' term ',' term ')' { $$ = f_new_inst(); $$->code = P('A','p'); $$->a1.p = $3; $$->a2.p = $5; } 
- | ADD '(' term ',' term ')' { $$ = f_new_inst(); $$->code = P('C','a'); $$->a1.p = $3; $$->a2.p = $5; $$->aux = 'a'; } 
+ | PREPEND '(' term ',' term ')' { $$ = f_new_inst(); $$->code = P('A','p'); $$->a1.p = $3; $$->a2.p = $5; }
+ | ADD '(' term ',' term ')' { $$ = f_new_inst(); $$->code = P('C','a'); $$->a1.p = $3; $$->a2.p = $5; $$->aux = 'a'; }
  | DELETE '(' term ',' term ')' { $$ = f_new_inst(); $$->code = P('C','a'); $$->a1.p = $3; $$->a2.p = $5; $$->aux = 'd'; }
  | FILTER '(' term ',' term ')' { $$ = f_new_inst(); $$->code = P('C','a'); $$->a1.p = $3; $$->a2.p = $5; $$->aux = 'f'; }
 
@@ -892,7 +892,7 @@ print_list: /* EMPTY */ { $$ = NULL; }
    }
  ;
 
-var_listn: term { 
+var_listn: term {
      $$ = f_new_inst();
      $$->code = 's';
      $$->a1.p = NULL;
@@ -960,7 +960,7 @@ cmd:
      $$ = f_new_inst();
      $$->code = P('P','S');
      $$->a1.p = $3;
-   } 
+   }
  | UNSET '(' rtadot dynamic_attr ')' ';' {
      $$ = $4;
      $$->aux = EAF_TYPE_UNDEF | EAF_TEMP;
diff --git a/filter/filter.h b/filter/filter.h
index e0f34e4f..049ceb76 100644
--- a/filter/filter.h
+++ b/filter/filter.h
@@ -35,7 +35,7 @@ struct f_inst {		/* Instruction */
 /* Not enough fields in f_inst for three args used by roa_check() */
 struct f_inst_roa_check {
   struct f_inst i;
-  struct roa_table_config *rtc;	
+  struct roa_table_config *rtc;
 };
 
 struct f_inst3 {
@@ -65,7 +65,7 @@ struct f_val {
     uint i;
     u64 ec;
     lcomm lc;
-    /*    ip_addr ip; Folded into prefix */	
+    /*    ip_addr ip; Folded into prefix */
     struct f_prefix px;
     char *s;
     struct f_tree *t;
@@ -190,16 +190,16 @@ void val_format(struct f_val v, buffer *buf);
 #define T_PREFIX_SET 0x81
 
 
-#define SA_FROM		 1    
-#define SA_GW		 2      
-#define SA_NET		 3     
-#define SA_PROTO	 4   
-#define SA_SOURCE	 5  
-#define SA_SCOPE	 6   
-#define SA_CAST    	 7
-#define SA_DEST    	 8
-#define SA_IFNAME  	 9
-#define SA_IFINDEX    	10
+#define SA_FROM		 1
+#define SA_GW		 2
+#define SA_NET		 3
+#define SA_PROTO	 4
+#define SA_SOURCE	 5
+#define SA_SCOPE	 6
+#define SA_CAST		 7
+#define SA_DEST		 8
+#define SA_IFNAME	 9
+#define SA_IFINDEX	10
 
 
 struct f_tree {
diff --git a/filter/tree.c b/filter/tree.c
index 1196e630..f8379fa8 100644
--- a/filter/tree.c
+++ b/filter/tree.c
@@ -63,7 +63,7 @@ tree_compare(const void *p1, const void *p2)
  * build_tree
  * @from: degenerated tree (linked by @tree->left) to be transformed into form suitable for find_tree()
  *
- * Transforms denerated tree into balanced tree.
+ * Transforms degenerated tree into balanced tree.
  */
 struct f_tree *
 build_tree(struct f_tree *from)
@@ -162,7 +162,7 @@ void
 tree_format(struct f_tree *t, buffer *buf)
 {
   buffer_puts(buf, "[");
- 
+
   tree_node_format(t, buf);
 
   if (buf->pos == buf->end)
@@ -171,6 +171,6 @@ tree_format(struct f_tree *t, buffer *buf)
   /* Undo last separator */
   if (buf->pos[-1] != '[')
     buf->pos -= 2;
- 
+
   buffer_puts(buf, "]");
 }
diff --git a/lib/buffer.h b/lib/buffer.h
index cf073e88..2a53f211 100644
--- a/lib/buffer.h
+++ b/lib/buffer.h
@@ -1,3 +1,17 @@
+/*
+ *	BIRD Library -- Generic Buffer Structure
+ *
+ *	(c) 2013 Ondrej Zajicek <santiago@crfreenet.org>
+ *	(c) 2013 CZ.NIC z.s.p.o.
+ *
+ *	Can be freely distributed and used under the terms of the GNU GPL.
+ */
+
+#ifndef _BIRD_BUFFER_H_
+#define _BIRD_BUFFER_H_
+
+#include "lib/resource.h"
+#include "sysdep/config.h"
 
 #define BUFFER(type)		struct { type *data; uint used, size; }
 
@@ -32,4 +46,4 @@
 
 #define BUFFER_FLUSH(v)		({ (v).used = 0; })
 
-
+#endif /* _BIRD_BUFFER_H_ */
diff --git a/lib/hash.h b/lib/hash.h
index fc5fea14..4239b1d8 100644
--- a/lib/hash.h
+++ b/lib/hash.h
@@ -1,4 +1,14 @@
-
+/*
+ *	BIRD Library -- Generic Hash Table
+ *
+ *	(c) 2013 Ondrej Zajicek <santiago@crfreenet.org>
+ *	(c) 2013 CZ.NIC z.s.p.o.
+ *
+ *	Can be freely distributed and used under the terms of the GNU GPL.
+ */
+
+#ifndef _BIRD_HASH_H_
+#define _BIRD_HASH_H_
 
 #define HASH(type)		struct { type **data; uint count, order; }
 #define HASH_TYPE(v)		typeof(** (v).data)
@@ -178,3 +188,4 @@
 
 #define HASH_WALK_FILTER_END } while (0)
 
+#endif
diff --git a/proto/ospf/rt.c b/proto/ospf/rt.c
index 8b3feda9..19f2d074 100644
--- a/proto/ospf/rt.c
+++ b/proto/ospf/rt.c
@@ -678,7 +678,7 @@ link_back(struct ospf_area *oa, struct top_hash_entry *en, struct top_hash_entry
      which may be later used as the next hop. */
 
   /* In OSPFv2, en->lb is set here. In OSPFv3, en->lb is just cleared here,
-     it is set in process_prefixes() to any global addres in the area */
+     it is set in process_prefixes() to any global address in the area */
 
   en->lb = IPA_NONE;
   en->lb_id = 0;
@@ -930,7 +930,7 @@ ospf_rt_sum_tr(struct ospf_area *oa)
   }
 }
 
-/* Decide about originating or flushing summary LSAs for condended area networks */
+/* Decide about originating or flushing summary LSAs for condensed area networks */
 static int
 decide_anet_lsa(struct ospf_area *oa, struct area_net *anet, struct ospf_area *anet_oa)
 {
diff --git a/sysdep/linux/syspriv.h b/sysdep/linux/syspriv.h
index d2ba95dd..8b210f06 100644
--- a/sysdep/linux/syspriv.h
+++ b/sysdep/linux/syspriv.h
@@ -1,4 +1,11 @@
+#ifndef _BIRD_SYSPRIV_H_
+#define _BIRD_SYSPRIV_H_
 
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+
+#include <unistd.h>
 #include <sys/prctl.h>
 #include <linux/capability.h>
 
@@ -70,3 +77,5 @@ drop_uid(uid_t uid)
   if (setresuid(uid, uid, uid) < 0)
     die("setresuid: %m");
 }
+
+#endif /* _BIRD_SYSPRIV_H_ */
diff --git a/sysdep/unix/io.c b/sysdep/unix/io.c
index 873b5805..644a4fcd 100644
--- a/sysdep/unix/io.c
+++ b/sysdep/unix/io.c
@@ -9,7 +9,9 @@
 
 /* Unfortunately, some glibc versions hide parts of RFC 3542 API
    if _GNU_SOURCE is not defined. */
-#define _GNU_SOURCE 1
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -2046,6 +2048,7 @@ watchdog_stop(void)
 
 volatile int async_config_flag;		/* Asynchronous reconfiguration/dump scheduled */
 volatile int async_dump_flag;
+volatile int async_shutdown_flag;
 
 void
 io_init(void)
diff --git a/sysdep/unix/main.c b/sysdep/unix/main.c
index 35bc3fd1..8aa19fce 100644
--- a/sysdep/unix/main.c
+++ b/sysdep/unix/main.c
@@ -8,7 +8,9 @@
 
 #undef LOCAL_DEBUG
 
-#define _GNU_SOURCE 1
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
 
 #include <stdio.h>
 #include <stdlib.h>

From 261816b0d4f3d4549a4402b95541b82fc7f10a4b Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Tue, 15 Nov 2016 16:24:39 +0100
Subject: [PATCH 160/165] BGP: Cluster list item should be prepended

Commit 3c09af41... changed behavior of int_set_add() from prepend to
append, which makes more sense for community list, but prepend must be
used for cluster list. Add int_set_prepend() and use it in cluster list
handling code.
---
 nest/a-set.c      | 23 +++++++++++++++++++++--
 nest/attrs.h      |  1 +
 proto/bgp/attrs.c |  2 +-
 3 files changed, 23 insertions(+), 3 deletions(-)

diff --git a/nest/a-set.c b/nest/a-set.c
index bd244e2e..a6c07f45 100644
--- a/nest/a-set.c
+++ b/nest/a-set.c
@@ -231,6 +231,26 @@ lc_set_contains(struct adata *list, lcomm val)
   return 0;
 }
 
+struct adata *
+int_set_prepend(struct linpool *pool, struct adata *list, u32 val)
+{
+  struct adata *res;
+  int len;
+
+  if (int_set_contains(list, val))
+    return list;
+
+  len = list ? list->length : 0;
+  res = lp_alloc(pool, sizeof(struct adata) + len + 4);
+  res->length = len + 4;
+
+  if (list)
+    memcpy(res->data + 4, list->data, list->length);
+
+  * (u32 *) res->data = val;
+
+  return res;
+}
 
 struct adata *
 int_set_add(struct linpool *pool, struct adata *list, u32 val)
@@ -248,8 +268,7 @@ int_set_add(struct linpool *pool, struct adata *list, u32 val)
   if (list)
     memcpy(res->data, list->data, list->length);
 
-  u32 *c = (u32 *) (res->data + len);
-  *c = val;
+  * (u32 *) (res->data + len) = val;
 
   return res;
 }
diff --git a/nest/attrs.h b/nest/attrs.h
index 548d71a9..a34e64d3 100644
--- a/nest/attrs.h
+++ b/nest/attrs.h
@@ -132,6 +132,7 @@ int lc_set_format(struct adata *set, int from, byte *buf, uint size);
 int int_set_contains(struct adata *list, u32 val);
 int ec_set_contains(struct adata *list, u64 val);
 int lc_set_contains(struct adata *list, lcomm val);
+struct adata *int_set_prepend(struct linpool *pool, struct adata *list, u32 val);
 struct adata *int_set_add(struct linpool *pool, struct adata *list, u32 val);
 struct adata *ec_set_add(struct linpool *pool, struct adata *list, u64 val);
 struct adata *lc_set_add(struct linpool *pool, struct adata *list, lcomm val);
diff --git a/proto/bgp/attrs.c b/proto/bgp/attrs.c
index 0309c1f7..aa2a3b46 100644
--- a/proto/bgp/attrs.c
+++ b/proto/bgp/attrs.c
@@ -1077,7 +1077,7 @@ static inline void
 bgp_cluster_list_prepend(rte *e, ea_list **attrs, struct linpool *pool, u32 cid)
 {
   eattr *a = ea_find(e->attrs->eattrs, EA_CODE(EAP_BGP, BA_CLUSTER_LIST));
-  bgp_attach_attr(attrs, pool, BA_CLUSTER_LIST, (uintptr_t) int_set_add(pool, a ? a->u.ptr : NULL, cid));
+  bgp_attach_attr(attrs, pool, BA_CLUSTER_LIST, (uintptr_t) int_set_prepend(pool, a ? a->u.ptr : NULL, cid));
 }
 
 static int

From ed1a908e535e4333b358d83b472453a2ad6d3f51 Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Fri, 25 Nov 2016 11:51:38 +0100
Subject: [PATCH 161/165] BGP: Fix memory leak in graceful restart code

Prefix and bucket tables are initialized when entering established state
but not explicitly freed when leaving it (that is handled by protocol
restart). With graceful restart, BGP may enter and leave established
state multiple times without hard protocol restart causing memory leak.
---
 lib/hash.h        |  6 ++++++
 proto/bgp/attrs.c | 26 ++++++++++++++++++++++++++
 proto/bgp/bgp.c   |  3 +++
 proto/bgp/bgp.h   |  2 ++
 4 files changed, 37 insertions(+)

diff --git a/lib/hash.h b/lib/hash.h
index 4239b1d8..6995bbc8 100644
--- a/lib/hash.h
+++ b/lib/hash.h
@@ -25,6 +25,12 @@
     (v).data = mb_allocz(pool, HASH_SIZE(v) * sizeof(* (v).data));	\
   })
 
+#define HASH_FREE(v)							\
+  ({									\
+    mb_free((v).data);							\
+    (v) = (typeof(v)){ };						\
+  })
+
 #define HASH_FIND(v,id,key...)						\
   ({									\
     u32 _h = HASH_FN(v, id, key);					\
diff --git a/proto/bgp/attrs.c b/proto/bgp/attrs.c
index aa2a3b46..9d23374a 100644
--- a/proto/bgp/attrs.c
+++ b/proto/bgp/attrs.c
@@ -934,6 +934,15 @@ bgp_init_prefix_table(struct bgp_proto *p, u32 order)
   p->prefix_slab = sl_new(p->p.pool, sizeof(struct bgp_prefix));
 }
 
+void
+bgp_free_prefix_table(struct bgp_proto *p)
+{
+  HASH_FREE(p->prefix_hash);
+
+  rfree(p->prefix_slab);
+  p->prefix_slab = NULL;
+}
+
 static struct bgp_prefix *
 bgp_get_prefix(struct bgp_proto *p, ip_addr prefix, int pxlen, u32 path_id)
 {
@@ -1940,6 +1949,23 @@ bgp_init_bucket_table(struct bgp_proto *p)
   // fib_init(&p->prefix_fib, p->p.pool, sizeof(struct bgp_prefix), 0, bgp_init_prefix);
 }
 
+void
+bgp_free_bucket_table(struct bgp_proto *p)
+{
+  mb_free(p->bucket_hash);
+  p->bucket_hash = NULL;
+
+  struct bgp_bucket *b;
+  WALK_LIST_FIRST(b, p->bucket_queue)
+  {
+    rem_node(&b->send_node);
+    mb_free(b);
+  }
+
+  mb_free(p->withdraw_bucket);
+  p->withdraw_bucket = NULL;
+}
+
 void
 bgp_get_route_info(rte *e, byte *buf, ea_list *attrs)
 {
diff --git a/proto/bgp/bgp.c b/proto/bgp/bgp.c
index 8ef4b990..0f1c9446 100644
--- a/proto/bgp/bgp.c
+++ b/proto/bgp/bgp.c
@@ -416,6 +416,9 @@ bgp_conn_leave_established_state(struct bgp_proto *p)
   BGP_TRACE(D_EVENTS, "BGP session closed");
   p->conn = NULL;
 
+  bgp_free_prefix_table(p);
+  bgp_free_bucket_table(p);
+
   if (p->p.proto_state == PS_UP)
     bgp_stop(p, 0);
 }
diff --git a/proto/bgp/bgp.h b/proto/bgp/bgp.h
index b4067f3a..d028bef4 100644
--- a/proto/bgp/bgp.h
+++ b/proto/bgp/bgp.h
@@ -253,8 +253,10 @@ int bgp_rte_recalculate(rtable *table, net *net, rte *new, rte *old, rte *old_be
 void bgp_rt_notify(struct proto *P, rtable *tbl UNUSED, net *n, rte *new, rte *old UNUSED, ea_list *attrs);
 int bgp_import_control(struct proto *, struct rte **, struct ea_list **, struct linpool *);
 void bgp_init_bucket_table(struct bgp_proto *);
+void bgp_free_bucket_table(struct bgp_proto *p);
 void bgp_free_bucket(struct bgp_proto *p, struct bgp_bucket *buck);
 void bgp_init_prefix_table(struct bgp_proto *p, u32 order);
+void bgp_free_prefix_table(struct bgp_proto *p);
 void bgp_free_prefix(struct bgp_proto *p, struct bgp_prefix *bp);
 uint bgp_encode_attrs(struct bgp_proto *p, byte *w, ea_list *attrs, int remains);
 void bgp_get_route_info(struct rte *, byte *buf, struct ea_list *attrs);

From 9e7d3a781075b39a7e0f97e63b6f313955daa661 Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Tue, 13 Dec 2016 17:34:42 +0100
Subject: [PATCH 162/165] OSPF: Fix net-summary origination combined with
 stubnet option

Stubnet nodes in OSPF FIB were removed during rt_sync(), but the pointer
remained in top_hash_entry.nf, so net-summary LSA origination was
confused, reported 'LSA ID collision' and net-summary LSAs were not
originated properly.

Thanks to Naveen Chowdary Yerramneni for bugreport and analysis.
---
 proto/ospf/rt.c | 17 ++++++++++-------
 proto/ospf/rt.h |  1 +
 2 files changed, 11 insertions(+), 7 deletions(-)

diff --git a/proto/ospf/rt.c b/proto/ospf/rt.c
index 19f2d074..21aaf144 100644
--- a/proto/ospf/rt.c
+++ b/proto/ospf/rt.c
@@ -429,10 +429,9 @@ add_network(struct ospf_area *oa, ip_addr px, int pxlen, int metric, struct top_
   if (en == oa->rt)
   {
     /*
-     * Local stub networks does not have proper iface in en->nhi
-     * (because they all have common top_hash_entry en).
-     * We have to find iface responsible for that stub network.
-     * Configured stubnets does not have any iface. They will
+     * Local stub networks do not have proper iface in en->nhi (because they all
+     * have common top_hash_entry en). We have to find iface responsible for
+     * that stub network. Configured stubnets do not have any iface. They will
      * be removed in rt_sync().
      */
 
@@ -1560,6 +1559,7 @@ ospf_rt_reset(struct ospf_proto *p)
   {
     ri = (ort *) nftmp;
     ri->area_net = 0;
+    ri->keep = 0;
     reset_ri(ri);
   }
   FIB_WALK_END;
@@ -1929,9 +1929,12 @@ rt_sync(struct ospf_proto *p)
 	}
     }
 
-    /* Remove configured stubnets */
-    if (!nf->n.nhs)
+    /* Remove configured stubnets but keep the entries */
+    if (nf->n.type && !nf->n.nhs)
+    {
       reset_ri(nf);
+      nf->keep = 1;
+    }
 
     if (nf->n.type) /* Add the route */
     {
@@ -1991,7 +1994,7 @@ rt_sync(struct ospf_proto *p)
     }
 
     /* Remove unused rt entry, some special entries are persistent */
-    if (!nf->n.type && !nf->external_rte && !nf->area_net)
+    if (!nf->n.type && !nf->external_rte && !nf->area_net && !nf->keep)
     {
       FIB_ITERATE_PUT(&fit, nftmp);
       fib_delete(fib, nftmp);
diff --git a/proto/ospf/rt.h b/proto/ospf/rt.h
index 30332f3b..73b28375 100644
--- a/proto/ospf/rt.h
+++ b/proto/ospf/rt.h
@@ -84,6 +84,7 @@ typedef struct ort
   rta *old_rta;
   u8 external_rte;
   u8 area_net;
+  u8 keep;
 }
 ort;
 

From 7d95c44572d79ef15ec8b0220950b4e4374c6bc6 Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Thu, 15 Dec 2016 15:31:25 +0100
Subject: [PATCH 163/165] OSPF: Fix ECMP external merging

The variable nfa is not cleaned before each loop iteration and can have
a wrong value of nfa.nhs_reuse from the previous step.

Thanks to Bernardo Figueiredo for the bugreport and analysis.
---
 proto/ospf/rt.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/proto/ospf/rt.c b/proto/ospf/rt.c
index 21aaf144..368e3d05 100644
--- a/proto/ospf/rt.c
+++ b/proto/ospf/rt.c
@@ -1405,7 +1405,6 @@ ospf_ext_spf(struct ospf_proto *p)
   struct top_hash_entry *en;
   struct ospf_lsa_ext_local rt;
   ort *nf1, *nf2;
-  orta nfa = {};
   ip_addr rtid;
   u32 br_metric;
   struct ospf_area *atmp;
@@ -1414,6 +1413,8 @@ ospf_ext_spf(struct ospf_proto *p)
 
   WALK_SLIST(en, p->lsal)
   {
+    orta nfa = {};
+
     /* 16.4. (1) */
     if ((en->lsa_type != LSA_T_EXT) && (en->lsa_type != LSA_T_NSSA))
       continue;

From 2c33da507046c25d87741fe0ce7947985c8c7a10 Mon Sep 17 00:00:00 2001
From: Jan Moskyto Matejka <mq@ucw.cz>
Date: Tue, 20 Dec 2016 20:13:08 +0100
Subject: [PATCH 164/165] Netlink: fix occasional netlink hangs on busy
 machines

---
 sysdep/linux/netlink.c | 1 +
 sysdep/unix/io.c       | 3 ++-
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/sysdep/linux/netlink.c b/sysdep/linux/netlink.c
index 368e0ef9..22313f43 100644
--- a/sysdep/linux/netlink.c
+++ b/sysdep/linux/netlink.c
@@ -1497,6 +1497,7 @@ nl_async_hook(sock *sk, uint size UNUSED)
 	   *  One day we might react to it by asking for route table
 	   *  scan in near future.
 	   */
+	  log(L_WARN "Kernel dropped some netlink messages, will resync on next scan.");
 	  return 1;	/* More data are likely to be ready */
 	}
       else if (errno != EWOULDBLOCK)
diff --git a/sysdep/unix/io.c b/sysdep/unix/io.c
index 644a4fcd..8773f4c4 100644
--- a/sysdep/unix/io.c
+++ b/sysdep/unix/io.c
@@ -2238,7 +2238,8 @@ io_loop(void)
 	      if (pfd[s->index].revents & (POLLHUP | POLLERR))
 		{
 		  sk_err(s, pfd[s->index].revents);
-		  goto next2;
+		  if (s != current_sock)
+		    goto next2;
 		}
 
 	      current_sock = sk_next(s);

From 017da76b729cc36c4a3416995b06386235660f42 Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Wed, 21 Dec 2016 16:46:47 +0100
Subject: [PATCH 165/165] NEWS and version update

---
 NEWS            | 7 +++++++
 misc/bird.spec  | 2 +-
 sysdep/config.h | 2 +-
 3 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/NEWS b/NEWS
index 26314d82..a9bd6a72 100644
--- a/NEWS
+++ b/NEWS
@@ -1,3 +1,10 @@
+Version 1.6.3 (2016-12-21)
+  o Large BGP communities
+  o BFD authentication (MD5, SHA1)
+  o SHA1 and SHA2 authentication for RIP and OSPF
+  o Improved documentation
+  o Several bug fixes
+
 Version 1.6.2 (2016-09-29)
   o Fixes serious bug introduced in the previous version
 
diff --git a/misc/bird.spec b/misc/bird.spec
index ebc0c942..bfbfc484 100644
--- a/misc/bird.spec
+++ b/misc/bird.spec
@@ -1,6 +1,6 @@
 Summary: BIRD Internet Routing Daemon
 Name: bird
-Version: 1.6.2
+Version: 1.6.3
 Release: 1
 Copyright: GPL
 Group: Networking/Daemons
diff --git a/sysdep/config.h b/sysdep/config.h
index c7f63e69..84085f9c 100644
--- a/sysdep/config.h
+++ b/sysdep/config.h
@@ -7,7 +7,7 @@
 #define _BIRD_CONFIG_H_
 
 /* BIRD version */
-#define BIRD_VERSION "1.6.2"
+#define BIRD_VERSION "1.6.3"
 
 /* Include parameters determined by configure script */
 #include "sysdep/autoconf.h"