1999-08-03 19:57:43 +00:00
|
|
|
/*
|
|
|
|
* BIRD -- Table-to-Table Routing Protocol a.k.a Pipe
|
|
|
|
*
|
2000-01-16 16:44:50 +00:00
|
|
|
* (c) 1999--2000 Martin Mares <mj@ucw.cz>
|
1999-08-03 19:57:43 +00:00
|
|
|
*
|
|
|
|
* Can be freely distributed and used under the terms of the GNU GPL.
|
|
|
|
*/
|
|
|
|
|
2000-06-04 16:15:37 +00: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 10:58:08 +00: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 13:28:29 +00: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-04 16:15:37 +00:00
|
|
|
*/
|
|
|
|
|
2000-03-12 21:01:38 +00:00
|
|
|
#undef LOCAL_DEBUG
|
1999-08-03 19:57:43 +00:00
|
|
|
|
|
|
|
#include "nest/bird.h"
|
|
|
|
#include "nest/iface.h"
|
|
|
|
#include "nest/protocol.h"
|
|
|
|
#include "nest/route.h"
|
2012-03-15 10:58:08 +00:00
|
|
|
#include "nest/cli.h"
|
1999-08-03 19:57:43 +00:00
|
|
|
#include "conf/conf.h"
|
|
|
|
#include "filter/filter.h"
|
1999-12-01 12:01:41 +00:00
|
|
|
#include "lib/string.h"
|
1999-08-03 19:57:43 +00:00
|
|
|
|
2020-02-10 14:01:36 +00:00
|
|
|
#ifdef CONFIG_BGP
|
|
|
|
#include "proto/bgp/bgp.h"
|
|
|
|
#endif
|
|
|
|
|
1999-08-03 19:57:43 +00:00
|
|
|
#include "pipe.h"
|
|
|
|
|
|
|
|
static void
|
2020-02-25 21:13:32 +00:00
|
|
|
pipe_rt_notify(struct channel *src_ch, struct rte_export *export)
|
1999-08-03 19:57:43 +00:00
|
|
|
{
|
2020-02-25 21:13:32 +00:00
|
|
|
struct pipe_proto *p = (void *) src_ch->proto;
|
2016-04-04 14:17:11 +00:00
|
|
|
struct channel *dst = (src_ch == p->pri) ? p->sec : p->pri;
|
2010-02-13 11:26:26 +00:00
|
|
|
|
2020-02-25 21:13:32 +00:00
|
|
|
if (!export->new && !export->old)
|
2009-05-31 13:24:27 +00:00
|
|
|
return;
|
|
|
|
|
2016-01-26 10:48:58 +00:00
|
|
|
if (dst->table->pipe_busy)
|
1999-08-03 19:57:43 +00:00
|
|
|
{
|
2015-11-05 11:48:52 +00:00
|
|
|
log(L_ERR "Pipe loop detected when sending %N to table %s",
|
2020-03-10 15:13:41 +00:00
|
|
|
export->net, dst->table->name);
|
1999-08-03 19:57:43 +00:00
|
|
|
return;
|
|
|
|
}
|
2012-03-15 10:58:08 +00:00
|
|
|
|
2020-02-25 21:13:32 +00:00
|
|
|
if (export->new)
|
1999-08-03 19:57:43 +00:00
|
|
|
{
|
2020-02-25 21:13:32 +00:00
|
|
|
rta *a = alloca(rta_size(export->new->attrs));
|
|
|
|
memcpy(a, export->new->attrs, rta_size(export->new->attrs));
|
2009-06-01 10:10:10 +00:00
|
|
|
|
2020-02-10 07:41:05 +00:00
|
|
|
a->cached = 0;
|
2020-02-25 21:13:32 +00:00
|
|
|
a->uc = 0;
|
2016-06-10 12:34:41 +00:00
|
|
|
a->hostentry = NULL;
|
2020-01-28 10:42:46 +00:00
|
|
|
|
2020-02-25 21:13:32 +00:00
|
|
|
rte e0 = {
|
|
|
|
.attrs = rta_lookup(a),
|
|
|
|
};
|
2009-05-31 13:24:27 +00:00
|
|
|
|
2020-02-25 21:13:32 +00:00
|
|
|
src_ch->table->pipe_busy = 1;
|
2020-03-10 15:13:41 +00:00
|
|
|
rte_update(dst, export->net, &e0);
|
2020-02-25 21:13:32 +00:00
|
|
|
src_ch->table->pipe_busy = 0;
|
1999-08-03 19:57:43 +00:00
|
|
|
}
|
|
|
|
else
|
2009-05-31 13:24:27 +00:00
|
|
|
{
|
2020-02-25 21:13:32 +00:00
|
|
|
src_ch->table->pipe_busy = 1;
|
2020-03-10 15:13:41 +00:00
|
|
|
rte_withdraw(dst, export->net, export->old_src);
|
2020-02-25 21:13:32 +00:00
|
|
|
src_ch->table->pipe_busy = 0;
|
2009-05-31 13:24:27 +00:00
|
|
|
}
|
1999-08-03 19:57:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2020-04-12 19:54:20 +00:00
|
|
|
pipe_preexport(struct proto *P, rte *e)
|
1999-08-03 19:57:43 +00:00
|
|
|
{
|
2020-04-12 19:54:20 +00:00
|
|
|
struct proto *pp = e->sender->proto;
|
1999-08-03 19:57:43 +00:00
|
|
|
|
2010-02-13 11:26:26 +00:00
|
|
|
if (pp == P)
|
1999-08-03 19:57:43 +00:00
|
|
|
return -1; /* Avoid local loops automatically */
|
2016-01-26 10:48:58 +00:00
|
|
|
|
1999-08-03 19:57:43 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-01-26 10:48:58 +00:00
|
|
|
static void
|
|
|
|
pipe_reload_routes(struct channel *C)
|
2009-12-20 13:59:12 +00:00
|
|
|
{
|
2016-01-26 10:48:58 +00:00
|
|
|
struct pipe_proto *p = (void *) C->proto;
|
2012-04-15 13:28:29 +00:00
|
|
|
|
2016-01-26 10:48:58 +00:00
|
|
|
/* Route reload on one channel is just refeed on the other */
|
2020-03-10 15:13:41 +00:00
|
|
|
channel_request_feeding((C == p->pri) ? p->sec : p->pri, NULL);
|
2009-12-20 13:59:12 +00:00
|
|
|
}
|
|
|
|
|
2012-03-15 10:58:08 +00:00
|
|
|
|
2016-01-26 10:48:58 +00:00
|
|
|
static void
|
|
|
|
pipe_postconfig(struct proto_config *CF)
|
1999-08-03 19:57:43 +00:00
|
|
|
{
|
2016-01-26 10:48:58 +00:00
|
|
|
struct pipe_config *cf = (void *) CF;
|
|
|
|
struct channel_config *cc = proto_cf_main_channel(CF);
|
1999-08-03 19:57:43 +00:00
|
|
|
|
2016-01-26 10:48:58 +00:00
|
|
|
if (!cc->table)
|
|
|
|
cf_error("Primary routing table not specified");
|
2009-12-02 16:26:16 +00:00
|
|
|
|
2016-01-26 10:48:58 +00:00
|
|
|
if (!cf->peer)
|
|
|
|
cf_error("Secondary routing table not specified");
|
1999-08-03 19:57:43 +00:00
|
|
|
|
2016-01-26 10:48:58 +00:00
|
|
|
if (cc->table == cf->peer)
|
|
|
|
cf_error("Primary table and peer table must be different");
|
2012-04-15 13:28:29 +00:00
|
|
|
|
2016-01-26 10:48:58 +00:00
|
|
|
if (cc->table->addr_type != cf->peer->addr_type)
|
|
|
|
cf_error("Primary table and peer table must have the same type");
|
1999-08-03 19:57:43 +00:00
|
|
|
|
2016-01-26 10:48:58 +00:00
|
|
|
if (cc->rx_limit.action)
|
|
|
|
cf_error("Pipe protocol does not support receive limits");
|
2012-08-14 14:25:22 +00:00
|
|
|
|
2016-01-26 10:48:58 +00:00
|
|
|
if (cc->in_keep_filtered)
|
|
|
|
cf_error("Pipe protocol prohibits keeping filtered routes");
|
2021-03-16 19:10:00 +00:00
|
|
|
|
|
|
|
cc->debug = cf->c.debug;
|
1999-08-03 19:57:43 +00:00
|
|
|
}
|
|
|
|
|
2016-01-26 10:48:58 +00:00
|
|
|
static int
|
|
|
|
pipe_configure_channels(struct pipe_proto *p, struct pipe_config *cf)
|
2010-07-05 15:50:19 +00:00
|
|
|
{
|
2016-01-26 10:48:58 +00: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,
|
2021-02-12 04:05:18 +00:00
|
|
|
.ra_mode = RA_ANY,
|
2021-03-16 19:10:00 +00:00
|
|
|
.debug = cc->debug,
|
2021-02-12 04:05:18 +00:00
|
|
|
.rpki_reload = cc->rpki_reload,
|
2016-01-26 10:48:58 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct channel_config sec_cf = {
|
|
|
|
.name = "sec",
|
|
|
|
.channel = cc->channel,
|
|
|
|
.table = cf->peer,
|
|
|
|
.out_filter = cc->in_filter,
|
|
|
|
.in_limit = cc->out_limit,
|
2021-02-12 04:05:18 +00:00
|
|
|
.ra_mode = RA_ANY,
|
2021-03-16 19:10:00 +00:00
|
|
|
.debug = cc->debug,
|
2021-02-12 04:05:18 +00:00
|
|
|
.rpki_reload = cc->rpki_reload,
|
2016-01-26 10:48:58 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
return
|
|
|
|
proto_configure_channel(&p->p, &p->pri, &pri_cf) &&
|
|
|
|
proto_configure_channel(&p->p, &p->sec, &sec_cf);
|
1999-08-03 19:57:43 +00:00
|
|
|
}
|
|
|
|
|
2016-01-26 10:48:58 +00:00
|
|
|
static struct proto *
|
|
|
|
pipe_init(struct proto_config *CF)
|
1999-08-03 19:57:43 +00:00
|
|
|
{
|
2016-01-26 10:48:58 +00:00
|
|
|
struct proto *P = proto_new(CF);
|
|
|
|
struct pipe_proto *p = (void *) P;
|
|
|
|
struct pipe_config *cf = (void *) CF;
|
1999-08-03 19:57:43 +00:00
|
|
|
|
2016-01-26 10:48:58 +00:00
|
|
|
P->rt_notify = pipe_rt_notify;
|
Terminology cleanup: The import_control hook is now called preexport.
Once upon a time, far far away, there were the old Bird developers
discussing what direction of route flow shall be called import and
export. They decided to say "import to protocol" and "export to table"
when speaking about a protocol. When speaking about a table, they
spoke about "importing to table" and "exporting to protocol".
The latter terminology was adopted in configuration, then also the
bird CLI in commit ea2ae6dd0 started to use it (in year 2009). Now
it's 2018 and the terminology is the latter. Import is from protocol to
table, export is from table to protocol. Anyway, there was still an
import_control hook which executed right before route export.
One thing is funny. There are two commits in April 1999 with just two
minutes between them. The older announces the final settlement
on config terminology, the newer uses the other definition. Let's see
their commit messages as the git-log tool shows them (the newer first):
commit 9e0e485e50ea74c4f1c5cb65bdfe6ce819c2cee2
Author: Martin Mares <mj@ucw.cz>
Date: Mon Apr 5 20:17:59 1999 +0000
Added some new protocol hooks (look at the comments for better explanation):
make_tmp_attrs Convert inline attributes to ea_list
store_tmp_attrs Convert ea_list to inline attributes
import_control Pre-import decisions
commit 5056c559c4eb253a4eee10cf35b694faec5265eb
Author: Martin Mares <mj@ucw.cz>
Date: Mon Apr 5 20:15:31 1999 +0000
Changed syntax of attaching filters to protocols to hopefully the final
version:
EXPORT <filter-spec> for outbound routes (i.e., those announced
by BIRD to the rest of the world).
IMPORT <filter-spec> for inbound routes (i.e., those imported
by BIRD from the rest of the world).
where <filter-spec> is one of:
ALL pass all routes
NONE drop all routes
FILTER <name> use named filter
FILTER { <filter> } use explicitly defined filter
For all protocols, the default is IMPORT ALL, EXPORT NONE. This includes
the kernel protocol, so that you need to add EXPORT ALL to get the previous
configuration of kernel syncer (as usually, see doc/bird.conf.example for
a bird.conf example :)).
Let's say RIP to this almost 19-years-old inconsistency. For now, if you
import a route, it is always from protocol to table. If you export a
route, it is always from table to protocol.
And they lived happily ever after.
2018-02-14 12:42:53 +00:00
|
|
|
P->preexport = pipe_preexport;
|
2016-01-26 10:48:58 +00:00
|
|
|
P->reload_routes = pipe_reload_routes;
|
2013-01-10 12:07:33 +00:00
|
|
|
|
2016-01-26 10:48:58 +00:00
|
|
|
pipe_configure_channels(p, cf);
|
1999-08-03 19:57:43 +00:00
|
|
|
|
2016-01-26 10:48:58 +00:00
|
|
|
return P;
|
|
|
|
}
|
2012-03-15 10:58:08 +00:00
|
|
|
|
2000-01-17 00:20:45 +00:00
|
|
|
static int
|
2016-01-26 10:48:58 +00:00
|
|
|
pipe_reconfigure(struct proto *P, struct proto_config *CF)
|
2000-01-17 00:20:45 +00:00
|
|
|
{
|
2016-01-26 10:48:58 +00:00
|
|
|
struct pipe_proto *p = (void *) P;
|
|
|
|
struct pipe_config *cf = (void *) CF;
|
2012-03-15 10:58:08 +00:00
|
|
|
|
2016-01-26 10:48:58 +00:00
|
|
|
return pipe_configure_channels(p, cf);
|
2000-01-17 00:20:45 +00:00
|
|
|
}
|
|
|
|
|
2011-11-06 23:31:23 +00:00
|
|
|
static void
|
2016-11-08 18:27:58 +00:00
|
|
|
pipe_copy_config(struct proto_config *dest UNUSED, struct proto_config *src UNUSED)
|
2011-11-06 23:31:23 +00:00
|
|
|
{
|
|
|
|
/* Just a shallow copy, not many items here */
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
pipe_get_status(struct proto *P, byte *buf)
|
|
|
|
{
|
2016-01-26 10:48:58 +00:00
|
|
|
struct pipe_proto *p = (void *) P;
|
2011-11-06 23:31:23 +00:00
|
|
|
|
2016-01-26 10:48:58 +00:00
|
|
|
bsprintf(buf, "%s <=> %s", p->pri->table->name, p->sec->table->name);
|
2012-03-15 10:58:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
pipe_show_stats(struct pipe_proto *p)
|
|
|
|
{
|
2016-01-26 10:48:58 +00:00
|
|
|
struct proto_stats *s1 = &p->pri->stats;
|
|
|
|
struct proto_stats *s2 = &p->sec->stats;
|
2012-03-15 10:58:08 +00: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-21 20:08:23 +00:00
|
|
|
cli_msg(-1006, " Routes: %u imported, %u exported",
|
2012-03-15 10:58:08 +00: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);
|
|
|
|
}
|
|
|
|
|
2018-01-16 15:10:13 +00:00
|
|
|
static const char *pipe_feed_state[] = { [ES_DOWN] = "down", [ES_FEEDING] = "feed", [ES_READY] = "up" };
|
|
|
|
|
2012-03-15 10:58:08 +00:00
|
|
|
static void
|
|
|
|
pipe_show_proto_info(struct proto *P)
|
|
|
|
{
|
2016-01-26 10:48:58 +00:00
|
|
|
struct pipe_proto *p = (void *) P;
|
2012-03-15 10:58:08 +00:00
|
|
|
|
2016-01-26 10:48:58 +00: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);
|
2018-01-16 15:10:13 +00:00
|
|
|
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]);
|
2016-01-26 10:48:58 +00:00
|
|
|
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 13:28:29 +00:00
|
|
|
|
2016-01-26 10:48:58 +00:00
|
|
|
channel_show_limit(&p->pri->in_limit, "Import limit:");
|
|
|
|
channel_show_limit(&p->sec->in_limit, "Export limit:");
|
2012-03-15 10:58:08 +00:00
|
|
|
|
|
|
|
if (P->proto_state != PS_DOWN)
|
|
|
|
pipe_show_stats(p);
|
2011-11-06 23:31:23 +00:00
|
|
|
}
|
|
|
|
|
2021-03-16 19:10:00 +00:00
|
|
|
void
|
|
|
|
pipe_update_debug(struct proto *P)
|
|
|
|
{
|
|
|
|
struct pipe_proto *p = (void *) P;
|
|
|
|
|
|
|
|
p->pri->debug = p->sec->debug = p->p.debug;
|
|
|
|
}
|
|
|
|
|
2010-02-13 09:44:46 +00:00
|
|
|
|
1999-08-03 19:57:43 +00:00
|
|
|
struct protocol proto_pipe = {
|
2014-12-03 09:10:34 +00:00
|
|
|
.name = "Pipe",
|
|
|
|
.template = "pipe%d",
|
2018-05-07 12:47:00 +00:00
|
|
|
.class = PROTOCOL_PIPE,
|
2016-01-26 10:48:58 +00:00
|
|
|
.proto_size = sizeof(struct pipe_proto),
|
2015-02-21 20:08:23 +00:00
|
|
|
.config_size = sizeof(struct pipe_config),
|
2014-12-03 09:10:34 +00: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-03 19:57:43 +00:00
|
|
|
};
|