0
0
mirror of https://gitlab.nic.cz/labs/bird.git synced 2024-11-08 20:28:43 +00:00
bird/proto/pipe/pipe.c
Igor Putovny c48de3cf85 Basic route aggregation
User can specify list of route attributes in the configuration file
and run route aggregation on the export side of the pipe protocol.
Routes are sorted and for every group of equivalent routes
new route is created and exported to the routing table.
It is also possible to specify filter which will run for every
route before aggregation.
Furthermore, it will be possible to set attributes of new routes
according to attributes of the aggregated routes.

This is a work in progress.
2024-05-30 12:30:00 +02:00

328 lines
9.3 KiB
C

/*
* BIRD -- Table-to-Table Routing Protocol a.k.a Pipe
*
* (c) 1999--2000 Martin Mares <mj@ucw.cz>
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
/**
* DOC: Pipe
*
* The Pipe protocol is very simple. It just connects to two routing tables
* using proto_add_announce_hook() and whenever it receives a rt_notify()
* about a change in one of the tables, it converts it to a rte_update()
* in the other one.
*
* To avoid pipe loops, Pipe keeps a `being updated' flag in each routing
* table.
*
* A pipe has two announce hooks, the first connected to the main
* table, the second connected to the peer table. When a new route is
* announced on the main table, it gets checked by an export filter in
* ahook 1, and, after that, it is announced to the peer table via
* rte_update(), an import filter in ahook 2 is called. When a new
* route is announced in the peer table, an export filter in ahook2
* and an import filter in ahook 1 are used. Oviously, there is no
* need in filtering the same route twice, so both import filters are
* set to accept, while user configured 'import' and 'export' filters
* are used as export filters in ahooks 2 and 1. Route limits are
* handled similarly, but on the import side of ahooks.
*/
#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 "filter/filter.h"
#include "lib/string.h"
#include "pipe.h"
static void
pipe_rt_notify(struct proto *P, struct channel *src_ch, net *n, rte *new, rte *old)
{
struct pipe_proto *p = (void *) P;
struct channel *dst = (src_ch == p->pri) ? p->sec : p->pri;
struct rte_src *src;
rte *e;
rta *a;
if (!new && !old)
return;
if (dst->table->pipe_busy)
{
log(L_ERR "Pipe loop detected when sending %N to table %s",
n->n.addr, dst->table->name);
return;
}
if (new)
{
src = new->src;
a = alloca(rta_size(new->attrs));
memcpy(a, new->attrs, rta_size(new->attrs));
a->cached = 0;
a->hostentry = NULL;
e = rte_get_temp(a, src);
}
else
{
e = NULL;
src = old->src;
}
src_ch->table->pipe_busy = 1;
rte_update2(dst, n->n.addr, e, old ? old->src : new->src);
src_ch->table->pipe_busy = 0;
}
static int
pipe_preexport(struct channel *C, rte *e)
{
struct proto *pp = e->sender->proto;
if (pp == C->proto)
return -1; /* Avoid local loops automatically */
return 0;
}
static void
pipe_reload_routes(struct channel *C)
{
struct pipe_proto *p = (void *) C->proto;
/* Route reload on one channel is just refeed on the other */
channel_request_feeding((C == p->pri) ? p->sec : p->pri);
}
static void
pipe_postconfig(struct proto_config *CF)
{
struct pipe_config *cf = (void *) CF;
struct channel_config *cc = proto_cf_main_channel(CF);
if (!cc->table)
cf_error("Primary routing table not specified");
if (!cf->peer)
cf_error("Secondary routing table not specified");
if (cc->table == cf->peer)
cf_error("Primary table and peer table must be different");
if (cc->table->addr_type != cf->peer->addr_type)
cf_error("Primary table and peer table must have the same type");
if (cc->rx_limit.action)
cf_error("Pipe protocol does not support receive limits");
if (cc->in_keep_filtered)
cf_error("Pipe protocol prohibits keeping filtered routes");
cc->debug = cf->c.debug;
}
static int
pipe_configure_channels(struct pipe_proto *p, struct pipe_config *cf)
{
struct channel_config *cc = proto_cf_main_channel(&cf->c);
log("pipe configure channels: ra_mode: %d", cc->ra_mode);
log("pipe configure channels: ai_aggr: %p", cc->ai_aggr);
struct channel_config pri_cf = {
.name = "pri",
.channel = cc->channel,
.table = cc->table,
.out_filter = cc->out_filter,
.in_limit = cc->in_limit,
.ra_mode = cc->ra_mode,
.ai_aggr = cc->ai_aggr,
.debug = cc->debug,
.rpki_reload = cc->rpki_reload,
};
struct channel_config sec_cf = {
.name = "sec",
.channel = cc->channel,
.table = cf->peer,
.out_filter = cc->in_filter,
.in_limit = cc->out_limit,
.ra_mode = RA_ANY,
.debug = cc->debug,
.rpki_reload = cc->rpki_reload,
};
log("ai_aggr = %p", cc->ai_aggr);
const struct aggr_item_linearized *ail = cc->ai_aggr;
int node = 1;
if (ail != NULL) {
for (int i = 0; i < ail->count; i++) {
switch (ail->items[i].type) {
case AGGR_ITEM_TERM:
log("node %d, type: term", node);
break;
case AGGR_ITEM_STATIC_ATTR:
log("node %d, type: static", node);
break;
case AGGR_ITEM_DYNAMIC_ATTR:
log("node %d, type: dynamic", node);
break;
default:
log("node %d, type: other", node);
break;
}
node++;
}
}
return
proto_configure_channel(&p->p, &p->pri, &pri_cf) &&
proto_configure_channel(&p->p, &p->sec, &sec_cf);
}
static struct proto *
pipe_init(struct proto_config *CF)
{
struct proto *P = proto_new(CF);
struct pipe_proto *p = (void *) P;
struct pipe_config *cf = (void *) CF;
P->rt_notify = pipe_rt_notify;
P->preexport = pipe_preexport;
P->reload_routes = pipe_reload_routes;
pipe_configure_channels(p, cf);
return P;
}
static int
pipe_reconfigure(struct proto *P, struct proto_config *CF)
{
struct pipe_proto *p = (void *) P;
struct pipe_config *cf = (void *) CF;
return pipe_configure_channels(p, cf);
}
static void
pipe_copy_config(struct proto_config *dest UNUSED, struct proto_config *src UNUSED)
{
/* Just a shallow copy, not many items here */
}
static void
pipe_get_status(struct proto *P, byte *buf)
{
struct pipe_proto *p = (void *) P;
bsprintf(buf, "%s <=> %s", p->pri->table->name, p->sec->table->name);
}
static void
pipe_show_stats(struct pipe_proto *p)
{
struct proto_stats *s1 = &p->pri->stats;
struct proto_stats *s2 = &p->sec->stats;
/*
* Pipe stats (as anything related to pipes) are a bit tricky. There
* are two sets of stats - s1 for ahook to the primary routing and
* s2 for the ahook to the secondary routing table. The user point
* of view is that routes going from the primary routing table to
* the secondary routing table are 'exported', while routes going in
* the other direction are 'imported'.
*
* Each route going through a pipe is, technically, first exported
* to the pipe and then imported from that pipe and such operations
* are counted in one set of stats according to the direction of the
* route propagation. Filtering is done just in the first part
* (export). Therefore, we compose stats for one directon for one
* user direction from both import and export stats, skipping
* immediate and irrelevant steps (exp_updates_accepted,
* imp_updates_received, imp_updates_filtered, ...).
*
* Rule of thumb is that stats s1 have the correct 'polarity'
* (imp/exp), while stats s2 have switched 'polarity'.
*/
cli_msg(-1006, " Routes: %u imported, %u exported",
s1->imp_routes, s2->imp_routes);
cli_msg(-1006, " Route change stats: received rejected filtered ignored accepted");
cli_msg(-1006, " Import updates: %10u %10u %10u %10u %10u",
s2->exp_updates_received, s2->exp_updates_rejected + s1->imp_updates_invalid,
s2->exp_updates_filtered, s1->imp_updates_ignored, s1->imp_updates_accepted);
cli_msg(-1006, " Import withdraws: %10u %10u --- %10u %10u",
s2->exp_withdraws_received, s1->imp_withdraws_invalid,
s1->imp_withdraws_ignored, s1->imp_withdraws_accepted);
cli_msg(-1006, " Export updates: %10u %10u %10u %10u %10u",
s1->exp_updates_received, s1->exp_updates_rejected + s2->imp_updates_invalid,
s1->exp_updates_filtered, s2->imp_updates_ignored, s2->imp_updates_accepted);
cli_msg(-1006, " Export withdraws: %10u %10u --- %10u %10u",
s1->exp_withdraws_received, s2->imp_withdraws_invalid,
s2->imp_withdraws_ignored, s2->imp_withdraws_accepted);
}
static const char *pipe_feed_state[] = { [ES_DOWN] = "down", [ES_FEEDING] = "feed", [ES_READY] = "up" };
static void
pipe_show_proto_info(struct proto *P)
{
struct pipe_proto *p = (void *) P;
cli_msg(-1006, " Channel %s", "main");
cli_msg(-1006, " Table: %s", p->pri->table->name);
cli_msg(-1006, " Peer table: %s", p->sec->table->name);
cli_msg(-1006, " Import state: %s", pipe_feed_state[p->sec->export_state]);
cli_msg(-1006, " Export state: %s", pipe_feed_state[p->pri->export_state]);
cli_msg(-1006, " Import filter: %s", filter_name(p->sec->out_filter));
cli_msg(-1006, " Export filter: %s", filter_name(p->pri->out_filter));
channel_show_limit(&p->pri->in_limit, "Import limit:");
channel_show_limit(&p->sec->in_limit, "Export limit:");
if (P->proto_state != PS_DOWN)
pipe_show_stats(p);
}
void
pipe_update_debug(struct proto *P)
{
struct pipe_proto *p = (void *) P;
p->pri->debug = p->sec->debug = p->p.debug;
}
struct protocol proto_pipe = {
.name = "Pipe",
.template = "pipe%d",
.class = PROTOCOL_PIPE,
.proto_size = sizeof(struct pipe_proto),
.config_size = sizeof(struct pipe_config),
.postconfig = pipe_postconfig,
.init = pipe_init,
.reconfigure = pipe_reconfigure,
.copy_config = pipe_copy_config,
.get_status = pipe_get_status,
.show_proto_info = pipe_show_proto_info
};
void
pipe_build(void)
{
proto_build(&proto_pipe);
}