From a848dad40aa618e5e24417e4ef46b62c860de679 Mon Sep 17 00:00:00 2001 From: Pawel Maslanka Date: Mon, 29 Mar 2021 22:45:21 +0200 Subject: [PATCH] BMP protocol support Initial implementation of a basic subset of the BMP (BGP Monitoring Protocol, RFC 7854) from Akamai team. Submitted for further review and improvement. --- configure.ac | 3 +- nest/protocol.h | 5 +- nest/rt-table.c | 11 + proto/Doc | 1 + proto/bgp/attrs.c | 7 + proto/bgp/bgp.c | 11 + proto/bgp/bgp.h | 14 + proto/bgp/packets.c | 352 +++++++++++- proto/bmp/Doc | 1 + proto/bmp/LICENSE | 2 + proto/bmp/Makefile | 6 + proto/bmp/README.txt | 6 + proto/bmp/bmp.c | 1279 ++++++++++++++++++++++++++++++++++++++++++ proto/bmp/bmp.h | 152 +++++ proto/bmp/buffer.c | 58 ++ proto/bmp/buffer.h | 78 +++ proto/bmp/config.Y | 90 +++ proto/bmp/map.c | 155 +++++ proto/bmp/map.h | 70 +++ proto/bmp/utils.h | 94 ++++ 20 files changed, 2391 insertions(+), 4 deletions(-) create mode 100644 proto/bmp/Doc create mode 100644 proto/bmp/LICENSE create mode 100644 proto/bmp/Makefile create mode 100644 proto/bmp/README.txt create mode 100644 proto/bmp/bmp.c create mode 100644 proto/bmp/bmp.h create mode 100644 proto/bmp/buffer.c create mode 100644 proto/bmp/buffer.h create mode 100644 proto/bmp/config.Y create mode 100644 proto/bmp/map.c create mode 100644 proto/bmp/map.h create mode 100644 proto/bmp/utils.h diff --git a/configure.ac b/configure.ac index d73eec28..f2091219 100644 --- a/configure.ac +++ b/configure.ac @@ -312,7 +312,7 @@ if test "$enable_mpls_kernel" != no ; then fi fi -all_protocols="$proto_bfd babel bgp mrt ospf perf pipe radv rip rpki static" +all_protocols="$proto_bfd babel bgp bmp mrt ospf perf pipe radv rip rpki static" all_protocols=`echo $all_protocols | sed 's/ /,/g'` @@ -323,6 +323,7 @@ fi AH_TEMPLATE([CONFIG_BABEL], [Babel protocol]) AH_TEMPLATE([CONFIG_BFD], [BFD protocol]) AH_TEMPLATE([CONFIG_BGP], [BGP protocol]) +AH_TEMPLATE([CONFIG_BMP], [BMP protocol]) AH_TEMPLATE([CONFIG_MRT], [MRT protocol]) AH_TEMPLATE([CONFIG_OSPF], [OSPF protocol]) AH_TEMPLATE([CONFIG_PIPE], [Pipe protocol]) diff --git a/nest/protocol.h b/nest/protocol.h index fcbf0539..03b8a8ec 100644 --- a/nest/protocol.h +++ b/nest/protocol.h @@ -42,6 +42,7 @@ enum protocol_class { PROTOCOL_BABEL, PROTOCOL_BFD, PROTOCOL_BGP, + PROTOCOL_BMP, PROTOCOL_DEVICE, PROTOCOL_DIRECT, PROTOCOL_KERNEL, @@ -103,7 +104,7 @@ void protos_dump_all(void); extern struct protocol proto_device, proto_radv, proto_rip, proto_static, proto_mrt, proto_ospf, proto_perf, - proto_pipe, proto_bgp, proto_bfd, proto_babel, proto_rpki; + proto_pipe, proto_bgp, proto_bmp, proto_bfd, proto_babel, proto_rpki; /* * Routing Protocol Instance @@ -213,6 +214,8 @@ struct proto { void (*if_notify)(struct proto *, unsigned flags, struct iface *i); void (*ifa_notify)(struct proto *, unsigned flags, struct ifa *a); void (*rt_notify)(struct proto *, struct channel *, struct network *net, struct rte *new, struct rte *old); + void (*rte_update_in_notify)(const struct proto *, const struct channel *, + const net *net, const struct rte *new, const struct rte *old, const struct rte_src *src); void (*neigh_notify)(struct neighbor *neigh); int (*preexport)(struct channel *, struct rte *rt); void (*reload_routes)(struct channel *); diff --git a/nest/rt-table.c b/nest/rt-table.c index e4b27814..553e8223 100644 --- a/nest/rt-table.c +++ b/nest/rt-table.c @@ -3095,6 +3095,10 @@ rte_update_in(struct channel *c, const net_addr *n, rte *new, struct rte_src *sr if (old->flags & (REF_STALE | REF_DISCARD | REF_MODIFY)) { old->flags &= ~(REF_STALE | REF_DISCARD | REF_MODIFY); + + if (c->proto->rte_update_in_notify) + c->proto->rte_update_in_notify(c->proto, c, net, new, old, src); + return 1; } @@ -3118,6 +3122,9 @@ rte_update_in(struct channel *c, const net_addr *n, rte *new, struct rte_src *sr if (!old) goto drop_withdraw; + if (c->proto->rte_update_in_notify) + c->proto->rte_update_in_notify(c->proto, c, net, new, old, src); + if (!net->routes) fib_delete(&tab->fib, net); @@ -3149,6 +3156,10 @@ rte_update_in(struct channel *c, const net_addr *n, rte *new, struct rte_src *sr e->next = *pos; *pos = e; tab->rt_count++; + + if (c->proto->rte_update_in_notify) + c->proto->rte_update_in_notify(c->proto, c, net, new, old, src); + return 1; drop_update: diff --git a/proto/Doc b/proto/Doc index ef573d2a..9de9eeec 100644 --- a/proto/Doc +++ b/proto/Doc @@ -2,6 +2,7 @@ H Protocols C babel C bfd C bgp +C bmp C ospf C pipe C radv diff --git a/proto/bgp/attrs.c b/proto/bgp/attrs.c index 204151c3..de45cae0 100644 --- a/proto/bgp/attrs.c +++ b/proto/bgp/attrs.c @@ -1151,6 +1151,13 @@ bgp_attr_known(uint code) return (code < ARRAY_SIZE(bgp_attr_table)) && bgp_attr_table[code].name; } +void bgp_fix_attr_flags(ea_list *attrs) +{ + for (u8 i = 0; i < attrs->count; i++) + { + attrs->attrs[i].flags = bgp_attr_table[EA_ID(attrs->attrs[i].id)].flags; + } +} /* * Attribute export diff --git a/proto/bgp/bgp.c b/proto/bgp/bgp.c index 9408715e..709625ea 100644 --- a/proto/bgp/bgp.c +++ b/proto/bgp/bgp.c @@ -125,6 +125,7 @@ #include "lib/string.h" #include "bgp.h" +#include "proto/bmp/bmp.h" static list STATIC_LIST_INIT(bgp_sockets); /* Global list of listening sockets */ @@ -866,7 +867,10 @@ bgp_graceful_restart_timeout(timer *t) } } else + { bgp_stop(p, 0, NULL, 0); + bmp_peer_down(p, BE_NONE, NULL, BMP_PEER_DOWN_NULL_PKT_SIZE); + } } static void @@ -990,7 +994,10 @@ bgp_sock_err(sock *sk, int err) if (err) BGP_TRACE(D_EVENTS, "Connection lost (%M)", err); else + { BGP_TRACE(D_EVENTS, "Connection closed"); + bmp_peer_down(p, BE_SOCKET, NULL, BMP_PEER_DOWN_NULL_PKT_SIZE); + } if ((conn->state == BS_ESTABLISHED) && p->gr_ready) bgp_handle_graceful_restart(p); @@ -1315,6 +1322,7 @@ bgp_neigh_notify(neighbor *n) bgp_store_error(p, NULL, BE_MISC, BEM_NEIGHBOR_LOST); /* Perhaps also run bgp_update_startup_delay(p)? */ bgp_stop(p, 0, NULL, 0); + bmp_peer_down(p, BE_MISC, NULL, BMP_PEER_DOWN_NULL_PKT_SIZE); } } else if (p->cf->check_link && !(n->iface->flags & IF_LINK_UP)) @@ -1326,6 +1334,7 @@ bgp_neigh_notify(neighbor *n) if (ps == PS_UP) bgp_update_startup_delay(p); bgp_stop(p, 0, NULL, 0); + bmp_peer_down(p, BE_MISC, NULL, BMP_PEER_DOWN_NULL_PKT_SIZE); } } else @@ -1367,6 +1376,7 @@ bgp_bfd_notify(struct bfd_request *req) if (ps == PS_UP) bgp_update_startup_delay(p); bgp_stop(p, 0, NULL, 0); + bmp_peer_down(p, BE_MISC, NULL, BMP_PEER_DOWN_NULL_PKT_SIZE); } } } @@ -1684,6 +1694,7 @@ bgp_init(struct proto_config *CF) struct bgp_config *cf = (struct bgp_config *) CF; P->rt_notify = bgp_rt_notify; + P->rte_update_in_notify = bgp_rte_update_in_notify; P->preexport = bgp_preexport; P->neigh_notify = bgp_neigh_notify; P->reload_routes = bgp_reload_routes; diff --git a/proto/bgp/bgp.h b/proto/bgp/bgp.h index 302f58e7..c4f4f3be 100644 --- a/proto/bgp/bgp.h +++ b/proto/bgp/bgp.h @@ -496,6 +496,13 @@ struct bgp_parse_state { #define BGP_CF_WALK_CHANNELS(P,C) WALK_LIST(C, P->c.channels) if (C->c.channel == &channel_bgp) #define BGP_WALK_CHANNELS(P,C) WALK_LIST(C, P->p.channels) if (C->c.channel == &channel_bgp) +#define BGP_MSG_HDR_MARKER_SIZE 16 +#define BGP_MSG_HDR_MARKER_POS 0 +#define BGP_MSG_HDR_LENGTH_SIZE 2 +#define BGP_MSG_HDR_LENGTH_POS BGP_MSG_HDR_MARKER_SIZE +#define BGP_MSG_HDR_TYPE_SIZE 1 +#define BGP_MSG_HDR_TYPE_POS (BGP_MSG_HDR_MARKER_SIZE + BGP_MSG_HDR_LENGTH_SIZE) + static inline int bgp_channel_is_ipv4(struct bgp_channel *c) { return BGP_AFI(c->afi) == BGP_AFI_IPV4; } @@ -542,6 +549,8 @@ void bgp_store_error(struct bgp_proto *p, struct bgp_conn *c, u8 class, u32 code void bgp_stop(struct bgp_proto *p, int subcode, byte *data, uint len); const char *bgp_format_role_name(u8 role); +void bgp_fix_attr_flags(ea_list *attrs); + static inline int rte_resolvable(rte *rt) { @@ -615,6 +624,9 @@ struct rte *bgp_rte_modify_stale(struct rte *r, struct linpool *pool); u32 bgp_rte_igp_metric(struct rte *); void bgp_rt_notify(struct proto *P, struct channel *C, net *n, rte *new, rte *old); int bgp_preexport(struct channel *, struct rte *); +void bgp_rte_update_in_notify(const struct proto *P, const struct channel *C, + const net *net, const struct rte *new, const struct rte *old, + const struct rte_src *src); int bgp_get_attr(const struct eattr *e, byte *buf, int buflen); void bgp_get_route_info(struct rte *, byte *buf); int bgp_total_aigp_metric_(rte *e, u64 *metric, const struct adata **ad); @@ -648,6 +660,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); /* Packet types */ @@ -658,6 +671,7 @@ void bgp_update_next_hop(struct bgp_export_state *s, eattr *a, ea_list **to); #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 */ +#define PKT_BMP_MSG 0x20 /* BGP Monitoring Protocol message [RFC7854] */ /* Attributes */ diff --git a/proto/bgp/packets.c b/proto/bgp/packets.c index 5c17c370..bec8cd91 100644 --- a/proto/bgp/packets.c +++ b/proto/bgp/packets.c @@ -26,6 +26,7 @@ #include "nest/cli.h" #include "bgp.h" +#include "proto/bmp/bmp.h" #define BGP_RR_REQUEST 0 @@ -166,6 +167,7 @@ bgp_create_notification(struct bgp_conn *conn, byte *buf) buf[0] = conn->notify_code; buf[1] = conn->notify_subcode; memcpy(buf+2, conn->notify_data, conn->notify_size); + bmp_peer_down(p, BE_NONE, buf, conn->notify_size + 2); return buf + 2 + conn->notify_size; } @@ -975,6 +977,7 @@ bgp_rx_open(struct bgp_conn *conn, byte *pkt, uint len) bgp_schedule_packet(conn, NULL, PKT_KEEPALIVE); bgp_start_timer(conn->hold_timer, conn->hold_time); bgp_conn_enter_openconfirm_state(conn); + bmp_put_recv_bgp_open_msg(p, pkt, len); } @@ -2239,6 +2242,224 @@ bgp_update_next_hop(struct bgp_export_state *s, eattr *a, ea_list **to) #define MAX_ATTRS_LENGTH (end-buf+BGP_HEADER_LENGTH - 1024) +/** + * Following functions starting with prefix bgp_bmp_* compose BGP UPDATE messages. + * Their implementation has been adopted from relevant function without 'bmp_' part in + * their names. + */ + +// Buffer @buf should be big enough. It means that there should be available at least 19 bytes +static byte * +bgp_bmp_prepare_bgp_hdr(byte *buf, const u16 msg_size, const u8 msg_type) +{ + if (!buf) + { + return NULL; + } + + memset(buf + BGP_MSG_HDR_MARKER_POS, 0xff, BGP_MSG_HDR_MARKER_SIZE); + put_u16(buf + BGP_MSG_HDR_LENGTH_POS, msg_size); + put_u8(buf + BGP_MSG_HDR_TYPE_POS, msg_type); + + return buf + BGP_MSG_HDR_TYPE_POS + BGP_MSG_HDR_TYPE_SIZE; +} + +static uint +bgp_bmp_encode_nlri_ip4(struct bgp_write_state *s, const net *n, + const u32 path_id, byte *buf, uint size) +{ + const struct net_addr_ip4 *naddr = (net_addr_ip4 *)n->n.addr; + + byte *pos = buf; + /* Encode path ID */ + if (s->add_path) + { + put_u32(pos, path_id); + ADVANCE(pos, size, 4); + } + + /* Encode prefix length */ + *pos = naddr->pxlen; + ADVANCE(pos, size, 1); + + /* Encode MPLS labels */ + if (s->mpls) + { + bgp_encode_mpls_labels(s, s->mpls_labels, &pos, &size, pos - 1); + } + + /* Encode prefix body */ + ip4_addr a = ip4_hton(naddr->prefix); + uint b = (naddr->pxlen + 7) / 8; + memcpy(pos, &a, b); + ADVANCE(pos, size, b); + + return pos - buf; +} + +static uint +bgp_bmp_encode_nlri_ip6(struct bgp_write_state *s, const net *n, + const u32 path_id, byte *buf, uint size) +{ + if (size < BGP_NLRI_MAX) + { + return 0; + } + + const struct net_addr_ip6 *naddr = (net_addr_ip6 *)n->n.addr; + byte *pos = buf; + /* Encode path ID */ + if (s->add_path) + { + put_u32(pos, path_id); + ADVANCE(pos, size, 4); + } + + /* Encode prefix length */ + *pos = naddr->pxlen; + ADVANCE(pos, size, 1); + + /* Encode MPLS labels */ + if (s->mpls) + { + bgp_encode_mpls_labels(s, s->mpls_labels, &pos, &size, pos - 1); + } + + /* Encode prefix body */ + ip6_addr a = ip6_hton(naddr->prefix); + uint b = (naddr->pxlen + 7) / 8; + memcpy(pos, &a, b); + ADVANCE(pos, size, b); + + return pos - buf; +} + +static byte * +bgp_bmp_create_ip_reach(struct bgp_write_state *s, const net *n, + const struct rte *new, const struct rte *old, const u32 path_id, + byte *buf, uint size) +{ + /* + * 2 B Withdrawn Routes Length (zero) + * --- IPv4 Withdrawn Routes NLRI (unused) + * 2 B Total Path Attribute Length + * var Path Attributes + * var IPv4 Network Layer Reachability Information + */ + + int lr, la; // Route length, attribute length + ea_list *attrs = new ? new->attrs->eattrs : old->attrs->eattrs; + bgp_fix_attr_flags(attrs); + + la = bgp_encode_attrs(s, attrs, buf + 2, buf + size - 2); + if (la < 0) + { + /* Attribute list too long */ + log(L_ERR "Failed to encode UPDATE msg attributes"); + return NULL; + } + + put_u16(buf, la); + lr = bgp_bmp_encode_nlri_ip4(s, n, path_id, buf + 2 + la, size - (2 + la)); + + return buf + 2 + la + lr; +} + +static byte * +bgp_bmp_create_mp_reach(struct bgp_write_state *s, const net *n, + const struct rte *new, const struct rte *old, const u32 path_id, + byte *buf, uint size) +{ + /* + * 2 B IPv4 Withdrawn Routes Length (zero) + * --- IPv4 Withdrawn Routes NLRI (unused) + * 2 B Total Path Attribute Length + * 1 B MP_REACH_NLRI hdr - Attribute Flags + * 1 B MP_REACH_NLRI hdr - Attribute Type Code + * 2 B MP_REACH_NLRI hdr - Length of Attribute Data + * 2 B MP_REACH_NLRI data - Address Family Identifier + * 1 B MP_REACH_NLRI data - Subsequent Address Family Identifier + * 1 B MP_REACH_NLRI data - Length of Next Hop Network Address + * var MP_REACH_NLRI data - Network Address of Next Hop + * 1 B MP_REACH_NLRI data - Reserved (zero) + * var MP_REACH_NLRI data - Network Layer Reachability Information + * var Rest of Path Attributes + * --- IPv4 Network Layer Reachability Information (unused) + */ + + int lh, lr, la; /* Lengths of next hop, NLRI and attributes */ + + /* Begin of MP_REACH_NLRI atribute */ + buf[4] = BAF_OPTIONAL | BAF_EXT_LEN; + buf[5] = BA_MP_REACH_NLRI; + put_u16(buf+6, 0); /* Will be fixed later */ + put_af3(buf+8, s->channel->afi); + byte *pos = buf+11; + byte *end = buf + size; + /* Encode attributes to temporary buffer */ + byte *abuf = alloca(MAX_ATTRS_LENGTH); + + ea_list *attrs = new ? new->attrs->eattrs : old->attrs->eattrs; + bgp_fix_attr_flags(attrs); + + la = bgp_encode_attrs(s, attrs, abuf, abuf + MAX_ATTRS_LENGTH); + if (la < 0) + { + /* Attribute list too long */ + log(L_ERR "Failed to encode UPDATE msg attributes"); + return NULL; + } + + /* Encode the next hop */ + lh = bgp_encode_next_hop(s, s->mp_next_hop, pos+1); + *pos = lh; + pos += 1+lh; + + /* Reserved field */ + *pos++ = 0; + + /* Encode the NLRI */ + lr = bgp_bmp_encode_nlri_ip6(s, n, path_id, pos, end - (buf + la)); + pos += lr; + + /* End of MP_REACH_NLRI atribute, update data length */ + put_u16(buf+6, pos-buf-8); + + /* Copy remaining attributes */ + memcpy(pos, abuf, la); + pos += la; + + /* Initial UPDATE fields */ + put_u16(buf+0, 0); + put_u16(buf+2, pos-buf-4); + + return pos; +} + +static byte * +bgp_bmp_create_ip_unreach(struct bgp_write_state *s, const net *n, + const struct rte *new, const struct rte *old, const u32 path_id, + byte *buf, uint size) +{ + /* + * 2 B Withdrawn Routes Length + * var IPv4 Withdrawn Routes NLRI + * 2 B Total Path Attribute Length (zero) + * --- Path Attributes (unused) + * --- IPv4 Network Layer Reachability Information (unused) + */ + + uint len = 0; + bool is_withdrawn = !new && old; + if (is_withdrawn) + { + len = bgp_bmp_encode_nlri_ip4(s, n, path_id, buf + 2, size - 2); + } + + put_u16(buf, len); + return buf + 2 + len; +} + static byte * bgp_create_ip_reach(struct bgp_write_state *s, struct bgp_bucket *buck, byte *buf, byte *end) { @@ -2384,6 +2605,122 @@ bgp_create_mp_unreach(struct bgp_write_state *s, struct bgp_bucket *buck, byte * return buf+11+len; } +static byte * +bgp_bmp_create_mp_unreach(struct bgp_write_state *s, const net *n, + const struct rte *new, const struct rte *old, const u32 path_id, + byte *buf, uint size) +{ + /* + * 2 B Withdrawn Routes Length (zero) + * --- IPv4 Withdrawn Routes NLRI (unused) + * 2 B Total Path Attribute Length + * 1 B MP_UNREACH_NLRI hdr - Attribute Flags + * 1 B MP_UNREACH_NLRI hdr - Attribute Type Code + * 2 B MP_UNREACH_NLRI hdr - Length of Attribute Data + * 2 B MP_UNREACH_NLRI data - Address Family Identifier + * 1 B MP_UNREACH_NLRI data - Subsequent Address Family Identifier + * var MP_UNREACH_NLRI data - Network Layer Reachability Information + * --- IPv4 Network Layer Reachability Information (unused) + */ + + uint len = 0; + bool is_withdrawn = !new && old; + if (is_withdrawn) + { + len = bgp_bmp_encode_nlri_ip6(s, n, path_id, buf + 11, size); + } + + put_u16(buf+0, 0); + put_u16(buf+2, 7+len); + + /* Begin of MP_UNREACH_NLRI atribute */ + buf[4] = BAF_OPTIONAL | BAF_EXT_LEN; + buf[5] = BA_MP_UNREACH_NLRI; + + put_u16(buf+6, 3+len); + put_af3(buf+8, s->channel->afi); + + return buf+11+len; +} + +void +bgp_rte_update_in_notify(const struct proto *P, const struct channel *C, + const net *n, const struct rte *new, const struct rte *old, + const struct rte_src *src) +{ + struct bgp_proto *p = (struct bgp_proto *)P; + struct bgp_channel *c = (struct bgp_channel *)C; + byte buf[BGP_MAX_EXT_MSG_LENGTH] = { 0x00 }; + byte *pkt = buf + BGP_HEADER_LENGTH; + byte *end = pkt + (bgp_max_packet_length(p->conn) - BGP_HEADER_LENGTH); + + struct bgp_caps *peer = p->conn->remote_caps; + const struct bgp_af_caps *rem = bgp_find_af_caps(peer, c->afi); + struct bgp_write_state s = { + .proto = p, + .channel = c, + .pool = tmp_linpool, + .mp_reach = (bgp_channel_is_ipv6(c) || rem->ext_next_hop), + .as4_session = peer->as4_support, + .add_path = c->add_path_rx, + .mpls = c->desc->mpls, + }; + + const u32 path_id = c->add_path_rx ? src->private_id : 0; + byte *pos = pkt; + if (!s.mp_reach) + { + pos = bgp_bmp_create_ip_unreach(&s, n, new, old, path_id, pkt, end - pkt); + if (!pos) + { + log(L_ERR "Failed to create unreachable field in UPDATE message"); + return; + } + + pos = bgp_bmp_create_ip_reach(&s, n, new, old, path_id, pos, end - pos); + if (!pos) + { + log(L_ERR "Failed to create reachable field in UPDATE message"); + return; + } + + bgp_bmp_prepare_bgp_hdr(buf, pos - buf, PKT_UPDATE); + bmp_route_monitor_put_update_in_pre_msg(buf, pos - buf); + } + else if (new) // && s.mp_reach + { + pos = s.mp_reach + ? bgp_bmp_create_mp_reach(&s, n, new, old, path_id, pos, end - pos) + : bgp_bmp_create_ip_reach(&s, n, new, old, path_id, pos, end - pos); + if (!pos) + { + log(L_ERR "Failed to create reachable field in UPDATE message"); + return; + } + + bgp_bmp_prepare_bgp_hdr(buf, pos - buf, PKT_UPDATE); + bmp_route_monitor_put_update_in_pre_msg(buf, pos - buf); + } + + if (!new && old) + { + bmp_route_monitor_update_in_pre_commit(p); + bmp_route_monitor_update_in_pre_end(); + bmp_route_monitor_update_in_pre_begin(); + pkt = buf + BGP_HEADER_LENGTH; + end = pkt + (bgp_max_packet_length(p->conn) - BGP_HEADER_LENGTH); + pos = bgp_bmp_create_mp_unreach(&s, n, new, old, path_id, pkt, end - pkt); + if (!pos) + { + log(L_ERR "Failed to create unreachable field in UPDATE message"); + return; + } + + bgp_bmp_prepare_bgp_hdr(buf, pos - buf, PKT_UPDATE); + bmp_route_monitor_put_update_in_pre_msg(buf, pos - buf); + } +} + static byte * bgp_create_update(struct bgp_channel *c, byte *buf) { @@ -2484,7 +2821,7 @@ bgp_create_mp_end_mark(struct bgp_channel *c, byte *buf) return buf+10; } -static byte * +byte * bgp_create_end_mark(struct bgp_channel *c, byte *buf) { struct bgp_proto *p = (void *) c->c.proto; @@ -2635,6 +2972,7 @@ bgp_rx_update(struct bgp_conn *conn, byte *pkt, uint len) s.ip_reach_len = len - pos; s.ip_reach_nlri = pkt + pos; + bmp_route_monitor_update_in_pre_begin(); if (s.attr_len) ea = bgp_decode_attrs(&s, s.attrs, s.attr_len); @@ -2666,6 +3004,9 @@ bgp_rx_update(struct bgp_conn *conn, byte *pkt, uint len) bgp_decode_nlri(&s, s.mp_reach_af, s.mp_reach_nlri, s.mp_reach_len, ea, s.mp_next_hop_data, s.mp_next_hop_len); + bmp_route_monitor_update_in_pre_commit(p); + bmp_route_monitor_update_in_pre_end(); + done: rta_free(s.cached_rta); lp_restore(tmp_linpool, &tmpp); @@ -2917,7 +3258,12 @@ bgp_fire_tx(struct bgp_conn *conn) { conn->packets_to_send &= ~(1 << PKT_OPEN); end = bgp_create_open(conn, pkt); - return bgp_send(conn, PKT_OPEN, end - buf); + int rv = bgp_send(conn, PKT_OPEN, end - buf); + if (rv >= 0) + { + bmp_put_sent_bgp_open_msg(p, pkt, end - buf); + } + return rv; } else if (s & (1 << PKT_KEEPALIVE)) { @@ -3216,6 +3562,8 @@ bgp_rx_notification(struct bgp_conn *conn, byte *pkt, uint len) p->p.disabled = 1; } } + + bmp_peer_down(p, BE_NONE, pkt, len); } static void diff --git a/proto/bmp/Doc b/proto/bmp/Doc new file mode 100644 index 00000000..69b6e807 --- /dev/null +++ b/proto/bmp/Doc @@ -0,0 +1 @@ +S bmp.c diff --git a/proto/bmp/LICENSE b/proto/bmp/LICENSE new file mode 100644 index 00000000..1772f08d --- /dev/null +++ b/proto/bmp/LICENSE @@ -0,0 +1,2 @@ +The patch is provided under the terms of the GNU General Public License, either +version 2, or any later version. \ No newline at end of file diff --git a/proto/bmp/Makefile b/proto/bmp/Makefile new file mode 100644 index 00000000..d6fca1aa --- /dev/null +++ b/proto/bmp/Makefile @@ -0,0 +1,6 @@ +src := bmp.c buffer.c map.c +obj := $(src-o-files) +$(all-daemon) +$(cf-local) + +tests_objs := $(tests_objs) $(src-o-files) \ No newline at end of file diff --git a/proto/bmp/README.txt b/proto/bmp/README.txt new file mode 100644 index 00000000..386f4029 --- /dev/null +++ b/proto/bmp/README.txt @@ -0,0 +1,6 @@ +ABOUT +This package |proto/bmp/*| provide implementation of BGP Monitoring Protocol (BMP). +It has been started by Akamai Technologies, Inc. as a pilot program for support BMP in BIRD. +It provides only basic features of BMP specification which are needed by Akamai evaluation of +feasible BMP protocol. +Content of this package has been provided as a patch for BIRD release v2.0.7. \ No newline at end of file diff --git a/proto/bmp/bmp.c b/proto/bmp/bmp.c new file mode 100644 index 00000000..5d4e1ac3 --- /dev/null +++ b/proto/bmp/bmp.c @@ -0,0 +1,1279 @@ +/* + * BIRD -- The BGP Monitoring Protocol (BMP) + * + * (c) 2020 Akamai Technologies, Inc. (Pawel Maslanka, pmaslank@akamai.com) + * + * Can be freely distributed and used under the terms of the GNU GPL. + */ + +/** + * DOC: BGP Monitoring Protocol (BMP) + * + * Supported standards: + * o RFC 7854 - BMP standard + * + * TODO: + * - Support Peer Distinguisher ID in Per-Peer Header + * - Support peer type as RD Instance in Peer Type field of Per-Peer Header. + * Currently, there are supported Global and Local Instance Peer types + * - Support corresponding FSM event code during send PEER DOWN NOTIFICATION + * - Support DE_CONFIGURED PEER DOWN REASON code in PEER DOWN NOTIFICATION message + * - If connection with BMP collector will lost then we don't establish connection again + * - Set Peer Type by its a global and local-scope IP address + */ + +#include "proto/bmp/bmp.h" +#include "proto/bmp/buffer.h" +#include "proto/bmp/map.h" +#include "proto/bmp/utils.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "nest/cli.h" +#include "filter/filter.h" +#include "proto/bgp/bgp.h" +#include "sysdep/unix/unix.h" +#include "lib/event.h" +#include "lib/ip.h" +#include "lib/lists.h" +#include "lib/resource.h" +#include "lib/unaligned.h" +#include "nest/iface.h" +#include "nest/route.h" + +// We allow for single instance of BMP protocol +static struct bmp_proto *g_bmp; + +/* BMP Common Header [RFC 7854 - Section 4.1] */ +enum bmp_version { + BMP_VER_UNUSED = 0, // Version 0 is reserved and MUST NOT be sent + BMP_VERSION_1 = 1, // Version 1 was used by draft version of RFC 7854 + BMP_VERSION_2 = 2, // Version 2 was used by draft version of RFC 7854 + BMP_VERSION_3 = 3 // Version 3 is used by all messages defined in RFC 7854 +}; + +enum bmp_message_type { + BMP_ROUTE_MONITOR = 0, // Route Monitoring + BMP_STATS_REPORT = 1, // Statistics Report + BMP_PEER_DOWN_NOTIF = 2, // Peer Down Notification + BMP_PEER_UP_NOTIF = 3, // Peer Up Notification + BMP_INIT_MSG = 4, // Initiation Message + BMP_TERM_MSG = 5, // Termination Message + BMP_ROUTE_MIRROR_MSG = 6 // Route Mirroring Message +}; + +// Total size of Common Header +#define BMP_COMMON_HDR_SIZE 6 +// Defines size of padding when IPv4 address is going to be put into field +// which can accept also IPv6 address +#define BMP_PADDING_IP4_ADDR_SIZE 12 + +/* BMP Per-Peer Header [RFC 7854 - Section 4.2] */ +// Total size of Per-Peer Header +#define BMP_PER_PEER_HDR_SIZE 42 + +enum bmp_peer_type { + BMP_PEER_TYPE_GLOBAL_INSTANCE = 0, + BMP_PEER_TYPE_RD_INSTANCE = 1, + BMP_PEER_TYPE_LOCAL_INSTANCE = 2 +}; + +#define BMP_PEER_HDR_FLAG_V_SHIFT 7 +enum bmp_peer_flag_v_t { + // The Peer address is an IPv4 address + BMP_PEER_HDR_FLAG_V_IP4 = (0 << BMP_PEER_HDR_FLAG_V_SHIFT), + // The Peer address is an IPv6 address + BMP_PEER_HDR_FLAG_V_IP6 = (1 << BMP_PEER_HDR_FLAG_V_SHIFT) +}; + +#define BMP_PEER_HDR_FLAG_L_SHIFT 6 +enum bmp_peer_flag_l { + BMP_PEER_HDR_FLAG_L_PRE_POLICY_ADJ_RIB_IN = (0 << BMP_PEER_HDR_FLAG_L_SHIFT), + BMP_PEER_HDR_FLAG_L_POST_POLICY_ADJ_RIB_IN = (1 << BMP_PEER_HDR_FLAG_L_SHIFT) +}; + +#define BMP_PEER_HDR_FLAG_A_SHIFT 5 +enum bmp_peer_flag_a { + // The 4-byte AS_PATH format + BMP_PEER_HDR_FLAG_A_AS_PATH_4B = (0 << BMP_PEER_HDR_FLAG_A_SHIFT), + // The legacy 2-byte AS_PATH format + BMP_PEER_HDR_FLAG_A_AS_PATH_2B = (1 << BMP_PEER_HDR_FLAG_A_SHIFT) +}; + +#define BMP_PEER_HDR_FLAGS_INIT(flags) \ + (flags) = 0 +#define BMP_PEER_HDR_FLAGS_SET(flags, bit_mask) \ + (flags) |= (bit_mask) + +/* BMP Information TLV header [RFC 7854 - Section 4.4] */ +// Total size of Type and Length fields of Information TLV Header without +// variable part +#define BMP_INFO_TLV_FIX_SIZE 4 + +enum bmp_info_tlv_type { + BMP_INFO_TLV_TYPE_STRING = 0, // String + BMP_INFO_TLV_TYPE_SYS_DESCR = 1, // SysDescr + BMP_INFO_TLV_TYPE_SYS_NAME = 2 // SysName +}; + +/* BMP Peer Up Notification message header [RFC 7854 - Section 4.10] */ +// Total size of all fields of Peer Up Notification message except variable part +#define BMP_PEER_UP_NOTIF_MSG_FIX_SIZE 20 + +enum bmp_peer_down_notif_reason { + // The local system closed the session + BMP_PEER_DOWN_REASON_LOCAL_BGP_NOTIFICATION = 1, + // The local system closed the session + BMP_PEER_DOWN_REASON_LOCAL_NO_NOTIFICATION = 2, + // The remote system closed the session with a notification message + BMP_PEER_DOWN_REASON_REMOTE_BGP_NOTIFICATION = 3, + // The remote system closed the session without a notification message + BMP_PEER_DOWN_REASON_REMOTE_NO_NOTIFICATION = 4, + // Information for this peer will no longer be sent to the monitoring station + // for configuration reasons + BMP_PEER_DOWN_REASON_PEER_DE_CONFIGURED = 5 +}; + +/* BMP Termination Message [RFC 7854 - Section 4.5] */ +#define BMP_TERM_INFO_TYPE_SIZE 2 +enum bmp_term_info_type { + BMP_TERM_INFO_STRING = 0, // The Information field contains string + BMP_TERM_INFO_REASON = 1, // The Information field contains 2-byte reason code +}; + +// 2-byte code in the Information field +#define BMP_TERM_REASON_CODE_SIZE 2 +enum bmp_term_reason { + BMP_TERM_REASON_ADM = 0, // Session administratively closed + BMP_TERM_REASON_UNK = 1, // Unspecified reason + BMP_TERM_REASON_OOR = 2, // Out of resources + BMP_TERM_REASON_DUP = 3, // Redundant connection + BMP_TERM_REASON_PERM = 4, // Session permanently administratively closed +}; + +// Size of Information Length field in Termination Message header +#define BMP_TERM_INFO_LEN_FIELD_SIZE 2 + +// Default chunk size request when memory allocation +#define DEFAULT_MEM_BLOCK_SIZE 4096 + +// Timeout for connection to the BMP collector retry +#define CONNECT_RETRY_SEC (10 S) + +#define IP4_MAX_TTL 255 + +// Handle BIRD socket error event +static void +bmp_sock_err(sock *sk, int err); + +static enum bmp_result +bmp_send_peer_up_notif_msg(const struct bgp_proto *bgp, + const byte* tx_data, const size_t tx_data_size, + const byte* rx_data, const size_t rx_data_size); + +static void +bmp_peer_map_walk_tx_open_msg_and_send_peer_up_notif( + const struct bmp_peer_map_key key, const byte *tx_msg, + const size_t tx_msg_size); + +// Stores necessary any data in list +struct bmp_data_node { + node n; + byte *data; + size_t data_size; +}; + +static void +bmp_route_monitor_pre_policy_table_in_snapshot(const struct channel *C); + +static void +bmp_common_hdr_serialize(buffer *stream, const enum bmp_message_type type, const u32 data_size) +{ + bmp_put_u8(stream, BMP_VERSION_3); + bmp_put_u32(stream, BMP_COMMON_HDR_SIZE + data_size); + bmp_put_u8(stream, type); +} + +static enum bmp_result +bmp_info_tlv_hdr_serialize(buffer *stream, const enum bmp_info_tlv_type type, + const char *ascii) +{ + const size_t ascii_len = strlen(ascii); + if (ascii_len > MIB_II_STR_LEN) + { + return BMP_E_INVALID_ARG; + } + + bmp_put_u16(stream, type); + // It doesn't contain null terminating character '\0' + bmp_put_u16(stream, ascii_len); + bmp_put_data(stream, ascii, ascii_len); + + return BMP_E_NONE; +} + +// Serializes BMP Initiation message header [RFC 7854 - Section 4.3] +static enum bmp_result +bmp_init_msg_serialize(buffer *stream, const char *sys_descr, const char *sys_name) +{ + const size_t sys_descr_len = strlen(sys_descr); + const size_t sys_name_len = strlen(sys_name); + // We include MIB-II sysDescr and sysName in BMP INIT MSG so that's why + // allocated 2x BMP_INFO_TLV_FIX_SIZE memory pool size + const size_t data_size = (2 * BMP_INFO_TLV_FIX_SIZE) + sys_descr_len + sys_name_len; + bmp_buffer_need(stream, BMP_COMMON_HDR_SIZE + data_size); + bmp_common_hdr_serialize(stream, BMP_INIT_MSG, data_size); + IF_BMP_FAILED_RETURN_RC( + bmp_info_tlv_hdr_serialize(stream, BMP_INFO_TLV_TYPE_SYS_DESCR, sys_descr) + ); + + IF_BMP_FAILED_RETURN_RC( + bmp_info_tlv_hdr_serialize(stream, BMP_INFO_TLV_TYPE_SYS_NAME, sys_name) + ); + + return BMP_E_NONE; +} + +static enum bmp_result +bmp_schedule_tx_packet(const byte *payload, const size_t size) +{ + IF_COND_TRUE_PRINT_ERR_MSG_AND_RETURN_OPT_VAL( + !g_bmp->station_connected, + "Not BMP station connected yet", + BMP_E_CONNECT_TO_SRV + ); + + struct bmp_data_node *tx_data = mb_alloc(g_bmp->tx_mem_pool, sizeof (struct bmp_data_node)); + tx_data->data = mb_alloc(g_bmp->tx_mem_pool, size); + memcpy(tx_data->data, payload, size); + tx_data->data_size = size; + add_tail(&g_bmp->tx_queue, &tx_data->n); + if (sk_tx_buffer_empty(g_bmp->conn->sk) + && !ev_active(g_bmp->conn->tx_ev)) + { + ev_schedule(g_bmp->conn->tx_ev); + } + + return BMP_E_NONE; +} + +/** + * bmp_startup - connect to the BMP collector. + * NOTE: Send Initiation Message to the BMP collector. + */ +static enum bmp_result +bmp_startup(void) +{ + if (g_bmp->started || !g_bmp->station_connected) + { + return BMP_E_NONE; + } + + enum bmp_result rc = BMP_E_NONE; + buffer payload + = bmp_buffer_alloc(g_bmp->buffer_mpool, DEFAULT_MEM_BLOCK_SIZE); + IF_BMP_FAILED_GOTO_LABEL( + bmp_init_msg_serialize(&payload, g_bmp->sys_descr, g_bmp->sys_name), + err + ); + + IF_BMP_FAILED_GOTO_LABEL( + bmp_schedule_tx_packet(bmp_buffer_data(&payload), bmp_buffer_pos(&payload)), + err + ); + + g_bmp->started = true; + +err: + bmp_buffer_free(&payload); + return rc; +} + +void +bmp_fire_tx(void *vconn) +{ + struct bmp_conn *conn = (struct bmp_conn *) vconn; + IF_PTR_IS_NULL_PRINT_ERR_MSG_AND_RETURN_OPT_VAL( + conn->sk, + "Socket is null" + ); + + byte *buf = conn->sk->tbuf; + IF_COND_TRUE_PRINT_ERR_MSG_AND_RETURN_OPT_VAL( + EMPTY_LIST(g_bmp->tx_queue), + "Called BMP TX event handler when there is not any data to send" + ); + + size_t cnt = 0; // Counts max packets which we want to send per TX slot + struct bmp_data_node *tx_data; + struct bmp_data_node *tx_data_next; + size_t data_size = 0; + WALK_LIST_DELSAFE(tx_data, tx_data_next, g_bmp->tx_queue) + { + if (tx_data->data_size > conn->sk->tbsize) + { + sk_set_tbsize(conn->sk, tx_data->data_size); + } + + data_size = tx_data->data_size; + memcpy(buf, tx_data->data, tx_data->data_size); + mb_free(tx_data->data); + rem_node((node *) tx_data); + mb_free(tx_data); + IF_COND_TRUE_PRINT_ERR_MSG_AND_RETURN_OPT_VAL( + (sk_send(conn->sk, data_size) == 0), + "Failed to send BMP packet", + ); + + // BMP packets should be treat with lowest priority when scheduling sending + // packets to target. That's why we want to send max. 32 packets per event + // call + if (++cnt > 32) + { + if (!ev_active(conn->tx_ev)) + { + ev_schedule(conn->tx_ev); + } + + return; + } + } +} + +static void +bmp_tx(struct birdsock *sk) +{ + IF_BMP_FAILED_PRINT_ERR_MSG_AND_RETURN_OPT_VAL( + bmp_startup(), + "Failed to send Initation message to BMP collector" + ); + + bmp_fire_tx(sk->data); +} + +static inline enum bmp_result +bmp_open_socket(struct bmp_proto *bmp) +{ + bmp->conn->sk->daddr = bmp->station_ip; + bmp->conn->sk->dport = bmp->station_port; + bmp->conn->sk->err_hook = bmp_sock_err; + + if (sk_open(bmp->conn->sk) < 0) + { + return BMP_E_OPEN_SOCKET; + } + + return BMP_E_NONE; +} + +static void +bmp_connection_retry(timer *t) +{ + struct bmp_proto *bmp = (struct bmp_proto *) t->data; + IF_BMP_FAILED_PRINT_ERR_MSG_AND_RETURN_OPT_VAL( + bmp_open_socket(bmp), + "Failed to connect to BMP station" + ); + + log(L_DEBUG "Connected to BMP station after connection retry"); + tm_stop(t); +} + +void +bmp_sock_err(sock *sk, int err) +{ + struct bmp_conn *conn = (struct bmp_conn *)sk->data; + log(L_WARN "[BMP:%s] Socket error: %M", conn->bmp->p.name, err); +} + +static void +bmp_put_ip4_addr_with_padding(buffer *stream, const ip4_addr addr) +{ + byte padding[BMP_PADDING_IP4_ADDR_SIZE] = { 0x00 }; + bmp_put_data(stream, padding, BMP_PADDING_IP4_ADDR_SIZE); + bmp_put_ip4(stream, addr); +} + +static void +bmp_set_initial_bgp_hdr(buffer *stream, const u16 msg_size, const u8 msg_type) +{ + byte marker[BGP_MSG_HDR_MARKER_SIZE]; + memset(marker, 0xff, BGP_MSG_HDR_MARKER_SIZE); + bmp_put_data(stream, marker, BGP_MSG_HDR_MARKER_SIZE); + bmp_put_u16(stream, msg_size); + bmp_put_u8(stream, msg_type); +} + +/** + * bmp_per_peer_hdr_serialize - serializes Per-Peer Header + * + * @is_pre_policy: indicate the message reflects the pre-policy Adj-RIB-In + * @peer_addr: the remote IP address associated with the TCP session + * @peer_as: the Autonomous System number of the peer + * @peer_bgp_id: the BGP Identifier of the peer + * @ts_sec: the time in seconds when the encapsulated routes were received + * @ts_usec: the time in microseconds when the encapsulated routes were received + */ +static void +bmp_per_peer_hdr_serialize(buffer *stream, const bool is_global_instance_peer, + const bool is_pre_policy, const bool is_as_path_4bytes, + const ip_addr peer_addr, const u32 peer_as, const u32 peer_bgp_id, + const u32 ts_sec, const u32 ts_usec) +{ + // TODO: ATM we don't support BMP_PEER_TYPE_RD_INSTANCE + const enum bmp_peer_type peer_type = is_global_instance_peer + ? BMP_PEER_TYPE_GLOBAL_INSTANCE + : BMP_PEER_TYPE_LOCAL_INSTANCE; + const u8 peer_flag_v = ipa_is_ip4(peer_addr) + ? BMP_PEER_HDR_FLAG_V_IP4 + : BMP_PEER_HDR_FLAG_V_IP6; + const u8 peer_flag_l = is_pre_policy + ? BMP_PEER_HDR_FLAG_L_PRE_POLICY_ADJ_RIB_IN + : BMP_PEER_HDR_FLAG_L_POST_POLICY_ADJ_RIB_IN; + const u8 peer_flag_a = is_as_path_4bytes + ? BMP_PEER_HDR_FLAG_A_AS_PATH_4B + : BMP_PEER_HDR_FLAG_A_AS_PATH_2B; + u8 peer_flags; + BMP_PEER_HDR_FLAGS_INIT(peer_flags); + BMP_PEER_HDR_FLAGS_SET(peer_flags, peer_flag_v); + BMP_PEER_HDR_FLAGS_SET(peer_flags, peer_flag_l); + BMP_PEER_HDR_FLAGS_SET(peer_flags, peer_flag_a); + + bmp_put_u8(stream, peer_type); + bmp_put_u8(stream, peer_flags); + // TODO: Provide appropriate peer Route Distinguisher if applicable + bmp_put_u64(stream, 0x00); // 0x00 - Not supported peer distinguisher + if (ipa_is_ip4(peer_addr)) + { + bmp_put_ip4_addr_with_padding(stream, ipa_to_ip4(peer_addr)); + } + else + { + bmp_put_ip6(stream, ipa_to_ip6(peer_addr)); + } + + bmp_put_u32(stream, peer_as); + bmp_put_u32(stream, peer_bgp_id); + bmp_put_u32(stream, ts_sec); + bmp_put_u32(stream, ts_usec); +} + +/* [4.6] Route Monitoring */ +static void +bmp_route_monitor_msg_serialize(buffer *stream, const bool is_peer_global, + const bool table_in_pre_policy, const u32 peer_as, const u32 peer_bgp_id, + const bool as4_support, const ip_addr remote_addr, const byte *update_msg, + const size_t update_msg_size, u32 ts_sec, u32 ts_usec) +{ + const size_t data_size = BMP_PER_PEER_HDR_SIZE + update_msg_size; + bmp_buffer_need(stream, BMP_COMMON_HDR_SIZE + data_size); + bmp_common_hdr_serialize(stream, BMP_ROUTE_MONITOR, data_size); + bmp_per_peer_hdr_serialize(stream, is_peer_global, table_in_pre_policy, + as4_support, remote_addr, peer_as, peer_bgp_id, ts_sec, ts_usec); + bmp_put_data(stream, update_msg, update_msg_size); +} + +static void +bmp_peer_up_notif_msg_serialize(buffer *stream, const bool is_peer_global, + const u32 peer_as, const u32 peer_bgp_id, const bool as4_support, + const ip_addr local_addr, const ip_addr remote_addr, const u16 local_port, + const u16 remote_port, const byte *sent_msg, const size_t sent_msg_size, + const byte *recv_msg, const size_t recv_msg_size) +{ + const size_t data_size = BMP_PER_PEER_HDR_SIZE + BMP_PEER_UP_NOTIF_MSG_FIX_SIZE + + sent_msg_size + recv_msg_size; + bmp_buffer_need(stream, BMP_COMMON_HDR_SIZE + data_size); + bmp_common_hdr_serialize(stream, BMP_PEER_UP_NOTIF, data_size); + bmp_per_peer_hdr_serialize(stream, is_peer_global, + true /* TODO: Hardcoded pre-policy Adj-RIB-In */, as4_support, remote_addr, + peer_as, peer_bgp_id, 0, 0); // 0, 0 - No timestamp provided + if (ipa_is_ip4(local_addr)) + { + bmp_put_ip4_addr_with_padding(stream, ipa_to_ip4(local_addr)); + } + else + { + bmp_put_ip6(stream, ipa_to_ip6(local_addr)); + } + + bmp_put_u16(stream, local_port); + bmp_put_u16(stream, remote_port); + bmp_set_initial_bgp_hdr(stream, sent_msg_size, PKT_OPEN); + const size_t missing_bgp_hdr_size = BGP_MSG_HDR_MARKER_SIZE + + BGP_MSG_HDR_LENGTH_SIZE + + BGP_MSG_HDR_TYPE_SIZE; + bmp_put_data(stream, sent_msg, sent_msg_size - missing_bgp_hdr_size); + bmp_put_data(stream, recv_msg, recv_msg_size); +} + +static void +bmp_peer_down_notif_msg_serialize(buffer *stream, const bool is_peer_global, + const u32 peer_as, const u32 peer_bgp_id, const bool as4_support, + const ip_addr remote_addr, const byte *data, const size_t data_size) +{ + const size_t payload_size = BMP_PER_PEER_HDR_SIZE + data_size; + bmp_buffer_need(stream, BMP_COMMON_HDR_SIZE + payload_size); + bmp_common_hdr_serialize(stream, BMP_PEER_DOWN_NOTIF, payload_size); + bmp_per_peer_hdr_serialize(stream, is_peer_global, + true /* TODO: Hardcoded pre-policy adj RIB IN */, as4_support, remote_addr, + peer_as, peer_bgp_id, 0, 0); // 0, 0 - No timestamp provided + bmp_put_data(stream, data, data_size); +} + +/** + * bmp_open - initialize internal resources of BMP implementation. + * NOTE: It does not connect to BMP collector yet. + */ +enum bmp_result +bmp_open(const struct proto *P) +{ + struct bmp_proto *bmp = (struct bmp_proto *) P; + g_bmp = bmp; + enum bmp_result rc = BMP_E_NONE; + + log(L_DEBUG "Init BMP"); + if (!P) + { + return BMP_E_NULL_REF; + } + + g_bmp->buffer_mpool = rp_new(P->pool, "BMP Buffer"); + g_bmp->map_mem_pool = rp_new(P->pool, "BMP Map"); + g_bmp->tx_mem_pool = rp_new(P->pool, "BMP Tx"); + g_bmp->update_msg_mem_pool = rp_new(P->pool, "BMP Update"); + bmp->conn->tx_ev = ev_new_init(g_bmp->tx_mem_pool, bmp_fire_tx, bmp->conn); + if (!bmp->conn->tx_ev) + { + return BMP_E_NEW_TX_EVENT; + } + + IF_BMP_FAILED_RETURN_RC( + bmp_peer_map_init(&g_bmp->peer_open_msg.tx_msg, g_bmp->map_mem_pool) + ); + + IF_BMP_FAILED_GOTO_LABEL( + bmp_peer_map_init(&g_bmp->peer_open_msg.rx_msg, g_bmp->map_mem_pool), + err_free_ip_map_tx_msg + ); + + IF_BMP_FAILED_GOTO_LABEL( + bmp_peer_map_init(&g_bmp->bgp_peers, g_bmp->map_mem_pool), + err_free_ip_map_rx_msg + ); + + init_list(&g_bmp->tx_queue); + init_list(&g_bmp->rt_table_in_pre_policy.update_msg_queue); + g_bmp->station_connected = false; + g_bmp->started = false; + g_bmp->connect_retry_timer = NULL; + if (BMP_FAILED(bmp_open_socket(bmp))) + { + log(L_DEBUG "Failed to connect to BMP station"); + g_bmp->connect_retry_timer = tm_new_init(P->pool, bmp_connection_retry, bmp, + CONNECT_RETRY_SEC, 0 /* not randomized */); + tm_start(g_bmp->connect_retry_timer, CONNECT_RETRY_SEC); + g_bmp->station_connected = false; + } + else + { + log(L_DEBUG "Connected to BMP station"); + } + + strncpy(g_bmp->sys_name, bmp->sys_name, sizeof (g_bmp->sys_name) - 1); + strncpy(g_bmp->sys_descr, bmp->sys_descr, sizeof (g_bmp->sys_descr) - 1); + return BMP_E_NONE; + +err_free_ip_map_rx_msg: + bmp_peer_map_free(&g_bmp->peer_open_msg.rx_msg); + +err_free_ip_map_tx_msg: + bmp_peer_map_free(&g_bmp->peer_open_msg.tx_msg); + return rc; +} + +void +bmp_peer_map_walk_tx_open_msg_and_send_peer_up_notif( + const struct bmp_peer_map_key key, const byte *tx_msg, + const size_t tx_msg_size) +{ + const struct bmp_peer_map_entry *map_rx_msg = bmp_peer_map_get(&g_bmp->peer_open_msg.rx_msg, key); + IF_PTR_IS_NULL_PRINT_ERR_MSG_AND_RETURN_OPT_VAL( + map_rx_msg, + "Processing TX BGP OPEN MSG but there is not corresponding received MSG" + ); + + const struct bmp_peer_map_entry *map_bgp_proto = bmp_peer_map_get(&g_bmp->bgp_peers, key); + IF_PTR_IS_NULL_PRINT_ERR_MSG_AND_RETURN_OPT_VAL( + map_bgp_proto, + "There is not BGP proto related with stored TX/RX OPEN MSG" + ); + + const struct bgp_proto *bgp; + memcpy(&bgp, map_bgp_proto->data.buf, sizeof (bgp)); + if (bgp->p.proto_state == PS_UP) + { + IF_BMP_FAILED_PRINT_ERR_MSG_AND_RETURN_OPT_VAL( + bmp_send_peer_up_notif_msg(bgp, tx_msg, tx_msg_size, map_rx_msg->data.buf, + map_rx_msg->data.buf_size), + "Failed to send BMP Peer Up Notification MSG" + ); + } +} + +static void +bmp_peer_up(const struct bgp_proto *bgp) +{ + struct bgp_channel *c; + WALK_LIST(c, bgp->p.channels) + { + bmp_route_monitor_pre_policy_table_in_snapshot((struct channel *) c); + } +} + +static const struct birdsock * +bmp_get_birdsock(const struct bgp_proto *bgp) +{ + if (bgp->conn && bgp->conn->sk) + { + return bgp->conn->sk; + } + + return NULL; +} + +static const struct birdsock * +bmp_get_birdsock_ext(const struct bgp_proto *bgp) +{ + const struct birdsock *sk = bmp_get_birdsock(bgp); + if (sk != NULL) + { + return sk; + } + + if (bgp->incoming_conn.sk) + { + sk = bgp->incoming_conn.sk; + } + else if (bgp->outgoing_conn.sk) + { + sk = bgp->outgoing_conn.sk; + } + + return sk; +} + +static const struct bgp_caps * +bmp_get_bgp_remote_caps(const struct bgp_proto *bgp) +{ + if (bgp->conn && bgp->conn->remote_caps) + { + return bgp->conn->remote_caps; + } + + return NULL; +} + +static const struct bgp_caps * +bmp_get_bgp_remote_caps_ext(const struct bgp_proto *bgp) +{ + const struct bgp_caps *remote_caps = bmp_get_bgp_remote_caps(bgp); + if (remote_caps != NULL) + { + return remote_caps; + } + + if (bgp->incoming_conn.remote_caps) + { + remote_caps = bgp->incoming_conn.remote_caps; + } + else if (bgp->outgoing_conn.remote_caps) + { + remote_caps = bgp->outgoing_conn.remote_caps; + } + + return remote_caps; +} + +static bool +bmp_is_peer_global_instance(const struct bgp_proto *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); +} + +enum bmp_result +bmp_send_peer_up_notif_msg(const struct bgp_proto *bgp, + const byte* tx_data, const size_t tx_data_size, + const byte* rx_data, const size_t rx_data_size) +{ + const struct birdsock *sk = bmp_get_birdsock_ext(bgp); + if (IS_NULL(sk)) + { + return BMP_E_BIRDSOCK_NULL_REF; + } + + const struct bgp_caps *remote_caps = bmp_get_bgp_remote_caps_ext(bgp); + if (IS_NULL(remote_caps)) + { + return BMP_E_REMOTE_CAPS_NULL_REF; + } + + enum bmp_result rc = BMP_E_NONE; + const bool is_global_instance_peer = bmp_is_peer_global_instance(bgp); + buffer payload = bmp_buffer_alloc(g_bmp->buffer_mpool, DEFAULT_MEM_BLOCK_SIZE); + bmp_peer_up_notif_msg_serialize(&payload, is_global_instance_peer, + bgp->remote_as, bgp->remote_id, remote_caps->as4_support, + sk->saddr, sk->daddr, sk->sport, sk->dport, tx_data, tx_data_size, + rx_data, rx_data_size); + IF_BMP_FAILED_GOTO_LABEL( + bmp_schedule_tx_packet(bmp_buffer_data(&payload), bmp_buffer_pos(&payload)), + err + ); + + bmp_peer_up(bgp); + +err: + bmp_buffer_free(&payload); + return rc; +} + +void +bmp_put_sent_bgp_open_msg(const struct bgp_proto *bgp, const byte* pkt, + const size_t pkt_size) +{ + if (IS_NULL(g_bmp)) + { + return; + } + + struct bmp_peer_map_key key = bmp_peer_map_key_create(bgp->remote_ip, + bgp->remote_as); + const struct bmp_peer_map_entry *map_entry + = bmp_peer_map_get(&g_bmp->peer_open_msg.rx_msg, key); + if (!map_entry || !g_bmp->started) + { + IF_BMP_FAILED_PRINT_ERR_MSG_AND_RETURN_OPT_VAL( + bmp_peer_map_insert(&g_bmp->peer_open_msg.tx_msg, key, pkt, pkt_size), + "Failed to put data into map" + ); + + if (!map_entry) + { + IF_BMP_FAILED_PRINT_ERR_MSG_AND_RETURN_OPT_VAL( + bmp_peer_map_insert(&g_bmp->bgp_peers, key, (const byte *) &bgp, + sizeof (bgp)), + "Failed to put data into map" + ); + } + + return; + } + + IF_BMP_FAILED_PRINT_ERR_MSG( + bmp_send_peer_up_notif_msg(bgp, pkt, pkt_size, map_entry->data.buf, + map_entry->data.buf_size), + "Failed to send PEER UP notification" + ); +} + +void +bmp_put_recv_bgp_open_msg(const struct bgp_proto *bgp, const byte* pkt, + const size_t pkt_size) +{ + if (IS_NULL(g_bmp)) + { + return; + } + + struct bmp_peer_map_key key + = bmp_peer_map_key_create(bgp->remote_ip, bgp->remote_as); + const struct bmp_peer_map_entry *map_data + = bmp_peer_map_get(&g_bmp->peer_open_msg.tx_msg, key); + if (!map_data || !g_bmp->started) + { + IF_BMP_FAILED_PRINT_ERR_MSG_AND_RETURN_OPT_VAL( + bmp_peer_map_insert(&g_bmp->peer_open_msg.rx_msg, key, pkt, pkt_size), + "Failed to insert item into peer map" + ); + + if (!map_data) + { + IF_BMP_FAILED_PRINT_ERR_MSG_AND_RETURN_OPT_VAL( + bmp_peer_map_insert(&g_bmp->bgp_peers, key, (const byte *) &bgp, + sizeof (bgp)), + "Failed to insert item into peer map" + ); + } + + return; + } + + IF_BMP_FAILED_PRINT_ERR_MSG_AND_RETURN_OPT_VAL( + bmp_send_peer_up_notif_msg(bgp, map_data->data.buf, map_data->data.buf_size, + pkt, pkt_size), + "Failed to send peer up notification" + ); +} + +void +bmp_route_monitor_update_in_pre_begin() +{ + if (IS_NULL(g_bmp)) + { + return; + } + + if (g_bmp->monitoring_rib.in_pre_policy == false) + { + return; + } + + IF_COND_TRUE_PRINT_ERR_MSG_AND_RETURN_OPT_VAL( + !g_bmp->started, + "BMP instance not started yet" + ); + + IF_COND_TRUE_PRINT_ERR_MSG_AND_RETURN_OPT_VAL( + !EMPTY_LIST(g_bmp->rt_table_in_pre_policy.update_msg_queue), + "Previous BMP route monitoring update not finished yet" + ); + + gettimeofday(&g_bmp->rt_table_in_pre_policy.update_begin_time,NULL); + init_list(&g_bmp->rt_table_in_pre_policy.update_msg_queue); + g_bmp->rt_table_in_pre_policy.update_msg_size = 0; + g_bmp->rt_table_in_pre_policy.update_in_progress = true; +} + +void +bmp_route_monitor_put_update_in_pre_msg(const byte *data, const size_t data_size) +{ + if (IS_NULL(g_bmp)) + { + return; + } + + if (g_bmp->monitoring_rib.in_pre_policy == false) + { + return; + } + + IF_COND_TRUE_PRINT_ERR_MSG_AND_RETURN_OPT_VAL( + !g_bmp->started, + "BMP instance not started yet" + ); + + IF_COND_TRUE_PRINT_ERR_MSG_AND_RETURN_OPT_VAL( + !g_bmp->rt_table_in_pre_policy.update_in_progress, + "BMP route monitoring update not started yet" + ); + + struct bmp_data_node *upd_msg = mb_alloc(g_bmp->update_msg_mem_pool, + sizeof (struct bmp_data_node)); + upd_msg->data = mb_alloc(g_bmp->update_msg_mem_pool, data_size); + memcpy(upd_msg->data, data, data_size); + upd_msg->data_size = data_size; + g_bmp->rt_table_in_pre_policy.update_msg_size += data_size; + add_tail(&g_bmp->rt_table_in_pre_policy.update_msg_queue, &upd_msg->n); +} + +void +bmp_route_monitor_update_in_pre_commit(const struct bgp_proto *bgp) +{ + if (IS_NULL(g_bmp)) + { + return; + } + + if (g_bmp->monitoring_rib.in_pre_policy == false) + { + return; + } + + IF_COND_TRUE_PRINT_ERR_MSG_AND_RETURN_OPT_VAL( + (!g_bmp->started || EMPTY_LIST(g_bmp->rt_table_in_pre_policy.update_msg_queue)), + "BMP route monitoring update not started yet" + ); + + const struct birdsock *sk = bmp_get_birdsock(bgp); + IF_PTR_IS_NULL_PRINT_ERR_MSG_AND_RETURN_OPT_VAL( + sk, + "Failed to get bird socket from BGP proto" + ); + + const struct bgp_caps *remote_caps = bmp_get_bgp_remote_caps(bgp); + IF_PTR_IS_NULL_PRINT_ERR_MSG_AND_RETURN_OPT_VAL( + remote_caps, + "Failed to get remote capabilities from BGP proto" + ); + + bool is_global_instance_peer = bmp_is_peer_global_instance(bgp); + buffer payload + = bmp_buffer_alloc(g_bmp->buffer_mpool, + g_bmp->rt_table_in_pre_policy.update_msg_size + DEFAULT_MEM_BLOCK_SIZE); + + buffer update_msgs + = bmp_buffer_alloc(g_bmp->buffer_mpool, + g_bmp->rt_table_in_pre_policy.update_msg_size); + + struct bmp_data_node *data; + WALK_LIST(data, g_bmp->rt_table_in_pre_policy.update_msg_queue) + { + bmp_put_data(&update_msgs, data->data, data->data_size); + bmp_route_monitor_msg_serialize(&payload, + is_global_instance_peer, true /* TODO: Hardcoded pre-policy Adj-Rib-In */, + bgp->conn->received_as, bgp->remote_id, remote_caps->as4_support, + sk->daddr, bmp_buffer_data(&update_msgs), bmp_buffer_pos(&update_msgs), + g_bmp->rt_table_in_pre_policy.update_begin_time.tv_sec, + g_bmp->rt_table_in_pre_policy.update_begin_time.tv_usec); + + IF_BMP_FAILED_PRINT_ERR_MSG_AND_GOTO_LABEL( + bmp_schedule_tx_packet(bmp_buffer_data(&payload), bmp_buffer_pos(&payload)), + "Failed to schedule packet for sent", + err + ); + + bmp_buffer_flush(&payload); + bmp_buffer_flush(&update_msgs); + } + +err: + bmp_buffer_free(&update_msgs); + bmp_buffer_free(&payload); +} + +void +bmp_route_monitor_update_in_pre_end() +{ + if (IS_NULL(g_bmp)) + { + return; + } + + if (g_bmp->monitoring_rib.in_pre_policy == false) + { + return; + } + + IF_COND_TRUE_PRINT_ERR_MSG_AND_RETURN_OPT_VAL( + (!g_bmp->started || EMPTY_LIST(g_bmp->rt_table_in_pre_policy.update_msg_queue)), + "BMP route monitoring update not started yet" + ); + + struct bmp_data_node *upd_msg; + struct bmp_data_node *upd_msg_next; + WALK_LIST_DELSAFE(upd_msg, upd_msg_next, g_bmp->rt_table_in_pre_policy.update_msg_queue) + { + mb_free(upd_msg->data); + rem_node((node *) upd_msg); + mb_free(upd_msg); + } +} + +void +bmp_route_monitor_pre_policy_table_in_snapshot(const struct channel *C) +{ + if (g_bmp->monitoring_rib.in_pre_policy == false) + { + return; + } + + struct rtable *tab = C->in_table; + if (IS_NULL(tab)) + { + return; + } + + size_t cnt = 0; + struct proto *P; + struct fib_iterator fit; + memset(&fit, 0x00, sizeof (fit)); + FIB_ITERATE_INIT(&fit, &tab->fib); + FIB_ITERATE_START(&tab->fib, &fit, net, n) + { + P = n->routes->sender->proto; + if (P->proto->class != PROTOCOL_BGP) + { + continue; + } + + bmp_route_monitor_update_in_pre_begin(); + + rte *e; + for (e = n->routes; e; e = e->next) + { + bgp_rte_update_in_notify(P, C, n, e, NULL, e->src); + } + + bmp_route_monitor_update_in_pre_commit((struct bgp_proto*) P); + bmp_route_monitor_update_in_pre_end(); + ++cnt; + } + FIB_ITERATE_END; + + if (cnt > 0) + { + bmp_route_monitor_update_in_pre_begin(); + byte rx_end_payload[DEFAULT_MEM_BLOCK_SIZE]; + byte *pos + = bgp_create_end_mark((struct bgp_channel *) C, 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); + put_u8(rx_end_payload + BGP_MSG_HDR_TYPE_POS, PKT_UPDATE); + bmp_route_monitor_put_update_in_pre_msg(rx_end_payload, pos - rx_end_payload); + bmp_route_monitor_update_in_pre_commit((struct bgp_proto *) C->proto); + bmp_route_monitor_update_in_pre_end(); + } +} + +static enum bmp_result +bmp_send_peer_down_notif_msg(const struct bgp_proto *bgp, + const byte* data, const size_t data_size) +{ + const struct bgp_caps *remote_caps = bmp_get_bgp_remote_caps_ext(bgp); + bool is_global_instance_peer = bmp_is_peer_global_instance(bgp); + enum bmp_result rc = BMP_E_NONE; + buffer payload + = bmp_buffer_alloc(g_bmp->buffer_mpool, DEFAULT_MEM_BLOCK_SIZE); + bmp_peer_down_notif_msg_serialize(&payload, is_global_instance_peer, + bgp->remote_as, bgp->remote_id, + remote_caps ? remote_caps->as4_support : bgp->as4_session, + bgp->remote_ip, data, data_size); + IF_BMP_FAILED_PRINT_ERR_MSG( + bmp_schedule_tx_packet(bmp_buffer_data(&payload), bmp_buffer_pos(&payload)), + "Failed to schedule packet for transmit" + ); + + bmp_buffer_free(&payload); + return rc; +} + +void +bmp_peer_down(const struct bgp_proto *bgp, const int err_class, const byte *pkt, + size_t pkt_size) +{ + if (IS_NULL(g_bmp) || (!g_bmp->started)) + { + return; + } + + struct bmp_peer_map_key key + = bmp_peer_map_key_create(bgp->remote_ip, bgp->remote_as); + if (!bmp_peer_map_get(&g_bmp->bgp_peers, key)) + { + return; + } + + bmp_peer_map_remove(&g_bmp->peer_open_msg.tx_msg, key); + bmp_peer_map_remove(&g_bmp->peer_open_msg.rx_msg, key); + bmp_peer_map_remove(&g_bmp->bgp_peers, key); + const size_t missing_bgp_hdr_size = BGP_MSG_HDR_MARKER_SIZE + + BGP_MSG_HDR_LENGTH_SIZE + + BGP_MSG_HDR_TYPE_SIZE; + buffer payload + = bmp_buffer_alloc(g_bmp->buffer_mpool, pkt_size + missing_bgp_hdr_size + 1); + if (pkt != NULL && pkt_size > 0) + { + byte marker[BGP_MSG_HDR_MARKER_SIZE]; + memset(marker, 0xff, BGP_MSG_HDR_MARKER_SIZE); // NOTIF MSG marker + if (!memcmp(pkt, marker, BGP_MSG_HDR_MARKER_SIZE)) + { + // So it is received BGP PDU + bmp_put_u8(&payload, BMP_PEER_DOWN_REASON_REMOTE_BGP_NOTIFICATION); + bmp_put_data(&payload, pkt, pkt_size); + } + else + { + bmp_put_u8(&payload, BMP_PEER_DOWN_REASON_LOCAL_BGP_NOTIFICATION); + bmp_put_data(&payload, marker, BGP_MSG_HDR_MARKER_SIZE); + bmp_put_u16(&payload, pkt_size); + bmp_put_u8(&payload, PKT_NOTIFICATION); + bmp_put_data(&payload, pkt, pkt_size); + } + } + else + { + // TODO: Handle De-configured Peer Down Reason Code + if (err_class == BE_SOCKET || err_class == BE_MISC) + { + bmp_put_u8(&payload, BMP_PEER_DOWN_REASON_REMOTE_NO_NOTIFICATION); + } + else + { + bmp_put_u8(&payload, BMP_PEER_DOWN_REASON_LOCAL_NO_NOTIFICATION); + // TODO: Fill in with appropriate FSM event code + bmp_put_u16(&payload, 0x00); // no relevant Event code is defined + } + } + + IF_BMP_FAILED_PRINT_ERR_MSG( + bmp_send_peer_down_notif_msg(bgp, bmp_buffer_data(&payload), + bmp_buffer_pos(&payload)), + "Failed to send PEER DOWN notification" + ); + + bmp_buffer_free(&payload); +} + +static enum bmp_result +bmp_send_termination_msg(struct bmp_proto *bmp, + const enum bmp_term_reason reason) +{ + enum bmp_result rc = BMP_E_NONE; + const size_t term_msg_hdr_size = BMP_TERM_INFO_TYPE_SIZE + + BMP_TERM_INFO_LEN_FIELD_SIZE + + BMP_TERM_REASON_CODE_SIZE; + const size_t term_msg_size = BMP_COMMON_HDR_SIZE + term_msg_hdr_size; + buffer stream + = bmp_buffer_alloc(g_bmp->buffer_mpool, term_msg_size); + bmp_common_hdr_serialize(&stream, BMP_TERM_MSG, term_msg_hdr_size); + bmp_put_u16(&stream, BMP_TERM_INFO_REASON); + bmp_put_u16(&stream, BMP_TERM_REASON_CODE_SIZE); // 2-byte code indication the reason + bmp_put_u16(&stream, reason); + memcpy(bmp->conn->sk->tbuf, bmp_buffer_data(&stream), bmp_buffer_pos(&stream)); + if (sk_send(bmp->conn->sk, bmp_buffer_pos(&stream)) < 0) + { + rc = BMP_E_SEND_DATA; + } + + bmp_buffer_free(&stream); + return rc; +} + +static void +bmp_station_connected(struct birdsock *sk) +{ + struct bmp_conn *conn = (struct bmp_conn *)sk->data; + conn->sk->tx_hook = bmp_tx; + conn->bmp->station_connected = true; + IF_BMP_FAILED_PRINT_ERR_MSG( + bmp_startup(), + "Failed to start BMP protocol" + ); + + bmp_peer_map_walk(&conn->bmp->peer_open_msg.tx_msg, + bmp_peer_map_walk_tx_open_msg_and_send_peer_up_notif); + bmp_peer_map_flush(&conn->bmp->peer_open_msg.tx_msg); + bmp_peer_map_flush(&conn->bmp->peer_open_msg.rx_msg); +} + +static inline void +bmp_setup_socket(struct bmp_conn *conn) +{ + sock *sk = sk_new(proto_pool); + sk->type = SK_TCP_ACTIVE; + sk->ttl = IP4_MAX_TTL; + sk->tos = IP_PREC_INTERNET_CONTROL; + sk->tbsize = BGP_TX_BUFFER_EXT_SIZE; + sk->tx_hook = bmp_station_connected; + + conn->sk = sk; + sk->data = conn; +} + +/** Configuration handle section **/ +static struct proto * +bmp_init(struct proto_config *CF) +{ + struct proto *P = proto_new(CF); + struct bmp_proto *bmp = (struct bmp_proto *) P; + IF_COND_TRUE_PRINT_ERR_MSG_AND_RETURN_OPT_VAL( + (g_bmp != NULL), + "Single BMP protocol instance has been already run", + PS_DOWN + ); + + struct bmp_config *cf = (struct bmp_config *) CF; + bmp->cf = cf; + bmp->station_ip = cf->station_ip; + bmp->station_port = cf->station_port; + strcpy(bmp->sys_descr, cf->sys_descr); + strcpy(bmp->sys_name, cf->sys_name); + bmp->disabled = cf->disabled; + bmp->monitoring_rib.in_pre_policy = cf->monitoring_rib_in_pre_policy; + bmp->monitoring_rib.in_post_policy = cf->monitoring_rib_in_post_policy; + bmp->monitoring_rib.local = cf->monitoring_rib_local; + + g_bmp = bmp; + return P; +} + +static int +bmp_start(struct proto *P) +{ + struct bmp_proto *bmp = (struct bmp_proto *) P; + if (bmp->disabled) + { + g_bmp = NULL; + return PS_DOWN; + } + + if (bmp->disabled) + { + return PS_DOWN; + } + + bmp->conn = mb_allocz(P->pool, sizeof (struct bmp_conn)); + bmp->conn->bmp = bmp; + bmp_setup_socket(bmp->conn); + IF_BMP_FAILED_PRINT_ERR_MSG_AND_RETURN_OPT_VAL( + bmp_open(P), + "Failed to connect to BMP collector", + PS_DOWN + ); + + return PS_UP; +} + +static int +bmp_shutdown(struct proto *P) +{ + struct bmp_proto *bmp = (struct bmp_proto *) P; + IF_BMP_FAILED_PRINT_ERR_MSG( + bmp_send_termination_msg(bmp, BMP_TERM_REASON_ADM), + "Failed to send BMP termination message" + ); + + g_bmp->station_connected = false; + g_bmp->started = false; + g_bmp = NULL; + + return PS_DOWN; +} + +static int +bmp_reconfigure(struct proto *P UNUSED, struct proto_config *CF UNUSED) +{ + log(L_WARN "Reconfiguring BMP is not supported"); + return PS_UP; +} + +struct protocol proto_bmp = { + .name = "BMP", + .class = PROTOCOL_BMP, + .proto_size = sizeof(struct bmp_proto), + .config_size = sizeof(struct bmp_config), + .init = bmp_init, + .start = bmp_start, + .shutdown = bmp_shutdown, + .reconfigure = bmp_reconfigure, +}; + +void +bmp_build(void) +{ + proto_build(&proto_bmp); +} diff --git a/proto/bmp/bmp.h b/proto/bmp/bmp.h new file mode 100644 index 00000000..03c5f529 --- /dev/null +++ b/proto/bmp/bmp.h @@ -0,0 +1,152 @@ +/* + * BIRD -- The BGP Monitoring Protocol (BMP) + * + * (c) 2020 Akamai Technologies, Inc. (Pawel Maslanka, pmaslank@akamai.com) + * + * Can be freely distributed and used under the terms of the GNU GPL. + */ + +#ifndef _BIRD_BMP_H_ +#define _BIRD_BMP_H_ + +#include "nest/bird.h" +#include "nest/protocol.h" +#include "lib/lists.h" +#include "nest/route.h" +#include "lib/event.h" +#include "lib/hash.h" +#include "lib/socket.h" +#include "proto/bmp/map.h" + +#include + +// Max length of MIB-II description object +#define MIB_II_STR_LEN 255 + +enum bmp_peer_down { + // Value of packet size of 'pkt_size' argument of bmp_peer_down() function + // used for pointing out that there was not any packet to pass + BMP_PEER_DOWN_NULL_PKT_SIZE = 0 +}; + +// The following fields of this structure controls whether there will be put +// specific routes into Route Monitoring message and send to BMP collector +struct monitoring_rib { + bool in_pre_policy; // Monitoring pre-policy Adj-Rib-In + bool in_post_policy; // Monitoring post-policy Adj-Rib-In + bool local; // Monitoring Local Rib +}; + +struct bmp_config { + struct proto_config c; + char *sys_descr; // sysDescr MIB-II [RFC1213] object + char *sys_name; // sysName MIB-II [RFC1213] object + ip_addr station_ip; // Monitoring station address + u16 station_port; // Monitoring station TCP port + bool disabled; // Manually disabled + bool monitoring_rib_in_pre_policy; // Route monitoring pre-policy Adj-Rib-In + bool monitoring_rib_in_post_policy; // Route monitoring post-policy Adj-Rib-In + bool monitoring_rib_local; // Route monitoring Local Rib +}; + +/* Forward declarations */ +struct bgp_proto; +struct bmp_proto; + +struct bmp_conn { + struct bmp_proto *bmp; + struct birdsock *sk; + event *tx_ev; +}; + +// Stores sent and received BGP OPEN MSGs +struct bmp_peer_open_msg { + struct bmp_peer_map tx_msg; + struct bmp_peer_map rx_msg; +}; + +// Keeps necessary information during composing BGP UPDATE MSG which is going +// to be sent to the BMP collector +struct rt_table_info { + list update_msg_queue; // Stores all composed BGP UPDATE MSGs + size_t update_msg_size; // Size of all BGP UPDATE MSGs + struct timeval update_begin_time; // Keeps timestamp of starting BGP UPDATE MSGs composing + bool update_in_progress; // Holds information whether composing process is still in progress +}; + +struct bmp_proto { + struct proto p; // Parent proto + const struct bmp_config *cf; // Shortcut to BMP configuration + struct bmp_conn *conn; // Connection we have established + char sys_descr[MIB_II_STR_LEN]; // sysDescr MIB-II [RFC1213] object + char sys_name[MIB_II_STR_LEN]; // sysName MIB-II [RFC1213] object + ip_addr station_ip; // Monitoring station IP address + u16 station_port; // Monitoring station TCP port + bool disabled; // Manually disabled + struct monitoring_rib monitoring_rib; + // Below fields are for internal use + int station_socket; // Socket associated with the BMP collector + struct bmp_peer_map bgp_peers; // Stores 'bgp_proto' structure per BGP peer + struct bmp_peer_open_msg peer_open_msg; // Stores sent and received BGP OPEN MSG per BGP peer + pool *buffer_mpool; // Memory pool used for BMP buffer allocations + pool *map_mem_pool; // Memory pool used for BMP map allocations + pool *tx_mem_pool; // Memory pool used for packet allocations designated to BMP collector + pool *update_msg_mem_pool; // Memory pool used for BPG UPDATE MSG allocations + list tx_queue; // Stores queued packets going to be sent + timer *connect_retry_timer; // Timer for retrying connection to the BMP collector + struct rt_table_info rt_table_in_pre_policy; // Pre-policy route import table + bool station_connected; // Flag that stores connection status with BMP station + bool started; // Flag that stores running status of BMP instance +}; + +/** + * bmp_put_sent_bgp_open_msg - save sent BGP OPEN msg packet in BMP implementation. + * NOTE: If there has been passed sent and received BGP OPEN MSGs to the BMP + * implementation, then there is going to be send BMP Peer Up Notification + * message to the BMP collector. + */ +void +bmp_put_sent_bgp_open_msg(const struct bgp_proto *bgp, const byte* pkt, + const size_t pkt_size); + +/** + * bmp_put_recv_bgp_open_msg - save received BGP OPEN msg packet in BMP implementation. + * NOTE: If there has been passed sent and received BGP OPEN MSGs to the BMP + * implementation, then there is going to be send BMP Peer Up Notification + * message to the BMP collector. + */ +void +bmp_put_recv_bgp_open_msg(const struct bgp_proto *bgp, const byte* pkt, + const size_t pkt_size); + +/** + * The following 4 functions create BMP Route Monitoring message based on + * pre-policy Adj-RIB-In. Composing Route Monitoring message consist of few + * stages. First of all call bmp_route_monitor_update_in_pre_begin() in order + * to start composing message. As a second step, call + * bmp_route_monitor_put_update_in_pre_msg() in order to save BGP UPDATE msg. + * As a third step call bmp_route_monitor_update_in_pre_commit() in order to + * send BMP Route Monitoring message to the BMP collector. As a last step, + * call bmp_route_monitor_update_in_pre_end() in order to release resources. + */ +void +bmp_route_monitor_update_in_pre_begin(void); + +void +bmp_route_monitor_put_update_in_pre_msg(const byte *data, const size_t data_size); + +void +bmp_route_monitor_update_in_pre_commit(const struct bgp_proto *bgp); + +void +bmp_route_monitor_update_in_pre_end(void); + +/** + * bmp_peer_down - send notification that BGP peer connection is not in + * established state + */ +void +bmp_peer_down(const struct bgp_proto *bgp, const int err_class, const byte *pkt, + size_t pkt_size); + +#endif /* _BIRD_BMP_H_ */ diff --git a/proto/bmp/buffer.c b/proto/bmp/buffer.c new file mode 100644 index 00000000..f471e08a --- /dev/null +++ b/proto/bmp/buffer.c @@ -0,0 +1,58 @@ +/* + * BIRD -- The BGP Monitoring Protocol (BMP) + * + * (c) 2020 Akamai Technologies, Inc. (Pawel Maslanka, pmaslank@akamai.com) + * + * Can be freely distributed and used under the terms of the GNU GPL. + */ + +#include "proto/bmp/buffer.h" + +buffer +bmp_buffer_alloc(pool *ppool, const size_t n) +{ + buffer buf; + buf.start = mb_alloc(ppool, n); + buf.pos = buf.start; + buf.end = buf.start + n; + + return buf; +} + +void +bmp_buffer_free(buffer *buf) +{ + mb_free(buf->start); + buf->start = buf->pos = buf->end = NULL; +} + +static void +bmp_buffer_grow(buffer *buf, const size_t n) +{ + const size_t pos = bmp_buffer_pos(buf); + buf->start = mb_realloc(buf->start, n); + buf->pos = buf->start + pos; + buf->end = buf->start + n; +} + +void +bmp_buffer_need(buffer *buf, const size_t n) +{ + if (bmp_buffer_avail(buf) < n) + { + bmp_buffer_grow(buf, n); + } +} + +void +bmp_put_data(buffer *buf, const void *src, const size_t n) +{ + if (!n) + { + return; + } + + bmp_buffer_need(buf, n); + memcpy(buf->pos, src, n); + buf->pos += n; +} \ No newline at end of file diff --git a/proto/bmp/buffer.h b/proto/bmp/buffer.h new file mode 100644 index 00000000..07eb4e9c --- /dev/null +++ b/proto/bmp/buffer.h @@ -0,0 +1,78 @@ +/* + * BIRD -- The BGP Monitoring Protocol (BMP) + * + * (c) 2020 Akamai Technologies, Inc. (Pawel Maslanka, pmaslank@akamai.com) + * + * Can be freely distributed and used under the terms of the GNU GPL. + */ + +#ifndef _BIRD_BMP_BUFFER_H_ +#define _BIRD_BMP_BUFFER_H_ + +#include "proto/bmp/bmp.h" +#include "proto/bmp/utils.h" + +#include + +#include "lib/resource.h" + +buffer +bmp_buffer_alloc(pool *ppool, const size_t n); + +void +bmp_buffer_free(buffer *buf); + +static inline void +bmp_buffer_flush(buffer *buf) +{ + buf->pos = buf->start; +} + +static inline size_t +bmp_buffer_size(const buffer *buf) +{ + return buf->end - buf->start; +} + +static inline size_t +bmp_buffer_avail(const buffer *buf) +{ + return buf->end - buf->pos; +} + +static inline size_t +bmp_buffer_pos(const buffer *buf) +{ + return buf->pos - buf->start; +} + +static inline byte * +bmp_buffer_data(const buffer *buf) +{ + return buf->start; +} + +void +bmp_buffer_need(buffer *buf, const size_t n); + +// Idea for following macros has been taken from |proto/mrt/mrt.c| +#define BMP_DEFINE_PUT_FUNC(S, T) \ + static inline void \ + bmp_put_##S(buffer *b, const T x) \ + { \ + bmp_buffer_need(b, sizeof(T)); \ + put_##S(b->pos, x); \ + b->pos += sizeof(T); \ + } + +BMP_DEFINE_PUT_FUNC(u8, u8) +BMP_DEFINE_PUT_FUNC(u16, u16) +BMP_DEFINE_PUT_FUNC(u32, u32) +BMP_DEFINE_PUT_FUNC(u64, u64) +BMP_DEFINE_PUT_FUNC(ip4, ip4_addr) +BMP_DEFINE_PUT_FUNC(ip6, ip6_addr) + +void +bmp_put_data(buffer *buf, const void *src, const size_t n); + +#endif /* _BIRD_BMP_BUFFER_H_ */ \ No newline at end of file diff --git a/proto/bmp/config.Y b/proto/bmp/config.Y new file mode 100644 index 00000000..df7822ea --- /dev/null +++ b/proto/bmp/config.Y @@ -0,0 +1,90 @@ +/* + * BIRD -- The BGP Monitoring Protocol (BMP) + * + * (c) 2020 Akamai Technologies, Inc. (Pawel Maslanka, pmaslank@akamai.com) + * + * Can be freely distributed and used under the terms of the GNU GPL. + */ + +CF_HDR + +#include "proto/bmp/bmp.h" + +CF_DEFINES + +#define BMP_CFG ((struct bmp_config *) this_proto) + +CF_DECLS + +CF_KEYWORDS(BMP, DESCRIPTION, ENABLED, IN, IP, MONITORING, NAME, PORT, + PRE_POLICY, POST_POLICY, RIB, STATION, SYSTEM) + +CF_GRAMMAR + +proto: bmp_proto '}' ; + +bmp_proto_start: proto_start BMP { + this_proto = proto_config_new(&proto_bmp, $1); + BMP_CFG->disabled = false; + BMP_CFG->station_ip = IPA_NONE4; + BMP_CFG->station_port = 0; + BMP_CFG->sys_descr = "Not defined"; + BMP_CFG->sys_name = "Not defined"; + BMP_CFG->monitoring_rib_in_pre_policy = false; + BMP_CFG->monitoring_rib_in_post_policy = false; + BMP_CFG->monitoring_rib_local = false; + } + ; + +bmp_station_address: + /* empty */ + | bmp_station_address IP ipa { + if (!BMP_CFG->disabled) + if (ipa_zero($3)) + cf_error("Invalid BMP monitoring station IP address"); + BMP_CFG->station_ip = $3; + } + | bmp_station_address PORT expr { + if (($3 < 1) || ($3 > 65535)) + cf_error("Invalid BMP monitoring station port number"); + BMP_CFG->station_port = $3; + } + ; + +bmp_proto: + bmp_proto_start proto_name '{' + | bmp_proto proto_item ';' + | bmp_proto ENABLED bool ';' { + BMP_CFG->disabled = $3; + } + | bmp_proto STATION ADDRESS bmp_station_address ';' + | bmp_proto SYSTEM DESCRIPTION text ';' { + if (!$4 || (strlen($4) == 0)) + cf_error("String is empty"); + else if (strlen($4) > 255) + cf_error("Invalid string length"); + BMP_CFG->sys_descr = $4; + } + | bmp_proto SYSTEM NAME text ';' { + if (!$4 || (strlen($4) == 0)) + cf_error("String is empty"); + else if (strlen($4) > 255) + cf_error("Invalid string length"); + BMP_CFG->sys_name = $4; + } + | bmp_proto MONITORING RIB IN PRE_POLICY bool ';' { + BMP_CFG->monitoring_rib_in_pre_policy = $6; + } + | bmp_proto MONITORING RIB IN POST_POLICY bool ';' { + BMP_CFG->monitoring_rib_in_post_policy = $6; + } + | bmp_proto MONITORING RIB LOCAL bool ';' { + BMP_CFG->monitoring_rib_local = $5; + } + | bmp_proto DISABLED bool ';' { + BMP_CFG->disabled = $3; } + ; + +CF_CODE + +CF_END diff --git a/proto/bmp/map.c b/proto/bmp/map.c new file mode 100644 index 00000000..e9a37266 --- /dev/null +++ b/proto/bmp/map.c @@ -0,0 +1,155 @@ +/* + * BIRD -- The BGP Monitoring Protocol (BMP) + * + * (c) 2020 Akamai Technologies, Inc. (Pawel Maslanka, pmaslank@akamai.com) + * + * Can be freely distributed and used under the terms of the GNU GPL. + */ + +#include "proto/bmp/map.h" +#include "proto/bmp/utils.h" + +/* Peer Index Table */ +#define PEER_KEY(n) (n)->peer_as, (n)->peer_ip +#define PEER_NEXT(n) (n)->next +#define PEER_EQ(as1,ip1,as2,ip2) \ + (as1) == (as2) && ipa_equal(ip1, ip2) +#define PEER_FN(as,ip) ipa_hash(ip) + +#define PEER_REHASH bmp_peer_rehash +#define PEER_PARAMS /8, *2, 2, 2, 6, 20 + +HASH_DEFINE_REHASH_FN(PEER, struct bmp_peer_map_key) + +#define PEER_INIT_ORDER 6 + +enum bmp_result +bmp_peer_map_init(struct bmp_peer_map *map, pool *mpool) +{ + if (IS_NULL(map) || IS_NULL(mpool)) + { + return BMP_E_NULL_REF; + } + + map->mpool = mpool; + HASH_INIT(map->peer_hash, map->mpool, PEER_INIT_ORDER); + + return BMP_E_NONE; +} + +struct bmp_peer_map_key +bmp_peer_map_key_create(const ip_addr peer_ip, const u32 peer_as) +{ + struct bmp_peer_map_key key; + key.next = NULL; + key.peer_ip = peer_ip; + key.peer_as = peer_as; + + return key; +} + +enum bmp_result +bmp_peer_map_flush(struct bmp_peer_map *map) +{ + if (IS_NULL(map)) + { + return BMP_E_NULL_REF; + } + + struct bmp_peer_map_entry *entry; + HASH_WALK_DELSAFE(map->peer_hash, next, e) + { + entry = (struct bmp_peer_map_entry *) e; + mb_free(entry->data.buf); + HASH_DELETE(map->peer_hash, PEER, PEER_KEY(&entry->key)); + mb_free(entry); + } + HASH_WALK_DELSAFE_END; + + HASH_MAY_RESIZE_DOWN(map->peer_hash, PEER, map->mpool); + return BMP_E_NONE; +} + +enum bmp_result +bmp_peer_map_free(struct bmp_peer_map *map) +{ + if (IS_NULL(map)) + { + return BMP_E_NULL_REF; + } + + IF_BMP_FAILED_RETURN_RC(bmp_peer_map_flush(map)); + HASH_FREE(map->peer_hash); + + return BMP_E_NONE; +} + +enum bmp_result +bmp_peer_map_insert(struct bmp_peer_map *map, const struct bmp_peer_map_key key, + const byte *data, const size_t data_size) +{ + if (IS_NULL(map)) + { + return BMP_E_NULL_REF; + } + + if (HASH_FIND(map->peer_hash, PEER, PEER_KEY(&key))) + { + return BMP_E_EXISTS; + } + + struct bmp_peer_map_entry *entry = mb_alloc(map->mpool, + sizeof (struct bmp_peer_map_entry)); + entry->data.buf = mb_alloc(map->mpool, data_size); + memcpy(entry->data.buf, data, data_size); + entry->data.buf_size = data_size; + entry->key = key; + HASH_INSERT2(map->peer_hash, PEER, map->mpool, &entry->key); + + return BMP_E_NONE; +} + +enum bmp_result +bmp_peer_map_remove(struct bmp_peer_map *map, const struct bmp_peer_map_key key) +{ + if (IS_NULL(map)) + { + return BMP_E_NULL_REF; + } + + struct bmp_peer_map_entry *entry + = (struct bmp_peer_map_entry *) HASH_FIND(map->peer_hash, PEER, PEER_KEY(&key)); + if (IS_NULL(entry)) + { + return BMP_E_NOT_EXISTS; + } + + mb_free(entry->data.buf); + HASH_DELETE(map->peer_hash, PEER, PEER_KEY(&entry->key)); + mb_free(entry); + + return BMP_E_NONE; +} + +const struct bmp_peer_map_entry * +bmp_peer_map_get(struct bmp_peer_map *map, const struct bmp_peer_map_key key) +{ + if (IS_NULL(map)) + { + return NULL; + } + + return (struct bmp_peer_map_entry *) HASH_FIND(map->peer_hash, PEER, PEER_KEY(&key)); +} + +void +bmp_peer_map_walk(const struct bmp_peer_map *map, bmp_peer_map_walk_action action) +{ + struct bmp_peer_map_entry *entry; + HASH_WALK_FILTER(map->peer_hash, next, e, _) + { + entry = (struct bmp_peer_map_entry *) e; + action(entry->key, entry->data.buf, entry->data.buf_size); + } + HASH_WALK_FILTER_END; +} diff --git a/proto/bmp/map.h b/proto/bmp/map.h new file mode 100644 index 00000000..e9d5798e --- /dev/null +++ b/proto/bmp/map.h @@ -0,0 +1,70 @@ +/* + * BIRD -- The BGP Monitoring Protocol (BMP) + * + * (c) 2020 Akamai Technologies, Inc. (Pawel Maslanka, pmaslank@akamai.com) + * + * Can be freely distributed and used under the terms of the GNU GPL. + */ + +/** + * This map implementation binds peer IP address as container key with custom data. + */ +#ifndef _BIRD_BMP_MAP_H_ +#define _BIRD_BMP_MAP_H_ + +#include "nest/bird.h" +#include "lib/hash.h" +#include "lib/resource.h" + +#include "proto/bmp/utils.h" + +struct bmp_peer_map_key { + struct bmp_peer_map_key *next; + ip_addr peer_ip; + u32 peer_as; +}; + +struct bmp_peer_map_data { + void *buf; + size_t buf_size; +}; + +struct bmp_peer_map_entry { + struct bmp_peer_map_key key; + struct bmp_peer_map_data data; +}; + +struct bmp_peer_map { + pool *mpool; // Memory pool for peer entries in peer_hash + HASH(struct bmp_peer_map_key) peer_hash; // Hash for peers to find the index +}; + +enum bmp_result +bmp_peer_map_init(struct bmp_peer_map *map, pool *mpool); + +struct bmp_peer_map_key +bmp_peer_map_key_create(const ip_addr peer_ip, const u32 peer_as); + +enum bmp_result +bmp_peer_map_free(struct bmp_peer_map *map); + +enum bmp_result +bmp_peer_map_flush(struct bmp_peer_map *map); + +enum bmp_result +bmp_peer_map_insert(struct bmp_peer_map *map, const struct bmp_peer_map_key key, + const byte *data, const size_t data_size); + +enum bmp_result +bmp_peer_map_remove(struct bmp_peer_map *map, const struct bmp_peer_map_key key); + +const struct bmp_peer_map_entry * +bmp_peer_map_get(struct bmp_peer_map *map, const struct bmp_peer_map_key key); + +typedef void (*bmp_peer_map_walk_action)(const struct bmp_peer_map_key key, + const byte *data, const size_t data_size); + +void +bmp_peer_map_walk(const struct bmp_peer_map *map, bmp_peer_map_walk_action action); + +#endif /* _BIRD_BMP_MAP_H_ */ diff --git a/proto/bmp/utils.h b/proto/bmp/utils.h new file mode 100644 index 00000000..faca2ba0 --- /dev/null +++ b/proto/bmp/utils.h @@ -0,0 +1,94 @@ +/* + * BIRD -- The BGP Monitoring Protocol (BMP) + * + * (c) 2020 Akamai Technologies, Inc. (Pawel Maslanka, pmaslank@akamai.com) + * + * Can be freely distributed and used under the terms of the GNU GPL. + */ + +#ifndef _BIRD_BMP_UTILS_H_ +#define _BIRD_BMP_UTILS_H_ + +/** + * TODO: + * - Provide descriptive explanation for the follwing enums + */ +enum bmp_result { + BMP_E_NONE = 0, + BMP_E_INVALID_ARG, + BMP_E_NULL_REF, + BMP_E_EXISTS, + BMP_E_NOT_EXISTS, + BMP_E_OPEN_SOCKET, + BMP_E_CONNECT_TO_SRV, + BMP_E_SEND_DATA, + BMP_E_BIRDSOCK_NULL_REF, + BMP_E_REMOTE_CAPS_NULL_REF, + BMP_E_NEW_TX_EVENT +}; + +#define BMP_FAILED(v) \ + (v != BMP_E_NONE) + +#define IF_BMP_FAILED_RETURN_RC(func) \ + do { \ + enum bmp_result rc = func; \ + if (BMP_FAILED(rc)) \ + { \ + return rc; \ + } \ + } while (0) + +// The following macro requires to define locally enum bmp_result rc; +#define IF_BMP_FAILED_GOTO_LABEL(func, label) \ + do { \ + rc = func; \ + if (BMP_FAILED(rc)) \ + { \ + goto label; \ + } \ + } while (0) + +#define IF_BMP_FAILED_PRINT_ERR_MSG(func, msg) \ + do { \ + enum bmp_result rc = func; \ + if (BMP_FAILED(rc)) \ + { \ + log(L_WARN "[BMP] " msg " (rc = %d)", rc); \ + } \ + } while (0) + +#define IF_BMP_FAILED_PRINT_ERR_MSG_AND_GOTO_LABEL(func, msg, label) \ + do { \ + enum bmp_result rc = func; \ + if (BMP_FAILED(rc)) \ + { \ + log(L_WARN "[BMP] " msg " (rc = %d)", rc); \ + goto label; \ + } \ + } while (0) + +#define IS_NULL(ptr) \ + ((ptr) == NULL) + +#define IF_COND_TRUE_PRINT_ERR_MSG_AND_RETURN_OPT_VAL(expr, msg, rv...) \ + do { \ + if ((expr)) \ + { \ + log(L_WARN "[BMP] " msg); \ + return rv; \ + } \ + } while (0) + +#define IF_PTR_IS_NULL_PRINT_ERR_MSG_AND_RETURN_OPT_VAL(p, msg, rv...) \ + do { \ + IF_COND_TRUE_PRINT_ERR_MSG_AND_RETURN_OPT_VAL(IS_NULL(p), msg, rv); \ + } while (0) + +#define IF_BMP_FAILED_PRINT_ERR_MSG_AND_RETURN_OPT_VAL(func, msg, rv...) \ + do { \ + enum bmp_result rc = func; \ + IF_COND_TRUE_PRINT_ERR_MSG_AND_RETURN_OPT_VAL(BMP_FAILED(rc), msg, rv); \ + } while (0) + +#endif /* _BIRD_BMP_UTILS_H_ */ \ No newline at end of file