bird/proto/static/static.c

/*
 *	BIRD -- Static Route Generator
 *
 *	(c) 1998--2000 Martin Mares <mj@ucw.cz>
 *
 *	Can be freely distributed and used under the terms of the GNU GPL.
 */

/**
 * DOC: Static
 *
 * The Static protocol is implemented in a straightforward way. It keeps
 * two lists of static routes: one containing interface routes and one
 * holding the remaining ones. Interface routes are inserted and removed according
 * to interface events received from the core via the if_notify() hook. Routes
 * pointing to a neighboring router use a sticky node in the neighbor cache
 * to be notified about gaining or losing the neighbor. Special
 * routes like black holes or rejects are inserted all the time.
 *
 * Multipath routes are tricky. Because these routes depends on
 * several neighbors we need to integrate that to the neighbor
 * notification handling, we use dummy static_route nodes, one for
 * each nexthop. Therefore, a multipath route consists of a master
 * static_route node (of dest RTD_MULTIPATH), which specifies prefix
 * and is used in most circumstances, and a list of dummy static_route
 * nodes (of dest RTD_NONE), which stores info about nexthops and are
 * connected to neighbor entries and neighbor notifications. Dummy
 * nodes are chained using mp_next, they aren't in other_routes list,
 * and abuse some fields (masklen, if_name) for other purposes.
 *
 * The only other thing worth mentioning is that when asked for reconfiguration,
 * Static not only compares the two configurations, but it also calculates
 * difference between the lists of static routes and it just inserts the
 * newly added routes and removes the obsolete ones.
 */

#undef LOCAL_DEBUG

#include "nest/bird.h"
#include "nest/iface.h"
#include "nest/protocol.h"
#include "nest/route.h"
#include "nest/cli.h"
#include "conf/conf.h"
#include "lib/string.h"
#include "lib/alloca.h"

#include "static.h"

static inline rtable *
p_igp_table(struct proto *p)
{
  struct static_config *cf = (void *) p->cf;
  return cf->igp_table ? cf->igp_table->table : p->table;
}


static void
static_install(struct proto *p, struct static_route *r, struct iface *ifa)
{
  net *n;
  rta a, *aa;
  rte *e;

  if (r->installed)
    return;

  DBG("Installing static route %I/%d, rtd=%d\n", r->net, r->masklen, r->dest);
  bzero(&a, sizeof(a));
  a.proto = p;
  a.source = (r->dest == RTD_DEVICE) ? RTS_STATIC_DEVICE : RTS_STATIC;
  a.scope = SCOPE_UNIVERSE;
  a.cast = RTC_UNICAST;
  a.dest = r->dest;
  a.gw = r->via;
  a.iface = ifa;

  if (r->dest == RTD_MULTIPATH)
    {
      struct static_route *r2;
      struct mpnh *nhs = NULL;
      struct mpnh **nhp = &nhs;

      for (r2 = r->mp_next; r2; r2 = r2->mp_next)
	if (r2->installed)
	  {
	    struct mpnh *nh = alloca(sizeof(struct mpnh));
	    nh->gw = r2->via;
	    nh->iface = r2->neigh->iface;
	    nh->weight = r2->masklen; /* really */
	    nh->next = NULL;
	    *nhp = nh;
	    nhp = &(nh->next);
	  }

      /* There is at least one nexthop */
      if (!nhs->next)
	{
	  /* Fallback to unipath route for exactly one nexthop */
	  a.dest = RTD_ROUTER;
	  a.gw = nhs->gw;
	  a.iface = nhs->iface;
	}
      else
	a.nexthops = nhs;
    }

  if (r->dest == RTDX_RECURSIVE)
    rta_set_recursive_next_hop(p->table, &a, p_igp_table(p), &r->via, &r->via);

  aa = rta_lookup(&a);
  n = net_get(p->table, r->net, r->masklen);
  e = rte_get_temp(aa);
  e->net = n;
  e->pflags = 0;
  rte_update(p->table, n, p, p, e);
  r->installed = 1;
}

static void
static_remove(struct proto *p, struct static_route *r)
{
  net *n;

  if (!r->installed)
    return;

  DBG("Removing static route %I/%d\n", r->net, r->masklen);
  n = net_find(p->table, r->net, r->masklen);
  if (n)
    rte_update(p->table, n, p, p, NULL);
  r->installed = 0;
}

static int
static_decide(struct static_config *cf, struct static_route *r)
{
  /* r->dest != RTD_MULTIPATH, but may be RTD_NONE (part of multipath route)
     the route also have to be valid (r->neigh != NULL) */

  struct iface *ifa = r->neigh->iface;

  if (!ifa)
    return 0;

  if (cf->check_link && !(ifa->flags & IF_LINK_UP))
    return 0;

  return 1;
}


static void
static_add(struct proto *p, struct static_config *cf, struct static_route *r)
{
  DBG("static_add(%I/%d,%d)\n", r->net, r->masklen, r->dest);
  switch (r->dest)
    {
    case RTD_ROUTER:
      {
	struct neighbor *n = neigh_find(p, &r->via, NEF_STICKY);
	if (n)
	  {
	    r->chain = n->data;
	    n->data = r;
	    r->neigh = n;
	    if (static_decide(cf, r))
	      static_install(p, r, n->iface);
	    else
	      static_remove(p, r);
	  }
	else
	  {
	    log(L_ERR "Static route destination %I is invalid. Ignoring.", r->via);
	    static_remove(p, r);
	  }
	break;
      }

    case RTD_DEVICE:
      break;

    case RTD_MULTIPATH:
      {
	int count = 0;
	struct static_route *r2;

	for (r2 = r->mp_next; r2; r2 = r2->mp_next)
	  {
	    struct neighbor *n = neigh_find(p, &r2->via, NEF_STICKY);
	    if (n)
	      {
		r2->chain = n->data;
		n->data = r2;
		r2->neigh = n;
		r2->installed = static_decide(cf, r2);
		count += r2->installed;
	      }
	    else
	      {
		log(L_ERR "Static route destination %I is invalid. Ignoring.", r2->via);
		r2->installed = 0;
	      }
	  }

	if (count)
	  static_install(p, r, NULL);
	else
	  static_remove(p, r);
	break;
      }

    default:
      static_install(p, r, NULL);
    }
}

static int
static_start(struct proto *p)
{
  struct static_config *cf = (void *) p->cf;
  struct static_route *r;

  DBG("Static: take off!\n");

  if (cf->igp_table)
    rt_lock_table(cf->igp_table->table);

  WALK_LIST(r, cf->other_routes)
    static_add(p, cf, r);
  return PS_UP;
}

static int
static_shutdown(struct proto *p)
{
  struct static_config *cf = (void *) p->cf;
  struct static_route *r;

  /* Just reset the flag, the routes will be flushed by the nest */
  WALK_LIST(r, cf->iface_routes)
    r->installed = 0;
  WALK_LIST(r, cf->other_routes)
    r->installed = 0;

  return PS_DOWN;
}

static void
static_cleanup(struct proto *p)
{
  struct static_config *cf = (void *) p->cf;

  if (cf->igp_table)
    rt_unlock_table(cf->igp_table->table);
}


static void
static_neigh_notify(struct neighbor *n)
{
  struct proto *p = n->proto;
  struct static_route *r;

  DBG("Static: neighbor notify for %I: iface %p\n", n->addr, n->iface);
  for(r=n->data; r; r=r->chain)
    switch (r->dest)
      {
      case RTD_ROUTER:
	if (static_decide((struct static_config *) p->cf, r))
	  static_install(p, r, n->iface);
	else
	  static_remove(p, r);
	break;

      case RTD_NONE: /* a part of multipath route */
	{
	  int decision = static_decide((struct static_config *) p->cf, r);
	  if (decision == r->installed)
	    break; /* no change */
	  r->installed = decision;

	  struct static_route *r1, *r2;
	  int count = 0;
	  r1 = (void *) r->if_name; /* really */
	  for (r2 = r1->mp_next; r2; r2 = r2->mp_next)
	    count += r2->installed;

	  if (count)
	    {
	      /* Set of nexthops changed - force reinstall */
	      r1->installed = 0;
	      static_install(p, r1, NULL);
	    }
	  else
	    static_remove(p, r1);

	  break;
	}
      }
}

static void
static_dump_rt(struct static_route *r)
{
  debug("%-1I/%2d: ", r->net, r->masklen);
  switch (r->dest)
    {
    case RTD_ROUTER:
      debug("via %I\n", r->via);
      break;
    case RTD_DEVICE:
      debug("dev %s\n", r->if_name);
      break;
    default:
      debug("rtd %d\n", r->dest);
      break;
    }
}

static void
static_dump(struct proto *p)
{
  struct static_config *c = (void *) p->cf;
  struct static_route *r;

  debug("Independent static routes:\n");
  WALK_LIST(r, c->other_routes)
    static_dump_rt(r);
  debug("Device static routes:\n");
  WALK_LIST(r, c->iface_routes)
    static_dump_rt(r);
}

static void
static_if_notify(struct proto *p, unsigned flags, struct iface *i)
{
  struct static_route *r;
  struct static_config *c = (void *) p->cf;

  if (flags & IF_CHANGE_UP)
    {
      WALK_LIST(r, c->iface_routes)
	if (!strcmp(r->if_name, i->name))
	  static_install(p, r, i);
    }
  else if (flags & IF_CHANGE_DOWN)
    {
      WALK_LIST(r, c->iface_routes)
	if (!strcmp(r->if_name, i->name))
	  static_remove(p, r);
    }
}

void
static_init_config(struct static_config *c)
{
  c->c.preference = DEF_PREF_STATIC;
  init_list(&c->iface_routes);
  init_list(&c->other_routes);
}

static struct proto *
static_init(struct proto_config *c)
{
  struct proto *p = proto_new(c, sizeof(struct proto));

  p->neigh_notify = static_neigh_notify;
  p->if_notify = static_if_notify;
  return p;
}

static inline int
static_same_net(struct static_route *x, struct static_route *y)
{
  return ipa_equal(x->net, y->net) && (x->masklen == y->masklen);
}

static inline int
static_same_dest(struct static_route *x, struct static_route *y)
{
  if (x->dest != y->dest)
    return 0;

  switch (x->dest)
    {
    case RTD_ROUTER:
      return ipa_equal(x->via, y->via);

    case RTD_DEVICE:
      return !strcmp(x->if_name, y->if_name);

    case RTD_MULTIPATH:
      for (x = x->mp_next, y = y->mp_next;
	   x && y;
	   x = x->mp_next, y = y->mp_next)
	if (!ipa_equal(x->via, y->via))
	  return 0;
      return !x && !y;

    case RTDX_RECURSIVE:
      return ipa_equal(x->via, y->via);

    default:
      return 1;
    }
}

static void
static_match(struct proto *p, struct static_route *r, struct static_config *n)
{
  struct static_route *t;

  /*
   * For given old route *r we find whether a route to the same
   * network is also in the new route list. In that case, we keep the
   * route and possibly update the route later if destination changed.
   * Otherwise, we remove the route.
   */

  if (r->neigh)
    r->neigh->data = NULL;
  WALK_LIST(t, n->iface_routes)
    if (static_same_net(r, t))
      {
	t->installed = r->installed && static_same_dest(r, t);
	return;
      }
  WALK_LIST(t, n->other_routes)
    if (static_same_net(r, t))
      {
	t->installed = r->installed && static_same_dest(r, t);
	return;
      }
  static_remove(p, r);
}

static inline rtable *
cf_igp_table(struct static_config *cf)
{
  return cf->igp_table ? cf->igp_table->table : NULL;
}

static int
static_reconfigure(struct proto *p, struct proto_config *new)
{
  struct static_config *o = (void *) p->cf;
  struct static_config *n = (void *) new;
  struct static_route *r;

  if (cf_igp_table(o) != cf_igp_table(n))
    return 0;

  /* Delete all obsolete routes and reset neighbor entries */
  WALK_LIST(r, o->iface_routes)
    static_match(p, r, n);
  WALK_LIST(r, o->other_routes)
    static_match(p, r, n);

  /* Now add all new routes, those not changed will be ignored by static_install() */
  WALK_LIST(r, n->iface_routes)
    {
      struct iface *ifa;
      if (ifa = if_find_by_name(r->if_name))
	static_install(p, r, ifa);
    }
  WALK_LIST(r, n->other_routes)
    static_add(p, n, r);

  return 1;
}

static void
static_copy_routes(list *dlst, list *slst)
{
  struct static_route *dr, *sr;

  init_list(dlst);
  WALK_LIST(sr, *slst)
    {
      /* copy one route */
      dr = cfg_alloc(sizeof(struct static_route));
      memcpy(dr, sr, sizeof(struct static_route));

      /* This fn is supposed to be called on fresh src routes, which have 'live'
	 fields (like .chain, .neigh or .installed) zero, so no need to zero them */

      /* We need to copy multipath chain, because there are backptrs in 'if_name' */
      if (dr->dest == RTD_MULTIPATH)
	{
	  struct static_route *md, *ms, **mp_last;

	  mp_last = &(dr->mp_next);
	  for (ms = sr->mp_next; ms; ms = ms->mp_next)
	    {
	      md = cfg_alloc(sizeof(struct static_route));
	      memcpy(md, ms, sizeof(struct static_route));
	      md->if_name = (void *) dr; /* really */

	      *mp_last = md;
	      mp_last = &(md->mp_next);
	    }
	  *mp_last = NULL;
	}

      add_tail(dlst, (node *) dr);
    }
}

static void
static_copy_config(struct proto_config *dest, struct proto_config *src)
{
  struct static_config *d = (struct static_config *) dest;
  struct static_config *s = (struct static_config *) src;

  /* Shallow copy of everything */
  proto_copy_rest(dest, src, sizeof(struct static_config));

  /* Copy route lists */
  static_copy_routes(&d->iface_routes, &s->iface_routes);
  static_copy_routes(&d->other_routes, &s->other_routes);
}


struct protocol proto_static = {
  name:		"Static",
  template:	"static%d",
  init:		static_init,
  dump:		static_dump,
  start:	static_start,
  shutdown:	static_shutdown,
  cleanup:	static_cleanup,
  reconfigure:	static_reconfigure,
  copy_config:	static_copy_config
};

static void
static_show_rt(struct static_route *r)
{
  byte via[STD_ADDRESS_P_LENGTH + 16];

  switch (r->dest)
    {
    case RTD_ROUTER:	bsprintf(via, "via %I", r->via); break;
    case RTD_DEVICE:	bsprintf(via, "dev %s", r->if_name); break;
    case RTD_BLACKHOLE:	bsprintf(via, "blackhole"); break;
    case RTD_UNREACHABLE: bsprintf(via, "unreachable"); break;
    case RTD_PROHIBIT:	bsprintf(via, "prohibited"); break;
    case RTD_MULTIPATH:	bsprintf(via, "multipath"); break;
    case RTDX_RECURSIVE: bsprintf(via, "recursive %I", r->via); break;
    default:		bsprintf(via, "???");
    }
  cli_msg(-1009, "%I/%d %s%s", r->net, r->masklen, via, r->installed ? "" : " (dormant)");

  struct static_route *r2;
  if (r->dest == RTD_MULTIPATH)
    for (r2 = r->mp_next; r2; r2 = r2->mp_next)
      cli_msg(-1009, "\tvia %I weight %d%s", r2->via, r2->masklen + 1, /* really */
	      r2->installed ? "" : " (dormant)");
}

void
static_show(struct proto *P)
{
  struct static_config *c = (void *) P->cf;
  struct static_route *r;

  WALK_LIST(r, c->other_routes)
    static_show_rt(r);
  WALK_LIST(r, c->iface_routes)
    static_show_rt(r);
  cli_msg(0, "");
}