bird/proto/static/static.c
Ondrej Zajicek (work) a1f5e514ef Implement onlink flag for nexthops
Add proper support for per-nexthop onlink flag in routes to handle next
hop addresses that are not covered by interface IP ranges. Supported by
kernel and static protocols.

Thanks to Vincent Bernat for the idea.
2017-07-04 23:36:21 +02:00

671 lines
15 KiB
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 a list
* of static routes. Routes of dest RTD_UNICAST have associated sticky node in
* the neighbor cache to be notified about gaining or losing the neighbor and
* about interface-related events (e.g. link down). They may also have a BFD
* request if associated with a BFD session. When a route is notified,
* static_decide() is used to see whether the route activeness is changed. In
* such case, the route is marked as dirty and scheduled to be announced or
* withdrawn, which is done asynchronously from event hook. Routes of other
* types (e.g. black holes) are announced all the time.
*
* Multipath routes are a bit tricky. To represent additional next hops, dummy
* static_route nodes are used, which are chained using @mp_next field and link
* to the master node by @mp_head field. Each next hop has a separate neighbor
* entry and an activeness state, but the master node is used for most purposes.
* Note that most functions DO NOT accept dummy nodes as arguments.
*
* 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, removes the obsolete ones and reannounces changed ones.
*/
#undef LOCAL_DEBUG
#include <stdlib.h>
#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 "filter/filter.h"
#include "lib/string.h"
#include "lib/alloca.h"
#include "static.h"
static linpool *static_lp;
static void
static_announce_rte(struct static_proto *p, struct static_route *r)
{
rta *a = allocz(RTA_MAX_SIZE);
a->src = p->p.main_source;
a->source = RTS_STATIC;
a->scope = SCOPE_UNIVERSE;
a->dest = r->dest;
if (r->dest == RTD_UNICAST)
{
struct static_route *r2;
struct nexthop *nhs = NULL;
for (r2 = r; r2; r2 = r2->mp_next)
{
if (!r2->active)
continue;
struct nexthop *nh = allocz(NEXTHOP_MAX_SIZE);
nh->gw = r2->via;
nh->iface = r2->neigh->iface;
nh->flags = r2->onlink ? RNF_ONLINK : 0;
nh->weight = r2->weight;
if (r2->mls)
{
nh->labels = r2->mls->len;
memcpy(nh->label, r2->mls->stack, r2->mls->len * sizeof(u32));
}
nexthop_insert(&nhs, nh);
}
if (!nhs)
goto withdraw;
nexthop_link(a, nhs);
}
if (r->dest == RTDX_RECURSIVE)
{
rtable *tab = ipa_is_ip4(r->via) ? p->igp_table_ip4 : p->igp_table_ip6;
rta_set_recursive_next_hop(p->p.main_channel->table, a, tab, r->via, IPA_NONE, r->mls);
}
/* Already announced */
if (r->state == SRS_CLEAN)
return;
/* We skip rta_lookup() here */
rte *e = rte_get_temp(a);
e->pflags = 0;
if (r->cmds)
f_eval_rte(r->cmds, &e, static_lp);
rte_update(&p->p, r->net, e);
r->state = SRS_CLEAN;
if (r->cmds)
lp_flush(static_lp);
return;
withdraw:
if (r->state == SRS_DOWN)
return;
rte_update(&p->p, r->net, NULL);
r->state = SRS_DOWN;
}
static void
static_mark_rte(struct static_proto *p, struct static_route *r)
{
if (r->state == SRS_DIRTY)
return;
r->state = SRS_DIRTY;
BUFFER_PUSH(p->marked) = r;
if (!ev_active(p->event))
ev_schedule(p->event);
}
static void
static_announce_marked(void *P)
{
struct static_proto *p = P;
BUFFER_WALK(p->marked, r)
static_announce_rte(P, r);
BUFFER_FLUSH(p->marked);
}
static void
static_bfd_notify(struct bfd_request *req);
static void
static_update_bfd(struct static_proto *p, struct static_route *r)
{
/* The @r is a RTD_UNICAST next hop, may be a dummy node */
struct neighbor *nb = r->neigh;
int bfd_up = (nb->scope > 0) && r->use_bfd;
if (bfd_up && !r->bfd_req)
{
// ip_addr local = ipa_nonzero(r->local) ? r->local : nb->ifa->ip;
r->bfd_req = bfd_request_session(p->p.pool, r->via, nb->ifa->ip, nb->iface,
static_bfd_notify, r);
}
if (!bfd_up && r->bfd_req)
{
rfree(r->bfd_req);
r->bfd_req = NULL;
}
}
static int
static_decide(struct static_proto *p, struct static_route *r)
{
/* The @r is a RTD_UNICAST next hop, may be a dummy node */
struct static_config *cf = (void *) p->p.cf;
uint old_active = r->active;
if (r->neigh->scope < 0)
goto fail;
if (cf->check_link && !(r->neigh->iface->flags & IF_LINK_UP))
goto fail;
if (r->bfd_req && (r->bfd_req->state != BFD_STATE_UP))
goto fail;
r->active = 1;
return !old_active;
fail:
r->active = 0;
return old_active;
}
static void
static_add_rte(struct static_proto *p, struct static_route *r)
{
if (r->dest == RTD_UNICAST)
{
struct static_route *r2;
struct neighbor *n;
for (r2 = r; r2; r2 = r2->mp_next)
{
n = ipa_nonzero(r2->via) ?
neigh_find2(&p->p, &r2->via, r2->iface,
NEF_STICKY | (r2->onlink ? NEF_ONLINK : 0)) :
neigh_find_iface(&p->p, r2->iface);
if (!n)
{
log(L_WARN "Invalid next hop %I of static route %N", r2->via, r2->net);
continue;
}
r2->neigh = n;
r2->chain = n->data;
n->data = r2;
static_update_bfd(p, r2);
static_decide(p, r2);
}
}
static_announce_rte(p, r);
}
static void
static_reset_rte(struct static_proto *p UNUSED, struct static_route *r)
{
struct static_route *r2;
for (r2 = r; r2; r2 = r2->mp_next)
{
r2->neigh = NULL;
r2->chain = NULL;
r2->state = 0;
r2->active = 0;
rfree(r2->bfd_req);
r2->bfd_req = NULL;
}
}
static void
static_remove_rte(struct static_proto *p, struct static_route *r)
{
if (r->state)
rte_update(&p->p, r->net, NULL);
static_reset_rte(p, r);
}
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_UNICAST:
for (; x && y; x = x->mp_next, y = y->mp_next)
{
if (!ipa_equal(x->via, y->via) ||
(x->iface != y->iface) ||
(x->onlink != y->onlink) ||
(x->weight != y->weight) ||
(x->use_bfd != y->use_bfd) ||
(!x->mls != !y->mls) ||
((x->mls) && (y->mls) && (x->mls->len != y->mls->len)))
return 0;
if (!x->mls)
continue;
for (uint i = 0; i < x->mls->len; i++)
if (x->mls->stack[i] != y->mls->stack[i])
return 0;
}
return !x && !y;
case RTDX_RECURSIVE:
if (!ipa_equal(x->via, y->via) ||
(!x->mls != !y->mls) ||
((x->mls) && (y->mls) && (x->mls->len != y->mls->len)))
return 0;
if (!x->mls)
return 1;
for (uint i = 0; i < x->mls->len; i++)
if (x->mls->stack[i] != y->mls->stack[i])
return 0;
return 1;
default:
return 1;
}
}
static inline int
static_same_rte(struct static_route *or, struct static_route *nr)
{
/* Note that i_same() requires arguments in (new, old) order */
return static_same_dest(or, nr) && i_same(nr->cmds, or->cmds);
}
static void
static_reconfigure_rte(struct static_proto *p, struct static_route *or, struct static_route *nr)
{
if ((or->state == SRS_CLEAN) && !static_same_rte(or, nr))
nr->state = SRS_DIRTY;
else
nr->state = or->state;
static_add_rte(p, nr);
static_reset_rte(p, or);
}
static void
static_neigh_notify(struct neighbor *n)
{
struct static_proto *p = (void *) 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)
{
static_update_bfd(p, r);
if (static_decide(p, r))
static_mark_rte(p, r->mp_head);
}
}
static void
static_bfd_notify(struct bfd_request *req)
{
struct static_route *r = req->data;
struct static_proto *p = (void *) r->neigh->proto;
// if (req->down) TRACE(D_EVENTS, "BFD session down for nbr %I on %s", XXXX);
if (static_decide(p, r))
static_mark_rte(p, r->mp_head);
}
static int
static_rte_mergable(rte *pri UNUSED, rte *sec UNUSED)
{
return 1;
}
static void
static_postconfig(struct proto_config *CF)
{
struct static_config *cf = (void *) CF;
struct static_route *r;
if (EMPTY_LIST(CF->channels))
cf_error("Channel not specified");
struct channel_config *cc = proto_cf_main_channel(CF);
if (!cf->igp_table_ip4)
cf->igp_table_ip4 = (cc->table->addr_type == NET_IP4) ?
cc->table : cf->c.global->def_tables[NET_IP4];
if (!cf->igp_table_ip6)
cf->igp_table_ip6 = (cc->table->addr_type == NET_IP6) ?
cc->table : cf->c.global->def_tables[NET_IP6];
WALK_LIST(r, cf->routes)
if (r->net && (r->net->type != CF->net_type))
cf_error("Route %N incompatible with channel type", r->net);
}
static struct proto *
static_init(struct proto_config *CF)
{
struct proto *P = proto_new(CF);
struct static_proto *p = (void *) P;
struct static_config *cf = (void *) CF;
P->main_channel = proto_add_channel(P, proto_cf_main_channel(CF));
P->neigh_notify = static_neigh_notify;
P->rte_mergable = static_rte_mergable;
if (cf->igp_table_ip4)
p->igp_table_ip4 = cf->igp_table_ip4->table;
if (cf->igp_table_ip6)
p->igp_table_ip6 = cf->igp_table_ip6->table;
return P;
}
static int
static_start(struct proto *P)
{
struct static_proto *p = (void *) P;
struct static_config *cf = (void *) P->cf;
struct static_route *r;
if (!static_lp)
static_lp = lp_new(&root_pool, LP_GOOD_SIZE(1024));
if (p->igp_table_ip4)
rt_lock_table(p->igp_table_ip4);
if (p->igp_table_ip6)
rt_lock_table(p->igp_table_ip6);
p->event = ev_new(p->p.pool);
p->event->hook = static_announce_marked;
p->event->data = p;
BUFFER_INIT(p->marked, p->p.pool, 4);
/* We have to go UP before routes could be installed */
proto_notify_state(P, PS_UP);
WALK_LIST(r, cf->routes)
static_add_rte(p, r);
return PS_UP;
}
static int
static_shutdown(struct proto *P)
{
struct static_proto *p = (void *) 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->routes)
static_reset_rte(p, r);
return PS_DOWN;
}
static void
static_cleanup(struct proto *P)
{
struct static_proto *p = (void *) P;
if (p->igp_table_ip4)
rt_unlock_table(p->igp_table_ip4);
if (p->igp_table_ip6)
rt_unlock_table(p->igp_table_ip6);
}
static void
static_dump_rte(struct static_route *r)
{
debug("%-1N: ", r->net);
if (r->dest == RTD_UNICAST)
if (r->iface && ipa_zero(r->via))
debug("dev %s\n", r->iface->name);
else
debug("via %I%J\n", r->via, r->iface);
else
debug("rtd %d\n", r->dest);
}
static void
static_dump(struct proto *P)
{
struct static_config *c = (void *) P->cf;
struct static_route *r;
debug("Static routes:\n");
WALK_LIST(r, c->routes)
static_dump_rte(r);
}
#define IGP_TABLE(cf, sym) ((cf)->igp_table_##sym ? (cf)->igp_table_##sym ->table : NULL )
static inline int
static_cmp_rte(const void *X, const void *Y)
{
struct static_route *x = *(void **)X, *y = *(void **)Y;
return net_compare(x->net, y->net);
}
static int
static_reconfigure(struct proto *P, struct proto_config *CF)
{
struct static_proto *p = (void *) P;
struct static_config *o = (void *) P->cf;
struct static_config *n = (void *) CF;
struct static_route *r, *r2, *or, *nr;
/* Check change in IGP tables */
if ((IGP_TABLE(o, ip4) != IGP_TABLE(n, ip4)) ||
(IGP_TABLE(o, ip6) != IGP_TABLE(n, ip6)))
return 0;
if (!proto_configure_channel(P, &P->main_channel, proto_cf_main_channel(CF)))
return 0;
p->p.cf = CF;
/* Reset route lists in neighbor entries */
WALK_LIST(r, o->routes)
for (r2 = r; r2; r2 = r2->mp_next)
if (r2->neigh)
r2->neigh->data = NULL;
/* Reconfigure initial matching sequence */
for (or = HEAD(o->routes), nr = HEAD(n->routes);
NODE_VALID(or) && NODE_VALID(nr) && net_equal(or->net, nr->net);
or = NODE_NEXT(or), nr = NODE_NEXT(nr))
static_reconfigure_rte(p, or, nr);
if (!NODE_VALID(or) && !NODE_VALID(nr))
return 1;
/* Reconfigure remaining routes, sort them to find matching pairs */
struct static_route *or2, *nr2, **orbuf, **nrbuf;
uint ornum = 0, nrnum = 0, orpos = 0, nrpos = 0, i;
for (or2 = or; NODE_VALID(or2); or2 = NODE_NEXT(or2))
ornum++;
for (nr2 = nr; NODE_VALID(nr2); nr2 = NODE_NEXT(nr2))
nrnum++;
orbuf = xmalloc(ornum * sizeof(void *));
nrbuf = xmalloc(nrnum * sizeof(void *));
for (i = 0, or2 = or; i < ornum; i++, or2 = NODE_NEXT(or2))
orbuf[i] = or2;
for (i = 0, nr2 = nr; i < nrnum; i++, nr2 = NODE_NEXT(nr2))
nrbuf[i] = nr2;
qsort(orbuf, ornum, sizeof(struct static_route *), static_cmp_rte);
qsort(nrbuf, nrnum, sizeof(struct static_route *), static_cmp_rte);
while ((orpos < ornum) && (nrpos < nrnum))
{
int x = net_compare(orbuf[orpos]->net, nrbuf[nrpos]->net);
if (x < 0)
static_remove_rte(p, orbuf[orpos++]);
else if (x > 0)
static_add_rte(p, nrbuf[nrpos++]);
else
static_reconfigure_rte(p, orbuf[orpos++], nrbuf[nrpos++]);
}
while (orpos < ornum)
static_remove_rte(p, orbuf[orpos++]);
while (nrpos < nrnum)
static_add_rte(p, nrbuf[nrpos++]);
xfree(orbuf);
xfree(nrbuf);
return 1;
}
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;
struct static_route *srt, *snh;
/* Copy route list */
init_list(&d->routes);
WALK_LIST(srt, s->routes)
{
struct static_route *drt = NULL, *dnh = NULL, **dnp = &drt;
for (snh = srt; snh; snh = snh->mp_next)
{
dnh = cfg_alloc(sizeof(struct static_route));
memcpy(dnh, snh, sizeof(struct static_route));
if (!drt)
add_tail(&d->routes, &(dnh->n));
*dnp = dnh;
dnp = &(dnh->mp_next);
if (snh->mp_head)
dnh->mp_head = drt;
}
}
}
static void
static_show_rt(struct static_route *r)
{
switch (r->dest)
{
case RTD_UNICAST:
{
struct static_route *r2;
cli_msg(-1009, "%N", r->net);
for (r2 = r; r2; r2 = r2->mp_next)
{
if (r2->iface && ipa_zero(r2->via))
cli_msg(-1009, "\tdev %s%s", r2->iface->name,
r2->active ? "" : " (dormant)");
else
cli_msg(-1009, "\tvia %I%J%s%s%s", r2->via, r2->iface,
r2->onlink ? " onlink" : "",
r2->bfd_req ? " (bfd)" : "",
r2->active ? "" : " (dormant)");
}
break;
}
case RTD_NONE:
case RTD_BLACKHOLE:
case RTD_UNREACHABLE:
case RTD_PROHIBIT:
cli_msg(-1009, "%N\t%s", r->net, rta_dest_names[r->dest]);
break;
case RTDX_RECURSIVE:
cli_msg(-1009, "%N\trecursive %I", r->net, r->via);
break;
}
}
void
static_show(struct proto *P)
{
struct static_config *c = (void *) P->cf;
struct static_route *r;
WALK_LIST(r, c->routes)
static_show_rt(r);
cli_msg(0, "");
}
struct protocol proto_static = {
.name = "Static",
.template = "static%d",
.preference = DEF_PREF_STATIC,
.channel_mask = NB_ANY,
.proto_size = sizeof(struct static_proto),
.config_size = sizeof(struct static_config),
.postconfig = static_postconfig,
.init = static_init,
.dump = static_dump,
.start = static_start,
.shutdown = static_shutdown,
.cleanup = static_cleanup,
.reconfigure = static_reconfigure,
.copy_config = static_copy_config
};