Channels - explicit links between protocols and tables

The patch adds support for channels, structures connecting protocols and
tables and handling most interactions between them. The documentation is
missing yet.

10 files changed, 1631 insertions, 1403 deletions

diff --git a/nest/config.Y b/nest/config.Y
index 769822f3..6bb686c3 100644
--- a/nest/config.Y
+++ b/nest/config.Y
@@ -17,6 +17,7 @@ CF_HDR
 CF_DEFINES
 
 static struct proto_config *this_proto;
+static struct channel_config *this_channel;
 static struct iface_patt *this_ipatt;
 static struct iface_patt_node *this_ipn;
 /* static struct roa_table_config *this_roa_table; */
@@ -49,6 +50,15 @@ get_passwords(void)
   return rv;
 }
 
+static void
+proto_postconfig(void)
+{
+  CALL(this_proto->protocol->postconfig, this_proto);
+  this_channel = NULL;
+  this_proto = NULL;
+}
+
+
 #define DIRECT_CFG ((struct rt_dev_config *) this_proto)
 
 CF_DECLS
@@ -76,9 +86,10 @@ CF_ENUM(T_ENUM_ROA, ROA_, UNKNOWN, VALID, INVALID)
 %type <s> optsym
 %type <ra> r_args
 %type <sd> sym_args
-%type <i> proto_start echo_mask echo_size debug_mask debug_list debug_flag mrtdump_mask mrtdump_list mrtdump_flag export_mode limit_action table_type table_sorted tos
+%type <i> proto_start echo_mask echo_size debug_mask debug_list debug_flag mrtdump_mask mrtdump_list mrtdump_flag export_mode limit_action net_type table_sorted tos
 %type <ps> proto_patt proto_patt2
-%type <g> limit_spec
+%type <cc> channel_start proto_channel
+%type <cl> limit_spec
 
 CF_GRAMMAR
 
@@ -115,7 +126,7 @@ listen_opts:
  | listen_opts listen_opt
  ;
 
-listen_opt: 
+listen_opt:
    ADDRESS ipa { new_config->listen_bgp_addr = $2; }
  | PORT expr { new_config->listen_bgp_port = $2; }
  | V6ONLY { new_config->listen_bgp_flags = 0; }
@@ -128,13 +139,10 @@ CF_ADDTO(conf, gr_opts)
 gr_opts: GRACEFUL RESTART WAIT expr ';' { new_config->gr_wait = $4; } ;
 
 
-/* Creation of routing tables */
+/* Network types (for tables, channels) */
 
-CF_ADDTO(conf, table)
-
-table_type:
-   /* empty */ { $$ = NET_IP4; }
- | IPV4 { $$ = NET_IP4; }
+net_type:
+   IPV4 { $$ = NET_IP4; }
  | IPV6 { $$ = NET_IP6; }
  | VPN4 { $$ = NET_VPN4; }
  | VPN6 { $$ = NET_VPN6; }
@@ -142,21 +150,27 @@ table_type:
  | ROA6 { $$ = NET_ROA6; }
  ;
 
+
+/* Creation of routing tables */
+
+CF_ADDTO(conf, table)
+
 table_sorted:
           { $$ = 0; }
  | SORTED { $$ = 1; }
  ;
 
-table: table_type TABLE SYM table_sorted {
+table: net_type TABLE SYM table_sorted {
    struct rtable_config *cf;
    cf = rt_new_table($3, $1);
    cf->sorted = $4;
    }
  ;
 
+
 /* Definition of protocols */
 
-CF_ADDTO(conf, proto)
+CF_ADDTO(conf, proto { proto_postconfig(); })
 
 proto_start:
    PROTOCOL { $$ = SYM_PROTO; }
@@ -194,24 +208,62 @@ proto_name:
 
 proto_item:
    /* EMPTY */
- | PREFERENCE expr {
-     if ($2 < 0 || $2 > 0xFFFF) cf_error("Invalid preference");
-     this_proto->preference = $2;
-   }
  | DISABLED bool { this_proto->disabled = $2; }
  | DEBUG debug_mask { this_proto->debug = $2; }
  | MRTDUMP mrtdump_mask { this_proto->mrtdump = $2; }
- | IMPORT imexport { this_proto->in_filter = $2; }
- | EXPORT imexport { this_proto->out_filter = $2; }
- | RECEIVE LIMIT limit_spec { this_proto->rx_limit = $3; }
- | IMPORT LIMIT limit_spec { this_proto->in_limit = $3; }
- | EXPORT LIMIT limit_spec { this_proto->out_limit = $3; }
- | IMPORT KEEP FILTERED bool { this_proto->in_keep_filtered = $4; }
- | TABLE rtable { this_proto->table = $2; }
  | ROUTER ID idval { this_proto->router_id = $3; }
  | DESCRIPTION text { this_proto->dsc = $2; }
  ;
 
+
+channel_start: net_type
+{
+  $$ = this_channel = channel_config_new(NULL, $1, this_proto);
+};
+
+channel_item:
+   TABLE rtable {
+     if (this_channel->net_type && ($2->addr_type != this_channel->net_type))
+       cf_error("Incompatible table type");
+     this_channel->table = $2;
+   }
+ | IMPORT imexport { this_channel->in_filter = $2; }
+ | EXPORT imexport { this_channel->out_filter = $2; }
+ | RECEIVE LIMIT limit_spec { this_channel->rx_limit = $3; }
+ | IMPORT LIMIT limit_spec { this_channel->in_limit = $3; }
+ | EXPORT LIMIT limit_spec { this_channel->out_limit = $3; }
+ | PREFERENCE expr { this_channel->preference = $2; check_u16($2); }
+ | IMPORT KEEP FILTERED bool { this_channel->in_keep_filtered = $4; }
+ ;
+
+channel_opts:
+   /* empty */
+ | channel_opts channel_item ';'
+ ;
+
+channel_opt_list:
+   /* empty */
+ | '{' channel_opts '}'
+ ;
+
+channel_end:
+{
+  if (!this_channel->table)
+    cf_error("Routing table not specified");
+
+  this_channel = NULL;
+};
+
+proto_channel: channel_start channel_opt_list channel_end;
+
+
+rtable:
+   SYM {
+     if ($1->class != SYM_TABLE) cf_error("Table expected");
+     $$ = $1->def;
+   }
+ ;
+
 imexport:
    FILTER filter { $$ = $2; }
  | where_filter
@@ -228,20 +280,8 @@ limit_action:
  ;
 
 limit_spec:
-   expr limit_action {
-     struct proto_limit *l = cfg_allocz(sizeof(struct proto_limit));
-     l->limit = $1;
-     l->action = $2;
-     $$ = l;
-   }
- | OFF { $$ = NULL; }
- ;
-
-rtable:
-   SYM {
-     if ($1->class != SYM_TABLE) cf_error("Table name expected");
-     $$ = $1->def;
-   }
+   expr limit_action { $$ = (struct channel_limit){ .limit = $1, $$.action = $2 }; }
+ | OFF { $$ = (struct channel_limit){}; }
  ;
 
 CF_ADDTO(conf, debug_default)
@@ -315,6 +355,7 @@ dev_proto_start: proto_start DIRECT {
 dev_proto:
    dev_proto_start proto_name '{'
  | dev_proto proto_item ';'
+ | dev_proto proto_channel ';'
  | dev_proto dev_iface_patt ';'
  ;
 
diff --git a/nest/iface.c b/nest/iface.c
index e9f55f0a..00af5052 100644
--- a/nest/iface.c
+++ b/nest/iface.c
@@ -138,7 +138,7 @@ if_copy(struct iface *to, struct iface *from)
 static inline void
 ifa_send_notify(struct proto *p, unsigned c, struct ifa *a)
 {
-  if (p->ifa_notify)
+  if (p->ifa_notify && (p->proto_state != PS_DOWN))
     {
       if (p->debug & D_IFACES)
 	log(L_TRACE "%s < %s address %N on interface %s %s",
@@ -155,7 +155,7 @@ ifa_notify_change_(unsigned c, struct ifa *a)
 
   DBG("IFA change notification (%x) for %s:%I\n", c, a->iface->name, a->ip);
 
-  WALK_LIST(p, active_proto_list)
+  WALK_LIST(p, proto_list)
     ifa_send_notify(p, c, a);
 }
 
@@ -174,7 +174,7 @@ ifa_notify_change(unsigned c, struct ifa *a)
 static inline void
 if_send_notify(struct proto *p, unsigned c, struct iface *i)
 {
-  if (p->if_notify)
+  if (p->if_notify && (p->proto_state != PS_DOWN))
     {
       if (p->debug & D_IFACES)
 	log(L_TRACE "%s < interface %s %s", p->name, i->name,
@@ -215,7 +215,7 @@ if_notify_change(unsigned c, struct iface *i)
 	ifa_notify_change_(IF_CHANGE_DOWN, a);
       }
 
-  WALK_LIST(p, active_proto_list)
+  WALK_LIST(p, proto_list)
     if_send_notify(p, c, i);
 
   if (c & IF_CHANGE_UP)
diff --git a/nest/neighbor.c b/nest/neighbor.c
index 74c3c664..69f09423 100644
--- a/nest/neighbor.c
+++ b/nest/neighbor.c
@@ -239,7 +239,7 @@ neigh_up(neighbor *n, struct iface *i, int scope, struct ifa *a)
   rem_node(&n->n);
   add_tail(&neigh_hash_table[neigh_hash(n->proto, &n->addr)], &n->n);
   DBG("Waking up sticky neighbor %I\n", n->addr);
-  if (n->proto->neigh_notify && n->proto->core_state != FS_FLUSHING)
+  if (n->proto->neigh_notify && (n->proto->proto_state != PS_STOP))
     n->proto->neigh_notify(n);
 }
 
@@ -252,7 +252,7 @@ neigh_down(neighbor *n)
     n->iface = NULL;
   n->ifa = NULL;
   n->scope = -1;
-  if (n->proto->neigh_notify && n->proto->core_state != FS_FLUSHING)
+  if (n->proto->neigh_notify && (n->proto->proto_state != PS_STOP))
     n->proto->neigh_notify(n);
   rem_node(&n->n);
   if (n->flags & NEF_STICKY)
@@ -333,7 +333,7 @@ neigh_if_link(struct iface *i)
   WALK_LIST_DELSAFE(x, y, i->neighbors)
     {
       neighbor *n = SKIP_BACK(neighbor, if_n, x);
-      if (n->proto->neigh_notify && n->proto->core_state != FS_FLUSHING)
+      if (n->proto->neigh_notify && (n->proto->proto_state != PS_STOP))
 	n->proto->neigh_notify(n);
     }
 }
diff --git a/nest/proto.c b/nest/proto.c
index d04da333..08786e56 100644
--- a/nest/proto.c
+++ b/nest/proto.c
@@ -21,19 +21,12 @@
 #include "filter/filter.h"
 
 pool *proto_pool;
+list  proto_list;
 
 static list protocol_list;
-static list proto_list;
 
 #define PD(pr, msg, args...) do { if (pr->debug & D_STATES) { log(L_TRACE "%s: " msg, pr->name , ## args); } } while(0)
 
-list active_proto_list;
-static list inactive_proto_list;
-static list initial_proto_list;
-static list flush_proto_list;
-static struct proto *initial_device_proto;
-
-static event *proto_flush_event;
 static timer *proto_shutdown_timer;
 static timer *gr_wait_timer;
 
@@ -46,199 +39,634 @@ static int graceful_restart_state;
 static u32 graceful_restart_locks;
 
 static char *p_states[] = { "DOWN", "START", "UP", "STOP" };
-static char *c_states[] = { "HUNGRY", "???", "HAPPY", "FLUSHING" };
 
-static void proto_flush_loop(void *);
+extern struct protocol proto_unix_iface;
+
 static void proto_shutdown_loop(struct timer *);
 static void proto_rethink_goal(struct proto *p);
-static void proto_want_export_up(struct proto *p);
-static void proto_fell_down(struct proto *p);
 static char *proto_state_name(struct proto *p);
+static void channel_verify_limits(struct channel *c);
+static void channel_reset_limit(struct channel_limit *l);
 
-static void
-proto_relink(struct proto *p)
-{
-  list *l = NULL;
 
-  switch (p->core_state)
-    {
-    case FS_HUNGRY:
-      l = &inactive_proto_list;
-      break;
-    case FS_HAPPY:
-      l = &active_proto_list;
-      break;
-    case FS_FLUSHING:
-      l = &flush_proto_list;
-      break;
-    default:
-      ASSERT(0);
-    }
+static inline int proto_is_done(struct proto *p)
+{ return (p->proto_state == PS_DOWN) && (p->active_channels == 0); }
 
-  rem_node(&p->n);
-  add_tail(l, &p->n);
-}
+static inline int channel_is_active(struct channel *c)
+{ return (c->channel_state == CS_START) || (c->channel_state == CS_UP); }
 
 static void
 proto_log_state_change(struct proto *p)
 {
   if (p->debug & D_STATES)
+  {
+    char *name = proto_state_name(p);
+    if (name != p->last_state_name_announced)
     {
-      char *name = proto_state_name(p);
-      if (name != p->last_state_name_announced)
-	{
-	  p->last_state_name_announced = name;
-	  PD(p, "State changed to %s", proto_state_name(p));
-	}
+      p->last_state_name_announced = name;
+      PD(p, "State changed to %s", proto_state_name(p));
     }
+  }
   else
     p->last_state_name_announced = NULL;
 }
 
 
-/**
- * proto_new - create a new protocol instance
- * @c: protocol configuration
- * @size: size of protocol data structure (each protocol instance is represented by
- * a structure starting with generic part [struct &proto] and continued
- * with data specific to the protocol)
- *
- * When a new configuration has been read in, the core code starts
- * initializing all the protocol instances configured by calling their
- * init() hooks with the corresponding instance configuration. The initialization
- * code of the protocol is expected to create a new instance according to the
- * configuration by calling this function and then modifying the default settings
- * to values wanted by the protocol.
- */
-void *
-proto_new(struct proto_config *c, unsigned size)
+struct channel_config *
+proto_cf_find_channel(struct proto_config *pc, uint net_type)
 {
-  struct protocol *pr = c->protocol;
-  struct proto *p = mb_allocz(proto_pool, size);
-
-  p->cf = c;
-  p->debug = c->debug;
-  p->mrtdump = c->mrtdump;
-  p->name = c->name;
-  p->preference = c->preference;
-  p->disabled = c->disabled;
-  p->proto = pr;
-  p->table = c->table->table;
-  p->hash_key = random_u32();
-  c->proto = p;
-  return p;
+  struct channel_config *cc;
+
+  WALK_LIST(cc, pc->channels)
+    if (cc->net_type == net_type)
+      return cc;
+
+  return NULL;
 }
 
-static void
-proto_init_instance(struct proto *p)
+/**
+ * proto_find_channel_by_table - find channel connected to a routing table
+ * @p: protocol instance
+ * @t: routing table
+ *
+ * Returns pointer to channel or NULL
+ */
+struct channel *
+proto_find_channel_by_table(struct proto *p, struct rtable *t)
 {
-  /* Here we cannot use p->cf->name since it won't survive reconfiguration */
-  p->pool = rp_new(proto_pool, p->proto->name);
-  p->attn = ev_new(p->pool);
-  p->attn->data = p;
+  struct channel *c;
 
-  if (graceful_restart_state == GRS_INIT)
-    p->gr_recovery = 1;
+  WALK_LIST(c, p->channels)
+    if (c->table == t)
+      return c;
 
-  if (! p->proto->multitable)
-    rt_lock_table(p->table);
+  return NULL;
 }
 
-extern pool *rt_table_pool;
 /**
- * proto_add_announce_hook - connect protocol to a routing table
+ * proto_add_channel - connect protocol to a routing table
  * @p: protocol instance
- * @t: routing table to connect to
- * @stats: per-table protocol statistics
- *
- * This function creates a connection between the protocol instance @p and the
- * routing table @t, making the protocol hear all changes in the table.
+ * @cf: channel configuration
  *
- * The announce hook is linked in the protocol ahook list. Announce hooks are
- * allocated from the routing table resource pool and when protocol accepts
- * routes also in the table ahook list. The are linked to the table ahook list
- * and unlinked from it depending on export_state (in proto_want_export_up() and
- * proto_want_export_down()) and they are automatically freed after the protocol
- * is flushed (in proto_fell_down()).
+ * This function creates a channel between the protocol instance @p and the
+ * routing table specified in the configuration @cf, making the protocol hear
+ * all changes in the table and allowing the protocol to update routes in the
+ * table.
  *
- * Unless you want to listen to multiple routing tables (as the Pipe protocol
- * does), you needn't to worry about this function since the connection to the
- * protocol's primary routing table is initialized automatically by the core
- * code.
+ * The channel is linked in the protocol channel list and when active also in
+ * the table channel list. Channels are allocated from the global resource pool
+ * (@proto_pool) and they are automatically freed when the protocol is removed.
  */
-struct announce_hook *
-proto_add_announce_hook(struct proto *p, struct rtable *t, struct proto_stats *stats)
+
+struct channel *
+proto_add_channel(struct proto *p, struct channel_config *cf)
+{
+  struct channel *c = mb_allocz(proto_pool, cf->channel->channel_size);
+
+  c->name = cf->name;
+  c->channel = cf->channel;
+  c->proto = p;
+  c->table = cf->table->table;
+
+  c->in_filter = cf->in_filter;
+  c->out_filter = cf->out_filter;
+  c->rx_limit = cf->rx_limit;
+  c->in_limit = cf->in_limit;
+  c->out_limit = cf->out_limit;
+
+  c->net_type = cf->net_type;
+  c->ra_mode = cf->ra_mode;
+  c->preference = cf->preference;
+  c->merge_limit = cf->merge_limit;
+  c->in_keep_filtered = cf->in_keep_filtered;
+
+  c->channel_state = CS_DOWN;
+  c->export_state = ES_DOWN;
+  c->last_state_change = now;
+  c->reloadable = 1;
+
+  CALL(c->channel->init, c, cf);
+
+  add_tail(&p->channels, &c->n);
+
+  PD(p, "Channel %s connected to table %s", c->name, c->table->name);
+
+  return c;
+}
+
+void
+proto_remove_channel(struct proto *p, struct channel *c)
+{
+  ASSERT(c->channel_state == CS_DOWN);
+
+  PD(p, "Channel %s removed", c->name);
+
+  rem_node(&c->n);
+  mb_free(c);
+}
+
+
+static void
+proto_start_channels(struct proto *p)
+{
+  struct channel *c;
+  WALK_LIST(c, p->channels)
+    if (!c->disabled)
+      channel_set_state(c, CS_UP);
+}
+
+static void
+proto_pause_channels(struct proto *p)
+{
+  struct channel *c;
+  WALK_LIST(c, p->channels)
+    if (!c->disabled && channel_is_active(c))
+      channel_set_state(c, CS_START);
+}
+
+static void
+proto_stop_channels(struct proto *p)
+{
+  struct channel *c;
+  WALK_LIST(c, p->channels)
+    if (!c->disabled && channel_is_active(c))
+      channel_set_state(c, CS_FLUSHING);
+}
+
+static void
+proto_remove_channels(struct proto *p)
+{
+  struct channel *c;
+  WALK_LIST_FIRST(c, p->channels)
+    proto_remove_channel(p, c);
+}
+
+static void
+channel_schedule_feed(struct channel *c, int initial)
+{
+  // DBG("%s: Scheduling meal\n", p->name);
+  ASSERT(c->channel_state == CS_UP);
+
+  c->export_state = ES_FEEDING;
+  c->refeeding = !initial;
+
+  ev_schedule(c->feed_event);
+}
+
+static void
+channel_feed_loop(void *ptr)
+{
+  struct channel *c = ptr;
+
+  if (c->export_state != ES_FEEDING)
+    return;
+
+  if (!c->feed_active)
+    if (c->proto->feed_begin)
+      c->proto->feed_begin(c, !c->refeeding);
+
+  // DBG("Feeding protocol %s continued\n", p->name);
+  if (!rt_feed_channel(c))
+  {
+    ev_schedule(c->feed_event);
+    return;
+  }
+
+  // DBG("Feeding protocol %s finished\n", p->name);
+  c->export_state = ES_READY;
+  // proto_log_state_change(p);
+
+  if (c->proto->feed_end)
+    c->proto->feed_end(c);
+}
+
+
+static void
+channel_start_export(struct channel *c)
+{
+  ASSERT(c->channel_state == CS_UP);
+  ASSERT(c->export_state == ES_DOWN);
+
+  channel_schedule_feed(c, 1);	/* Sets ES_FEEDING */
+}
+
+static void
+channel_stop_export(struct channel *c)
+{
+  /* Need to abort feeding */
+  if (c->export_state == ES_FEEDING)
+    rt_feed_channel_abort(c);
+
+  c->export_state = ES_DOWN;
+}
+
+static void
+channel_do_start(struct channel *c)
+{
+  rt_lock_table(c->table);
+  add_tail(&c->table->channels, &c->table_node);
+  c->proto->active_channels++;
+
+  c->feed_event = ev_new(c->proto->pool);
+  c->feed_event->data = c;
+  c->feed_event->hook = channel_feed_loop;
+
+  channel_reset_limit(&c->rx_limit);
+  channel_reset_limit(&c->in_limit);
+  channel_reset_limit(&c->out_limit);
+
+  CALL(c->channel->start, c);
+}
+
+static void
+channel_do_flush(struct channel *c)
+{
+  rt_schedule_prune(c->table);
+
+  c->gr_wait = 0;
+  if (c->gr_lock)
+    channel_graceful_restart_unlock(c);
+
+  CALL(c->channel->shutdown, c);
+}
+
+static void
+channel_do_down(struct channel *c)
 {
-  struct announce_hook *h;
+  rem2_node(&c->table_node);
+  rt_unlock_table(c->table);
+  c->proto->active_channels--;
+
+  if ((c->stats.imp_routes + c->stats.filt_routes) != 0)
+    log(L_ERR "%s: Channel %s is down but still has some routes", c->proto->name, c->name);
+
+  memset(&c->stats, 0, sizeof(struct proto_stats));
+
+  /* Schedule protocol shutddown */
+  if (proto_is_done(c->proto))
+    ev_schedule(c->proto->event);
+}
+
+void
+channel_set_state(struct channel *c, uint state)
+{
+  uint cs = c->channel_state;
+  uint es = c->export_state;
+
+  DBG("%s reporting state transition %s/%s -> */%s\n", p->name, c_states[cs], p_states[ops], p_states[ps]);
+  if (state == cs)
+    return;
 
-  DBG("Connecting protocol %s to table %s\n", p->name, t->name);
-  PD(p, "Connected to table %s", t->name);
+  c->channel_state = state;
+  c->last_state_change = now;
 
-  h = mb_allocz(rt_table_pool, sizeof(struct announce_hook));
-  h->table = t;
-  h->proto = p;
-  h->stats = stats;
+  switch (state)
+  {
+  case CS_START:
+    ASSERT(cs == CS_DOWN || cs == CS_UP);
+
+    if (cs == CS_DOWN)
+      channel_do_start(c);
+
+    if (es != ES_DOWN)
+      channel_stop_export(c);
+
+    break;
+
+  case CS_UP:
+    ASSERT(cs == CS_DOWN || cs == CS_START);
+
+    if (cs == CS_DOWN)
+      channel_do_start(c);
+
+    if (!c->gr_wait)
+      channel_start_export(c);
+
+    break;
+
+  case CS_FLUSHING:
+    ASSERT(cs == CS_START || cs == CS_UP);
+
+    if (es != ES_DOWN)
+      channel_stop_export(c);
 
-  h->next = p->ahooks;
-  p->ahooks = h;
+    channel_do_flush(c);
+    break;
 
-  if (p->rt_notify && (p->export_state != ES_DOWN))
-    add_tail(&t->hooks, &h->n);
-  return h;
+  case CS_DOWN:
+    ASSERT(cs == CS_FLUSHING);
+
+    channel_do_down(c);
+    break;
+
+  default:
+    ASSERT(0);
+  }
+  // XXXX proto_log_state_change(c);
 }
 
 /**
- * proto_find_announce_hook - find announce hooks
- * @p: protocol instance
- * @t: routing table
+ * channel_request_feeding - request feeding routes to the channel
+ * @c: given channel
  *
- * Returns pointer to announce hook or NULL
+ * Sometimes it is needed to send again all routes to the channel. This is
+ * called feeding and can be requested by this function. This would cause
+ * channel export state transition to ES_FEEDING (during feeding) and when
+ * completed, it will switch back to ES_READY. This function can be called
+ * even when feeding is already running, in that case it is restarted.
  */
-struct announce_hook *
-proto_find_announce_hook(struct proto *p, struct rtable *t)
+void
+channel_request_feeding(struct channel *c)
 {
-  struct announce_hook *a;
+  ASSERT(c->channel_state == CS_UP);
 
-  for (a = p->ahooks; a; a = a->next)
-    if (a->table == t)
-      return a;
+  /* Do nothing if we are still waiting for feeding */
+  if (c->export_state == ES_DOWN)
+    return;
 
-  return NULL;
+  /* If we are already feeding, we want to restart it */
+  if (c->export_state == ES_FEEDING)
+  {
+    /* Unless feeding is in initial state */
+    if (!c->feed_active)
+	return;
+
+    rt_feed_channel_abort(c);
+  }
+
+  channel_reset_limit(&c->out_limit);
+
+  /* Hack: reset exp_routes during refeed, and do not decrease it later */
+  c->stats.exp_routes = 0;
+
+  channel_schedule_feed(c, 0);	/* Sets ES_FEEDING */
+  // proto_log_state_change(c);
+}
+
+static inline int
+channel_reloadable(struct channel *c)
+{
+  return c->proto->reload_routes && c->reloadable;
 }
 
 static void
-proto_link_ahooks(struct proto *p)
+channel_request_reload(struct channel *c)
 {
-  struct announce_hook *h;
+  ASSERT(c->channel_state == CS_UP);
+  // ASSERT(channel_reloadable(c));
+
+  c->proto->reload_routes(c);
 
-  if (p->rt_notify)
-    for(h=p->ahooks; h; h=h->next)
-      add_tail(&h->table->hooks, &h->n);
+  /*
+   * Should this be done before reload_routes() hook?
+   * Perhaps, but routes are updated asynchronously.
+   */
+  channel_reset_limit(&c->rx_limit);
+  channel_reset_limit(&c->in_limit);
 }
 
-static void
-proto_unlink_ahooks(struct proto *p)
+const struct channel_class channel_basic = {
+  .channel_size = sizeof(struct channel),
+  .config_size = sizeof(struct channel_config)
+};
+
+void *
+channel_config_new(const struct channel_class *cc, uint net_type, struct proto_config *proto)
+{
+  struct channel_config *cf = NULL;
+  struct rtable_config *tab = NULL;
+  const char *name = NULL;
+
+  if (net_type)
+  {
+    if (!net_val_match(net_type, proto->protocol->channel_mask))
+      cf_error("Unsupported channel type");
+
+    if (proto->net_type && (net_type != proto->net_type))
+      cf_error("Different channel type");
+
+    tab = new_config->def_tables[net_type];
+    name = net_label[net_type];
+  }
+
+  if (!cc)
+    cc = &channel_basic;
+
+  cf = cfg_allocz(cc->config_size);
+  cf->name = name;
+  cf->channel = cc;
+  cf->table = tab;
+  cf->out_filter = FILTER_REJECT;
+
+  cf->net_type = net_type;
+  cf->ra_mode = RA_OPTIMAL;
+  cf->preference = proto->protocol->preference;
+
+  add_tail(&proto->channels, &cf->n);
+
+  return cf;
+}
+
+struct channel_config *
+channel_copy_config(struct channel_config *src, struct proto_config *proto)
 {
-  struct announce_hook *h;
+  struct channel_config *dst = cfg_alloc(src->channel->config_size);
+
+  memcpy(dst, src, src->channel->config_size);
+  add_tail(&proto->channels, &dst->n);
+  CALL(src->channel->copy_config, dst, src);
+
+  return dst;
+}
+
+
+static int reconfigure_type;  /* Hack to propagate type info to channel_reconfigure() */
+
+int
+channel_reconfigure(struct channel *c, struct channel_config *cf)
+{
+  /* FIXME: better handle these changes, also handle in_keep_filtered */
+  if ((c->table != cf->table->table) || (c->ra_mode != cf->ra_mode))
+    return 0;
 
-  if (p->rt_notify)
-    for(h=p->ahooks; h; h=h->next)
-      rem_node(&h->n);
+  int import_changed = !filter_same(c->in_filter, cf->in_filter);
+  int export_changed = !filter_same(c->out_filter, cf->out_filter);
+
+  if (c->preference != cf->preference)
+    import_changed = 1;
+
+  if (c->merge_limit != cf->merge_limit)
+    export_changed = 1;
+
+  /* Reconfigure channel fields */
+  c->in_filter = cf->in_filter;
+  c->out_filter = cf->out_filter;
+  c->rx_limit = cf->rx_limit;
+  c->in_limit = cf->in_limit;
+  c->out_limit = cf->out_limit;
+
+  // c->ra_mode = cf->ra_mode;
+  c->merge_limit = cf->merge_limit;
+  c->preference = cf->preference;
+  c->in_keep_filtered = cf->in_keep_filtered;
+
+  channel_verify_limits(c);
+
+  CALL(c->channel->reconfigure, c, cf);
+
+  /* If the channel is not open, it has no routes and we cannot reload it anyways */
+  if (c->channel_state != CS_UP)
+    return 1;
+
+  if (reconfigure_type == RECONFIG_SOFT)
+  {
+    if (import_changed)
+      log(L_INFO "Channel %s.%s changed import", c->proto->name, c->name);
+
+    if (export_changed)
+      log(L_INFO "Channel %s.%s changed export", c->proto->name, c->name);
+
+    return 1;
+  }
+
+  /* Route reload may be not supported */
+  if (import_changed && !channel_reloadable(c))
+    return 0;
+
+  if (import_changed || export_changed)
+    log(L_INFO "Reloading channel %s.%s", c->proto->name, c->name);
+
+  if (import_changed)
+    channel_request_reload(c);
+
+  if (export_changed)
+    channel_request_feeding(c);
+
+  return 1;
 }
 
+
+int
+proto_configure_channel(struct proto *p, struct channel **pc, struct channel_config *cf)
+{
+  struct channel *c = *pc;
+
+  if (!c && cf)
+  {
+    *pc = proto_add_channel(p, cf);
+  }
+  else if (c && !cf)
+  {
+    if (c->channel_state != CS_DOWN)
+    {
+      log(L_INFO "Cannot remove channel %s.%s", c->proto->name, c->name);
+      return 0;
+    }
+
+    proto_remove_channel(p, c);
+    *pc = NULL;
+  }
+  else if (c && cf)
+  {
+    if (!channel_reconfigure(c, cf))
+    {
+      log(L_INFO "Cannot reconfigure channel %s.%s", c->proto->name, c->name);
+      return 0;
+    }
+  }
+
+  return 1;
+}
+
+
 static void
-proto_free_ahooks(struct proto *p)
+proto_event(void *ptr)
 {
-  struct announce_hook *h, *hn;
+  struct proto *p = ptr;
 
-  for(h = p->ahooks; h; h = hn)
+  if (p->do_start)
   {
-    hn = h->next;
-    mb_free(h);
+    if_feed_baby(p);
+    p->do_start = 0;
   }
 
-  p->ahooks = NULL;
-  p->main_ahook = NULL;
+  if (p->do_stop)
+  {
+    if (p->proto == &proto_unix_iface)
+      if_flush_ifaces(p);
+    p->do_stop = 0;
+  }
+
+  if (proto_is_done(p))
+  {
+    if (p->proto->cleanup)
+      p->proto->cleanup(p);
+
+    p->active = 0;
+    proto_log_state_change(p);
+    proto_rethink_goal(p);
+  }
+}
+
+
+/**
+ * proto_new - create a new protocol instance
+ * @c: protocol configuration
+ *
+ * When a new configuration has been read in, the core code starts
+ * initializing all the protocol instances configured by calling their
+ * init() hooks with the corresponding instance configuration. The initialization
+ * code of the protocol is expected to create a new instance according to the
+ * configuration by calling this function and then modifying the default settings
+ * to values wanted by the protocol.
+ */
+void *
+proto_new(struct proto_config *cf)
+{
+  struct proto *p = mb_allocz(proto_pool, cf->protocol->proto_size);
+
+  p->cf = cf;
+  p->debug = cf->debug;
+  p->mrtdump = cf->mrtdump;
+  p->name = cf->name;
+  p->proto = cf->protocol;
+  p->net_type = cf->net_type;
+  p->disabled = cf->disabled;
+  p->hash_key = random_u32();
+  cf->proto = p;
+
+  init_list(&p->channels);
+
+  return p;
+}
+
+static struct proto *
+proto_init(struct proto_config *c, node *n)
+{
+  struct protocol *pr = c->protocol;
+  struct proto *p = pr->init(c);
+
+  p->proto_state = PS_DOWN;
+  p->last_state_change = now;
+  insert_node(&p->n, n);
+
+  p->event = ev_new(proto_pool);
+  p->event->hook = proto_event;
+  p->event->data = p;
+
+  PD(p, "Initializing%s", p->disabled ? " [disabled]" : "");
+
+  return p;
+}
+
+static void
+proto_start(struct proto *p)
+{
+  /* Here we cannot use p->cf->name since it won't survive reconfiguration */
+  p->pool = rp_new(proto_pool, p->proto->name);
+
+  if (graceful_restart_state == GRS_INIT)
+    p->gr_recovery = 1;
 }
 
 
@@ -263,22 +691,24 @@ proto_free_ahooks(struct proto *p)
 void *
 proto_config_new(struct protocol *pr, int class)
 {
-  struct proto_config *c = cfg_allocz(pr->config_size);
+  struct proto_config *cf = cfg_allocz(pr->config_size);
 
   if (class == SYM_PROTO)
-    add_tail(&new_config->protos, &c->n);
-  c->global = new_config;
-  c->protocol = pr;
-  c->name = pr->name;
-  c->preference = pr->preference;
-  c->class = class;
-  c->out_filter = FILTER_REJECT;
-  c->table = c->global->master_rtc;
-  c->debug = new_config->proto_default_debug;
-  c->mrtdump = new_config->proto_default_mrtdump;
-  return c;
+    add_tail(&new_config->protos, &cf->n);
+
+  cf->global = new_config;
+  cf->protocol = pr;
+  cf->name = pr->name;
+  cf->class = class;
+  cf->debug = new_config->proto_default_debug;
+  cf->mrtdump = new_config->proto_default_mrtdump;
+
+  init_list(&cf->channels);
+
+  return cf;
 }
 
+
 /**
  * proto_copy_config - copy a protocol configuration
  * @dest: destination protocol configuration
@@ -293,6 +723,7 @@ proto_config_new(struct protocol *pr, int class)
 void
 proto_copy_config(struct proto_config *dest, struct proto_config *src)
 {
+  struct channel_config *cc;
   node old_node;
   int old_class;
   char *old_name;
@@ -305,7 +736,7 @@ proto_copy_config(struct proto_config *dest, struct proto_config *src)
 
   DBG("Copying configuration from %s to %s\n", src->name, dest->name);
 
-  /* 
+  /*
    * Copy struct proto_config here. Keep original node, class and name.
    * protocol-specific config copy is handled by protocol copy_config() hook
    */
@@ -314,12 +745,17 @@ proto_copy_config(struct proto_config *dest, struct proto_config *src)
   old_class = dest->class;
   old_name = dest->name;
 
-  memcpy(dest, src, sizeof(struct proto_config));
+  memcpy(dest, src, src->protocol->config_size);
 
   dest->n = old_node;
   dest->class = old_class;
   dest->name = old_name;
+  init_list(&dest->channels);
 
+  WALK_LIST(cc, src->channels)
+    channel_copy_config(cc, dest);
+
+  /* FIXME: allow for undefined copy_config */
   dest->protocol->copy_config(dest, src);
 }
 
@@ -339,66 +775,15 @@ protos_preconfig(struct config *c)
   init_list(&c->protos);
   DBG("Protocol preconfig:");
   WALK_LIST(p, protocol_list)
-    {
-      DBG(" %s", p->name);
-      p->name_counter = 0;
-      if (p->preconfig)
-	p->preconfig(p, c);
-    }
-  DBG("\n");
-}
-
-/**
- * protos_postconfig - post-configuration processing
- * @c: new configuration
- *
- * This function calls the postconfig() hooks of all protocol
- * instances specified in configuration @c. The hooks are not
- * called for protocol templates.
- */
-void
-protos_postconfig(struct config *c)
-{
-  struct proto_config *x;
-  struct protocol *p;
-
-  DBG("Protocol postconfig:");
-  WALK_LIST(x, c->protos)
-    {
-      DBG(" %s", x->name);
-
-      p = x->protocol;
-      if (p->postconfig)
-	p->postconfig(x);
-    }
+  {
+    DBG(" %s", p->name);
+    p->name_counter = 0;
+    if (p->preconfig)
+      p->preconfig(p, c);
+  }
   DBG("\n");
 }
 
-extern struct protocol proto_unix_iface;
-
-static struct proto *
-proto_init(struct proto_config *c)
-{
-  struct protocol *p = c->protocol;
-  struct proto *q = p->init(c);
-
-  q->proto_state = PS_DOWN;
-  q->core_state = FS_HUNGRY;
-  q->export_state = ES_DOWN;
-  q->last_state_change = now;
-
-  add_tail(&initial_proto_list, &q->n);
-
-  if (p == &proto_unix_iface)
-    initial_device_proto = q;
-
-  add_tail(&proto_list, &q->glob_node);
-  PD(q, "Initializing%s", q->disabled ? " [disabled]" : "");
-  return q;
-}
-
-int proto_reconfig_type;  /* Hack to propagate type info to pipe reconfigure hook */
-
 static int
 proto_reconfigure(struct proto *p, struct proto_config *oc, struct proto_config *nc, int type)
 {
@@ -408,74 +793,23 @@ proto_reconfigure(struct proto *p, struct proto_config *oc, struct proto_config
 
   /* If there is a too big change in core attributes, ... */
   if ((nc->protocol != oc->protocol) ||
-      (nc->disabled != p->disabled) ||
-      (nc->table->table != oc->table->table))
+      (nc->net_type != oc->net_type) ||
+      (nc->disabled != p->disabled))
+
     return 0;
 
+  p->name = nc->name;
   p->debug = nc->debug;
   p->mrtdump = nc->mrtdump;
-  proto_reconfig_type = type;
+  reconfigure_type = type;
 
   /* Execute protocol specific reconfigure hook */
-  if (! (p->proto->reconfigure && p->proto->reconfigure(p, nc)))
+  if (!p->proto->reconfigure || !p->proto->reconfigure(p, nc))
     return 0;
 
   DBG("\t%s: same\n", oc->name);
   PD(p, "Reconfigured");
   p->cf = nc;
-  p->name = nc->name;
-  p->preference = nc->preference;
-
-
-  /* Multitable protocols handle rest in their reconfigure hooks */
-  if (p->proto->multitable)
-    return 1;
-
-  /* Update filters and limits in the main announce hook
-     Note that this also resets limit state */
-  if (p->main_ahook)
-    {  
-      struct announce_hook *ah = p->main_ahook;
-      ah->in_filter = nc->in_filter;
-      ah->out_filter = nc->out_filter;
-      ah->rx_limit = nc->rx_limit;
-      ah->in_limit = nc->in_limit;
-      ah->out_limit = nc->out_limit;
-      ah->in_keep_filtered = nc->in_keep_filtered;
-      proto_verify_limits(ah);
-    }
-
-  /* Update routes when filters changed. If the protocol in not UP,
-     it has no routes and we can ignore such changes */
-  if ((p->proto_state != PS_UP) || (type == RECONFIG_SOFT))
-    return 1;
-
-  int import_changed = ! filter_same(nc->in_filter, oc->in_filter);
-  int export_changed = ! filter_same(nc->out_filter, oc->out_filter);
-
-  /* We treat a change in preferences by reimporting routes */
-  if (nc->preference != oc->preference)
-    import_changed = 1;
-
-  if (import_changed || export_changed)
-    log(L_INFO "Reloading protocol %s", p->name);
-
-  /* If import filter changed, call reload hook */
-  if (import_changed && ! (p->reload_routes && p->reload_routes(p)))
-    {
-      /* Now, the protocol is reconfigured. But route reload failed
-	 and we have to do regular protocol restart. */
-      log(L_INFO "Restarting protocol %s", p->name);
-      p->disabled = 1;
-      p->down_code = PDC_CF_RESTART;
-      proto_rethink_goal(p);
-      p->disabled = 0;
-      proto_rethink_goal(p);
-      return 1;
-    }
-
-  if (export_changed)
-    proto_request_feeding(p);
 
   return 1;
 }
@@ -512,85 +846,94 @@ void
 protos_commit(struct config *new, struct config *old, int force_reconfig, int type)
 {
   struct proto_config *oc, *nc;
-  struct proto *p, *n;
   struct symbol *sym;
+  struct proto *p;
+  node *n;
+
 
   DBG("protos_commit:\n");
   if (old)
+  {
+    WALK_LIST(oc, old->protos)
     {
-      WALK_LIST(oc, old->protos)
-	{
-	  p = oc->proto;
-	  sym = cf_find_symbol(new, oc->name);
-	  if (sym && sym->class == SYM_PROTO && !new->shutdown)
-	    {
-	      /* Found match, let's check if we can smoothly switch to new configuration */
-	      /* No need to check description */
-	      nc = sym->def;
-	      nc->proto = p;
-
-	      /* We will try to reconfigure protocol p */
-	      if (! force_reconfig && proto_reconfigure(p, oc, nc, type))
-		continue;
-
-	      /* Unsuccessful, we will restart it */
-	      if (!p->disabled && !nc->disabled)
-		log(L_INFO "Restarting protocol %s", p->name);
-	      else if (p->disabled && !nc->disabled)
-		log(L_INFO "Enabling protocol %s", p->name);
-	      else if (!p->disabled && nc->disabled)
-		log(L_INFO "Disabling protocol %s", p->name);
-
-	      p->down_code = nc->disabled ? PDC_CF_DISABLE : PDC_CF_RESTART;
-	      p->cf_new = nc;
-	    }
-	  else if (!new->shutdown)
-	    {
-	      log(L_INFO "Removing protocol %s", p->name);
-	      p->down_code = PDC_CF_REMOVE;
-	      p->cf_new = NULL;
-	    }
-	  else /* global shutdown */
-	    {
-	      p->down_code = PDC_CMD_SHUTDOWN;
-	      p->cf_new = NULL;
-	    }
-
-	  p->reconfiguring = 1;
-	  config_add_obstacle(old);
-	  proto_rethink_goal(p);
-	}
+      p = oc->proto;
+      sym = cf_find_symbol(new, oc->name);
+      if (sym && sym->class == SYM_PROTO && !new->shutdown)
+      {
+	/* Found match, let's check if we can smoothly switch to new configuration */
+	/* No need to check description */
+	nc = sym->def;
+	nc->proto = p;
+
+	/* We will try to reconfigure protocol p */
+	if (! force_reconfig && proto_reconfigure(p, oc, nc, type))
+	  continue;
+
+	/* Unsuccessful, we will restart it */
+	if (!p->disabled && !nc->disabled)
+	  log(L_INFO "Restarting protocol %s", p->name);
+	else if (p->disabled && !nc->disabled)
+	  log(L_INFO "Enabling protocol %s", p->name);
+	else if (!p->disabled && nc->disabled)
+	  log(L_INFO "Disabling protocol %s", p->name);
+
+	p->down_code = nc->disabled ? PDC_CF_DISABLE : PDC_CF_RESTART;
+	p->cf_new = nc;
+      }
+      else if (!new->shutdown)
+      {
+	log(L_INFO "Removing protocol %s", p->name);
+	p->down_code = PDC_CF_REMOVE;
+	p->cf_new = NULL;
+      }
+      else /* global shutdown */
+      {
+	p->down_code = PDC_CMD_SHUTDOWN;
+	p->cf_new = NULL;
+      }
+
+      p->reconfiguring = 1;
+      config_add_obstacle(old);
+      proto_rethink_goal(p);
     }
+  }
 
+  struct proto *first_dev_proto = NULL;
+
+  n = NODE &(proto_list.head);
   WALK_LIST(nc, new->protos)
     if (!nc->proto)
-      {
-	if (old)		/* Not a first-time configuration */
-	  log(L_INFO "Adding protocol %s", nc->name);
-	proto_init(nc);
-      }
-  DBG("\tdone\n");
+    {
+      /* Not a first-time configuration */
+      if (old)
+	log(L_INFO "Adding protocol %s", nc->name);
+
+      p = proto_init(nc, n);
+      n = NODE p;
+
+      if (p->proto == &proto_unix_iface)
+	first_dev_proto = p;
+    }
+    else
+      n = NODE nc->proto;
 
   DBG("Protocol start\n");
 
   /* Start device protocol first */
-  if (initial_device_proto)
-  {
-    proto_rethink_goal(initial_device_proto);
-    initial_device_proto = NULL;
-  }
+  if (first_dev_proto)
+    proto_rethink_goal(first_dev_proto);
 
   /* Determine router ID for the first time - it has to be here and not in
      global_commit() because it is postponed after start of device protocol */
   if (!config->router_id)
-    {
-      config->router_id = if_choose_router_id(config->router_id_from, 0);
-      if (!config->router_id)
-	die("Cannot determine router ID, please configure it manually");
-    }
+  {
+    config->router_id = if_choose_router_id(config->router_id_from, 0);
+    if (!config->router_id)
+      die("Cannot determine router ID, please configure it manually");
+  }
 
-  /* Start all other protocols */
-  WALK_LIST_DELSAFE(p, n, initial_proto_list)
+  /* Start all new protocols */
+  WALK_LIST_DELSAFE(p, n, proto_list)
     proto_rethink_goal(p);
 }
 
@@ -600,19 +943,21 @@ proto_rethink_goal(struct proto *p)
   struct protocol *q;
   byte goal;
 
-  if (p->reconfiguring && p->core_state == FS_HUNGRY && p->proto_state == PS_DOWN)
-    {
-      struct proto_config *nc = p->cf_new;
-      DBG("%s has shut down for reconfiguration\n", p->name);
-      p->cf->proto = NULL;
-      config_del_obstacle(p->cf->global);
-      rem_node(&p->n);
-      rem_node(&p->glob_node);
-      mb_free(p);
-      if (!nc)
-	return;
-      p = proto_init(nc);
-    }
+  if (p->reconfiguring && !p->active)
+  {
+    struct proto_config *nc = p->cf_new;
+    node *n = p->n.prev;
+    DBG("%s has shut down for reconfiguration\n", p->name);
+    p->cf->proto = NULL;
+    config_del_obstacle(p->cf->global);
+    proto_remove_channels(p);
+    rem_node(&p->n);
+    rfree(p->event);
+    mb_free(p);
+    if (!nc)
+      return;
+    p = proto_init(nc, n);
+  }
 
   /* Determine what state we want to reach */
   if (p->disabled || p->reconfiguring)
@@ -621,25 +966,27 @@ proto_rethink_goal(struct proto *p)
     goal = PS_UP;
 
   q = p->proto;
-  if (goal == PS_UP) 			/* Going up */
+  if (goal == PS_UP)
+  {
+    if (!p->active)
     {
-      if (p->proto_state == PS_DOWN && p->core_state == FS_HUNGRY)
-	{
-	  DBG("Kicking %s up\n", p->name);
-	  PD(p, "Starting");
-	  proto_init_instance(p);
-	  proto_notify_state(p, (q->start ? q->start(p) : PS_UP));
-	}
+      /* Going up */
+      DBG("Kicking %s up\n", p->name);
+      PD(p, "Starting");
+      proto_start(p);
+      proto_notify_state(p, (q->start ? q->start(p) : PS_UP));
     }
-  else 					/* Going down */
+  }
+  else
+  {
+    if (p->proto_state == PS_START || p->proto_state == PS_UP)
     {
-      if (p->proto_state == PS_START || p->proto_state == PS_UP)
-	{
-	  DBG("Kicking %s down\n", p->name);
-	  PD(p, "Shutting down");
-	  proto_notify_state(p, (q->shutdown ? q->shutdown(p) : PS_DOWN));
-	}
+      /* Going down */
+      DBG("Kicking %s down\n", p->name);
+      PD(p, "Shutting down");
+      proto_notify_state(p, (q->shutdown ? q->shutdown(p) : PS_DOWN));
     }
+  }
 }
 
 
@@ -661,13 +1008,14 @@ proto_rethink_goal(struct proto *p)
  * When graceful restart recovery need is detected during initialization, then
  * enabled protocols are marked with @gr_recovery flag before start. Such
  * protocols then decide how to proceed with graceful restart, participation is
- * voluntary. Protocols could lock the recovery by proto_graceful_restart_lock()
- * (stored in @gr_lock flag), which means that they want to postpone the end of
- * the recovery until they converge and then unlock it. They also could set
- * @gr_wait before advancing to %PS_UP, which means that the core should defer
- * route export to that protocol until the end of the recovery. This should be
- * done by protocols that expect their neigbors to keep the proper routes
- * (kernel table, BGP sessions with BGP graceful restart capability).
+ * voluntary. Protocols could lock the recovery for each channel by function
+ * channel_graceful_restart_lock() (starte stored in @gr_lock flag), which means
+ * that they want to postpone the end of the recovery until they converge and
+ * then unlock it. They also could set @gr_wait before advancing to %PS_UP,
+ * which means that the core should defer route export to that channel until
+ * the end of the recovery. This should be done by protocols that expect their
+ * neigbors to keep the proper routes (kernel table, BGP sessions with BGP
+ * graceful restart capability).
  *
  * The graceful restart recovery is finished when either all graceful restart
  * locks are unlocked or when graceful restart wait timer fires.
@@ -705,10 +1053,10 @@ graceful_restart_init(void)
   log(L_INFO "Graceful restart started");
 
   if (!graceful_restart_locks)
-    {
-      graceful_restart_done(NULL);
-      return;
-    }
+  {
+    graceful_restart_done(NULL);
+    return;
+  }
 
   graceful_restart_state = GRS_ACTIVE;
   gr_wait_timer = tm_new(proto_pool);
@@ -728,30 +1076,30 @@ graceful_restart_init(void)
 static void
 graceful_restart_done(struct timer *t UNUSED)
 {
-  struct proto *p;
-  node *n;
-
   log(L_INFO "Graceful restart done");
   graceful_restart_state = GRS_DONE;
 
-  WALK_LIST2(p, n, proto_list, glob_node)
-    {
-      if (!p->gr_recovery)
-	continue;
+  struct proto *p;
+  WALK_LIST(p, proto_list)
+  {
+    if (!p->gr_recovery)
+      continue;
 
+    struct channel *c;
+    WALK_LIST(c, p->channels)
+    {
       /* Resume postponed export of routes */
-      if ((p->proto_state == PS_UP) && p->gr_wait)
-      {
-	proto_want_export_up(p);
-	proto_log_state_change(p);
-      }
+      if ((c->channel_state == CS_UP) && c->gr_wait)
+	channel_start_export(c);
 
       /* Cleanup */
-      p->gr_recovery = 0;
-      p->gr_wait = 0;
-      p->gr_lock = 0;
+      c->gr_wait = 0;
+      c->gr_lock = 0;
     }
 
+    p->gr_recovery = 0;
+  }
+
   graceful_restart_locks = 0;
 }
 
@@ -762,17 +1110,17 @@ graceful_restart_show_status(void)
     return;
 
   cli_msg(-24, "Graceful restart recovery in progress");
-  cli_msg(-24, "  Waiting for %d protocols to recover", graceful_restart_locks);
+  cli_msg(-24, "  Waiting for %d channels to recover", graceful_restart_locks);
   cli_msg(-24, "  Wait timer is %d/%d", tm_remains(gr_wait_timer), config->gr_wait);
 }
 
 /**
- * proto_graceful_restart_lock - lock graceful restart by protocol
- * @p: protocol instance
+ * channel_graceful_restart_lock - lock graceful restart by channel
+ * @p: channel instance
  *
  * This function allows a protocol to postpone the end of graceful restart
  * recovery until it converges. The lock is removed when the protocol calls
- * proto_graceful_restart_unlock() or when the protocol is stopped.
+ * channel_graceful_restart_unlock() or when the channel is closed.
  *
  * The function have to be called during the initial phase of graceful restart
  * recovery and only for protocols that are part of graceful restart (i.e. their
@@ -780,32 +1128,32 @@ graceful_restart_show_status(void)
  * hooks.
  */
 void
-proto_graceful_restart_lock(struct proto *p)
+channel_graceful_restart_lock(struct channel *c)
 {
   ASSERT(graceful_restart_state == GRS_INIT);
-  ASSERT(p->gr_recovery);
+  ASSERT(c->proto->gr_recovery);
 
-  if (p->gr_lock)
+  if (c->gr_lock)
     return;
 
-  p->gr_lock = 1;
+  c->gr_lock = 1;
   graceful_restart_locks++;
 }
 
 /**
- * proto_graceful_restart_unlock - unlock graceful restart by protocol
- * @p: protocol instance
+ * channel_graceful_restart_unlock - unlock graceful restart by channel
+ * @p: channel instance
  *
- * This function unlocks a lock from proto_graceful_restart_lock(). It is also
+ * This function unlocks a lock from channel_graceful_restart_lock(). It is also
  * automatically called when the lock holding protocol went down.
  */
 void
-proto_graceful_restart_unlock(struct proto *p)
+channel_graceful_restart_unlock(struct channel *c)
 {
-  if (!p->gr_lock)
+  if (!c->gr_lock)
     return;
 
-  p->gr_lock = 0;
+  c->gr_lock = 0;
   graceful_restart_locks--;
 
   if ((graceful_restart_state == GRS_ACTIVE) && !graceful_restart_locks)
@@ -826,34 +1174,26 @@ proto_graceful_restart_unlock(struct proto *p)
 void
 protos_dump_all(void)
 {
-  struct proto *p;
-  struct announce_hook *a;
-
   debug("Protocols:\n");
 
-  WALK_LIST(p, active_proto_list)
+  struct proto *p;
+  WALK_LIST(p, proto_list)
+  {
+    debug("  protocol %s state %s\n", p->name, p_states[p->proto_state]);
+
+    struct channel *c;
+    WALK_LIST(c, p->channels)
     {
-      debug("  protocol %s state %s/%s\n", p->name,
-	    p_states[p->proto_state], c_states[p->core_state]);
-      for (a = p->ahooks; a; a = a->next)
-	{
-	  debug("\tTABLE %s\n", a->table->name);
-	  if (a->in_filter)
-	    debug("\tInput filter: %s\n", filter_name(a->in_filter));
-	  if (a->out_filter != FILTER_REJECT)
-	    debug("\tOutput filter: %s\n", filter_name(a->out_filter));
-	}
-      if (p->disabled)
-	debug("\tDISABLED\n");
-      else if (p->proto->dump)
-	p->proto->dump(p);
+      debug("\tTABLE %s\n", c->table->name);
+      if (c->in_filter)
+	debug("\tInput filter: %s\n", filter_name(c->in_filter));
+      if (c->out_filter)
+	debug("\tOutput filter: %s\n", filter_name(c->out_filter));
     }
-  WALK_LIST(p, inactive_proto_list)
-    debug("  inactive %s: state %s/%s\n", p->name, p_states[p->proto_state], c_states[p->core_state]);
-  WALK_LIST(p, initial_proto_list)
-    debug("  initial %s\n", p->name);
-  WALK_LIST(p, flush_proto_list)
-    debug("  flushing %s\n", p->name);
+
+    if (p->proto->dump && (p->proto_state != PS_DOWN))
+      p->proto->dump(p);
+  }
 }
 
 /**
@@ -890,12 +1230,9 @@ extern void bfd_init_all(void);
 void
 protos_build(void)
 {
-  init_list(&protocol_list);
   init_list(&proto_list);
-  init_list(&active_proto_list);
-  init_list(&inactive_proto_list);
-  init_list(&initial_proto_list);
-  init_list(&flush_proto_list);
+  init_list(&protocol_list);
+
   proto_build(&proto_device);
 #ifdef CONFIG_RADV
   proto_build(&proto_radv);
@@ -921,136 +1258,10 @@ protos_build(void)
 #endif
 
   proto_pool = rp_new(&root_pool, "Protocols");
-  proto_flush_event = ev_new(proto_pool);
-  proto_flush_event->hook = proto_flush_loop;
   proto_shutdown_timer = tm_new(proto_pool);
   proto_shutdown_timer->hook = proto_shutdown_loop;
 }
 
-static void
-proto_feed_more(void *P)
-{
-  struct proto *p = P;
-
-  if (p->export_state != ES_FEEDING)
-    return;
-
-  DBG("Feeding protocol %s continued\n", p->name);
-  if (rt_feed_baby(p))
-    {
-      DBG("Feeding protocol %s finished\n", p->name);
-      p->export_state = ES_READY;
-      proto_log_state_change(p);
-
-      if (p->feed_end)
-	p->feed_end(p);
-    }
-  else
-    {
-      p->attn->hook = proto_feed_more;
-      ev_schedule(p->attn);		/* Will continue later... */
-    }
-}
-
-static void
-proto_feed_initial(void *P)
-{
-  struct proto *p = P;
-
-  if (p->export_state != ES_FEEDING)
-    return;
-
-  DBG("Feeding protocol %s\n", p->name);
-
-  if_feed_baby(p);
-  proto_feed_more(P);
-}
-
-static void
-proto_schedule_feed(struct proto *p, int initial)
-{
-  DBG("%s: Scheduling meal\n", p->name);
-
-  p->export_state = ES_FEEDING;
-  p->refeeding = !initial;
-
-  p->attn->hook = initial ? proto_feed_initial : proto_feed_more;
-  ev_schedule(p->attn);
-
-  if (p->feed_begin)
-    p->feed_begin(p, initial);
-}
-
-/*
- * Flushing loop is responsible for flushing routes and protocols
- * after they went down. It runs in proto_flush_event. At the start of
- * one round, protocols waiting to flush are marked in
- * proto_schedule_flush_loop(). At the end of the round (when routing
- * table flush is complete), marked protocols are flushed and a next
- * round may start.
- */
-
-static int flush_loop_state;	/* 1 -> running */
-
-static void
-proto_schedule_flush_loop(void)
-{
-  struct proto *p;
-  struct announce_hook *h;
-
-  if (flush_loop_state)
-    return;
-  flush_loop_state = 1;
-
-  WALK_LIST(p, flush_proto_list)
-  {
-    p->flushing = 1;
-    for (h=p->ahooks; h; h=h->next)
-      rt_mark_for_prune(h->table);
-  }
-
-  ev_schedule(proto_flush_event);
-}
-
-static void
-proto_flush_loop(void *unused UNUSED)
-{
-  struct proto *p;
-
-  if (! rt_prune_loop())
-    {
-      /* Rtable pruning is not finished */
-      ev_schedule(proto_flush_event);
-      return;
-    }
-
-  rt_prune_sources();
-
- again:
-  WALK_LIST(p, flush_proto_list)
-    if (p->flushing)
-      {
-	/* This will flush interfaces in the same manner
-	   like rt_prune_all() flushes routes */
-	if (p->proto == &proto_unix_iface)
-	  if_flush_ifaces(p);
-
-	DBG("Flushing protocol %s\n", p->name);
-	p->flushing = 0;
-	p->core_state = FS_HUNGRY;
-	proto_relink(p);
-	proto_log_state_change(p);
-	if (p->proto_state == PS_DOWN)
-	  proto_fell_down(p);
-	goto again;
-      }
-
-  /* This round finished, perhaps there will be another one */
-  flush_loop_state = 0;
-  if (!EMPTY_LIST(flush_proto_list))
-    proto_schedule_flush_loop();
-}
-
 
 /* Temporary hack to propagate restart to BGP */
 int proto_restart;
@@ -1060,19 +1271,19 @@ proto_shutdown_loop(struct timer *t UNUSED)
 {
   struct proto *p, *p_next;
 
-  WALK_LIST_DELSAFE(p, p_next, active_proto_list)
+  WALK_LIST_DELSAFE(p, p_next, proto_list)
     if (p->down_sched)
-      {
-	proto_restart = (p->down_sched == PDS_RESTART);
+    {
+      proto_restart = (p->down_sched == PDS_RESTART);
 
-	p->disabled = 1;
+      p->disabled = 1;
+      proto_rethink_goal(p);
+      if (proto_restart)
+      {
+	p->disabled = 0;
 	proto_rethink_goal(p);
-	if (proto_restart)
-	  {
-	    p->disabled = 0;
-	    proto_rethink_goal(p);
-	  }
       }
+    }
 }
 
 static inline void
@@ -1091,50 +1302,8 @@ proto_schedule_down(struct proto *p, byte restart, byte code)
 }
 
 
-/**
- * proto_request_feeding - request feeding routes to the protocol
- * @p: given protocol 
- *
- * Sometimes it is needed to send again all routes to the
- * protocol. This is called feeding and can be requested by this
- * function. This would cause protocol export state transition
- * to ES_FEEDING (during feeding) and when completed, it will
- * switch back to ES_READY. This function can be called even
- * when feeding is already running, in that case it is restarted.
- */
-void
-proto_request_feeding(struct proto *p)
-{
-  ASSERT(p->proto_state == PS_UP);
-
-  /* Do nothing if we are still waiting for feeding */
-  if (p->export_state == ES_DOWN)
-    return;
-
-  /* If we are already feeding, we want to restart it */
-  if (p->export_state == ES_FEEDING)
-    {
-      /* Unless feeding is in initial state */
-      if (p->attn->hook == proto_feed_initial)
-	return;
-
-      rt_feed_baby_abort(p);
-    }
-
-  /* FIXME: This should be changed for better support of multitable protos */
-  struct announce_hook *ah;
-  for (ah = p->ahooks; ah; ah = ah->next)
-    proto_reset_limit(ah->out_limit);
-
-  /* Hack: reset exp_routes during refeed, and do not decrease it later */
-  p->stats.exp_routes = 0;
-
-  proto_schedule_feed(p, 0);
-  proto_log_state_change(p);
-}
-
 static const char *
-proto_limit_name(struct proto_limit *l)
+channel_limit_name(struct channel_limit *l)
 {
   const char *actions[] = {
     [PLA_WARN] = "warn",
@@ -1147,22 +1316,22 @@ proto_limit_name(struct proto_limit *l)
 }
 
 /**
- * proto_notify_limit: notify about limit hit and take appropriate action
- * @ah: announce hook
+ * channel_notify_limit: notify about limit hit and take appropriate action
+ * @c: channel
  * @l: limit being hit
  * @dir: limit direction (PLD_*)
- * @rt_count: the number of routes 
+ * @rt_count: the number of routes
  *
  * The function is called by the route processing core when limit @l
  * is breached. It activates the limit and tooks appropriate action
  * according to @l->action.
  */
 void
-proto_notify_limit(struct announce_hook *ah, struct proto_limit *l, int dir, u32 rt_count)
+channel_notify_limit(struct channel *c, struct channel_limit *l, int dir, u32 rt_count)
 {
   const char *dir_name[PLD_MAX] = { "receive", "import" , "export" };
   const byte dir_down[PLD_MAX] = { PDC_RX_LIMIT_HIT, PDC_IN_LIMIT_HIT, PDC_OUT_LIMIT_HIT };
-  struct proto *p = ah->proto;
+  struct proto *p = c->proto;
 
   if (l->state == PLS_BLOCKED)
     return;
@@ -1170,147 +1339,112 @@ proto_notify_limit(struct announce_hook *ah, struct proto_limit *l, int dir, u32
   /* For warning action, we want the log message every time we hit the limit */
   if (!l->state || ((l->action == PLA_WARN) && (rt_count == l->limit)))
     log(L_WARN "Protocol %s hits route %s limit (%d), action: %s",
-	p->name, dir_name[dir], l->limit, proto_limit_name(l));
+	p->name, dir_name[dir], l->limit, channel_limit_name(l));
 
   switch (l->action)
-    {
-    case PLA_WARN:
-      l->state = PLS_ACTIVE;
-      break;
-
-    case PLA_BLOCK:
-      l->state = PLS_BLOCKED;
-      break;
-
-    case PLA_RESTART:
-    case PLA_DISABLE:
-      l->state = PLS_BLOCKED;
-      if (p->proto_state == PS_UP)
-	proto_schedule_down(p, l->action == PLA_RESTART, dir_down[dir]);
-      break;
-    }
+  {
+  case PLA_WARN:
+    l->state = PLS_ACTIVE;
+    break;
+
+  case PLA_BLOCK:
+    l->state = PLS_BLOCKED;
+    break;
+
+  case PLA_RESTART:
+  case PLA_DISABLE:
+    l->state = PLS_BLOCKED;
+    if (p->proto_state == PS_UP)
+      proto_schedule_down(p, l->action == PLA_RESTART, dir_down[dir]);
+    break;
+  }
 }
 
-void
-proto_verify_limits(struct announce_hook *ah)
+static void
+channel_verify_limits(struct channel *c)
 {
-  struct proto_limit *l;
-  struct proto_stats *stats = ah->stats;
-  u32 all_routes = stats->imp_routes + stats->filt_routes;
+  struct channel_limit *l;
+  u32 all_routes = c->stats.imp_routes + c->stats.filt_routes;
 
-  l = ah->rx_limit;
-  if (l && (all_routes > l->limit))
-    proto_notify_limit(ah, l, PLD_RX, all_routes);
+  l = &c->rx_limit;
+  if (l->action && (all_routes > l->limit))
+    channel_notify_limit(c, l, PLD_RX, all_routes);
 
-  l = ah->in_limit;
-  if (l && (stats->imp_routes > l->limit))
-    proto_notify_limit(ah, l, PLD_IN, stats->imp_routes);
+  l = &c->in_limit;
+  if (l->action && (c->stats.imp_routes > l->limit))
+    channel_notify_limit(c, l, PLD_IN, c->stats.imp_routes);
 
-  l = ah->out_limit;
-  if (l && (stats->exp_routes > l->limit))
-    proto_notify_limit(ah, l, PLD_OUT, stats->exp_routes);
+  l = &c->out_limit;
+  if (l->action && (c->stats.exp_routes > l->limit))
+    channel_notify_limit(c, l, PLD_OUT, c->stats.exp_routes);
 }
 
-
-static void
-proto_want_core_up(struct proto *p)
+static inline void
+channel_reset_limit(struct channel_limit *l)
 {
-  ASSERT(p->core_state == FS_HUNGRY);
-
-  if (!p->proto->multitable)
-    {
-      p->main_source = rt_get_source(p, 0);
-      rt_lock_source(p->main_source);
-
-      /* Connect protocol to routing table */
-      p->main_ahook = proto_add_announce_hook(p, p->table, &p->stats);
-      p->main_ahook->in_filter = p->cf->in_filter;
-      p->main_ahook->out_filter = p->cf->out_filter;
-      p->main_ahook->rx_limit = p->cf->rx_limit;
-      p->main_ahook->in_limit = p->cf->in_limit;
-      p->main_ahook->out_limit = p->cf->out_limit;
-      p->main_ahook->in_keep_filtered = p->cf->in_keep_filtered;
-
-      proto_reset_limit(p->main_ahook->rx_limit);
-      proto_reset_limit(p->main_ahook->in_limit);
-      proto_reset_limit(p->main_ahook->out_limit);
-    }
-
-  p->core_state = FS_HAPPY;
-  proto_relink(p);
+  if (l->action)
+    l->state = PLS_INITIAL;
 }
 
-static void
-proto_want_export_up(struct proto *p)
+static inline void
+proto_do_start(struct proto *p)
 {
-  ASSERT(p->core_state == FS_HAPPY);
-  ASSERT(p->export_state == ES_DOWN);
-
-  proto_link_ahooks(p);
-  proto_schedule_feed(p, 1); /* Sets ES_FEEDING */
+  p->active = 1;
+  p->do_start = 1;
+  ev_schedule(p->event);
 }
 
 static void
-proto_want_export_down(struct proto *p)
+proto_do_up(struct proto *p)
 {
-  ASSERT(p->export_state != ES_DOWN);
-
-  /* Need to abort feeding */
-  if (p->export_state == ES_FEEDING)
-    rt_feed_baby_abort(p);
+  if (!p->main_source)
+  {
+    p->main_source = rt_get_source(p, 0);
+    rt_lock_source(p->main_source);
+  }
 
-  p->export_state = ES_DOWN;
-  proto_unlink_ahooks(p);
+  proto_start_channels(p);
 }
 
-static void
-proto_want_core_down(struct proto *p)
+static inline void
+proto_do_pause(struct proto *p)
 {
-  ASSERT(p->core_state == FS_HAPPY);
-  ASSERT(p->export_state == ES_DOWN);
-
-  p->core_state = FS_FLUSHING;
-  proto_relink(p);
-  proto_schedule_flush_loop();
-
-  if (!p->proto->multitable)
-    {
-      rt_unlock_source(p->main_source);
-      p->main_source = NULL;
-    }
+  proto_pause_channels(p);
 }
 
 static void
-proto_falling_down(struct proto *p)
+proto_do_stop(struct proto *p)
 {
+  p->down_sched = 0;
   p->gr_recovery = 0;
-  p->gr_wait = 0;
-  if (p->gr_lock)
-    proto_graceful_restart_unlock(p);
-}
-
-static void
-proto_fell_down(struct proto *p)
-{
-  DBG("Protocol %s down\n", p->name);
-
-  u32 all_routes = p->stats.imp_routes + p->stats.filt_routes;
-  if (all_routes != 0)
-    log(L_ERR "Protocol %s is down but still has %d routes", p->name, all_routes);
 
-  bzero(&p->stats, sizeof(struct proto_stats));
-  proto_free_ahooks(p);
+  p->do_stop = 1;
+  ev_schedule(p->event);
 
-  if (! p->proto->multitable)
-    rt_unlock_table(p->table);
+  if (p->main_source)
+  {
+    rt_unlock_source(p->main_source);
+    p->main_source = NULL;
+  }
 
-  if (p->proto->cleanup)
-    p->proto->cleanup(p);
+  proto_stop_channels(p);
+}
 
-  proto_rethink_goal(p);
+static void
+proto_do_down(struct proto *p)
+{
+  p->down_code = 0;
+  neigh_prune();
+  rfree(p->pool);
+  p->pool = NULL;
+
+  /* Shutdown is finished in the protocol event */
+  if (proto_is_done(p))
+    ev_schedule(p->event);
 }
 
 
+
 /**
  * proto_notify_state - notify core about protocol state change
  * @p: protocol the state of which has changed
@@ -1326,78 +1460,53 @@ proto_fell_down(struct proto *p)
  * it should be used at tail positions of protocol callbacks.
  */
 void
-proto_notify_state(struct proto *p, unsigned ps)
+proto_notify_state(struct proto *p, uint state)
 {
-  unsigned ops = p->proto_state;
-  unsigned cs = p->core_state;
-  unsigned es = p->export_state;
+  uint ps = p->proto_state;
 
-  DBG("%s reporting state transition %s/%s -> */%s\n", p->name, c_states[cs], p_states[ops], p_states[ps]);
-  if (ops == ps)
+  DBG("%s reporting state transition %s -> %s\n", p->name, p_states[ps], p_states[state]);
+  if (state == ps)
     return;
 
-  p->proto_state = ps;
+  p->proto_state = state;
   p->last_state_change = now;
 
-  switch (ps)
-    {
-    case PS_START:
-      ASSERT(ops == PS_DOWN || ops == PS_UP);
-      ASSERT(cs == FS_HUNGRY || cs == FS_HAPPY);
-
-      if (es != ES_DOWN)
-	proto_want_export_down(p);
-      break;
-
-    case PS_UP:
-      ASSERT(ops == PS_DOWN || ops == PS_START);
-      ASSERT(cs == FS_HUNGRY || cs == FS_HAPPY);
-      ASSERT(es == ES_DOWN);
-
-      if (cs == FS_HUNGRY)
-	proto_want_core_up(p);
-      if (!p->gr_wait)
-	proto_want_export_up(p);
-      break;
-
-    case PS_STOP:
-      ASSERT(ops == PS_START || ops == PS_UP);
-
-      p->down_sched = 0;
-
-      if (es != ES_DOWN)
-	proto_want_export_down(p);
-      if (cs == FS_HAPPY)
-	proto_want_core_down(p);
-      proto_falling_down(p);
-      break;
-
-    case PS_DOWN:
-      p->down_code = 0;
-      p->down_sched = 0;
-
-      if (es != ES_DOWN)
-	proto_want_export_down(p);
-      if (cs == FS_HAPPY)
-	proto_want_core_down(p);
-      if (ops != PS_STOP)
-	proto_falling_down(p);
-
-      neigh_prune(); // FIXME convert neighbors to resource?
-      rfree(p->pool);
-      p->pool = NULL;
-
-      if (cs == FS_HUNGRY)		/* Shutdown finished */
-	{
-	  proto_log_state_change(p);
-	  proto_fell_down(p);
-	  return;			/* The protocol might have ceased to exist */
-	}
-      break;
-
-    default:
-      bug("%s: Invalid state %d", p->name, ps);
-    }
+  switch (state)
+  {
+  case PS_START:
+    ASSERT(ps == PS_DOWN || ps == PS_UP);
+
+    if (ps == PS_DOWN)
+      proto_do_start(p);
+    else
+      proto_do_pause(p);
+    break;
+
+  case PS_UP:
+    ASSERT(ps == PS_DOWN || ps == PS_START);
+
+    if (ps == PS_DOWN)
+      proto_do_start(p);
+
+    proto_do_up(p);
+    break;
+
+  case PS_STOP:
+    ASSERT(ps == PS_START || ps == PS_UP);
+
+    proto_do_stop(p);
+    break;
+
+  case PS_DOWN:
+    if (ps != PS_STOP)
+      proto_do_stop(p);
+
+    proto_do_down(p);
+    break;
+
+  default:
+    bug("%s: Invalid state %d", p->name, ps);
+  }
 
   proto_log_state_change(p);
 }
@@ -1409,82 +1518,73 @@ proto_notify_state(struct proto *p, unsigned ps)
 static char *
 proto_state_name(struct proto *p)
 {
-#define P(x,y) ((x << 4) | y)
-  switch (P(p->proto_state, p->core_state))
-    {
-    case P(PS_DOWN, FS_HUNGRY):		return "down";
-    case P(PS_START, FS_HUNGRY):
-    case P(PS_START, FS_HAPPY):		return "start";
-    case P(PS_UP, FS_HAPPY):
-      switch (p->export_state)
-	{
-	case ES_DOWN:			return "wait";
-	case ES_FEEDING:		return "feed";
-	case ES_READY:			return "up";
-	default:      			return "???";
-	}
-    case P(PS_STOP, FS_HUNGRY):
-    case P(PS_STOP, FS_FLUSHING):	return "stop";
-    case P(PS_DOWN, FS_FLUSHING):	return "flush";
-    default:      			return "???";
-    }
-#undef P
+  switch (p->proto_state)
+  {
+  case PS_DOWN:		return p->active ? "flush" : "down";
+  case PS_START:	return "start";
+  case PS_UP:		return "up";
+  case PS_STOP:		return "stop";
+  default:		return "???";
+  }
 }
 
 static void
-proto_show_stats(struct proto_stats *s, int in_keep_filtered)
+channel_show_stats(struct channel *c)
 {
-  if (in_keep_filtered)
-    cli_msg(-1006, "  Routes:         %u imported, %u filtered, %u exported, %u preferred", 
-	    s->imp_routes, s->filt_routes, s->exp_routes, s->pref_routes);
+  struct proto_stats *s = &c->stats;
+
+  if (c->in_keep_filtered)
+    cli_msg(-1006, "    Routes:         %u imported, %u filtered, %u exported",
+	    s->imp_routes, s->filt_routes, s->exp_routes);
   else
-    cli_msg(-1006, "  Routes:         %u imported, %u exported, %u preferred", 
-	    s->imp_routes, s->exp_routes, s->pref_routes);
+    cli_msg(-1006, "    Routes:         %u imported, %u exported",
+	    s->imp_routes, s->exp_routes);
 
-  cli_msg(-1006, "  Route change stats:     received   rejected   filtered    ignored   accepted");
-  cli_msg(-1006, "    Import updates:     %10u %10u %10u %10u %10u",
+  cli_msg(-1006, "    Route change stats:     received   rejected   filtered    ignored   accepted");
+  cli_msg(-1006, "      Import updates:     %10u %10u %10u %10u %10u",
 	  s->imp_updates_received, s->imp_updates_invalid,
 	  s->imp_updates_filtered, s->imp_updates_ignored,
 	  s->imp_updates_accepted);
-  cli_msg(-1006, "    Import withdraws:   %10u %10u        --- %10u %10u",
+  cli_msg(-1006, "      Import withdraws:   %10u %10u        --- %10u %10u",
 	  s->imp_withdraws_received, s->imp_withdraws_invalid,
 	  s->imp_withdraws_ignored, s->imp_withdraws_accepted);
-  cli_msg(-1006, "    Export updates:     %10u %10u %10u        --- %10u",
+  cli_msg(-1006, "      Export updates:     %10u %10u %10u        --- %10u",
 	  s->exp_updates_received, s->exp_updates_rejected,
 	  s->exp_updates_filtered, s->exp_updates_accepted);
-  cli_msg(-1006, "    Export withdraws:   %10u        ---        ---        --- %10u",
+  cli_msg(-1006, "      Export withdraws:   %10u        ---        ---        --- %10u",
 	  s->exp_withdraws_received, s->exp_withdraws_accepted);
 }
 
 void
-proto_show_limit(struct proto_limit *l, const char *dsc)
+channel_show_limit(struct channel_limit *l, const char *dsc)
 {
-  if (!l)
+  if (!l->action)
     return;
 
-  cli_msg(-1006, "  %-16s%d%s", dsc, l->limit, l->state ? " [HIT]" : "");
-  cli_msg(-1006, "    Action:       %s", proto_limit_name(l));
+  cli_msg(-1006, "    %-16s%d%s", dsc, l->limit, l->state ? " [HIT]" : "");
+  cli_msg(-1006, "      Action:       %s", channel_limit_name(l));
 }
 
 void
-proto_show_basic_info(struct proto *p)
+channel_show_info(struct channel *c)
 {
-  // cli_msg(-1006, "  Table:          %s", p->table->name);
-  cli_msg(-1006, "  Preference:     %d", p->preference);
-  cli_msg(-1006, "  Input filter:   %s", filter_name(p->cf->in_filter));
-  cli_msg(-1006, "  Output filter:  %s", filter_name(p->cf->out_filter));
+  cli_msg(-1006, "  Channel %s", c->name);
+  cli_msg(-1006, "    Table:          %s", c->table->name);
+  cli_msg(-1006, "    Preference:     %d", c->preference);
+  cli_msg(-1006, "    Input filter:   %s", filter_name(c->in_filter));
+  cli_msg(-1006, "    Output filter:  %s", filter_name(c->out_filter));
 
   if (graceful_restart_state == GRS_ACTIVE)
-    cli_msg(-1006, "  GR recovery:   %s%s",
-	    p->gr_lock ? " pending" : "",
-	    p->gr_wait ? " waiting" : "");
+    cli_msg(-1006, "    GR recovery:   %s%s",
+	    c->gr_lock ? " pending" : "",
+	    c->gr_wait ? " waiting" : "");
 
-  proto_show_limit(p->cf->rx_limit, "Receive limit:");
-  proto_show_limit(p->cf->in_limit, "Import limit:");
-  proto_show_limit(p->cf->out_limit, "Export limit:");
+  channel_show_limit(&c->rx_limit, "Receive limit:");
+  channel_show_limit(&c->in_limit, "Import limit:");
+  channel_show_limit(&c->out_limit, "Export limit:");
 
-  if (p->proto_state != PS_DOWN)
-    proto_show_stats(&p->stats, p->cf->in_keep_filtered);
+  if (c->channel_state != CS_DOWN)
+    channel_show_stats(c);
 }
 
 void
@@ -1503,34 +1603,39 @@ proto_cmd_show(struct proto *p, uint verbose, int cnt)
   cli_msg(-1002, "%-8s %-8s %-8s %-5s  %-10s  %s",
 	  p->name,
 	  p->proto->name,
-	  p->table->name,
+	  p->main_channel ? p->main_channel->table->name : "---",
 	  proto_state_name(p),
 	  tbuf,
 	  buf);
+
   if (verbose)
+  {
+    if (p->cf->dsc)
+      cli_msg(-1006, "  Description:    %s", p->cf->dsc);
+    if (p->cf->router_id)
+      cli_msg(-1006, "  Router ID:      %R", p->cf->router_id);
+
+    if (p->proto->show_proto_info)
+      p->proto->show_proto_info(p);
+    else
     {
-      if (p->cf->dsc)
-	cli_msg(-1006, "  Description:    %s", p->cf->dsc);
-      if (p->cf->router_id)
-	cli_msg(-1006, "  Router ID:      %R", p->cf->router_id);
-
-      if (p->proto->show_proto_info)
-	p->proto->show_proto_info(p);
-      else
-	proto_show_basic_info(p);
-
-      cli_msg(-1006, "");
+      struct channel *c;
+      WALK_LIST(c, p->channels)
+	channel_show_info(c);
     }
+
+    cli_msg(-1006, "");
+  }
 }
 
 void
 proto_cmd_disable(struct proto *p, uint arg UNUSED, int cnt UNUSED)
 {
   if (p->disabled)
-    {
-      cli_msg(-8, "%s: already disabled", p->name);
-      return;
-    }
+  {
+    cli_msg(-8, "%s: already disabled", p->name);
+    return;
+  }
 
   log(L_INFO "Disabling protocol %s", p->name);
   p->disabled = 1;
@@ -1543,10 +1648,10 @@ void
 proto_cmd_enable(struct proto *p, uint arg UNUSED, int cnt UNUSED)
 {
   if (!p->disabled)
-    {
-      cli_msg(-10, "%s: already enabled", p->name);
-      return;
-    }
+  {
+    cli_msg(-10, "%s: already enabled", p->name);
+    return;
+  }
 
   log(L_INFO "Enabling protocol %s", p->name);
   p->disabled = 0;
@@ -1558,10 +1663,10 @@ void
 proto_cmd_restart(struct proto *p, uint arg UNUSED, int cnt UNUSED)
 {
   if (p->disabled)
-    {
-      cli_msg(-8, "%s: already disabled", p->name);
-      return;
-    }
+  {
+    cli_msg(-8, "%s: already disabled", p->name);
+    return;
+  }
 
   log(L_INFO "Restarting protocol %s", p->name);
   p->disabled = 1;
@@ -1575,41 +1680,38 @@ proto_cmd_restart(struct proto *p, uint arg UNUSED, int cnt UNUSED)
 void
 proto_cmd_reload(struct proto *p, uint dir, int cnt UNUSED)
 {
+  struct channel *c;
+
   if (p->disabled)
-    {
-      cli_msg(-8, "%s: already disabled", p->name);
-      return;
-    }
+  {
+    cli_msg(-8, "%s: already disabled", p->name);
+    return;
+  }
 
   /* If the protocol in not UP, it has no routes */
   if (p->proto_state != PS_UP)
     return;
 
+  /* All channels must support reload */
+  if (dir != CMD_RELOAD_OUT)
+    WALK_LIST(c, p->channels)
+      if (!channel_reloadable(c))
+      {
+	cli_msg(-8006, "%s: reload failed", p->name);
+	return;
+      }
+
   log(L_INFO "Reloading protocol %s", p->name);
 
   /* re-importing routes */
   if (dir != CMD_RELOAD_OUT)
-    {
-      if (! (p->reload_routes && p->reload_routes(p)))
-	{
-	  cli_msg(-8006, "%s: reload failed", p->name);
-	  return;
-	}
-
-      /*
-       * Should be done before reload_routes() hook?
-       * Perhaps, but these hooks work asynchronously.
-       */
-      if (!p->proto->multitable)
-	{
-	  proto_reset_limit(p->main_ahook->rx_limit);
-	  proto_reset_limit(p->main_ahook->in_limit);
-	}
-    }
+    WALK_LIST(c, p->channels)
+      channel_request_reload(c);
 
   /* re-exporting routes */
   if (dir != CMD_RELOAD_IN)
-    proto_request_feeding(p);
+    WALK_LIST(c, p->channels)
+      channel_request_feeding(c);
 
   cli_msg(-15, "%s: reloading", p->name);
 }
@@ -1630,10 +1732,10 @@ static void
 proto_apply_cmd_symbol(struct symbol *s, void (* cmd)(struct proto *, uint, int), uint arg)
 {
   if (s->class != SYM_PROTO)
-    {
-      cli_msg(9002, "%s is not a protocol", s->name);
-      return;
-    }
+  {
+    cli_msg(9002, "%s is not a protocol", s->name);
+    return;
+  }
 
   cmd(((struct proto_config *)s->def)->proto, arg, 0);
   cli_msg(0, "");
@@ -1642,16 +1744,12 @@ proto_apply_cmd_symbol(struct symbol *s, void (* cmd)(struct proto *, uint, int)
 static void
 proto_apply_cmd_patt(char *patt, void (* cmd)(struct proto *, uint, int), uint arg)
 {
+  struct proto *p;
   int cnt = 0;
 
-  node *nn;
-  WALK_LIST(nn, proto_list)
-    {
-      struct proto *p = SKIP_BACK(struct proto, glob_node, nn);
-
-      if (!patt || patmatch(patt, p->name))
-	cmd(p, arg, cnt++);
-    }
+  WALK_LIST(p, proto_list)
+    if (!patt || patmatch(patt, p->name))
+      cmd(p, arg, cnt++);
 
   if (!cnt)
     cli_msg(8003, "No protocols match");
@@ -1678,25 +1776,27 @@ proto_get_named(struct symbol *sym, struct protocol *pr)
   struct proto *p, *q;
 
   if (sym)
-    {
-      if (sym->class != SYM_PROTO)
-	cf_error("%s: Not a protocol", sym->name);
-      p = ((struct proto_config *)sym->def)->proto;
-      if (!p || p->proto != pr)
-	cf_error("%s: Not a %s protocol", sym->name, pr->name);
-    }
+  {
+    if (sym->class != SYM_PROTO)
+      cf_error("%s: Not a protocol", sym->name);
+
+    p = ((struct proto_config *) sym->def)->proto;
+    if (!p || p->proto != pr)
+      cf_error("%s: Not a %s protocol", sym->name, pr->name);
+  }
   else
-    {
-      p = NULL;
-      WALK_LIST(q, active_proto_list)
-	if (q->proto == pr)
-	  {
-	    if (p)
-	      cf_error("There are multiple %s protocols running", pr->name);
-	    p = q;
-	  }
-      if (!p)
-	cf_error("There is no %s protocol running", pr->name);
-    }
+  {
+    p = NULL;
+    WALK_LIST(q, proto_list)
+      if ((q->proto == pr) && (q->proto_state != PS_DOWN))
+      {
+	if (p)
+	  cf_error("There are multiple %s protocols running", pr->name);
+	p = q;
+      }
+    if (!p)
+      cf_error("There is no %s protocol running", pr->name);
+  }
+
   return p;
 }
diff --git a/nest/proto.sgml b/nest/proto.sgml
index 1d4c31a7..53da78b8 100644
--- a/nest/proto.sgml
+++ b/nest/proto.sgml
@@ -69,23 +69,6 @@ its state by calling the <func/proto_notify_state/ function.
 
 <p>At any time, the core code can ask the protocol to shut itself down by calling its stop() hook.
 
-<p>The <em/core state machine/ takes care of the core view of protocol state.
-The states are traversed according to changes of the protocol state machine, but
-sometimes the transitions are delayed if the core needs to finish some actions
-(for example sending of new routes to the protocol) before proceeding to the
-new state. There are the following core states:
-
-<descrip>
-	<tag/FS_HUNGRY/ The protocol is down, it doesn't have any routes and
-	doesn't want them.
-	<tag/FS_FEEDING/ The protocol has reached the <tt/PS_UP/ state, but
-	we are still busy sending the initial set of routes to it.
-	<tag/FS_HAPPY/ The protocol is up and has complete routing information.
-	<tag/FS_FLUSHING/ The protocol is shutting down (it's in either <tt/PS_STOP/
-	or <tt/PS_DOWN/ state) and we're flushing all of its routes from the
-	routing tables.
-</descrip>
-
 <sect1>Functions of the protocol module
 
 <p>The protocol module provides the following functions:
diff --git a/nest/protocol.h b/nest/protocol.h
index 8c49154f..41e31a80 100644
--- a/nest/protocol.h
+++ b/nest/protocol.h
@@ -11,7 +11,9 @@
 
 #include "lib/lists.h"
 #include "lib/resource.h"
+#include "lib/event.h"
 #include "lib/timer.h"
+#include "nest/route.h"
 #include "conf/conf.h"
 
 struct iface;
@@ -22,13 +24,16 @@ struct neighbor;
 struct rta;
 struct network;
 struct proto_config;
+struct channel_limit;
+struct channel_config;
 struct config;
 struct proto;
-struct event;
+struct channel;
 struct ea_list;
 struct eattr;
 struct symbol;
 
+
 /*
  *	Routing Protocol
  */
@@ -39,9 +44,10 @@ struct protocol {
   char *template;			/* Template for automatic generation of names */
   int name_counter;			/* Counter for automatic name generation */
   int attr_class;			/* Attribute class known to this protocol */
-  int multitable;			/* Protocol handles all announce hooks itself */
   uint preference;			/* Default protocol preference */
-  uint config_size;			/* Size of protocol config */
+  uint channel_mask;			/* Mask of accepted channel types (NB_*) */
+  uint proto_size;			/* Size of protocol data structure */
+  uint config_size;			/* Size of protocol config data structure */
 
   void (*preconfig)(struct protocol *, struct config *);	/* Just before configuring */
   void (*postconfig)(struct proto_config *);			/* After configuring each instance */
@@ -62,7 +68,6 @@ struct protocol {
 void protos_build(void);
 void proto_build(struct protocol *);
 void protos_preconfig(struct config *);
-void protos_postconfig(struct config *);
 void protos_commit(struct config *new, struct config *old, int force_restart, int type);
 void protos_dump_all(void);
 
@@ -90,16 +95,12 @@ struct proto_config {
   char *name;
   char *dsc;
   int class;				/* SYM_PROTO or SYM_TEMPLATE */
+  u8 net_type;				/* Protocol network type (NET_*), 0 for undefined */
+  u8 disabled;				/* Protocol enabled/disabled by default */
   u32 debug, mrtdump;			/* Debugging bitfields, both use D_* constants */
-  unsigned preference, disabled;	/* Generic parameters */
-  int in_keep_filtered;			/* Routes rejected in import filter are kept */
   u32 router_id;			/* Protocol specific router ID */
-  struct rtable_config *table;		/* Table we're attached to */
-  struct filter *in_filter, *out_filter; /* Attached filters */
-  struct proto_limit *rx_limit;		/* Limit for receiving routes from protocol
-					   (relevant when in_keep_filtered is active) */
-  struct proto_limit *in_limit;		/* Limit for importing routes from protocol */
-  struct proto_limit *out_limit;	/* Limit for exporting routes to protocol */
+
+  list channels;			/* List of channel configs (struct channel_config) */
 
   /* Check proto_reconfigure() and proto_copy_config() after changing struct proto_config */
 
@@ -111,7 +112,6 @@ struct proto_stats {
   /* Import - from protocol to core */
   u32 imp_routes;		/* Number of routes successfully imported to the (adjacent) routing table */
   u32 filt_routes;		/* Number of routes rejected in import filter but kept in the routing table */
-  u32 pref_routes;		/* Number of routes that are preferred, sum over all routing tables */
   u32 imp_updates_received;	/* Number of route updates received */
   u32 imp_updates_invalid;	/* Number of route updates rejected as invalid */
   u32 imp_updates_filtered;	/* Number of route updates rejected by filters */
@@ -133,36 +133,34 @@ struct proto_stats {
 };
 
 struct proto {
-  node n;				/* Node in *_proto_list */
-  node glob_node;			/* Node in global proto_list */
+  node n;				/* Node in global proto_list */
   struct protocol *proto;		/* Protocol */
   struct proto_config *cf;		/* Configuration data */
   struct proto_config *cf_new;		/* Configuration we want to switch to after shutdown (NULL=delete) */
   pool *pool;				/* Pool containing local objects */
-  struct event *attn;			/* "Pay attention" event */
+  event *event;				/* Protocol event */
+
+  list channels;			/* List of channels to rtables (struct channel) */
+  struct channel *main_channel;		/* Primary channel */
+  struct rte_src *main_source;		/* Primary route source */
 
   char *name;				/* Name of this instance (== cf->name) */
   u32 debug;				/* Debugging flags */
   u32 mrtdump;				/* MRTDump flags */
-  unsigned preference;			/* Default route preference */
-  byte accept_ra_types;			/* Which types of route announcements are accepted (RA_OPTIMAL or RA_ANY) */
+  uint active_channels;			/* Number of active channels */
+  byte net_type;			/* Protocol network type (NET_*), 0 for undefined */
   byte disabled;			/* Manually disabled */
   byte proto_state;			/* Protocol state machine (PS_*, see below) */
-  byte core_state;			/* Core state machine (FS_*, see below) */
-  byte export_state;			/* Route export state (ES_*, see below) */
+  byte active;				/* From PS_START to cleanup after PS_STOP */
+  byte do_start;			/* Start actions are scheduled */
+  byte do_stop;				/* Stop actions are scheduled */
   byte reconfiguring;			/* We're shutting down due to reconfiguration */
-  byte refeeding;			/* We are refeeding (valid only if export_state == ES_FEEDING) */
-  byte flushing;			/* Protocol is flushed in current flush loop round */
   byte gr_recovery;			/* Protocol should participate in graceful restart recovery */
-  byte gr_lock;				/* Graceful restart mechanism should wait for this proto */
-  byte gr_wait;				/* Route export to protocol is postponed until graceful restart */
   byte down_sched;			/* Shutdown is scheduled for later (PDS_*) */
   byte down_code;			/* Reason for shutdown (PDC_* codes) */
-  byte merge_limit;			/* Maximal number of nexthops for RA_MERGED */
   u32 hash_key;				/* Random key used for hashing of neighbors */
   bird_clock_t last_state_change;	/* Time of last state transition */
   char *last_state_name_announced;	/* Last state name we've announced to the user */
-  struct proto_stats stats;		/* Current protocol statistics */
 
   /*
    *	General protocol hooks:
@@ -177,11 +175,11 @@ struct proto {
    *			It can construct a new rte, add private attributes and
    *			decide whether the route shall be imported: 1=yes, -1=no,
    *			0=process it through the import filter set by the user.
-   *	   reload_routes   Request protocol to reload all its routes to the core
+   *	   reload_routes   Request channel to reload all its routes to the core
    *			(using rte_update()). Returns: 0=reload cannot be done,
    *			1= reload is scheduled and will happen (asynchronously).
-   *	   feed_begin	Notify protocol about beginning of route feeding.
-   *	   feed_end	Notify protocol about finish of route feeding.
+   *	   feed_begin	Notify channel about beginning of route feeding.
+   *	   feed_end	Notify channel about finish of route feeding.
    */
 
   void (*if_notify)(struct proto *, unsigned flags, struct iface *i);
@@ -191,9 +189,9 @@ struct proto {
   struct ea_list *(*make_tmp_attrs)(struct rte *rt, struct linpool *pool);
   void (*store_tmp_attrs)(struct rte *rt, struct ea_list *attrs);
   int (*import_control)(struct proto *, struct rte **rt, struct ea_list **attrs, struct linpool *pool);
-  int (*reload_routes)(struct proto *);
-  void (*feed_begin)(struct proto *, int initial);
-  void (*feed_end)(struct proto *);
+  void (*reload_routes)(struct channel *);
+  void (*feed_begin)(struct channel *, int initial);
+  void (*feed_end)(struct channel *);
 
   /*
    *	Routing entry hooks (called only for routes belonging to this protocol):
@@ -213,14 +211,6 @@ struct proto {
   void (*rte_insert)(struct network *, struct rte *);
   void (*rte_remove)(struct network *, struct rte *);
 
-  struct rtable *table;			/* Our primary routing table */
-  struct rte_src *main_source;		/* Primary route source */
-  struct announce_hook *main_ahook;	/* Primary announcement hook */
-  struct announce_hook *ahooks;		/* Announcement hooks for this protocol */
-
-  struct fib_iterator *feed_iterator;	/* Routing table iterator used during protocol feeding */
-  struct announce_hook *feed_ahook;	/* Announce hook we currently feed */
-
   /* Hic sunt protocol-specific data */
 };
 
@@ -244,25 +234,20 @@ struct proto_spec {
 #define PDC_OUT_LIMIT_HIT	0x23	/* Route export limit reached */
 
 
-void *proto_new(struct proto_config *, unsigned size);
+void *proto_new(struct proto_config *);
 void *proto_config_new(struct protocol *, int class);
 void proto_copy_config(struct proto_config *dest, struct proto_config *src);
-void proto_request_feeding(struct proto *p);
-
-static inline void
-proto_copy_rest(struct proto_config *dest, struct proto_config *src, unsigned size)
-{ memcpy(dest + 1, src + 1, size - sizeof(struct proto_config)); }
 
 void graceful_restart_recovery(void);
 void graceful_restart_init(void);
 void graceful_restart_show_status(void);
-void proto_graceful_restart_lock(struct proto *p);
-void proto_graceful_restart_unlock(struct proto *p);
+void channel_graceful_restart_lock(struct channel *c);
+void channel_graceful_restart_unlock(struct channel *c);
 
 #define DEFAULT_GR_WAIT	240
 
-void proto_show_limit(struct proto_limit *l, const char *dsc);
-void proto_show_basic_info(struct proto *p);
+void channel_show_limit(struct channel_limit *l, const char *dsc);
+void channel_show_info(struct channel *c);
 
 void proto_cmd_show(struct proto *, uint, int);
 void proto_cmd_disable(struct proto *, uint, int);
@@ -285,7 +270,10 @@ proto_get_router_id(struct proto_config *pc)
   return pc->router_id ? pc->router_id : pc->global->router_id;
 }
 
-extern list active_proto_list;
+/* Moved from route.h to avoid dependency conflicts */
+static inline void rte_update(struct proto *p, net *net, rte *new) { rte_update2(p->main_channel, net, new, p->main_source); }
+
+extern list proto_list;
 
 /*
  *  Each protocol instance runs two different state machines:
@@ -361,16 +349,6 @@ void proto_notify_state(struct proto *p, unsigned state);
  *	as a result of received ROUTE-REFRESH request).
  */
 
-#define FS_HUNGRY	0
-#define FS_FEEDING	1	/* obsolete */
-#define FS_HAPPY	2
-#define FS_FLUSHING	3
-
-
-#define ES_DOWN		0
-#define ES_FEEDING	1
-#define ES_READY	2
-
 
 
 /*
@@ -413,6 +391,7 @@ extern struct proto_config *cf_dev_proto;
 #define PLD_OUT		2	/* Export limit */
 #define PLD_MAX		3
 
+#define PLA_NONE	0	/* No limit */
 #define PLA_WARN	1	/* Issue log warning */
 #define PLA_BLOCK	2	/* Block new routes */
 #define PLA_RESTART	4	/* Force protocol restart */
@@ -422,42 +401,176 @@ extern struct proto_config *cf_dev_proto;
 #define PLS_ACTIVE	1	/* Limit was hit */
 #define PLS_BLOCKED	2	/* Limit is active and blocking new routes */
 
-struct proto_limit {
+struct channel_limit {
   u32 limit;			/* Maximum number of prefixes */
-  byte action;			/* Action to take (PLA_*) */
-  byte state;			/* State of limit (PLS_*) */
+  u8 action;			/* Action to take (PLA_*) */
+  u8 state;			/* State of limit (PLS_*) */
 };
 
-void proto_notify_limit(struct announce_hook *ah, struct proto_limit *l, int dir, u32 rt_count);
-void proto_verify_limits(struct announce_hook *ah);
-
-static inline void
-proto_reset_limit(struct proto_limit *l)
-{
-  if (l)
-    l->state = PLS_INITIAL;
-}
+void channel_notify_limit(struct channel *c, struct channel_limit *l, int dir, u32 rt_count);
 
 
 /*
- *	Route Announcement Hook
+ *	Channels
  */
 
-struct announce_hook {
+struct channel_class {
+  uint channel_size;			/* Size of channel data structure */
+  uint config_size;			/* Size of channel config data structure */
+
+  struct channel * (*init)(struct channel *, struct channel_config *);	/* Create new instance */
+  int (*reconfigure)(struct channel *, struct channel_config *);	/* Try to reconfigure instance, returns success */
+  int (*start)(struct channel *);	/* Start the instance */
+  int (*shutdown)(struct channel *);	/* Stop the instance */
+
+  void (*copy_config)(struct channel_config *, struct channel_config *); /* Copy config from given channel instance */
+#if 0
+  void (*preconfig)(struct protocol *, struct config *);	/* Just before configuring */
+  void (*postconfig)(struct proto_config *);			/* After configuring each instance */
+
+
+  void (*dump)(struct proto *);			/* Debugging dump */
+  void (*dump_attrs)(struct rte *);		/* Dump protocol-dependent attributes */
+  void (*cleanup)(struct proto *);		/* Called after shutdown when protocol became hungry/down */
+  void (*get_status)(struct proto *, byte *buf); /* Get instance status (for `show protocols' command) */
+  void (*get_route_info)(struct rte *, byte *buf, struct ea_list *attrs); /* Get route information (for `show route' command) */
+  int (*get_attr)(struct eattr *, byte *buf, int buflen);	/* ASCIIfy dynamic attribute (returns GA_*) */
+  void (*show_proto_info)(struct proto *);	/* Show protocol info (for `show protocols all' command) */
+
+#endif
+};
+
+struct channel_config {
   node n;
-  struct rtable *table;
+  const char *name;
+  const struct channel_class *channel;
+
+  struct rtable_config *table;		/* Table we're attached to */
+  struct filter *in_filter, *out_filter; /* Attached filters */
+  struct channel_limit rx_limit;	/* Limit for receiving routes from protocol
+					   (relevant when in_keep_filtered is active) */
+  struct channel_limit in_limit;	/* Limit for importing routes from protocol */
+  struct channel_limit out_limit;	/* Limit for exporting routes to protocol */
+
+  u8 net_type;				/* Routing table network type (NET_*), 0 for undefined */
+  u8 ra_mode;				/* Mode of received route advertisements (RA_*) */
+  u16 preference;			/* Default route preference */
+  u8 merge_limit;			/* Maximal number of nexthops for RA_MERGED */
+  u8 in_keep_filtered;			/* Routes rejected in import filter are kept */
+};
+
+struct channel {
+  node n;				/* Node in proto->channels */
+  node table_node;			/* Node in table->channels */
+
+  const char *name;			/* Channel name (may be NULL) */
+  const struct channel_class *channel;
   struct proto *proto;
+
+  struct rtable *table;
   struct filter *in_filter;		/* Input filter */
   struct filter *out_filter;		/* Output filter */
-  struct proto_limit *rx_limit;		/* Receive limit (for in_keep_filtered) */
-  struct proto_limit *in_limit;		/* Input limit */
-  struct proto_limit *out_limit;	/* Output limit */
-  struct proto_stats *stats;		/* Per-table protocol statistics */
-  struct announce_hook *next;		/* Next hook for the same protocol */
-  int in_keep_filtered;			/* Routes rejected in import filter are kept */
+  struct channel_limit rx_limit;	/* Receive limit (for in_keep_filtered) */
+  struct channel_limit in_limit;	/* Input limit */
+  struct channel_limit out_limit;	/* Output limit */
+
+  struct event *feed_event;		/* Event responsible for feeding */
+  struct fib_iterator feed_fit;		/* Routing table iterator used during feeding */
+  struct proto_stats stats;		/* Per-channel protocol statistics */
+
+  u8 net_type;				/* Routing table network type (NET_*), 0 for undefined */
+  u8 ra_mode;				/* Mode of received route advertisements (RA_*) */
+  u16 preference;			/* Default route preference */
+  u8 merge_limit;			/* Maximal number of nexthops for RA_MERGED */
+  u8 in_keep_filtered;			/* Routes rejected in import filter are kept */
+  u8 disabled;
+
+  u8 channel_state;
+  u8 export_state;			/* Route export state (ES_*, see below) */
+  u8 feed_active;
+  u8 flush_active;
+  u8 refeeding;				/* We are refeeding (valid only if export_state == ES_FEEDING) */
+  u8 reloadable;			/* Hook reload_routes() is allowed on the channel */
+  u8 gr_lock;				/* Graceful restart mechanism should wait for this channel */
+  u8 gr_wait;				/* Route export to channel is postponed until graceful restart */
+
+  bird_clock_t last_state_change;	/* Time of last state transition */
 };
 
-struct announce_hook *proto_add_announce_hook(struct proto *p, struct rtable *t, struct proto_stats *stats);
-struct announce_hook *proto_find_announce_hook(struct proto *p, struct rtable *t);
+
+/*
+ * Channel states
+ *
+ * CS_DOWN - The initial and the final state of a channel. There is no route
+ * exchange between the protocol and the table. Channel is not counted as
+ * active. Channel keeps a ptr to the table, but do not lock the table and is
+ * not linked in the table. Generally, new closed channels are created in
+ * protocols' init() hooks. The protocol is expected to explicitly activate its
+ * channels (by calling channel_init() or channel_open()).
+ *
+ * CS_START - The channel as a connection between the protocol and the table is
+ * initialized (counted as active by the protocol, linked in the table and keeps
+ * the table locked), but there is no current route exchange. There still may be
+ * routes associated with the channel in the routing table if the channel falls
+ * to CS_START from CS_UP. Generally, channels are initialized in protocols'
+ * start() hooks when going to PS_START.
+ *
+ * CS_UP - The channel is initialized and the route exchange is allowed. Note
+ * that even in CS_UP state, route export may still be down (ES_DOWN) by the
+ * core decision (e.g. waiting for table convergence after graceful restart).
+ * I.e., the protocol decides to open the channel but the core decides to start
+ * route export. Route import (caused by rte_update() from the protocol) is not
+ * restricted by that and is on volition of the protocol. Generally, channels
+ * are opened in protocols' start() hooks when going to PS_UP.
+ *
+ * CS_FLUSHING - The transitional state between initialized channel and closed
+ * channel. The channel is still initialized, but no route exchange is allowed.
+ * Instead, the associated table is running flush loop to remove routes imported
+ * through the channel. After that, the channel changes state to CS_DOWN and
+ * is detached from the table (the table is unlocked and the channel is unlinked
+ * from it). Unlike other states, the CS_FLUSHING state is not explicitly
+ * entered or left by the protocol. A protocol may request to close a channel
+ * (by calling channel_close()), which causes the channel to change state to
+ * CS_FLUSHING and later to CS_DOWN. Also note that channels are closed
+ * automatically by the core when the protocol is going down.
+ *
+ * Allowed transitions:
+ *
+ * CS_DOWN	-> CS_START / CS_UP
+ * CS_START	-> CS_UP / CS_FLUSHING
+ * CS_UP	-> CS_START / CS_FLUSHING
+ * CS_FLUSHING	-> CS_DOWN (automatic)
+ */
+
+#define CS_DOWN		0
+#define CS_START	1
+#define CS_UP		2
+#define CS_FLUSHING	3
+
+#define ES_DOWN		0
+#define ES_FEEDING	1
+#define ES_READY	2
+
+
+struct channel_config *proto_cf_find_channel(struct proto_config *p, uint net_type);
+static inline struct channel_config *proto_cf_main_channel(struct proto_config *pc)
+{ struct channel_config *cc = HEAD(pc->channels); return NODE_VALID(cc) ? cc : NULL; }
+
+struct channel *proto_find_channel_by_table(struct proto *p, struct rtable *t);
+struct channel *proto_add_channel(struct proto *p, struct channel_config *cf);
+int proto_configure_channel(struct proto *p, struct channel **c, struct channel_config *cf);
+
+void channel_set_state(struct channel *c, uint state);
+
+/*
+static inline void channel_init(struct channel *c) { channel_set_state(c, CS_START); }
+static inline void channel_open(struct channel *c) { channel_set_state(c, CS_UP); }
+static inline void channel_close(struct channel *c) { channel_set_state(c, CS_FLUSHING); }
+*/
+
+void channel_request_feeding(struct channel *c);
+void *channel_config_new(const struct channel_class *cc, uint net_type, struct proto_config *proto);
+int channel_reconfigure(struct channel *c, struct channel_config *cf);
+
 
 #endif
diff --git a/nest/route.h b/nest/route.h
index eba3d9b0..b68f614f 100644
--- a/nest/route.h
+++ b/nest/route.h
@@ -12,10 +12,12 @@
 #include "lib/lists.h"
 #include "lib/resource.h"
 #include "lib/timer.h"
-#include "nest/protocol.h"
+//#include "nest/protocol.h"
 
+struct ea_list;
 struct protocol;
 struct proto;
+struct rte_src;
 struct symbol;
 struct filter;
 struct cli;
@@ -57,8 +59,8 @@ struct fib {
   uint hash_order;			/* Binary logarithm of hash_size */
   uint hash_shift;			/* 32 - hash_order */
   uint addr_type;			/* Type of address data stored in fib (NET_*) */
-  uint node_size;	/* XXXX */
-  uint node_offset;	/* XXXX */
+  uint node_size;			/* FIB node size, 0 for nonuniform */
+  uint node_offset;			/* Offset of fib_node struct inside of user data */
   uint entries;				/* Number of entries */
   uint entries_min, entries_max;	/* Entry count limits (else start rehashing) */
   fib_init_fn init;			/* Constructor */
@@ -146,7 +148,7 @@ typedef struct rtable {
   node n;				/* Node in list of all tables */
   struct fib fib;
   char *name;				/* Name of this table */
-  list hooks;				/* List of announcement hooks */
+  list channels;			/* List of attached channels (struct channel) */
   uint addr_type;			/* Type of address data stored in table (NET_*) */
   int pipe_busy;			/* Pipe loop detection */
   int use_count;			/* Number of protocols using this table */
@@ -159,7 +161,6 @@ typedef struct rtable {
   struct event *rt_event;		/* Routing table event */
   int gc_counter;			/* Number of operations since last GC */
   bird_clock_t gc_time;			/* Time of last GC */
-  byte gc_scheduled;			/* GC is scheduled */
   byte prune_state;			/* Table prune state, 1 -> scheduled, 2-> running */
   byte hcu_scheduled;			/* Hostcache update is scheduled */
   byte nhu_state;			/* Next Hop Update state */
@@ -167,10 +168,6 @@ typedef struct rtable {
   struct fib_iterator nhu_fit;		/* Next Hop Update FIB iterator */
 } rtable;
 
-#define RPS_NONE	0
-#define RPS_SCHEDULED	1
-#define RPS_RUNNING	2
-
 typedef struct network {
   struct rte *routes;			/* Available routes for this network */
   struct fib_node n;			/* FIB flags reserved for kernel syncer */
@@ -206,7 +203,7 @@ struct hostentry {
 typedef struct rte {
   struct rte *next;
   net *net;				/* Network this RTE belongs to */
-  struct announce_hook *sender;		/* Announce hook used to send the route to the routing table */
+  struct channel *sender;		/* Channel used to send the route to the routing table */
   struct rta *attrs;			/* Attributes of this route */
   byte flags;				/* Flags (REF_...) */
   byte pflags;				/* Protocol-specific flags */
@@ -279,13 +276,14 @@ static inline net *net_get(rtable *tab, const net_addr *addr) { return (net *) f
 
 rte *rte_find(net *net, struct rte_src *src);
 rte *rte_get_temp(struct rta *);
-void rte_update2(struct announce_hook *ah, net *net, rte *new, struct rte_src *src);
-static inline void rte_update(struct proto *p, net *net, rte *new) { rte_update2(p->main_ahook, net, new, p->main_source); }
+void rte_update2(struct channel *c, net *net, rte *new, struct rte_src *src);
+/* rte_update() moved to protocol.h to avoid dependency conflicts */
 void rte_discard(rtable *tab, rte *old);
 int rt_examine(rtable *t, net_addr *a, struct proto *p, struct filter *filter);
-rte *rt_export_merged(struct announce_hook *ah, net *net, rte **rt_free, struct ea_list **tmpa, int silent);
-void rt_refresh_begin(rtable *t, struct announce_hook *ah);
-void rt_refresh_end(rtable *t, struct announce_hook *ah);
+rte *rt_export_merged(struct channel *c, net *net, rte **rt_free, struct ea_list **tmpa, int silent);
+void rt_refresh_begin(rtable *t, struct channel *c);
+void rt_refresh_end(rtable *t, struct channel *c);
+void rt_schedule_prune(rtable *t);
 void rte_dump(rte *);
 void rte_free(rte *);
 rte *rte_do_cow(rte *);
@@ -293,19 +291,10 @@ static inline rte * rte_cow(rte *r) { return (r->flags & REF_COW) ? rte_do_cow(r
 rte *rte_cow_rta(rte *r, linpool *lp);
 void rt_dump(rtable *);
 void rt_dump_all(void);
-int rt_feed_baby(struct proto *p);
-void rt_feed_baby_abort(struct proto *p);
-int rt_prune_loop(void);
+int rt_feed_channel(struct channel *c);
+void rt_feed_channel_abort(struct channel *c);
 struct rtable_config *rt_new_table(struct symbol *s, uint addr_type);
 
-static inline void
-rt_mark_for_prune(rtable *tab)
-{
-  if (tab->prune_state == RPS_RUNNING)
-    fit_get(&tab->fib, &tab->prune_fit);
-
-  tab->prune_state = RPS_SCHEDULED;
-}
 
 struct rt_show_data {
   net_addr *addr;
@@ -315,6 +304,7 @@ struct rt_show_data {
   struct fib_iterator fit;
   struct proto *show_protocol;
   struct proto *export_protocol;
+  struct channel *export_channel;
   int export_mode, primary_only, filtered;
   struct config *running_on_config;
   int net_counter, rt_counter, show_counter;
@@ -561,7 +551,6 @@ extern struct protocol *attr_class_to_protocol[EAP_MAX];
 #define DEF_PREF_OSPF		150	/* OSPF intra-area, inter-area and type 1 external routes */
 #define DEF_PREF_RIP		120	/* RIP */
 #define DEF_PREF_BGP		100	/* BGP */
-#define DEF_PREF_PIPE		70	/* Routes piped from other tables */
 #define DEF_PREF_INHERITED	10	/* Routes inherited from other routing daemons */
 
 /*
diff --git a/nest/rt-dev.c b/nest/rt-dev.c
index f94933d5..17737853 100644
--- a/nest/rt-dev.c
+++ b/nest/rt-dev.c
@@ -24,13 +24,16 @@
 #include "lib/resource.h"
 #include "lib/string.h"
 
+
 static void
-dev_ifa_notify(struct proto *p, unsigned c, struct ifa *ad)
+dev_ifa_notify(struct proto *P, uint flags, struct ifa *ad)
 {
-  struct rt_dev_config *P = (void *) p->cf;
+  struct rt_dev_proto *p = (void *) P;
+  struct rt_dev_config *cf = (void *) P->cf;
+  struct channel *c;
 
-  if (!EMPTY_LIST(P->iface_list) &&
-      !iface_patt_find(&P->iface_list, ad->iface, ad->iface->addr))
+  if (!EMPTY_LIST(cf->iface_list) &&
+      !iface_patt_find(&cf->iface_list, ad->iface, ad->iface->addr))
     /* Empty list is automagically treated as "*" */
     return;
 
@@ -40,12 +43,22 @@ dev_ifa_notify(struct proto *p, unsigned c, struct ifa *ad)
   if (ad->scope <= SCOPE_LINK)
     return;
 
-  if (c & IF_CHANGE_DOWN)
+  if (ad->prefix.type == NET_IP4)
+    c = p->ip4_channel;
+  else if (ad->prefix.type == NET_IP6)
+    c = p->ip6_channel;
+  else
+    return;
+
+  if (!c)
+    return;
+
+  if (flags & IF_CHANGE_DOWN)
     {
       net *n;
 
       DBG("dev_if_notify: %s:%I going down\n", ad->iface->name, ad->ip);
-      n = net_find(p->table, &ad->prefix);
+      n = net_find(c->table, &ad->prefix);
       if (!n)
 	{
 	  DBG("dev_if_notify: device shutdown: prefix not found\n");
@@ -53,10 +66,10 @@ dev_ifa_notify(struct proto *p, unsigned c, struct ifa *ad)
 	}
 
       /* Use iface ID as local source ID */
-      struct rte_src *src = rt_get_source(p, ad->iface->index);
-      rte_update2(p->main_ahook, n, NULL, src);
+      struct rte_src *src = rt_get_source(P, ad->iface->index);
+      rte_update2(c, n, NULL, src);
     }
-  else if (c & IF_CHANGE_UP)
+  else if (flags & IF_CHANGE_UP)
     {
       rta *a;
       net *n;
@@ -65,7 +78,7 @@ dev_ifa_notify(struct proto *p, unsigned c, struct ifa *ad)
       DBG("dev_if_notify: %s:%I going up\n", ad->iface->name, ad->ip);
 
       /* Use iface ID as local source ID */
-      struct rte_src *src = rt_get_source(p, ad->iface->index);
+      struct rte_src *src = rt_get_source(P, ad->iface->index);
 
       rta a0 = {
 	.src = src,
@@ -77,37 +90,51 @@ dev_ifa_notify(struct proto *p, unsigned c, struct ifa *ad)
       };
 
       a = rta_lookup(&a0);
-      n = net_get(p->table, &ad->prefix);
+      n = net_get(c->table, &ad->prefix);
       e = rte_get_temp(a);
       e->net = n;
       e->pflags = 0;
-      rte_update2(p->main_ahook, n, e, src);
+      rte_update2(c, n, e, src);
     }
 }
 
 static struct proto *
-dev_init(struct proto_config *c)
+dev_init(struct proto_config *CF)
 {
-  struct proto *p = proto_new(c, sizeof(struct proto));
+  struct proto *P = proto_new(CF);
+  struct rt_dev_proto *p = (void *) P;
+  // struct rt_dev_config *cf = (void *) CF;
 
-  p->ifa_notify = dev_ifa_notify;
-  return p;
+  proto_configure_channel(P, &p->ip4_channel, proto_cf_find_channel(CF, NET_IP4));
+  proto_configure_channel(P, &p->ip6_channel, proto_cf_find_channel(CF, NET_IP6));
+
+  P->ifa_notify = dev_ifa_notify;
+
+  return P;
 }
 
 static int
-dev_reconfigure(struct proto *p, struct proto_config *new)
+dev_reconfigure(struct proto *P, struct proto_config *CF)
 {
-  struct rt_dev_config *o = (struct rt_dev_config *) p->cf;
-  struct rt_dev_config *n = (struct rt_dev_config *) new;
+  struct rt_dev_proto *p = (void *) P;
+  struct rt_dev_config *o = (void *) P->cf;
+  struct rt_dev_config *n = (void *) CF;
+
+  if (!iface_patts_equal(&o->iface_list, &n->iface_list, NULL))
+    return 0;
+
+  return
+    proto_configure_channel(P, &p->ip4_channel, proto_cf_find_channel(CF, NET_IP4)) &&
+    proto_configure_channel(P, &p->ip6_channel, proto_cf_find_channel(CF, NET_IP6));
 
-  return iface_patts_equal(&o->iface_list, &n->iface_list, NULL);
+  return 1;
 }
 
 static void
 dev_copy_config(struct proto_config *dest, struct proto_config *src)
 {
-  struct rt_dev_config *d = (struct rt_dev_config *) dest;
-  struct rt_dev_config *s = (struct rt_dev_config *) src;
+  struct rt_dev_config *d = (void *) dest;
+  struct rt_dev_config *s = (void *) src;
 
   /*
    * We copy iface_list as ifaces can be shared by more direct protocols.
@@ -120,7 +147,9 @@ dev_copy_config(struct proto_config *dest, struct proto_config *src)
 struct protocol proto_device = {
   .name = 		"Direct",
   .template = 		"direct%d",
-  .preference = 	DEF_PREF_DIRECT,
+  .preference =		DEF_PREF_DIRECT,
+  .channel_mask =	NB_IP,
+  .proto_size =		sizeof(struct rt_dev_proto),
   .config_size =	sizeof(struct rt_dev_config),
   .init = 		dev_init,
   .reconfigure = 	dev_reconfigure,
diff --git a/nest/rt-dev.h b/nest/rt-dev.h
index c36d0742..c9012336 100644
--- a/nest/rt-dev.h
+++ b/nest/rt-dev.h
@@ -14,4 +14,10 @@ struct rt_dev_config {
   list iface_list;		/* list of struct iface_patt */
 };
 
+struct rt_dev_proto {
+  struct proto p;
+  struct channel *ip4_channel;
+  struct channel *ip6_channel;
+};
+
 #endif
diff --git a/nest/rt-table.c b/nest/rt-table.c
index f164ecd9..88f60bdf 100644
--- a/nest/rt-table.c
+++ b/nest/rt-table.c
@@ -55,9 +55,7 @@ static void rt_free_hostcache(rtable *tab);
 static void rt_notify_hostcache(rtable *tab, net *net);
 static void rt_update_hostcache(rtable *tab);
 static void rt_next_hop_update(rtable *tab);
-static inline int rt_prune_table(rtable *tab);
-static inline void rt_schedule_gc(rtable *tab);
-static inline void rt_schedule_prune(rtable *tab);
+static inline void rt_prune_table(rtable *tab);
 
 
 static inline struct ea_list *
@@ -230,7 +228,7 @@ rte_get_temp(rta *a)
 
   e->attrs = a;
   e->flags = 0;
-  e->pref = a->src->proto->preference;
+  e->pref = 0;
   return e;
 }
 
@@ -349,11 +347,11 @@ rte_trace_out(uint flag, struct proto *p, rte *e, char *msg)
 }
 
 static rte *
-export_filter(struct announce_hook *ah, rte *rt0, rte **rt_free, ea_list **tmpa, int silent)
+export_filter(struct channel *c, rte *rt0, rte **rt_free, ea_list **tmpa, int silent)
 {
-  struct proto *p = ah->proto;
-  struct filter *filter = ah->out_filter;
-  struct proto_stats *stats = ah->stats;
+  struct proto *p = c->proto;
+  struct filter *filter = c->out_filter;
+  struct proto_stats *stats = &c->stats;
   ea_list *tmpb = NULL;
   rte *rt;
   int v;
@@ -409,10 +407,10 @@ export_filter(struct announce_hook *ah, rte *rt0, rte **rt_free, ea_list **tmpa,
 }
 
 static void
-do_rt_notify(struct announce_hook *ah, net *net, rte *new, rte *old, ea_list *tmpa, int refeed)
+do_rt_notify(struct channel *c, net *net, rte *new, rte *old, ea_list *tmpa, int refeed)
 {
-  struct proto *p = ah->proto;
-  struct proto_stats *stats = ah->stats;
+  struct proto *p = c->proto;
+  struct proto_stats *stats = &c->stats;
 
 
   /*
@@ -442,11 +440,11 @@ do_rt_notify(struct announce_hook *ah, net *net, rte *new, rte *old, ea_list *tm
    * also non-new updates (contrary to import blocking).
    */
 
-  struct proto_limit *l = ah->out_limit;
-  if (l && new)
+  struct channel_limit *l = &c->out_limit;
+  if (l->action && new)
     {
       if ((!old || refeed) && (stats->exp_routes >= l->limit))
-	proto_notify_limit(ah, l, PLD_OUT, stats->exp_routes);
+	channel_notify_limit(c, l, PLD_OUT, stats->exp_routes);
 
       if (l->state == PLS_BLOCKED)
 	{
@@ -483,25 +481,24 @@ do_rt_notify(struct announce_hook *ah, net *net, rte *new, rte *old, ea_list *tm
 	rte_trace_out(D_ROUTES, p, old, "removed");
     }
   if (!new)
-    p->rt_notify(p, ah->table, net, NULL, old, NULL);
+    p->rt_notify(p, c->table, net, NULL, old, NULL);
   else if (tmpa)
     {
       ea_list *t = tmpa;
       while (t->next)
 	t = t->next;
       t->next = new->attrs->eattrs;
-      p->rt_notify(p, ah->table, net, new, old, tmpa);
+      p->rt_notify(p, c->table, net, new, old, tmpa);
       t->next = NULL;
     }
   else
-    p->rt_notify(p, ah->table, net, new, old, new->attrs->eattrs);
+    p->rt_notify(p, c->table, net, new, old, new->attrs->eattrs);
 }
 
 static void
-rt_notify_basic(struct announce_hook *ah, net *net, rte *new0, rte *old0, int refeed)
+rt_notify_basic(struct channel *c, net *net, rte *new0, rte *old0, int refeed)
 {
-  struct proto *p = ah->proto;
-  struct proto_stats *stats = ah->stats;
+  struct proto *p = c->proto;
 
   rte *new = new0;
   rte *old = old0;
@@ -510,9 +507,9 @@ rt_notify_basic(struct announce_hook *ah, net *net, rte *new0, rte *old0, int re
   ea_list *tmpa = NULL;
 
   if (new)
-    stats->exp_updates_received++;
+    c->stats.exp_updates_received++;
   else
-    stats->exp_withdraws_received++;
+    c->stats.exp_withdraws_received++;
 
   /*
    * This is a tricky part - we don't know whether route 'old' was
@@ -535,10 +532,10 @@ rt_notify_basic(struct announce_hook *ah, net *net, rte *new0, rte *old0, int re
    */
 
   if (new)
-    new = export_filter(ah, new, &new_free, &tmpa, 0);
+    new = export_filter(c, new, &new_free, &tmpa, 0);
 
   if (old && !refeed)
-    old = export_filter(ah, old, &old_free, NULL, 1);
+    old = export_filter(c, old, &old_free, NULL, 1);
 
   if (!new && !old)
   {
@@ -555,13 +552,13 @@ rt_notify_basic(struct announce_hook *ah, net *net, rte *new0, rte *old0, int re
 
 #ifdef CONFIG_PIPE
     if ((p->proto == &proto_pipe) && !new0 && (p != old0->sender->proto))
-      p->rt_notify(p, ah->table, net, NULL, old0, NULL);
+      p->rt_notify(p, c->table, net, NULL, old0, NULL);
 #endif
 
     return;
   }
 
-  do_rt_notify(ah, net, new, old, tmpa, refeed);
+  do_rt_notify(c, net, new, old, tmpa, refeed);
 
   /* Discard temporary rte's */
   if (new_free)
@@ -571,10 +568,9 @@ rt_notify_basic(struct announce_hook *ah, net *net, rte *new0, rte *old0, int re
 }
 
 static void
-rt_notify_accepted(struct announce_hook *ah, net *net, rte *new_changed, rte *old_changed, rte *before_old, int feed)
+rt_notify_accepted(struct channel *c, net *net, rte *new_changed, rte *old_changed, rte *before_old, int feed)
 {
-  // struct proto *p = ah->proto;
-  struct proto_stats *stats = ah->stats;
+  // struct proto *p = c->proto;
 
   rte *r;
   rte *new_best = NULL;
@@ -592,14 +588,14 @@ rt_notify_accepted(struct announce_hook *ah, net *net, rte *new_changed, rte *ol
      was not valid, caller must use NULL for both old_changed and before_old. */
 
   if (new_changed)
-    stats->exp_updates_received++;
+    c->stats.exp_updates_received++;
   else
-    stats->exp_withdraws_received++;
+    c->stats.exp_withdraws_received++;
 
   /* First, find the new_best route - first accepted by filters */
   for (r=net->routes; rte_is_valid(r); r=r->next)
     {
-      if (new_best = export_filter(ah, r, &new_free, &tmpa, 0))
+      if (new_best = export_filter(c, r, &new_free, &tmpa, 0))
 	break;
 
       /* Note if we walked around the position of old_changed route */
@@ -650,7 +646,7 @@ rt_notify_accepted(struct announce_hook *ah, net *net, rte *new_changed, rte *ol
 
   /* First case */
   if (old_meet)
-    if (old_best = export_filter(ah, old_changed, &old_free, NULL, 1))
+    if (old_best = export_filter(c, old_changed, &old_free, NULL, 1))
       goto found;
 
   /* Second case */
@@ -668,18 +664,18 @@ rt_notify_accepted(struct announce_hook *ah, net *net, rte *new_changed, rte *ol
   /* Fourth case */
   for (r=r->next; rte_is_valid(r); r=r->next)
     {
-      if (old_best = export_filter(ah, r, &old_free, NULL, 1))
+      if (old_best = export_filter(c, r, &old_free, NULL, 1))
 	goto found;
 
       if (r == before_old)
-	if (old_best = export_filter(ah, old_changed, &old_free, NULL, 1))
+	if (old_best = export_filter(c, old_changed, &old_free, NULL, 1))
 	  goto found;
     }
 
   /* Implicitly, old_best is NULL and new_best is non-NULL */
 
  found:
-  do_rt_notify(ah, net, new_best, old_best, tmpa, (feed == 2));
+  do_rt_notify(c, net, new_best, old_best, tmpa, (feed == 2));
 
   /* Discard temporary rte's */
   if (new_free)
@@ -698,9 +694,9 @@ mpnh_merge_rta(struct mpnh *nhs, rta *a, int max)
 }
 
 rte *
-rt_export_merged(struct announce_hook *ah, net *net, rte **rt_free, ea_list **tmpa, int silent)
+rt_export_merged(struct channel *c, net *net, rte **rt_free, ea_list **tmpa, int silent)
 {
-  // struct proto *p = ah->proto;
+  // struct proto *p = c->proto;
   struct mpnh *nhs = NULL;
   rte *best0, *best, *rt0, *rt, *tmp;
 
@@ -710,7 +706,7 @@ rt_export_merged(struct announce_hook *ah, net *net, rte **rt_free, ea_list **tm
   if (!rte_is_valid(best0))
     return NULL;
 
-  best = export_filter(ah, best0, rt_free, tmpa, silent);
+  best = export_filter(c, best0, rt_free, tmpa, silent);
 
   if (!best || !rte_is_reachable(best))
     return best;
@@ -720,13 +716,13 @@ rt_export_merged(struct announce_hook *ah, net *net, rte **rt_free, ea_list **tm
     if (!rte_mergable(best0, rt0))
       continue;
 
-    rt = export_filter(ah, rt0, &tmp, NULL, 1);
+    rt = export_filter(c, rt0, &tmp, NULL, 1);
 
     if (!rt)
       continue;
 
     if (rte_is_reachable(rt))
-      nhs = mpnh_merge_rta(nhs, rt->attrs, ah->proto->merge_limit);
+      nhs = mpnh_merge_rta(nhs, rt->attrs, c->merge_limit);
 
     if (tmp)
       rte_free(tmp);
@@ -734,7 +730,7 @@ rt_export_merged(struct announce_hook *ah, net *net, rte **rt_free, ea_list **tm
 
   if (nhs)
   {
-    nhs = mpnh_merge_rta(nhs, best->attrs, ah->proto->merge_limit);
+    nhs = mpnh_merge_rta(nhs, best->attrs, c->merge_limit);
 
     if (nhs->next)
     {
@@ -752,10 +748,10 @@ rt_export_merged(struct announce_hook *ah, net *net, rte **rt_free, ea_list **tm
 
 
 static void
-rt_notify_merged(struct announce_hook *ah, net *net, rte *new_changed, rte *old_changed,
+rt_notify_merged(struct channel *c, net *net, rte *new_changed, rte *old_changed,
 		 rte *new_best, rte*old_best, int refeed)
 {
-  // struct proto *p = ah->proto;
+  // struct proto *p = c->proto;
 
   rte *new_best_free = NULL;
   rte *old_best_free = NULL;
@@ -773,31 +769,31 @@ rt_notify_merged(struct announce_hook *ah, net *net, rte *new_changed, rte *old_
   if ((new_best == old_best) && !refeed)
   {
     new_changed = rte_mergable(new_best, new_changed) ?
-      export_filter(ah, new_changed, &new_changed_free, NULL, 1) : NULL;
+      export_filter(c, new_changed, &new_changed_free, NULL, 1) : NULL;
 
     old_changed = rte_mergable(old_best, old_changed) ?
-      export_filter(ah, old_changed, &old_changed_free, NULL, 1) : NULL;
+      export_filter(c, old_changed, &old_changed_free, NULL, 1) : NULL;
 
     if (!new_changed && !old_changed)
       return;
   }
 
   if (new_best)
-    ah->stats->exp_updates_received++;
+    c->stats.exp_updates_received++;
   else
-    ah->stats->exp_withdraws_received++;
+    c->stats.exp_withdraws_received++;
 
   /* Prepare new merged route */
   if (new_best)
-    new_best = rt_export_merged(ah, net, &new_best_free, &tmpa, 0);
+    new_best = rt_export_merged(c, net, &new_best_free, &tmpa, 0);
 
   /* Prepare old merged route (without proper merged next hops) */
   /* There are some issues with running filter on old route - see rt_notify_basic() */
   if (old_best && !refeed)
-    old_best = export_filter(ah, old_best, &old_best_free, NULL, 1);
+    old_best = export_filter(c, old_best, &old_best_free, NULL, 1);
 
   if (new_best || old_best)
-    do_rt_notify(ah, net, new_best, old_best, tmpa, refeed);
+    do_rt_notify(c, net, new_best, old_best, tmpa, refeed);
 
   /* Discard temporary rte's */
   if (new_best_free)
@@ -858,28 +854,22 @@ rte_announce(rtable *tab, unsigned type, net *net, rte *new, rte *old,
   if (!old && !new)
     return;
 
-  if (type == RA_OPTIMAL)
-    {
-      if (new)
-	new->attrs->src->proto->stats.pref_routes++;
-      if (old)
-	old->attrs->src->proto->stats.pref_routes--;
+  if ((type == RA_OPTIMAL) && tab->hostcache)
+    rt_notify_hostcache(tab, net);
 
-      if (tab->hostcache)
-	rt_notify_hostcache(tab, net);
-    }
-
-  struct announce_hook *a;
-  WALK_LIST(a, tab->hooks)
+  struct channel *c; node *n;
+  WALK_LIST2(c, n, tab->channels, table_node)
     {
-      ASSERT(a->proto->export_state != ES_DOWN);
-      if (a->proto->accept_ra_types == type)
+      if (c->export_state == ES_DOWN)
+	continue;
+
+      if (c->ra_mode == type)
 	if (type == RA_ACCEPTED)
-	  rt_notify_accepted(a, net, new, old, before_old, 0);
+	  rt_notify_accepted(c, net, new, old, before_old, 0);
 	else if (type == RA_MERGED)
-	  rt_notify_merged(a, net, new, old, new_best, old_best, 0);
+	  rt_notify_merged(c, net, new, old, new_best, old_best, 0);
 	else
-	  rt_notify_basic(a, net, new, old, 0);
+	  rt_notify_basic(c, net, new, old, 0);
     }
 }
 
@@ -943,11 +933,11 @@ rte_same(rte *x, rte *y)
 static inline int rte_is_ok(rte *e) { return e && !rte_is_filtered(e); }
 
 static void
-rte_recalculate(struct announce_hook *ah, net *net, rte *new, struct rte_src *src)
+rte_recalculate(struct channel *c, net *net, rte *new, struct rte_src *src)
 {
-  struct proto *p = ah->proto;
-  struct rtable *table = ah->table;
-  struct proto_stats *stats = ah->stats;
+  struct proto *p = c->proto;
+  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;
@@ -1011,13 +1001,13 @@ rte_recalculate(struct announce_hook *ah, net *net, rte *new, struct rte_src *sr
   int new_ok = rte_is_ok(new);
   int old_ok = rte_is_ok(old);
 
-  struct proto_limit *l = ah->rx_limit;
-  if (l && !old && new)
+  struct channel_limit *l = &c->rx_limit;
+  if (l->action && !old && new)
     {
       u32 all_routes = stats->imp_routes + stats->filt_routes;
 
       if (all_routes >= l->limit)
-	proto_notify_limit(ah, l, PLD_RX, all_routes);
+	channel_notify_limit(c, l, PLD_RX, all_routes);
 
       if (l->state == PLS_BLOCKED)
 	{
@@ -1031,11 +1021,11 @@ rte_recalculate(struct announce_hook *ah, net *net, rte *new, struct rte_src *sr
 	}
     }
 
-  l = ah->in_limit;
-  if (l && !old_ok && new_ok)
+  l = &c->in_limit;
+  if (l->action && !old_ok && new_ok)
     {
       if (stats->imp_routes >= l->limit)
-	proto_notify_limit(ah, l, PLD_IN, stats->imp_routes);
+	channel_notify_limit(c, l, PLD_IN, stats->imp_routes);
 
       if (l->state == PLS_BLOCKED)
 	{
@@ -1049,13 +1039,13 @@ rte_recalculate(struct announce_hook *ah, net *net, rte *new, struct rte_src *sr
 	  stats->imp_updates_ignored++;
 	  rte_trace_in(D_FILTERS, p, new, "ignored [limit]");
 
-	  if (ah->in_keep_filtered)
+	  if (c->in_keep_filtered)
 	    new->flags |= REF_FILTERED;
 	  else
 	    { rte_free_quick(new); new = NULL; }
 
 	  /* Note that old && !new could be possible when
-	     ah->in_keep_filtered changed in the recent past. */
+	     c->in_keep_filtered changed in the recent past. */
 
 	  if (!old && !new)
 	    return;
@@ -1188,7 +1178,7 @@ rte_recalculate(struct announce_hook *ah, net *net, rte *new, struct rte_src *sr
   if (!net->routes &&
       (table->gc_counter++ >= table->config->gc_max_ops) &&
       (table->gc_time + table->config->gc_min_time <= now))
-    rt_schedule_gc(table);
+    rt_schedule_prune(table);
 
   if (old_ok && p->rte_remove)
     p->rte_remove(net, old);
@@ -1237,7 +1227,7 @@ rte_unhide_dummy_routes(net *net, rte **dummy)
 /**
  * rte_update - enter a new update to a routing table
  * @table: table to be updated
- * @ah: pointer to table announce hook
+ * @c: channel doing the update
  * @net: network node
  * @p: protocol submitting the update
  * @src: protocol originating the update
@@ -1277,18 +1267,23 @@ rte_unhide_dummy_routes(net *net, rte **dummy)
  */
 
 void
-rte_update2(struct announce_hook *ah, net *net, rte *new, struct rte_src *src)
+rte_update2(struct channel *c, net *net, rte *new, struct rte_src *src)
 {
-  struct proto *p = ah->proto;
-  struct proto_stats *stats = ah->stats;
-  struct filter *filter = ah->in_filter;
+  struct proto *p = c->proto;
+  struct proto_stats *stats = &c->stats;
+  struct filter *filter = c->in_filter;
   ea_list *tmpa = NULL;
   rte *dummy = NULL;
 
+  ASSERT(c->channel_state == CS_UP);
+
   rte_update_lock();
   if (new)
     {
-      new->sender = ah;
+      new->sender = c;
+
+      if (!new->pref)
+	new->pref = c->preference;
 
       stats->imp_updates_received++;
       if (!rte_validate(new))
@@ -1303,7 +1298,7 @@ rte_update2(struct announce_hook *ah, net *net, rte *new, struct rte_src *src)
 	  stats->imp_updates_filtered++;
 	  rte_trace_in(D_FILTERS, p, new, "filtered out");
 
-	  if (! ah->in_keep_filtered)
+	  if (! c->in_keep_filtered)
 	    goto drop;
 
 	  /* new is a private copy, i could modify it */
@@ -1321,7 +1316,7 @@ rte_update2(struct announce_hook *ah, net *net, rte *new, struct rte_src *src)
 		  stats->imp_updates_filtered++;
 		  rte_trace_in(D_FILTERS, p, new, "filtered out");
 
-		  if (! ah->in_keep_filtered)
+		  if (! c->in_keep_filtered)
 		    goto drop;
 
 		  new->flags |= REF_FILTERED;
@@ -1348,7 +1343,7 @@ rte_update2(struct announce_hook *ah, net *net, rte *new, struct rte_src *src)
 
  recalc:
   rte_hide_dummy_routes(net, &dummy);
-  rte_recalculate(ah, net, new, src);
+  rte_recalculate(c, net, new, src);
   rte_unhide_dummy_routes(net, &dummy);
   rte_update_unlock();
   return;
@@ -1409,25 +1404,25 @@ rt_examine(rtable *t, net_addr *a, struct proto *p, struct filter *filter)
 /**
  * rt_refresh_begin - start a refresh cycle
  * @t: related routing table
- * @ah: related announce hook 
+ * @c related channel
  *
  * This function starts a refresh cycle for given routing table and announce
  * hook. The refresh cycle is a sequence where the protocol sends all its valid
  * routes to the routing table (by rte_update()). After that, all protocol
- * routes (more precisely routes with @ah as @sender) not sent during the
+ * routes (more precisely routes with @c as @sender) not sent during the
  * refresh cycle but still in the table from the past are pruned. This is
  * implemented by marking all related routes as stale by REF_STALE flag in
  * rt_refresh_begin(), then marking all related stale routes with REF_DISCARD
  * flag in rt_refresh_end() and then removing such routes in the prune loop.
  */
 void
-rt_refresh_begin(rtable *t, struct announce_hook *ah)
+rt_refresh_begin(rtable *t, struct channel *c)
 {
   FIB_WALK(&t->fib, net, n)
     {
       rte *e;
       for (e = n->routes; e; e = e->next)
-	if (e->sender == ah)
+	if (e->sender == c)
 	  e->flags |= REF_STALE;
     }
   FIB_WALK_END;
@@ -1436,13 +1431,13 @@ rt_refresh_begin(rtable *t, struct announce_hook *ah)
 /**
  * rt_refresh_end - end a refresh cycle
  * @t: related routing table
- * @ah: related announce hook 
+ * @c: related channel
  *
- * This function starts a refresh cycle for given routing table and announce
+ * This function ends a refresh cycle for given routing table and announce
  * hook. See rt_refresh_begin() for description of refresh cycles.
  */
 void
-rt_refresh_end(rtable *t, struct announce_hook *ah)
+rt_refresh_end(rtable *t, struct channel *c)
 {
   int prune = 0;
 
@@ -1450,7 +1445,7 @@ rt_refresh_end(rtable *t, struct announce_hook *ah)
     {
       rte *e;
       for (e = n->routes; e; e = e->next)
-	if ((e->sender == ah) && (e->flags & REF_STALE))
+	if ((e->sender == c) && (e->flags & REF_STALE))
 	  {
 	    e->flags |= REF_DISCARD;
 	    prune = 1;
@@ -1501,10 +1496,6 @@ rt_dump(rtable *t)
 	rte_dump(e);
     }
   FIB_WALK_END;
-
-  struct announce_hook *a;
-  WALK_LIST(a, t->hooks)
-    debug("\tAnnounces routes to protocol %s\n", a->proto->name);
   debug("\n");
 }
 
@@ -1523,23 +1514,6 @@ rt_dump_all(void)
 }
 
 static inline void
-rt_schedule_prune(rtable *tab)
-{
-  rt_mark_for_prune(tab);
-  ev_schedule(tab->rt_event);
-}
-
-static inline void
-rt_schedule_gc(rtable *tab)
-{
-  if (tab->gc_scheduled)
-    return;
-
-  tab->gc_scheduled = 1;
-  ev_schedule(tab->rt_event);
-}
-
-static inline void
 rt_schedule_hcu(rtable *tab)
 {
   if (tab->hcu_scheduled)
@@ -1559,38 +1533,17 @@ rt_schedule_nhu(rtable *tab)
   tab->nhu_state |= 1;
 }
 
-
-static void
-rt_prune_nets(rtable *tab)
+void
+rt_schedule_prune(rtable *tab)
 {
-  struct fib_iterator fit;
-  int ncnt = 0, ndel = 0;
-
-#ifdef DEBUGGING
-  fib_check(&tab->fib);
-#endif
-
-  FIB_ITERATE_INIT(&fit, &tab->fib);
-again:
-  FIB_ITERATE_START(&tab->fib, &fit, net, n)
-    {
-      ncnt++;
-      if (!n->routes)		/* Orphaned FIB entry */
-	{
-	  FIB_ITERATE_PUT(&fit);
-	  fib_delete(&tab->fib, n);
-	  ndel++;
-	  goto again;
-	}
-    }
-  FIB_ITERATE_END;
-  DBG("Pruned %d of %d networks\n", ndel, ncnt);
+  if (tab->prune_state == 0)
+    ev_schedule(tab->rt_event);
 
-  tab->gc_counter = 0;
-  tab->gc_time = now;
-  tab->gc_scheduled = 0;
+  /* state change 0->1, 2->3 */
+  tab->prune_state |= 1;
 }
 
+
 static void
 rt_event(void *ptr)
 {
@@ -1603,18 +1556,7 @@ rt_event(void *ptr)
     rt_next_hop_update(tab);
 
   if (tab->prune_state)
-    if (!rt_prune_table(tab))
-      {
-	/* Table prune unfinished */
-	ev_schedule(tab->rt_event);
-	return;
-      }
-
-  if (tab->gc_scheduled)
-    {
-      rt_prune_nets(tab);
-      rt_prune_sources(); // FIXME this should be moved to independent event
-    }
+    rt_prune_table(tab);
 }
 
 void
@@ -1625,7 +1567,8 @@ rt_setup(pool *p, rtable *t, char *name, struct rtable_config *cf)
   t->config = cf;
   t->addr_type = cf ? cf->addr_type : NET_IP4;
   fib_init(&t->fib, p, t->addr_type, sizeof(net), OFFSETOF(net, n), 0, NULL);
-  init_list(&t->hooks);
+  init_list(&t->channels);
+
   if (cf)
     {
       t->rt_event = ev_new(p);
@@ -1652,24 +1595,47 @@ rt_init(void)
 }
 
 
-static int
-rt_prune_step(rtable *tab, int *limit)
+/**
+ * rt_prune_table - prune a routing table
+ *
+ * The prune loop scans routing tables and removes routes belonging to flushing
+ * protocols, discarded routes and also stale network entries. It is called from
+ * rt_event(). The event is rescheduled if the current iteration do not finish
+ * the table. The pruning is directed by the prune state (@prune_state),
+ * specifying whether the prune cycle is scheduled or running, and there
+ * is also a persistent pruning iterator (@prune_fit).
+ *
+ * The prune loop is used also for channel flushing. For this purpose, the
+ * channels to flush are marked before the iteration and notified after the
+ * iteration.
+ */
+static void
+rt_prune_table(rtable *tab)
 {
   struct fib_iterator *fit = &tab->prune_fit;
+  int limit = 512;
+
+  struct channel *c;
+  node *n, *x;
 
   DBG("Pruning route table %s\n", tab->name);
 #ifdef DEBUGGING
   fib_check(&tab->fib);
 #endif
 
-  if (tab->prune_state == RPS_NONE)
-    return 1;
+  if (tab->prune_state == 0)
+    return;
 
-  if (tab->prune_state == RPS_SCHEDULED)
-    {
-      FIB_ITERATE_INIT(fit, &tab->fib);
-      tab->prune_state = RPS_RUNNING;
-    }
+  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;
+
+    FIB_ITERATE_INIT(fit, &tab->fib);
+    tab->prune_state = 2;
+  }
 
 again:
   FIB_ITERATE_START(&tab->fib, fit, net, n)
@@ -1678,19 +1644,21 @@ again:
 
     rescan:
       for (e=n->routes; e; e=e->next)
-	if (e->sender->proto->flushing || (e->flags & REF_DISCARD))
+	if (e->sender->flush_active || (e->flags & REF_DISCARD))
 	  {
-	    if (*limit <= 0)
+	    if (limit <= 0)
 	      {
 		FIB_ITERATE_PUT(fit);
-		return 0;
+		ev_schedule(tab->rt_event);
+		return;
 	      }
 
 	    rte_discard(tab, e);
-	    (*limit)--;
+	    limit--;
 
 	    goto rescan;
 	  }
+
       if (!n->routes)		/* Orphaned FIB entry */
 	{
 	  FIB_ITERATE_PUT(fit);
@@ -1704,61 +1672,40 @@ again:
   fib_check(&tab->fib);
 #endif
 
-  tab->prune_state = RPS_NONE;
-  return 1;
-}
+  tab->gc_counter = 0;
+  tab->gc_time = now;
 
-/**
- * rt_prune_table - prune a routing table
- *
- * This function scans the routing table @tab and removes routes belonging to
- * flushing protocols, discarded routes and also stale network entries, in a
- * similar fashion like rt_prune_loop(). Returns 1 when all such routes are
- * pruned. Contrary to rt_prune_loop(), this function is not a part of the
- * protocol flushing loop, but it is called from rt_event() for just one routing
- * table.
- *
- * Note that rt_prune_table() and rt_prune_loop() share (for each table) the
- * prune state (@prune_state) and also the pruning iterator (@prune_fit).
- */
-static inline int
-rt_prune_table(rtable *tab)
-{
-  int limit = 512;
-  return rt_prune_step(tab, &limit);
-}
+  /* state change 2->0, 3->1 */
+  tab->prune_state &= 1;
 
-/**
- * rt_prune_loop - prune routing tables
- *
- * The prune loop scans routing tables and removes routes belonging to flushing
- * protocols, discarded routes and also stale network entries. Returns 1 when
- * all such routes are pruned. It is a part of the protocol flushing loop.
- */
-int
-rt_prune_loop(void)
-{
-  int limit = 512;
-  rtable *t;
+  if (tab->prune_state > 0)
+    ev_schedule(tab->rt_event);
 
-  WALK_LIST(t, routing_tables)
-    if (! rt_prune_step(t, &limit))
-      return 0;
+  /* FIXME: This should be handled in a better way */
+  rt_prune_sources();
 
-  return 1;
+  /* 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;
 }
 
 void
 rt_preconfig(struct config *c)
 {
-  struct symbol *s = cf_get_symbol("master");
-
   init_list(&c->tables);
-  c->master_rtc = rt_new_table(s, NET_IP4);
+
+  rt_new_table(cf_get_symbol("master4"), NET_IP4);
+  rt_new_table(cf_get_symbol("master6"), NET_IP6);
 }
 
 
-/* 
+/*
  * Some functions for handing internal next hop updates
  * triggered by rt_schedule_nhu().
  */
@@ -1914,7 +1861,9 @@ struct rtable_config *
 rt_new_table(struct symbol *s, uint addr_type)
 {
   /* Hack that allows to 'redefine' the master table */
-  if ((s->class == SYM_TABLE) && (s->def == new_config->master_rtc))
+  if ((s->class == SYM_TABLE) &&
+      (s->def == new_config->def_tables[addr_type]) &&
+      ((addr_type == NET_IP4) || (addr_type == NET_IP6)))
     return s->def;
 
   struct rtable_config *c = cfg_allocz(sizeof(struct rtable_config));
@@ -1922,9 +1871,15 @@ rt_new_table(struct symbol *s, uint addr_type)
   cf_define_symbol(s, SYM_TABLE, c);
   c->name = s->name;
   c->addr_type = addr_type;
-  add_tail(&new_config->tables, &c->n);
   c->gc_max_ops = 1000;
   c->gc_min_time = 5;
+
+  add_tail(&new_config->tables, &c->n);
+
+  /* First table of each type is kept as default */
+  if (! new_config->def_tables[addr_type])
+    new_config->def_tables[addr_type] = c;
+
   return c;
 }
 
@@ -2029,48 +1984,42 @@ rt_commit(struct config *new, struct config *old)
 }
 
 static inline void
-do_feed_baby(struct proto *p, int type, struct announce_hook *h, net *n, rte *e)
+do_feed_channel(struct channel *c, net *n, rte *e)
 {
   rte_update_lock();
-  if (type == RA_ACCEPTED)
-    rt_notify_accepted(h, n, e, NULL, NULL, p->refeeding ? 2 : 1);
-  else if (type == RA_MERGED)
-    rt_notify_merged(h, n, NULL, NULL, e, p->refeeding ? e : NULL, p->refeeding);
-  else
-    rt_notify_basic(h, n, e, p->refeeding ? e : NULL, p->refeeding);
+  if (c->ra_mode == RA_ACCEPTED)
+    rt_notify_accepted(c, n, e, NULL, NULL, c->refeeding ? 2 : 1);
+  else if (c->ra_mode == RA_MERGED)
+    rt_notify_merged(c, n, NULL, NULL, e, c->refeeding ? e : NULL, c->refeeding);
+  else /* RA_BASIC */
+    rt_notify_basic(c, n, e, c->refeeding ? e : NULL, c->refeeding);
   rte_update_unlock();
 }
 
 /**
- * rt_feed_baby - advertise routes to a new protocol
- * @p: protocol to be fed
+ * rt_feed_channel - advertise all routes to a channel
+ * @c: channel to be fed
  *
- * This function performs one pass of advertisement of routes to a newly
- * initialized protocol. It's called by the protocol code as long as it
- * has something to do. (We avoid transferring all the routes in single
- * pass in order not to monopolize CPU time.)
+ * This function performs one pass of advertisement of routes to a channel that
+ * is in the ES_FEEDING state. It is called by the protocol code as long as it
+ * has something to do. (We avoid transferring all the routes in single pass in
+ * order not to monopolize CPU time.)
  */
 int
-rt_feed_baby(struct proto *p)
+rt_feed_channel(struct channel *c)
 {
-  struct announce_hook *h;
-  struct fib_iterator *fit;
+  struct fib_iterator *fit = &c->feed_fit;
   int max_feed = 256;
 
-  if (!p->feed_ahook)			/* Need to initialize first */
+  ASSERT(c->export_state == ES_FEEDING);
+
+  if (!c->feed_active)
     {
-      if (!p->ahooks)
-	return 1;
-      DBG("Announcing routes to new protocol %s\n", p->name);
-      p->feed_ahook = p->ahooks;
-      fit = p->feed_iterator = mb_alloc(p->pool, sizeof(struct fib_iterator));
-      goto next_hook;
+      FIB_ITERATE_INIT(fit, &c->table->fib);
+      c->feed_active = 1;
     }
-  fit = p->feed_iterator;
 
-again:
-  h = p->feed_ahook;
-  FIB_ITERATE_START(&h->table->fib, fit, net, n)
+  FIB_ITERATE_START(&c->table->fib, fit, net, n)
     {
       rte *e = n->routes;
       if (max_feed <= 0)
@@ -2079,68 +2028,60 @@ again:
 	  return 0;
 	}
 
-      /* XXXX perhaps we should change feed for RA_ACCEPTED to not use 'new' */
+      /* FIXME: perhaps we should change feed for RA_ACCEPTED to not use 'new' */
 
-      if ((p->accept_ra_types == RA_OPTIMAL) ||
-	  (p->accept_ra_types == RA_ACCEPTED) ||
-	  (p->accept_ra_types == RA_MERGED))
+      if ((c->ra_mode == RA_OPTIMAL) ||
+	  (c->ra_mode == RA_ACCEPTED) ||
+	  (c->ra_mode == RA_MERGED))
 	if (rte_is_valid(e))
 	  {
-	    if (p->export_state != ES_FEEDING)
-	      return 1;  /* In the meantime, the protocol fell down. */
+	    /* In the meantime, the protocol may fell down */
+	    if (c->export_state != ES_FEEDING)
+	      goto done;
 
-	    do_feed_baby(p, p->accept_ra_types, h, n, e);
+	    do_feed_channel(c, n, e);
 	    max_feed--;
 	  }
 
-      if (p->accept_ra_types == RA_ANY)
+      if (c->ra_mode == RA_ANY)
 	for(e = n->routes; e; e = e->next)
 	  {
-	    if (p->export_state != ES_FEEDING)
-	      return 1;  /* In the meantime, the protocol fell down. */
+	    /* In the meantime, the protocol may fell down */
+	    if (c->export_state != ES_FEEDING)
+	      goto done;
 
 	    if (!rte_is_valid(e))
 	      continue;
 
-	    do_feed_baby(p, RA_ANY, h, n, e);
+	    do_feed_channel(c, n, e);
 	    max_feed--;
 	  }
     }
   FIB_ITERATE_END;
-  p->feed_ahook = h->next;
-  if (!p->feed_ahook)
-    {
-      mb_free(p->feed_iterator);
-      p->feed_iterator = NULL;
-      return 1;
-    }
 
-next_hook:
-  h = p->feed_ahook;
-  FIB_ITERATE_INIT(fit, &h->table->fib);
-  goto again;
+done:
+  c->feed_active = 0;
+  return 1;
 }
 
 /**
  * rt_feed_baby_abort - abort protocol feeding
- * @p: protocol
+ * @c: channel
  *
- * This function is called by the protocol code when the protocol
- * stops or ceases to exist before the last iteration of rt_feed_baby()
- * has finished.
+ * This function is called by the protocol code when the protocol stops or
+ * ceases to exist during the feeding.
  */
 void
-rt_feed_baby_abort(struct proto *p)
+rt_feed_channel_abort(struct channel *c)
 {
-  if (p->feed_ahook)
+  if (c->feed_active)
     {
-      /* Unlink the iterator and exit */
-      fit_get(&p->feed_ahook->table->fib, p->feed_iterator);
-      p->feed_ahook = NULL;
+      /* Unlink the iterator */
+      fit_get(&c->table->fib, &c->feed_fit);
+      c->feed_active = 0;
     }
 }
 
-
 static inline unsigned
 ptr_hash(void *ptr)
 {
@@ -2517,21 +2458,12 @@ rt_show_net(struct cli *c, net *n, struct rt_show_data *d)
   rte *e, *ee;
   byte ia[NET_MAX_TEXT_LENGTH+1];
   struct ea_list *tmpa;
-  struct announce_hook *a = NULL;
+  struct channel *ec = d->export_channel;
   int first = 1;
   int pass = 0;
 
   bsprintf(ia, "%N", n->n.addr);
 
-  if (d->export_mode)
-    {
-      if (! d->export_protocol->rt_notify)
-	return;
-
-      a = proto_find_announce_hook(d->export_protocol, d->table);
-      if (!a)
-	return;
-    }
 
   for (e = n->routes; e; e = e->next)
     {
@@ -2550,10 +2482,10 @@ rt_show_net(struct cli *c, net *n, struct rt_show_data *d)
       tmpa = make_tmp_attrs(e, rte_update_pool);
 
       /* Special case for merged export */
-      if ((d->export_mode == RSEM_EXPORT) && (d->export_protocol->accept_ra_types == RA_MERGED))
+      if ((d->export_mode == RSEM_EXPORT) && (ec->ra_mode == RA_MERGED))
         {
 	  rte *rt_free;
-	  e = rt_export_merged(a, n, &rt_free, &tmpa, 1);
+	  e = rt_export_merged(ec, n, &rt_free, &tmpa, 1);
 	  pass = 1;
 
 	  if (!e)
@@ -2564,7 +2496,7 @@ rt_show_net(struct cli *c, net *n, struct rt_show_data *d)
 	  struct proto *ep = d->export_protocol;
 	  int ic = ep->import_control ? ep->import_control(ep, &e, &tmpa, rte_update_pool) : 0;
 
-	  if (ep->accept_ra_types == RA_OPTIMAL || ep->accept_ra_types == RA_MERGED)
+	  if (ec->ra_mode == RA_OPTIMAL || ec->ra_mode == RA_MERGED)
 	    pass = 1;
 
 	  if (ic < 0)
@@ -2578,12 +2510,12 @@ rt_show_net(struct cli *c, net *n, struct rt_show_data *d)
 	       * command may change the export filter and do not update routes.
 	       */
 	      int do_export = (ic > 0) ||
-		(f_run(a->out_filter, &e, &tmpa, rte_update_pool, FF_FORCE_TMPATTR) <= F_ACCEPT);
+		(f_run(ec->out_filter, &e, &tmpa, rte_update_pool, FF_FORCE_TMPATTR) <= F_ACCEPT);
 
 	      if (do_export != (d->export_mode == RSEM_EXPORT))
 		goto skip;
 
-	      if ((d->export_mode == RSEM_EXPORT) && (ep->accept_ra_types == RA_ACCEPTED))
+	      if ((d->export_mode == RSEM_EXPORT) && (ec->ra_mode == RA_ACCEPTED))
 		pass = 1;
 	    }
 	}
@@ -2612,6 +2544,15 @@ rt_show_net(struct cli *c, net *n, struct rt_show_data *d)
     }
 }
 
+static struct channel *
+rt_show_export_channel(struct rt_show_data *d)
+{
+  if (! d->export_protocol->rt_notify)
+    return NULL;
+
+  return proto_find_channel_by_table(d->export_protocol, d->table);
+}
+
 static void
 rt_show_cont(struct cli *c)
 {
@@ -2624,18 +2565,19 @@ rt_show_cont(struct cli *c)
   struct fib *fib = &d->table->fib;
   struct fib_iterator *it = &d->fit;
 
-  FIB_ITERATE_START(fib, it, net, n)
+  if (d->export_mode)
     {
-      if (d->running_on_config && d->running_on_config != config)
-	{
-	  cli_printf(c, 8004, "Stopped due to reconfiguration");
-	  goto done;
-	}
-      if (d->export_protocol && (d->export_protocol->export_state == ES_DOWN))
-	{
-	  cli_printf(c, 8005, "Protocol is down");
+      /* Ensure we have current export channel */
+      d->export_channel = rt_show_export_channel(d);
+      if (!d->export_channel || (d->export_channel->export_state == ES_DOWN))
+        {
+	  cli_printf(c, 8005, "Channel is down");
 	  goto done;
 	}
+    }
+
+  FIB_ITERATE_START(fib, it, net, n)
+    {
       if (!max--)
 	{
 	  FIB_ITERATE_PUT(it);
@@ -2661,15 +2603,29 @@ rt_show_cleanup(struct cli *c)
   fit_get(&d->table->fib, &d->fit);
 }
 
+static inline rtable *
+rt_show_get_table(struct proto *p)
+{
+  /* FIXME: Use a better way to handle multi-channel protocols */
+
+  if (p->main_channel)
+    return p->main_channel->table;
+
+  if (!EMPTY_LIST(p->channels))
+    return ((struct channel *) HEAD(p->channels))->table;
+
+  return NULL;
+}
+
 void
 rt_show(struct rt_show_data *d)
 {
   net *n;
 
   /* Default is either a master table or a table related to a respective protocol */
-  if (!d->table && d->export_protocol) d->table = d->export_protocol->table;
-  if (!d->table && d->show_protocol) d->table = d->show_protocol->table;
-  if (!d->table) d->table = config->master_rtc->table;
+  if (!d->table && d->export_protocol) d->table = rt_show_get_table(d->export_protocol);
+  if (!d->table && d->show_protocol) d->table = rt_show_get_table(d->show_protocol);
+  if (!d->table) d->table = config->def_tables[NET_IP4]->table; /* FIXME: iterate through all tables ? */
 
   /* Filtered routes are neither exported nor have sensible ordering */
   if (d->filtered && (d->export_mode || d->primary_only))
@@ -2684,6 +2640,17 @@ rt_show(struct rt_show_data *d)
     }
   else
     {
+      if (d->export_mode)
+        {
+	  /* Find channel associated with the export protocol */
+	  d->export_channel = rt_show_export_channel(d);
+	  if (!d->export_channel || (d->export_channel->export_state == ES_DOWN))
+	    {
+	      cli_msg(8005, "Channel is down");
+	      return;
+	    }
+	}
+
       if (d->show_for)
 	n = net_route(d->table, d->addr);
       else