diff --git a/configure.ac b/configure.ac
index d73eec28..c9c52038 100644
--- a/configure.ac
+++ b/configure.ac
@@ -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/doc/bird.sgml b/doc/bird.sgml
index 557140b8..39eae4cd 100644
--- a/doc/bird.sgml
+++ b/doc/bird.sgml
@@ -3268,6 +3268,35 @@ protocol bgp {
 </code>
 
 
+<sect>BMP
+<label id="bmp">
+
+<p>The BGP Monitoring Protocol is used for monitoring BGP sessions and obtaining
+routing table data. The current implementation in BIRD is a preliminary release
+with a limited feature set, it will be subject to significant changes in the
+future. It is not ready for production usage and therefore it is not compiled
+by default and have to be enabled during installation by the configure option
+<tt/--with-protocols=/.
+
+<p>The implementation is limited to monitor protocol state changes and routes
+in <ref id="bgp-import-table" name="BGP import tables"> (not regular routing
+tables), therefore import table must be enabled in BGP protocols. All BGP
+protocols are monitored automatically.
+
+<sect1>Example
+<label id="bmp-exam">
+
+<p><code>
+protocol bmp {
+	# The monitoring station to connect to
+	station address ip 198.51.100.10 port 1790;
+
+	# required option
+	monitoring rib in pre_policy;
+}
+</code>
+
+
 <sect>Device
 <label id="device">
 
diff --git a/nest/protocol.h b/nest/protocol.h
index fcbf0539..da6d434e 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,7 @@ 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)(struct channel *, const net_addr *, const struct rte *, const struct rte_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..2b065032 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, n, old, src);
+
 	  return 1;
 	}
 
@@ -3121,6 +3125,9 @@ rte_update_in(struct channel *c, const net_addr *n, rte *new, struct rte_src *sr
     if (!net->routes)
       fib_delete(&tab->fib, net);
 
+    if (c->proto->rte_update_in_notify)
+      c->proto->rte_update_in_notify(c, n, NULL, src);
+
     return 1;
   }
 
@@ -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, n, e, 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..c806765a 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, 0);
+  }
 }
 
 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, 0);
+  }
 
   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, 0);
     }
   }
   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, 0);
     }
   }
   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, 0);
     }
   }
 }
@@ -1695,6 +1705,10 @@ bgp_init(struct proto_config *CF)
   P->rte_modify = bgp_rte_modify_stale;
   P->rte_igp_metric = bgp_rte_igp_metric;
 
+#ifdef CONFIG_BMP
+  P->rte_update_in_notify = bgp_rte_update_in_notify;
+#endif
+
   p->cf = cf;
   p->is_internal = (cf->local_as == cf->remote_as);
   p->is_interior = p->is_internal || cf->confederation_member;
diff --git a/proto/bgp/bgp.h b/proto/bgp/bgp.h
index 302f58e7..7c96e851 100644
--- a/proto/bgp/bgp.h
+++ b/proto/bgp/bgp.h
@@ -434,6 +434,7 @@ struct bgp_write_state {
   int as4_session;
   int add_path;
   int mpls;
+  int sham;
 
   eattr *mp_next_hop;
   const adata *mpls_labels;
@@ -496,6 +497,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 +550,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 +625,7 @@ 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(struct channel *C, const net_addr *n, const struct rte *new, 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 +659,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 */
 
diff --git a/proto/bgp/packets.c b/proto/bgp/packets.c
index 5c17c370..b9537169 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);
 }
 
 
@@ -1563,7 +1566,10 @@ bgp_encode_nlri_ip4(struct bgp_write_state *s, struct bgp_bucket *buck, byte *bu
     memcpy(pos, &a, b);
     ADVANCE(pos, size, b);
 
-    bgp_free_prefix(s->channel, px);
+    if (!s->sham)
+      bgp_free_prefix(s->channel, px);
+    else
+      rem_node(&px->buck_node);
   }
 
   return pos - buf;
@@ -1648,7 +1654,10 @@ bgp_encode_nlri_ip6(struct bgp_write_state *s, struct bgp_bucket *buck, byte *bu
     memcpy(pos, &a, b);
     ADVANCE(pos, size, b);
 
-    bgp_free_prefix(s->channel, px);
+    if (!s->sham)
+      bgp_free_prefix(s->channel, px);
+    else
+      rem_node(&px->buck_node);
   }
 
   return pos - buf;
@@ -1736,7 +1745,10 @@ bgp_encode_nlri_vpn4(struct bgp_write_state *s, struct bgp_bucket *buck, byte *b
     memcpy(pos, &a, b);
     ADVANCE(pos, size, b);
 
-    bgp_free_prefix(s->channel, px);
+    if (!s->sham)
+      bgp_free_prefix(s->channel, px);
+    else
+      rem_node(&px->buck_node);
   }
 
   return pos - buf;
@@ -1833,7 +1845,10 @@ bgp_encode_nlri_vpn6(struct bgp_write_state *s, struct bgp_bucket *buck, byte *b
     memcpy(pos, &a, b);
     ADVANCE(pos, size, b);
 
-    bgp_free_prefix(s->channel, px);
+    if (!s->sham)
+      bgp_free_prefix(s->channel, px);
+    else
+      rem_node(&px->buck_node);
   }
 
   return pos - buf;
@@ -1920,7 +1935,10 @@ bgp_encode_nlri_flow4(struct bgp_write_state *s, struct bgp_bucket *buck, byte *
     memcpy(pos, net->data, flen);
     ADVANCE(pos, size, flen);
 
-    bgp_free_prefix(s->channel, px);
+    if (!s->sham)
+      bgp_free_prefix(s->channel, px);
+    else
+      rem_node(&px->buck_node);
   }
 
   return pos - buf;
@@ -2012,7 +2030,10 @@ bgp_encode_nlri_flow6(struct bgp_write_state *s, struct bgp_bucket *buck, byte *
     memcpy(pos, net->data, flen);
     ADVANCE(pos, size, flen);
 
-    bgp_free_prefix(s->channel, px);
+    if (!s->sham)
+      bgp_free_prefix(s->channel, px);
+    else
+      rem_node(&px->buck_node);
   }
 
   return pos - buf;
@@ -2256,7 +2277,8 @@ bgp_create_ip_reach(struct bgp_write_state *s, struct bgp_bucket *buck, byte *bu
   if (la < 0)
   {
     /* Attribute list too long */
-    bgp_withdraw_bucket(s->channel, buck);
+    if (!s->sham)
+      bgp_withdraw_bucket(s->channel, buck);
     return NULL;
   }
 
@@ -2303,7 +2325,8 @@ bgp_create_mp_reach(struct bgp_write_state *s, struct bgp_bucket *buck, byte *bu
   if (la < 0)
   {
     /* Attribute list too long */
-    bgp_withdraw_bucket(s->channel, buck);
+    if (!s->sham)
+      bgp_withdraw_bucket(s->channel, buck);
     return NULL;
   }
 
@@ -2384,6 +2407,94 @@ bgp_create_mp_unreach(struct bgp_write_state *s, struct bgp_bucket *buck, byte *
   return buf+11+len;
 }
 
+
+#ifdef CONFIG_BMP
+
+static byte *
+bgp_create_update_bmp(struct bgp_channel *c, byte *buf, struct bgp_bucket *buck, bool update)
+{
+  struct bgp_proto *p = (void *) c->c.proto;
+  byte *end = buf + (BGP_MAX_EXT_MSG_LENGTH - BGP_HEADER_LENGTH);
+  /* FIXME: must be a bit shorter */
+
+  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 = (c->afi != BGP_AF_IPV4) || rem->ext_next_hop,
+    .as4_session = 1,
+    .add_path = c->add_path_rx,
+    .mpls = c->desc->mpls,
+    .sham = 1,
+  };
+
+  if (!update)
+  {
+    return !s.mp_reach ?
+      bgp_create_ip_unreach(&s, buck, buf, end):
+      bgp_create_mp_unreach(&s, buck, buf, end);
+  }
+  else
+  {
+    return !s.mp_reach ?
+      bgp_create_ip_reach(&s, buck, buf, end):
+      bgp_create_mp_reach(&s, buck, buf, end);
+  }
+}
+
+static byte *
+bgp_bmp_prepare_bgp_hdr(byte *buf, const u16 msg_size, const u8 msg_type)
+{
+  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;
+}
+
+void
+bgp_rte_update_in_notify(struct channel *C, const net_addr *n,
+			 const struct rte *new, const struct rte_src *src)
+{
+//  struct bgp_proto *p = (void *) C->proto;
+  struct bgp_channel *c = (void *) C;
+
+  byte buf[BGP_MAX_EXT_MSG_LENGTH];
+  byte *pkt = buf + BGP_HEADER_LENGTH;
+
+  ea_list *attrs = new ? new->attrs->eattrs : NULL;
+  uint ea_size = new ? (sizeof(ea_list) + attrs->count * sizeof(eattr)) : 0;
+  uint bucket_size = sizeof(struct bgp_bucket) + ea_size;
+  uint prefix_size = sizeof(struct bgp_prefix) + n->length;
+
+  /* Sham bucket */
+  struct bgp_bucket *b = alloca(bucket_size);
+  *b = (struct bgp_bucket) { };
+  init_list(&b->prefixes);
+
+  if (attrs)
+    memcpy(b->eattrs, attrs, ea_size);
+
+  /* Sham prefix */
+  struct bgp_prefix *px = alloca(prefix_size);
+  *px = (struct bgp_prefix) { };
+  px->path_id = src->private_id;
+  net_copy(px->net, n);
+  add_tail(&b->prefixes, &px->buck_node);
+
+  byte *end = bgp_create_update_bmp(c, pkt, b, !!new);
+  if (!end)
+    return;
+
+  bgp_bmp_prepare_bgp_hdr(buf, end - buf, PKT_UPDATE);
+  bmp_route_monitor_put_update_in_pre_msg(buf, end - buf);
+}
+
+#endif /* CONFIG_BMP */
+
+
 static byte *
 bgp_create_update(struct bgp_channel *c, byte *buf)
 {
@@ -2484,7 +2595,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 +2746,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 +2778,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 +3032,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 +3336,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..f04b59b8
--- /dev/null
+++ b/proto/bmp/bmp.c
@@ -0,0 +1,1168 @@
+/*
+ *	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
+ *
+ * The BMP session is managed by a simple state machine with three states: Idle
+ * (!started, !sk), Connect (!started, sk active), and Established (started). It
+ * has three events: connect successfull (Connect -> Established), socket error
+ * (any -> Idle), and connect timeout (Idle/Connect -> Connect, resetting the
+ * TCP socket).
+ */
+
+#include "proto/bmp/bmp.h"
+#include "proto/bmp/buffer.h"
+#include "proto/bmp/map.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
+
+// Initial delay for connection to the BMP collector
+#define CONNECT_INIT_TIME (200 MS)
+
+// Timeout for connection to the BMP collector retry
+#define CONNECT_RETRY_TIME (10 S)
+
+#define IP4_MAX_TTL 255
+
+
+#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(!(p), msg, rv);	\
+  } while (0)
+
+
+static void bmp_connected(struct birdsock *sk);
+static void bmp_sock_err(sock *sk, int err);
+static void bmp_close_socket(struct bmp_proto *p);
+
+static void
+bmp_send_peer_up_notif_msg(struct bmp_proto *p, const struct bgp_proto *bgp,
+  const byte* tx_data, const size_t tx_data_size,
+  const byte* rx_data, const size_t rx_data_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(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 void
+bmp_info_tlv_hdr_serialize(buffer *stream, const enum bmp_info_tlv_type type,
+  const char *str)
+{
+  size_t str_len = strlen(str);
+  str_len = MIN(str_len, 65535);
+
+  bmp_put_u16(stream, type);
+  bmp_put_u16(stream, str_len);
+  bmp_put_data(stream, str, str_len);
+}
+
+// Serializes BMP Initiation message header [RFC 7854 - Section 4.3]
+static void
+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);
+  bmp_info_tlv_hdr_serialize(stream, BMP_INFO_TLV_TYPE_SYS_DESCR, sys_descr);
+  bmp_info_tlv_hdr_serialize(stream, BMP_INFO_TLV_TYPE_SYS_NAME, sys_name);
+}
+
+static void
+bmp_schedule_tx_packet(struct bmp_proto *p, const byte *payload, const size_t size)
+{
+  ASSERT(p->started);
+
+  struct bmp_data_node *tx_data = mb_alloc(p->tx_mem_pool, sizeof (struct bmp_data_node));
+  tx_data->data = mb_alloc(p->tx_mem_pool, size);
+  memcpy(tx_data->data, payload, size);
+  tx_data->data_size = size;
+  add_tail(&p->tx_queue, &tx_data->n);
+
+  if (sk_tx_buffer_empty(p->sk)
+      && !ev_active(p->tx_ev))
+  {
+    ev_schedule(p->tx_ev);
+  }
+}
+
+static void
+bmp_fire_tx(void *p_)
+{
+  struct bmp_proto *p = p_;
+  byte *buf = p->sk->tbuf;
+  IF_COND_TRUE_PRINT_ERR_MSG_AND_RETURN_OPT_VAL(
+    EMPTY_LIST(p->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;
+  WALK_LIST_DELSAFE(tx_data, tx_data_next, p->tx_queue)
+  {
+    if (tx_data->data_size > p->sk->tbsize)
+    {
+      sk_set_tbsize(p->sk, tx_data->data_size);
+    }
+
+    size_t 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 (sk_send(p->sk, data_size) <= 0)
+      return;
+
+    // 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(p->tx_ev))
+      {
+        ev_schedule(p->tx_ev);
+      }
+
+      return;
+    }
+  }
+}
+
+static void
+bmp_tx(struct birdsock *sk)
+{
+  bmp_fire_tx(sk->data);
+}
+
+/* We need RX hook just to accept socket close events */
+static int
+bmp_rx(struct birdsock *sk UNUSED, uint size UNUSED)
+{
+  return 0;
+}
+
+
+static inline void
+bmp_put_ipa(buffer *stream, const ip_addr addr)
+{
+  bmp_put_ip6(stream, ipa_is_ip4(addr) ?
+	      ip6_build(0,0,0, ipa_to_u32(addr)) :
+	      ipa_to_ip6(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
+  bmp_put_ipa(stream, 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
+  bmp_put_ipa(stream, 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);
+}
+
+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, void *bmp_)
+{
+  struct bmp_proto *p = bmp_;
+  ASSERT(p->started);
+
+  const struct bmp_peer_map_entry *map_rx_msg = bmp_peer_map_get(&p->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(&p->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)
+  {
+    bmp_send_peer_up_notif_msg(p, bgp, tx_msg, tx_msg_size,
+			       map_rx_msg->data.buf, map_rx_msg->data.buf_size);
+  }
+}
+
+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);
+}
+
+static void
+bmp_send_peer_up_notif_msg(struct bmp_proto *p, 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)
+{
+  ASSERT(p->started);
+
+  const struct birdsock *sk = bmp_get_birdsock_ext(bgp);
+  IF_PTR_IS_NULL_PRINT_ERR_MSG_AND_RETURN_OPT_VAL(
+    sk,
+    "[BMP] No BGP socket"
+  );
+
+  const bool is_global_instance_peer = bmp_is_peer_global_instance(bgp);
+  buffer payload = bmp_buffer_alloc(p->buffer_mpool, DEFAULT_MEM_BLOCK_SIZE);
+  bmp_peer_up_notif_msg_serialize(&payload, is_global_instance_peer,
+    bgp->remote_as, bgp->remote_id, 1,
+    sk->saddr, sk->daddr, sk->sport, sk->dport, tx_data, tx_data_size,
+    rx_data, rx_data_size);
+  bmp_schedule_tx_packet(p, bmp_buffer_data(&payload), bmp_buffer_pos(&payload));
+  bmp_buffer_free(&payload);
+
+  bmp_peer_up(bgp);
+}
+
+void
+bmp_put_sent_bgp_open_msg(const struct bgp_proto *bgp, const byte* pkt,
+  const size_t pkt_size)
+{
+  struct bmp_proto *p = g_bmp;
+
+  if (!p)
+  {
+    return;
+  }
+
+  struct bmp_peer_map_key key
+    = bmp_peer_map_key_create(bgp->remote_ip, bgp->remote_as);
+  const struct bmp_peer_map_entry *rx_msg
+    = bmp_peer_map_get(&p->peer_open_msg.rx_msg, key);
+
+  bmp_peer_map_insert(&p->peer_open_msg.tx_msg, key, pkt, pkt_size);
+
+  if (!rx_msg)
+    bmp_peer_map_insert(&p->bgp_peers, key, (const byte *) &bgp, sizeof (bgp));
+
+  if (rx_msg && p->started)
+    bmp_send_peer_up_notif_msg(p, bgp, pkt, pkt_size, rx_msg->data.buf,
+			       rx_msg->data.buf_size);
+}
+
+void
+bmp_put_recv_bgp_open_msg(const struct bgp_proto *bgp, const byte* pkt,
+  const size_t pkt_size)
+{
+  struct bmp_proto *p = g_bmp;
+
+  if (!p)
+  {
+    return;
+  }
+
+  struct bmp_peer_map_key key
+    = bmp_peer_map_key_create(bgp->remote_ip, bgp->remote_as);
+  const struct bmp_peer_map_entry *tx_msg
+    = bmp_peer_map_get(&p->peer_open_msg.tx_msg, key);
+
+  bmp_peer_map_insert(&p->peer_open_msg.rx_msg, key, pkt, pkt_size);
+
+  if (!tx_msg)
+    bmp_peer_map_insert(&p->bgp_peers, key, (const byte *) &bgp, sizeof (bgp));
+
+  if (tx_msg && p->started)
+    bmp_send_peer_up_notif_msg(p, bgp, tx_msg->data.buf, tx_msg->data.buf_size,
+			       pkt, pkt_size);
+}
+
+void
+bmp_route_monitor_update_in_pre_begin()
+{
+  struct bmp_proto *p = g_bmp;
+
+  if (!p || !p->started)
+  {
+    return;
+  }
+
+  if (p->monitoring_rib.in_pre_policy == false)
+  {
+    return;
+  }
+
+  IF_COND_TRUE_PRINT_ERR_MSG_AND_RETURN_OPT_VAL(
+    !EMPTY_LIST(p->rt_table_in_pre_policy.update_msg_queue),
+    "Previous BMP route monitoring update not finished yet"
+  );
+
+  gettimeofday(&p->rt_table_in_pre_policy.update_begin_time,NULL);
+  init_list(&p->rt_table_in_pre_policy.update_msg_queue);
+  p->rt_table_in_pre_policy.update_msg_size = 0;
+  p->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)
+{
+  struct bmp_proto *p = g_bmp;
+
+  if (!p || !p->started)
+  {
+    return;
+  }
+
+  if (p->monitoring_rib.in_pre_policy == false)
+  {
+    return;
+  }
+
+  IF_COND_TRUE_PRINT_ERR_MSG_AND_RETURN_OPT_VAL(
+    !p->rt_table_in_pre_policy.update_in_progress,
+    "BMP route monitoring update not started yet"
+  );
+
+  struct bmp_data_node *upd_msg = mb_alloc(p->update_msg_mem_pool,
+                               sizeof (struct bmp_data_node));
+  upd_msg->data = mb_alloc(p->update_msg_mem_pool, data_size);
+  memcpy(upd_msg->data, data, data_size);
+  upd_msg->data_size = data_size;
+  p->rt_table_in_pre_policy.update_msg_size += data_size;
+  add_tail(&p->rt_table_in_pre_policy.update_msg_queue, &upd_msg->n);
+}
+
+void
+bmp_route_monitor_update_in_pre_commit(const struct bgp_proto *bgp)
+{
+  struct bmp_proto *p = g_bmp;
+
+  if (!p || !p->started)
+  {
+    return;
+  }
+
+  if (p->monitoring_rib.in_pre_policy == false)
+  {
+    return;
+  }
+
+  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(p->buffer_mpool,
+        p->rt_table_in_pre_policy.update_msg_size + DEFAULT_MEM_BLOCK_SIZE);
+
+  buffer update_msgs
+    = bmp_buffer_alloc(p->buffer_mpool,
+        p->rt_table_in_pre_policy.update_msg_size);
+
+  struct bmp_data_node *data;
+  WALK_LIST(data, p->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),
+      p->rt_table_in_pre_policy.update_begin_time.tv_sec,
+      p->rt_table_in_pre_policy.update_begin_time.tv_usec);
+
+    bmp_schedule_tx_packet(p, bmp_buffer_data(&payload), bmp_buffer_pos(&payload));
+
+    bmp_buffer_flush(&payload);
+    bmp_buffer_flush(&update_msgs);
+  }
+
+  bmp_buffer_free(&payload);
+  bmp_buffer_free(&update_msgs);
+}
+
+void
+bmp_route_monitor_update_in_pre_end()
+{
+  struct bmp_proto *p = g_bmp;
+
+  if (!p || !p->started)
+  {
+    return;
+  }
+
+  if (p->monitoring_rib.in_pre_policy == false)
+  {
+    return;
+  }
+
+  struct bmp_data_node *upd_msg;
+  struct bmp_data_node *upd_msg_next;
+  WALK_LIST_DELSAFE(upd_msg, upd_msg_next, p->rt_table_in_pre_policy.update_msg_queue)
+  {
+    mb_free(upd_msg->data);
+    rem_node((node *) upd_msg);
+    mb_free(upd_msg);
+  }
+
+  p->rt_table_in_pre_policy.update_in_progress = false;
+}
+
+static void
+bmp_route_monitor_pre_policy_table_in_snapshot(struct channel *C)
+{
+  struct bmp_proto *p = g_bmp;
+
+  if (p->monitoring_rib.in_pre_policy == false)
+  {
+    return;
+  }
+
+  struct rtable *tab = C->in_table;
+  if (!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(C, n->n.addr, e, 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 void
+bmp_send_peer_down_notif_msg(struct bmp_proto *p, const struct bgp_proto *bgp,
+  const byte* data, const size_t data_size)
+{
+  ASSERT(p->started);
+
+  const struct bgp_caps *remote_caps = bmp_get_bgp_remote_caps_ext(bgp);
+  bool is_global_instance_peer = bmp_is_peer_global_instance(bgp);
+  buffer payload
+    = bmp_buffer_alloc(p->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);
+  bmp_schedule_tx_packet(p, bmp_buffer_data(&payload), bmp_buffer_pos(&payload));
+
+  bmp_buffer_free(&payload);
+}
+
+void
+bmp_peer_down(const struct bgp_proto *bgp, const int err_class, const byte *pkt,
+  size_t pkt_size)
+{
+  struct bmp_proto *p = g_bmp;
+
+  if (!p)
+  {
+    return;
+  }
+
+  struct bmp_peer_map_key key
+    = bmp_peer_map_key_create(bgp->remote_ip, bgp->remote_as);
+
+  bmp_peer_map_remove(&p->peer_open_msg.tx_msg, key);
+  bmp_peer_map_remove(&p->peer_open_msg.rx_msg, key);
+  bmp_peer_map_remove(&p->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;
+
+  if (!p->started)
+    return;
+
+  buffer payload
+    = bmp_buffer_alloc(p->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
+    }
+  }
+
+  bmp_send_peer_down_notif_msg(p, bgp, bmp_buffer_data(&payload), bmp_buffer_pos(&payload));
+
+  bmp_buffer_free(&payload);
+}
+
+static void
+bmp_send_termination_msg(struct bmp_proto *p,
+  const enum bmp_term_reason reason)
+{
+  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(p->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(p->sk->tbuf, bmp_buffer_data(&stream), bmp_buffer_pos(&stream));
+  IF_COND_TRUE_PRINT_ERR_MSG_AND_RETURN_OPT_VAL(
+    sk_send(p->sk, bmp_buffer_pos(&stream)) < 0,
+    "Failed to send BMP termination message"
+    );
+
+  bmp_buffer_free(&stream);
+}
+
+/**
+ * bmp_startup - enter established state
+ * @p: BMP instance
+ *
+ * The bgp_startup() function is called when the BMP session is established.
+ * It sends initiation and peer up messagages.
+ */
+static void
+bmp_startup(struct bmp_proto *p)
+{
+  ASSERT(!p->started);
+  p->started = true;
+
+  TRACE(D_EVENTS, "BMP session established");
+
+  /* Send initiation message */
+  buffer payload = bmp_buffer_alloc(p->buffer_mpool, DEFAULT_MEM_BLOCK_SIZE);
+  bmp_init_msg_serialize(&payload, p->sys_descr, p->sys_name);
+  bmp_schedule_tx_packet(p, bmp_buffer_data(&payload), bmp_buffer_pos(&payload));
+  bmp_buffer_free(&payload);
+
+  /* Send Peer Up messages */
+  bmp_peer_map_walk(&p->peer_open_msg.tx_msg,
+		    bmp_peer_map_walk_tx_open_msg_and_send_peer_up_notif, p);
+
+  proto_notify_state(&p->p, PS_UP);
+}
+
+/**
+ * bmp_down - leave established state
+ * @p: BMP instance
+ *
+ * The bgp_down() function is called when the BMP session fails.
+ */
+static void
+bmp_down(struct bmp_proto *p)
+{
+  ASSERT(p->started);
+  p->started = false;
+
+  TRACE(D_EVENTS, "BMP session closed");
+
+  proto_notify_state(&p->p, PS_START);
+}
+
+/**
+ * bmp_connect - initiate an outgoing connection
+ * @p: BMP instance
+ *
+ * The bmp_connect() function creates the socket and initiates an outgoing TCP
+ * connection to the monitoring station. It is called to enter Connect state.
+ */
+static void
+bmp_connect(struct bmp_proto *p)
+{
+  ASSERT(!p->started);
+
+  sock *sk = sk_new(p->p.pool);
+  sk->type = SK_TCP_ACTIVE;
+  sk->daddr = p->station_ip;
+  sk->dport = p->station_port;
+  sk->ttl = IP4_MAX_TTL;
+  sk->tos = IP_PREC_INTERNET_CONTROL;
+  sk->tbsize = BGP_TX_BUFFER_EXT_SIZE;
+  sk->tx_hook = bmp_connected;
+  sk->err_hook = bmp_sock_err;
+
+  p->sk = sk;
+  sk->data = p;
+
+  int rc = sk_open(sk);
+
+  if (rc < 0)
+    sk_log_error(sk, p->p.name);
+
+  tm_start(p->connect_retry_timer, CONNECT_RETRY_TIME);
+}
+
+/* BMP connect successfull event - switch from Connect to Established state */
+static void
+bmp_connected(struct birdsock *sk)
+{
+  struct bmp_proto *p = (void *) sk->data;
+
+  sk->rx_hook = bmp_rx;
+  sk->tx_hook = bmp_tx;
+  tm_stop(p->connect_retry_timer);
+
+  bmp_startup(p);
+}
+
+/* BMP socket error event - switch from any state to Idle state */
+static void
+bmp_sock_err(sock *sk, int err)
+{
+  struct bmp_proto *p = sk->data;
+
+  if (err)
+    TRACE(D_EVENTS, "Connection lost (%M)", err);
+  else
+    TRACE(D_EVENTS, "Connection closed");
+
+  if (p->started)
+    bmp_down(p);
+
+  bmp_close_socket(p);
+  tm_start(p->connect_retry_timer, CONNECT_RETRY_TIME);
+}
+
+/* BMP connect timeout event - switch from Idle/Connect state to Connect state */
+static void
+bmp_connection_retry(timer *t)
+{
+  struct bmp_proto *p = t->data;
+
+  if (p->started)
+    return;
+
+  bmp_close_socket(p);
+  bmp_connect(p);
+}
+
+static void
+bmp_close_socket(struct bmp_proto *p)
+{
+  rfree(p->sk);
+  p->sk = NULL;
+}
+
+
+/** Configuration handle section **/
+static struct proto *
+bmp_init(struct proto_config *CF)
+{
+  struct proto *P = proto_new(CF);
+  struct bmp_proto *p = (void *) P;
+  struct bmp_config *cf = (void *) CF;
+
+  p->cf = cf;
+  p->station_ip = cf->station_ip;
+  p->station_port = cf->station_port;
+  strcpy(p->sys_descr, cf->sys_descr);
+  strcpy(p->sys_name, cf->sys_name);
+  p->monitoring_rib.in_pre_policy = cf->monitoring_rib_in_pre_policy;
+  p->monitoring_rib.in_post_policy = cf->monitoring_rib_in_post_policy;
+  p->monitoring_rib.local = cf->monitoring_rib_local;
+
+  return P;
+}
+
+static int
+bmp_start(struct proto *P)
+{
+  struct bmp_proto *p = (void *) P;
+
+  log(L_DEBUG "Init BMP");
+
+  p->buffer_mpool = rp_new(P->pool, "BMP Buffer");
+  p->map_mem_pool = rp_new(P->pool, "BMP Map");
+  p->tx_mem_pool = rp_new(P->pool, "BMP Tx");
+  p->update_msg_mem_pool = rp_new(P->pool, "BMP Update");
+  p->tx_ev = ev_new_init(p->tx_mem_pool, bmp_fire_tx, p);
+  p->connect_retry_timer = tm_new_init(p->p.pool, bmp_connection_retry, p, 0, 0);
+  p->sk = NULL;
+
+  bmp_peer_map_init(&p->peer_open_msg.tx_msg, p->map_mem_pool);
+  bmp_peer_map_init(&p->peer_open_msg.rx_msg, p->map_mem_pool);
+  bmp_peer_map_init(&p->bgp_peers, p->map_mem_pool);
+
+  init_list(&p->tx_queue);
+  init_list(&p->rt_table_in_pre_policy.update_msg_queue);
+  p->started = false;
+
+  tm_start(p->connect_retry_timer, CONNECT_INIT_TIME);
+
+  g_bmp = p;
+
+  return PS_START;
+}
+
+static int
+bmp_shutdown(struct proto *P)
+{
+  struct bmp_proto *p = (void *) P;
+
+  if (p->started)
+  {
+    bmp_send_termination_msg(p, BMP_TERM_REASON_ADM);
+    p->started = false;
+  }
+
+  g_bmp = NULL;
+
+  return PS_DOWN;
+}
+
+static int
+bmp_reconfigure(struct proto *P, struct proto_config *CF)
+{
+  struct bmp_proto *p = (void *) P;
+  const struct bmp_config *cf = (void *) CF;
+
+  log(L_WARN "Reconfiguring BMP is not supported");
+
+  p->cf = cf;
+
+  return 1;
+}
+
+struct protocol proto_bmp = {
+  .name = "BMP",
+  .template = "bmp%d",
+  .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..19623e33
--- /dev/null
+++ b/proto/bmp/bmp.h
@@ -0,0 +1,153 @@
+/*
+ *	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
+
+// 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;
+  const char *sys_descr;              // sysDescr MIB-II [RFC1213] object
+  const char *sys_name;               // sysName MIB-II [RFC1213] object
+  ip_addr station_ip;                 // Monitoring station address
+  u16 station_port;                   // Monitoring station TCP port
+  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;
+
+// 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
+  sock *sk;                        // TCP connection
+  event *tx_ev;			   // TX event
+  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
+  struct monitoring_rib monitoring_rib;
+  // Below fields are for internal use
+  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 started;                    // Flag that stores running status of BMP instance
+};
+
+
+#ifdef CONFIG_BMP
+
+/**
+ * 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);
+
+
+#else /* BMP build disabled */
+
+static inline void bmp_put_sent_bgp_open_msg(const struct bgp_proto *bgp UNUSED, const byte* pkt UNUSED, const size_t pkt_size UNUSED) { }
+static inline void bmp_put_recv_bgp_open_msg(const struct bgp_proto *bgp UNUSED, const byte* pkt UNUSED, const size_t pkt_size UNUSED) { }
+static inline void bmp_route_monitor_update_in_pre_begin(void) { }
+static inline void bmp_route_monitor_put_update_in_pre_msg(const byte *data UNUSED, const size_t data_size UNUSED) { }
+static inline void bmp_route_monitor_update_in_pre_commit(const struct bgp_proto *bgp UNUSED) { }
+static inline void bmp_route_monitor_update_in_pre_end(void) { }
+static inline void bmp_peer_down(const struct bgp_proto *bgp UNUSED, const int err_class UNUSED, const byte *pkt UNUSED, size_t pkt_size UNUSED) { }
+
+#endif /* CONFIG_BMP */
+
+#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..f752cf5d
--- /dev/null
+++ b/proto/bmp/buffer.h
@@ -0,0 +1,77 @@
+/*
+ *	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 <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_ */
diff --git a/proto/bmp/config.Y b/proto/bmp/config.Y
new file mode 100644
index 00000000..776d7ecc
--- /dev/null
+++ b/proto/bmp/config.Y
@@ -0,0 +1,83 @@
+/*
+ *	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->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 (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 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;
+   }
+ ;
+
+CF_CODE
+
+CF_END
diff --git a/proto/bmp/map.c b/proto/bmp/map.c
new file mode 100644
index 00000000..16e714fd
--- /dev/null
+++ b/proto/bmp/map.c
@@ -0,0 +1,119 @@
+/*
+ *	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"
+
+/* 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
+
+void
+bmp_peer_map_init(struct bmp_peer_map *map, pool *mpool)
+{
+  map->mpool = mpool;
+  HASH_INIT(map->peer_hash, map->mpool, PEER_INIT_ORDER);
+}
+
+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;
+}
+
+void
+bmp_peer_map_flush(struct bmp_peer_map *map)
+{
+  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);
+}
+
+void
+bmp_peer_map_free(struct bmp_peer_map *map)
+{
+  bmp_peer_map_flush(map);
+  HASH_FREE(map->peer_hash);
+}
+
+void
+bmp_peer_map_insert(struct bmp_peer_map *map, const struct bmp_peer_map_key key,
+  const byte *data, const size_t data_size)
+{
+  struct bmp_peer_map_entry *entry
+    = (void *) HASH_FIND(map->peer_hash, PEER, PEER_KEY(&key));
+
+  if (entry)
+  {
+    mb_free(entry->data.buf);
+    entry->data.buf = mb_alloc(map->mpool, data_size);
+    memcpy(entry->data.buf, data, data_size);
+    entry->data.buf_size = data_size;
+    return;
+  }
+
+  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);
+}
+
+void
+bmp_peer_map_remove(struct bmp_peer_map *map, const struct bmp_peer_map_key key)
+{
+  struct bmp_peer_map_entry *entry
+    = (void *) HASH_DELETE(map->peer_hash, PEER, PEER_KEY(&key));
+
+  if (!entry)
+    return;
+
+  mb_free(entry->data.buf);
+  mb_free(entry);
+}
+
+const struct bmp_peer_map_entry *
+bmp_peer_map_get(struct bmp_peer_map *map, const struct bmp_peer_map_key key)
+{
+  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, void *arg)
+{
+  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, arg);
+  }
+  HASH_WALK_FILTER_END;
+}
diff --git a/proto/bmp/map.h b/proto/bmp/map.h
new file mode 100644
index 00000000..8e7ea695
--- /dev/null
+++ b/proto/bmp/map.h
@@ -0,0 +1,68 @@
+/*
+ *	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"
+
+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
+};
+
+void
+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);
+
+void
+bmp_peer_map_free(struct bmp_peer_map *map);
+
+void
+bmp_peer_map_flush(struct bmp_peer_map *map);
+
+void
+bmp_peer_map_insert(struct bmp_peer_map *map, const struct bmp_peer_map_key key,
+  const byte *data, const size_t data_size);
+
+void
+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 *arg);
+
+void
+bmp_peer_map_walk(const struct bmp_peer_map *map, bmp_peer_map_walk_action action, void *arg);
+
+#endif /* _BIRD_BMP_MAP_H_ */