1999-08-04 03:57:43 +08:00
|
|
|
/*
|
|
|
|
* BIRD -- Table-to-Table Routing Protocol a.k.a Pipe
|
|
|
|
*
|
2000-01-17 00:44:50 +08:00
|
|
|
* (c) 1999--2000 Martin Mares <mj@ucw.cz>
|
1999-08-04 03:57:43 +08:00
|
|
|
*
|
|
|
|
* Can be freely distributed and used under the terms of the GNU GPL.
|
|
|
|
*/
|
|
|
|
|
2000-06-05 00:15:37 +08:00
|
|
|
/**
|
|
|
|
* 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.
|
2012-03-15 18:58:08 +08:00
|
|
|
*
|
|
|
|
* 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
|
2012-04-15 21:28:29 +08:00
|
|
|
* 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.
|
2000-06-05 00:15:37 +08:00
|
|
|
*/
|
|
|
|
|
2000-03-13 05:01:38 +08:00
|
|
|
#undef LOCAL_DEBUG
|
1999-08-04 03:57:43 +08:00
|
|
|
|
|
|
|
#include "nest/bird.h"
|
|
|
|
#include "nest/iface.h"
|
|
|
|
#include "nest/protocol.h"
|
|
|
|
#include "nest/route.h"
|
2012-03-15 18:58:08 +08:00
|
|
|
#include "nest/cli.h"
|
1999-08-04 03:57:43 +08:00
|
|
|
#include "conf/conf.h"
|
|
|
|
#include "filter/filter.h"
|
1999-12-01 20:01:41 +08:00
|
|
|
#include "lib/string.h"
|
1999-08-04 03:57:43 +08:00
|
|
|
|
|
|
|
#include "pipe.h"
|
|
|
|
|
|
|
|
static void
|
2016-04-04 22:17:11 +08:00
|
|
|
pipe_rt_notify(struct proto *P, struct channel *src_ch, net *n, rte *new, rte *old, ea_list *attrs)
|
1999-08-04 03:57:43 +08:00
|
|
|
{
|
2016-01-26 18:48:58 +08:00
|
|
|
struct pipe_proto *p = (void *) P;
|
2016-04-04 22:17:11 +08:00
|
|
|
struct channel *dst = (src_ch == p->pri) ? p->sec : p->pri;
|
2012-08-14 22:25:22 +08:00
|
|
|
struct rte_src *src;
|
2010-02-13 19:26:26 +08:00
|
|
|
|
1999-08-04 03:57:43 +08:00
|
|
|
rte *e;
|
|
|
|
rta a;
|
|
|
|
|
2009-05-31 21:24:27 +08:00
|
|
|
if (!new && !old)
|
|
|
|
return;
|
|
|
|
|
2016-01-26 18:48:58 +08:00
|
|
|
if (dst->table->pipe_busy)
|
1999-08-04 03:57:43 +08:00
|
|
|
{
|
2015-11-05 19:48:52 +08:00
|
|
|
log(L_ERR "Pipe loop detected when sending %N to table %s",
|
2016-01-26 18:48:58 +08:00
|
|
|
n->n.addr, dst->table->name);
|
1999-08-04 03:57:43 +08:00
|
|
|
return;
|
|
|
|
}
|
2012-03-15 18:58:08 +08:00
|
|
|
|
1999-08-04 03:57:43 +08:00
|
|
|
if (new)
|
|
|
|
{
|
|
|
|
memcpy(&a, new->attrs, sizeof(rta));
|
2009-06-01 18:10:10 +08:00
|
|
|
|
1999-08-04 03:57:43 +08:00
|
|
|
a.aflags = 0;
|
2000-05-13 19:02:02 +08:00
|
|
|
a.eattrs = attrs;
|
2010-07-05 23:50:19 +08:00
|
|
|
a.hostentry = NULL;
|
1999-08-04 03:57:43 +08:00
|
|
|
e = rte_get_temp(&a);
|
2009-09-17 18:40:02 +08:00
|
|
|
e->pflags = 0;
|
2009-05-31 21:24:27 +08:00
|
|
|
|
2016-01-26 18:48:58 +08:00
|
|
|
/* Copy protocol specific embedded attributes. */
|
|
|
|
memcpy(&(e->u), &(new->u), sizeof(e->u));
|
|
|
|
e->pref = new->pref;
|
|
|
|
e->pflags = new->pflags;
|
2009-05-31 21:24:27 +08:00
|
|
|
|
2012-08-14 22:25:22 +08:00
|
|
|
src = a.src;
|
1999-08-04 03:57:43 +08:00
|
|
|
}
|
|
|
|
else
|
2009-05-31 21:24:27 +08:00
|
|
|
{
|
|
|
|
e = NULL;
|
2012-08-14 22:25:22 +08:00
|
|
|
src = old->attrs->src;
|
2009-05-31 21:24:27 +08:00
|
|
|
}
|
|
|
|
|
2016-04-04 22:17:11 +08:00
|
|
|
src_ch->table->pipe_busy = 1;
|
2016-04-08 19:08:03 +08:00
|
|
|
rte_update2(dst, n->n.addr, e, src);
|
2016-04-04 22:17:11 +08:00
|
|
|
src_ch->table->pipe_busy = 0;
|
1999-08-04 03:57:43 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2004-06-05 17:27:35 +08:00
|
|
|
pipe_import_control(struct proto *P, rte **ee, ea_list **ea UNUSED, struct linpool *p UNUSED)
|
1999-08-04 03:57:43 +08:00
|
|
|
{
|
2012-03-15 18:58:08 +08:00
|
|
|
struct proto *pp = (*ee)->sender->proto;
|
1999-08-04 03:57:43 +08:00
|
|
|
|
2010-02-13 19:26:26 +08:00
|
|
|
if (pp == P)
|
1999-08-04 03:57:43 +08:00
|
|
|
return -1; /* Avoid local loops automatically */
|
2016-01-26 18:48:58 +08:00
|
|
|
|
1999-08-04 03:57:43 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-01-26 18:48:58 +08:00
|
|
|
static void
|
|
|
|
pipe_reload_routes(struct channel *C)
|
2009-12-20 21:59:12 +08:00
|
|
|
{
|
2016-01-26 18:48:58 +08:00
|
|
|
struct pipe_proto *p = (void *) C->proto;
|
2012-04-15 21:28:29 +08:00
|
|
|
|
2016-01-26 18:48:58 +08:00
|
|
|
/* Route reload on one channel is just refeed on the other */
|
|
|
|
channel_request_feeding((C == p->pri) ? p->sec : p->pri);
|
2009-12-20 21:59:12 +08:00
|
|
|
}
|
|
|
|
|
2012-03-15 18:58:08 +08:00
|
|
|
|
2016-01-26 18:48:58 +08:00
|
|
|
static void
|
|
|
|
pipe_postconfig(struct proto_config *CF)
|
1999-08-04 03:57:43 +08:00
|
|
|
{
|
2016-01-26 18:48:58 +08:00
|
|
|
struct pipe_config *cf = (void *) CF;
|
|
|
|
struct channel_config *cc = proto_cf_main_channel(CF);
|
1999-08-04 03:57:43 +08:00
|
|
|
|
2016-01-26 18:48:58 +08:00
|
|
|
if (!cc->table)
|
|
|
|
cf_error("Primary routing table not specified");
|
2009-12-03 00:26:16 +08:00
|
|
|
|
2016-01-26 18:48:58 +08:00
|
|
|
if (!cf->peer)
|
|
|
|
cf_error("Secondary routing table not specified");
|
1999-08-04 03:57:43 +08:00
|
|
|
|
2016-01-26 18:48:58 +08:00
|
|
|
if (cc->table == cf->peer)
|
|
|
|
cf_error("Primary table and peer table must be different");
|
2012-04-15 21:28:29 +08:00
|
|
|
|
2016-01-26 18:48:58 +08:00
|
|
|
if (cc->table->addr_type != cf->peer->addr_type)
|
|
|
|
cf_error("Primary table and peer table must have the same type");
|
1999-08-04 03:57:43 +08:00
|
|
|
|
2016-01-26 18:48:58 +08:00
|
|
|
if (cc->rx_limit.action)
|
|
|
|
cf_error("Pipe protocol does not support receive limits");
|
2012-08-14 22:25:22 +08:00
|
|
|
|
2016-01-26 18:48:58 +08:00
|
|
|
if (cc->in_keep_filtered)
|
|
|
|
cf_error("Pipe protocol prohibits keeping filtered routes");
|
1999-08-04 03:57:43 +08:00
|
|
|
}
|
|
|
|
|
2016-01-26 18:48:58 +08:00
|
|
|
static int
|
|
|
|
pipe_configure_channels(struct pipe_proto *p, struct pipe_config *cf)
|
2010-07-05 23:50:19 +08:00
|
|
|
{
|
2016-01-26 18:48:58 +08:00
|
|
|
struct channel_config *cc = proto_cf_main_channel(&cf->c);
|
|
|
|
|
|
|
|
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 = RA_ANY
|
|
|
|
};
|
|
|
|
|
|
|
|
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
|
|
|
|
};
|
|
|
|
|
|
|
|
return
|
|
|
|
proto_configure_channel(&p->p, &p->pri, &pri_cf) &&
|
|
|
|
proto_configure_channel(&p->p, &p->sec, &sec_cf);
|
1999-08-04 03:57:43 +08:00
|
|
|
}
|
|
|
|
|
2016-01-26 18:48:58 +08:00
|
|
|
static struct proto *
|
|
|
|
pipe_init(struct proto_config *CF)
|
1999-08-04 03:57:43 +08:00
|
|
|
{
|
2016-01-26 18:48:58 +08:00
|
|
|
struct proto *P = proto_new(CF);
|
|
|
|
struct pipe_proto *p = (void *) P;
|
|
|
|
struct pipe_config *cf = (void *) CF;
|
1999-08-04 03:57:43 +08:00
|
|
|
|
2016-01-26 18:48:58 +08:00
|
|
|
P->rt_notify = pipe_rt_notify;
|
|
|
|
P->import_control = pipe_import_control;
|
|
|
|
P->reload_routes = pipe_reload_routes;
|
2013-01-10 20:07:33 +08:00
|
|
|
|
2016-01-26 18:48:58 +08:00
|
|
|
pipe_configure_channels(p, cf);
|
1999-08-04 03:57:43 +08:00
|
|
|
|
2016-01-26 18:48:58 +08:00
|
|
|
return P;
|
|
|
|
}
|
2012-03-15 18:58:08 +08:00
|
|
|
|
2000-01-17 08:20:45 +08:00
|
|
|
static int
|
2016-01-26 18:48:58 +08:00
|
|
|
pipe_reconfigure(struct proto *P, struct proto_config *CF)
|
2000-01-17 08:20:45 +08:00
|
|
|
{
|
2016-01-26 18:48:58 +08:00
|
|
|
struct pipe_proto *p = (void *) P;
|
|
|
|
struct pipe_config *cf = (void *) CF;
|
2012-03-15 18:58:08 +08:00
|
|
|
|
2016-01-26 18:48:58 +08:00
|
|
|
return pipe_configure_channels(p, cf);
|
2000-01-17 08:20:45 +08:00
|
|
|
}
|
|
|
|
|
2011-11-07 07:31:23 +08:00
|
|
|
static void
|
|
|
|
pipe_copy_config(struct proto_config *dest, struct proto_config *src)
|
|
|
|
{
|
|
|
|
/* Just a shallow copy, not many items here */
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
pipe_get_status(struct proto *P, byte *buf)
|
|
|
|
{
|
2016-01-26 18:48:58 +08:00
|
|
|
struct pipe_proto *p = (void *) P;
|
2011-11-07 07:31:23 +08:00
|
|
|
|
2016-01-26 18:48:58 +08:00
|
|
|
bsprintf(buf, "%s <=> %s", p->pri->table->name, p->sec->table->name);
|
2012-03-15 18:58:08 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
pipe_show_stats(struct pipe_proto *p)
|
|
|
|
{
|
2016-01-26 18:48:58 +08:00
|
|
|
struct proto_stats *s1 = &p->pri->stats;
|
|
|
|
struct proto_stats *s2 = &p->sec->stats;
|
2012-03-15 18:58:08 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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'.
|
|
|
|
*/
|
|
|
|
|
2015-02-22 04:08:23 +08:00
|
|
|
cli_msg(-1006, " Routes: %u imported, %u exported",
|
2012-03-15 18:58:08 +08:00
|
|
|
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 void
|
|
|
|
pipe_show_proto_info(struct proto *P)
|
|
|
|
{
|
2016-01-26 18:48:58 +08:00
|
|
|
struct pipe_proto *p = (void *) P;
|
2012-03-15 18:58:08 +08:00
|
|
|
|
2016-01-26 18:48:58 +08:00
|
|
|
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 filter: %s", filter_name(p->sec->out_filter));
|
|
|
|
cli_msg(-1006, " Export filter: %s", filter_name(p->pri->out_filter));
|
2012-04-15 21:28:29 +08:00
|
|
|
|
2016-01-26 18:48:58 +08:00
|
|
|
channel_show_limit(&p->pri->in_limit, "Import limit:");
|
|
|
|
channel_show_limit(&p->sec->in_limit, "Export limit:");
|
2012-03-15 18:58:08 +08:00
|
|
|
|
|
|
|
if (P->proto_state != PS_DOWN)
|
|
|
|
pipe_show_stats(p);
|
2011-11-07 07:31:23 +08:00
|
|
|
}
|
|
|
|
|
2010-02-13 17:44:46 +08:00
|
|
|
|
1999-08-04 03:57:43 +08:00
|
|
|
struct protocol proto_pipe = {
|
2014-12-03 17:10:34 +08:00
|
|
|
.name = "Pipe",
|
|
|
|
.template = "pipe%d",
|
2016-01-26 18:48:58 +08:00
|
|
|
.proto_size = sizeof(struct pipe_proto),
|
2015-02-22 04:08:23 +08:00
|
|
|
.config_size = sizeof(struct pipe_config),
|
2014-12-03 17:10:34 +08:00
|
|
|
.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
|
1999-08-04 03:57:43 +08:00
|
|
|
};
|