mirrors/bird
mirrors/bird
0
0
Fork 0
mirror of https://gitlab.nic.cz/labs/bird.git synced 2025-01-15 05:21:54 +00:00
Code Releases Activity

wip bmp: compilable version, but mrt test detected some peer problems, bmp not tested

Browse Source
This commit is contained in:
Katerina Kubecova 2024-07-11 14:43:32 +02:00 committed by Maria Matejka
parent 9816b18cc2
commit ad1bc4c379
13 changed files with 165 additions and 101 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
configure.ac
View File

@ -308,7 +308,6 @@ if test "$enable_mpls_kernel" != no ; then
fi
fi
<<<<<<< HEAD
BIRD_CHECK_CLOCK(CLOCK_MONOTONIC)
if test "$bird_cv_clock_CLOCK_MONOTONIC" != yes ; then
AC_MSG_ERROR([Monotonic clock not supported])

2
filter/data.c
View File

@ -654,8 +654,6 @@ mem_hash_mix_f_val(u64 *h, struct f_val *v)
case T_PTR:
case T_ENUM_STATE:
case T_BTIME:
case T_POINTER:
case T_BGP_CONN:
bug("Invalid type %s in f_val hashing", f_type_name(v->type));
}
}

6
lib/route.h
View File

@ -370,7 +370,7 @@ void ea_list_copy(ea_list *dest, ea_list *src, uint size);
#define EA_LITERAL_STORE_PTR(_class, _flags, _ptr) ({ \
btype _type = (_class)->type; \
ASSERT_DIE(!(_type == T_PTR)); \
ASSERT_DIE(_type == T_PTR); \
EA_LITERAL_GENERIC((_class)->id, _type, _flags, .u.v_ptr = _ptr); \
})
@ -469,9 +469,9 @@ extern struct ea_class ea_gen_mpls_label,
/* protocol journal attributes */
extern struct ea_class ea_name, ea_protocol_name, ea_protocol_type, ea_table,
ea_state, ea_old_state, ea_last_modified, ea_info, ea_proto_id,
ea_channel_id, ea_deleted, ea_bgp_conn, ea_rtable, ea_bgp_afi;
ea_channel_id, ea_deleted, ea_bgp_conn, ea_bgp_in_conn, ea_bgp_out_conn, ea_rtable, ea_bgp_afi;
/* bgp protocol journal attributes */
extern struct ea_class ea_bgp_rem_id, ea_bgp_rem_as, ea_bgp_rem_ip;
extern struct ea_class ea_bgp_rem_id, ea_bgp_rem_as, ea_bgp_loc_as, ea_bgp_rem_ip, ea_bgp_peer_type;
/* Source: An old method to devise the route source protocol and kind.
* To be superseded in a near future by something more informative. */

2
lib/type.h
View File

@ -121,8 +121,6 @@ enum btype {
/* protocol */
T_ENUM_STATE = 0xd1,
T_BTIME = 0xd4,
T_POINTER = 0xd8,
T_BGP_CONN = 0xcb,
} PACKED;
typedef enum btype btype;

11
nest/proto.c
View File

@ -2541,7 +2541,7 @@ proto_cmd_show(struct proto *p, union cmd_arg verbose, int cnt)
p->proto->get_status(p, buf);
}
const btime *time = (btime *)ea_get_adata(eal, &ea_last_modified)->data;
tm_format_time(tbuf, &config->tf_proto, *time);
tm_format_time(tbuf, &atomic_load_explicit(&global_runtime, memory_order_acquire)->tf_proto, *time); //todo readlock????
cli_msg(-1002, "%-10s %-10s %-10s %-6s %-12s %s",
name,
@ -2960,14 +2960,14 @@ proto_state_to_eattr(struct proto *p, int old_state, int proto_deleting)
{
struct {
ea_list l;
eattr a[15];
eattr a[9+9];
} eattrs;
eattrs.l = (ea_list) {};
eattrs.a[eattrs.l.count++] = EA_LITERAL_STORE_STRING(&ea_name, 0, p->name);
//eattrs.a[eattrs.l.count++] = EA_LITERAL_STORE_STRING(&ea_protocol_name, 0, p->proto->name); this info is stored in ea_protocol_type
eattrs.a[eattrs.l.count++] = EA_LITERAL_STORE_ADATA(&ea_protocol_type, 0, &p->proto, sizeof(struct protocol *));
eattrs.a[eattrs.l.count++] = EA_LITERAL_STORE_PTR(&ea_protocol_type, 0, p->proto);
if (p->main_channel)
eattrs.a[eattrs.l.count++] = EA_LITERAL_STORE_STRING(&ea_table, 0, p->main_channel->table->name);
eattrs.a[eattrs.l.count++] = EA_LITERAL_EMBEDDED(&ea_state, 0, p->proto_state);
@ -2992,10 +2992,7 @@ channel_state_to_eattr(struct channel *ch, int proto_deleting)
eattrs.a[eattrs.l.count++] = EA_LITERAL_EMBEDDED(&ea_proto_id, 0, ch->proto->id);
eattrs.a[eattrs.l.count++] = EA_LITERAL_EMBEDDED(&ea_deleted, 0, proto_deleting);
if (ch->table)
{
struct rtable_adata rad = (struct rtable_adata){.table = h->table};
eattrs.a[eattrs.l.count++] = EA_LITERAL_STORE_ADATA(&ea_gen_rtable, 0, &rad, sizeof(rtable *));
}
eattrs.a[eattrs.l.count++] = EA_LITERAL_STORE_PTR(&ea_rtable, 0, &ch->table);
if (ch->proto->proto == &proto_bgp && ch != ch->proto->mpls_channel)
{
struct bgp_channel *bc = (struct bgp_channel *) ch;

42
nest/rt-attr.c
View File

@ -171,15 +171,15 @@ struct ea_class ea_gen_hostentry_version = {
static void
ea_gen_rtable_stored(const eattr *ea)
{
struct rtable_adata *had = (struct rtable_adata *) ea->u.ptr;
rt_lock_table(had->table);
rtable *r = (rtable *) ea->u.v_ptr;
rt_lock_table(r);
}
static void
ea_gen_rtable_freed(const eattr *ea)
{
struct rtable_adata *had = (struct rtable_adata *) ea->u.ptr;
rt_unlock_table(had->table);
rtable *r = (rtable *) ea->u.v_ptr;
rt_unlock_table(r);
}
struct ea_class ea_gen_rtable = {
@ -1872,7 +1872,7 @@ struct ea_class ea_protocol_name = {
struct ea_class ea_protocol_type = {
.name = "proto_protocol_type",
.type = T_POINTER,
.type = T_PTR,
};
struct ea_class ea_table = {
@ -1925,6 +1925,11 @@ struct ea_class ea_bgp_rem_as = {
.type = T_INT,
};
struct ea_class ea_bgp_loc_as = {
.name = "proto_bgp_loc_as",
.type = T_INT,
};
struct ea_class ea_bgp_rem_ip = {
.name = "proto_bgp_rem_ip",
.type = T_IP,
@ -1932,7 +1937,17 @@ struct ea_class ea_bgp_rem_ip = {
struct ea_class ea_bgp_conn = {
.name = "proto_bgp_rem_conn",
.type = T_BGP_CONN,
.type = T_PTR,
};
struct ea_class ea_bgp_in_conn = {
.name = "proto_bgp_rem_in_conn",
.type = T_PTR,
};
struct ea_class ea_bgp_out_conn = {
.name = "proto_bgp_rem_out_conn",
.type = T_PTR,
};
struct ea_class ea_bgp_afi = {
@ -1940,6 +1955,16 @@ struct ea_class ea_bgp_afi = {
.type = T_INT,
};
struct ea_class ea_bgp_peer_type = {
.name = "bgp_peer_type",
.type = T_INT,
};
struct ea_class ea_rtable = {
.name = "rtable",
.type = T_PTR,
};
/**
* rta_init - initialize route attribute cache
*
@ -1997,11 +2022,14 @@ rta_init(void)
/* Protocol bgp attributes */
ea_register_init(&ea_bgp_rem_id);
ea_register_init(&ea_bgp_rem_as);
ea_register_init(&ea_bgp_loc_as);
ea_register_init(&ea_bgp_rem_ip);
ea_register_init(&ea_bgp_conn);
ea_register_init(&ea_bgp_in_conn);
ea_register_init(&ea_bgp_out_conn);
ea_register_init(&ea_rtable);
ea_register_init(&ea_bgp_peer_type);
ea_register_init(&ea_bgp_afi);
ea_register_init(&ea_gen_rtable);
}
/*

22
proto/bgp/bgp.c
View File

@ -676,6 +676,9 @@ bgp_conn_enter_established_state(struct bgp_conn *conn)
conn->sk->fast_rx = 0;
p->conn = conn;
ea_list *eal = proto_state_table->attrs[p->p.id];
ea_set_attr(&eal, EA_LITERAL_STORE_PTR(&ea_bgp_conn, 0, p->conn));
proto_journal_state_push(eal, &p->p);
p->last_error_class = 0;
p->last_error_code = 0;
@ -793,7 +796,7 @@ bgp_conn_enter_established_state(struct bgp_conn *conn)
proto_notify_state(&p->p, PS_UP);
#ifdef CONFIG_BMP
bmp_peer_up(p, conn->local_open_msg, conn->local_open_length,
bmp_peer_up(proto_state_table->attrs[p->p.id], conn->local_open_msg, conn->local_open_length,
conn->remote_open_msg, conn->remote_open_length);
#endif
}
@ -2362,6 +2365,9 @@ bgp_reconfigure(struct proto *P, struct proto_config *CF)
/* We should update our copy of configuration ptr as old configuration will be freed */
p->cf = new;
ea_list *eal = proto_state_table->attrs[p->p.id];
ea_set_attr(&eal, EA_LITERAL_EMBEDDED(&ea_bgp_peer_type, 0, p->cf->peer_type));
proto_journal_state_push(eal, &p->p);
/* Check whether existing connections are compatible with required capabilities */
struct bgp_conn *ci = &p->incoming_conn;
@ -2573,16 +2579,14 @@ bgp_state_to_eattr(struct proto *P, ea_list *l, eattr *attributes)
attributes[l->count++] = EA_LITERAL_EMBEDDED(&ea_bgp_rem_id, 0, p->remote_id);
attributes[l->count++] = EA_LITERAL_EMBEDDED(&ea_bgp_rem_as, 0, p->remote_as);
attributes[l->count++] = EA_LITERAL_STORE_ADATA(&ea_bgp_rem_ip, 0, &p->remote_ip, sizeof(ip_addr));
attributes[l->count++] = EA_LITERAL_EMBEDDED(&ea_bgp_peer_type, 0, p->cf->peer_type);
attributes[l->count++] = EA_LITERAL_EMBEDDED(&ea_bgp_loc_as, 0, p->local_as);
attributes[l->count++] = EA_LITERAL_EMBEDDED(&ea_bgp_rem_as, 0, p->remote_as);
if (p->conn)
{
struct journal_bgp_conn conn = {
.state = p->conn->state,
.local_open_msg = p->conn->local_open_msg,
.remote_open_msg = p->conn->remote_open_msg,
.local_open_length = p->conn->local_open_length,
.remote_open_length = p->conn->remote_open_length,
};
attributes[l->count++] = EA_LITERAL_STORE_ADATA(&ea_bgp_conn, 0, &conn, sizeof(struct journal_bgp_conn));
attributes[l->count++] = EA_LITERAL_STORE_PTR(&ea_bgp_conn, 0, &p->conn);
attributes[l->count++] = EA_LITERAL_STORE_PTR(&ea_bgp_in_conn, 0, &p->incoming_conn);
attributes[l->count++] = EA_LITERAL_STORE_PTR(&ea_bgp_out_conn, 0, &p->outgoing_conn);
}
}

20
proto/bgp/bgp.h
View File

@ -290,15 +290,6 @@ struct bgp_stats {
uint fsm_established_transitions;
};
struct journal_bgp_conn {
u8 state;
byte *local_open_msg;
byte *remote_open_msg;
uint local_open_length;
uint remote_open_length;
};
struct bgp_conn {
struct bgp_proto *bgp;
struct birdsock *sk;
@ -328,6 +319,13 @@ struct bgp_conn {
uint hold_time, keepalive_time, send_hold_time; /* Times calculated from my and neighbor's requirements */
};
struct journal_bgp_conn {
struct bgp_conn *conn;
struct bgp_conn outgoing_conn;
struct bgp_conn incoming_conn;
};
struct bgp_listen_request {
node n; /* Node in bgp_socket / pending list */
struct bgp_socket *sock; /* Assigned socket */
@ -690,7 +688,8 @@ static inline struct bgp_proto *bgp_rte_proto(const rte *rte)
SKIP_BACK(struct bgp_proto, p.sources, rte->src->owner) : NULL;
}
byte * bgp_bmp_encode_rte(struct bgp_channel *c, byte *buf, const net_addr *n, const struct rte *new, const struct rte_src *src);
byte * bgp_bmp_encode_rte(ea_list *c, struct bgp_proto *bgp_p, byte *buf, const net_addr *n,
const struct rte *new, const struct rte_src *src);
#define BGP_AIGP_METRIC 1
#define BGP_AIGP_MAX U64(0xffffffffffffffff)
@ -725,6 +724,7 @@ void bgp_log_error(struct bgp_proto *p, u8 class, char *msg, unsigned code, unsi
void bgp_update_next_hop(struct bgp_export_state *s, eattr *a, ea_list **to);
byte *bgp_create_end_mark_(struct bgp_channel *c, byte *buf);
byte *bgp_create_end_mark_ea_(ea_list *c, byte *buf);
/* Packet types */

44
proto/bgp/packets.c
View File

@ -2454,23 +2454,28 @@ bgp_create_mp_unreach(struct bgp_write_state *s, struct bgp_bucket *buck, byte *
#ifdef CONFIG_BMP
static byte *
bgp_create_update_bmp(struct bgp_channel *c, byte *buf, struct bgp_bucket *buck, bool update)
bgp_create_update_bmp(ea_list *channel_ea, struct bgp_proto *bgp_p, byte *buf, struct bgp_bucket *buck, bool update)
{
struct bgp_proto *p = (void *) c->c.proto;
struct bgp_channel *c;
int c_id = ea_get_int(channel_ea, &ea_channel_id, 0);
BGP_WALK_CHANNELS(bgp_p, c)
if (c->c.id == c_id)
break;
byte *end = buf + (BGP_MAX_EXT_MSG_LENGTH - BGP_HEADER_LENGTH);
byte *res = NULL;
/* FIXME: must be a bit shorter */
struct bgp_caps *peer = p->conn->remote_caps;
struct bgp_caps *peer = bgp_p->conn->remote_caps;
const struct bgp_af_caps *rem = bgp_find_af_caps(peer, c->afi);
struct bgp_write_state s = {
.proto = p,
.proto = bgp_p,
.pool = tmp_linpool,
.mp_reach = (c->afi != BGP_AF_IPV4) || rem->ext_next_hop,
.as4_session = 1,
.add_path = c->add_path_rx,
.mpls = c->desc->mpls,
.mpls = c->desc->mpls, //this is problem, but we can have proto. What about find correct channel in proto? TODO
};
if (!update)
@ -2500,7 +2505,7 @@ bgp_bmp_prepare_bgp_hdr(byte *buf, const u16 msg_size, const u8 msg_type)
}
byte *
bgp_bmp_encode_rte(struct bgp_channel *c, byte *buf, const net_addr *n,
bgp_bmp_encode_rte(ea_list *c, struct bgp_proto *bgp_p, byte *buf, const net_addr *n,
const struct rte *new, const struct rte_src *src)
{
// struct bgp_proto *p = (void *) c->c.proto;
@ -2528,7 +2533,7 @@ bgp_bmp_encode_rte(struct bgp_channel *c, byte *buf, const net_addr *n,
//FIXME net_copy(px->net, n);
add_tail(&b->prefixes, &px->buck_node); // why was there _xx ?
byte *end = bgp_create_update_bmp(c, pkt, b, !!new);
byte *end = bgp_create_update_bmp(c, bgp_p, pkt, b, !!new);
if (end)
bgp_bmp_prepare_bgp_hdr(buf, end - buf, PKT_UPDATE);
@ -2636,6 +2641,31 @@ bgp_create_mp_end_mark(struct bgp_channel *c, byte *buf)
return buf+10;
}
static byte *
bgp_create_mp_end_mark_ea(ea_list *c, byte *buf)
{
put_u16(buf+0, 0);
put_u16(buf+2, 6); /* length 4--9 */
/* Empty MP_UNREACH_NLRI atribute */
buf[4] = BAF_OPTIONAL;
buf[5] = BA_MP_UNREACH_NLRI;
buf[6] = 3; /* Length 7--9 */
int afi = ea_get_int(c, &ea_bgp_afi, 0);
put_af3(buf+7, afi);
return buf+10;
}
byte *
bgp_create_end_mark_ea_(ea_list *c, byte *buf)
{
int afi = ea_get_int(c, &ea_bgp_afi, 0);
return (afi == BGP_AF_IPV4) ?
bgp_create_ip_end_mark(NULL, buf):
bgp_create_mp_end_mark_ea(c, buf);
}
byte *
bgp_create_end_mark_(struct bgp_channel *c, byte *buf)
{

96
proto/bmp/bmp.c
View File

@ -219,7 +219,7 @@ static void bmp_sock_err(sock *sk, int err);
static void bmp_close_socket(struct bmp_proto *p);
static void
bmp_send_peer_up_notif_msg(struct bmp_proto *p, const ea_list *bgp,
bmp_send_peer_up_notif_msg(struct bmp_proto *p, ea_list *bgp,
const byte *tx_data, const size_t tx_data_size,
const byte *rx_data, const size_t rx_data_size);
@ -551,7 +551,7 @@ static inline bool bmp_stream_policy(struct bmp_stream *bs)
{ return !!(bs->key & BMP_STREAM_KEY_POLICY); }
static struct bmp_stream *
bmp_find_stream(struct bmp_proto *p, ea_list *bgp_attr, u32 afi, bool policy)
bmp_find_stream(struct bmp_proto *p, struct bgp_proto *bgp_attr, u32 afi, bool policy)
{
return HASH_FIND(p->stream_map, HASH_STREAM, (void*)bgp_attr, bmp_stream_key(afi, policy));
}
@ -649,7 +649,7 @@ bmp_peer_up_(struct bmp_proto *p, ea_list *bgp_attr, bool sync,
if (bp)
return;
const char *name = ea_find(bgp_attr, &ea_name)->u.ad->data;
const char *name = ea_get_adata(bgp_attr, &ea_name)->data;
TRACE(D_STATES, "Peer up for %s", name);
bp = bmp_add_peer(p, bgp_attr);
@ -685,7 +685,7 @@ bmp_peer_up(ea_list *bgp,
static void
bmp_peer_init(struct bmp_proto *p, ea_list *bgp_attr)
{
struct journal_bgp_conn *conn = (struct journal_bgp_conn *) ea_find(bgp_attr, &ea_bgp_conn)->u.ad->data;
const struct bgp_conn *conn = (const struct bgp_conn *) ea_get_ptr(bgp_attr, &ea_bgp_conn, 0);
if (!conn || (conn->state != BS_ESTABLISHED) ||
!conn->local_open_msg || !conn->remote_open_msg)
@ -698,28 +698,31 @@ bmp_peer_init(struct bmp_proto *p, ea_list *bgp_attr)
static const struct birdsock *
bmp_get_birdsock(const struct bgp_proto *bgp)
bmp_get_birdsock(ea_list *bgp)
{
if (bgp->conn && bgp->conn->sk)
return bgp->conn->sk;
struct bgp_conn *conn = (struct bgp_conn *) ea_get_ptr(bgp, &ea_bgp_conn, 0);
if (conn && conn->sk)
return conn->sk;
return NULL;
}
static const struct birdsock *
bmp_get_birdsock_ext(const struct bgp_proto *bgp)
bmp_get_birdsock_ext(ea_list *bgp)
{
const struct birdsock *sk = bmp_get_birdsock(bgp);
if (sk != NULL)
return sk;
if (bgp->incoming_conn.sk)
struct bgp_conn *in_conn = (struct bgp_conn *) ea_get_ptr(bgp, &ea_bgp_in_conn, 0);
struct bgp_conn *out_conn = (struct bgp_conn *) ea_get_ptr(bgp, &ea_bgp_out_conn, 0);
if (in_conn->sk)
{
sk = bgp->incoming_conn.sk;
sk = in_conn->sk;
}
else if (bgp->outgoing_conn.sk)
else if (out_conn->sk)
{
sk = bgp->outgoing_conn.sk;
sk = out_conn->sk;
}
return sk;
@ -754,16 +757,19 @@ bmp_get_bgp_remote_caps_ext(const struct bgp_proto *bgp)
}
static bool
bmp_is_peer_global_instance(const struct bgp_proto *bgp)
bmp_is_peer_global_instance(ea_list *bgp)
{
return (bgp->cf->peer_type != BGP_PT_EXTERNAL &&
bgp->cf->peer_type != BGP_PT_INTERNAL)
? (bgp->local_as != bgp->remote_as)
: (bgp->cf->peer_type == BGP_PT_EXTERNAL);
int peer_type = ea_get_int(bgp, &ea_bgp_peer_type, 0);
int local_as = ea_get_int(bgp, &ea_bgp_loc_as, 0);
int remote_as = ea_get_int(bgp, &ea_bgp_rem_as, 0);
return (peer_type != BGP_PT_EXTERNAL &&
peer_type != BGP_PT_INTERNAL)
? (local_as != remote_as)
: (peer_type == BGP_PT_EXTERNAL);
}
static void
bmp_send_peer_up_notif_msg(struct bmp_proto *p, const struct bgp_proto *bgp,
bmp_send_peer_up_notif_msg(struct bmp_proto *p, ea_list *bgp,
const byte *tx_data, const size_t tx_data_size,
const byte *rx_data, const size_t rx_data_size)
{
@ -775,10 +781,12 @@ bmp_send_peer_up_notif_msg(struct bmp_proto *p, const struct bgp_proto *bgp,
"[BMP] No BGP socket"
);
const int rem_as = ea_get_int(bgp, &ea_bgp_rem_as, 0);
const int rem_id = ea_get_int(bgp, &ea_bgp_rem_id, 0);
const bool is_global_instance_peer = bmp_is_peer_global_instance(bgp);
buffer payload = bmp_buffer_alloc(p->buffer_mpool, DEFAULT_MEM_BLOCK_SIZE);
bmp_peer_up_notif_msg_serialize(&payload, is_global_instance_peer,
bgp->remote_as, bgp->remote_id, 1,
rem_as, rem_id, 1,
sk->saddr, sk->daddr, sk->sport, sk->dport, tx_data, tx_data_size,
rx_data, rx_data_size);
bmp_schedule_tx_packet(p, bmp_buffer_data(&payload), bmp_buffer_pos(&payload));
@ -796,10 +804,10 @@ bmp_route_monitor_put_update(struct bmp_proto *p, struct bmp_stream *bs, const b
add_tail(&p->update_msg_queue, &upd_msg->n);
/* Save some metadata */
struct bgp_proto *bgp = bs->bgp;
upd_msg->remote_as = bgp->remote_as;
upd_msg->remote_id = bgp->remote_id;
upd_msg->remote_ip = bgp->remote_ip;
ea_list *bgp = bs->bgp;
upd_msg->remote_as = ea_get_int(bgp, &ea_bgp_rem_as, 0);
upd_msg->remote_id = ea_get_int(bgp, &ea_bgp_rem_id, 0);
upd_msg->remote_ip = ea_get_ip(bgp, &ea_bgp_rem_ip, IPA_NONE);
upd_msg->timestamp = timestamp;
upd_msg->global_peer = bmp_is_peer_global_instance(bgp);
upd_msg->policy = bmp_stream_policy(bs);
@ -810,11 +818,11 @@ bmp_route_monitor_put_update(struct bmp_proto *p, struct bmp_stream *bs, const b
}
static void
bmp_route_monitor_notify(struct bmp_proto *p, struct bmp_stream *bs,
bmp_route_monitor_notify(struct bmp_proto *p, struct bgp_proto *bgp_p, struct bmp_stream *bs,
const net_addr *n, const struct rte *new, const struct rte_src *src)
{
byte buf[BGP_MAX_EXT_MSG_LENGTH];
byte *end = bgp_bmp_encode_rte(bs->sender, buf, n, new, src);
byte *end = bgp_bmp_encode_rte(bs->sender, bgp_p, buf, n, new, src);
btime delta_t = new ? current_time() - new->lastmod : 0;
btime timestamp = current_real_time() - delta_t;
@ -860,10 +868,10 @@ bmp_route_monitor_commit(void *p_)
static void
bmp_route_monitor_end_of_rib(struct bmp_proto *p, struct bmp_stream *bs)
{
TRACE(D_PACKETS, "Sending END-OF-RIB for %s.%s", bs->bgp->p.name, ea_get_adata(bs->sender, &ea_name)->adata);
TRACE(D_PACKETS, "Sending END-OF-RIB for %s.%s", ea_get_adata(bs->bgp, &ea_name)->data, ea_get_adata(bs->sender, &ea_name)->data);
byte rx_end_payload[DEFAULT_MEM_BLOCK_SIZE];
byte *pos = bgp_create_end_mark_(bs->sender, rx_end_payload + BGP_HEADER_LENGTH);
byte *pos = bgp_create_end_mark_ea_(bs->sender, rx_end_payload + BGP_HEADER_LENGTH);
memset(rx_end_payload + BGP_MSG_HDR_MARKER_POS, 0xff,
BGP_MSG_HDR_MARKER_SIZE); // BGP UPDATE MSG marker
put_u16(rx_end_payload + BGP_MSG_HDR_LENGTH_POS, pos - rx_end_payload);
@ -879,7 +887,7 @@ bmp_send_peer_down_notif_msg(struct bmp_proto *p, const struct bgp_proto *bgp,
ASSERT(p->started);
const struct bgp_caps *remote_caps = bmp_get_bgp_remote_caps_ext(bgp);
bool is_global_instance_peer = bmp_is_peer_global_instance(bgp);
bool is_global_instance_peer = bmp_is_peer_global_instance(proto_state_table->attrs[bgp->p.id]);
buffer payload
= bmp_buffer_alloc(p->buffer_mpool, DEFAULT_MEM_BLOCK_SIZE);
bmp_peer_down_notif_msg_serialize(&payload, is_global_instance_peer,
@ -898,7 +906,7 @@ bmp_peer_down_(struct bmp_proto *p, const struct bgp_proto *bgp,
if (!p->started)
return;
struct bmp_peer *bp = bmp_find_peer(p, bgp);
struct bmp_peer *bp = bmp_find_peer(p, proto_state_table->attrs[bgp->p.id]);
if (!bp)
return;
@ -1004,7 +1012,7 @@ bmp_preexport(struct channel *C UNUSED, rte *e)
static void
bmp_rt_notify(struct proto *P, struct channel *c, const net_addr *net,
struct rte *new, struct rte *old)
struct rte *new, const struct rte *old)
{
struct bmp_proto *p = (void *) P;
@ -1023,7 +1031,7 @@ bmp_rt_notify(struct proto *P, struct channel *c, const net_addr *net,
if (!bs)
return;
bmp_route_monitor_notify(p, bs, net, new, (new ?: old)->src);
bmp_route_monitor_notify(p, bgp, bs, net, new, (new ?: old)->src);
}
static void
@ -1080,16 +1088,16 @@ bmp_startup(struct bmp_proto *p)
bmp_buffer_free(&payload);
/* Send Peer Up messages */
for (int i = 0; i < bgp_attributes->length; i++)
for (u32 i = 0; i < proto_state_table->length; i++)
{
ea_list *bgp_attr = bgp_attributes->attrs[i];
if (bgp_attr == NULL)
ea_list *proto_attr = proto_state_table->attrs[i];
if (proto_attr == NULL)
continue;
struct protocol *proto = (struct protocol *) ea_find(bgp_attr, &ea_protocol_type)->u.ad->data;
const int state = ea_find(bgp_attr, &ea_state)->u.i;
struct protocol *proto = (struct protocol *) ea_get_ptr(proto_attr, &ea_protocol_type, 0);
const int state = ea_get_int(proto_attr, &ea_state, 0);
if (proto != &proto_bgp || state != PS_UP)
continue;
bmp_peer_init(p, bgp_attr);
bmp_peer_init(p, proto_attr);
}
/*struct proto *peer;
WALK_LIST(peer, proto_list)
@ -1151,7 +1159,7 @@ bmp_connect(struct bmp_proto *p)
TRACE(D_EVENTS, "Connecting to %I port %u", sk->daddr, sk->dport);
int rc = sk_open(sk);
int rc = sk_open(sk, p->p.loop);
if (rc < 0)
sk_log_error(sk, p->p.name);
@ -1243,7 +1251,7 @@ bmp_init(struct proto_config *CF)
P->rt_notify = bmp_rt_notify;
P->preexport = bmp_preexport;
P->feed_end = bmp_feed_end;
//P->feed_end = bmp_feed_end; I am confused. It looks like feed_end and bmp_feed_end exist only here
p->cf = cf;
p->local_addr = cf->local_addr;
@ -1266,10 +1274,10 @@ bmp_start(struct proto *P)
{
struct bmp_proto *p = (void *) P;
p->buffer_mpool = rp_new(P->pool, "BMP Buffer");
p->map_mem_pool = rp_new(P->pool, "BMP Map");
p->tx_mem_pool = rp_new(P->pool, "BMP Tx");
p->update_msg_mem_pool = rp_new(P->pool, "BMP Update");
p->buffer_mpool = rp_new(P->pool, proto_domain(&p->p), "BMP Buffer");
p->map_mem_pool = rp_new(P->pool, proto_domain(&p->p), "BMP Map");
p->tx_mem_pool = rp_new(P->pool, proto_domain(&p->p), "BMP Tx");
p->update_msg_mem_pool = rp_new(P->pool, proto_domain(&p->p), "BMP Update");
p->tx_ev = ev_new_init(p->p.pool, bmp_fire_tx, p);
p->update_ev = ev_new_init(p->p.pool, bmp_route_monitor_commit, p);
p->connect_retry_timer = tm_new_init(p->p.pool, bmp_connection_retry, p, 0, 0);
@ -1371,7 +1379,7 @@ bmp_show_proto_info(struct proto *P)
struct protocol proto_bmp = {
.name = "BMP",
.template = "bmp%d",
.class = PROTOCOL_BMP,
//.class = PROTOCOL_BMP, looks like there are no classes for protocols anymore
.proto_size = sizeof(struct bmp_proto),
.config_size = sizeof(struct bmp_config),
.postconfig = bmp_postconfig,

2
proto/bmp/bmp.h
View File

@ -106,7 +106,7 @@ struct bmp_table {
* bmp_peer_up - send notification that BGP peer connection is established
*/
void
bmp_peer_up(struct bgp_proto *bgp,
bmp_peer_up(struct ea_list *bgp,
const byte *tx_open_msg, uint tx_open_length,
const byte *rx_open_msg, uint rx_open_length);

16
proto/mrt/mrt.c
View File

@ -52,6 +52,7 @@
#include "proto/bgp/bgp.h"
#include "sysdep/unix/unix.h"
#include "sysdep/unix/io-loop.h"
#include "conf/conf.h"
#ifdef PATH_MAX
@ -376,7 +377,7 @@ static void
mrt_peer_table_dump(struct mrt_table_dump_state *s)
{
mrt_init_message(&s->buf, MRT_TABLE_DUMP_V2, MRT_PEER_INDEX_TABLE);
mrt_peer_table_header(s, config->router_id, get_tab(s)->name);
mrt_peer_table_header(s, OBSREF_GET(config)->router_id, get_tab(s)->name);
/* 0 is fake peer for non-BGP routes */
mrt_peer_table_entry(s, 0, 0, IPA_NONE);
@ -394,7 +395,7 @@ mrt_peer_table_dump(struct mrt_table_dump_state *s)
continue;
}
rcu_read_unlock();
struct protocol **type = (struct protocol **)ea_get_adata(eal, &ea_protocol_type)->data;
struct protocol **type = (struct protocol **)ea_get_ptr(eal, &ea_protocol_type, 0);
int state = ea_get_int(eal, &ea_state, 0);
if ((*type == &proto_bgp) && (state != PS_DOWN))
{
@ -408,6 +409,7 @@ mrt_peer_table_dump(struct mrt_table_dump_state *s)
/* Fix Peer Count */
put_u16(s->buf.start + s->peer_count_offset, s->peer_count);
log("peer count %i", s->peer_count);
mrt_dump_message(&s->buf, s->fd);
}
@ -603,8 +605,8 @@ mrt_table_dump_init(pool *pp)
mrt_buffer_init(&s->buf, pool, 2 * MRT_ATTR_BUFFER_SIZE);
/* We lock the current config as we may reference it indirectly by filter */
s->config = config;
config_add_obstacle(s->config);
OBSREF_SET(s->config, OBSREF_GET(config));
s->fd = -1;
@ -614,7 +616,7 @@ mrt_table_dump_init(pool *pp)
static void
mrt_table_dump_free(struct mrt_table_dump_state *s)
{
config_del_obstacle(s->config);
OBSREF_CLEAR(s->config);
rp_free(s->pool);
}
@ -841,7 +843,7 @@ mrt_dump_bgp_message(struct mrt_bgp_data *d)
mrt_init_message(b, MRT_BGP4MP, subtypes[d->as4 + 4*d->add_path]);
mrt_bgp_header(b, d);
mrt_put_data(b, d->message, d->msg_len);
mrt_dump_message(b, rf_fileno(config->mrtdump_file));
mrt_dump_message(b, rf_fileno(OBSREF_GET(config)->mrtdump_file));
}
void
@ -861,7 +863,7 @@ mrt_dump_bgp_state_change(struct mrt_bgp_data *d)
mrt_bgp_header(b, d);
mrt_put_u16(b, states[d->old_state]);
mrt_put_u16(b, states[d->new_state]);
mrt_dump_message(b, rf_fileno(config->mrtdump_file));
mrt_dump_message(b, rf_fileno(OBSREF_GET(config)->mrtdump_file));
}

2
proto/mrt/mrt.h
View File

@ -55,7 +55,7 @@ struct mrt_peer_entry {
struct mrt_table_dump_state {
struct mrt_proto *proto; /* Protocol for regular MRT dumps (or NULL) */
struct cli *cli; /* CLI for irregular MRT dumps (or NULL) */
struct config *config; /* Config valid during start of dump, locked */
config_ref config; /* Config valid during start of dump, locked */
/* Configuration information */
const char *table_expr; /* Wildcard for table name (or NULL) */