Jerry/bird
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
bird/nest/rt-table.c
Ondrej Zajicek 40b65f947a Fixes bug in pipe route filtering. 
Routes comming through pipe from primary to secondary table were
filtered by both EXPORT and IMPORT filters, but they should be
only filtered by EXPORT filters.
2009-03-25 19:05:52 +01:00

1145 lines
28 KiB
C
Raw Blame History

/*
* BIRD -- Routing Tables
*
* (c) 1998--2000 Martin Mares <mj@ucw.cz>
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
/**
* DOC: Routing tables
*
* Routing tables are probably the most important structures BIRD uses. They
* hold all the information about known networks, the associated routes and
* their attributes.
*
* There are multiple routing tables (a primary one together with any
* number of secondary ones if requested by the configuration). Each table
* is basically a FIB containing entries describing the individual
* destination networks. For each network (represented by structure &net),
* there is a one-way linked list of route entries (&rte), the first entry
* on the list being the best one (i.e., the one we currently use
* for routing), the order of the other ones is undetermined.
*
* The &rte contains information specific to the route (preference, protocol
* metrics, time of last modification etc.) and a pointer to a &rta structure
* (see the route attribute module for a precise explanation) holding the
* remaining route attributes which are expected to be shared by multiple
* routes in order to conserve memory.
*/
#undef LOCAL_DEBUG
#include "nest/bird.h"
#include "nest/route.h"
#include "nest/protocol.h"
#include "nest/cli.h"
#include "nest/iface.h"
#include "lib/resource.h"
#include "lib/event.h"
#include "lib/string.h"
#include "conf/conf.h"
#include "filter/filter.h"
#include "lib/string.h"
#include "lib/alloca.h"
static slab *rte_slab;
static linpool *rte_update_pool;
static pool *rt_table_pool;
static list routing_tables;
static void rt_format_via(rte *e, byte *via);
static void
rte_init(struct fib_node *N)
{
net *n = (net *) N;
N->flags = 0;
n->routes = NULL;
}
/**
* rte_find - find a route
* @net: network node
* @p: protocol
*
* The rte_find() function returns a route for destination @net
* which belongs has been defined by protocol @p.
*/
rte *
rte_find(net *net, struct proto *p)
{
rte *e = net->routes;
while (e && e->attrs->proto != p)
e = e->next;
return e;
}
/**
* rte_get_temp - get a temporary &rte
* @a: attributes to assign to the new route (a &rta; in case it's
* un-cached, rte_update() will create a cached copy automatically)
*
* Create a temporary &rte and bind it with the attributes @a.
* Also set route preference to the default preference set for
* the protocol.
*/
rte *
rte_get_temp(rta *a)
{
rte *e = sl_alloc(rte_slab);
e->attrs = a;
e->flags = 0;
e->pref = a->proto->preference;
return e;
}
rte *
rte_do_cow(rte *r)
{
rte *e = sl_alloc(rte_slab);
memcpy(e, r, sizeof(rte));
e->attrs = rta_clone(r->attrs);
e->flags = 0;
return e;
}
static int /* Actually better or at least as good as */
rte_better(rte *new, rte *old)
{
int (*better)(rte *, rte *);
if (!old)
return 1;
if (new->pref > old->pref)
return 1;
if (new->pref < old->pref)
return 0;
if (new->attrs->proto->proto != old->attrs->proto->proto)
{
/*
* If the user has configured protocol preferences, so that two different protocols
* have the same preference, try to break the tie by comparing addresses. Not too
* useful, but keeps the ordering of routes unambiguous.
*/
return new->attrs->proto->proto > old->attrs->proto->proto;
}
if (better = new->attrs->proto->rte_better)
return better(new, old);
return 0;
}
static void
rte_trace(struct proto *p, rte *e, int dir, char *msg)
{
byte via[STD_ADDRESS_P_LENGTH+32];
rt_format_via(e, via);
log(L_TRACE "%s %c %s %I/%d %s", p->name, dir, msg, e->net->n.prefix, e->net->n.pxlen, via);
}
static inline void
rte_trace_in(unsigned int flag, struct proto *p, rte *e, char *msg)
{
if (p->debug & flag)
rte_trace(p, e, '>', msg);
}
static inline void
rte_trace_out(unsigned int flag, struct proto *p, rte *e, char *msg)
{
if (p->debug & flag)
rte_trace(p, e, '<', msg);
}
static inline void
do_rte_announce(struct announce_hook *a, net *net, rte *new, rte *old, ea_list *tmpa, int class)
{
struct proto *p = a->proto;
rte *new0 = new;
rte *old0 = old;
int ok;
if (new)
{
char *drop_reason = NULL;
if ((class & IADDR_SCOPE_MASK) < p->min_scope)
drop_reason = "out of scope";
else if ((ok = p->import_control ? p->import_control(p, &new, &tmpa, rte_update_pool) : 0) < 0)
drop_reason = "rejected by protocol";
else if (ok)
rte_trace_out(D_FILTERS, p, new, "forced accept by protocol");
else if (p->out_filter == FILTER_REJECT ||
p->out_filter && f_run(p->out_filter, &new, &tmpa, rte_update_pool, FF_FORCE_TMPATTR) > F_ACCEPT)
drop_reason = "filtered out";
if (drop_reason)
{
rte_trace_out(D_FILTERS, p, new, drop_reason);
if (new != new0)
rte_free(new);
new = NULL;
}
}
if (old && p->out_filter)
{
if (p->out_filter == FILTER_REJECT)
old = NULL;
else
{
ea_list *tmpb = p->make_tmp_attrs ? p->make_tmp_attrs(old, rte_update_pool) : NULL;
ok = p->import_control ? p->import_control(p, &old, &tmpb, rte_update_pool) : 0;
if (ok < 0 || (!ok && f_run(p->out_filter, &old, &tmpb, rte_update_pool, FF_FORCE_TMPATTR) > F_ACCEPT))
{
if (old != old0)
rte_free(old);
old = NULL;
}
}
}
if (p->debug & D_ROUTES)
{
if (new && old)
rte_trace_out(D_ROUTES, p, new, "replaced");
else if (new)
rte_trace_out(D_ROUTES, p, new, "added");
else if (old)
rte_trace_out(D_ROUTES, p, old, "removed");
}
if (!new && !old)
return;
if (!new)
p->rt_notify(p, 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, net, new, old, tmpa);
t->next = NULL;
}
else
p->rt_notify(p, net, new, old, new->attrs->eattrs);
if (new && new != new0) /* Discard temporary rte's */
rte_free(new);
if (old && old != old0)
rte_free(old);
}
/**
* rte_announce - announce a routing table change
* @tab: table the route has been added to
* @net: network in question
* @new: the new route to be announced
* @old: previous optimal route for the same network
* @tmpa: a list of temporary attributes belonging to the new route
*
* This function gets a routing table update and announces it
* to all protocols connected to the same table by their announcement hooks.
*
* For each such protocol, we first call its import_control() hook which
* performs basic checks on the route (each protocol has a right to veto
* or force accept of the route before any filter is asked) and adds default
* values of attributes specific to the new protocol (metrics, tags etc.).
* Then it consults the protocol's export filter and if it accepts the
* route, the rt_notify() hook of the protocol gets called.
*/
static void
rte_announce(rtable *tab, net *net, rte *new, rte *old, ea_list *tmpa)
{
struct announce_hook *a;
int class = ipa_classify(net->n.prefix);
WALK_LIST(a, tab->hooks)
{
ASSERT(a->proto->core_state == FS_HAPPY || a->proto->core_state == FS_FEEDING);
do_rte_announce(a, net, new, old, tmpa, class);
}
}
static inline int
rte_validate(rte *e)
{
int c;
net *n = e->net;
if (ipa_nonzero(ipa_and(n->n.prefix, ipa_not(ipa_mkmask(n->n.pxlen)))))
{
log(L_BUG "Ignoring bogus prefix %I/%d received via %s",
n->n.prefix, n->n.pxlen, e->attrs->proto->name);
return 0;
}
if (n->n.pxlen)
{
c = ipa_classify(n->n.prefix);
if (c < 0 || !(c & IADDR_HOST))
{
if (!ipa_nonzero(n->n.prefix))
{
/* Various default routes */
#ifdef IPV6
if (n->n.pxlen == 96)
#else
if (n->n.pxlen <= 1)
#endif
return 1;
}
log(L_WARN "Ignoring bogus route %I/%d received via %s",
n->n.prefix, n->n.pxlen, e->attrs->proto->name);
return 0;
}
if ((c & IADDR_SCOPE_MASK) < e->attrs->proto->min_scope)
{
log(L_WARN "Ignoring %s scope route %I/%d received from %I via %s",
ip_scope_text(c & IADDR_SCOPE_MASK),
n->n.prefix, n->n.pxlen, e->attrs->from, e->attrs->proto->name);
return 0;
}
}
return 1;
}
/**
* rte_free - delete a &rte
* @e: &rte to be deleted
*
* rte_free() deletes the given &rte from the routing table it's linked to.
*/
void
rte_free(rte *e)
{
if (e->attrs->aflags & RTAF_CACHED)
rta_free(e->attrs);
sl_free(rte_slab, e);
}
static inline void
rte_free_quick(rte *e)
{
rta_free(e->attrs);
sl_free(rte_slab, e);
}
static int
rte_same(rte *x, rte *y)
{
return
x->attrs == y->attrs &&
x->flags == y->flags &&
x->pflags == y->pflags &&
x->pref == y->pref &&
(!x->attrs->proto->rte_same || x->attrs->proto->rte_same(x, y));
}
static void
rte_recalculate(rtable *table, net *net, struct proto *p, rte *new, ea_list *tmpa)
{
rte *old_best = net->routes;
rte *old = NULL;
rte **k, *r, *s;
k = &net->routes; /* Find and remove original route from the same protocol */
while (old = *k)
{
if (old->attrs->proto == p)
{
if (new && rte_same(old, new))
{
/* No changes, ignore the new route */
rte_trace_in(D_ROUTES, p, new, "ignored");
rte_free_quick(new);
old->lastmod = now;
return;
}
*k = old->next;
break;
}
k = &old->next;
}
if (new && rte_better(new, old_best)) /* It's a new optimal route => announce and relink it */
{
rte_trace_in(D_ROUTES, p, new, "added [best]");
rte_announce(table, net, new, old_best, tmpa);
new->next = net->routes;
net->routes = new;
}
else
{
if (old == old_best) /* It has _replaced_ the old optimal route */
{
r = new; /* Find new optimal route and announce it */
for(s=net->routes; s; s=s->next)
if (rte_better(s, r))
r = s;
rte_announce(table, net, r, old_best, tmpa);
if (r) /* Re-link the new optimal route */
{
k = &net->routes;
while (s = *k)
{
if (s == r)
{
*k = r->next;
break;
}
k = &s->next;
}
r->next = net->routes;
net->routes = r;
}
else if (table->gc_counter++ >= table->config->gc_max_ops &&
table->gc_time + table->config->gc_min_time <= now)
ev_schedule(table->gc_event);
}
if (new) /* Link in the new non-optimal route */
{
new->next = old_best->next;
old_best->next = new;
rte_trace_in(D_ROUTES, p, new, "added");
}
else if (old && (p->debug & D_ROUTES))
{
if (old != old_best)
rte_trace_in(D_ROUTES, p, old, "removed");
else if (net->routes)
rte_trace_in(D_ROUTES, p, old, "removed [replaced]");
else
rte_trace_in(D_ROUTES, p, old, "removed [sole]");
}
}
if (old)
{
if (p->rte_remove)
p->rte_remove(net, old);
rte_free_quick(old);
}
if (new)
{
new->lastmod = now;
if (p->rte_insert)
p->rte_insert(net, new);
}
}
static int rte_update_nest_cnt; /* Nesting counter to allow recursive updates */
static inline void
rte_update_lock(void)
{
rte_update_nest_cnt++;
}
static inline void
rte_update_unlock(void)
{
if (!--rte_update_nest_cnt)
lp_flush(rte_update_pool);
}
/**
* rte_update - enter a new update to a routing table
* @table: table to be updated
* @net: network node
* @p: protocol submitting the update
* @new: a &rte representing the new route or %NULL for route removal.
*
* This function is called by the routing protocols whenever they discover
* a new route or wish to update/remove an existing route. The right announcement
* sequence is to build route attributes first (either un-cached with @aflags set
* to zero or a cached one using rta_lookup(); in this case please note that
* you need to increase the use count of the attributes yourself by calling
* rta_clone()), call rte_get_temp() to obtain a temporary &rte, fill in all
* the appropriate data and finally submit the new &rte by calling rte_update().
*
* When rte_update() gets any route, it automatically validates it (checks,
* whether the network and next hop address are valid IP addresses and also
* whether a normal routing protocol doesn't try to smuggle a host or link
* scope route to the table), converts all protocol dependent attributes stored
* in the &rte to temporary extended attributes, consults import filters of the
* protocol to see if the route should be accepted and/or its attributes modified,
* stores the temporary attributes back to the &rte.
*
* Now, having a "public" version of the route, we
* automatically find any old route defined by the protocol @p
* for network @n, replace it by the new one (or removing it if @new is %NULL),
* recalculate the optimal route for this destination and finally broadcast
* the change (if any) to all routing protocols by calling rte_announce().
*
* All memory used for attribute lists and other temporary allocations is taken
* from a special linear pool @rte_update_pool and freed when rte_update()
* finishes.
*/
void
rte_update(rtable *table, net *net, struct proto *p, rte *new)
{
ea_list *tmpa = NULL;
rte_update_lock();
if (new)
{
struct filter *filter = p->in_filter;
/* Do not filter routes going to the secondary side of the pipe,
that should only go through export filter.
FIXME Make a better check whether p is really a pipe. */
if (p->table != table)
filter = FILTER_ACCEPT;
if (!rte_validate(new))
{
rte_trace_in(D_FILTERS, p, new, "invalid");
goto drop;
}
if (filter == FILTER_REJECT)
{
rte_trace_in(D_FILTERS, p, new, "filtered out");
goto drop;
}
if (p->make_tmp_attrs)
tmpa = p->make_tmp_attrs(new, rte_update_pool);
if (filter)
{
ea_list *old_tmpa = tmpa;
int fr = f_run(filter, &new, &tmpa, rte_update_pool, 0);
if (fr > F_ACCEPT)
{
rte_trace_in(D_FILTERS, p, new, "filtered out");
goto drop;
}
if (tmpa != old_tmpa && p->store_tmp_attrs)
p->store_tmp_attrs(new, tmpa);
}
if (!(new->attrs->aflags & RTAF_CACHED)) /* Need to copy attributes */
new->attrs = rta_lookup(new->attrs);
new->flags |= REF_COW;
}
rte_recalculate(table, net, p, new, tmpa);
rte_update_unlock();
return;
drop:
rte_free(new);
rte_update_unlock();
}
void
rte_discard(rtable *t, rte *old) /* Non-filtered route deletion, used during garbage collection */
{
net *n = old->net;
struct proto *p = old->attrs->proto;
rte_update_lock();
rte_recalculate(t, n, p, NULL, NULL);
rte_update_unlock();
}
/**
* rte_dump - dump a route
* @e: &rte to be dumped
*
* This functions dumps contents of a &rte to debug output.
*/
void
rte_dump(rte *e)
{
net *n = e->net;
if (n)
debug("%-1I/%2d ", n->n.prefix, n->n.pxlen);
else
debug("??? ");
debug("KF=%02x PF=%02x pref=%d lm=%d ", n->n.flags, e->pflags, e->pref, now-e->lastmod);
rta_dump(e->attrs);
if (e->attrs->proto->proto->dump_attrs)
e->attrs->proto->proto->dump_attrs(e);
debug("\n");
}
/**
* rt_dump - dump a routing table
* @t: routing table to be dumped
*
* This function dumps contents of a given routing table to debug output.
*/
void
rt_dump(rtable *t)
{
rte *e;
net *n;
struct announce_hook *a;
debug("Dump of routing table <%s>\n", t->name);
#ifdef DEBUGGING
fib_check(&t->fib);
#endif
FIB_WALK(&t->fib, fn)
{
n = (net *) fn;
for(e=n->routes; e; e=e->next)
rte_dump(e);
}
FIB_WALK_END;
WALK_LIST(a, t->hooks)
debug("\tAnnounces routes to protocol %s\n", a->proto->name);
debug("\n");
}
/**
* rt_dump_all - dump all routing tables
*
* This function dumps contents of all routing tables to debug output.
*/
void
rt_dump_all(void)
{
rtable *t;
WALK_LIST(t, routing_tables)
rt_dump(t);
}
static void
rt_gc(void *tab)
{
rtable *t = tab;
DBG("Entered routing table garbage collector for %s after %d seconds and %d deletes\n",
t->name, (int)(now - t->gc_time), t->gc_counter);
rt_prune(t);
}
void
rt_setup(pool *p, rtable *t, char *name, struct rtable_config *cf)
{
bzero(t, sizeof(*t));
fib_init(&t->fib, p, sizeof(net), 0, rte_init);
t->name = name;
t->config = cf;
init_list(&t->hooks);
if (cf)
{
t->gc_event = ev_new(p);
t->gc_event->hook = rt_gc;
t->gc_event->data = t;
t->gc_time = now;
}
}
/**
* rt_init - initialize routing tables
*
* This function is called during BIRD startup. It initializes the
* routing table module.
*/
void
rt_init(void)
{
rta_init();
rt_table_pool = rp_new(&root_pool, "Routing tables");
rte_update_pool = lp_new(rt_table_pool, 4080);
rte_slab = sl_new(rt_table_pool, sizeof(rte));
init_list(&routing_tables);
}
/**
* rt_prune - prune a routing table
* @tab: routing table to be pruned
*
* This function is called whenever a protocol shuts down. It scans
* the routing table and removes all routes belonging to inactive
* protocols and also stale network entries.
*/
void
rt_prune(rtable *tab)
{
struct fib_iterator fit;
int rcnt = 0, rdel = 0, ncnt = 0, ndel = 0;
DBG("Pruning route table %s\n", tab->name);
#ifdef DEBUGGING
fib_check(&tab->fib);
#endif
FIB_ITERATE_INIT(&fit, &tab->fib);
again:
FIB_ITERATE_START(&tab->fib, &fit, f)
{
net *n = (net *) f;
rte *e;
ncnt++;
rescan:
for (e=n->routes; e; e=e->next, rcnt++)
if (e->attrs->proto->core_state != FS_HAPPY &&
e->attrs->proto->core_state != FS_FEEDING)
{
rte_discard(tab, e);
rdel++;
goto rescan;
}
if (!n->routes) /* Orphaned FIB entry? */
{
FIB_ITERATE_PUT(&fit, f);
fib_delete(&tab->fib, f);
ndel++;
goto again;
}
}
FIB_ITERATE_END(f);
DBG("Pruned %d of %d routes and %d of %d networks\n", rdel, rcnt, ndel, ncnt);
#ifdef DEBUGGING
fib_check(&tab->fib);
#endif
tab->gc_counter = 0;
tab->gc_time = now;
}
/**
* rt_prune_all - prune all routing tables
*
* This function calls rt_prune() for all known routing tables.
*/
void
rt_prune_all(void)
{
rtable *t;
WALK_LIST(t, routing_tables)
rt_prune(t);
}
struct rtable_config *
rt_new_table(struct symbol *s)
{
struct rtable_config *c = cfg_allocz(sizeof(struct rtable_config));
cf_define_symbol(s, SYM_TABLE, c);
c->name = s->name;
add_tail(&new_config->tables, &c->n);
c->gc_max_ops = 1000;
c->gc_min_time = 5;
return c;
}
void
rt_preconfig(struct config *c)
{
struct symbol *s = cf_find_symbol("master");
init_list(&c->tables);
c->master_rtc = rt_new_table(s);
}
/**
* rt_lock_table - lock a routing table
* @r: routing table to be locked
*
* Lock a routing table, because it's in use by a protocol,
* preventing it from being freed when it gets undefined in a new
* configuration.
*/
void
rt_lock_table(rtable *r)
{
r->use_count++;
}
/**
* rt_unlock_table - unlock a routing table
* @r: routing table to be unlocked
*
* Unlock a routing table formerly locked by rt_lock_table(),
* that is decrease its use count and delete it if it's scheduled
* for deletion by configuration changes.
*/
void
rt_unlock_table(rtable *r)
{
if (!--r->use_count && r->deleted)
{
struct config *conf = r->deleted;
DBG("Deleting routing table %s\n", r->name);
rem_node(&r->n);
fib_free(&r->fib);
mb_free(r);
config_del_obstacle(conf);
}
}
/**
* rt_commit - commit new routing table configuration
* @new: new configuration
* @old: original configuration or %NULL if it's boot time config
*
* Scan differences between @old and @new configuration and modify
* the routing tables according to these changes. If @new defines a
* previously unknown table, create it, if it omits a table existing
* in @old, schedule it for deletion (it gets deleted when all protocols
* disconnect from it by calling rt_unlock_table()), if it exists
* in both configurations, leave it unchanged.
*/
void
rt_commit(struct config *new, struct config *old)
{
struct rtable_config *o, *r;
DBG("rt_commit:\n");
if (old)
{
WALK_LIST(o, old->tables)
{
rtable *ot = o->table;
if (!ot->deleted)
{
struct symbol *sym = cf_find_symbol(o->name);
if (sym && sym->class == SYM_TABLE && !new->shutdown)
{
DBG("\t%s: same\n", o->name);
r = sym->def;
r->table = ot;
ot->name = r->name;
ot->config = r;
}
else
{
DBG("\t%s: deleted\n", o->name);
ot->deleted = old;
config_add_obstacle(old);
rt_lock_table(ot);
rt_unlock_table(ot);
}
}
}
}
WALK_LIST(r, new->tables)
if (!r->table)
{
rtable *t = mb_alloc(rt_table_pool, sizeof(struct rtable));
DBG("\t%s: created\n", r->name);
rt_setup(rt_table_pool, t, r->name, r);
add_tail(&routing_tables, &t->n);
r->table = t;
}
DBG("\tdone\n");
}
/**
* rt_feed_baby - advertise routes to a new protocol
* @p: protocol 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.)
*/
int
rt_feed_baby(struct proto *p)
{
struct announce_hook *h;
struct fib_iterator *fit;
int max_feed = 256;
if (!p->feed_ahook) /* Need to initialize first */
{
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;
}
fit = p->feed_iterator;
again:
h = p->feed_ahook;
FIB_ITERATE_START(&h->table->fib, fit, fn)
{
net *n = (net *) fn;
rte *e = n->routes;
if (max_feed <= 0)
{
FIB_ITERATE_PUT(fit, fn);
return 0;
}
if (e)
{
struct proto *q = e->attrs->proto;
ea_list *tmpa;
if (p->core_state != FS_FEEDING)
return 1; /* In the meantime, the protocol fell down. */
rte_update_lock();
tmpa = q->make_tmp_attrs ? q->make_tmp_attrs(e, rte_update_pool) : NULL;
do_rte_announce(h, n, e, NULL, tmpa, ipa_classify(n->n.prefix));
rte_update_unlock();
max_feed--;
}
}
FIB_ITERATE_END(fn);
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;
}
/**
* rt_feed_baby_abort - abort protocol feeding
* @p: protocol
*
* 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.
*/
void
rt_feed_baby_abort(struct proto *p)
{
if (p->feed_ahook)
{
/* Unlink the iterator and exit */
fit_get(&p->feed_ahook->table->fib, p->feed_iterator);
p->feed_ahook = NULL;
}
}
/*
* CLI commands
*/
static void
rt_format_via(rte *e, byte *via)
{
rta *a = e->attrs;
switch (a->dest)
{
case RTD_ROUTER: bsprintf(via, "via %I on %s", a->gw, a->iface->name); break;
case RTD_DEVICE: bsprintf(via, "dev %s", a->iface->name); break;
case RTD_BLACKHOLE: bsprintf(via, "blackhole"); break;
case RTD_UNREACHABLE: bsprintf(via, "unreachable"); break;
case RTD_PROHIBIT: bsprintf(via, "prohibited"); break;
default: bsprintf(via, "???");
}
}
static void
rt_show_rte(struct cli *c, byte *ia, rte *e, struct rt_show_data *d, ea_list *tmpa)
{
byte via[STD_ADDRESS_P_LENGTH+32], from[STD_ADDRESS_P_LENGTH+6];
byte tm[TM_RELTIME_BUFFER_SIZE], info[256];
rta *a = e->attrs;
rt_format_via(e, via);
tm_format_reltime(tm, e->lastmod);
if (ipa_nonzero(a->from) && !ipa_equal(a->from, a->gw))
bsprintf(from, " from %I", a->from);
else
from[0] = 0;
if (a->proto->proto->get_route_info || d->verbose)
{
/* Need to normalize the extended attributes */
ea_list *t = tmpa;
t = ea_append(t, a->eattrs);
tmpa = alloca(ea_scan(t));
ea_merge(t, tmpa);
ea_sort(tmpa);
}
if (a->proto->proto->get_route_info)
a->proto->proto->get_route_info(e, info, tmpa);
else
bsprintf(info, " (%d)", e->pref);
cli_printf(c, -1007, "%-18s %s [%s %s%s]%s", ia, via, a->proto->name, tm, from, info);
if (d->verbose)
rta_show(c, a, tmpa);
}
static void
rt_show_net(struct cli *c, net *n, struct rt_show_data *d)
{
rte *e, *ee;
byte ia[STD_ADDRESS_P_LENGTH+8];
int ok;
bsprintf(ia, "%I/%d", n->n.prefix, n->n.pxlen);
if (n->routes)
d->net_counter++;
for(e=n->routes; e; e=e->next)
{
struct ea_list *tmpa, *old_tmpa;
struct proto *p0 = e->attrs->proto;
struct proto *p1 = d->import_protocol;
d->rt_counter++;
ee = e;
rte_update_lock(); /* We use the update buffer for filtering */
old_tmpa = tmpa = p0->make_tmp_attrs ? p0->make_tmp_attrs(e, rte_update_pool) : NULL;
ok = (d->filter == FILTER_ACCEPT || f_run(d->filter, &e, &tmpa, rte_update_pool, FF_FORCE_TMPATTR) <= F_ACCEPT);
if (ok && d->import_mode)
{
int ic = (p1->import_control ? p1->import_control(p1, &e, &tmpa, rte_update_pool) : 0);
if (ic < 0)
ok = 0;
else if (!ic && d->import_mode > 1)
{
if (p1->out_filter == FILTER_REJECT ||
p1->out_filter && f_run(p1->out_filter, &e, &tmpa, rte_update_pool, FF_FORCE_TMPATTR) > F_ACCEPT)
ok = 0;
}
}
if (ok)
{
d->show_counter++;
if (d->stats < 2)
rt_show_rte(c, ia, e, d, tmpa);
ia[0] = 0;
}
if (e != ee)
rte_free(ee);
rte_update_unlock();
if (d->primary_only)
break;
}
}
static void
rt_show_cont(struct cli *c)
{
struct rt_show_data *d = c->rover;
#ifdef DEBUGGING
unsigned max = 4;
#else
unsigned max = 64;
#endif
struct fib *fib = &d->table->fib;
struct fib_iterator *it = &d->fit;
FIB_ITERATE_START(fib, it, f)
{
net *n = (net *) f;
if (d->running_on_config && d->running_on_config != config)
{
cli_printf(c, 8004, "Stopped due to reconfiguration");
goto done;
}
if (d->import_protocol &&
d->import_protocol->core_state != FS_HAPPY &&
d->import_protocol->core_state != FS_FEEDING)
{
cli_printf(c, 8005, "Protocol is down");
goto done;
}
if (!max--)
{
FIB_ITERATE_PUT(it, f);
return;
}
rt_show_net(c, n, d);
}
FIB_ITERATE_END(f);
if (d->stats)
cli_printf(c, 14, "%d of %d routes for %d networks", d->show_counter, d->rt_counter, d->net_counter);
else
cli_printf(c, 0, "");
done:
c->cont = c->cleanup = NULL;
}
static void
rt_show_cleanup(struct cli *c)
{
struct rt_show_data *d = c->rover;
/* Unlink the iterator */
fit_get(&d->table->fib, &d->fit);
}
void
rt_show(struct rt_show_data *d)
{
net *n;
if (d->pxlen == 256)
{
FIB_ITERATE_INIT(&d->fit, &d->table->fib);
this_cli->cont = rt_show_cont;
this_cli->cleanup = rt_show_cleanup;
this_cli->rover = d;
}
else
{
if (d->show_for)
n = fib_route(&d->table->fib, d->prefix, d->pxlen);
else
n = fib_find(&d->table->fib, &d->prefix, d->pxlen);
if (n)
{
rt_show_net(this_cli, n, d);
cli_msg(0, "");
}
else
cli_msg(8001, "Network not in table");
}
}
/*
* Documentation for functions declared inline in route.h
*/
#if 0
/**
* net_find - find a network entry
* @tab: a routing table
* @addr: address of the network
* @len: length of the network prefix
*
* net_find() looks up the given network in routing table @tab and
* returns a pointer to its &net entry or %NULL if no such network
* exists.
*/
static inline net *net_find(rtable *tab, ip_addr addr, unsigned len)
{ DUMMY; }
/**
* net_get - obtain a network entry
* @tab: a routing table
* @addr: address of the network
* @len: length of the network prefix
*
* net_get() looks up the given network in routing table @tab and
* returns a pointer to its &net entry. If no such entry exists, it's
* created.
*/
static inline net *net_get(rtable *tab, ip_addr addr, unsigned len)
{ DUMMY; }
/**
* rte_cow - copy a route for writing
* @r: a route entry to be copied
*
* rte_cow() takes a &rte and prepares it for modification. The exact action
* taken depends on the flags of the &rte -- if it's a temporary entry, it's
* just returned unchanged, else a new temporary entry with the same contents
* is created.
*
* The primary use of this function is inside the filter machinery -- when
* a filter wants to modify &rte contents (to change the preference or to
* attach another set of attributes), it must ensure that the &rte is not
* shared with anyone else (and especially that it isn't stored in any routing
* table).
*
* Result: a pointer to the new writable &rte.
*/
static inline rte * rte_cow(rte *r)
{ DUMMY; }
#endif
Reference in a new issue View git blame Copy permalink