summaryrefslogtreecommitdiff
path: root/proto
diff options
context:
space:
mode:
Diffstat (limited to 'proto')
-rw-r--r--proto/Doc1
-rw-r--r--proto/bgp/attrs.c7
-rw-r--r--proto/bgp/bgp.c11
-rw-r--r--proto/bgp/bgp.h14
-rw-r--r--proto/bgp/packets.c352
-rw-r--r--proto/bmp/Doc1
-rw-r--r--proto/bmp/LICENSE2
-rw-r--r--proto/bmp/Makefile6
-rw-r--r--proto/bmp/README.txt6
-rw-r--r--proto/bmp/bmp.c1279
-rw-r--r--proto/bmp/bmp.h152
-rw-r--r--proto/bmp/buffer.c58
-rw-r--r--proto/bmp/buffer.h78
-rw-r--r--proto/bmp/config.Y90
-rw-r--r--proto/bmp/map.c155
-rw-r--r--proto/bmp/map.h70
-rw-r--r--proto/bmp/utils.h94
17 files changed, 2374 insertions, 2 deletions
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)
{
@@ -2385,6 +2606,122 @@ bgp_create_mp_unreach(struct bgp_write_state *s, struct bgp_bucket *buck, byte *
}
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)
{
struct bgp_proto *p = (void *) c->c.proto;
@@ -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 <sys/socket.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <netinet/in.h>
+#include <netdb.h>
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+#include <arpa/inet.h>
+#include <limits.h>
+
+#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 <stdbool.h>
+
+// 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 <stdlib.h>
+
+#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
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-23 13:45:22 +0000