mirrors/bird
mirrors/bird
0
0
Fork 0
mirror of https://gitlab.nic.cz/labs/bird.git synced 2024-09-16 18:35:19 +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
parent 5aa7c6b981
commit 034647bb05
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
fi fi
<<<<<<< HEAD
BIRD_CHECK_CLOCK(CLOCK_MONOTONIC) BIRD_CHECK_CLOCK(CLOCK_MONOTONIC)
if test "$bird_cv_clock_CLOCK_MONOTONIC" != yes ; then if test "$bird_cv_clock_CLOCK_MONOTONIC" != yes ; then
AC_MSG_ERROR([Monotonic clock not supported]) 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_PTR:
case T_ENUM_STATE: case T_ENUM_STATE:
case T_BTIME: case T_BTIME:
case T_POINTER:
case T_BGP_CONN:
bug("Invalid type %s in f_val hashing", f_type_name(v->type)); 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) ({ \ #define EA_LITERAL_STORE_PTR(_class, _flags, _ptr) ({ \
btype _type = (_class)->type; \ 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); \ 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 */ /* protocol journal attributes */
extern struct ea_class ea_name, ea_protocol_name, ea_protocol_type, ea_table, 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_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 */ /* 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. /* Source: An old method to devise the route source protocol and kind.
* To be superseded in a near future by something more informative. */ * To be superseded in a near future by something more informative. */

2
lib/type.h
View File

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

11
nest/proto.c
View File

@ -2503,7 +2503,7 @@ proto_cmd_show(struct proto *p, union cmd_arg verbose, int cnt)
p->proto->get_status(p, buf); p->proto->get_status(p, buf);
} }
const btime *time = (btime *)ea_get_adata(eal, &ea_last_modified)->data; 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", cli_msg(-1002, "%-10s %-10s %-10s %-6s %-12s %s",
name, name,
@ -2922,14 +2922,14 @@ proto_state_to_eattr(struct proto *p, int old_state, int proto_deleting)
{ {
struct { struct {
ea_list l; ea_list l;
eattr a[15]; eattr a[9+9];
} eattrs; } eattrs;
eattrs.l = (ea_list) {}; 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_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_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) 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_STORE_STRING(&ea_table, 0, p->main_channel->table->name);
eattrs.a[eattrs.l.count++] = EA_LITERAL_EMBEDDED(&ea_state, 0, p->proto_state); eattrs.a[eattrs.l.count++] = EA_LITERAL_EMBEDDED(&ea_state, 0, p->proto_state);
@ -2954,10 +2954,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_proto_id, 0, ch->proto->id);
eattrs.a[eattrs.l.count++] = EA_LITERAL_EMBEDDED(&ea_deleted, 0, proto_deleting); eattrs.a[eattrs.l.count++] = EA_LITERAL_EMBEDDED(&ea_deleted, 0, proto_deleting);
if (ch->table) if (ch->table)
{ eattrs.a[eattrs.l.count++] = EA_LITERAL_STORE_PTR(&ea_rtable, 0, &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 *));
}
if (ch->proto->proto == &proto_bgp && ch != ch->proto->mpls_channel) if (ch->proto->proto == &proto_bgp && ch != ch->proto->mpls_channel)
{ {
struct bgp_channel *bc = (struct bgp_channel *) ch; 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 static void
ea_gen_rtable_stored(const eattr *ea) ea_gen_rtable_stored(const eattr *ea)
{ {
struct rtable_adata *had = (struct rtable_adata *) ea->u.ptr; rtable *r = (rtable *) ea->u.v_ptr;
rt_lock_table(had->table); rt_lock_table(r);
} }
static void static void
ea_gen_rtable_freed(const eattr *ea) ea_gen_rtable_freed(const eattr *ea)
{ {
struct rtable_adata *had = (struct rtable_adata *) ea->u.ptr; rtable *r = (rtable *) ea->u.v_ptr;
rt_unlock_table(had->table); rt_unlock_table(r);
} }
struct ea_class ea_gen_rtable = { struct ea_class ea_gen_rtable = {
@ -1859,7 +1859,7 @@ struct ea_class ea_protocol_name = {
struct ea_class ea_protocol_type = { struct ea_class ea_protocol_type = {
.name = "proto_protocol_type", .name = "proto_protocol_type",
.type = T_POINTER, .type = T_PTR,
}; };
struct ea_class ea_table = { struct ea_class ea_table = {
@ -1912,6 +1912,11 @@ struct ea_class ea_bgp_rem_as = {
.type = T_INT, .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 = { struct ea_class ea_bgp_rem_ip = {
.name = "proto_bgp_rem_ip", .name = "proto_bgp_rem_ip",
.type = T_IP, .type = T_IP,
@ -1919,7 +1924,17 @@ struct ea_class ea_bgp_rem_ip = {
struct ea_class ea_bgp_conn = { struct ea_class ea_bgp_conn = {
.name = "proto_bgp_rem_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 = { struct ea_class ea_bgp_afi = {
@ -1927,6 +1942,16 @@ struct ea_class ea_bgp_afi = {
.type = T_INT, .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 * rta_init - initialize route attribute cache
* *
@ -1984,11 +2009,14 @@ rta_init(void)
/* Protocol bgp attributes */ /* Protocol bgp attributes */
ea_register_init(&ea_bgp_rem_id); ea_register_init(&ea_bgp_rem_id);
ea_register_init(&ea_bgp_rem_as); 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_rem_ip);
ea_register_init(&ea_bgp_conn); 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_rtable);
ea_register_init(&ea_bgp_peer_type);
ea_register_init(&ea_bgp_afi); ea_register_init(&ea_bgp_afi);
ea_register_init(&ea_gen_rtable);
} }
/* /*

22
proto/bgp/bgp.c
View File

@ -678,6 +678,9 @@ bgp_conn_enter_established_state(struct bgp_conn *conn)
conn->sk->fast_rx = 0; conn->sk->fast_rx = 0;
p->conn = conn; 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_class = 0;
p->last_error_code = 0; p->last_error_code = 0;
@ -795,7 +798,7 @@ bgp_conn_enter_established_state(struct bgp_conn *conn)
proto_notify_state(&p->p, PS_UP); proto_notify_state(&p->p, PS_UP);
#ifdef CONFIG_BMP #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); conn->remote_open_msg, conn->remote_open_length);
#endif #endif
} }
@ -2370,6 +2373,9 @@ bgp_reconfigure(struct proto *P, struct proto_config *CF)
/* We should update our copy of configuration ptr as old configuration will be freed */ /* We should update our copy of configuration ptr as old configuration will be freed */
p->cf = new; 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 */ /* Check whether existing connections are compatible with required capabilities */
struct bgp_conn *ci = &p->incoming_conn; struct bgp_conn *ci = &p->incoming_conn;
@ -2581,16 +2587,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_id, 0, p->remote_id);
attributes[l->count++] = EA_LITERAL_EMBEDDED(&ea_bgp_rem_as, 0, p->remote_as); 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_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) if (p->conn)
{ {
struct journal_bgp_conn conn = { attributes[l->count++] = EA_LITERAL_STORE_PTR(&ea_bgp_conn, 0, &p->conn);
.state = p->conn->state, attributes[l->count++] = EA_LITERAL_STORE_PTR(&ea_bgp_in_conn, 0, &p->incoming_conn);
.local_open_msg = p->conn->local_open_msg, attributes[l->count++] = EA_LITERAL_STORE_PTR(&ea_bgp_out_conn, 0, &p->outgoing_conn);
.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));
} }
} }

20
proto/bgp/bgp.h
View File

@ -290,15 +290,6 @@ struct bgp_stats {
uint fsm_established_transitions; 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_conn {
struct bgp_proto *bgp; struct bgp_proto *bgp;
struct birdsock *sk; struct birdsock *sk;
@ -329,6 +320,13 @@ struct bgp_conn {
uint hold_time, keepalive_time, send_hold_time; /* Times calculated from my and neighbor's requirements */ 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 { struct bgp_listen_request {
node n; /* Node in bgp_socket / pending list */ node n; /* Node in bgp_socket / pending list */
struct bgp_socket *sock; /* Assigned socket */ 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; 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_METRIC 1
#define BGP_AIGP_MAX U64(0xffffffffffffffff) #define BGP_AIGP_MAX U64(0xffffffffffffffff)
@ -726,6 +725,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); 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_(struct bgp_channel *c, byte *buf);
byte *bgp_create_end_mark_ea_(ea_list *c, byte *buf);
/* Packet types */ /* Packet types */

44
proto/bgp/packets.c
View File

@ -2451,23 +2451,28 @@ bgp_create_mp_unreach(struct bgp_write_state *s, struct bgp_bucket *buck, byte *
#ifdef CONFIG_BMP #ifdef CONFIG_BMP
static byte * 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 *end = buf + (BGP_MAX_EXT_MSG_LENGTH - BGP_HEADER_LENGTH);
byte *res = NULL; byte *res = NULL;
/* FIXME: must be a bit shorter */ /* 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); const struct bgp_af_caps *rem = bgp_find_af_caps(peer, c->afi);
struct bgp_write_state s = { struct bgp_write_state s = {
.proto = p, .proto = bgp_p,
.pool = tmp_linpool, .pool = tmp_linpool,
.mp_reach = (c->afi != BGP_AF_IPV4) || rem->ext_next_hop, .mp_reach = (c->afi != BGP_AF_IPV4) || rem->ext_next_hop,
.as4_session = 1, .as4_session = 1,
.add_path = c->add_path_rx, .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) if (!update)
@ -2497,7 +2502,7 @@ bgp_bmp_prepare_bgp_hdr(byte *buf, const u16 msg_size, const u8 msg_type)
} }
byte * 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) const struct rte *new, const struct rte_src *src)
{ {
// struct bgp_proto *p = (void *) c->c.proto; // struct bgp_proto *p = (void *) c->c.proto;
@ -2525,7 +2530,7 @@ bgp_bmp_encode_rte(struct bgp_channel *c, byte *buf, const net_addr *n,
//FIXME net_copy(px->net, n); //FIXME net_copy(px->net, n);
add_tail(&b->prefixes, &px->buck_node); // why was there _xx ? 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) if (end)
bgp_bmp_prepare_bgp_hdr(buf, end - buf, PKT_UPDATE); bgp_bmp_prepare_bgp_hdr(buf, end - buf, PKT_UPDATE);
@ -2633,6 +2638,31 @@ bgp_create_mp_end_mark(struct bgp_channel *c, byte *buf)
return buf+10; 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 * byte *
bgp_create_end_mark_(struct bgp_channel *c, byte *buf) 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_close_socket(struct bmp_proto *p);
static void 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 *tx_data, const size_t tx_data_size,
const byte *rx_data, const size_t rx_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); } { return !!(bs->key & BMP_STREAM_KEY_POLICY); }
static struct bmp_stream * 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)); 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) if (bp)
return; 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); TRACE(D_STATES, "Peer up for %s", name);
bp = bmp_add_peer(p, bgp_attr); bp = bmp_add_peer(p, bgp_attr);
@ -685,7 +685,7 @@ bmp_peer_up(ea_list *bgp,
static void static void
bmp_peer_init(struct bmp_proto *p, ea_list *bgp_attr) 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) || if (!conn || (conn->state != BS_ESTABLISHED) ||
!conn->local_open_msg || !conn->remote_open_msg) !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 * static const struct birdsock *
bmp_get_birdsock(const struct bgp_proto *bgp) bmp_get_birdsock(ea_list *bgp)
{ {
if (bgp->conn && bgp->conn->sk) struct bgp_conn *conn = (struct bgp_conn *) ea_get_ptr(bgp, &ea_bgp_conn, 0);
return bgp->conn->sk; if (conn && conn->sk)
return conn->sk;
return NULL; return NULL;
} }
static const struct birdsock * 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); const struct birdsock *sk = bmp_get_birdsock(bgp);
if (sk != NULL) if (sk != NULL)
return sk; 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; return sk;
@ -754,16 +757,19 @@ bmp_get_bgp_remote_caps_ext(const struct bgp_proto *bgp)
} }
static bool 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 && int peer_type = ea_get_int(bgp, &ea_bgp_peer_type, 0);
bgp->cf->peer_type != BGP_PT_INTERNAL) int local_as = ea_get_int(bgp, &ea_bgp_loc_as, 0);
? (bgp->local_as != bgp->remote_as) int remote_as = ea_get_int(bgp, &ea_bgp_rem_as, 0);
: (bgp->cf->peer_type == BGP_PT_EXTERNAL); return (peer_type != BGP_PT_EXTERNAL &&
peer_type != BGP_PT_INTERNAL)
? (local_as != remote_as)
: (peer_type == BGP_PT_EXTERNAL);
} }
static void 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 *tx_data, const size_t tx_data_size,
const byte *rx_data, const size_t rx_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" "[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); const bool is_global_instance_peer = bmp_is_peer_global_instance(bgp);
buffer payload = bmp_buffer_alloc(p->buffer_mpool, DEFAULT_MEM_BLOCK_SIZE); buffer payload = bmp_buffer_alloc(p->buffer_mpool, DEFAULT_MEM_BLOCK_SIZE);
bmp_peer_up_notif_msg_serialize(&payload, is_global_instance_peer, 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, sk->saddr, sk->daddr, sk->sport, sk->dport, tx_data, tx_data_size,
rx_data, rx_data_size); rx_data, rx_data_size);
bmp_schedule_tx_packet(p, bmp_buffer_data(&payload), bmp_buffer_pos(&payload)); 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); add_tail(&p->update_msg_queue, &upd_msg->n);
/* Save some metadata */ /* Save some metadata */
struct bgp_proto *bgp = bs->bgp; ea_list *bgp = bs->bgp;
upd_msg->remote_as = bgp->remote_as; upd_msg->remote_as = ea_get_int(bgp, &ea_bgp_rem_as, 0);
upd_msg->remote_id = bgp->remote_id; upd_msg->remote_id = ea_get_int(bgp, &ea_bgp_rem_id, 0);
upd_msg->remote_ip = bgp->remote_ip; upd_msg->remote_ip = ea_get_ip(bgp, &ea_bgp_rem_ip, IPA_NONE);
upd_msg->timestamp = timestamp; upd_msg->timestamp = timestamp;
upd_msg->global_peer = bmp_is_peer_global_instance(bgp); upd_msg->global_peer = bmp_is_peer_global_instance(bgp);
upd_msg->policy = bmp_stream_policy(bs); 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 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) const net_addr *n, const struct rte *new, const struct rte_src *src)
{ {
byte buf[BGP_MAX_EXT_MSG_LENGTH]; 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 delta_t = new ? current_time() - new->lastmod : 0;
btime timestamp = current_real_time() - delta_t; btime timestamp = current_real_time() - delta_t;
@ -860,10 +868,10 @@ bmp_route_monitor_commit(void *p_)
static void static void
bmp_route_monitor_end_of_rib(struct bmp_proto *p, struct bmp_stream *bs) 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 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, memset(rx_end_payload + BGP_MSG_HDR_MARKER_POS, 0xff,
BGP_MSG_HDR_MARKER_SIZE); // BGP UPDATE MSG marker BGP_MSG_HDR_MARKER_SIZE); // BGP UPDATE MSG marker
put_u16(rx_end_payload + BGP_MSG_HDR_LENGTH_POS, pos - rx_end_payload); 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); ASSERT(p->started);
const struct bgp_caps *remote_caps = bmp_get_bgp_remote_caps_ext(bgp); 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 buffer payload
= bmp_buffer_alloc(p->buffer_mpool, DEFAULT_MEM_BLOCK_SIZE); = bmp_buffer_alloc(p->buffer_mpool, DEFAULT_MEM_BLOCK_SIZE);
bmp_peer_down_notif_msg_serialize(&payload, is_global_instance_peer, 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) if (!p->started)
return; 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) if (!bp)
return; return;
@ -1004,7 +1012,7 @@ bmp_preexport(struct channel *C UNUSED, rte *e)
static void static void
bmp_rt_notify(struct proto *P, struct channel *c, const net_addr *net, 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; 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) if (!bs)
return; 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 static void
@ -1080,16 +1088,16 @@ bmp_startup(struct bmp_proto *p)
bmp_buffer_free(&payload); bmp_buffer_free(&payload);
/* Send Peer Up messages */ /* 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]; ea_list *proto_attr = proto_state_table->attrs[i];
if (bgp_attr == NULL) if (proto_attr == NULL)
continue; continue;
struct protocol *proto = (struct protocol *) ea_find(bgp_attr, &ea_protocol_type)->u.ad->data; struct protocol *proto = (struct protocol *) ea_get_ptr(proto_attr, &ea_protocol_type, 0);
const int state = ea_find(bgp_attr, &ea_state)->u.i; const int state = ea_get_int(proto_attr, &ea_state, 0);
if (proto != &proto_bgp || state != PS_UP) if (proto != &proto_bgp || state != PS_UP)
continue; continue;
bmp_peer_init(p, bgp_attr); bmp_peer_init(p, proto_attr);
} }
/*struct proto *peer; /*struct proto *peer;
WALK_LIST(peer, proto_list) 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); 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) if (rc < 0)
sk_log_error(sk, p->p.name); sk_log_error(sk, p->p.name);
@ -1243,7 +1251,7 @@ bmp_init(struct proto_config *CF)
P->rt_notify = bmp_rt_notify; P->rt_notify = bmp_rt_notify;
P->preexport = bmp_preexport; 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->cf = cf;
p->local_addr = cf->local_addr; p->local_addr = cf->local_addr;
@ -1266,10 +1274,10 @@ bmp_start(struct proto *P)
{ {
struct bmp_proto *p = (void *) P; struct bmp_proto *p = (void *) P;
p->buffer_mpool = rp_new(P->pool, "BMP Buffer"); p->buffer_mpool = rp_new(P->pool, proto_domain(&p->p), "BMP Buffer");
p->map_mem_pool = rp_new(P->pool, "BMP Map"); p->map_mem_pool = rp_new(P->pool, proto_domain(&p->p), "BMP Map");
p->tx_mem_pool = rp_new(P->pool, "BMP Tx"); p->tx_mem_pool = rp_new(P->pool, proto_domain(&p->p), "BMP Tx");
p->update_msg_mem_pool = rp_new(P->pool, "BMP Update"); 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->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->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); 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 = { struct protocol proto_bmp = {
.name = "BMP", .name = "BMP",
.template = "bmp%d", .template = "bmp%d",
.class = PROTOCOL_BMP, //.class = PROTOCOL_BMP, looks like there are no classes for protocols anymore
.proto_size = sizeof(struct bmp_proto), .proto_size = sizeof(struct bmp_proto),
.config_size = sizeof(struct bmp_config), .config_size = sizeof(struct bmp_config),
.postconfig = bmp_postconfig, .postconfig = bmp_postconfig,

2
proto/bmp/bmp.h
View File

@ -108,7 +108,7 @@ struct bmp_table {
* bmp_peer_up - send notification that BGP peer connection is established * bmp_peer_up - send notification that BGP peer connection is established
*/ */
void 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 *tx_open_msg, uint tx_open_length,
const byte *rx_open_msg, uint rx_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 "proto/bgp/bgp.h"
#include "sysdep/unix/unix.h" #include "sysdep/unix/unix.h"
#include "sysdep/unix/io-loop.h" #include "sysdep/unix/io-loop.h"
#include "conf/conf.h"
#ifdef PATH_MAX #ifdef PATH_MAX
@ -376,7 +377,7 @@ static void
mrt_peer_table_dump(struct mrt_table_dump_state *s) mrt_peer_table_dump(struct mrt_table_dump_state *s)
{ {
mrt_init_message(&s->buf, MRT_TABLE_DUMP_V2, MRT_PEER_INDEX_TABLE); 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 */ /* 0 is fake peer for non-BGP routes */
mrt_peer_table_entry(s, 0, 0, IPA_NONE); mrt_peer_table_entry(s, 0, 0, IPA_NONE);
@ -394,7 +395,7 @@ mrt_peer_table_dump(struct mrt_table_dump_state *s)
continue; continue;
} }
rcu_read_unlock(); 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); int state = ea_get_int(eal, &ea_state, 0);
if ((*type == &proto_bgp) && (state != PS_DOWN)) if ((*type == &proto_bgp) && (state != PS_DOWN))
{ {
@ -408,6 +409,7 @@ mrt_peer_table_dump(struct mrt_table_dump_state *s)
/* Fix Peer Count */ /* Fix Peer Count */
put_u16(s->buf.start + s->peer_count_offset, s->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); 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); mrt_buffer_init(&s->buf, pool, 2 * MRT_ATTR_BUFFER_SIZE);
/* We lock the current config as we may reference it indirectly by filter */ /* 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; s->fd = -1;
@ -614,7 +616,7 @@ mrt_table_dump_init(pool *pp)
static void static void
mrt_table_dump_free(struct mrt_table_dump_state *s) mrt_table_dump_free(struct mrt_table_dump_state *s)
{ {
config_del_obstacle(s->config); OBSREF_CLEAR(s->config);
rp_free(s->pool); 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_init_message(b, MRT_BGP4MP, subtypes[d->as4 + 4*d->add_path]);
mrt_bgp_header(b, d); mrt_bgp_header(b, d);
mrt_put_data(b, d->message, d->msg_len); 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 void
@ -861,7 +863,7 @@ mrt_dump_bgp_state_change(struct mrt_bgp_data *d)
mrt_bgp_header(b, d); mrt_bgp_header(b, d);
mrt_put_u16(b, states[d->old_state]); mrt_put_u16(b, states[d->old_state]);
mrt_put_u16(b, states[d->new_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_table_dump_state {
struct mrt_proto *proto; /* Protocol for regular MRT dumps (or NULL) */ struct mrt_proto *proto; /* Protocol for regular MRT dumps (or NULL) */
struct cli *cli; /* CLI for irregular 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 */ /* Configuration information */
const char *table_expr; /* Wildcard for table name (or NULL) */ const char *table_expr; /* Wildcard for table name (or NULL) */