1 files changed, 931 insertions, 856 deletions

diff --git a/nest/rt-table.c b/nest/rt-table.c
index 6f948ada..d43305c9 100644
--- a/nest/rt-table.c
+++ b/nest/rt-table.c
@@ -112,10 +112,10 @@
 
 pool *rt_table_pool;
 
-static slab *rte_slab;
 static linpool *rte_update_pool;
 
 list routing_tables;
+list deleted_routing_tables;
 
 static void rt_free_hostcache(rtable *tab);
 static void rt_notify_hostcache(rtable *tab, net *net);
@@ -124,6 +124,41 @@ static void rt_next_hop_update(rtable *tab);
 static inline void rt_prune_table(rtable *tab);
 static inline void rt_schedule_notify(rtable *tab);
 static void rt_flowspec_notify(rtable *tab, net *net);
+static void rt_feed_channel(void *);
+
+const char *rt_import_state_name_array[TIS_MAX] = {
+  [TIS_DOWN] = "DOWN",
+  [TIS_UP] = "UP",
+  [TIS_STOP] = "STOP",
+  [TIS_FLUSHING] = "FLUSHING",
+  [TIS_WAITING] = "WAITING",
+  [TIS_CLEARED] = "CLEARED",
+};
+
+const char *rt_export_state_name_array[TES_MAX] = {
+  [TES_DOWN] = "DOWN",
+  [TES_HUNGRY] = "HUNGRY",
+  [TES_FEEDING] = "FEEDING",
+  [TES_READY] = "READY",
+  [TES_STOP] = "STOP"
+};
+
+const char *rt_import_state_name(u8 state)
+{
+  if (state >= TIS_MAX)
+    return "!! INVALID !!";
+  else
+    return rt_import_state_name_array[state];
+}
+
+const char *rt_export_state_name(u8 state)
+{
+  if (state >= TES_MAX)
+    return "!! INVALID !!";
+  else
+    return rt_export_state_name_array[state];
+}
+
 
 
 static void
@@ -394,7 +429,7 @@ net_roa_check_ip4_trie(rtable *tab, const net_addr_ip4 *px, u32 asn)
       net_addr_roa4 *roa = (void *) fn->addr;
       net *r = fib_node_to_user(&tab->fib, fn);
 
-      if (net_equal_prefix_roa4(roa, &roa0) && rte_is_valid(r->routes))
+      if (net_equal_prefix_roa4(roa, &roa0) && r->routes && rte_is_valid(&r->routes->rte))
       {
 	anything = 1;
 	if (asn && (roa->asn == asn) && (roa->max_pxlen >= px->pxlen))
@@ -421,7 +456,7 @@ net_roa_check_ip4_fib(rtable *tab, const net_addr_ip4 *px, u32 asn)
       net_addr_roa4 *roa = (void *) fn->addr;
       net *r = fib_node_to_user(&tab->fib, fn);
 
-      if (net_equal_prefix_roa4(roa, &n) && rte_is_valid(r->routes))
+      if (net_equal_prefix_roa4(roa, &n) && r->routes && rte_is_valid(&r->routes->rte))
       {
 	anything = 1;
 	if (asn && (roa->asn == asn) && (roa->max_pxlen >= px->pxlen))
@@ -454,7 +489,7 @@ net_roa_check_ip6_trie(rtable *tab, const net_addr_ip6 *px, u32 asn)
       net_addr_roa6 *roa = (void *) fn->addr;
       net *r = fib_node_to_user(&tab->fib, fn);
 
-      if (net_equal_prefix_roa6(roa, &roa0) && rte_is_valid(r->routes))
+      if (net_equal_prefix_roa6(roa, &roa0) && r->routes && rte_is_valid(&r->routes->rte))
       {
 	anything = 1;
 	if (asn && (roa->asn == asn) && (roa->max_pxlen >= px->pxlen))
@@ -481,7 +516,7 @@ net_roa_check_ip6_fib(rtable *tab, const net_addr_ip6 *px, u32 asn)
       net_addr_roa6 *roa = (void *) fn->addr;
       net *r = fib_node_to_user(&tab->fib, fn);
 
-      if (net_equal_prefix_roa6(roa, &n) && rte_is_valid(r->routes))
+      if (net_equal_prefix_roa6(roa, &n) && r->routes && rte_is_valid(&r->routes->rte))
       {
 	anything = 1;
 	if (asn && (roa->asn == asn) && (roa->max_pxlen >= px->pxlen))
@@ -540,105 +575,52 @@ net_roa_check(rtable *tab, const net_addr *n, u32 asn)
  * @net: network node
  * @src: route source
  *
- * The rte_find() function returns a route for destination @net
- * which is from route source @src.
+ * The rte_find() function returns a pointer to a route for destination @net
+ * which is from route source @src. List end pointer is returned if no route is found.
  */
-rte *
+static struct rte_storage **
 rte_find(net *net, struct rte_src *src)
 {
-  rte *e = net->routes;
+  struct rte_storage **e = &net->routes;
 
-  while (e && e->src != src)
-    e = e->next;
-  return e;
-}
+  while ((*e) && (*e)->rte.src != src)
+    e = &(*e)->next;
 
-/**
- * rte_get_temp - get a temporary &rte
- * @a: attributes to assign to the new route (a &rta; in case it's
- * un-cached, rte_update() will create a cached copy automatically)
- *
- * Create a temporary &rte and bind it with the attributes @a.
- * Also set route preference to the default preference set for
- * the protocol.
- */
-rte *
-rte_get_temp(rta *a, struct rte_src *src)
-{
-  rte *e = sl_alloc(rte_slab);
-
-  e->attrs = a;
-  e->id = 0;
-  e->flags = 0;
-  rt_lock_source(e->src = src);
   return e;
 }
 
-rte *
-rte_do_cow(rte *r)
+
+struct rte_storage *
+rte_store(const rte *r, net *net, rtable *tab)
 {
-  rte *e = sl_alloc(rte_slab);
+  struct rte_storage *e = sl_alloc(tab->rte_slab);
 
-  memcpy(e, r, sizeof(rte));
+  e->rte = *r;
+  e->rte.net = net->n.addr;
 
-  rt_lock_source(e->src);
-  e->attrs = rta_clone(r->attrs);
-  e->flags = 0;
-  return e;
-}
+  rt_lock_source(e->rte.src);
 
-/**
- * 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;
+  if (e->rte.attrs->cached)
+    e->rte.attrs = rta_clone(e->rte.attrs);
+  else
+    e->rte.attrs = rta_lookup(e->rte.attrs);
 
-  r = rte_cow(r);
-  rta *a = rta_do_cow(r->attrs, lp);
-  rta_free(r->attrs);
-  r->attrs = a;
-  return r;
+  return e;
 }
 
 /**
  * rte_free - delete a &rte
- * @e: &rte to be deleted
+ * @e: &struct rte_storage to be deleted
+ * @tab: the table which the rte belongs to
  *
  * rte_free() deletes the given &rte from the routing table it's linked to.
  */
-void
-rte_free(rte *e)
-{
-  rt_unlock_source(e->src);
-  if (rta_is_cached(e->attrs))
-    rta_free(e->attrs);
-  sl_free(e);
-}
 
-static inline void
-rte_free_quick(rte *e)
+void
+rte_free(struct rte_storage *e)
 {
-  rt_unlock_source(e->src);
-  rta_free(e->attrs);
+  rt_unlock_source(e->rte.src);
+  rta_free(e->rte.attrs);
   sl_free(e);
 }
 
@@ -694,162 +676,187 @@ rte_mergable(rte *pri, rte *sec)
 }
 
 static void
-rte_trace(struct channel *c, rte *e, int dir, char *msg)
+rte_trace(const char *name, const rte *e, int dir, const char *msg)
 {
-  log(L_TRACE "%s.%s %c %s %N %uL %uG %s",
-      c->proto->name, c->name ?: "?", dir, msg, e->net->n.addr, e->src->private_id, e->src->global_id,
+  log(L_TRACE "%s %c %s %N %uL %uG %s",
+      name, dir, msg, e->net, e->src->private_id, e->src->global_id,
       rta_dest_name(e->attrs->dest));
 }
 
 static inline void
-rte_trace_in(uint flag, struct channel *c, rte *e, char *msg)
+channel_rte_trace_in(uint flag, struct channel *c, const rte *e, const char *msg)
 {
   if ((c->debug & flag) || (c->proto->debug & flag))
-    rte_trace(c, e, '>', msg);
+    rte_trace(c->in_req.name, e, '>', msg);
 }
 
 static inline void
-rte_trace_out(uint flag, struct channel *c, rte *e, char *msg)
+channel_rte_trace_out(uint flag, struct channel *c, const rte *e, const char *msg)
 {
   if ((c->debug & flag) || (c->proto->debug & flag))
-    rte_trace(c, e, '<', msg);
+    rte_trace(c->out_req.name, e, '<', msg);
+}
+
+static inline void
+rt_rte_trace_in(uint flag, struct rt_import_request *req, const rte *e, const char *msg)
+{
+  if (req->trace_routes & flag)
+    rte_trace(req->name, e, '>', msg);
+}
+
+#if 0
+// seems to be unused at all
+static inline void
+rt_rte_trace_out(uint flag, struct rt_export_request *req, const rte *e, const char *msg)
+{
+  if (req->trace_routes & flag)
+    rte_trace(req->name, e, '<', msg);
+}
+#endif
+
+static uint
+rte_feed_count(net *n)
+{
+  uint count = 0;
+  for (struct rte_storage *e = n->routes; e; e = e->next)
+    if (rte_is_valid(RTE_OR_NULL(e)))
+      count++;
+  return count;
+}
+
+static void
+rte_feed_obtain(net *n, struct rte **feed, uint count)
+{
+  uint i = 0;
+  for (struct rte_storage *e = n->routes; e; e = e->next)
+    if (rte_is_valid(RTE_OR_NULL(e)))
+    {
+      ASSERT_DIE(i < count);
+      feed[i++] = &e->rte;
+    }
+  ASSERT_DIE(i == count);
 }
 
 static rte *
-export_filter(struct channel *c, rte *rt0, rte **rt_free, int silent)
+export_filter(struct channel *c, rte *rt, int silent)
 {
   struct proto *p = c->proto;
   const struct filter *filter = c->out_filter;
-  struct proto_stats *stats = &c->stats;
-  rte *rt;
-  int v;
+  struct channel_export_stats *stats = &c->export_stats;
 
-  rt = rt0;
-  *rt_free = NULL;
+  /* Do nothing if we have already rejected the route */
+  if (silent && bmap_test(&c->export_reject_map, rt->id))
+    goto reject_noset;
 
-  v = p->preexport ? p->preexport(p, rt) : 0;
+  int v = p->preexport ? p->preexport(c, rt) : 0;
   if (v < 0)
     {
       if (silent)
-	goto reject;
+	goto reject_noset;
 
-      stats->exp_updates_rejected++;
+      stats->updates_rejected++;
       if (v == RIC_REJECT)
-	rte_trace_out(D_FILTERS, c, rt, "rejected by protocol");
-      goto reject;
+	channel_rte_trace_out(D_FILTERS, c, rt, "rejected by protocol");
+      goto reject_noset;
+
     }
   if (v > 0)
     {
       if (!silent)
-	rte_trace_out(D_FILTERS, c, rt, "forced accept by protocol");
+	channel_rte_trace_out(D_FILTERS, c, rt, "forced accept by protocol");
       goto accept;
     }
 
   v = filter && ((filter == FILTER_REJECT) ||
-		 (f_run(filter, &rt,
+		 (f_run(filter, rt,
 			(silent ? FF_SILENT : 0)) > F_ACCEPT));
   if (v)
     {
       if (silent)
 	goto reject;
 
-      stats->exp_updates_filtered++;
-      rte_trace_out(D_FILTERS, c, rt, "filtered out");
+      stats->updates_filtered++;
+      channel_rte_trace_out(D_FILTERS, c, rt, "filtered out");
       goto reject;
     }
 
  accept:
-  if (rt != rt0)
-    *rt_free = rt;
+  /* We have accepted the route */
+  bmap_clear(&c->export_reject_map, rt->id);
   return rt;
 
  reject:
+  /* We have rejected the route by filter */
+  bmap_set(&c->export_reject_map, rt->id);
+
+reject_noset:
   /* Discard temporary rte */
-  if (rt != rt0)
-    rte_free(rt);
   return NULL;
 }
 
 static void
-do_rt_notify(struct channel *c, net *net, rte *new, rte *old, int refeed)
+do_rt_notify(struct channel *c, const net_addr *net, rte *new, const rte *old)
 {
   struct proto *p = c->proto;
-  struct proto_stats *stats = &c->stats;
+  struct channel_export_stats *stats = &c->export_stats;
 
-  if (refeed && new)
+  if (c->refeeding && new)
     c->refeed_count++;
 
-  /* Apply export limit */
-  struct channel_limit *l = &c->out_limit;
-  if (l->action && !old && new)
-  {
-    if (stats->exp_routes >= l->limit)
-      channel_notify_limit(c, l, PLD_OUT, stats->exp_routes);
-
-    if (l->state == PLS_BLOCKED)
+  if (!old && new)
+    if (CHANNEL_LIMIT_PUSH(c, OUT))
     {
-      stats->exp_updates_rejected++;
-      rte_trace_out(D_FILTERS, c, new, "rejected [limit]");
+      stats->updates_rejected++;
+      channel_rte_trace_out(D_FILTERS, c, new, "rejected [limit]");
       return;
     }
-  }
+
+  if (!new && old)
+    CHANNEL_LIMIT_POP(c, OUT);
 
   /* Apply export table */
-  struct rte *old_exported = NULL;
+  struct rte_storage *old_exported = NULL;
   if (c->out_table)
   {
-    if (!rte_update_out(c, net->n.addr, new, old, &old_exported, refeed))
+    if (!rte_update_out(c, net, new, old, &old_exported))
+    {
+      channel_rte_trace_out(D_ROUTES, c, new, "idempotent");
       return;
+    }
   }
-  else if (c->out_filter == FILTER_ACCEPT)
-    old_exported = old;
 
   if (new)
-    stats->exp_updates_accepted++;
+    stats->updates_accepted++;
   else
-    stats->exp_withdraws_accepted++;
+    stats->withdraws_accepted++;
 
   if (old)
-  {
     bmap_clear(&c->export_map, old->id);
-    stats->exp_routes--;
-  }
 
   if (new)
-  {
     bmap_set(&c->export_map, new->id);
-    stats->exp_routes++;
-  }
 
   if (p->debug & D_ROUTES)
   {
     if (new && old)
-      rte_trace_out(D_ROUTES, c, new, "replaced");
+      channel_rte_trace_out(D_ROUTES, c, new, "replaced");
     else if (new)
-      rte_trace_out(D_ROUTES, c, new, "added");
+      channel_rte_trace_out(D_ROUTES, c, new, "added");
     else if (old)
-      rte_trace_out(D_ROUTES, c, old, "removed");
+      channel_rte_trace_out(D_ROUTES, c, old, "removed");
   }
 
-  p->rt_notify(p, c, net, new, old);
+  p->rt_notify(p, c, net, new, old_exported ? &old_exported->rte : old);
 
   if (c->out_table && old_exported)
-    rte_free_quick(old_exported);
+    rte_free(old_exported);
 }
 
 static void
-rt_notify_basic(struct channel *c, net *net, rte *new, rte *old, int refeed)
+rt_notify_basic(struct channel *c, const net_addr *net, rte *new, rte *old)
 {
-  // struct proto *p = c->proto;
-  rte *new_free = NULL;
-
-  if (new)
-    c->stats.exp_updates_received++;
-  else
-    c->stats.exp_withdraws_received++;
-
   if (new)
-    new = export_filter(c, new, &new_free, 0);
+    new = export_filter(c, new, 0);
 
   if (old && !bmap_test(&c->export_map, old->id))
     old = NULL;
@@ -857,133 +864,134 @@ rt_notify_basic(struct channel *c, net *net, rte *new, rte *old, int refeed)
   if (!new && !old)
     return;
 
-  do_rt_notify(c, net, new, old, refeed);
-
-  /* Discard temporary rte */
-  if (new_free)
-    rte_free(new_free);
+  do_rt_notify(c, net, new, old);
 }
 
-static void
-rt_notify_accepted(struct channel *c, net *net, rte *new_changed, rte *old_changed, int refeed)
+void
+rt_notify_accepted(struct rt_export_request *req, const net_addr *n, struct rt_pending_export *rpe,
+    struct rte **feed, uint count)
 {
-  // struct proto *p = c->proto;
-  rte *new_best = NULL;
-  rte *old_best = NULL;
-  rte *new_free = NULL;
-  int new_first = 0;
-
-  /*
-   * We assume that there are no changes in net route order except (added)
-   * new_changed and (removed) old_changed. Therefore, the function is not
-   * compatible with deterministic_med (where nontrivial reordering can happen
-   * as a result of a route change) and with recomputation of recursive routes
-   * due to next hop update (where many routes can be changed in one step).
-   *
-   * Note that we need this assumption just for optimizations, we could just
-   * run full new_best recomputation otherwise.
-   *
-   * There are three cases:
-   * feed or old_best is old_changed -> we need to recompute new_best
-   * old_best is before new_changed -> new_best is old_best, ignore
-   * old_best is after new_changed -> try new_changed, otherwise old_best
-   */
+  struct channel *c = SKIP_BACK(struct channel, out_req, req);
 
-  if (net->routes)
-    c->stats.exp_updates_received++;
-  else
-    c->stats.exp_withdraws_received++;
+  rte nb0, *new_best = NULL;
+  const rte *old_best = NULL;
 
-  /* Find old_best - either old_changed, or route for net->routes */
-  if (old_changed && bmap_test(&c->export_map, old_changed->id))
-    old_best = old_changed;
-  else
+  for (uint i = 0; i < count; i++)
   {
-    for (rte *r = net->routes; rte_is_valid(r); r = r->next)
+    if (!rte_is_valid(feed[i]))
+      continue;
+
+    /* Has been already rejected, won't bother with it */
+    if (!c->refeeding && bmap_test(&c->export_reject_map, feed[i]->id))
+      continue;
+
+    /* Previously exported */
+    if (!old_best && bmap_test(&c->export_map, feed[i]->id))
     {
-      if (bmap_test(&c->export_map, r->id))
+      /* is still best */
+      if (!new_best)
       {
-	old_best = r;
-	break;
+	DBG("rt_notify_accepted: idempotent\n");
+	goto done;
       }
 
-      /* Note if new_changed found before old_best */
-      if (r == new_changed)
-	new_first = 1;
+      /* is superseded */
+      old_best = feed[i];
+      break;
+    }
+
+    /* Have no new best route yet */
+    if (!new_best)
+    {
+      /* Try this route not seen before */
+      nb0 = *feed[i];
+      new_best = export_filter(c, &nb0, 0);
+      DBG("rt_notify_accepted: checking route id %u: %s\n", feed[i]->id, new_best ? "ok" : "no");
     }
   }
 
-  /* Find new_best */
-  if ((new_changed == old_changed) || (old_best == old_changed))
-  {
-    /* Feed or old_best changed -> find first accepted by filters */
-    for (rte *r = net->routes; rte_is_valid(r); r = r->next)
-      if (new_best = export_filter(c, r, &new_free, 0))
+  /* Check obsolete routes for previously exported */
+  if (!old_best)
+    if (rpe && rpe->old && bmap_test(&c->export_map, rpe->old->rte.id))
+      old_best = &rpe->old->rte;
+
+/*    for (; rpe; rpe = atomic_load_explicit(&rpe->next, memory_order_relaxed))
+    {
+      if (rpe->old && bmap_test(&hook->accept_map, rpe->old->id))
+      {
+	old_best = &rpe->old.rte;
 	break;
-  }
-  else
-  {
-    /* Other cases -> either new_changed, or old_best (and nothing changed) */
-    if (new_first && (new_changed = export_filter(c, new_changed, &new_free, 0)))
-      new_best = new_changed;
-    else
-      return;
-  }
+      }
+
+      if (rpe == rpe_last)
+	break;
+    }
+    */
 
+  /* Nothing to export */
   if (!new_best && !old_best)
-    return;
+  {
+    DBG("rt_notify_accepted: nothing to export\n");
+    goto done;
+  }
 
-  do_rt_notify(c, net, new_best, old_best, refeed);
+  do_rt_notify(c, n, new_best, old_best);
 
-  /* Discard temporary rte */
-  if (new_free)
-    rte_free(new_free);
+done:
+  /* Drop the old stored rejection if applicable.
+   * new->id == old->id happens when updating hostentries. */
+  if (rpe && rpe->old && (!rpe->new || (rpe->new->rte.id != rpe->old->rte.id)))
+    bmap_clear(&c->export_reject_map, rpe->old->rte.id);
 }
 
 rte *
-rt_export_merged(struct channel *c, net *net, rte **rt_free, linpool *pool, int silent)
+rt_export_merged(struct channel *c, struct rte **feed, uint count, linpool *pool, int silent)
 {
+  _Thread_local static rte rloc;
+
   // struct proto *p = c->proto;
   struct nexthop_adata *nhs = NULL;
-  rte *best0, *best, *rt0, *rt, *tmp;
-
-  best0 = net->routes;
-  *rt_free = NULL;
+  rte *best0 = feed[0];
+  rte *best = NULL;
 
   if (!rte_is_valid(best0))
     return NULL;
 
-  best = export_filter(c, best0, rt_free, silent);
+  /* Already rejected, no need to re-run the filter */
+  if (!c->refeeding && bmap_test(&c->export_reject_map, best0->id))
+    return NULL;
+
+  rloc = *best0;
+  best = export_filter(c, &rloc, silent);
+
+  if (!best)
+    /* Best route doesn't pass the filter */
+    return NULL;
 
-  if (!best || !rte_is_reachable(best))
+  if (!rte_is_reachable(best))
+    /* Unreachable routes can't be merged */
     return best;
 
-  for (rt0 = best0->next; rt0; rt0 = rt0->next)
+  for (uint i = 1; i < count; i++)
   {
-    if (!rte_mergable(best0, rt0))
+    if (!rte_mergable(best0, feed[i]))
       continue;
 
-    rt = export_filter(c, rt0, &tmp, 1);
+    rte tmp0 = *feed[i];
+    rte *tmp = export_filter(c, &tmp0, 1);
 
-    if (!rt)
+    if (!tmp || !rte_is_reachable(tmp))
       continue;
 
-    if (rte_is_reachable(rt))
-    {
-      eattr *nhea = ea_find(rt->attrs->eattrs, &ea_gen_nexthop);
-      ASSERT_DIE(nhea);
-
-      if (nhs)
-	nhs = nexthop_merge(nhs, (struct nexthop_adata *) nhea->u.ptr, c->merge_limit, pool);
-      else
-	nhs = (struct nexthop_adata *) nhea->u.ptr;
-    }
+    eattr *nhea = ea_find(tmp->attrs->eattrs, &ea_gen_nexthop);
+    ASSERT_DIE(nhea);
 
-    if (tmp)
-      rte_free(tmp);
+    if (nhs)
+      nhs = nexthop_merge(nhs, (struct nexthop_adata *) nhea->u.ptr, c->merge_limit, pool);
+    else
+      nhs = (struct nexthop_adata *) nhea->u.ptr;
   }
 
-
   if (nhs)
   {
     eattr *nhea = ea_find(best->attrs->eattrs, &ea_gen_nexthop);
@@ -991,66 +999,115 @@ rt_export_merged(struct channel *c, net *net, rte **rt_free, linpool *pool, int
 
     nhs = nexthop_merge(nhs, (struct nexthop_adata *) nhea->u.ptr, c->merge_limit, pool);
 
-    best = rte_cow_rta(best, pool);
+    best->attrs = rta_cow(best->attrs, pool);
     ea_set_attr(&best->attrs->eattrs,
 	EA_LITERAL_DIRECT_ADATA(&ea_gen_nexthop, 0, &nhs->ad));
   }
 
-  if (best != best0)
-    *rt_free = best;
-
   return best;
 }
 
-
-static void
-rt_notify_merged(struct channel *c, net *net, rte *new_changed, rte *old_changed,
-		 rte *new_best, rte *old_best, int refeed)
+void
+rt_notify_merged(struct rt_export_request *req, const net_addr *n, struct rt_pending_export *rpe,
+    struct rte **feed, uint count)
 {
-  // struct proto *p = c->proto;
-  rte *new_free = NULL;
+  struct channel *c = SKIP_BACK(struct channel, out_req, req);
 
-  /* 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;
+  // struct proto *p = c->proto;
 
+#if 0 /* TODO: Find whether this check is possible when processing multiple changes at once. */
   /* Check whether the change is relevant to the merged route */
   if ((new_best == old_best) &&
       (new_changed != old_changed) &&
       !rte_mergable(new_best, new_changed) &&
       !rte_mergable(old_best, old_changed))
     return;
+#endif
 
-  if (new_best)
-    c->stats.exp_updates_received++;
-  else
-    c->stats.exp_withdraws_received++;
+  rte *old_best = NULL;
+  /* Find old best route */
+  for (uint i = 0; i < count; i++)
+    if (bmap_test(&c->export_map, feed[i]->id))
+    {
+      old_best = feed[i];
+      break;
+    }
+
+  /* Check obsolete routes for previously exported */
+  if (!old_best)
+    if (rpe && rpe->old && bmap_test(&c->export_map, rpe->old->rte.id))
+      old_best = &rpe->old->rte;
+
+/*    for (; rpe; rpe = atomic_load_explicit(&rpe->next, memory_order_relaxed))
+    {
+      if (rpe->old && bmap_test(&hook->accept_map, rpe->old->id))
+      {
+	old_best = &rpe->old.rte;
+	break;
+      }
+
+      if (rpe == rpe_last)
+	break;
+    }
+    */
 
   /* Prepare new merged route */
-  if (new_best)
-    new_best = rt_export_merged(c, net, &new_free, rte_update_pool, 0);
+  rte *new_merged = count ? rt_export_merged(c, feed, count, rte_update_pool, 0) : NULL;
 
-  /* Check old merged route */
-  if (old_best && !bmap_test(&c->export_map, old_best->id))
-    old_best = NULL;
+  if (new_merged || old_best)
+    do_rt_notify(c, n, new_merged, old_best);
 
-  if (!new_best && !old_best)
-    return;
+  /* Drop the old stored rejection if applicable.
+   * new->id == old->id happens when updating hostentries. */
+  if (rpe && rpe->old && (!rpe->new || (rpe->new->rte.id != rpe->old->rte.id)))
+    bmap_clear(&c->export_reject_map, rpe->old->rte.id);
+}
 
-  do_rt_notify(c, net, new_best, old_best, refeed);
+void
+rt_notify_optimal(struct rt_export_request *req, const net_addr *net, struct rt_pending_export *rpe)
+{
+  struct channel *c = SKIP_BACK(struct channel, out_req, req);
+  rte n0;
 
-  /* Discard temporary rte */
-  if (new_free)
-    rte_free(new_free);
+  if (rpe->new_best != rpe->old_best)
+    rt_notify_basic(c, net, RTE_COPY(rpe->new_best, &n0), RTE_OR_NULL(rpe->old_best));
+
+  /* Drop the old stored rejection if applicable.
+   * new->id == old->id happens when updating hostentries. */
+  if (rpe->old && (!rpe->new || (rpe->new->rte.id != rpe->old->rte.id)))
+    bmap_clear(&c->export_reject_map, rpe->old->rte.id);
 }
 
+void
+rt_notify_any(struct rt_export_request *req, const net_addr *net, struct rt_pending_export *rpe)
+{
+  struct channel *c = SKIP_BACK(struct channel, out_req, req);
+  rte n0;
+
+  if (rpe->new != rpe->old)
+    rt_notify_basic(c, net, RTE_COPY(rpe->new, &n0), RTE_OR_NULL(rpe->old));
+
+  /* Drop the old stored rejection if applicable.
+   * new->id == old->id happens when updating hostentries. */
+  if (rpe->old && (!rpe->new || (rpe->new->rte.id != rpe->old->rte.id)))
+    bmap_clear(&c->export_reject_map, rpe->old->rte.id);
+}
+
+void
+rt_feed_any(struct rt_export_request *req, const net_addr *net, struct rt_pending_export *rpe UNUSED, rte **feed, uint count)
+{
+  struct channel *c = SKIP_BACK(struct channel, out_req, req);
+
+  for (uint i=0; i<count; i++)
+  {
+    rte n0 = *feed[i];
+    rt_notify_basic(c, net, &n0, NULL);
+  }
+}
 
 /**
  * rte_announce - announce a routing table change
  * @tab: table the route has been added to
- * @type: type of route announcement (RA_UNDEF or RA_ANY)
  * @net: network in question
  * @new: the new or changed route
  * @old: the previous route replaced by the new one
@@ -1066,13 +1123,6 @@ rt_notify_merged(struct channel *c, net *net, rte *new_changed, rte *old_changed
  * and @new_best and @old_best describes best routes. Other routes are not
  * affected, but in sorted table the order of other routes might change.
  *
- * Second, There is a bulk change of multiple routes in @net, with shared best
- * route selection. In such case separate route changes are described using
- * @type of %RA_ANY, with @new and @old specifying the changed route, while
- * @new_best and @old_best are NULL. After that, another notification is done
- * where @new_best and @old_best are filled (may be the same), but @new and @old
- * are NULL.
- *
  * The function announces the change to all associated channels. For each
  * channel, an appropriate preprocessing is done according to channel &ra_mode.
  * For example, %RA_OPTIMAL channels receive just changes of best routes.
@@ -1087,19 +1137,19 @@ rt_notify_merged(struct channel *c, net *net, rte *new_changed, rte *old_changed
  * done outside of scope of rte_announce().
  */
 static void
-rte_announce(rtable *tab, uint type, net *net, rte *new, rte *old,
-	     rte *new_best, rte *old_best)
+rte_announce(rtable *tab, net *net, struct rte_storage *new, struct rte_storage *old,
+	     struct rte_storage *new_best, struct rte_storage *old_best)
 {
-  if (!rte_is_valid(new))
+  if (!rte_is_valid(RTE_OR_NULL(new)))
     new = NULL;
 
-  if (!rte_is_valid(old))
+  if (!rte_is_valid(RTE_OR_NULL(old)))
     old = NULL;
 
-  if (!rte_is_valid(new_best))
+  if (!rte_is_valid(RTE_OR_NULL(new_best)))
     new_best = NULL;
 
-  if (!rte_is_valid(old_best))
+  if (!rte_is_valid(RTE_OR_NULL(old_best)))
     old_best = NULL;
 
   if (!new && !old && !new_best && !old_best)
@@ -1108,9 +1158,9 @@ rte_announce(rtable *tab, uint type, net *net, rte *new, rte *old,
   if (new_best != old_best)
   {
     if (new_best)
-      new_best->sender->stats.pref_routes++;
+      new_best->rte.sender->stats.pref++;
     if (old_best)
-      old_best->sender->stats.pref_routes--;
+      old_best->rte.sender->stats.pref--;
 
     if (tab->hostcache)
       rt_notify_hostcache(tab, net);
@@ -1121,69 +1171,66 @@ rte_announce(rtable *tab, uint type, net *net, rte *new, rte *old,
 
   rt_schedule_notify(tab);
 
-  struct channel *c; node *n;
-  WALK_LIST2(c, n, tab->channels, table_node)
+  struct rt_pending_export rpe = { .new = new, .old = old, .new_best = new_best, .old_best = old_best };
+  uint count = rte_feed_count(net);
+  rte **feed = NULL;
+  if (count)
   {
-    if (c->export_state == ES_DOWN)
-      continue;
+    feed = alloca(count * sizeof(rte *));
+    rte_feed_obtain(net, feed, count);
+  }
 
-    if (type && (type != c->ra_mode))
+  struct rt_export_hook *eh;
+  WALK_LIST(eh, tab->exports)
+  {
+    if (eh->export_state == TES_STOP)
       continue;
 
-    switch (c->ra_mode)
-    {
-    case RA_OPTIMAL:
-      if (new_best != old_best)
-	rt_notify_basic(c, net, new_best, old_best, 0);
-      break;
-
-    case RA_ANY:
-      if (new != old)
-	rt_notify_basic(c, net, new, old, 0);
-      break;
-
-    case RA_ACCEPTED:
-      rt_notify_accepted(c, net, new, old, 0);
-      break;
+    if (new)
+      eh->stats.updates_received++;
+    else
+      eh->stats.withdraws_received++;
 
-    case RA_MERGED:
-      rt_notify_merged(c, net, new, old, new_best, old_best, 0);
-      break;
-    }
+    if (eh->req->export_one)
+      eh->req->export_one(eh->req, net->n.addr, &rpe);
+    else if (eh->req->export_bulk)
+      eh->req->export_bulk(eh->req, net->n.addr, &rpe, feed, count);
+    else
+      bug("Export request must always provide an export method");
   }
 }
 
 static inline int
-rte_validate(rte *e)
+rte_validate(struct channel *ch, rte *e)
 {
   int c;
-  net *n = e->net;
+  const net_addr *n = e->net;
 
-  if (!net_validate(n->n.addr))
+  if (!net_validate(n))
   {
     log(L_WARN "Ignoring bogus prefix %N received via %s",
-	n->n.addr, e->sender->proto->name);
+	n, ch->proto->name);
     return 0;
   }
 
   /* FIXME: better handling different nettypes */
-  c = !net_is_flow(n->n.addr) ?
-    net_classify(n->n.addr): (IADDR_HOST | SCOPE_UNIVERSE);
+  c = !net_is_flow(n) ?
+    net_classify(n): (IADDR_HOST | SCOPE_UNIVERSE);
   if ((c < 0) || !(c & IADDR_HOST) || ((c & IADDR_SCOPE_MASK) <= SCOPE_LINK))
   {
     log(L_WARN "Ignoring bogus route %N received via %s",
-	n->n.addr, e->sender->proto->name);
+	n, ch->proto->name);
     return 0;
   }
 
-  if (net_type_match(n->n.addr, NB_DEST) == !e->attrs->dest)
+  if (net_type_match(n, NB_DEST) == !e->attrs->dest)
   {
     /* Exception for flowspec that failed validation */
-    if (net_is_flow(n->n.addr) && (e->attrs->dest == RTD_UNREACHABLE))
+    if (net_is_flow(n) && (e->attrs->dest == RTD_UNREACHABLE))
       return 1;
 
     log(L_WARN "Ignoring route %N with invalid dest %d received via %s",
-	n->n.addr, e->attrs->dest, e->sender->proto->name);
+	n, e->attrs->dest, ch->proto->name);
     return 0;
   }
 
@@ -1191,7 +1238,7 @@ rte_validate(rte *e)
   if ((!nhea) != (e->attrs->dest != RTD_UNICAST))
   {
     log(L_WARN "Ignoring route %N with destination %d and %snexthop received via %s",
-	n->n.addr, e->attrs->dest, (nhea ? "" : "no "), e->sender->proto->name);
+	n, e->attrs->dest, (nhea ? "" : "no "), ch->proto->name);
     return 0;
   }
 
@@ -1199,7 +1246,7 @@ rte_validate(rte *e)
       !nexthop_is_sorted((struct nexthop_adata *) nhea->u.ptr))
   {
     log(L_WARN "Ignoring unsorted multipath route %N received via %s",
-	n->n.addr, e->sender->proto->name);
+	n, ch->proto->name);
     return 0;
   }
 
@@ -1220,41 +1267,36 @@ 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 channel *c, net *net, rte *new, struct rte_src *src)
+rte_recalculate(struct rt_import_hook *c, net *net, rte *new, struct rte_src *src)
 {
-  struct proto *p = c->proto;
+  struct rt_import_request *req = c->req;
   struct rtable *table = c->table;
-  struct proto_stats *stats = &c->stats;
-  static struct tbf rl_pipe = TBF_DEFAULT_LOG_LIMITS;
-  rte *before_old = NULL;
-  rte *old_best = net->routes;
+  struct rt_import_stats *stats = &c->stats;
+  struct rte_storage *old_best_stored = net->routes, *old_stored = NULL;
+  rte *old_best = old_best_stored ? &old_best_stored->rte : NULL;
   rte *old = NULL;
-  rte **k;
 
-  k = &net->routes;			/* Find and remove original route from the same protocol */
-  while (old = *k)
+  /* Find and remove original route from the same protocol */
+  struct rte_storage **before_old = rte_find(net, src);
+
+  if (*before_old)
     {
-      if (old->src == src)
+      old = &(old_stored = (*before_old))->rte;
+
+      /* If there is the same route in the routing table but from
+       * a different sender, then there are two paths from the
+       * source protocol to this routing table through transparent
+       * pipes, which is not allowed.
+       * We log that and ignore the route. */
+      if (old->sender != c)
 	{
-	  /* If there is the same route in the routing table but from
-	   * a different sender, then there are two paths from the
-	   * source protocol to this routing table through transparent
-	   * pipes, which is not allowed.
-	   *
-	   * We log that and ignore the route. If it is withdraw, we
-	   * ignore it completely (there might be 'spurious withdraws',
-	   * see FIXME in do_rte_announce())
-	   */
-	  if (old->sender->proto != p)
-	    {
-	      if (new)
-		{
-		  log_rl(&rl_pipe, L_ERR "Pipe collision detected when sending %N to table %s",
-		      net->n.addr, table->name);
-		  rte_free_quick(new);
-		}
-	      return;
-	    }
+	  if (!old->generation && !new->generation)
+	    bug("Two protocols claim to author a route with the same rte_src in table %s: %N %s/%u:%u",
+		c->table->name, net->n.addr, old->src->proto->name, old->src->private_id, old->src->global_id);
+
+	  log_rl(&table->rl_pipe, L_ERR "Route source collision in table %s: %N %s/%u:%u",
+		c->table->name, net->n.addr, old->src->proto->name, old->src->private_id, old->src->global_id);
+	}
 
 	  if (new && rte_same(old, new))
 	    {
@@ -1264,123 +1306,56 @@ rte_recalculate(struct channel *c, net *net, rte *new, struct rte_src *src)
 
 	      if (!rte_is_filtered(new))
 		{
-		  stats->imp_updates_ignored++;
-		  rte_trace_in(D_ROUTES, c, new, "ignored");
+		  stats->updates_ignored++;
+		  rt_rte_trace_in(D_ROUTES, req, new, "ignored");
 		}
+	  }
 
-	      rte_free_quick(new);
-	      return;
-	    }
-	  *k = old->next;
-	  table->rt_count--;
-	  break;
-	}
-      k = &old->next;
-      before_old = old;
+	*before_old = (*before_old)->next;
+	table->rt_count--;
     }
 
-  /* Save the last accessed position */
-  rte **pos = k;
-
-  if (!old)
-    before_old = NULL;
-
   if (!old && !new)
     {
-      stats->imp_withdraws_ignored++;
+      stats->withdraws_ignored++;
       return;
     }
 
+  if (req->preimport)
+    new = req->preimport(req, new, old);
+
   int new_ok = rte_is_ok(new);
   int old_ok = rte_is_ok(old);
 
-  struct channel_limit *l = &c->rx_limit;
-  if (l->action && !old && new && !c->in_table)
-    {
-      u32 all_routes = stats->imp_routes + stats->filt_routes;
-
-      if (all_routes >= l->limit)
-	channel_notify_limit(c, l, PLD_RX, all_routes);
-
-      if (l->state == PLS_BLOCKED)
-	{
-	  /* In receive limit the situation is simple, old is NULL so
-	     we just free new and exit like nothing happened */
-
-	  stats->imp_updates_ignored++;
-	  rte_trace_in(D_FILTERS, c, new, "ignored [limit]");
-	  rte_free_quick(new);
-	  return;
-	}
-    }
-
-  l = &c->in_limit;
-  if (l->action && !old_ok && new_ok)
-    {
-      if (stats->imp_routes >= l->limit)
-	channel_notify_limit(c, l, PLD_IN, stats->imp_routes);
-
-      if (l->state == PLS_BLOCKED)
-	{
-	  /* In import limit the situation is more complicated. We
-	     shouldn't just drop the route, we should handle it like
-	     it was filtered. We also have to continue the route
-	     processing if old or new is non-NULL, but we should exit
-	     if both are NULL as this case is probably assumed to be
-	     already handled. */
-
-	  stats->imp_updates_ignored++;
-	  rte_trace_in(D_FILTERS, c, new, "ignored [limit]");
-
-	  if (c->in_keep_filtered)
-	    new->flags |= REF_FILTERED;
-	  else
-	    { rte_free_quick(new); new = NULL; }
-
-	  /* Note that old && !new could be possible when
-	     c->in_keep_filtered changed in the recent past. */
-
-	  if (!old && !new)
-	    return;
-
-	  new_ok = 0;
-	  goto skip_stats1;
-	}
-    }
-
   if (new_ok)
-    stats->imp_updates_accepted++;
+    stats->updates_accepted++;
   else if (old_ok)
-    stats->imp_withdraws_accepted++;
+    stats->withdraws_accepted++;
   else
-    stats->imp_withdraws_ignored++;
+    stats->withdraws_ignored++;
 
   if (old_ok || new_ok)
     table->last_rt_change = current_time();
 
- skip_stats1:
-
-  if (new)
-    rte_is_filtered(new) ? stats->filt_routes++ : stats->imp_routes++;
-  if (old)
-    rte_is_filtered(old) ? stats->filt_routes-- : stats->imp_routes--;
+  struct rte_storage *new_stored = new ? rte_store(new, net, table) : NULL;
 
   if (table->config->sorted)
     {
       /* If routes are sorted, just insert new route to appropriate position */
-      if (new)
+      if (new_stored)
 	{
-	  if (before_old && !rte_better(new, before_old))
-	    k = &before_old->next;
+	  struct rte_storage **k;
+	  if ((before_old != &net->routes) && !rte_better(new, &SKIP_BACK(struct rte_storage, next, before_old)->rte))
+	    k = before_old;
 	  else
 	    k = &net->routes;
 
 	  for (; *k; k=&(*k)->next)
-	    if (rte_better(new, *k))
+	    if (rte_better(new, &(*k)->rte))
 	      break;
 
-	  new->next = *k;
-	  *k = new;
+	  new_stored->next = *k;
+	  *k = new_stored;
 
 	  table->rt_count++;
 	}
@@ -1390,16 +1365,17 @@ rte_recalculate(struct channel *c, net *net, rte *new, struct rte_src *src)
       /* If routes are not sorted, find the best route and move it on
 	 the first position. There are several optimized cases. */
 
-      if (src->proto->rte_recalculate && src->proto->rte_recalculate(table, net, new, old, old_best))
+      if (src->proto->rte_recalculate &&
+	  src->proto->rte_recalculate(table, net, new_stored ? &new_stored->rte : NULL, old, old_best))
 	goto do_recalculate;
 
-      if (new && rte_better(new, old_best))
+      if (new_stored && rte_better(&new_stored->rte, old_best))
 	{
 	  /* The first case - the new route is cleary optimal,
 	     we link it at the first position */
 
-	  new->next = net->routes;
-	  net->routes = new;
+	  new_stored->next = net->routes;
+	  net->routes = new_stored;
 
 	  table->rt_count++;
 	}
@@ -1413,10 +1389,10 @@ rte_recalculate(struct channel *c, net *net, rte *new, struct rte_src *src)
 
 	do_recalculate:
 	  /* Add the new route to the list */
-	  if (new)
+	  if (new_stored)
 	    {
-	      new->next = *pos;
-	      *pos = new;
+	      new_stored->next = *before_old;
+	      *before_old = new_stored;
 
 	      table->rt_count++;
 	    }
@@ -1424,81 +1400,82 @@ rte_recalculate(struct channel *c, net *net, rte *new, struct rte_src *src)
 	  /* Find a new optimal route (if there is any) */
 	  if (net->routes)
 	    {
-	      rte **bp = &net->routes;
-	      for (k=&(*bp)->next; *k; k=&(*k)->next)
-		if (rte_better(*k, *bp))
+	      struct rte_storage **bp = &net->routes;
+	      for (struct rte_storage **k=&(*bp)->next; *k; k=&(*k)->next)
+		if (rte_better(&(*k)->rte, &(*bp)->rte))
 		  bp = k;
 
 	      /* And relink it */
-	      rte *best = *bp;
+	      struct rte_storage *best = *bp;
 	      *bp = best->next;
 	      best->next = net->routes;
 	      net->routes = best;
 	    }
 	}
-      else if (new)
+      else if (new_stored)
 	{
 	  /* The third case - the new route is not better than the old
 	     best route (therefore old_best != NULL) and the old best
 	     route was not removed (therefore old_best == net->routes).
 	     We just link the new route to the old/last position. */
 
-	  new->next = *pos;
-	  *pos = new;
+	  new_stored->next = *before_old;
+	  *before_old = new_stored;
 
 	  table->rt_count++;
 	}
       /* The fourth (empty) case - suboptimal route was removed, nothing to do */
     }
 
-  if (new)
+  if (new_stored)
     {
-      new->lastmod = current_time();
+      new_stored->rte.lastmod = current_time();
 
       if (!old)
         {
-	  new->id = hmap_first_zero(&table->id_map);
-	  hmap_set(&table->id_map, new->id);
+	  new_stored->rte.id = hmap_first_zero(&table->id_map);
+	  hmap_set(&table->id_map, new_stored->rte.id);
 	}
       else
-	new->id = old->id;
+	new_stored->rte.id = old->id;
     }
 
   /* Log the route change */
-  if ((c->debug & D_ROUTES) || (p->debug & D_ROUTES))
+  if (new_ok)
+    rt_rte_trace_in(D_ROUTES, req, &new_stored->rte, new_stored == net->routes ? "added [best]" : "added");
+  else if (old_ok)
     {
-      if (new_ok)
-	rte_trace(c, new, '>', new == net->routes ? "added [best]" : "added");
-      else if (old_ok)
-	{
-	  if (old != old_best)
-	    rte_trace(c, old, '>', "removed");
-	  else if (rte_is_ok(net->routes))
-	    rte_trace(c, old, '>', "removed [replaced]");
-	  else
-	    rte_trace(c, old, '>', "removed [sole]");
-	}
+      if (old != old_best)
+	rt_rte_trace_in(D_ROUTES, req, old, "removed");
+      else if (net->routes && rte_is_ok(&net->routes->rte))
+	rt_rte_trace_in(D_ROUTES, req, old, "removed [replaced]");
+      else
+	rt_rte_trace_in(D_ROUTES, req, old, "removed [sole]");
     }
 
   /* Propagate the route change */
-  rte_announce(table, RA_UNDEF, net, new, old, net->routes, old_best);
+  rte_announce(table, net, new_stored, old_stored,
+      net->routes, old_best_stored);
 
   if (!net->routes &&
       (table->gc_counter++ >= table->config->gc_max_ops) &&
       (table->gc_time + table->config->gc_min_time <= current_time()))
     rt_schedule_prune(table);
 
+#if 0
+  /* Enable and reimplement these callbacks if anybody wants to use them */
   if (old_ok && p->rte_remove)
     p->rte_remove(net, old);
   if (new_ok && p->rte_insert)
-    p->rte_insert(net, new);
+    p->rte_insert(net, &new_stored->rte);
+#endif
 
   if (old)
     {
-      if (!new)
+      if (!new_stored)
 	hmap_clear(&table->id_map, old->id);
 
-      rte_free_quick(old);
+      rte_free(old_stored);
     }
 }
 
@@ -1517,174 +1494,150 @@ rte_update_unlock(void)
     lp_flush(rte_update_pool);
 }
 
-/**
- * rte_update - enter a new update to a routing table
- * @table: table to be updated
- * @c: channel doing the update
- * @net: network node
- * @p: protocol submitting the update
- * @src: protocol originating the update
- * @new: a &rte representing the new route or %NULL for route removal.
- *
- * This function is called by the routing protocols whenever they discover
- * a new route or wish to update/remove an existing route. The right announcement
- * sequence is to build route attributes first (either un-cached with @aflags set
- * to zero or a cached one using rta_lookup(); in this case please note that
- * you need to increase the use count of the attributes yourself by calling
- * rta_clone()), call rte_get_temp() to obtain a temporary &rte, fill in all
- * the appropriate data and finally submit the new &rte by calling rte_update().
- *
- * @src specifies the protocol that originally created the route and the meaning
- * of protocol-dependent data of @new. If @new is not %NULL, @src have to be the
- * same value as @new->attrs->proto. @p specifies the protocol that called
- * rte_update(). In most cases it is the same protocol as @src. rte_update()
- * stores @p in @new->sender;
- *
- * When rte_update() gets any route, it automatically validates it (checks,
- * whether the network and next hop address are valid IP addresses and also
- * whether a normal routing protocol doesn't try to smuggle a host or link
- * scope route to the table), converts all protocol dependent attributes stored
- * in the &rte to temporary extended attributes, consults import filters of the
- * protocol to see if the route should be accepted and/or its attributes modified,
- * stores the temporary attributes back to the &rte.
- *
- * Now, having a "public" version of the route, we
- * automatically find any old route defined by the protocol @src
- * for network @n, replace it by the new one (or removing it if @new is %NULL),
- * recalculate the optimal route for this destination and finally broadcast
- * the change (if any) to all routing protocols by calling rte_announce().
- *
- * All memory used for attribute lists and other temporary allocations is taken
- * from a special linear pool @rte_update_pool and freed when rte_update()
- * finishes.
- */
+rte *
+channel_preimport(struct rt_import_request *req, rte *new, rte *old)
+{
+  struct channel *c = SKIP_BACK(struct channel, in_req, req);
+
+  if (new && !old)
+    if (CHANNEL_LIMIT_PUSH(c, RX))
+      return NULL;
+
+  if (!new && old)
+    CHANNEL_LIMIT_POP(c, RX);
+
+  int new_in = new && !rte_is_filtered(new);
+  int old_in = old && !rte_is_filtered(old);
+
+  if (new_in && !old_in)
+    if (CHANNEL_LIMIT_PUSH(c, IN))
+      if (c->in_keep_filtered)
+      {
+	new->flags |= REF_FILTERED;
+	return new;
+      }
+      else
+	return NULL;
+
+  if (!new_in && old_in)
+    CHANNEL_LIMIT_POP(c, IN);
+
+  return new;
+}
+
+static void rte_update_direct(struct channel *c, const net_addr *n, rte *new, struct rte_src *src);
 
 void
-rte_update2(struct channel *c, const net_addr *n, rte *new, struct rte_src *src)
+rte_update(struct channel *c, const net_addr *n, rte *new, struct rte_src *src)
 {
-  // struct proto *p = c->proto;
-  struct proto_stats *stats = &c->stats;
-  const struct filter *filter = c->in_filter;
-  net *nn;
+  if (!c->in_req.hook)
+    return;
 
   ASSERT(c->channel_state == CS_UP);
 
+  if (c->in_table && !rte_update_in(c, n, new, src))
+    return;
+
+  return rte_update_direct(c, n, new, src);
+}
+
+static void
+rte_update_direct(struct channel *c, const net_addr *n, rte *new, struct rte_src *src)
+{
+  const struct filter *filter = c->in_filter;
+  struct channel_import_stats *stats = &c->import_stats;
+
   rte_update_lock();
   if (new)
     {
-      /* Create a temporary table node */
-      nn = alloca(sizeof(net) + n->length);
-      memset(nn, 0, sizeof(net) + n->length);
-      net_copy(nn->n.addr, n);
+      new->net = n;
 
-      new->net = nn;
-      new->sender = c;
+      int fr;
 
-      stats->imp_updates_received++;
-      if (!rte_validate(new))
+      stats->updates_received++;
+      if (!rte_validate(c, new))
 	{
-	  rte_trace_in(D_FILTERS, c, new, "invalid");
-	  stats->imp_updates_invalid++;
-	  goto drop;
+	  channel_rte_trace_in(D_FILTERS, c, new, "invalid");
+	  stats->updates_invalid++;
+	  new = NULL;
 	}
-
-      if (filter == FILTER_REJECT)
+      else if ((filter == FILTER_REJECT) ||
+	((fr = f_run(filter, new, 0)) > F_ACCEPT))
 	{
-	  stats->imp_updates_filtered++;
-	  rte_trace_in(D_FILTERS, c, new, "filtered out");
-
-	  if (! c->in_keep_filtered)
-	    goto drop;
+	  stats->updates_filtered++;
+	  channel_rte_trace_in(D_FILTERS, c, new, "filtered out");
 
-	  /* new is a private copy, i could modify it */
-	  new->flags |= REF_FILTERED;
+	  if (c->in_keep_filtered)
+	    new->flags |= REF_FILTERED;
+	  else
+	    new = NULL;
 	}
-      else if (filter)
-	{
-	  int fr = f_run(filter, &new, 0);
-	  if (fr > F_ACCEPT)
-	  {
-	    stats->imp_updates_filtered++;
-	    rte_trace_in(D_FILTERS, c, new, "filtered out");
+    }
+  else
+    stats->withdraws_received++;
 
-	    if (! c->in_keep_filtered)
-	      goto drop;
+  rte_import(&c->in_req, n, new, src);
 
-	    new->flags |= REF_FILTERED;
-	  }
-	}
-      if (!rta_is_cached(new->attrs)) /* Need to copy attributes */
-	new->attrs = rta_lookup(new->attrs);
-      new->flags |= REF_COW;
+  rte_update_unlock();
+}
+
+void
+rte_import(struct rt_import_request *req, const net_addr *n, rte *new, struct rte_src *src)
+{
+  struct rt_import_hook *hook = req->hook;
+  if (!hook)
+    return;
 
+  net *nn;
+  if (new)
+    {
       /* Use the actual struct network, not the dummy one */
-      nn = net_get(c->table, n);
-      new->net = nn;
+      nn = net_get(hook->table, n);
+      new->net = nn->n.addr;
+      new->sender = hook;
     }
-  else
+  else if (!(nn = net_find(hook->table, n)))
     {
-      stats->imp_withdraws_received++;
-
-      if (!(nn = net_find(c->table, n)) || !src)
-	{
-	  stats->imp_withdraws_ignored++;
-	  rte_update_unlock();
-	  return;
-	}
+      req->hook->stats.withdraws_ignored++;
+      return;
     }
 
- recalc:
   /* And recalculate the best route */
-  rte_recalculate(c, nn, new, src);
-
-  rte_update_unlock();
-  return;
-
- drop:
-  rte_free(new);
-  new = NULL;
-  if (nn = net_find(c->table, n))
-    goto recalc;
-
-  rte_update_unlock();
+  rte_recalculate(hook, nn, new, 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, uint type, net *net, rte *new, rte *old,
-	       rte *new_best, rte *old_best)
+rte_announce_i(rtable *tab, net *net, struct rte_storage *new, struct rte_storage *old,
+	       struct rte_storage *new_best, struct rte_storage *old_best)
 {
   rte_update_lock();
-  rte_announce(tab, type, net, new, old, new_best, old_best);
+  rte_announce(tab, net, new, old, new_best, old_best);
   rte_update_unlock();
 }
 
 static inline void
-rte_discard(rte *old)	/* Non-filtered route deletion, used during garbage collection */
+rte_discard(net *net, rte *old)	/* Non-filtered route deletion, used during garbage collection */
 {
   rte_update_lock();
-  rte_recalculate(old->sender, old->net, NULL, old->src);
+  rte_recalculate(old->sender, net, NULL, old->src);
   rte_update_unlock();
 }
 
 /* Modify existing route by protocol hook, used for long-lived graceful restart */
 static inline void
-rte_modify(rte *old)
+rte_modify(net *net, rte *old)
 {
   rte_update_lock();
 
-  rte *new = old->sender->proto->rte_modify(old, rte_update_pool);
+  rte *new = old->sender->req->rte_modify(old, rte_update_pool);
   if (new != old)
   {
     if (new)
-    {
-      if (!rta_is_cached(new->attrs))
-	new->attrs = rta_lookup(new->attrs);
-      new->flags = (old->flags & ~REF_MODIFY) | REF_COW;
-    }
+      new->flags = old->flags & ~REF_MODIFY;
 
-    rte_recalculate(old->sender, old->net, new, old->src);
+    rte_recalculate(old->sender, net, new, old->src);
   }
 
   rte_update_unlock();
@@ -1692,30 +1645,148 @@ rte_modify(rte *old)
 
 /* Check rtable for best route to given net whether it would be exported do p */
 int
-rt_examine(rtable *t, net_addr *a, struct proto *p, const struct filter *filter)
+rt_examine(rtable *t, net_addr *a, struct channel *c, const struct filter *filter)
 {
   net *n = net_find(t, a);
-  rte *rt = n ? n->routes : NULL;
 
-  if (!rte_is_valid(rt))
+  if (!n || !rte_is_valid(RTE_OR_NULL(n->routes)))
     return 0;
 
+  rte rt = n->routes->rte;
+
   rte_update_lock();
 
   /* Rest is stripped down export_filter() */
-  int v = p->preexport ? p->preexport(p, rt) : 0;
+  int v = c->proto->preexport ? c->proto->preexport(c, &rt) : 0;
   if (v == RIC_PROCESS)
     v = (f_run(filter, &rt, FF_SILENT) <= F_ACCEPT);
 
-  /* Discard temporary rte */
-  if (rt != n->routes)
-    rte_free(rt);
-
   rte_update_unlock();
 
   return v > 0;
 }
 
+static void
+rt_export_stopped(void *data)
+{
+  struct rt_export_hook *hook = data;
+  rtable *tab = hook->table;
+
+  /* Unlist */
+  rem_node(&hook->n);
+
+  /* Reporting the channel as stopped. */
+  hook->stopped(hook->req);
+
+  /* Freeing the hook together with its coroutine. */
+  rfree(hook->pool);
+  rt_unlock_table(tab);
+
+  DBG("Export hook %p in table %s finished uc=%u\n", hook, tab->name, tab->use_count);
+}
+
+
+static inline void
+rt_set_import_state(struct rt_import_hook *hook, u8 state)
+{
+  hook->last_state_change = current_time();
+  hook->import_state = state;
+
+  if (hook->req->log_state_change)
+    hook->req->log_state_change(hook->req, state);
+}
+
+static inline void
+rt_set_export_state(struct rt_export_hook *hook, u8 state)
+{
+  hook->last_state_change = current_time();
+  hook->export_state = state;
+
+  if (hook->req->log_state_change)
+    hook->req->log_state_change(hook->req, state);
+}
+
+void
+rt_request_import(rtable *tab, struct rt_import_request *req)
+{
+  rt_lock_table(tab);
+
+  struct rt_import_hook *hook = req->hook = mb_allocz(tab->rp, sizeof(struct rt_import_hook));
+
+  DBG("Lock table %s for import %p req=%p uc=%u\n", tab->name, hook, req, tab->use_count);
+
+  hook->req = req;
+  hook->table = tab;
+
+  rt_set_import_state(hook, TIS_UP);
+
+  hook->n = (node) {};
+  add_tail(&tab->imports, &hook->n);
+}
+
+void
+rt_stop_import(struct rt_import_request *req, void (*stopped)(struct rt_import_request *))
+{
+  ASSERT_DIE(req->hook);
+  struct rt_import_hook *hook = req->hook;
+
+  rt_schedule_prune(hook->table);
+
+  rt_set_import_state(hook, TIS_STOP);
+
+  hook->stopped = stopped;
+}
+
+void
+rt_request_export(rtable *tab, struct rt_export_request *req)
+{
+  rt_lock_table(tab);
+
+  pool *p = rp_new(tab->rp, "Export hook");
+  struct rt_export_hook *hook = req->hook = mb_allocz(p, sizeof(struct rt_export_hook));
+  hook->pool = p;
+  hook->lp = lp_new_default(p);
+  
+  hook->req = req;
+  hook->table = tab;
+
+  /* stats zeroed by mb_allocz */
+
+  rt_set_export_state(hook, TES_HUNGRY);
+
+  hook->n = (node) {};
+  add_tail(&tab->exports, &hook->n);
+
+  FIB_ITERATE_INIT(&hook->feed_fit, &tab->fib);
+
+  DBG("New export hook %p req %p in table %s uc=%u\n", hook, req, tab->name, tab->use_count);
+
+  rt_set_export_state(hook, TES_FEEDING);
+
+  hook->event = ev_new_init(p, rt_feed_channel, hook);
+  ev_schedule_work(hook->event);
+}
+
+void
+rt_stop_export(struct rt_export_request *req, void (*stopped)(struct rt_export_request *))
+{
+  ASSERT_DIE(req->hook);
+  struct rt_export_hook *hook = req->hook;
+
+  rtable *tab = hook->table;
+
+  /* Stop feeding */
+  ev_postpone(hook->event);
+
+  if (hook->export_state == TES_FEEDING)
+    fit_get(&tab->fib, &hook->feed_fit);
+
+  hook->event->hook = rt_export_stopped;
+  hook->stopped = stopped;
+
+  rt_set_export_state(hook, TES_STOP);
+  ev_schedule(hook->event);
+}
 
 /**
  * rt_refresh_begin - start a refresh cycle
@@ -1732,14 +1803,13 @@ rt_examine(rtable *t, net_addr *a, struct proto *p, const struct filter *filter)
  * flag in rt_refresh_end() and then removing such routes in the prune loop.
  */
 void
-rt_refresh_begin(rtable *t, struct channel *c)
+rt_refresh_begin(rtable *t, struct rt_import_request *req)
 {
   FIB_WALK(&t->fib, net, n)
     {
-      rte *e;
-      for (e = n->routes; e; e = e->next)
-	if (e->sender == c)
-	  e->flags |= REF_STALE;
+      for (struct rte_storage *e = n->routes; e; e = e->next)
+	if (e->rte.sender == req->hook)
+	  e->rte.flags |= REF_STALE;
     }
   FIB_WALK_END;
 }
@@ -1753,17 +1823,16 @@ rt_refresh_begin(rtable *t, struct channel *c)
  * hook. See rt_refresh_begin() for description of refresh cycles.
  */
 void
-rt_refresh_end(rtable *t, struct channel *c)
+rt_refresh_end(rtable *t, struct rt_import_request *req)
 {
   int prune = 0;
 
   FIB_WALK(&t->fib, net, n)
     {
-      rte *e;
-      for (e = n->routes; e; e = e->next)
-	if ((e->sender == c) && (e->flags & REF_STALE))
+      for (struct rte_storage *e = n->routes; e; e = e->next)
+	if ((e->rte.sender == req->hook) && (e->rte.flags & REF_STALE))
 	  {
-	    e->flags |= REF_DISCARD;
+	    e->rte.flags |= REF_DISCARD;
 	    prune = 1;
 	  }
     }
@@ -1774,17 +1843,16 @@ rt_refresh_end(rtable *t, struct channel *c)
 }
 
 void
-rt_modify_stale(rtable *t, struct channel *c)
+rt_modify_stale(rtable *t, struct rt_import_request *req)
 {
   int prune = 0;
 
   FIB_WALK(&t->fib, net, n)
     {
-      rte *e;
-      for (e = n->routes; e; e = e->next)
-	if ((e->sender == c) && (e->flags & REF_STALE) && !(e->flags & REF_FILTERED))
+      for (struct rte_storage *e = n->routes; e; e = e->next)
+	if ((e->rte.sender == req->hook) && (e->rte.flags & REF_STALE) && !(e->rte.flags & REF_FILTERED))
 	  {
-	    e->flags |= REF_MODIFY;
+	    e->rte.flags |= REF_MODIFY;
 	    prune = 1;
 	  }
     }
@@ -1801,12 +1869,11 @@ rt_modify_stale(rtable *t, struct channel *c)
  * This functions dumps contents of a &rte to debug output.
  */
 void
-rte_dump(rte *e)
+rte_dump(struct rte_storage *e)
 {
-  net *n = e->net;
-  debug("%-1N ", n->n.addr);
-  debug("PF=%02x ", e->pflags);
-  rta_dump(e->attrs);
+  debug("%-1N ", e->rte.net);
+  debug("PF=%02x ", e->rte.pflags);
+  rta_dump(e->rte.attrs);
   debug("\n");
 }
 
@@ -1819,14 +1886,13 @@ rte_dump(rte *e)
 void
 rt_dump(rtable *t)
 {
-  debug("Dump of routing table <%s>\n", t->name);
+  debug("Dump of routing table <%s>%s\n", t->name, t->deleted ? " (deleted)" : "");
 #ifdef DEBUGGING
   fib_check(&t->fib);
 #endif
   FIB_WALK(&t->fib, net, n)
     {
-      rte *e;
-      for(e=n->routes; e; e=e->next)
+      for(struct rte_storage *e=n->routes; e; e=e->next)
 	rte_dump(e);
     }
   FIB_WALK_END;
@@ -1846,6 +1912,54 @@ rt_dump_all(void)
 
   WALK_LIST2(t, n, routing_tables, n)
     rt_dump(t);
+
+  WALK_LIST2(t, n, deleted_routing_tables, n)
+    rt_dump(t);
+}
+
+void
+rt_dump_hooks(rtable *tab)
+{
+  debug("Dump of hooks in routing table <%s>%s\n", tab->name, tab->deleted ? " (deleted)" : "");
+  debug("  nhu_state=%u hcu_scheduled=%u use_count=%d rt_count=%u\n",
+      tab->nhu_state, tab->hcu_scheduled, tab->use_count, tab->rt_count);
+  debug("  last_rt_change=%t gc_time=%t gc_counter=%d prune_state=%u\n",
+      tab->last_rt_change, tab->gc_time, tab->gc_counter, tab->prune_state);
+
+  struct rt_import_hook *ih;
+  WALK_LIST(ih, tab->imports)
+  {
+    ih->req->dump_req(ih->req);
+    debug("  Import hook %p requested by %p: pref=%u"
+       " last_state_change=%t import_state=%u stopped=%p\n",
+       ih, ih->req, ih->stats.pref,
+       ih->last_state_change, ih->import_state, ih->stopped);
+  }
+
+  struct rt_export_hook *eh;
+  WALK_LIST(eh, tab->exports)
+  {
+    eh->req->dump_req(eh->req);
+    debug("  Export hook %p requested by %p:"
+       " refeed_pending=%u last_state_change=%t export_state=%u stopped=%p\n",
+       eh, eh->req, eh->refeed_pending, eh->last_state_change, eh->export_state, eh->stopped);
+  }
+  debug("\n");
+}
+
+void
+rt_dump_hooks_all(void)
+{
+  rtable *t;
+  node *n;
+
+  debug("Dump of all table hooks\n");
+
+  WALK_LIST2(t, n, routing_tables, n)
+    rt_dump_hooks(t);
+
+  WALK_LIST2(t, n, deleted_routing_tables, n)
+    rt_dump_hooks(t);
 }
 
 static inline void
@@ -1963,6 +2077,7 @@ rt_subscribe(rtable *tab, struct rt_subscription *s)
 {
   s->tab = tab;
   rt_lock_table(tab);
+  DBG("rt_subscribe(%s)\n", tab->name);
   add_tail(&tab->subscribers, &s->n);
 }
 
@@ -2108,6 +2223,8 @@ rt_setup(pool *pp, struct rtable_config *cf)
   rtable *t = ralloc(p, &rt_class);
   t->rp = p;
 
+  t->rte_slab = sl_new(p, sizeof(struct rte_storage));
+
   t->name = cf->name;
   t->config = cf;
   t->addr_type = cf->addr_type;
@@ -2122,18 +2239,22 @@ rt_setup(pool *pp, struct rtable_config *cf)
     t->fib.init = net_init_with_trie;
   }
 
-  init_list(&t->channels);
   init_list(&t->flowspec_links);
-  init_list(&t->subscribers);
 
   if (!(t->internal = cf->internal))
   {
+    init_list(&t->imports);
+    init_list(&t->exports);
     hmap_init(&t->id_map, p, 1024);
     hmap_set(&t->id_map, 0);
 
+    init_list(&t->subscribers);
+
     t->rt_event = ev_new_init(p, rt_event, t);
     t->last_rt_change = t->gc_time = current_time();
 
+    t->rl_pipe = (struct tbf) TBF_DEFAULT_LOG_LIMITS;
+
     if (rt_is_flow(t))
     {
       t->flowspec_trie = f_new_trie(lp_new_default(p), 0);
@@ -2156,8 +2277,8 @@ rt_init(void)
   rta_init();
   rt_table_pool = rp_new(&root_pool, "Routing tables");
   rte_update_pool = lp_new_default(rt_table_pool);
-  rte_slab = sl_new(rt_table_pool, sizeof(rte));
   init_list(&routing_tables);
+  init_list(&deleted_routing_tables);
 }
 
 
@@ -2179,9 +2300,9 @@ static void
 rt_prune_table(rtable *tab)
 {
   struct fib_iterator *fit = &tab->prune_fit;
-  int limit = 512;
+  int limit = 2000;
 
-  struct channel *c;
+  struct rt_import_hook *ih;
   node *n, *x;
 
   DBG("Pruning route table %s\n", tab->name);
@@ -2195,9 +2316,9 @@ rt_prune_table(rtable *tab)
   if (tab->prune_state == 1)
   {
     /* Mark channels to flush */
-    WALK_LIST2(c, n, tab->channels, table_node)
-      if (c->channel_state == CS_FLUSHING)
-	c->flush_active = 1;
+    WALK_LIST2(ih, n, tab->imports, n)
+      if (ih->import_state == TIS_STOP)
+	rt_set_import_state(ih, TIS_FLUSHING);
 
     FIB_ITERATE_INIT(fit, &tab->fib);
     tab->prune_state = 2;
@@ -2213,8 +2334,6 @@ rt_prune_table(rtable *tab)
 again:
   FIB_ITERATE_START(&tab->fib, fit, net, n)
     {
-      rte *e;
-
     rescan:
       if (limit <= 0)
       {
@@ -2223,19 +2342,19 @@ again:
 	return;
       }
 
-      for (e=n->routes; e; e=e->next)
+      for (struct rte_storage *e=n->routes; e; e=e->next)
       {
-	if (e->sender->flush_active || (e->flags & REF_DISCARD))
+	if ((e->rte.sender->import_state == TIS_FLUSHING) || (e->rte.flags & REF_DISCARD))
 	  {
-	    rte_discard(e);
+	    rte_discard(n, &e->rte);
 	    limit--;
 
 	    goto rescan;
 	  }
 
-	if (e->flags & REF_MODIFY)
+	if (e->rte.flags & REF_MODIFY)
 	  {
-	    rte_modify(e);
+	    rte_modify(n, &e->rte);
 	    limit--;
 
 	    goto rescan;
@@ -2298,21 +2417,18 @@ again:
     }
   }
 
-  if (tab->prune_state > 0)
-    ev_schedule(tab->rt_event);
-
-  /* FIXME: This should be handled in a better way */
   rt_prune_sources();
 
   /* Close flushed channels */
-  WALK_LIST2_DELSAFE(c, n, x, tab->channels, table_node)
-    if (c->flush_active)
-      {
-	c->flush_active = 0;
-	channel_set_state(c, CS_DOWN);
-      }
-
-  return;
+  WALK_LIST2_DELSAFE(ih, n, x, tab->imports, n)
+    if (ih->import_state == TIS_FLUSHING)
+    {
+      rt_set_import_state(ih, TIS_CLEARED);
+      ih->stopped(ih->req);
+      rem_node(&ih->n);
+      mb_free(ih);
+      rt_unlock_table(tab);
+    }
 }
 
 /**
@@ -2503,8 +2619,8 @@ rta_next_hop_outdated(rta *a)
     (he_nh_ea && a_nh_ea && !adata_same(he_nh_ea->u.ptr, a_nh_ea->u.ptr));
 }
 
-static inline rte *
-rt_next_hop_update_rte(rtable *tab UNUSED, rte *old)
+static inline struct rte_storage *
+rt_next_hop_update_rte(rtable *tab, net *n, rte *old)
 {
   if (!rta_next_hop_outdated(old->attrs))
     return NULL;
@@ -2515,12 +2631,10 @@ rt_next_hop_update_rte(rtable *tab UNUSED, rte *old)
   rta_apply_hostentry(a, old->attrs->hostentry);
   a->cached = 0;
 
-  rte *e = sl_alloc(rte_slab);
-  memcpy(e, old, sizeof(rte));
-  e->attrs = rta_lookup(a);
-  rt_lock_source(e->src);
+  rte e0 = *old;
+  e0.attrs = a;
 
-  return e;
+  return rte_store(&e0, n, tab);
 }
 
 
@@ -2589,7 +2703,7 @@ rt_flowspec_check(rtable *tab_ip, rtable *tab_flow, const net_addr *n, rta *a, i
 
   /* Find best-match BGP unicast route for flowspec dst prefix */
   net *nb = net_route(tab_ip, &dst);
-  rte *rb = nb ? nb->routes : NULL;
+  const rte *rb = nb ? &nb->routes->rte : NULL;
 
   /* Register prefix to trie for tracking further changes */
   int max_pxlen = (n->type == NET_FLOW4) ? IP4_MAX_PREFIX_LENGTH : IP6_MAX_PREFIX_LENGTH;
@@ -2627,7 +2741,7 @@ rt_flowspec_check(rtable *tab_ip, rtable *tab_flow, const net_addr *n, rta *a, i
     if (!nc)
       continue;
 
-    rte *rc = nc->routes;
+    const rte *rc = &nc->routes->rte;
     if (rt_get_source_attr(rc) != RTS_BGP)
       return 0;
 
@@ -2641,8 +2755,8 @@ rt_flowspec_check(rtable *tab_ip, rtable *tab_flow, const net_addr *n, rta *a, i
 
 #endif /* CONFIG_BGP */
 
-static rte *
-rt_flowspec_update_rte(rtable *tab, rte *r)
+static struct rte_storage *
+rt_flowspec_update_rte(rtable *tab, net *n, rte *r)
 {
 #ifdef CONFIG_BGP
   if (rt_get_source_attr(r) != RTS_BGP)
@@ -2652,9 +2766,8 @@ rt_flowspec_update_rte(rtable *tab, rte *r)
   if (!bc->base_table)
     return NULL;
 
-  const net_addr *n = r->net->n.addr;
   struct bgp_proto *p = (void *) r->src->proto;
-  int valid = rt_flowspec_check(bc->base_table, tab, n, r->attrs, p->is_interior);
+  int valid = rt_flowspec_check(bc->base_table, tab, n->n.addr, r->attrs, p->is_interior);
   int dest = valid ? RTD_NONE : RTD_UNREACHABLE;
 
   if (dest == r->attrs->dest)
@@ -2665,11 +2778,11 @@ rt_flowspec_update_rte(rtable *tab, rte *r)
   a->dest = dest;
   a->cached = 0;
 
-  rte *new = sl_alloc(rte_slab);
-  memcpy(new, r, sizeof(rte));
-  new->attrs = rta_lookup(a);
+  rte new;
+  memcpy(&new, r, sizeof(rte));
+  new.attrs = a;
 
-  return new;
+  return rte_store(&new, n, tab);
 #else
   return NULL;
 #endif
@@ -2679,51 +2792,55 @@ rt_flowspec_update_rte(rtable *tab, rte *r)
 static inline int
 rt_next_hop_update_net(rtable *tab, net *n)
 {
-  rte **k, *e, *new, *old_best, **new_best;
+  struct rte_storage *new;
   int count = 0;
-  int free_old_best = 0;
+  int is_flow = net_is_flow(n->n.addr);
 
-  old_best = n->routes;
+  struct rte_storage *old_best = n->routes;
   if (!old_best)
     return 0;
 
-  for (k = &n->routes; e = *k; k = &e->next)
-  {
-    if (!net_is_flow(n->n.addr))
-      new = rt_next_hop_update_rte(tab, e);
-    else
-      new = rt_flowspec_update_rte(tab, e);
+  for (struct rte_storage *e, **k = &n->routes; e = *k; k = &e->next)
+    if (is_flow || rta_next_hop_outdated(e->rte.attrs))
+      count++;
 
-    if (new)
-      {
-	*k = new;
+  if (!count)
+    return 0;
 
-	rte_trace_in(D_ROUTES, new->sender, new, "updated");
-	rte_announce_i(tab, RA_ANY, n, new, e, NULL, NULL);
+  struct rte_multiupdate {
+    struct rte_storage *old, *new;
+  } *updates = alloca(sizeof(struct rte_multiupdate) * count);
+
+  int pos = 0;
+  for (struct rte_storage *e, **k = &n->routes; e = *k; k = &e->next)
+    if (is_flow || rta_next_hop_outdated(e->rte.attrs))
+      {
+	struct rte_storage *new = is_flow
+	  ? rt_flowspec_update_rte(tab, n, &e->rte)
+	  : rt_next_hop_update_rte(tab, n, &e->rte);
 
 	/* Call a pre-comparison hook */
 	/* Not really an efficient way to compute this */
-	if (e->src->proto->rte_recalculate)
-	  e->src->proto->rte_recalculate(tab, n, new, e, NULL);
+	if (e->rte.src->proto->rte_recalculate)
+	  e->rte.src->proto->rte_recalculate(tab, n, &new->rte, &e->rte, &old_best->rte);
 
-	if (e != old_best)
-	  rte_free_quick(e);
-	else /* Freeing of the old best rte is postponed */
-	  free_old_best = 1;
+	updates[pos++] = (struct rte_multiupdate) {
+	  .old = e,
+	  .new = new,
+	};
 
-	e = new;
-	count++;
+	/* Replace the route in the list */
+	new->next = e->next;
+	*k = e = new;
       }
-  }
 
-  if (!count)
-    return 0;
+  ASSERT_DIE(pos == count);
 
   /* Find the new best route */
-  new_best = NULL;
-  for (k = &n->routes; e = *k; k = &e->next)
+  struct rte_storage **new_best = NULL;
+  for (struct rte_storage *e, **k = &n->routes; e = *k; k = &e->next)
     {
-      if (!new_best || rte_better(e, *new_best))
+      if (!new_best || rte_better(&e->rte, &(*new_best)->rte))
 	new_best = k;
     }
 
@@ -2736,15 +2853,17 @@ rt_next_hop_update_net(rtable *tab, net *n)
       n->routes = new;
     }
 
-  /* Announce the new best route */
-  if (new != old_best)
-    rte_trace_in(D_ROUTES, new->sender, new, "updated [best]");
-
-  /* Propagate changes */
-  rte_announce_i(tab, RA_UNDEF, n, NULL, NULL, n->routes, old_best);
+  /* Announce the changes */
+  for (int i=0; i<count; i++)
+  {
+    _Bool nb = (new == updates[i].new), ob = (old_best == updates[i].old);
+    const char *best_indicator[2][2] = { { "updated", "updated [-best]" }, { "updated [+best]", "updated [best]" } };
+    rt_rte_trace_in(D_ROUTES, updates[i].new->rte.sender->req, &updates[i].new->rte, best_indicator[nb][ob]);
+    rte_announce_i(tab, n, updates[i].new, updates[i].old, new, old_best);
+  }
 
-  if (free_old_best)
-    rte_free_quick(old_best);
+  for (int i=0; i<count; i++)
+    rte_free(updates[i].old);
 
   return count;
 }
@@ -2924,19 +3043,6 @@ rt_commit(struct config *new, struct config *old)
   DBG("\tdone\n");
 }
 
-static inline void
-do_feed_channel(struct channel *c, net *n, rte *e)
-{
-  rte_update_lock();
-  if (c->ra_mode == RA_ACCEPTED)
-    rt_notify_accepted(c, n, NULL, NULL, c->refeeding);
-  else if (c->ra_mode == RA_MERGED)
-    rt_notify_merged(c, n, NULL, NULL, e, e, c->refeeding);
-  else /* RA_BASIC */
-    rt_notify_basic(c, n, e, e, c->refeeding);
-  rte_update_unlock();
-}
-
 /**
  * rt_feed_channel - advertise all routes to a channel
  * @c: channel to be fed
@@ -2946,79 +3052,55 @@ do_feed_channel(struct channel *c, net *n, rte *e)
  * has something to do. (We avoid transferring all the routes in single pass in
  * order not to monopolize CPU time.)
  */
-int
-rt_feed_channel(struct channel *c)
+static void
+rt_feed_channel(void *data)
 {
+  struct rt_export_hook *c = data;
+
   struct fib_iterator *fit = &c->feed_fit;
   int max_feed = 256;
 
-  ASSERT(c->export_state == ES_FEEDING);
-
-  if (!c->feed_active)
-    {
-      FIB_ITERATE_INIT(fit, &c->table->fib);
-      c->feed_active = 1;
-    }
+  ASSERT(c->export_state == TES_FEEDING);
 
   FIB_ITERATE_START(&c->table->fib, fit, net, n)
     {
-      rte *e = n->routes;
       if (max_feed <= 0)
 	{
 	  FIB_ITERATE_PUT(fit);
-	  return 0;
+	  ev_schedule_work(c->event);
+	  return;
 	}
 
-      if ((c->ra_mode == RA_OPTIMAL) ||
-	  (c->ra_mode == RA_ACCEPTED) ||
-	  (c->ra_mode == RA_MERGED))
-	if (rte_is_valid(e))
-	  {
-	    /* In the meantime, the protocol may fell down */
-	    if (c->export_state != ES_FEEDING)
-	      goto done;
-
-	    do_feed_channel(c, n, e);
-	    max_feed--;
-	  }
+      if (c->export_state != TES_FEEDING)
+	goto done;
 
-      if (c->ra_mode == RA_ANY)
-	for(e = n->routes; e; e = e->next)
-	  {
-	    /* In the meantime, the protocol may fell down */
-	    if (c->export_state != ES_FEEDING)
-	      goto done;
-
-	    if (!rte_is_valid(e))
-	      continue;
-
-	    do_feed_channel(c, n, e);
-	    max_feed--;
-	  }
+      if (c->req->export_bulk)
+      {
+	uint count = rte_feed_count(n);
+	if (count)
+	{
+	  rte_update_lock();
+	  rte **feed = alloca(count * sizeof(rte *));
+	  rte_feed_obtain(n, feed, count);
+	  struct rt_pending_export rpe = { .new_best = n->routes };
+	  c->req->export_bulk(c->req, n->n.addr, &rpe, feed, count);
+	  max_feed -= count;
+	  rte_update_unlock();
+	}
+      }
+      else if (n->routes && rte_is_valid(&n->routes->rte))
+      {
+	rte_update_lock();
+	struct rt_pending_export rpe = { .new = n->routes, .new_best = n->routes };
+	c->req->export_one(c->req, n->n.addr, &rpe);
+	max_feed--;
+	rte_update_unlock();
+      }
     }
   FIB_ITERATE_END;
 
 done:
-  c->feed_active = 0;
-  return 1;
-}
-
-/**
- * rt_feed_baby_abort - abort protocol feeding
- * @c: channel
- *
- * This function is called by the protocol code when the protocol stops or
- * ceases to exist during the feeding.
- */
-void
-rt_feed_channel_abort(struct channel *c)
-{
-  if (c->feed_active)
-    {
-      /* Unlink the iterator */
-      fit_get(&c->table->fib, &c->feed_fit);
-      c->feed_active = 0;
-    }
+  rt_set_export_state(c, TES_READY);
 }
 
 
@@ -3030,16 +3112,10 @@ int
 rte_update_in(struct channel *c, const net_addr *n, rte *new, struct rte_src *src)
 {
   struct rtable *tab = c->in_table;
-  rte *old, **pos;
   net *net;
 
   if (new)
-  {
     net = net_get(tab, n);
-
-    if (!rta_is_cached(new->attrs))
-      new->attrs = rta_lookup(new->attrs);
-  }
   else
   {
     net = net_find(tab, n);
@@ -3049,9 +3125,10 @@ rte_update_in(struct channel *c, const net_addr *n, rte *new, struct rte_src *sr
   }
 
   /* Find the old rte */
-  for (pos = &net->routes; old = *pos; pos = &old->next)
-    if (old->src == src)
+  struct rte_storage **pos = rte_find(net, src);
+  if (*pos)
     {
+      rte *old = &(*pos)->rte;
       if (new && rte_same(old, new))
       {
 	/* Refresh the old rte, continue with update to main rtable */
@@ -3064,60 +3141,52 @@ rte_update_in(struct channel *c, const net_addr *n, rte *new, struct rte_src *sr
 	goto drop_update;
       }
 
+      if (!new)
+	CHANNEL_LIMIT_POP(c, RX);
+
       /* Move iterator if needed */
-      if (old == c->reload_next_rte)
-	c->reload_next_rte = old->next;
+      if (*pos == c->reload_next_rte)
+	c->reload_next_rte = (*pos)->next;
 
       /* Remove the old rte */
-      *pos = old->next;
-      rte_free_quick(old);
+      struct rte_storage *del = *pos;
+      *pos = (*pos)->next;
+      rte_free(del);
       tab->rt_count--;
+    }
+  else if (new)
+    {
+      if (CHANNEL_LIMIT_PUSH(c, RX))
+      {
+	/* Required by rte_trace_in() */
+	new->net = n;
 
-      break;
+	channel_rte_trace_in(D_FILTERS, c, new, "ignored [limit]");
+	goto drop_update;
+      }
     }
+  else
+    goto drop_withdraw;
 
   if (!new)
   {
-    if (!old)
-      goto drop_withdraw;
-
     if (!net->routes)
       fib_delete(&tab->fib, net);
 
     return 1;
   }
 
-  struct channel_limit *l = &c->rx_limit;
-  if (l->action && !old)
-  {
-    if (tab->rt_count >= l->limit)
-      channel_notify_limit(c, l, PLD_RX, tab->rt_count);
-
-    if (l->state == PLS_BLOCKED)
-    {
-      /* Required by rte_trace_in() */
-      new->net = net;
-
-      rte_trace_in(D_FILTERS, c, new, "ignored [limit]");
-      goto drop_update;
-    }
-  }
-
   /* Insert the new rte */
-  rte *e = rte_do_cow(new);
-  e->flags |= REF_COW;
-  e->net = net;
-  e->sender = c;
-  e->lastmod = current_time();
+  struct rte_storage *e = rte_store(new, net, tab);
+  e->rte.lastmod = current_time();
   e->next = *pos;
   *pos = e;
   tab->rt_count++;
   return 1;
 
 drop_update:
-  c->stats.imp_updates_received++;
-  c->stats.imp_updates_ignored++;
-  rte_free(new);
+  c->import_stats.updates_received++;
+  c->in_req.hook->stats.updates_ignored++;
 
   if (!net->routes)
     fib_delete(&tab->fib, net);
@@ -3125,8 +3194,8 @@ drop_update:
   return 0;
 
 drop_withdraw:
-  c->stats.imp_withdraws_received++;
-  c->stats.imp_withdraws_ignored++;
+  c->import_stats.withdraws_received++;
+  c->in_req.hook->stats.withdraws_ignored++;
   return 0;
 }
 
@@ -3146,7 +3215,7 @@ rt_reload_channel(struct channel *c)
   }
 
   do {
-    for (rte *e = c->reload_next_rte; e; e = e->next)
+    for (struct rte_storage *e = c->reload_next_rte; e; e = e->next)
     {
       if (max_feed-- <= 0)
       {
@@ -3155,7 +3224,8 @@ rt_reload_channel(struct channel *c)
 	return 0;
       }
 
-      rte_update2(c, e->net->n.addr, rte_do_cow(e), e->src);
+      rte r = e->rte;
+      rte_update_direct(c, r.net, &r, r.src);
     }
 
     c->reload_next_rte = NULL;
@@ -3198,14 +3268,14 @@ rt_prune_sync(rtable *t, int all)
 again:
   FIB_ITERATE_START(&t->fib, &fit, net, n)
   {
-    rte *e, **ee = &n->routes;
+    struct rte_storage *e, **ee = &n->routes;
 
     while (e = *ee)
     {
-      if (all || (e->flags & (REF_STALE | REF_DISCARD)))
+      if (all || (e->rte.flags & (REF_STALE | REF_DISCARD)))
       {
 	*ee = e->next;
-	rte_free_quick(e);
+	rte_free(e);
 	t->rt_count--;
       }
       else
@@ -3228,20 +3298,16 @@ again:
  */
 
 int
-rte_update_out(struct channel *c, const net_addr *n, rte *new, rte *old0, rte **old_exported, int refeed)
+rte_update_out(struct channel *c, const net_addr *n, rte *new, const rte *old0, struct rte_storage **old_exported)
 {
   struct rtable *tab = c->out_table;
   struct rte_src *src;
-  rte *old, **pos;
   net *net;
 
   if (new)
   {
     net = net_get(tab, n);
     src = new->src;
-
-    if (!rta_is_cached(new->attrs))
-      new->attrs = rta_lookup(new->attrs);
   }
   else
   {
@@ -3249,39 +3315,28 @@ rte_update_out(struct channel *c, const net_addr *n, rte *new, rte *old0, rte **
     src = old0->src;
 
     if (!net)
-      goto drop_withdraw;
+      goto drop;
   }
 
   /* Find the old rte */
-  for (pos = &net->routes; old = *pos; pos = &old->next)
-    if ((c->ra_mode != RA_ANY) || (old->src == src))
-    {
-      if (new && rte_same(old, new))
-      {
-	/* REF_STALE / REF_DISCARD not used in export table */
-	/*
-	if (old->flags & (REF_STALE | REF_DISCARD | REF_MODIFY))
-	{
-	  old->flags &= ~(REF_STALE | REF_DISCARD | REF_MODIFY);
-	  return 1;
-	}
-	*/
-
-	goto drop_update;
-      }
+  struct rte_storage **pos = (c->ra_mode == RA_ANY) ? rte_find(net, src) : &net->routes;
+  struct rte_storage *old = NULL;
 
-      /* Remove the old rte */
-      *pos = old->next;
-      *old_exported = old;
-      tab->rt_count--;
+  if (old = *pos)
+  {
+    if (new && rte_same(&(*pos)->rte, new))
+      goto drop;
 
-      break;
-    }
+    /* Remove the old rte */
+    *pos = old->next;
+    *old_exported = old;
+    tab->rt_count--;
+  }
 
   if (!new)
   {
     if (!old)
-      goto drop_withdraw;
+      goto drop;
 
     if (!net->routes)
       fib_delete(&tab->fib, net);
@@ -3290,23 +3345,43 @@ rte_update_out(struct channel *c, const net_addr *n, rte *new, rte *old0, rte **
   }
 
   /* Insert the new rte */
-  rte *e = rte_do_cow(new);
-  e->flags |= REF_COW;
-  e->net = net;
-  e->sender = c;
-  e->lastmod = current_time();
+  struct rte_storage *e = rte_store(new, net, tab);
+  e->rte.lastmod = current_time();
   e->next = *pos;
   *pos = e;
   tab->rt_count++;
   return 1;
 
-drop_update:
-  return refeed;
-
-drop_withdraw:
+drop:
   return 0;
 }
 
+void
+rt_refeed_channel(struct channel *c)
+{
+  if (!c->out_table)
+  {
+    channel_request_feeding(c);
+    return;
+  }
+
+  ASSERT_DIE(c->ra_mode != RA_ANY);
+
+  c->proto->feed_begin(c, 0);
+
+  FIB_WALK(&c->out_table->fib, net, n)
+  {
+    if (!n->routes)
+      continue;
+
+    rte e = n->routes->rte;
+    c->proto->rt_notify(c->proto, c, n->n.addr, &e, NULL);
+  }
+  FIB_WALK_END;
+
+  c->proto->feed_end(c);
+}
+
 
 /*
  *	Hostcache
@@ -3472,7 +3547,7 @@ if_local_addr(ip_addr a, struct iface *i)
 }
 
 u32
-rt_get_igp_metric(rte *rt)
+rt_get_igp_metric(const rte *rt)
 {
   eattr *ea = ea_find(rt->attrs->eattrs, "igp_metric");
 
@@ -3506,8 +3581,8 @@ rt_update_hostentry(rtable *tab, struct hostentry *he)
   net *n = net_route(tab, &he_addr);
   if (n)
     {
-      rte *e = n->routes;
-      rta *a = e->attrs;
+      struct rte_storage *e = n->routes;
+      rta *a = e->rte.attrs;
       pxlen = n->n.addr->pxlen;
 
       if (a->hostentry)
@@ -3545,7 +3620,7 @@ rt_update_hostentry(rtable *tab, struct hostentry *he)
       he->src = rta_clone(a);
       he->dest = a->dest;
       he->nexthop_linkable = !direct;
-      he->igp_metric = rt_get_igp_metric(e);
+      he->igp_metric = rt_get_igp_metric(&e->rte);
     }
 
 done: