mirrors/bird
mirrors/bird
0
0
Fork 0
mirror of https://gitlab.nic.cz/labs/bird.git synced 2024-12-23 10:11:53 +00:00
Code Releases Activity

Merge branch 'master' into birdtest

Browse Source
This commit is contained in:
Pavel Tvrdík 2015-04-20 16:27:48 +02:00
commit 259e7e0f67
22 changed files with 618 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
NEWS
View File

@ -1,6 +1,32 @@
Version 1.5.0pre (2014-11-05) - Not for production
o Major OSPF protocol redesign
o RFC 6549 - OSPFv2 multi-instance extension
Version 1.5.0 (2015-04-20)
o Major OSPF protocol redesign.
o OSPFv2 multi-instance extension (RFC 6549).
o BGP AS-wide unique router ID (RFC 6286).
o BGP enhanced route refresh (RFC 7313).
o Link state support in BGP.
o Latency tracking and internal watchdog.
o Uses high port range for BFD on BSD.
o Increase max symbol length to 64.
o Allows to define unnamed protocols from templates.
o Fixes two serious bugs in BGP.
o Several bugfixes and minor improvements.
o Several minor option changes:
- OSPF: Protocol-wide 'instance id' option added.
- BGP: Parameters to option 'neighbor' extended.
- BGP: Separate option 'interface' added.
- BGP: Option 'start delay time' renamed to 'connect delay time'.
- BGP: Option 'route limit' deprecated.
Upgrade notes:
For OSPF, there are deep internal changes, but user-visible changes
are limited to log messages and minor changes in formatting of command
output.
For BGP, version 1.5.0 is essentially a minor release. There are two
deprecated options ('start delay time' and 'route limit') and some
minor formatting changes.
Version 1.4.5 (2014-10-06)
o New 'show route noexport' command option.

4
conf/conf.h
View File

@ -41,6 +41,10 @@ struct config {
u32 gr_wait; /* Graceful restart wait timeout */
int cli_debug; /* Tracing of CLI connections and commands */
int latency_debug; /* I/O loop tracks duration of each event */
u32 latency_limit; /* Events with longer duration are logged (us) */
u32 watchdog_warning; /* I/O loop watchdog limit for warning (us) */
u32 watchdog_timeout; /* Watchdog timeout (in seconds, 0 = disabled) */
char *err_msg; /* Parser error message */
int err_lino; /* Line containing error */
char *err_file_name; /* File name containing error */

10
doc/bird.conf.example
View File

@ -33,6 +33,10 @@
# Turn on global debugging of all protocols
#debug protocols all;
# Turn on internal watchdog
#watchdog warning 5 s;
#watchdog timeout 30 s;
# The direct protocol automatically generates device routes to
# all network interfaces. Can exist in as many instances as you wish
# if you want to populate multiple routing tables with device routes.
@ -162,7 +166,7 @@ protocol static {
# };
# };
#}
#protocol bgp {
# disabled;
@ -186,7 +190,7 @@ protocol static {
# source address 198.51.100.14; # What local address we use for the TCP connection
# password "secret"; # Password used for MD5 authentication
# rr client; # I am a route reflector and the neighor is my client
# rr cluster id 1.0.0.1; # Use this value for cluster id instead of my router id
# rr cluster id 1.0.0.1; # Use this value for cluster id instead of my router id
# export where source=RTS_STATIC;
# export filter {
# if source = RTS_STATIC then {
@ -202,7 +206,7 @@ protocol static {
# reject;
# };
#}
#
#
# Template usage example
#template bgp rr_client {
# disabled;

35
doc/bird.sgml
View File

@ -344,6 +344,23 @@ protocol rip {
of connects and disconnects, 2 and higher for logging of all client
commands). Default: 0.
<tag>debug latency <m/switch/</tag>
Activate tracking of elapsed time for internal events. Recent events
could be examined using <cf/dump events/ command. Default: off.
<tag>debug latency limit <m/time/</tag>
If <cf/debug latency/ is enabled, this option allows to specify a limit
for elapsed time. Events exceeding the limit are logged. Default: 1 s.
<tag>watchdog warning <m/time/</tag>
Set time limit for I/O loop cycle. If one iteration took more time to
complete, a warning is logged. Default: 5 s.
<tag>watchdog timeout <m/time/</tag>
Set time limit for I/O loop cycle. If the limit is breached, BIRD is
killed by abort signal. The timeout has effective granularity of
seconds, zero means disabled. Default: disabled (0).
<tag>mrtdump "<m/filename/"</tag>
Set MRTdump file name. This option must be specified to allow MRTdump
feature. Default: no dump file.
@ -1787,13 +1804,17 @@ using the following configuration parameters:
other means. Default: 0 (no local AS number allowed).
<tag>enable route refresh <m/switch/</tag>
When BGP speaker changes its import filter, it has to re-examine all
routes received from its neighbor against the new filter. As these
routes might not be available, there is a BGP protocol extension Route
Refresh (specified in RFC 2918) that allows BGP speaker to request
re-advertisement of all routes from its neighbor. This option specifies
whether BIRD advertises this capability and accepts such requests. Even
when disabled, BIRD can send route refresh requests. Default: on.
After the initial route exchange, BGP protocol uses incremental updates
to keep BGP speakers synchronized. Sometimes (e.g., if BGP speaker
changes its import filter, or if there is suspicion of inconsistency) it
is necessary to do a new complete route exchange. BGP protocol extension
Route Refresh (RFC 2918) allows BGP speaker to request re-advertisement
of all routes from its neighbor. BGP protocol extension Enhanced Route
Refresh (RFC 7313) specifies explicit begin and end for such exchanges,
therefore the receiver can remove stale routes that were not advertised
during the exchange. This option specifies whether BIRD advertises these
capabilities and supports related procedures. Note that even when
disabled, BIRD can send route refresh requests. Default: on.
<tag>graceful restart <m/switch/|aware</tag>
When a BGP speaker restarts or crashes, neighbors will discard all

7
lib/event.c
View File

@ -114,6 +114,8 @@ ev_schedule(event *e)
ev_enqueue(&global_event_list, e);
}
void io_log_event(void *hook, void *data);
/**
* ev_run_list - run an event list
* @l: an event list
@ -132,6 +134,11 @@ ev_run_list(event_list *l)
WALK_LIST_FIRST(n, tmp_list)
{
event *e = SKIP_BACK(event, n, n);
/* This is ugly hack, we want to log just events executed from the main I/O loop */
if (l == &global_event_list)
io_log_event(e->hook, e->data);
ev_run(e);
}
return !EMPTY_LIST(*l);

6
misc/bird.spec
View File

@ -1,6 +1,6 @@
Summary: BIRD Internet Routing Daemon
Name: bird
Version: 1.4.5
Version: 1.5.0
Release: 1
Copyright: GPL
Group: Networking/Daemons
@ -41,11 +41,11 @@ install $RPM_SOURCE_DIR/birdc6 usr/sbin/birdc6
%post
/sbin/ldconfig
/sbin/chkconfig --add bird
%preun
if [ $1 = 0 ] ; then
/sbin/chkconfig --del bird
fi
fi
%files
%attr(755,root,root) /usr/sbin/bird

8
nest/config.Y
View File

@ -181,6 +181,12 @@ proto_name:
cf_define_symbol($1, this_proto->class, this_proto);
this_proto->name = $1->name;
}
| FROM SYM {
struct symbol *s = cf_default_name(this_proto->protocol->template, &this_proto->protocol->name_counter);
this_proto->name = s->name;
if (($2->class != SYM_TEMPLATE) && ($2->class != SYM_PROTO)) cf_error("Template or protocol name expected");
proto_copy_config(this_proto, $2->def);
}
| SYM FROM SYM {
if (($3->class != SYM_TEMPLATE) && ($3->class != SYM_PROTO)) cf_error("Template or protocol name expected");
@ -621,6 +627,8 @@ CF_CLI(DUMP RESOURCES,,, [[Dump all allocated resource]])
{ rdump(&root_pool); cli_msg(0, ""); } ;
CF_CLI(DUMP SOCKETS,,, [[Dump open sockets]])
{ sk_dump_all(); cli_msg(0, ""); } ;
CF_CLI(DUMP EVENTS,,, [[Dump event log]])
{ io_log_dump(); cli_msg(0, ""); } ;
CF_CLI(DUMP INTERFACES,,, [[Dump interface information]])
{ if_dump_all(); cli_msg(0, ""); } ;
CF_CLI(DUMP NEIGHBORS,,, [[Dump neighbor cache]])

7
nest/proto.c
View File

@ -942,8 +942,8 @@ proto_feed_more(void *P)
p->export_state = ES_READY;
proto_log_state_change(p);
if (p->feed_done)
p->feed_done(p);
if (p->feed_end)
p->feed_end(p);
}
else
{
@ -976,6 +976,9 @@ proto_schedule_feed(struct proto *p, int initial)
p->attn->hook = initial ? proto_feed_initial : proto_feed_more;
ev_schedule(p->attn);
if (p->feed_begin)
p->feed_begin(p, initial);
}
/*

6
nest/protocol.h
View File

@ -179,7 +179,8 @@ struct proto {
* reload_routes Request protocol to reload all its routes to the core
* (using rte_update()). Returns: 0=reload cannot be done,
* 1= reload is scheduled and will happen (asynchronously).
* feed_done Notify protocol about finish of route feeding.
* feed_begin Notify protocol about beginning of route feeding.
* feed_end Notify protocol about finish of route feeding.
*/
void (*if_notify)(struct proto *, unsigned flags, struct iface *i);
@ -190,7 +191,8 @@ struct proto {
void (*store_tmp_attrs)(struct rte *rt, struct ea_list *attrs);
int (*import_control)(struct proto *, struct rte **rt, struct ea_list **attrs, struct linpool *pool);
int (*reload_routes)(struct proto *);
void (*feed_done)(struct proto *);
void (*feed_begin)(struct proto *, int initial);
void (*feed_end)(struct proto *);
/*
* Routing entry hooks (called only for routes belonging to this protocol):

102
proto/bgp/bgp.c
View File

@ -377,6 +377,8 @@ bgp_conn_enter_established_state(struct bgp_conn *conn)
p->conn = conn;
p->last_error_class = 0;
p->last_error_code = 0;
p->feed_state = BFS_NONE;
p->load_state = BFS_NONE;
bgp_init_bucket_table(p);
bgp_init_prefix_table(p, 8);
@ -394,6 +396,12 @@ bgp_conn_enter_established_state(struct bgp_conn *conn)
if (p->gr_active && (!conn->peer_gr_able || !(conn->peer_gr_aflags & BGP_GRF_FORWARDING)))
bgp_graceful_restart_done(p);
/* GR capability implies that neighbor will send End-of-RIB */
if (conn->peer_gr_aware)
p->load_state = BFS_LOADING;
/* proto_notify_state() will likely call bgp_feed_begin(), setting p->feed_state */
bgp_conn_set_state(conn, BS_ESTABLISHED);
proto_notify_state(&p->p, PS_UP);
}
@ -504,6 +512,47 @@ bgp_graceful_restart_timeout(timer *t)
bgp_stop(p, 0);
}
/**
* bgp_refresh_begin - start incoming enhanced route refresh sequence
* @p: BGP instance
*
* This function is called when an incoming enhanced route refresh sequence is
* started by the neighbor, demarcated by the BoRR packet. The function updates
* the load state and starts the routing table refresh cycle. Note that graceful
* restart also uses routing table refresh cycle, but RFC 7313 and load states
* ensure that these two sequences do not overlap.
*/
void
bgp_refresh_begin(struct bgp_proto *p)
{
if (p->load_state == BFS_LOADING)
{ log(L_WARN "%s: BEGIN-OF-RR received before END-OF-RIB, ignoring", p->p.name); return; }
p->load_state = BFS_REFRESHING;
rt_refresh_begin(p->p.main_ahook->table, p->p.main_ahook);
}
/**
* bgp_refresh_end - finish incoming enhanced route refresh sequence
* @p: BGP instance
*
* This function is called when an incoming enhanced route refresh sequence is
* finished by the neighbor, demarcated by the EoRR packet. The function updates
* the load state and ends the routing table refresh cycle. Routes not received
* during the sequence are removed by the nest.
*/
void
bgp_refresh_end(struct bgp_proto *p)
{
if (p->load_state != BFS_REFRESHING)
{ log(L_WARN "%s: END-OF-RR received without prior BEGIN-OF-RR, ignoring", p->p.name); return; }
p->load_state = BFS_NONE;
rt_refresh_end(p->p.main_ahook->table, p->p.main_ahook);
}
static void
bgp_send_open(struct bgp_conn *conn)
{
@ -514,6 +563,7 @@ bgp_send_open(struct bgp_conn *conn)
conn->peer_refresh_support = 0;
conn->peer_as4_support = 0;
conn->peer_add_path = 0;
conn->peer_enhanced_refresh_support = 0;
conn->peer_gr_aware = 0;
conn->peer_gr_able = 0;
conn->peer_gr_time = 0;
@ -959,16 +1009,56 @@ bgp_reload_routes(struct proto *P)
}
static void
bgp_feed_done(struct proto *P)
bgp_feed_begin(struct proto *P, int initial)
{
struct bgp_proto *p = (struct bgp_proto *) P;
if (!p->conn || !p->cf->gr_mode || p->p.refeeding)
/* This should not happen */
if (!p->conn)
return;
p->send_end_mark = 1;
if (initial && p->cf->gr_mode)
p->feed_state = BFS_LOADING;
/* It is refeed and both sides support enhanced route refresh */
if (!initial && p->cf->enable_refresh &&
p->conn->peer_enhanced_refresh_support)
{
/* BoRR must not be sent before End-of-RIB */
if (p->feed_state == BFS_LOADING || p->feed_state == BFS_LOADED)
return;
p->feed_state = BFS_REFRESHING;
bgp_schedule_packet(p->conn, PKT_BEGIN_REFRESH);
}
}
static void
bgp_feed_end(struct proto *P)
{
struct bgp_proto *p = (struct bgp_proto *) P;
/* This should not happen */
if (!p->conn)
return;
/* Non-demarcated feed ended, nothing to do */
if (p->feed_state == BFS_NONE)
return;
/* Schedule End-of-RIB packet */
if (p->feed_state == BFS_LOADING)
p->feed_state = BFS_LOADED;
/* Schedule EoRR packet */
if (p->feed_state == BFS_REFRESHING)
p->feed_state = BFS_REFRESHED;
/* Kick TX hook */
bgp_schedule_packet(p->conn, PKT_UPDATE);
}
static void
bgp_start_locked(struct object_lock *lock)
{
@ -1150,7 +1240,8 @@ bgp_init(struct proto_config *C)
P->import_control = bgp_import_control;
P->neigh_notify = bgp_neigh_notify;
P->reload_routes = bgp_reload_routes;
P->feed_done = bgp_feed_done;
P->feed_begin = bgp_feed_begin;
P->feed_end = bgp_feed_end;
P->rte_better = bgp_rte_better;
P->rte_recalculate = c->deterministic_med ? bgp_rte_recalculate : NULL;
@ -1426,8 +1517,9 @@ bgp_show_proto_info(struct proto *P)
else if (P->proto_state == PS_UP)
{
cli_msg(-1006, " Neighbor ID: %R", p->remote_id);
cli_msg(-1006, " Neighbor caps: %s%s%s%s%s",
cli_msg(-1006, " Neighbor caps: %s%s%s%s%s%s",
c->peer_refresh_support ? " refresh" : "",
c->peer_enhanced_refresh_support ? " enhanced-refresh" : "",
c->peer_gr_able ? " restart-able" : (c->peer_gr_aware ? " restart-aware" : ""),
c->peer_as4_support ? " AS4" : "",
(c->peer_add_path & ADD_PATH_RX) ? " add-path-rx" : "",

46
proto/bgp/bgp.h
View File

@ -103,6 +103,7 @@ struct bgp_conn {
u8 peer_refresh_support; /* Peer supports route refresh [RFC2918] */
u8 peer_as4_support; /* Peer supports 4B AS numbers [RFC4893] */
u8 peer_add_path; /* Peer supports ADD-PATH [draft] */
u8 peer_enhanced_refresh_support; /* Peer supports enhanced refresh [RFC7313] */
u8 peer_gr_aware;
u8 peer_gr_able;
u16 peer_gr_time;
@ -127,6 +128,8 @@ struct bgp_proto {
int rs_client; /* Whether neighbor is RS client of me */
u8 gr_ready; /* Neighbor could do graceful restart */
u8 gr_active; /* Neighbor is doing graceful restart */
u8 feed_state; /* Feed state (TX) for EoR, RR packets, see BFS_* */
u8 load_state; /* Load state (RX) for EoR, RR packets, see BFS_* */
struct bgp_conn *conn; /* Connection we have established */
struct bgp_conn outgoing_conn; /* Outgoing connection we're working with */
struct bgp_conn incoming_conn; /* Incoming connection we have neither accepted nor rejected yet */
@ -144,7 +147,6 @@ struct bgp_proto {
slab *prefix_slab; /* Slab holding prefix nodes */
list bucket_queue; /* Queue of buckets to send */
struct bgp_bucket *withdraw_bucket; /* Withdrawn routes */
unsigned send_end_mark; /* End-of-RIB mark scheduled for transmit */
unsigned startup_delay; /* Time to delay protocol startup by due to errors */
bird_clock_t last_proto_error; /* Time of last error that leads to protocol stop */
u8 last_error_class; /* Error class of last error */
@ -196,6 +198,8 @@ void bgp_conn_enter_close_state(struct bgp_conn *conn);
void bgp_conn_enter_idle_state(struct bgp_conn *conn);
void bgp_handle_graceful_restart(struct bgp_proto *p);
void bgp_graceful_restart_done(struct bgp_proto *p);
void bgp_refresh_begin(struct bgp_proto *p);
void bgp_refresh_end(struct bgp_proto *p);
void bgp_store_error(struct bgp_proto *p, struct bgp_conn *c, u8 class, u32 code);
void bgp_stop(struct bgp_proto *p, unsigned subcode);
@ -263,7 +267,8 @@ void bgp_log_error(struct bgp_proto *p, u8 class, char *msg, unsigned code, unsi
#define PKT_UPDATE 0x02
#define PKT_NOTIFICATION 0x03
#define PKT_KEEPALIVE 0x04
#define PKT_ROUTE_REFRESH 0x05
#define PKT_ROUTE_REFRESH 0x05 /* [RFC2918] */
#define PKT_BEGIN_REFRESH 0x1e /* Dummy type for BoRR packet [RFC7313] */
#define PKT_SCHEDULE_CLOSE 0x1f /* Used internally to schedule socket close */
/* Attributes */
@ -306,13 +311,13 @@ void bgp_log_error(struct bgp_proto *p, u8 class, char *msg, unsigned code, unsi
#define BS_MAX 7
/* BGP start states
*
*
* Used in PS_START for fine-grained specification of starting state.
*
* When BGP protocol is started by core, it goes to BSS_PREPARE. When BGP protocol
* done what is neccessary to start itself (like acquiring the lock), it goes to BSS_CONNECT.
* When some connection attempt failed because of option or capability error, it goes to
* BSS_CONNECT_NOCAP.
* When BGP protocol is started by core, it goes to BSS_PREPARE. When BGP
* protocol done what is neccessary to start itself (like acquiring the lock),
* it goes to BSS_CONNECT. When some connection attempt failed because of
* option or capability error, it goes to BSS_CONNECT_NOCAP.
*/
#define BSS_PREPARE 0 /* Used before ordinary BGP started, i. e. waiting for lock */
@ -320,6 +325,33 @@ void bgp_log_error(struct bgp_proto *p, u8 class, char *msg, unsigned code, unsi
#define BSS_CONNECT 2 /* Ordinary BGP connecting */
#define BSS_CONNECT_NOCAP 3 /* Legacy BGP connecting (without capabilities) */
/* BGP feed states (TX)
*
* RFC 4724 specifies that an initial feed should end with End-of-RIB mark.
*
* RFC 7313 specifies that a route refresh should be demarcated by BoRR and EoRR packets.
*
* These states (stored in p->feed_state) are used to keep track of these
* requirements. When such feed is started, BFS_LOADING / BFS_REFRESHING is
* set. When it ended, BFS_LOADED / BFS_REFRESHED is set to schedule End-of-RIB
* or EoRR packet. When the packet is sent, the state returned to BFS_NONE.
*
* Note that when a non-demarcated feed (e.g. plain RFC 4271 initial load
* without End-of-RIB or plain RFC 2918 route refresh without BoRR/EoRR
* demarcation) is active, BFS_NONE is set.
*
* BFS_NONE, BFS_LOADING and BFS_REFRESHING are also used as load states (RX)
* with correspondent semantics (-, expecting End-of-RIB, expecting EoRR).
*/
#define BFS_NONE 0 /* No feed or original non-demarcated feed */
#define BFS_LOADING 1 /* Initial feed active, End-of-RIB planned */
#define BFS_LOADED 2 /* Loading done, End-of-RIB marker scheduled */
#define BFS_REFRESHING 3 /* Route refresh (introduced by BoRR) active */
#define BFS_REFRESHED 4 /* Refresh done, EoRR packet scheduled */
/* Error classes */
#define BE_NONE 0

165
proto/bgp/packets.c
View File

@ -22,6 +22,12 @@
#include "bgp.h"
#define BGP_RR_REQUEST 0
#define BGP_RR_BEGIN 1
#define BGP_RR_END 2
static struct tbf rl_rcv_update = TBF_DEFAULT_LOG_LIMITS;
static struct tbf rl_snd_update = TBF_DEFAULT_LOG_LIMITS;
@ -209,6 +215,15 @@ bgp_put_cap_add_path(struct bgp_proto *p, byte *buf)
return buf;
}
static byte *
bgp_put_cap_err(struct bgp_proto *p UNUSED, byte *buf)
{
*buf++ = 70; /* Capability 70: Support for enhanced route refresh */
*buf++ = 0; /* Capability data length */
return buf;
}
static byte *
bgp_create_open(struct bgp_conn *conn, byte *buf)
{
@ -256,6 +271,9 @@ bgp_create_open(struct bgp_conn *conn, byte *buf)
if (p->cf->add_path)
cap = bgp_put_cap_add_path(p, cap);
if (p->cf->enable_refresh)
cap = bgp_put_cap_err(p, cap);
cap_len = cap - buf - 12;
if (cap_len > 0)
{
@ -389,7 +407,7 @@ static byte *
bgp_create_end_mark(struct bgp_conn *conn, byte *buf)
{
struct bgp_proto *p = conn->bgp;
BGP_TRACE(D_PACKETS, "Sending End-of-RIB");
BGP_TRACE(D_PACKETS, "Sending END-OF-RIB");
put_u32(buf, 0);
return buf+4;
@ -568,7 +586,7 @@ static byte *
bgp_create_end_mark(struct bgp_conn *conn, byte *buf)
{
struct bgp_proto *p = conn->bgp;
BGP_TRACE(D_PACKETS, "Sending End-of-RIB");
BGP_TRACE(D_PACKETS, "Sending END-OF-RIB");
put_u16(buf+0, 0);
put_u16(buf+2, 6); /* length 4-9 */
@ -586,19 +604,49 @@ bgp_create_end_mark(struct bgp_conn *conn, byte *buf)
#endif
static byte *
static inline byte *
bgp_create_route_refresh(struct bgp_conn *conn, byte *buf)
{
struct bgp_proto *p = conn->bgp;
BGP_TRACE(D_PACKETS, "Sending ROUTE-REFRESH");
/* Original original route refresh request, RFC 2918 */
*buf++ = 0;
*buf++ = BGP_AF;
*buf++ = 0; /* RFU */
*buf++ = 1; /* and SAFI 1 */
*buf++ = BGP_RR_REQUEST;
*buf++ = 1; /* SAFI */
return buf;
}
static inline byte *
bgp_create_begin_refresh(struct bgp_conn *conn, byte *buf)
{
struct bgp_proto *p = conn->bgp;
BGP_TRACE(D_PACKETS, "Sending BEGIN-OF-RR");
/* Demarcation of beginning of route refresh (BoRR), RFC 7313 */
*buf++ = 0;
*buf++ = BGP_AF;
*buf++ = BGP_RR_BEGIN;
*buf++ = 1; /* SAFI */
return buf;
}
static inline byte *
bgp_create_end_refresh(struct bgp_conn *conn, byte *buf)
{
struct bgp_proto *p = conn->bgp;
BGP_TRACE(D_PACKETS, "Sending END-OF-RR");
/* Demarcation of ending of route refresh (EoRR), RFC 7313 */
*buf++ = 0;
*buf++ = BGP_AF;
*buf++ = BGP_RR_END;
*buf++ = 1; /* SAFI */
return buf;
}
static void
bgp_create_header(byte *buf, unsigned int len, unsigned int type)
{
@ -666,24 +714,44 @@ bgp_fire_tx(struct bgp_conn *conn)
type = PKT_ROUTE_REFRESH;
end = bgp_create_route_refresh(conn, pkt);
}
else if (s & (1 << PKT_BEGIN_REFRESH))
{
s &= ~(1 << PKT_BEGIN_REFRESH);
type = PKT_ROUTE_REFRESH; /* BoRR is a subtype of RR */
end = bgp_create_begin_refresh(conn, pkt);
}
else if (s & (1 << PKT_UPDATE))
{
end = bgp_create_update(conn, pkt);
type = PKT_UPDATE;
end = bgp_create_update(conn, pkt);
if (!end)
{
{
/* No update to send, perhaps we need to send End-of-RIB or EoRR */
conn->packets_to_send = 0;
if (!p->send_end_mark)
if (p->feed_state == BFS_LOADED)
{
type = PKT_UPDATE;
end = bgp_create_end_mark(conn, pkt);
}
else if (p->feed_state == BFS_REFRESHED)
{
type = PKT_ROUTE_REFRESH;
end = bgp_create_end_refresh(conn, pkt);
}
else /* Really nothing to send */
return 0;
p->send_end_mark = 0;
end = bgp_create_end_mark(conn, pkt);
p->feed_state = BFS_NONE;
}
}
else
return 0;
conn->packets_to_send = s;
bgp_create_header(buf, end - buf, type);
return sk_send(sk, end - buf);
@ -701,7 +769,7 @@ bgp_schedule_packet(struct bgp_conn *conn, int type)
{
DBG("BGP: Scheduling packet type %d\n", type);
conn->packets_to_send |= 1 << type;
if (conn->sk && conn->sk->tpos == conn->sk->tbuf)
if (conn->sk && conn->sk->tpos == conn->sk->tbuf && !ev_active(conn->tx_ev))
ev_schedule(conn->tx_ev);
}
@ -737,7 +805,7 @@ bgp_parse_capabilities(struct bgp_conn *conn, byte *opt, int len)
{
if (len < 2 || len < 2 + opt[1])
goto err;
cl = opt[1];
switch (opt[0])
@ -780,7 +848,12 @@ bgp_parse_capabilities(struct bgp_conn *conn, byte *opt, int len)
conn->peer_add_path = opt[2+i+3];
if (conn->peer_add_path > ADD_PATH_FULL)
goto err;
break;
case 70: /* Enhanced route refresh capability, RFC 7313 */
if (cl != 0)
goto err;
conn->peer_enhanced_refresh_support = 1;
break;
/* We can safely ignore all other capabilities */
@ -870,7 +943,8 @@ bgp_rx_open(struct bgp_conn *conn, byte *pkt, int len)
if (hold > 0 && hold < 3)
{ bgp_error(conn, 2, 6, pkt+22, 2); return; }
if (!id || id == 0xffffffff || id == p->local_id)
/* RFC 6286 2.2 - router ID is nonzero and AS-wide unique */
if (!id || (p->is_internal && id == p->local_id))
{ bgp_error(conn, 2, 3, pkt+24, -4); return; }
if ((conn->advertised_as != base_as) && (base_as != AS_TRANS))
@ -905,8 +979,23 @@ bgp_rx_open(struct bgp_conn *conn, byte *pkt, int len)
break;
case BS_OPENCONFIRM:
if ((p->local_id < id) == (conn == &p->incoming_conn))
{
/*
* Description of collision detection rules in RFC 4271 is confusing and
* contradictory, but it is essentially:
*
* 1. Router with higher ID is dominant
* 2. If both have the same ID, router with higher ASN is dominant [RFC6286]
* 3. When both connections are in OpenConfirm state, one initiated by
* the dominant router is kept.
*
* The first line in the expression below evaluates whether the neighbor
* is dominant, the second line whether the new connection was initiated
* by the neighbor. If both are true (or both are false), we keep the new
* connection, otherwise we keep the old one.
*/
if (((p->local_id < id) || ((p->local_id == id) && (p->local_as < p->remote_as)))
== (conn == &p->incoming_conn))
{
/* Should close the other connection */
BGP_TRACE(D_EVENTS, "Connection collision, giving up the other connection");
bgp_error(other, 6, 7, NULL, 0);
@ -945,7 +1034,10 @@ bgp_rx_open(struct bgp_conn *conn, byte *pkt, int len)
static inline void
bgp_rx_end_mark(struct bgp_proto *p)
{
BGP_TRACE(D_PACKETS, "Got End-of-RIB");
BGP_TRACE(D_PACKETS, "Got END-OF-RIB");
if (p->load_state == BFS_LOADING)
p->load_state = BFS_NONE;
if (p->p.gr_recovery)
proto_graceful_restart_unlock(&p->p);
@ -999,7 +1091,11 @@ bgp_rte_update(struct bgp_proto *p, ip_addr prefix, int pxlen,
if (!*a)
{
a0->src = *src;
/* Workaround for rta_lookup() breaking eattrs */
ea_list *ea = a0->eattrs;
*a = rta_lookup(a0);
a0->eattrs = ea;
}
net *n = net_get(p->p.table, prefix, pxlen);
@ -1349,7 +1445,9 @@ static struct {
{ 6, 5, "Connection rejected" },
{ 6, 6, "Other configuration change" },
{ 6, 7, "Connection collision resolution" },
{ 6, 8, "Out of Resources" }
{ 6, 8, "Out of Resources" },
{ 7, 0, "Invalid ROUTE-REFRESH message" }, /* [RFC7313] */
{ 7, 1, "Invalid ROUTE-REFRESH message length" } /* [RFC7313] */
};
/**
@ -1480,22 +1578,47 @@ bgp_rx_route_refresh(struct bgp_conn *conn, byte *pkt, int len)
{
struct bgp_proto *p = conn->bgp;
BGP_TRACE(D_PACKETS, "Got ROUTE-REFRESH");
if (conn->state != BS_ESTABLISHED)
{ bgp_error(conn, 5, fsm_err_subcode[conn->state], NULL, 0); return; }
if (!p->cf->enable_refresh)
{ bgp_error(conn, 1, 3, pkt+18, 1); return; }
if (len != (BGP_HEADER_LENGTH + 4))
if (len < (BGP_HEADER_LENGTH + 4))
{ bgp_error(conn, 1, 2, pkt+16, 2); return; }
if (len > (BGP_HEADER_LENGTH + 4))
{ bgp_error(conn, 7, 1, pkt, MIN(len, 2048)); return; }
/* FIXME - we ignore AFI/SAFI values, as we support
just one value and even an error code for an invalid
request is not defined */
proto_request_feeding(&p->p);
/* RFC 7313 redefined reserved field as RR message subtype */
uint subtype = conn->peer_enhanced_refresh_support ? pkt[21] : BGP_RR_REQUEST;
switch (subtype)
{
case BGP_RR_REQUEST:
BGP_TRACE(D_PACKETS, "Got ROUTE-REFRESH");
proto_request_feeding(&p->p);
break;
case BGP_RR_BEGIN:
BGP_TRACE(D_PACKETS, "Got BEGIN-OF-RR");
bgp_refresh_begin(p);
break;
case BGP_RR_END:
BGP_TRACE(D_PACKETS, "Got END-OF-RR");
bgp_refresh_end(p);
break;
default:
log(L_WARN "%s: Got ROUTE-REFRESH message with unknown subtype %u, ignoring",
p->p.name, subtype);
break;
}
}

2
proto/ospf/ospf.h
View File

@ -916,9 +916,11 @@ static inline void ospf_send_to_des(struct ospf_iface *ifa)
ospf_send_to_bdr(ifa);
}
#ifndef PARSER
#define DROP(DSC,VAL) do { err_dsc = DSC; err_val = VAL; goto drop; } while(0)
#define DROP1(DSC) do { err_dsc = DSC; goto drop; } while(0)
#define SKIP(DSC) do { err_dsc = DSC; goto skip; } while(0)
#endif
static inline uint ospf_pkt_hdrlen(struct ospf_proto *p)
{ return ospf_is_v2(p) ? (sizeof(struct ospf_packet) + sizeof(union ospf_auth)) : sizeof(struct ospf_packet); }

5
proto/ospf/rt.c
View File

@ -95,6 +95,8 @@ merge_nexthops(struct ospf_proto *p, struct mpnh *s1, struct mpnh *s2, int r1, i
struct mpnh **n = &root;
int count = p->ecmp;
ASSERT(p->ecmp);
/*
* r1, r2 signalize whether we can reuse nexthops from s1, s2.
* New nexthops (s2, new) can be reused if they are not inherited
@ -153,6 +155,9 @@ fix_device_nexthops(struct ospf_proto *p, const struct mpnh *n, ip_addr gw)
struct mpnh **nn1 = &root1;
struct mpnh **nn2 = &root2;
if (!p->ecmp)
return new_nexthop(p, gw, n->iface, n->weight);
/* This is a bit tricky. We cannot just copy the list and update n->gw,
because the list should stay sorted, so we create two lists, one with new
gateways and one with old ones, and then merge them. */

8
sysdep/bsd/krt-sock.c
View File

@ -247,7 +247,7 @@ krt_send_route(struct krt_proto *p, int cmd, rte *e)
#ifdef IPV6
/* Embed interface ID to link-local address */
if (ipa_has_link_scope(gw))
if (ipa_is_link_local(gw))
_I0(gw) = 0xfe800000 | (i->index & 0x0000ffff);
#endif
@ -468,7 +468,7 @@ krt_read_route(struct ks_msg *msg, struct krt_proto *p, int scan)
#ifdef IPV6
/* Clean up embedded interface ID returned in link-local address */
if (ipa_has_link_scope(a.gw))
if (ipa_is_link_local(a.gw))
_I0(a.gw) = 0xfe800000;
#endif
@ -662,10 +662,10 @@ krt_read_addr(struct ks_msg *msg, int scan)
#ifdef IPV6
/* Clean up embedded interface ID returned in link-local address */
if (ipa_has_link_scope(iaddr))
if (ipa_is_link_local(iaddr))
_I0(iaddr) = 0xfe800000;
if (ipa_has_link_scope(ibrd))
if (ipa_is_link_local(ibrd))
_I0(ibrd) = 0xfe800000;
#endif

2
sysdep/config.h
View File

@ -7,7 +7,7 @@
#define _BIRD_CONFIG_H_
/* BIRD version */
#define BIRD_VERSION "1.5.0pre"
#define BIRD_VERSION "1.5.0"
/* Include parameters determined by configure script */
#include "sysdep/autoconf.h"

3
sysdep/linux/netlink.c
View File

@ -436,6 +436,9 @@ nl_parse_link(struct nlmsghdr *h, int scan)
else
f.flags |= IF_MULTIACCESS; /* NBMA */
if (fl & IFF_MULTICAST)
f.flags |= IF_MULTICAST;
ifi = if_update(&f);
if (!scan)

13
sysdep/unix/config.Y
View File

@ -15,6 +15,7 @@ CF_DECLS
CF_KEYWORDS(LOG, SYSLOG, ALL, DEBUG, TRACE, INFO, REMOTE, WARNING, ERROR, AUTH, FATAL, BUG, STDERR, SOFT)
CF_KEYWORDS(TIMEFORMAT, ISO, OLD, SHORT, LONG, BASE, NAME, CONFIRM, UNDO, CHECK, TIMEOUT)
CF_KEYWORDS(DEBUG, LATENCY, LIMIT, WATCHDOG, WARNING, TIMEOUT)
%type <i> log_mask log_mask_list log_cat cfg_timeout
%type <g> log_file
@ -83,6 +84,7 @@ mrtdump_base:
}
;
CF_ADDTO(conf, timeformat_base)
timeformat_which:
@ -104,6 +106,17 @@ timeformat_base:
TIMEFORMAT timeformat_spec ';'
;
CF_ADDTO(conf, debug_unix)
debug_unix:
DEBUG LATENCY bool { new_config->latency_debug = $3; }
| DEBUG LATENCY LIMIT expr_us { new_config->latency_limit = $4; }
| WATCHDOG WARNING expr_us { new_config->watchdog_warning = $3; }
| WATCHDOG TIMEOUT expr_us { new_config->watchdog_timeout = ($3 + 999999) TO_S; }
;
/* Unix specific commands */
CF_CLI_HELP(CONFIGURE, ..., [[Reload configuration]])

210
sysdep/unix/io.c
View File

@ -332,6 +332,8 @@ tm_first_shot(void)
return x;
}
void io_log_event(void *hook, void *data);
static void
tm_shot(void)
{
@ -372,6 +374,7 @@ tm_shot(void)
i = 0;
tm_start(t, i);
}
io_log_event(t->hook, t->data);
t->hook(t);
}
}
@ -764,6 +767,32 @@ sk_set_tos6(sock *s, int tos)
return 0;
}
static inline int
sk_set_high_port(sock *s)
{
/* Port range setting is optional, ignore it if not supported */
#ifdef IP_PORTRANGE
if (sk_is_ipv4(s))
{
int range = IP_PORTRANGE_HIGH;
if (setsockopt(s->fd, SOL_IP, IP_PORTRANGE, &range, sizeof(range)) < 0)
ERR("IP_PORTRANGE");
}
#endif
#ifdef IPV6_PORTRANGE
if (sk_is_ipv6(s))
{
int range = IPV6_PORTRANGE_HIGH;
if (setsockopt(s->fd, SOL_IPV6, IPV6_PORTRANGE, &range, sizeof(range)) < 0)
ERR("IPV6_PORTRANGE");
}
#endif
return 0;
}
static inline byte *
sk_skip_ip_header(byte *pkt, int *len)
{
@ -1103,7 +1132,7 @@ sk_dump(resource *r)
sock *s = (sock *) r;
static char *sk_type_names[] = { "TCP<", "TCP>", "TCP", "UDP", NULL, "IP", NULL, "MAGIC", "UNIX<", "UNIX", "DEL!" };
debug("(%s, ud=%p, sa=%08x, sp=%d, da=%08x, dp=%d, tos=%d, ttl=%d, if=%s)\n",
debug("(%s, ud=%p, sa=%I, sp=%d, da=%I, dp=%d, tos=%d, ttl=%d, if=%s)\n",
sk_type_names[s->type],
s->data,
s->saddr,
@ -1399,14 +1428,10 @@ sk_open(sock *s)
}
#endif
}
#ifdef IP_PORTRANGE
else if (s->flags & SKF_HIGH_PORT)
{
int range = IP_PORTRANGE_HIGH;
if (setsockopt(fd, IPPROTO_IP, IP_PORTRANGE, &range, sizeof(range)) < 0)
log(L_WARN "Socket error: %s%#m", "IP_PORTRANGE");
}
#endif
else
if (s->flags & SKF_HIGH_PORT)
if (sk_set_high_port(s) < 0)
log(L_WARN "Socket error: %s%#m", s->err);
sockaddr_fill(&sa, af, bind_addr, s->iface, bind_port);
if (bind(fd, &sa.sa, SA_LEN(sa)) < 0)
@ -1839,6 +1864,162 @@ sk_dump_all(void)
}
/*
* Internal event log and watchdog
*/
#define EVENT_LOG_LENGTH 32
struct event_log_entry
{
void *hook;
void *data;
btime timestamp;
btime duration;
};
static struct event_log_entry event_log[EVENT_LOG_LENGTH];
static struct event_log_entry *event_open;
static int event_log_pos, event_log_num, watchdog_active;
static btime last_time;
static btime loop_time;
static void
io_update_time(void)
{
struct timespec ts;
int rv;
if (!clock_monotonic_available)
return;
/*
* This is third time-tracking procedure (after update_times() above and
* times_update() in BFD), dedicated to internal event log and latency
* tracking. Hopefully, we consolidate these sometimes.
*/
rv = clock_gettime(CLOCK_MONOTONIC, &ts);
if (rv < 0)
die("clock_gettime: %m");
last_time = ((s64) ts.tv_sec S) + (ts.tv_nsec / 1000);
if (event_open)
{
event_open->duration = last_time - event_open->timestamp;
if (event_open->duration > config->latency_limit)
log(L_WARN "Event 0x%p 0x%p took %d ms",
event_open->hook, event_open->data, (int) (event_open->duration TO_MS));
event_open = NULL;
}
}
/**
* io_log_event - mark approaching event into event log
* @hook: event hook address
* @data: event data address
*
* Store info (hook, data, timestamp) about the following internal event into
* a circular event log (@event_log). When latency tracking is enabled, the log
* entry is kept open (in @event_open) so the duration can be filled later.
*/
void
io_log_event(void *hook, void *data)
{
if (config->latency_debug)
io_update_time();
struct event_log_entry *en = event_log + event_log_pos;
en->hook = hook;
en->data = data;
en->timestamp = last_time;
en->duration = 0;
event_log_num++;
event_log_pos++;
event_log_pos %= EVENT_LOG_LENGTH;
event_open = config->latency_debug ? en : NULL;
}
static inline void
io_close_event(void)
{
if (event_open)
io_update_time();
}
void
io_log_dump(void)
{
int i;
log(L_DEBUG "Event log:");
for (i = 0; i < EVENT_LOG_LENGTH; i++)
{
struct event_log_entry *en = event_log + (event_log_pos + i) % EVENT_LOG_LENGTH;
if (en->hook)
log(L_DEBUG " Event 0x%p 0x%p at %8d for %d ms", en->hook, en->data,
(int) ((last_time - en->timestamp) TO_MS), (int) (en->duration TO_MS));
}
}
void
watchdog_sigalrm(int sig UNUSED)
{
/* Update last_time and duration, but skip latency check */
config->latency_limit = 0xffffffff;
io_update_time();
/* We want core dump */
abort();
}
static inline void
watchdog_start1(void)
{
io_update_time();
loop_time = last_time;
}
static inline void
watchdog_start(void)
{
io_update_time();
loop_time = last_time;
event_log_num = 0;
if (config->watchdog_timeout)
{
alarm(config->watchdog_timeout);
watchdog_active = 1;
}
}
static inline void
watchdog_stop(void)
{
io_update_time();
if (watchdog_active)
{
alarm(0);
watchdog_active = 0;
}
btime duration = last_time - loop_time;
if (duration > config->watchdog_warning)
log(L_WARN "I/O loop cycle took %d ms for %d events",
(int) (duration TO_MS), event_log_num);
}
/*
* Main I/O Loop
*/
@ -1873,6 +2054,7 @@ io_loop(void)
sock *s;
node *n;
watchdog_start1();
sock_recalc_fdsets_p = 1;
for(;;)
{
@ -1887,6 +2069,8 @@ io_loop(void)
timo.tv_sec = events ? 0 : MIN(tout - now, 3);
timo.tv_usec = 0;
io_close_event();
if (sock_recalc_fdsets_p)
{
sock_recalc_fdsets_p = 0;
@ -1923,25 +2107,30 @@ io_loop(void)
if (async_config_flag)
{
io_log_event(async_config, NULL);
async_config();
async_config_flag = 0;
continue;
}
if (async_dump_flag)
{
io_log_event(async_dump, NULL);
async_dump();
async_dump_flag = 0;
continue;
}
if (async_shutdown_flag)
{
io_log_event(async_shutdown, NULL);
async_shutdown();
async_shutdown_flag = 0;
continue;
}
/* And finally enter select() to find active sockets */
watchdog_stop();
hi = select(hi+1, &rd, &wr, NULL, &timo);
watchdog_start();
if (hi < 0)
{
@ -1965,6 +2154,7 @@ io_loop(void)
do
{
steps--;
io_log_event(s->rx_hook, s->data);
e = sk_read(s);
if (s != current_sock)
goto next;
@ -1976,6 +2166,7 @@ io_loop(void)
do
{
steps--;
io_log_event(s->tx_hook, s->data);
e = sk_write(s);
if (s != current_sock)
goto next;
@ -2003,6 +2194,7 @@ io_loop(void)
if ((s->type < SK_MAGIC) && FD_ISSET(s->fd, &rd) && s->rx_hook)
{
count++;
io_log_event(s->rx_hook, s->data);
e = sk_read(s);
if (s != current_sock)
goto next2;

4
sysdep/unix/krt.c
View File

@ -1023,7 +1023,7 @@ krt_reload_routes(struct proto *P)
}
static void
krt_feed_done(struct proto *P)
krt_feed_end(struct proto *P)
{
struct krt_proto *p = (struct krt_proto *) P;
@ -1056,7 +1056,7 @@ krt_init(struct proto_config *c)
p->p.rt_notify = krt_rt_notify;
p->p.if_notify = krt_if_notify;
p->p.reload_routes = krt_reload_routes;
p->p.feed_done = krt_feed_done;
p->p.feed_end = krt_feed_end;
p->p.make_tmp_attrs = krt_make_tmp_attrs;
p->p.store_tmp_attrs = krt_store_tmp_attrs;
p->p.rte_same = krt_rte_same;

8
sysdep/unix/main.c
View File

@ -168,6 +168,9 @@ sysdep_preconfig(struct config *c)
{
init_list(&c->logfiles);
c->latency_limit = UNIX_DEFAULT_LATENCY_LIMIT;
c->watchdog_warning = UNIX_DEFAULT_WATCHDOG_WARNING;
#ifdef PATH_IPROUTE_DIR
read_iproute_table(PATH_IPROUTE_DIR "/rt_protos", "ipp_", 256);
read_iproute_table(PATH_IPROUTE_DIR "/rt_realms", "ipr_", 256);
@ -585,6 +588,8 @@ handle_sigterm(int sig UNUSED)
async_shutdown_flag = 1;
}
void watchdog_sigalrm(int sig UNUSED);
static void
signal_init(void)
{
@ -600,6 +605,9 @@ signal_init(void)
sa.sa_handler = handle_sigterm;
sa.sa_flags = SA_RESTART;
sigaction(SIGTERM, &sa, NULL);
sa.sa_handler = watchdog_sigalrm;
sa.sa_flags = 0;
sigaction(SIGALRM, &sa, NULL);
signal(SIGPIPE, SIG_IGN);
}

5
sysdep/unix/unix.h
View File

@ -27,8 +27,10 @@ void cmd_reconfig_confirm(void);
void cmd_reconfig_undo(void);
void cmd_shutdown(void);
#define UNIX_DEFAULT_CONFIGURE_TIMEOUT 300
#define UNIX_DEFAULT_CONFIGURE_TIMEOUT 300
#define UNIX_DEFAULT_LATENCY_LIMIT (1 S_)
#define UNIX_DEFAULT_WATCHDOG_WARNING (5 S_)
/* io.c */
@ -99,6 +101,7 @@ volatile int async_shutdown_flag;
void io_init(void);
void io_loop(void);
void io_log_dump(void);
int sk_open_unix(struct birdsock *s, char *name);
void *tracked_fopen(struct pool *, char *name, char *mode);
void test_old_bird(char *path);