Merge commit '1e8721e2aeccfbc3f533e8b8abc07582cee77e9a' into int-new

1 files changed, 266 insertions, 79 deletions

diff --git a/proto/radv/radv.c b/proto/radv/radv.c
index e9140115..0a2a3e78 100644
--- a/proto/radv/radv.c
+++ b/proto/radv/radv.c
@@ -12,59 +12,63 @@
 /**
  * DOC: Router Advertisements
  *
- * The RAdv protocol is implemented in two files: |radv.c| containing
- * the interface with BIRD core and the protocol logic and |packets.c|
- * handling low level protocol stuff (RX, TX and packet formats).
- * The protocol does not export any routes.
+ * The RAdv protocol is implemented in two files: |radv.c| containing the
+ * interface with BIRD core and the protocol logic and |packets.c| handling low
+ * level protocol stuff (RX, TX and packet formats). The protocol does not
+ * export any routes.
  *
- * The RAdv is structured in the usual way - for each handled interface
- * there is a structure &radv_iface that contains a state related to
- * that interface together with its resources (a socket, a timer).
- * There is also a prepared RA stored in a TX buffer of the socket
- * associated with an iface. These iface structures are created
- * and removed according to iface events from BIRD core handled by
- * radv_if_notify() callback.
+ * The RAdv is structured in the usual way - for each handled interface there is
+ * a structure &radv_iface that contains a state related to that interface
+ * together with its resources (a socket, a timer). There is also a prepared RA
+ * stored in a TX buffer of the socket associated with an iface. These iface
+ * structures are created and removed according to iface events from BIRD core
+ * handled by radv_if_notify() callback.
  *
- * The main logic of RAdv consists of two functions:
- * radv_iface_notify(), which processes asynchronous events (specified
- * by RA_EV_* codes), and radv_timer(), which triggers sending RAs and
- * computes the next timeout.
+ * The main logic of RAdv consists of two functions: radv_iface_notify(), which
+ * processes asynchronous events (specified by RA_EV_* codes), and radv_timer(),
+ * which triggers sending RAs and computes the next timeout.
  *
- * The RAdv protocol could receive routes (through
- * radv_import_control() and radv_rt_notify()), but only the
- * configured trigger route is tracked (in &active var).  When a radv
- * protocol is reconfigured, the connected routing table is examined
- * (in radv_check_active()) to have proper &active value in case of
- * the specified trigger prefix was changed.
+ * The RAdv protocol could receive routes (through radv_import_control() and
+ * radv_rt_notify()), but only the configured trigger route is tracked (in
+ * &active var).  When a radv protocol is reconfigured, the connected routing
+ * table is examined (in radv_check_active()) to have proper &active value in
+ * case of the specified trigger prefix was changed.
  *
  * Supported standards:
  * - RFC 4861 - main RA standard
+ * - RFC 4191 - Default Router Preferences and More-Specific Routes
  * - RFC 6106 - DNS extensions (RDDNS, DNSSL)
- * - RFC 4191 (partial) - Default Router Preference
  */
 
+static void radv_prune_prefixes(struct radv_iface *ifa);
+static void radv_prune_routes(struct radv_proto *p);
+
+/* Invalidate cached RA packet */
+static inline void radv_invalidate(struct radv_iface *ifa)
+{ ifa->plen = 0; }
+
 static void
 radv_timer(timer *tm)
 {
   struct radv_iface *ifa = tm->data;
   struct radv_proto *p = ifa->ra;
+  btime now = current_time();
 
   RADV_TRACE(D_EVENTS, "Timer fired on %s", ifa->iface->name);
 
-  /*
-   * If some dead prefixes expired, regenerate the prefix list and the packet.
-   * We do so by pretending there was a change on the interface.
-   *
-   * This sets the timer, but we replace it just at the end of this function
-   * (replacing a timer is fine).
-   */
-  if (ifa->prefix_expires && (ifa->prefix_expires <= current_time()))
-    radv_iface_notify(ifa, RA_EV_GC);
+  if (ifa->valid_time <= now)
+    radv_invalidate(ifa);
+
+  if (ifa->prune_time <= now)
+    radv_prune_prefixes(ifa);
 
-  radv_send_ra(ifa, 0);
+  if (p->prune_time <= now)
+    radv_prune_routes(p);
+
+  radv_send_ra(ifa);
 
   /* Update timer */
-  ifa->last = current_time();
+  ifa->last = now;
   btime t = ifa->cf->min_ra_int S;
   btime r = (ifa->cf->max_ra_int - ifa->cf->min_ra_int) S;
   t += random() % (r + 1);
@@ -115,8 +119,8 @@ static void
 radv_prepare_prefixes(struct radv_iface *ifa)
 {
   struct radv_proto *p = ifa->ra;
-  struct radv_iface_config *cf = ifa->cf;
-  struct radv_prefix *pfx;
+  struct radv_prefix *pfx, *next;
+  btime now = current_time();
 
   /* First mark all the prefixes as unused */
   WALK_LIST(pfx, ifa->prefixes)
@@ -159,55 +163,58 @@ radv_prepare_prefixes(struct radv_iface *ifa)
      * Update the information (it may have changed, or even bring a prefix back
      * to life).
      */
-    existing->alive = 1;
+    existing->valid = 1;
+    existing->changed = now;
     existing->mark = 1;
     existing->cf = pc;
   }
 
-  /*
-   * Garbage-collect the prefixes. If something isn't used, it dies (but isn't
-   * dropped just yet). If something is dead and rots there for long enough,
-   * clean it up.
-   */
-  btime now_ = current_time();
-  btime expires = now_ + cf->linger_time S;
-  btime expires_min = 0;
-  struct radv_prefix *next;
   WALK_LIST_DELSAFE(pfx, next, ifa->prefixes)
   {
-    if (pfx->alive && !pfx->mark)
+    if (pfx->valid && !pfx->mark)
     {
-      RADV_TRACE(D_EVENTS, "Marking prefix %N on %s as dead",
+      RADV_TRACE(D_EVENTS, "Invalidating prefix %N on %s",
 		 pfx->prefix, ifa->iface->name);
 
-      pfx->alive = 0;
-      pfx->expires = expires;
+      pfx->valid = 0;
+      pfx->changed = now;
       pfx->cf = &dead_prefix;
     }
+  }
+}
+
+static void
+radv_prune_prefixes(struct radv_iface *ifa)
+{
+  struct radv_proto *p = ifa->ra;
+  btime now = current_time();
+  btime next = TIME_INFINITY;
+  btime expires = 0;
 
-    if (!pfx->alive)
+  struct radv_prefix *px, *pxn;
+  WALK_LIST_DELSAFE(px, pxn, ifa->prefixes)
+  {
+    if (!px->valid)
     {
-      if (pfx->expires <= now_)
+      expires = px->changed + ifa->cf->prefix_linger_time S;
+
+      if (expires <= now)
       {
 	RADV_TRACE(D_EVENTS, "Removing prefix %N on %s",
-		   pfx->prefix, ifa->iface->name);
+		   px->prefix, ifa->iface->name);
 
-	rem_node(NODE pfx);
-	mb_free(pfx);
+	rem_node(NODE px);
+	mb_free(px);
       }
       else
-      {
-	/* Find minimum expiration time */
-	if (!expires_min || (pfx->expires < expires_min))
-	  expires_min = pfx->expires;
-      }
+	next = MIN(next, expires);
     }
   }
 
-  ifa->prefix_expires = expires_min;
+  ifa->prune_time = next;
 }
 
-static char* ev_name[] = { NULL, "Init", "Change", "RS", "Garbage collect" };
+static char* ev_name[] = { NULL, "Init", "Change", "RS" };
 
 void
 radv_iface_notify(struct radv_iface *ifa, int event)
@@ -222,18 +229,17 @@ radv_iface_notify(struct radv_iface *ifa, int event)
   switch (event)
   {
   case RA_EV_CHANGE:
-  case RA_EV_GC:
-    ifa->plen = 0;
+    radv_invalidate(ifa);
   case RA_EV_INIT:
     ifa->initial = MAX_INITIAL_RTR_ADVERTISEMENTS;
+    radv_prepare_prefixes(ifa);
+    radv_prune_prefixes(ifa);
     break;
 
   case RA_EV_RS:
     break;
   }
 
-  radv_prepare_prefixes(ifa);
-
   /* Update timer */
   btime t = ifa->last + ifa->cf->min_delay S - current_time();
   tm_start(ifa->timer, t);
@@ -248,7 +254,6 @@ radv_iface_notify_all(struct radv_proto *p, int event)
     radv_iface_notify(ifa, event);
 }
 
-
 static struct radv_iface *
 radv_iface_find(struct radv_proto *p, struct iface *what)
 {
@@ -291,6 +296,7 @@ radv_iface_new(struct radv_proto *p, struct iface *iface, struct radv_iface_conf
   ifa->iface = iface;
   ifa->addr = iface->llv6;
   init_list(&ifa->prefixes);
+  ifa->prune_time = TIME_INFINITY;
 
   add_tail(&p->iface_list, NODE ifa);
 
@@ -397,14 +403,19 @@ radv_import_control(struct proto *P, rte **new, ea_list **attrs UNUSED, struct l
   if (radv_net_match_trigger(cf, (*new)->net))
     return RIC_PROCESS;
 
-  return RIC_DROP;
+  if (cf->propagate_routes)
+    return RIC_PROCESS;
+  else
+    return RIC_DROP;
 }
 
 static void
-radv_rt_notify(struct proto *P, struct channel *ch UNUSED, net *n, rte *new, rte *old UNUSED, ea_list *attrs UNUSED)
+radv_rt_notify(struct proto *P, struct channel *ch UNUSED, net *n, rte *new, rte *old UNUSED, ea_list *attrs)
 {
   struct radv_proto *p = (struct radv_proto *) P;
   struct radv_config *cf = (struct radv_config *) (P->cf);
+  struct radv_route *rt;
+  eattr *ea;
 
   if (radv_net_match_trigger(cf, n))
   {
@@ -420,7 +431,123 @@ radv_rt_notify(struct proto *P, struct channel *ch UNUSED, net *n, rte *new, rte
       RADV_TRACE(D_EVENTS, "Suppressed");
 
     radv_iface_notify_all(p, RA_EV_CHANGE);
+    return;
+  }
+
+  if (!cf->propagate_routes)
+    return;
+
+  /*
+   * Some other route we want to send (or stop sending). Update the cache,
+   * with marking a removed one as dead or creating a new one as needed.
+   *
+   * And yes, we exclude the trigger route on purpose.
+   */
+
+  if (new)
+  {
+    /* Update */
+
+    ea = ea_find(attrs, EA_RA_PREFERENCE);
+    uint preference = ea ? ea->u.data : RA_PREF_MEDIUM;
+    uint preference_set = !!ea;
+
+    ea = ea_find(attrs, EA_RA_LIFETIME);
+    uint lifetime = ea ? ea->u.data : 0;
+    uint lifetime_set = !!ea;
+
+    if ((preference != RA_PREF_LOW) &&
+	(preference != RA_PREF_MEDIUM) &&
+	(preference != RA_PREF_HIGH))
+    {
+      log(L_WARN "%s: Invalid ra_preference value %u on route %N",
+	  p->p.name, preference, n->n.addr);
+      preference = RA_PREF_MEDIUM;
+      preference_set = 1;
+      lifetime = 0;
+      lifetime_set = 1;
+    }
+
+    rt = fib_get(&p->routes, n->n.addr);
+
+    /* Ignore update if nothing changed */
+    if (rt->valid &&
+	(rt->preference == preference) &&
+	(rt->preference_set == preference_set) &&
+	(rt->lifetime == lifetime) &&
+	(rt->lifetime_set == lifetime_set))
+      return;
+
+    if (p->routes.entries == 18)
+      log(L_WARN "%s: More than 17 routes exported to RAdv", p->p.name);
+
+    rt->valid = 1;
+    rt->changed = current_time();
+    rt->preference = preference;
+    rt->preference_set = preference_set;
+    rt->lifetime = lifetime;
+    rt->lifetime_set = lifetime_set;
+  }
+  else
+  {
+    /* Withdraw */
+    rt = fib_find(&p->routes, n->n.addr);
+
+    if (!rt || !rt->valid)
+      return;
+
+    /* Invalidate the route */
+    rt->valid = 0;
+    rt->changed = current_time();
+
+    /* Invalidated route will be pruned eventually */
+    btime expires = rt->changed + cf->max_linger_time S;
+    p->prune_time = MIN(p->prune_time, expires);
   }
+
+  radv_iface_notify_all(p, RA_EV_CHANGE);
+}
+
+/*
+ * Cleans up all the dead routes that expired and schedules itself to be run
+ * again if there are more routes waiting for expiration.
+ */
+static void
+radv_prune_routes(struct radv_proto *p)
+{
+  struct radv_config *cf = (struct radv_config *) (p->p.cf);
+  btime now = current_time();
+  btime next = TIME_INFINITY;
+  btime expires = 0;
+
+  /* Should not happen */
+  if (!p->fib_up)
+    return;
+
+  struct fib_iterator fit;
+  FIB_ITERATE_INIT(&fit, &p->routes);
+
+again:
+  FIB_ITERATE_START(&p->routes, &fit, struct radv_route, rt)
+  {
+    if (!rt->valid)
+    {
+      expires = rt->changed + cf->max_linger_time S;
+
+      /* Delete expired nodes */
+      if (expires <= now)
+      {
+	FIB_ITERATE_PUT(&fit);
+	fib_delete(&p->routes, rt);
+	goto again;
+      }
+      else
+	next = MIN(next, expires);
+    }
+  }
+  FIB_ITERATE_END;
+
+  p->prune_time = next;
 }
 
 static int
@@ -460,6 +587,22 @@ radv_init(struct proto_config *CF)
   return P;
 }
 
+static void
+radv_set_fib(struct radv_proto *p, int up)
+{
+  if (up == p->fib_up)
+    return;
+
+  if (up)
+    fib_init(&p->routes, p->p.pool, NET_IP6, sizeof(struct radv_route),
+	     OFFSETOF(struct radv_route, n), 4, NULL);
+  else
+    fib_free(&p->routes);
+
+  p->fib_up = up;
+  p->prune_time = TIME_INFINITY;
+}
+
 static int
 radv_start(struct proto *P)
 {
@@ -467,8 +610,13 @@ radv_start(struct proto *P)
   struct radv_config *cf = (struct radv_config *) (P->cf);
 
   init_list(&(p->iface_list));
+  p->valid = 1;
   p->active = !radv_trigger_valid(cf);
 
+  p->fib_up = 0;
+  radv_set_fib(p, cf->propagate_routes);
+  p->prune_time = TIME_INFINITY;
+
   return PS_UP;
 }
 
@@ -476,7 +624,10 @@ static inline void
 radv_iface_shutdown(struct radv_iface *ifa)
 {
   if (ifa->sk)
-    radv_send_ra(ifa, 1);
+  {
+    radv_invalidate(ifa);
+    radv_send_ra(ifa);
+  }
 }
 
 static int
@@ -484,6 +635,8 @@ radv_shutdown(struct proto *P)
 {
   struct radv_proto *p = (struct radv_proto *) P;
 
+  p->valid = 0;
+
   struct radv_iface *ifa;
   WALK_LIST(ifa, p->iface_list)
     radv_iface_shutdown(ifa);
@@ -495,23 +648,22 @@ static int
 radv_reconfigure(struct proto *P, struct proto_config *CF)
 {
   struct radv_proto *p = (struct radv_proto *) P;
-  // struct radv_config *old = (struct radv_config *) (p->cf);
+  struct radv_config *old = (struct radv_config *) (P->cf);
   struct radv_config *new = (struct radv_config *) CF;
 
-  /*
-   * The question is why there is a reconfigure function for RAdv if
-   * it has almost none internal state so restarting the protocol
-   * would probably suffice. One small reason is that restarting the
-   * protocol would lead to sending a RA with Router Lifetime 0
-   * causing nodes to temporary remove their default routes.
-   */
-
   if (!proto_configure_channel(P, &P->main_channel, proto_cf_main_channel(CF)))
     return 0;
 
   P->cf = CF; /* radv_check_active() requires proper P->cf */
   p->active = radv_check_active(p);
 
+  /* Allocate or free FIB */
+  radv_set_fib(p, new->propagate_routes);
+
+  /* We started to accept routes so we need to refeed them */
+  if (!old->propagate_routes && new->propagate_routes)
+    channel_request_feeding(p->p.main_channel);
+
   struct iface *iface;
   WALK_LIST(iface, iface_list)
   {
@@ -574,9 +726,43 @@ radv_get_status(struct proto *P, byte *buf)
     strcpy(buf, "Suppressed");
 }
 
+static const char *
+radv_pref_str(u32 pref)
+{
+  switch (pref)
+  {
+    case RA_PREF_LOW:
+      return "low";
+    case RA_PREF_MEDIUM:
+      return "medium";
+    case RA_PREF_HIGH:
+      return "high";
+    default:
+      return "??";
+  }
+}
+
+/* The buffer has some minimal size */
+static int
+radv_get_attr(eattr *a, byte *buf, int buflen UNUSED)
+{
+  switch (a->id)
+  {
+  case EA_RA_PREFERENCE:
+    bsprintf(buf, "preference: %s", radv_pref_str(a->u.data));
+    return GA_FULL;
+  case EA_RA_LIFETIME:
+    bsprintf(buf, "lifetime");
+    return GA_NAME;
+  default:
+    return GA_UNKNOWN;
+  }
+}
+
 struct protocol proto_radv = {
   .name =		"RAdv",
   .template =		"radv%d",
+  .attr_class =		EAP_RADV,
   .channel_mask =	NB_IP6,
   .proto_size =		sizeof(struct radv_proto),
   .config_size =	sizeof(struct radv_config),
@@ -586,5 +772,6 @@ struct protocol proto_radv = {
   .shutdown =		radv_shutdown,
   .reconfigure =	radv_reconfigure,
   .copy_config =	radv_copy_config,
-  .get_status =		radv_get_status
+  .get_status =		radv_get_status,
+  .get_attr =		radv_get_attr
 };