Internet on FIRE

/*

 *        BIRD -- Protocols

 *

 *        (c) 1998--2000 Martin Mares <mj@ucw.cz>

 *

 *        Can be freely distributed and used under the terms of the GNU GPL.

 */

#undef LOCAL_DEBUG

#include "nest/bird.h"

#include "nest/protocol.h"

#include "lib/resource.h"

#include "lib/lists.h"

#include "lib/event.h"

#include "lib/string.h"

#include "conf/conf.h"

#include "nest/route.h"

#include "nest/iface.h"

#include "nest/cli.h"

#include "filter/filter.h"

pool *proto_pool;

list  proto_list;

static list protocol_list;

#define PD(pr, msg, args...) do { if (pr->debug & D_STATES) { log(L_TRACE "%s: " msg, pr->name , ## args); } } while(0)

static timer *proto_shutdown_timer;

static timer *gr_wait_timer;

#define GRS_NONE        0

#define GRS_INIT        1

#define GRS_ACTIVE        2

#define GRS_DONE        3

static int graceful_restart_state;

static u32 graceful_restart_locks;

static char *p_states[] = { "DOWN", "START", "UP", "STOP" };

static char *c_states[] = { "DOWN", "START", "UP", "FLUSHING" };

extern struct protocol proto_unix_iface;

static void proto_shutdown_loop(timer *);

static void proto_rethink_goal(struct proto *p);

static char *proto_state_name(struct proto *p);

static void channel_verify_limits(struct channel *c);

static inline void channel_reset_limit(struct channel_limit *l);

static inline int proto_is_done(struct proto *p)

{ return (p->proto_state == PS_DOWN) && (p->active_channels == 0); }

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)

    {

      p->last_state_name_announced = name;

      PD(p, "State changed to %s", proto_state_name(p));

    }

  }

  else

    p->last_state_name_announced = NULL;

}

struct channel_config *

proto_cf_find_channel(struct proto_config *pc, uint net_type)

{

  struct channel_config *cc;

  WALK_LIST(cc, pc->channels)

    if (cc->net_type == net_type)

      return cc;

  return NULL;

}

/**

 * 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)

{

  struct channel *c;

  WALK_LIST(c, p->channels)

    if (c->table == t)

      return c;

  return NULL;

}

/**

 * proto_find_channel_by_name - find channel by its name

 * @p: protocol instance

 * @n: channel name

 *

 * Returns pointer to channel or NULL

 */

struct channel *

proto_find_channel_by_name(struct proto *p, const char *n)

{

  struct channel *c;

  WALK_LIST(c, p->channels)

    if (!strcmp(c->name, n))

      return c;

  return NULL;

}

/**

 * proto_add_channel - connect protocol to a routing table

 * @p: protocol instance

 * @cf: channel configuration

 *

 * 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.

 *

 * 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 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 = current_time();

  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;

  c->stats.exp_routes = 0;

}

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)

{

  rem_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));

  CALL(c->channel->cleanup, c);

  /* 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 channel %s state transition %s -> %s\n", c->proto->name, c->name, c_states[cs], c_states[state]);

  if (state == cs)

    return;

  c->channel_state = state;

  c->last_state_change = current_time();

  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 && c->proto->rt_notify)

      channel_start_export(c);

    break;

  case CS_FLUSHING:

    ASSERT(cs == CS_START || cs == CS_UP);

    if (es != ES_DOWN)

      channel_stop_export(c);

    channel_do_flush(c);

    break;

  case CS_DOWN:

    ASSERT(cs == CS_FLUSHING);

    channel_do_down(c);

    break;

  default:

    ASSERT(0);

  }

  // XXXX proto_log_state_change(c);

}

/**

 * channel_request_feeding - request feeding routes to the channel

 * @c: given channel

 *

 * 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.

 */

void

channel_request_feeding(struct channel *c)

{

  ASSERT(c->channel_state == CS_UP);

  /* Do nothing if we are still waiting for feeding */

  if (c->export_state == ES_DOWN)

    return;

  /* 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

channel_request_reload(struct channel *c)

{

  ASSERT(c->channel_state == CS_UP);

  // ASSERT(channel_reloadable(c));

  c->proto->reload_routes(c);

  /*

   * 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);

}

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 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) || (cf->ra_mode && (c->ra_mode != cf->ra_mode)))

    return 0;

  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);

  /* Execute channel-specific reconfigure hook */

  if (c->channel->reconfigure && !c->channel->reconfigure(c, cf))

    return 0;

  /* 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_event(void *ptr)

{

  struct proto *p = ptr;

  if (p->do_start)

  {

    if_feed_baby(p);

    p->do_start = 0;

  }

  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 = current_time();

  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;

}

/**

 * proto_config_new - create a new protocol configuration

 * @pr: protocol the configuration will belong to

 * @class: SYM_PROTO or SYM_TEMPLATE

 *

 * Whenever the configuration file says that a new instance

 * of a routing protocol should be created, the parser calls

 * proto_config_new() to create a configuration entry for this

 * instance (a structure staring with the &proto_config header

 * containing all the generic items followed by protocol-specific

 * ones). Also, the configuration entry gets added to the list

 * of protocol instances kept in the configuration.

 *

 * The function is also used to create protocol templates (when class

 * SYM_TEMPLATE is specified), the only difference is that templates

 * are not added to the list of protocol instances and therefore not

 * initialized during protos_commit()).

 */

void *

proto_config_new(struct protocol *pr, int class)

{

  struct proto_config *cf = cfg_allocz(pr->config_size);

  if (class == SYM_PROTO)

    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

 * @src: source protocol configuration

 *

 * Whenever a new instance of a routing protocol is created from the

 * template, proto_copy_config() is called to copy a content of

 * the source protocol configuration to the new protocol configuration.

 * Name, class and a node in protos list of @dest are kept intact.

 * copy_config() protocol hook is used to copy protocol-specific data.

 */

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;

  if (dest->protocol != src->protocol)

    cf_error("Can't copy configuration from a different protocol type");

  if (dest->protocol->copy_config == NULL)

    cf_error("Inheriting configuration for %s is not supported", src->protocol->name);

  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

   */

  old_node = dest->n;

  old_class = dest->class;

  old_name = dest->name;

  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);

}

/**

 * protos_preconfig - pre-configuration processing

 * @c: new configuration

 *

 * This function calls the preconfig() hooks of all routing

 * protocols available to prepare them for reading of the new

 * configuration.

 */

void

protos_preconfig(struct config *c)

{

  struct protocol *p;

  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");

}

static int

proto_reconfigure(struct proto *p, struct proto_config *oc, struct proto_config *nc, int type)

{

  /* If the protocol is DOWN, we just restart it */

  if (p->proto_state == PS_DOWN)

    return 0;

  /* If there is a too big change in core attributes, ... */

  if ((nc->protocol != oc->protocol) ||

      (nc->net_type != oc->net_type) ||

      (nc->disabled != p->disabled))

    return 0;

  p->name = nc->name;

  p->debug = nc->debug;

  p->mrtdump = nc->mrtdump;

  reconfigure_type = type;

  /* Execute protocol specific reconfigure hook */

  if (!p->proto->reconfigure || !p->proto->reconfigure(p, nc))

    return 0;

  DBG("\t%s: same\n", oc->name);

  PD(p, "Reconfigured");

  p->cf = nc;

  return 1;

}

/**

 * protos_commit - commit new protocol configuration

 * @new: new configuration

 * @old: old configuration or %NULL if it's boot time config

 * @force_reconfig: force restart of all protocols (used for example

 * when the router ID changes)

 * @type: type of reconfiguration (RECONFIG_SOFT or RECONFIG_HARD)

 *

 * Scan differences between @old and @new configuration and adjust all

 * protocol instances to conform to the new configuration.

 *

 * When a protocol exists in the new configuration, but it doesn't in the

 * original one, it's immediately started. When a collision with the other

 * running protocol would arise, the new protocol will be temporarily stopped

 * by the locking mechanism.

 *

 * When a protocol exists in the old configuration, but it doesn't in the

 * new one, it's shut down and deleted after the shutdown completes.

 *

 * When a protocol exists in both configurations, the core decides

 * whether it's possible to reconfigure it dynamically - it checks all

 * the core properties of the protocol (changes in filters are ignored

 * if type is RECONFIG_SOFT) and if they match, it asks the

 * reconfigure() hook of the protocol to see if the protocol is able

 * to switch to the new configuration.  If it isn't possible, the

 * protocol is shut down and a new instance is started with the new

 * configuration after the shutdown is completed.

 */

void

protos_commit(struct config *new, struct config *old, int force_reconfig, int type)

{

  struct proto_config *oc, *nc;

  struct symbol *sym;

  struct proto *p;

  node *n;

  DBG("protos_commit:\n");

  if (old)

  {

    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);

    }

  }

  struct proto *first_dev_proto = NULL;

  n = NODE &(proto_list.head);

  WALK_LIST(nc, new->protos)

    if (!nc->proto)

    {

      /* 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 (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");

  }

  /* Start all new protocols */

  WALK_LIST_DELSAFE(p, n, proto_list)

    proto_rethink_goal(p);

}

static void

proto_rethink_goal(struct proto *p)

{

  struct protocol *q;

  byte goal;

  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)

    goal = PS_DOWN;

  else

    goal = PS_UP;

  q = p->proto;

  if (goal == PS_UP)

  {

    if (!p->active)

    {

      /* 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

  {

    if (p->proto_state == PS_START || p->proto_state == PS_UP)

    {

      /* Going down */

      DBG("Kicking %s down\n", p->name);

      PD(p, "Shutting down");

      proto_notify_state(p, (q->shutdown ? q->shutdown(p) : PS_DOWN));

    }

  }

}

/**

 * DOC: Graceful restart recovery

 *

 * Graceful restart of a router is a process when the routing plane (e.g. BIRD)

 * restarts but both the forwarding plane (e.g kernel routing table) and routing

 * neighbors keep proper routes, and therefore uninterrupted packet forwarding

 * is maintained.

 *

 * BIRD implements graceful restart recovery by deferring export of routes to

 * protocols until routing tables are refilled with the expected content. After

 * start, protocols generate routes as usual, but routes are not propagated to

 * them, until protocols report that they generated all routes. After that,

 * graceful restart recovery is finished and the export (and the initial feed)

 * to protocols is enabled.

 *

 * 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 for each channel by function

 * channel_graceful_restart_lock() (state 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.

 *

 */

static void graceful_restart_done(timer *t);

/**

 * graceful_restart_recovery - request initial graceful restart recovery

 *

 * Called by the platform initialization code if the need for recovery

 * after graceful restart is detected during boot. Have to be called

 * before protos_commit().

 */

void

graceful_restart_recovery(void)

{

  graceful_restart_state = GRS_INIT;

}

/**

 * graceful_restart_init - initialize graceful restart

 *

 * When graceful restart recovery was requested, the function starts an active

 * phase of the recovery and initializes graceful restart wait timer. The

 * function have to be called after protos_commit().

 */

void

graceful_restart_init(void)

{

  if (!graceful_restart_state)

    return;

  log(L_INFO "Graceful restart started");

  if (!graceful_restart_locks)

  {

    graceful_restart_done(NULL);

    return;

  }

  graceful_restart_state = GRS_ACTIVE;

  gr_wait_timer = tm2_new_init(proto_pool, graceful_restart_done, NULL, 0, 0);

  tm2_start(gr_wait_timer, config->gr_wait S);

}

/**

 * graceful_restart_done - finalize graceful restart

 * @t: unused

 *

 * When there are no locks on graceful restart, the functions finalizes the

 * graceful restart recovery. Protocols postponing route export until the end of

 * the recovery are awakened and the export to them is enabled. All other

 * related state is cleared. The function is also called when the graceful

 * restart wait timer fires (but there are still some locks).

 */

static void

graceful_restart_done(timer *t UNUSED)

{

  log(L_INFO "Graceful restart done");

  graceful_restart_state = GRS_DONE;

  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 ((c->channel_state == CS_UP) && c->gr_wait && c->proto->rt_notify)

        channel_start_export(c);

      /* Cleanup */

      c->gr_wait = 0;

      c->gr_lock = 0;

    }

    p->gr_recovery = 0;

  }

  graceful_restart_locks = 0;

}

void

graceful_restart_show_status(void)

{

  if (graceful_restart_state != GRS_ACTIVE)

    return;

  cli_msg(-24, "Graceful restart recovery in progress");

  cli_msg(-24, "  Waiting for %d channels to recover", graceful_restart_locks);

  cli_msg(-24, "  Wait timer is %t/%u", tm2_remains(gr_wait_timer), config->gr_wait);

}

/**

 * 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

 * 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

 * @gr_recovery is set), which means it should be called from protocol start

 * hooks.

 */

void

channel_graceful_restart_lock(struct channel *c)

{

  ASSERT(graceful_restart_state == GRS_INIT);

  ASSERT(c->proto->gr_recovery);

  if (c->gr_lock)

    return;

  c->gr_lock = 1;

  graceful_restart_locks++;

}

/**

 * channel_graceful_restart_unlock - unlock graceful restart by channel

 * @p: channel instance

 *

 * This function unlocks a lock from channel_graceful_restart_lock(). It is also

 * automatically called when the lock holding protocol went down.

 */

void

channel_graceful_restart_unlock(struct channel *c)

{

  if (!c->gr_lock)

    return;

  c->gr_lock = 0;

  graceful_restart_locks--;

  if ((graceful_restart_state == GRS_ACTIVE) && !graceful_restart_locks)

    tm2_start(gr_wait_timer, 0);

}

/**

 * protos_dump_all - dump status of all protocols

 *

 * This function dumps status of all existing protocol instances to the

 * debug output. It involves printing of general status information

 * such as protocol states, its position on the protocol lists

 * and also calling of a dump() hook of the protocol to print

 * the internals.

 */

void

protos_dump_all(void)

{

  debug("Protocols:\n");

  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("\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));

    }

    if (p->proto->dump && (p->proto_state != PS_DOWN))

      p->proto->dump(p);

  }

}

/**

 * proto_build - make a single protocol available

 * @p: the protocol

 *

 * After the platform specific initialization code uses protos_build()

 * to add all the standard protocols, it should call proto_build() for

 * all platform specific protocols to inform the core that they exist.

 */

void

proto_build(struct protocol *p)

{

  add_tail(&protocol_list, &p->n);

  if (p->attr_class)

    {

      ASSERT(!attr_class_to_protocol[p->attr_class]);

      attr_class_to_protocol[p->attr_class] = p;

    }

}

/* FIXME: convert this call to some protocol hook */

extern void bfd_init_all(void);

/**

 * protos_build - build a protocol list

 *

 * This function is called during BIRD startup to insert

 * all standard protocols to the global protocol list. Insertion

 * of platform specific protocols (such as the kernel syncer)

 * is in the domain of competence of the platform dependent

 * startup code.

 */

void

protos_build(void)

{

  init_list(&proto_list);

  init_list(&protocol_list);

  proto_build(&proto_device);

#ifdef CONFIG_RADV

  proto_build(&proto_radv);

#endif

#ifdef CONFIG_RIP

  proto_build(&proto_rip);

#endif

#ifdef CONFIG_STATIC

  proto_build(&proto_static);

#endif

#ifdef CONFIG_OSPF

  proto_build(&proto_ospf);

#endif

#ifdef CONFIG_PIPE

  proto_build(&proto_pipe);

#endif

#ifdef CONFIG_BGP

  proto_build(&proto_bgp);

#endif

#ifdef CONFIG_BFD

  proto_build(&proto_bfd);

  bfd_init_all();

#endif

#ifdef CONFIG_BABEL

  proto_build(&proto_babel);

#endif

#ifdef CONFIG_RPKI

  proto_build(&proto_rpki);

#endif

  proto_pool = rp_new(&root_pool, "Protocols");

  proto_shutdown_timer = tm2_new(proto_pool);

  proto_shutdown_timer->hook = proto_shutdown_loop;

}

/* Temporary hack to propagate restart to BGP */

int proto_restart;

static void

proto_shutdown_loop(timer *t UNUSED)

{

  struct proto *p, *p_next;

  WALK_LIST_DELSAFE(p, p_next, proto_list)

    if (p->down_sched)

    {

      proto_restart = (p->down_sched == PDS_RESTART);

      p->disabled = 1;

      proto_rethink_goal(p);

      if (proto_restart)

      {

        p->disabled = 0;

        proto_rethink_goal(p);

      }

    }

}

static inline void

proto_schedule_down(struct proto *p, byte restart, byte code)

{

  /* Does not work for other states (even PS_START) */

  ASSERT(p->proto_state == PS_UP);

  /* Scheduled restart may change to shutdown, but not otherwise */

  if (p->down_sched == PDS_DISABLE)

    return;

  p->down_sched = restart ? PDS_RESTART : PDS_DISABLE;

  p->down_code = code;

  tm2_start_max(proto_shutdown_timer, restart ? 250 MS : 0);

}

static const char *

channel_limit_name(struct channel_limit *l)

{

  const char *actions[] = {

    [PLA_WARN] = "warn",

    [PLA_BLOCK] = "block",

    [PLA_RESTART] = "restart",

    [PLA_DISABLE] = "disable",

  };

  return actions[l->action];

}

/**

 * 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

 *

 * 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

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 = c->proto;

  if (l->state == PLS_BLOCKED)

    return;

  /* 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)))