diff --git a/configure.ac b/configure.ac
index 0ed4d2d7..65bbd20b 100644
--- a/configure.ac
+++ b/configure.ac
@@ -312,7 +312,7 @@ if test "$enable_mpls_kernel" != no ; then
   fi
 fi
 
-all_protocols="aggregator $proto_bfd babel bgp l3vpn mrt ospf perf pipe radv rip rpki static"
+all_protocols="aggregator $proto_bfd babel bgp l3vpn mrt ospf perf pipe radv rip rpki snmp static"
 
 all_protocols=`echo $all_protocols | sed 's/ /,/g'`
 
diff --git a/doc/bird.sgml b/doc/bird.sgml
index e2050c13..954fc7ed 100644
--- a/doc/bird.sgml
+++ b/doc/bird.sgml
@@ -6198,6 +6198,358 @@ protocol static {
 }
 </code>
 
+<sect>SNMP
+<label id="snmp">
+
+<p>The Simple Network Management Protocol is protocol for collecting and
+managing network devices. Managed information is divided into so called MIBs --
+Management Information Bases. Each MIB describe information and semantics it
+provides. The SNMP architecture is very flexible, some MIB are standartized by
+IETF, others published by independent third parties.
+
+<p>The BIRD SNMP support is achieved by an additional component -- a SNMP daemon
+with AgentX protocol support. The SNMP daemon acts as an AgentX master agent and
+deal with user authentication, access control and managing MIB regions in OID
+tree. BIRD instance acts as AgentX subagent, register configurated MIBs and
+provides queried data. The AgentX communication protocol between master agent
+and subagents does not consider security what so ever. It is therefore upon the
+user to use the AgentX in a secure way. This can be achieved either by using
+Unix Domain sockets on same host or by using secure tunnel. Note that following
+sections containing pieces of Net-SNMP configuraiton are only meant as a helper
+for cold start, or as a pointer what to search for, not as full reference. For
+full reference consult the original manpages.
+
+<sect1>SNMP Daemon configuration
+<p>We recommend you to use Net-SNMP implementation of daemon and utilities, quick
+guide below assume that. Net-SNMP implementation is quite popular so you should
+find it's packages inside your distribution package manager.
+
+<sect2>Example snmpd configuration
+<p>
+<code>
+# file /etc/snmp/snmpd.conf
+# minimal SNMPv3 config
+agentx master
+agentaddress udp:192.0.2.64
+agentXSocket tcp:198.51.100.2
+
+createUser snmp_name MD5 example_pass
+rwuser snmp_name noauth
+</code>
+
+<sect2>AgentX Enabling
+<p>
+<code>
+# File /etc/snmp/snmpd.conf
+agentx master
+agentXSocket [unix:|tcp:|tcp6:]&lt;address&gt;[,...]
+agentXPerms &lt;sockperms&gt; [&lt;dirperms&gt; [&lt;user&gt;|&lt;uid&gt; [&lt;group&gt;|&lt;gid&gt;]]]
+agentaddress [&lt;trasport-type&gt;:]&lt;trasport-address&gt;[,...]
+</code>
+
+<descrip>
+	<tag><label id="snmpd-agentx-master">agentx master</tag>
+	SNMP daemon will enable AgentX functionality and start listening on
+	configured AgentX address.
+
+
+	<tag><label id="snmpd-agentxsocket">agentXSocket
+	[unix:|tcp:|tcp6:]<m/trasport-address/[,...] </tag>
+
+	Define address to listen for AgentX subagent. Use one of <cf>unix:,
+	tcp:, tcp6:</cf> transport type. Other transport type are not supported
+	by BIRD and also not mentioned in AgentX RFC, see <rfc id="2741">.
+	Default: Unix Domain socket <file>/var/run/agentx/master</file>.
+
+
+	<tag><label id="snmpd-agentxperms">agentXPerms <m/sockperms/
+	[<m/dirperms/ [<m/user/|<m/uid/ [<m/group/|<m/gid/]]]</tag>
+
+	Define common permissions for AgentX listening Unix Domain sockets. Both
+	<m/sockperms/ and <m/dirperms/ must be octal digits like for
+	<m/chmod(1)/. Option <m/user/ is string and <m/uid/ is numeric user id.
+	Same for <m/group/ and <m/gid/.
+
+
+	<tag><label id="snmpd-agentaddress">agentaddress
+	[<m/transport-type/:]<m/trasport-address/[,...]</tag>
+
+	Define address, or list of addresses, to listen for SNMP requests (send
+	for example by <it/snmpwalk(1)/). You most likely want <m/trasport-type/ to
+	be one from <cf/udp:/, <cf/udp6:/, <cf/tcp:/, <cf/tcp6:/, <cf/unix:/,
+	<cf/ssh:/ but Net-SNMP support even more transport types.
+	Value <m/transport-address/ define address, Net-SNMP should be able to
+	derive <m/trasport-type/ from <m/transport-address/. Beware that for
+	Unix Domain socket derivation to work, the path must start with /. Also
+	note that the working directory of snmpd daemon is filesystem root.
+	Default: UDP on all IPv4 interfaces on port 161. (e.g.
+	<cf>agentaddress udp6:localhost:161</cf>,
+	<cf>agentaddress tcp:192.0.2.1</cf>,
+	<cf>agentaddress /var/run/mydir/agentx_master</cf>,
+	<cf>agentaddress localhost,/p/u1,/p/u2</cf>).
+</descrip>
+
+<sect2>Configure access
+<p>You can use the SNMPv3 USM module for user authorization, or use simpler older
+version SNMPv1/SNMPv2c with authentication by community. Other means of
+authorization are also possible (e.g. external Kerberos) but out of scope of
+this guide.
+
+<sect3>SNMPv3 USM
+<p>
+<code>
+# file /etc/snmp/snmpd.conf (continuation)
+createUser [-e &lt;engineid&gt;] &lt;username&gt; (MD5|SHA|SHA-512|SHA-384|SHA-256|SHA-224) &lt;authpassphrase&gt; [DES|AES] [&lt;pass&gt;]
+rwuser [-s secmodel] &lt;user&gt; [noauth|auth|priv [&lt;oid&gt; | -V &lt;view&gt; [&lt;context&gt;]]]
+rouser [-s secmodel] &lt;user&gt; [noauth|auth|priv [&lt;oid&gt; | -V &lt;view&gt; [&lt;context&gt;]]]
+</code>
+
+<descrip>
+	<tag><label id="snmpd-createuser">createUser [-e <m/engineid/]
+	<m/username/ (MD5|SHA|SHA-512|SHA-384|SHA-256|SHA-224)
+	<m/authpassphrase/ [DES|AES] [<m/privpassphrase/] </tag>
+
+	Create user with in order specified username, authentication type,
+	authentication password, private protocol and private password. If the
+	private password is not used, it fallbacks to same password as the
+	authentication one.
+
+
+	<tag><label id="snmpd-rwuser">rwuser [-s <m/secmodel/] <m/user/
+	[noauth|auth|priv [<m/oid/ | -V <m/view/ [<m/context/]]]</tag>
+
+	Give user with selected security level read-write permissions
+	to the defined <m/oid/ OID subtree or <m/view/ view,
+	see <ref id="snmp_view" name="view definition">. Security level
+	<cf>noauth</cf> does not require authentication, <cf>auth</cf> requires
+	authentication and <cf>priv</cf> authentication with enforced message
+	encryption. View is a Net-SNMP construct to name and group set of OID
+	subtrees with optional context. Contexts are currently not supported by
+	BIRD.
+
+
+	<tag><label id="snmpd-rouser">rouser [-s <m/secmodel/] <m/user/
+	[noauth|auth|priv [<m/oid/ | -V <m/view/ [<m/context/]]]</tag>
+
+	Same as <cf>rwuser</cf> but only with read permissions.
+</descrip>
+
+<sect3>SNMPv1/SNMPv2c community-based
+<p>
+<code>
+# file /etc/snmp/snmpd.conf (continuation)
+rwcommunity &lt;community&gt; [&lt;source&gt; [&lt;oid&gt; | -V &lt;view&gt; [&lt;context&gt;]]]
+rocommunity &lt;community&gt; [&lt;source&gt; [&lt;oid&gt; | -V &lt;view&gt; [&lt;context&gt;]]]
+rwcommunity6 &lt;community&gt; [&lt;source&gt; [&lt;oid&gt; | -V &lt;view&gt; [&lt;context&gt;]]]
+rocommunity6 &lt;community&gt; [&lt;source&gt; [&lt;oid&gt; | -V &lt;view&gt; [&lt;context&gt;]]]
+view &lt;vname&gt; (include|exclude) &lt;oid&gt; [&lt;mask&gt;]
+</code>
+
+<descrip>
+	<tag><label id="snmpd-rwcommunity">rwcommunity <m/community/ [<m/source/
+	[<m/oid/ | -V <m/view/ [<m/context/]]]</tag>
+
+	Create a community with read-write permissions named <m/community/.
+	Option <m/source/ is used to restrict senders of request, use
+	<cf>"default"</cf> as a placeholder in doubts. You can also restrict
+	accessible regions of OID tree to OID subtree of <m/oid/ or named
+	<m/view/, otherwise the access is unrestricted to the whole OID tree.
+	Contexts are currently not supported by BIRD.
+
+
+	<tag><label id="snmpd-rocommunity">rocommunity <m/community/> [<m/source/
+	[<m/oid/ | -V <m/view/ [<m/context/]]]</tag>
+
+	Same as <cf>rwcommunity</cf> but only with read permissions.
+
+
+	<tag><label id="snmpd-rwcommunity6">rwcommunity6 <m/community/
+	[<m/source/ [<m/oid/ | -V <m/view/ [<m/context/]]] </tag>
+
+	Is <cf>rwcommunity</cf> for packet received using IPv6.
+
+	<tag><label id="snmpd-rocommunity6">rocommunity6 <m/community/
+	[<m/source/ [<m/oid/ | -V <m/view/ [<m/context/]]]</tag>
+
+	Same as <cf>rwcommunity6</cf> but only with read permissions.
+
+	<tag><label id="snmpd-view">view <m/vname/ (include|exclude) <m/oid/ [<m/mask/]</tag>
+	Define a named grouping of OIDs. May be used multiple times with same
+	<m/vname/.
+</descrip>
+
+
+<sect1>BIRD SNMP configuration
+<p>
+<code>
+protocol snmp [&lt;name&gt;] {
+	agentx master address (default|&lt;unix_path&gt;|&lt;ip&gt; [port &lt;port&gt;]);
+	subagent description &lt;text&gt;;
+	source address &lt;ip&gt;;
+	registration priority &lt;num&gt;;
+	message timeout &lt;time&gt;;
+	start delay time &lt;time&gt;;
+	verbose &lt;switch&gt;;
+
+	mib bgp4 {
+		local as &lt;num&gt;;
+		local router id &lt;ip4&gt;;
+		peer &lt;name&gt;;
+	};
+}
+</code>
+
+<descrip>
+	<tag><label id="snmp-master">agentx master address
+	(default|<m/unix_path/|<m/ip/ [port <m/port/])</tag>
+
+	Address of AgentX master. Default is <cf>"/var/run/agentx/master"</cf>.
+	String option <m/unix_path/ select transport over Unix Domain sockets
+	with selected path address. Option <m/ip/ select transport over TCP.
+
+	Default port for TCP transmission is 705.
+
+	<tag><label id="snmp-descr">subagent description <m/text/</tag>
+	Short string describing the subagent. Default: "bird".
+
+	<tag><label id="snmp-src-addr">source address <m/ip/</tag>
+	For TCP based AgentX communication sets socket's source address.
+
+	<tag><label id="snmp-reg-priority">registration priority <m/number/</tag>
+	Set AgentX registration priority for all MIBs. Lower values have higher
+	priority. Valid interval 0-255. Default: 127.
+
+	<tag><label id="snmp-msg-timeout">message timeout <m/time/ s|ms</tag>
+	Set timeout for all AgentX messages. With 1 second granurality with
+	values from interval 0-255. Default: 15 s.
+
+	<tag><label id="snmp-start-delay">start delay time <m/time/ s|ms</tag>
+	Wait <m/time/ before sending first packet after protocol start.
+
+	<tag><label id="snmp-verbose">verbose <m/switch/</tag>
+	Enable logging of events connected to AgentX master pinging. Default:
+	verbose logging is disabled.
+
+	<tag><label id="snmp-bgp4-mib">mib bgp4</tag>
+	Enable BGP4-MIB which is defined in <rfc id="4273">. The support is
+	limited to BGP4-MIB::bgpPeerTable; the BGP4-MIB::bgpRcvdPathAttrTable,
+	BGP4-MIB::bgpPathAttrTable, traps and notifications are not supported.
+
+	<tag><label id="snmp-bgp4-local-as">local as <m/number/</tag>
+	Specify Local As for BGP4 MIB (BGP4-MIB::bgpLocalAs.0). This option is
+	required.
+
+	<tag><label id="snmp-bgp4-router-id">local router id <m/IPv4 address/</tag>
+	Specify Router ID for BGP4 MIB (BGP4-MIB::bgpLocalIdentifier.0). This
+	option is required.
+
+	<tag><label id="snmp-bgp4-peer">peer <m/name/</tag>
+	Make information about BGP protocol <m/name/ accessible. This protocol
+	must over IPv4 (this limitation is introduced by the BGP4-MIB). May
+	be used multiple times.
+</descrip>
+
+<sect2>An example SNMP protocol configuration
+<p>
+<code>
+protocol bgp ibgp1 {
+	local as 2;
+	router id 192.0.2.1;
+	/* ... */
+}
+
+protocol bgp ibgp2 {
+	local as 4;
+	router id 192.0.2.128;
+	/* ... */
+}
+
+protocol snmp snmp1 {
+	agentx master address 198.51.100.2;
+
+	mib bgp4 {
+		local as 2;
+		local router id 192.0.2.1;
+		peer ibgp1;
+		peer ibgp2;
+	}
+}
+</code>
+
+<sect1>Accessing MIB data
+<p>To save some keystrokes and to avoid putting passwords in shell history, you
+could use common configuration file for all Net-SNMP command line utilities.
+Here is an example:
+
+<code>
+# file ~/.snmp/snmp.conf
+defVersion (1|2c|3)
+defCommunity &lt;community&gt;
+defSecurityName &lt;username&gt;
+defAuthType (MD5|SHA|SHA-512|SHA-384|SHA-256|SHA-224)
+defAuthPassphrase &lt;authpass&gt;
+defPrivType (DES|AES)
+defPrivPassphrase &lt;privpass&gt;
+clientaddr [&lt;transport-type&gt;:]&lt;transport-address&gt;
+</code>
+
+<descrip>
+	<tag><label id="snmpcmd-version">defVersion (1|2c|3)</tag>
+	Select version of SNMP packets, must follow
+	<file>/etc/snmp/snmpd.conf</file>. Use only if community/view based
+	configuration.
+
+	<tag><label id="snmpcmd-community">defCommunity <m/community/</tag>
+	Use by default given community. Use only for SNMP version 1 and 2c as
+	community as kind of a username for these versions.
+
+	<tag><label id="snmpcmd-authtype">defAuthType
+	(MD5|SHA|SHA-512|SHA-384|SHA-256|SHA-224)</tag>
+
+	Select authentication type.
+
+
+	<tag><label id="snmpcmd-authpass">defAuthPassphrase <m/authpass/</tag>
+	Set authentication password.
+
+	<tag><label id="snmpcmd-privtype">defPrivType (DES|AES)</tag>
+	Select private protocols.
+
+	<tag><label id="snmpcmd-privpass">defPrivPassphrase <m/privpass/</tag>
+	Set private password used for encryption.
+
+
+	<tag><label id="snmpcmd-clientaddr">clientaddr
+	[<m/transport-type/:]<m/transport-address/</tag>
+
+	SNMP command line utility equivalent to <cf>agentaddress</cf> daemon
+	option.
+</descrip>
+
+<p>For further information, see <it/snmp.conf(5)/.
+
+<p>Example of configuration for Net-SNMP utils.
+<code>
+# SNMPv3
+defVersion 3
+defSecurityName snmp_name
+defSecurityLevel noAuthNoPriv
+defAuthType MD5
+defAuthPassphrase example_pass
+</code>
+
+<code>
+$ # &lt;snmputil&gt; &lt;master-address&gt; &lt;oid&gt;[ &lt;oid&gt; [...]]
+$ snmpget     192.0.2.64 BGP4-MIB::bgpLocalAs.0
+$ snmpgetnext 192.0.2.64 BGP4-MIB::bgpPeerState BGP4-MIB::bgpPeerAdminStatus
+$ snmpwalk    192.0.2.64 BGP4-MIB::bgp
+$ snmptable   192.0.2.64 BGP4-MIB::bgpPeerTable
+</code>
+
+<p>We recommend you to check manpages for Net-SNMP utilities mentioned above,
+such as <it/snmp_config(5)/, <it/snmpd.conf(5)/, <it/snmpd(8)/,
+<it/snmp.conf(5)/, <it/snmpcmds(1)/, <it/snmpget(1)/, <it/snmpgetnext(1)/,
+<it/snmpbulkget(1)/, <it/snmpwalk(1)/, <it/snmptable(1)/.
 
 <chapt>Conclusions
 <label id="conclusion">
diff --git a/doc/snmp.conf.example b/doc/snmp.conf.example
new file mode 100644
index 00000000..36d99821
--- /dev/null
+++ b/doc/snmp.conf.example
@@ -0,0 +1,5 @@
+defSecurityName snmp_name
+defAuthType MD5
+defAuthPassphrase test_pass
+defSecurityLevel noAuthNoPriv
+defVersion 3
diff --git a/doc/snmpd.conf.example b/doc/snmpd.conf.example
new file mode 100644
index 00000000..58066bd8
--- /dev/null
+++ b/doc/snmpd.conf.example
@@ -0,0 +1,18 @@
+#
+#  snmpd configuration file
+#
+
+# SNMP connection address
+agentaddress  127.0.0.1
+
+# enable AgentX protocol
+master agentx
+
+# AgentX connection address
+agentXSocket tcp:localhost:705
+
+
+# Create example user
+createUser snmp_name MD5 test_pass
+rwuser snmp_name noauth
+
diff --git a/nest/protocol.h b/nest/protocol.h
index 4f69a6a7..cb89f612 100644
--- a/nest/protocol.h
+++ b/nest/protocol.h
@@ -56,6 +56,7 @@ enum protocol_class {
   PROTOCOL_RADV,
   PROTOCOL_RIP,
   PROTOCOL_RPKI,
+  PROTOCOL_SNMP,
   PROTOCOL_STATIC,
   PROTOCOL__MAX
 };
@@ -105,9 +106,9 @@ void protos_dump_all(void);
  */
 
 extern struct protocol
-  proto_device, proto_radv, proto_rip, proto_static, proto_mrt,
-  proto_ospf, proto_perf, proto_l3vpn, proto_aggregator,
-  proto_pipe, proto_bgp, proto_bmp, proto_bfd, proto_babel, proto_rpki;
+  proto_device, proto_radv, proto_rip, proto_static, proto_mrt, proto_ospf,
+  proto_perf, proto_l3vpn, proto_aggregator, proto_pipe, proto_bgp, proto_bmp,
+  proto_bfd, proto_babel, proto_rpki, proto_snmp;
 
 /*
  *	Routing Protocol Instance
diff --git a/proto/Doc b/proto/Doc
index 9de9eeec..07e1f48b 100644
--- a/proto/Doc
+++ b/proto/Doc
@@ -8,5 +8,6 @@ C pipe
 C radv
 C rip
 C rpki
+C snmp
 C static
 S ../nest/rt-dev.c
diff --git a/proto/snmp/Doc b/proto/snmp/Doc
new file mode 100644
index 00000000..a19894d0
--- /dev/null
+++ b/proto/snmp/Doc
@@ -0,0 +1,5 @@
+S snmp.c
+S subagent.c
+S snmp_utils.c
+S mib_tree.c
+S bgp4_mib.c
diff --git a/proto/snmp/Makefile b/proto/snmp/Makefile
new file mode 100644
index 00000000..81055a54
--- /dev/null
+++ b/proto/snmp/Makefile
@@ -0,0 +1,8 @@
+src := snmp.c snmp_utils.c subagent.c mib_tree.c bgp4_mib.c
+obj := $(src-o-files)
+$(all-daemon)
+$(cf-local)
+
+tests_src := snmp_test.c
+tests_targets := $(tests_targets) $(tests-target-files)
+tests_objs := $(tests_objs) $(src-o-files)
diff --git a/proto/snmp/bgp4_mib.c b/proto/snmp/bgp4_mib.c
new file mode 100644
index 00000000..4ff61bc7
--- /dev/null
+++ b/proto/snmp/bgp4_mib.c
@@ -0,0 +1,1009 @@
+/*
+ *	BIRD -- Simple Network Management Protocol (SNMP)
+ *        BGP4-MIB bgpPeerTable
+ *
+ *      (c) 2022 Vojtech Vilimek <vojtech.vilimek@nic.cz>
+ *      (c) 2022 CZ.NIC z.s.p.o
+ *
+ *	Can be freely distributed and used under the terms of the GNU GPL.
+ */
+
+#include "snmp.h"
+#include "snmp_utils.h"
+#include "subagent.h"
+#include "bgp4_mib.h"
+#include "mib_tree.h"
+
+#include "nest/cli.h"
+
+/* hash table macros */
+#define SNMP_HASH_KEY(n)  n->peer_ip
+#define SNMP_HASH_NEXT(n) n->next
+#define SNMP_HASH_EQ(ip1, ip2) ip4_equal(ip1, ip2)
+#define SNMP_HASH_FN(ip)  ip4_hash(ip)
+
+#define SNMP_HASH_LESS4(ip1, ip2) ip4_less(ip1, ip2)
+#define SNMP_HASH_LESS6(ip1, ip2) ip6_less(ip1, ip2)
+
+/* hash table only store ip4 addresses */
+#define SNMP_HASH_LESS(ip1, ip2) SNMP_HASH_LESS4(ip1,ip2)
+
+#define DECLARE_BGP4(addr, proto, conn, stats, config) \
+  ip4_addr addr; \
+  const struct bgp_proto UNUSED *proto; \
+  const struct bgp_conn UNUSED *conn; \
+  const struct bgp_stats UNUSED *stats; \
+  const struct bgp_config UNUSED *config
+
+#define POPULATE_BGP4(addr, proto, conn, stats, config) populate_bgp4(c, &(addr), &(proto), &(conn), &(stats), &(config))
+
+static inline void ip4_to_oid(struct oid *oid, ip4_addr addr);
+static const STATIC_OID(2) bgp4_mib_oid = STATIC_OID_INITIALIZER(2, SNMP_MGMT, SNMP_MIB_2, SNMP_BGP4_MIB);
+
+static inline void
+snmp_hash_add_peer(struct snmp_proto *p, struct snmp_bgp_peer *peer)
+{
+  HASH_INSERT(p->bgp_hash, SNMP_HASH, peer);
+}
+
+static inline struct snmp_bgp_peer *
+snmp_hash_find(struct snmp_proto *p, ip4_addr key)
+{
+  return HASH_FIND(p->bgp_hash, SNMP_HASH, key);
+}
+
+static inline void
+snmp_bgp_last_error(const struct bgp_proto *bgp, char err[2])
+{
+  err[0] = bgp->last_error_code & 0x00FF0000 >> 16;
+  err[1] = bgp->last_error_code & 0x000000FF;
+}
+
+static void
+snmp_bgp_reg_failed(struct snmp_proto *p, const struct agentx_response *res, struct snmp_registration *reg)
+{
+  (void) res;
+  (void) reg;
+  snmp_reset(p);
+}
+
+/*
+ * snmp_bgp_fsm_state - extract BGP FSM state for SNMP BGP4-MIB
+ * @bgp_proto: BGP instance
+ *
+ * Return FSM state in BGP4-MIB encoding
+ */
+static inline uint
+snmp_bgp_fsm_state(const struct bgp_proto *bgp_proto)
+{
+  const struct bgp_conn *bgp_conn = bgp_proto->conn;
+  const struct bgp_conn *bgp_in = &bgp_proto->incoming_conn;
+  const struct bgp_conn *bgp_out = &bgp_proto->outgoing_conn;
+
+  if (bgp_conn)
+    return bgp_conn->state + 1;
+
+  if (MAX(bgp_in->state, bgp_out->state) == BS_CLOSE &&
+      MIN(bgp_in->state, bgp_out->state) != BS_CLOSE)
+    return MIN(bgp_in->state, bgp_out->state) + 1;
+  if (MIN(bgp_in->state, bgp_out->state) == BS_CLOSE)
+    return BS_IDLE;
+
+  return MAX(bgp_in->state, bgp_out->state) + 1;
+}
+
+
+/*
+ * snmp_bgp_notify_common - common functionaly for BGP4-MIB notifications
+ * @p: SNMP protocol instance
+ * @type: type of notification send - either established or backward transition
+ * @ip4: IPv4 remote addr
+ * @last_error: 2 bytes of BGP last error
+ * @state_val: BGP peer state as defined in MIB
+ */
+static void
+snmp_bgp_notify_common(struct snmp_proto *p, uint type, ip4_addr ip4, char last_error[], uint state_val)
+{
+  uint sz = (uint) (snmp_varbind_size_from_len(9, AGENTX_IP_ADDRESS, 0)
+      + snmp_varbind_size_from_len(9, AGENTX_OCTET_STRING, 2)
+      + snmp_varbind_size_from_len(9, AGENTX_INTEGER, 0));
+
+  u32 trap_ids[] = { 1, 0, type };
+  STATIC_ASSERT(ARRAY_SIZE(trap_ids) == 3);
+  /* additional size for trap identification, here either
+   *  bgpEstablishedNotification or bgpBackwardTransNotification (see below) */
+  void *data = tmp_alloc(snmp_oid_size_from_len(ARRAY_SIZE(trap_ids)) + sz);
+  struct oid *head = data;
+
+  { /* trap id BGP4-MIB::bgpEstablishedNotification (.1.3.6.1.2.15.0.1)
+     *	or BGP4-MIB::bgpBackwardTransNotification (.1.3.6.1.2.15.0.2) */
+    head->n_subid = ARRAY_SIZE(trap_ids);
+    head->prefix = SNMP_MGMT;
+    head->include = head->reserved = 0;
+
+    for (uint i = 0; i < head->n_subid; i++)
+      head->ids[i] = trap_ids[i];
+  }
+
+  data += sz;
+  struct agentx_varbind *addr_vb = data;
+  struct agentx_varbind *error_vb = \
+    data + snmp_varbind_size_from_len(9, AGENTX_IP_ADDRESS, 0);
+  struct agentx_varbind *state_vb = \
+    (void *) error_vb + snmp_varbind_size_from_len(9, AGENTX_OCTET_STRING, 2);
+
+  u32 oid_ids[] = {
+    SNMP_MIB_2, SNMP_BGP4_MIB, BGP4_MIB_PEER_TABLE, BGP4_MIB_PEER_ENTRY
+  };
+
+  /*
+   * The n_subid is 9 in all cases because all are rows entries of
+   * BGP4-MIB::bgpPeerTable
+   *  BGP4-MIB::bgpPeerRemoteAddr = .1.3.6.1.[2].1.15.3.1.7.a.b.c.d
+   * where .1.3.6.1 is internet prefix, .[2] is SNMP_MGMT,
+   * .1.15.3.1.7.a.b.c.d has 9 elements (a.b.c.d are IP addr bytes)
+   *  Here subidentifier 7 is entry type bgpPeerRemoteAddr.
+   */
+  #define PEER_TABLE_ENTRY 9
+  #define ENTRY_TYPE 4
+
+  { /* BGP4-MIB::bgpPeerRemoteAddr */
+    struct oid *addr = &addr_vb->name;
+    *addr = (struct oid) {
+      .n_subid = PEER_TABLE_ENTRY, .prefix = SNMP_MGMT, .include = 0,
+      .reserved = 0,
+    };
+    for (uint i = 0; i < ARRAY_SIZE(oid_ids); i++)
+      addr->ids[i] = oid_ids[i];
+    addr->ids[ENTRY_TYPE] = BGP4_MIB_REMOTE_ADDR;
+    ip4_to_oid(addr, ip4);
+  }
+  /* We have enough space inside the TX buffer prepared */
+  struct snmp_pdu dummy = { 0 };
+  dummy.sr_vb_start = addr_vb;
+  snmp_varbind_ip4(&dummy, ip4);
+
+  { /* BGP4-MIB::bgpPeerLastError */
+    struct oid *error = &error_vb->name;
+    *error = (struct oid) {
+      .n_subid = PEER_TABLE_ENTRY, .prefix = SNMP_MGMT, .include = 0,
+      .reserved = 0,
+    };
+    for (uint i = 0; i < ARRAY_SIZE(oid_ids); i++)
+      error->ids[i] = oid_ids[i];
+    error->ids[ENTRY_TYPE] = BGP4_MIB_LAST_ERROR;
+    ip4_to_oid(error, ip4);
+  }
+
+  dummy.sr_vb_start = error_vb;
+  snmp_varbind_nstr(&dummy, last_error, 2);
+
+  { /* BGP4-MIB::bgpPeerState */
+    struct oid *state = &state_vb->name;
+    *state = (struct oid) {
+      .n_subid = PEER_TABLE_ENTRY, .prefix = SNMP_MGMT, .include = 0,
+      .reserved = 0,
+    };
+    for (uint i = 0; i < ARRAY_SIZE(oid_ids); i++)
+      state->ids[i] = oid_ids[i];
+    state->ids[ENTRY_TYPE] = BGP4_MIB_STATE;
+    ip4_to_oid(state, ip4);
+  }
+
+  dummy.sr_vb_start = state_vb;
+  snmp_varbind_int(&dummy, state_val);
+
+  /* We do not send the systemUpTime.0 */
+  snmp_notify_pdu(p, head, data, sz, 0);
+
+  #undef OID_N_SUBID
+}
+
+static void
+snmp_bgp_notify_wrapper(struct snmp_proto *p, struct bgp_proto *bgp, uint type)
+{
+  /* possibly incorrect cast */
+  ip4_addr ip4 = ipa_to_ip4(bgp->remote_ip);
+  char last_error[2];
+  snmp_bgp_last_error(bgp, last_error);
+  uint state_val = snmp_bgp_fsm_state(bgp);
+  snmp_bgp_notify_common(p, type, ip4, last_error, state_val);
+}
+
+void UNUSED
+snmp_bgp_notify_established(struct snmp_proto *p, struct bgp_proto *bgp)
+{
+  snmp_bgp_notify_wrapper(p, bgp, BGP4_MIB_ESTABLISHED_NOTIFICATION);
+}
+
+void UNUSED
+snmp_bgp_notify_backward_trans(struct snmp_proto *p, struct bgp_proto *bgp)
+{
+  snmp_bgp_notify_wrapper(p, bgp, BGP4_MIB_BACKWARD_TRANS_NOTIFICATION);
+}
+
+static int
+snmp_bgp_valid_ip4(const struct oid *o)
+{
+  return snmp_valid_ip4_index(o, 5);
+}
+
+static inline ip4_addr
+ip4_from_oid(const struct oid *o)
+{
+  return ip4_build(
+    o->n_subid > 5 ? (o->ids[5] & 0xff) : 0,
+    o->n_subid > 6 ? (o->ids[6] & 0xff) : 0,
+    o->n_subid > 7 ? (o->ids[7] & 0xff) : 0,
+    o->n_subid > 8 ? (o->ids[8] & 0xff) : 0
+  );
+}
+
+static inline void
+ip4_to_oid(struct oid *o, ip4_addr addr)
+{
+  u32 tmp = ip4_to_u32(addr);
+  ASSUME(o->n_subid >= 9);
+  o->ids[5] = (tmp & 0xFF000000) >> 24;
+  o->ids[6] = (tmp & 0x00FF0000) >> 16;
+  o->ids[7] = (tmp & 0x0000FF00) >>  8;
+  o->ids[8] = (tmp & 0x000000FF) >>  0;
+}
+
+static inline enum snmp_search_res
+populate_bgp4(struct snmp_pdu *c, ip4_addr *addr, const struct bgp_proto **proto, const struct bgp_conn
+**conn, const struct bgp_stats **stats, const struct bgp_config **config)
+{
+  const struct oid * const oid = &c->sr_vb_start->name;
+  if (snmp_bgp_valid_ip4(oid) && oid->n_subid == 9)
+    *addr = ip4_from_oid(oid);
+  else
+    return SNMP_SEARCH_NO_INSTANCE;
+
+  struct snmp_bgp_peer *pe = snmp_hash_find(c->p, *addr);
+  if (!pe)
+    return SNMP_SEARCH_NO_INSTANCE;
+
+  const struct bgp_proto *bgp_proto;
+  *proto = bgp_proto = pe->bgp_proto;
+  if (!ipa_is_ip4(bgp_proto->remote_ip))
+  {
+    c->error = AGENTX_RES_GEN_ERROR;
+    return SNMP_SEARCH_NO_INSTANCE;
+  }
+
+  ip4_addr proto_ip = ipa_to_ip4(bgp_proto->remote_ip);
+  if (!ip4_equal(proto_ip, pe->peer_ip))
+  {
+    /* Here, we could be in problem as the bgp_proto IP address could be changed */
+    c->error = AGENTX_RES_GEN_ERROR;
+    return SNMP_SEARCH_NO_INSTANCE;
+  }
+
+  *conn = bgp_proto->conn;
+  *stats = &bgp_proto->stats;
+  *config = bgp_proto->cf;
+
+  return SNMP_SEARCH_OK;
+}
+
+/*
+ *
+ *    MIB tree fill hooks
+ *
+ */
+
+static enum snmp_search_res
+fill_bgp_version(struct mib_walk_state *walk UNUSED, struct snmp_pdu *c)
+{
+  if (c->sr_vb_start->name.n_subid != 4)
+    return SNMP_SEARCH_NO_INSTANCE;
+  c->size -= snmp_str_size_from_len(1);
+  snmp_varbind_nstr(c, BGP4_VERSIONS, 1);
+  return SNMP_SEARCH_OK;
+}
+
+static enum snmp_search_res
+fill_local_as(struct mib_walk_state *walk UNUSED, struct snmp_pdu *c)
+{
+  if (c->sr_vb_start->name.n_subid != 4)
+    return SNMP_SEARCH_NO_INSTANCE;
+  snmp_varbind_int(c, c->p->bgp4_local_as);
+  return SNMP_SEARCH_OK;
+}
+
+static enum snmp_search_res
+fill_peer_id(struct mib_walk_state *walk UNUSED, struct snmp_pdu *c)
+{
+  enum snmp_search_res res;
+  DECLARE_BGP4(addr, bgp_proto, bgp_conn, bgp_stats, bgp_conf);
+  res = POPULATE_BGP4(addr, bgp_proto, bgp_conn, bgp_stats, bgp_conf);
+  if (res != SNMP_SEARCH_OK)
+    return res;
+
+  uint fsm_state = snmp_bgp_fsm_state(bgp_proto);
+
+  if (fsm_state == BGP4_MIB_OPENCONFIRM || fsm_state == BGP4_MIB_ESTABLISHED)
+    // TODO last
+    snmp_varbind_ip4(c, ip4_from_u32(bgp_proto->remote_id));
+  else
+    snmp_varbind_ip4(c, IP4_NONE);
+  return SNMP_SEARCH_OK;
+}
+
+static enum snmp_search_res
+fill_peer_state(struct mib_walk_state *walk UNUSED, struct snmp_pdu *c)
+{
+  enum snmp_search_res res;
+  DECLARE_BGP4(addr, bgp_proto, bgp_conn, bgp_stats, bgp_conf);
+  res = POPULATE_BGP4(addr, bgp_proto, bgp_conn, bgp_stats, bgp_conf);
+  if (res != SNMP_SEARCH_OK)
+    return res;
+
+  uint fsm_state = snmp_bgp_fsm_state(bgp_proto);
+
+  snmp_varbind_int(c, fsm_state);
+  return SNMP_SEARCH_OK;
+}
+
+static enum snmp_search_res
+fill_admin_status(struct mib_walk_state *walk UNUSED, struct snmp_pdu *c)
+{
+  enum snmp_search_res res;
+  DECLARE_BGP4(addr, bgp_proto, bgp_conn, bgp_stats, bgp_conf);
+  res = POPULATE_BGP4(addr, bgp_proto, bgp_conn, bgp_stats, bgp_conf);
+  if (res != SNMP_SEARCH_OK)
+    return res;
+
+  if (bgp_proto->p.disabled)
+    snmp_varbind_int(c, BGP4_ADMIN_STOP);
+  else
+    snmp_varbind_int(c, BGP4_ADMIN_START);
+  return SNMP_SEARCH_OK;
+}
+
+static enum snmp_search_res
+fill_neg_version(struct mib_walk_state *walk UNUSED, struct snmp_pdu *c)
+{
+  enum snmp_search_res res;
+  DECLARE_BGP4(addr, bgp_proto, bgp_conn, bgp_stats, bgp_conf);
+  res = POPULATE_BGP4(addr, bgp_proto, bgp_conn, bgp_stats, bgp_conf);
+  if (res != SNMP_SEARCH_OK)
+    return res;
+
+  uint fsm_state = snmp_bgp_fsm_state(bgp_proto);
+
+  if (fsm_state == BGP4_MIB_ESTABLISHED || fsm_state == BGP4_MIB_ESTABLISHED)
+    snmp_varbind_int(c, BGP4_MIB_NEGOTIATED_VER_VALUE);
+  else
+    snmp_varbind_int(c, BGP4_MIB_NEGOTIATED_VER_NO_VALUE);
+  return SNMP_SEARCH_OK;
+}
+
+static enum snmp_search_res
+fill_local_addr(struct mib_walk_state *walk UNUSED, struct snmp_pdu *c)
+{
+  enum snmp_search_res res;
+  DECLARE_BGP4(addr, bgp_proto, bgp_conn, bgp_stats, bgp_conf);
+  res = POPULATE_BGP4(addr, bgp_proto, bgp_conn, bgp_stats, bgp_conf);
+
+  if (res != SNMP_SEARCH_OK)
+    return res;
+
+  snmp_varbind_ip4(c, ipa_to_ip4(bgp_proto->local_ip));
+  return SNMP_SEARCH_OK;
+}
+
+static enum snmp_search_res
+fill_local_port(struct mib_walk_state *walk UNUSED, struct snmp_pdu *c)
+{
+  enum snmp_search_res res;
+  DECLARE_BGP4(addr, bgp_proto, bgp_conn, bgp_stats, bgp_conf);
+  res = POPULATE_BGP4(addr, bgp_proto, bgp_conn, bgp_stats, bgp_conf);
+  if (res != SNMP_SEARCH_OK)
+    return res;
+
+  snmp_varbind_int(c, bgp_conf->local_port);
+  return SNMP_SEARCH_OK;
+}
+
+static enum snmp_search_res
+fill_remote_addr(struct mib_walk_state *walk UNUSED, struct snmp_pdu *c)
+{
+  enum snmp_search_res res;
+  DECLARE_BGP4(addr, bgp_proto, bgp_conn, bgp_stats, bgp_conf);
+  res = POPULATE_BGP4(addr, bgp_proto, bgp_conn, bgp_stats, bgp_conf);
+  if (res != SNMP_SEARCH_OK)
+    return res;
+
+  snmp_varbind_ip4(c, ipa_to_ip4(bgp_proto->remote_ip));
+  return SNMP_SEARCH_OK;
+}
+
+static enum snmp_search_res
+fill_remote_port(struct mib_walk_state *walk UNUSED, struct snmp_pdu *c)
+{
+  enum snmp_search_res res;
+  DECLARE_BGP4(addr, bgp_proto, bgp_conn, bgp_stats, bgp_conf);
+  res = POPULATE_BGP4(addr, bgp_proto, bgp_conn, bgp_stats, bgp_conf);
+  if (res != SNMP_SEARCH_OK)
+    return res;
+
+  snmp_varbind_int(c, bgp_conf->remote_port);
+  return SNMP_SEARCH_OK;
+}
+
+static enum snmp_search_res
+fill_remote_as(struct mib_walk_state *walk UNUSED, struct snmp_pdu *c)
+{
+  enum snmp_search_res res;
+  DECLARE_BGP4(addr, bgp_proto, bgp_conn, bgp_stats, bgp_conf);
+  res = POPULATE_BGP4(addr, bgp_proto, bgp_conn, bgp_stats, bgp_conf);
+  if (res != SNMP_SEARCH_OK)
+    return res;
+
+  snmp_varbind_int(c, bgp_proto->remote_as);
+  return SNMP_SEARCH_OK;
+}
+
+static enum snmp_search_res
+fill_in_updates(struct mib_walk_state *walk UNUSED, struct snmp_pdu *c)
+{
+  enum snmp_search_res res;
+  DECLARE_BGP4(addr, bgp_proto, bgp_conn, bgp_stats, bgp_conf);
+  res = POPULATE_BGP4(addr, bgp_proto, bgp_conn, bgp_stats, bgp_conf);
+  if (res != SNMP_SEARCH_OK)
+    return res;
+
+  snmp_varbind_counter32(c, bgp_stats->rx_updates);
+  return SNMP_SEARCH_OK;
+}
+
+static enum snmp_search_res
+fill_out_updates(struct mib_walk_state *walk UNUSED, struct snmp_pdu *c)
+{
+  enum snmp_search_res res;
+  DECLARE_BGP4(addr, bgp_proto, bgp_conn, bgp_stats, bgp_conf);
+  res = POPULATE_BGP4(addr, bgp_proto, bgp_conn, bgp_stats, bgp_conf);
+  if (res != SNMP_SEARCH_OK)
+    return res;
+
+  snmp_varbind_counter32(c, bgp_stats->tx_updates);
+  return SNMP_SEARCH_OK;
+}
+
+static enum snmp_search_res
+fill_in_total_msg(struct mib_walk_state *walk UNUSED, struct snmp_pdu *c)
+{
+  enum snmp_search_res res;
+  DECLARE_BGP4(addr, bgp_proto, bgp_conn, bgp_stats, bgp_conf);
+  res = POPULATE_BGP4(addr, bgp_proto, bgp_conn, bgp_stats, bgp_conf);
+  if (res != SNMP_SEARCH_OK)
+    return res;
+
+  snmp_varbind_counter32(c, bgp_stats->rx_messages);
+  return SNMP_SEARCH_OK;
+}
+
+static enum snmp_search_res
+fill_out_total_msg(struct mib_walk_state *walk UNUSED, struct snmp_pdu *c)
+{
+  enum snmp_search_res res;
+  DECLARE_BGP4(addr, bgp_proto, bgp_conn, bgp_stats, bgp_conf);
+  res = POPULATE_BGP4(addr, bgp_proto, bgp_conn, bgp_stats, bgp_conf);
+  if (res != SNMP_SEARCH_OK)
+    return res;
+
+  snmp_varbind_counter32(c, bgp_stats->tx_messages);
+  return SNMP_SEARCH_OK;
+}
+
+static enum snmp_search_res
+fill_last_err(struct mib_walk_state *walk UNUSED, struct snmp_pdu *c)
+{
+  enum snmp_search_res res;
+  DECLARE_BGP4(addr, bgp_proto, bgp_conn, bgp_stats, bgp_conf);
+  res = POPULATE_BGP4(addr, bgp_proto, bgp_conn, bgp_stats, bgp_conf);
+  if (res != SNMP_SEARCH_OK)
+    return res;
+
+  char last_error[2];
+  snmp_bgp_last_error(bgp_proto, last_error);
+
+  snmp_varbind_nstr(c, last_error, 2);
+  return SNMP_SEARCH_OK;
+}
+
+static enum snmp_search_res
+fill_established_trans(struct mib_walk_state *walk UNUSED, struct snmp_pdu *c)
+{
+  enum snmp_search_res res;
+  DECLARE_BGP4(addr, bgp_proto, bgp_conn, bgp_stats, bgp_conf);
+  res = POPULATE_BGP4(addr, bgp_proto, bgp_conn, bgp_stats, bgp_conf);
+  if (res != SNMP_SEARCH_OK)
+    return res;
+
+  snmp_varbind_counter32(c,
+      bgp_stats->fsm_established_transitions);
+  return SNMP_SEARCH_OK;
+}
+
+static enum snmp_search_res
+fill_established_time(struct mib_walk_state *walk UNUSED, struct snmp_pdu *c)
+{
+  enum snmp_search_res res;
+  DECLARE_BGP4(addr, bgp_proto, bgp_conn, bgp_stats, bgp_conf);
+  res = POPULATE_BGP4(addr, bgp_proto, bgp_conn, bgp_stats, bgp_conf);
+  if (res != SNMP_SEARCH_OK)
+    return res;
+
+  snmp_varbind_gauge32(c,
+	(current_time() - bgp_proto->last_established) TO_S);
+  return SNMP_SEARCH_OK;
+}
+
+static enum snmp_search_res
+fill_retry_interval(struct mib_walk_state *walk UNUSED, struct snmp_pdu *c)
+{
+  enum snmp_search_res res;
+  DECLARE_BGP4(addr, bgp_proto, bgp_conn, bgp_stats, bgp_conf);
+  res = POPULATE_BGP4(addr, bgp_proto, bgp_conn, bgp_stats, bgp_conf);
+  if (res != SNMP_SEARCH_OK)
+    return res;
+
+  snmp_varbind_int(c, bgp_conf->connect_retry_time);
+  return SNMP_SEARCH_OK;
+}
+
+static enum snmp_search_res
+fill_hold_time(struct mib_walk_state *walk UNUSED, struct snmp_pdu *c)
+{
+  enum snmp_search_res res;
+  DECLARE_BGP4(addr, bgp_proto, bgp_conn, bgp_stats, bgp_conf);
+  res = POPULATE_BGP4(addr, bgp_proto, bgp_conn, bgp_stats, bgp_conf);
+  if (res != SNMP_SEARCH_OK)
+    return res;
+
+  snmp_varbind_int(c, (bgp_conn) ?  bgp_conn->hold_time : 0);
+  return SNMP_SEARCH_OK;
+}
+
+static enum snmp_search_res
+fill_keep_alive(struct mib_walk_state *walk UNUSED, struct snmp_pdu *c)
+{
+  enum snmp_search_res res;
+  DECLARE_BGP4(addr, bgp_proto, bgp_conn, bgp_stats, bgp_conf);
+  res = POPULATE_BGP4(addr, bgp_proto, bgp_conn, bgp_stats, bgp_conf);
+  if (res != SNMP_SEARCH_OK)
+    return res;
+
+  if (!bgp_conf->hold_time)
+    snmp_varbind_int(c, 0);
+  else
+    snmp_varbind_int(c,
+      (bgp_conn) ? bgp_conn->keepalive_time : 0);
+  return SNMP_SEARCH_OK;
+}
+
+static enum snmp_search_res
+fill_hold_time_conf(struct mib_walk_state *walk UNUSED, struct snmp_pdu *c)
+{
+  enum snmp_search_res res;
+  DECLARE_BGP4(addr, bgp_proto, bgp_conn, bgp_stats, bgp_conf);
+  res = POPULATE_BGP4(addr, bgp_proto, bgp_conn, bgp_stats, bgp_conf);
+  if (res != SNMP_SEARCH_OK)
+    return res;
+
+  snmp_varbind_int(c, bgp_conf->hold_time);
+  return SNMP_SEARCH_OK;
+}
+
+static enum snmp_search_res
+fill_keep_alive_conf(struct mib_walk_state *walk UNUSED, struct snmp_pdu *c)
+{
+  enum snmp_search_res res;
+  DECLARE_BGP4(addr, bgp_proto, bgp_conn, bgp_stats, bgp_conf);
+  res = POPULATE_BGP4(addr, bgp_proto, bgp_conn, bgp_stats, bgp_conf);
+  if (res != SNMP_SEARCH_OK)
+    return res;
+
+  if (!bgp_conf->keepalive_time)
+    snmp_varbind_int(c, 0);
+  else
+    snmp_varbind_int(c,
+      (bgp_conn) ? bgp_conn->keepalive_time : 0);
+  return SNMP_SEARCH_OK;
+}
+
+static enum snmp_search_res
+fill_min_as_org_interval(struct mib_walk_state *walk UNUSED, struct snmp_pdu *c)
+{
+  enum snmp_search_res res;
+  DECLARE_BGP4(addr, bgp_proto, bgp_conn, bgp_stats, bgp_conf);
+  res = POPULATE_BGP4(addr, bgp_proto, bgp_conn, bgp_stats, bgp_conf);
+  if (res != SNMP_SEARCH_OK)
+    return res;
+
+  /* value should be in 1..65535 but is not supported by bird */
+  snmp_varbind_int(c, 0);
+  return SNMP_SEARCH_OK;
+}
+
+static enum snmp_search_res
+fill_route_adv_interval(struct mib_walk_state *walk UNUSED, struct snmp_pdu *c)
+{
+  enum snmp_search_res res;
+  DECLARE_BGP4(addr, bgp_proto, bgp_conn, bgp_stats, bgp_conf);
+  res = POPULATE_BGP4(addr, bgp_proto, bgp_conn, bgp_stats, bgp_conf);
+  if (res != SNMP_SEARCH_OK)
+    return res;
+
+  /* value should be in 1..65535 but is not supported by bird */
+  snmp_varbind_int(c, 0);
+  return SNMP_SEARCH_OK;
+}
+
+static enum snmp_search_res
+fill_in_update_elapsed_time(struct mib_walk_state *walk UNUSED, struct snmp_pdu *c)
+{
+  enum snmp_search_res res;
+  DECLARE_BGP4(addr, bgp_proto, bgp_conn, bgp_stats, bgp_conf);
+  res = POPULATE_BGP4(addr, bgp_proto, bgp_conn, bgp_stats, bgp_conf);
+  if (res != SNMP_SEARCH_OK)
+    return res;
+
+  snmp_varbind_gauge32(c,
+    (current_time() - bgp_proto->last_rx_update) TO_S
+  );
+  return SNMP_SEARCH_OK;
+}
+
+static enum snmp_search_res
+fill_local_id(struct mib_walk_state *walk UNUSED, struct snmp_pdu *c)
+{
+  if (c->sr_vb_start->name.n_subid != 4)
+    return SNMP_SEARCH_NO_INSTANCE;
+  ip4_addr router_id_ip = ip4_from_u32(c->p->bgp4_local_id);
+  snmp_varbind_ip4(c, router_id_ip);
+  return SNMP_SEARCH_OK;
+}
+
+/*
+ * bgp4_next_peer - find next BGP peer with IPv4 address
+ * @state: MIB tree walk state
+ * @c: SNMP PDU context data
+ *
+ * Update TX buffer VarBind name to next peer address.
+ */
+static int
+bgp4_next_peer(struct mib_walk_state *state, struct snmp_pdu *c)
+{
+  struct oid *oid = &c->sr_vb_start->name;
+
+  /* BGP4-MIB::bgpPeerIdentifier */
+  STATIC_OID(9) bgp4_peer_id = STATIC_OID_INITIALIZER(9, SNMP_MGMT,
+    /* ids */ SNMP_MIB_2, SNMP_BGP4_MIB,
+      BGP4_MIB_PEER_TABLE, BGP4_MIB_PEER_ENTRY, BGP4_MIB_PEER_IDENTIFIER);
+
+  ip4_addr ip4 = ip4_from_oid(oid);
+
+  const struct oid *peer_oid = (const struct oid *) &bgp4_peer_id;
+
+  int precise = 1;
+  if (oid->n_subid > 9)
+    precise = 0;
+
+  if (oid->n_subid != 9 || snmp_oid_compare(oid, peer_oid) < 0)
+  {
+    int old = snmp_oid_size(oid);
+    int new = snmp_oid_size(peer_oid);
+
+    if (new - old > 0 && snmp_tbuf_reserve(c, new - old))
+      oid = &c->sr_vb_start->name;
+
+    c->buffer += (new - old);
+
+    snmp_oid_copy(oid, peer_oid);
+    oid->include = 1;
+  }
+
+  ASSUME(oid->n_subid == 9);
+  /* Stack has one more node for empty prefix (tree root) */
+  ASSUME(state->stack_pos > 10);
+  oid->ids[4] = state->stack[10]->empty.id;
+
+  net_addr net;
+  net_fill_ip4(&net, ip4, IP4_MAX_PREFIX_LENGTH);
+  struct f_trie_walk_state ws;
+
+  int match = trie_walk_init(&ws, c->p->bgp_trie, &net, 1);
+
+  if (match && oid->include && precise)
+  {
+    oid->include = 0;
+    ip4_to_oid(oid, ip4);
+    return 0;
+  }
+
+  /* We skip the first match as we should not include ip address in oid */
+  if (match)
+   (void) trie_walk_next(&ws, &net);
+
+  if (trie_walk_next(&ws, &net))
+  {
+    ASSUME(oid->n_subid == 9);
+    ip4_addr res = ipa_to_ip4(net_prefix(&net));
+    ip4_to_oid(oid, res);
+    return 0;
+  }
+
+  return 1;
+}
+
+/*
+ * snmp_bgp4_show_info - display info BGP4-MIB
+ * @p: SNMP protocol instance
+ *
+ * Print info about BGP4-MIB status and bound bgp peers to cli.
+ */
+void
+snmp_bgp4_show_info(struct snmp_proto *p)
+{
+  /* TODO: Use special code (not -1006) for printing MIB, or BGP4-MIB data?
+   * don't forget add it into doc/reply_code */
+  cli_msg(-1006, "    BGP4-MIB");
+  cli_msg(-1006, "      Local AS %u", p->bgp4_local_as);
+  cli_msg(-1006, "      Local router id %R", p->bgp4_local_id);
+  cli_msg(-1006, "      BGP peers");
+
+  if (p->bgp_hash.count == 0 || !snmp_is_active(p))
+  {
+    cli_msg(-1006, "        <no peers available>");
+  }
+
+  if (!snmp_is_active(p))
+    return;
+
+  HASH_WALK(p->bgp_hash, next, peer)
+  {
+    cli_msg(-1006, "        Protocol name: %s", peer->bgp_proto->p.name);
+    cli_msg(-1006, "          Remote IPv4 address: %I4", peer->peer_ip);
+    cli_msg(-1006, "          Remote router id %R", peer->bgp_proto->remote_id);
+    /* TODO: add peer connection local ip */
+  }
+  HASH_WALK_END;
+}
+
+void
+snmp_bgp4_register(struct snmp_proto *p)
+{
+  /* Register the whole BGP4-MIB::bgp root tree node */
+  struct snmp_registration *reg;
+  reg = snmp_registration_create(p, BGP4_MIB_ID);
+
+  struct oid *oid = mb_allocz(p->pool, sizeof(bgp4_mib_oid));
+  memcpy(oid, &bgp4_mib_oid, sizeof(bgp4_mib_oid));
+
+  reg->reg_hook_ok = NULL;
+  reg->reg_hook_fail = snmp_bgp_reg_failed;
+
+  /*
+   * We set both upper bound and index to zero, therefore only single OID
+   * is being registered.
+   */
+  snmp_register(p, oid, 0, 0, SNMP_REGISTER_TREE);
+}
+
+
+/*
+ * snmp_bgp4_start - prepare BGP4-MIB
+ * @p: SNMP protocol instance holding memory pool
+ * @with_mib_tree: flag choosing to insert BGP4-MIB into MIB tree
+ *
+ * This function create all runtime bindings to BGP procotol structures.
+ * It is gruaranteed that the BGP protocols exist.
+ */
+void
+snmp_bgp4_start(struct snmp_proto *p, int with_mib_tree)
+{
+  struct snmp_config *cf = SKIP_BACK(struct snmp_config, cf, p->p.cf);
+
+  /* Create binding to BGP protocols */
+  struct snmp_bond *b;
+  WALK_LIST(b, cf->bgp_entries)
+  {
+    const struct bgp_config *bgp_config = (struct bgp_config *) b->config;
+    const struct bgp_proto *bgp = SKIP_BACK(struct bgp_proto, p,
+      bgp_config->c.proto);
+
+    struct snmp_bgp_peer *peer = \
+      mb_alloc(p->pool, sizeof(struct snmp_bgp_peer));
+
+    peer->bgp_proto = bgp;
+    peer->peer_ip = ipa_to_ip4(bgp->remote_ip);
+
+    struct net_addr net;
+    net_fill_ip4(&net, ipa_to_ip4(bgp->remote_ip), IP4_MAX_PREFIX_LENGTH);
+    trie_add_prefix(p->bgp_trie, &net, IP4_MAX_PREFIX_LENGTH,
+      IP4_MAX_PREFIX_LENGTH);
+
+    snmp_hash_add_peer(p, peer);
+  }
+
+  if (!with_mib_tree)
+    return;
+
+  const STATIC_OID(4) bgp4_mib_peer_entry = STATIC_OID_INITIALIZER(4, SNMP_MGMT,
+    /* ids */ SNMP_MIB_2, SNMP_BGP4_MIB, BGP4_MIB_PEER_TABLE, BGP4_MIB_PEER_ENTRY);
+
+  (void) mib_tree_hint(p->pool, p->mib_tree,
+    (const struct oid *) &bgp4_mib_oid, BGP4_MIB_IDENTIFIER);
+  (void) mib_tree_hint(p->pool, p->mib_tree,
+    (const struct oid *) &bgp4_mib_peer_entry, BGP4_MIB_IN_UPDATE_ELAPSED_TIME);
+
+  mib_node_u *node;
+  struct mib_leaf *leaf;
+  STATIC_OID(4) bgp4_var = STATIC_OID_INITIALIZER(4, SNMP_MGMT,
+    /* ids */ SNMP_MIB_2, SNMP_BGP4_MIB, BGP4_MIB_VERSION, 0);
+
+  struct {
+    u32 id;
+    enum snmp_search_res (*filler)(struct mib_walk_state *state, struct snmp_pdu *c);
+    enum agentx_type type;
+    int size;
+  } leafs[] = {
+    {
+      .id = BGP4_MIB_VERSION,
+      .filler = fill_bgp_version,
+      .type = AGENTX_OCTET_STRING,
+      .size = snmp_str_size_from_len(sizeof(BGP4_VERSIONS)),
+    },
+    {
+      .id =  BGP4_MIB_LOCAL_AS,
+      .filler = fill_local_as,
+      .type = AGENTX_INTEGER,
+    },
+    {
+      .id =  BGP4_MIB_IDENTIFIER,
+      .filler = fill_local_id,
+      .type = AGENTX_IP_ADDRESS,
+    },
+  };
+
+  for (uint i = 0; i < ARRAY_SIZE(leafs); i++)
+  {
+    bgp4_var.ids[ARRAY_SIZE(bgp4_var.ids) - 2] = leafs[i].id;
+    node = mib_tree_add(p->pool, p->mib_tree, (const struct oid *) &bgp4_var, 1);
+
+    ASSUME(mib_node_is_leaf(node));
+    leaf = &node->leaf;
+
+    leaf->filler = leafs[i].filler;
+    leaf->call_next = NULL;
+    leaf->type = leafs[i].type;
+    leaf->size = leafs[i].size;
+  }
+
+  STATIC_OID(5) bgp4_entry_var = STATIC_OID_INITIALIZER(5, SNMP_MGMT,
+    /* ids */ SNMP_MIB_2, SNMP_BGP4_MIB,
+       BGP4_MIB_PEER_TABLE, BGP4_MIB_PEER_ENTRY, BGP4_MIB_PEER_IDENTIFIER);
+
+  struct {
+      enum snmp_search_res (*filler)(struct mib_walk_state *state, struct snmp_pdu *c);
+      enum agentx_type type;
+      int size;
+  } entry_leafs[] = {
+    [BGP4_MIB_PEER_IDENTIFIER] = {
+      .filler =	fill_peer_id,
+      .type = AGENTX_IP_ADDRESS,
+    },
+    [BGP4_MIB_STATE] = {
+      .filler = fill_peer_state,
+      .type = AGENTX_INTEGER,
+    },
+    [BGP4_MIB_ADMIN_STATUS] = {
+      .filler = fill_admin_status,
+      .type = AGENTX_INTEGER,
+    },
+    [BGP4_MIB_NEGOTIATED_VERSION] = {
+      .filler = fill_neg_version,
+      .type = AGENTX_INTEGER,
+    },
+    [BGP4_MIB_LOCAL_ADDR] = {
+      .filler = fill_local_addr,
+      .type = AGENTX_IP_ADDRESS,
+    },
+    [BGP4_MIB_LOCAL_PORT] = {
+      .filler = fill_local_port,
+      .type = AGENTX_INTEGER,
+    },
+    [BGP4_MIB_REMOTE_ADDR] = {
+      .filler = fill_remote_addr,
+      .type = AGENTX_IP_ADDRESS,
+    },
+    [BGP4_MIB_REMOTE_PORT] = {
+      .filler = fill_remote_port,
+      .type = AGENTX_INTEGER,
+    },
+    [BGP4_MIB_REMOTE_AS] = {
+      .filler = fill_remote_as,
+      .type = AGENTX_INTEGER,
+    },
+    [BGP4_MIB_RX_UPDATES] = {
+      .filler = fill_in_updates,
+      .type = AGENTX_COUNTER_32,
+    },
+    [BGP4_MIB_TX_UPDATES] = {
+      .filler = fill_out_updates,
+      .type = AGENTX_COUNTER_32,
+    },
+    [BGP4_MIB_RX_MESSAGES] = {
+      .filler = fill_in_total_msg,
+      .type = AGENTX_COUNTER_32,
+    },
+    [BGP4_MIB_TX_MESSAGES] = {
+      .filler = fill_out_total_msg,
+      .type = AGENTX_COUNTER_32,
+    },
+    [BGP4_MIB_LAST_ERROR] = {
+      .filler = fill_last_err,
+      .type = AGENTX_OCTET_STRING,
+      .size = snmp_str_size_from_len(2),
+    },
+    [BGP4_MIB_FSM_TRANSITIONS] = {
+      .filler = fill_established_trans,
+      .type = AGENTX_COUNTER_32,
+    },
+    [BGP4_MIB_FSM_ESTABLISHED_TIME] = {
+      .filler = fill_established_time,
+      .type = AGENTX_GAUGE_32,
+    },
+    [BGP4_MIB_RETRY_INTERVAL] = {
+      .filler = fill_retry_interval,
+      .type = AGENTX_INTEGER,
+    },
+    [BGP4_MIB_HOLD_TIME] = {
+      .filler = fill_hold_time,
+      .type = AGENTX_INTEGER,
+    },
+    [BGP4_MIB_KEEPALIVE] = {
+      .filler = fill_keep_alive,
+      .type = AGENTX_INTEGER,
+    },
+    [BGP4_MIB_HOLD_TIME_CONFIGURED] = {
+      .filler = fill_hold_time_conf,
+      .type = AGENTX_INTEGER,
+    },
+    [BGP4_MIB_KEEPALIVE_CONFIGURED] = {
+      .filler = fill_keep_alive_conf,
+      .type = AGENTX_INTEGER,
+    },
+    [BGP4_MIB_ORIGINATION_INTERVAL] = {
+      .filler = fill_min_as_org_interval,
+      .type = AGENTX_INTEGER,
+    },
+    [BGP4_MIB_MIN_ROUTE_ADVERTISEMENT] = {
+      .filler = fill_route_adv_interval,
+      .type = AGENTX_INTEGER,
+    },
+    [BGP4_MIB_IN_UPDATE_ELAPSED_TIME] = {
+      .filler = fill_in_update_elapsed_time,
+      .type = AGENTX_GAUGE_32,
+    },
+  }; /* struct _anon entry_leafs[] */
+
+  for (enum bgp4_mib_peer_entry_row e = BGP4_MIB_PEER_IDENTIFIER;
+      e <= BGP4_MIB_IN_UPDATE_ELAPSED_TIME; e++)
+  {
+    bgp4_entry_var.ids[ARRAY_SIZE(bgp4_entry_var.ids) - 1] = (u32) e;
+    node = mib_tree_add(p->pool, p->mib_tree, (const struct oid *) &bgp4_entry_var, 1);
+
+    ASSUME(mib_node_is_leaf(node));
+    leaf = &node->leaf;
+
+    leaf->filler = entry_leafs[e].filler;
+    leaf->call_next = bgp4_next_peer;
+    leaf->type = entry_leafs[e].type;
+    leaf->size = entry_leafs[e].size;
+  }
+}
diff --git a/proto/snmp/bgp4_mib.h b/proto/snmp/bgp4_mib.h
new file mode 100644
index 00000000..21a6767f
--- /dev/null
+++ b/proto/snmp/bgp4_mib.h
@@ -0,0 +1,97 @@
+#ifndef _BIRD_SNMP_BGP4_MIB_H_
+#define _BIRD_SNMP_BGP4_MIB_H_
+
+#include "snmp.h"
+#include "proto/bgp/bgp.h"
+#include "subagent.h"
+
+/* BGP4-MIB root identifier is found in snmp.h as SNMP_BGP4_MIB */
+
+/* peers attributes */
+enum bgp4_mib_peer_entry_row {
+  BGP4_MIB_PEER_IDENTIFIER	    =  1,
+  BGP4_MIB_STATE		    =  2,
+  BGP4_MIB_ADMIN_STATUS		    =  3,   /* in read-only mode */
+  BGP4_MIB_NEGOTIATED_VERSION	    =  4,
+  BGP4_MIB_LOCAL_ADDR		    =  5,
+  BGP4_MIB_LOCAL_PORT		    =  6,
+  BGP4_MIB_REMOTE_ADDR		    =  7,
+  BGP4_MIB_REMOTE_PORT		    =  8,
+  BGP4_MIB_REMOTE_AS		    =  9,
+  BGP4_MIB_RX_UPDATES		    = 10,   /* in updates */
+  BGP4_MIB_TX_UPDATES		    = 11,   /* out updates */
+  BGP4_MIB_RX_MESSAGES		    = 12,   /* in total messages */
+  BGP4_MIB_TX_MESSAGES		    = 13,   /* out total messages */
+  BGP4_MIB_LAST_ERROR		    = 14,
+  BGP4_MIB_FSM_TRANSITIONS	    = 15,   /* FSM established transitions */
+  BGP4_MIB_FSM_ESTABLISHED_TIME	    = 16,
+  BGP4_MIB_RETRY_INTERVAL	    = 17,
+  BGP4_MIB_HOLD_TIME		    = 18,   /* in read-only mode */
+  BGP4_MIB_KEEPALIVE		    = 19,   /* in read-only mode */
+  BGP4_MIB_HOLD_TIME_CONFIGURED	    = 20,
+  BGP4_MIB_KEEPALIVE_CONFIGURED	    = 21,
+  BGP4_MIB_ORIGINATION_INTERVAL	    = 22,   /* UNSUPPORTED - 0 */
+  BGP4_MIB_MIN_ROUTE_ADVERTISEMENT  = 23,   /* UNSUPPORTED - 0 */
+  BGP4_MIB_IN_UPDATE_ELAPSED_TIME   = 24,
+} PACKED;
+
+/* version of BGP, here BGP-4 */
+#define BGP4_VERSIONS ((char[]) { 0x10 }) /* OID BGP4-MIB::bgpVersion */
+
+/* values for BGP4-MIB::bgpPeerNegotiatedVersion */
+#define BGP4_MIB_NEGOTIATED_VER_VALUE 4
+#define BGP4_MIB_NEGOTIATED_VER_NO_VALUE 0
+
+/* values for BGP4-MIB::bgpPeerAdminStatus */
+enum bgp4_admin_status {
+  BGP4_ADMIN_STOP = 1,
+  BGP4_ADMIN_START = 2,
+};
+
+void snmp_bgp4_start(struct snmp_proto *p, int with_mib);
+void snmp_bgp4_register(struct snmp_proto *p);
+void snmp_bgp4_show_info(struct snmp_proto *p);
+
+enum snmp_search_res snmp_bgp_search(struct snmp_proto *p, struct agentx_varbind **vb_search, const struct oid *o_end, struct snmp_pdu *c);
+enum snmp_search_res snmp_bgp_search2(struct snmp_proto *p, struct oid **searched, const struct oid *o_end, uint contid);
+void snmp_bgp_fill(struct snmp_proto *p, struct agentx_varbind **vb, struct snmp_pdu *c);
+//int snmp_bgp_testset(struct snmp_proto *p, const struct agentx_varbind *vb, void* tr, struct oid *oid, uint pkt_type);
+
+void snmp_bgp_notify_established(struct snmp_proto *p, struct bgp_proto *bgp);
+void snmp_bgp_notify_backward_trans(struct snmp_proto *p, struct bgp_proto *bgp);
+
+enum bgp4_mib_rows {
+  BGP4_MIB_VERSION    = 1,
+  BGP4_MIB_LOCAL_AS   = 2,
+  BGP4_MIB_PEER_TABLE = 3,    /* subtable */
+  BGP4_MIB_IDENTIFIER = 4,    /* BGP4-MIB::bgpIdentifier local router id */
+};
+
+enum bgp4_mib_peer_table_rows {
+  BGP4_MIB_PEER_ENTRY = 1,
+};
+
+/* valid values for BGP4_MIB_STATE */
+enum bgp4_mib_bgp_states {
+  BGP4_MIB_IDLE = 1,
+  BGP4_MIB_CONNECT = 2,
+  BGP4_MIB_ACTIVE = 3,
+  BGP4_MIB_OPENSENT = 4,
+  BGP4_MIB_OPENCONFIRM = 5,
+  BGP4_MIB_ESTABLISHED = 6,
+};
+
+STATIC_ASSERT(BGP4_MIB_IDLE == BS_IDLE + 1);
+STATIC_ASSERT(BGP4_MIB_CONNECT == BS_CONNECT + 1);
+STATIC_ASSERT(BGP4_MIB_ACTIVE == BS_ACTIVE + 1);
+STATIC_ASSERT(BGP4_MIB_OPENSENT == BS_OPENSENT + 1);
+STATIC_ASSERT(BGP4_MIB_OPENCONFIRM == BS_OPENCONFIRM + 1);
+STATIC_ASSERT(BGP4_MIB_ESTABLISHED == BS_ESTABLISHED + 1);
+
+/* Traps OID sub-identifiers */
+enum bgp4_traps_subids {
+  BGP4_MIB_ESTABLISHED_NOTIFICATION = 1,
+  BGP4_MIB_BACKWARD_TRANS_NOTIFICATION = 2,
+};
+
+#endif
diff --git a/proto/snmp/config.Y b/proto/snmp/config.Y
new file mode 100644
index 00000000..4fe88708
--- /dev/null
+++ b/proto/snmp/config.Y
@@ -0,0 +1,171 @@
+/*
+ *	BIRD -- Statistics Protocol Configuration
+ *
+ *      (c) 2022 Vojtech Vilimek <vojtech.vilimek@nic.cz>
+ *      (c) 2022 CZ.NIC z.s.p.o.
+ *
+ *	Can be freely distributed and used under the terms of the GNU GPL.
+ */
+
+CF_HDR
+
+#include "proto/snmp/snmp.h"
+#include "proto/snmp/subagent.h"
+
+CF_DEFINES
+
+#define SNMP_CFG ((struct snmp_config *) this_proto)
+
+CF_DECLS
+
+CF_KEYWORDS(SNMP, PROTOCOL, LOCAL, AS, REMOTE, ADDRESS, PORT, DESCRIPTION,
+	    TIMEOUT, PRIORITY, CONTEXT, DEFAULT, MESSAGE, VERBOSE, AGENTX,
+	    SUBAGENT, MASTER, BGP4, MIB, REGISTRATION, PEER)
+
+CF_GRAMMAR
+
+proto: snmp_proto ;
+
+snmp_proto:
+   snmp_proto_start proto_name '{' snmp_proto_opts '}' ;
+
+snmp_proto_item:
+   proto_item
+ | bgp4_mib
+ | SOURCE ADDRESS ipa { SNMP_CFG->local_ip = $3; }
+ | AGENTX MASTER ADDRESS DEFAULT {
+    if (SNMP_CFG->trans_type != SNMP_TRANS_DEFAULT)
+      cf_error("Duplicit option remote address");
+  }
+ | AGENTX MASTER ADDRESS text {
+    if (SNMP_CFG->trans_type != SNMP_TRANS_DEFAULT)
+      cf_error("Duplicit option remote address");
+
+    if (strcmp($4, agentx_master_addr)) {
+      SNMP_CFG->master_path = $4;
+      SNMP_CFG->trans_type = SNMP_TRANS_UNIX;
+    }
+  }
+ | AGENTX MASTER ADDRESS ipa {
+    if (SNMP_CFG->trans_type != SNMP_TRANS_DEFAULT)
+      cf_error("Duplicit option agentx master address");
+
+    SNMP_CFG->master_ip = $4;
+    SNMP_CFG->trans_type = SNMP_TRANS_TCP;
+  }
+ | AGENTX MASTER ADDRESS ipa PORT expr {
+    if (SNMP_CFG->trans_type != SNMP_TRANS_DEFAULT)
+      cf_error("Duplicit option agentx master address");
+
+    if (($6 < 1) || ($6 > UINT16_MAX)) cf_error("Invalid port number");
+
+    SNMP_CFG->master_ip = $4;
+    SNMP_CFG->trans_type = SNMP_TRANS_TCP;
+    SNMP_CFG->master_port = $6;
+  }
+ | SUBAGENT DESCRIPTION text {
+    if (strlen($3) > UINT16_MAX - 1) cf_error("Description is too long");
+    SNMP_CFG->description = $3;
+  }
+ | REGISTRATION PRIORITY expr {
+    if ($3 > 255) cf_error("Registration priority must be in range 0-255");
+    SNMP_CFG->priority = $3;
+  }
+ | MESSAGE TIMEOUT expr_us {
+    /* TODO */
+    if ($3 TO_S > 255 || $3 TO_S < 1)
+      log(L_WARN "resolution of AgentX message timeout is from 1 to 255 s.");
+    if (($3 TO_S) - (int)($3 TO_S) > 0)
+      log(L_WARN "AgentX message timeout cannot use second fraction, "
+	"will use rounded up value.");
+    SNMP_CFG->timeout = $3;
+  }
+/*
+ | ERROR TIMEOUT expr_us {
+    / * TODO * /
+    SNMP_CFG->error_timeout = $3;
+  }
+ | RETRY TIME expr_us {
+    / * TODO * /
+    SNMP_CFG->retry_timeout = $3;
+  }
+*/
+ | START DELAY TIME expr_us { SNMP_CFG->startup_delay = $4; }
+ | VERBOSE bool { SNMP_CFG->verbose = $2; }
+ ;
+
+bgp4_mib:
+   MIB BGP4 '{' bgp4_mib_items '}'
+ | BGP4 MIB '{' bgp4_mib_items '}'
+ ;
+
+bgp4_mib_items:
+   bgp4_mib_items_opt bgp4_mib_as bgp4_mib_items_opt bgp4_mib_id bgp4_mib_items_opt
+ ;
+
+bgp4_mib_as:
+  LOCAL AS expr ';' {
+    if ($3 < 1 || $3 > UINT16_MAX) cf_error("Invalid local AS for BGP4-MIB");
+    SNMP_CFG->bgp4_local_as = $3;
+  }
+  /* TODO add option to follow some bgp peer local as */
+ ;
+
+bgp4_mib_id:
+   LOCAL ROUTER ID idval ';' { SNMP_CFG->bgp4_local_id = $4; }
+  /* TODO add option to inherit global router id, or follow some bgp peer */
+ ;
+
+bgp4_mib_items_opt:
+   /* empty */
+ | bgp4_mib_items_opt bgp4_mib_peer ';'
+ ;
+
+bgp4_mib_peer: PEER symbol
+{
+  /* the snmp_context rule sets the correct value of this_bond */
+  cf_assert_symbol($2, SYM_PROTO);
+
+  if (!$2->proto) cf_error("BGP protocol %s not found", $2->name);
+
+  cf_assert($2->proto->protocol == &proto_bgp,
+    "SNMP BGP bond accepts only BGP protocols");
+
+  struct snmp_bond *this_bond = cfg_alloc(sizeof(struct snmp_bond));
+  this_bond->type = SNMP_BGP;
+  this_bond->config = $2->proto;
+
+  add_tail(&SNMP_CFG->bgp_entries, &this_bond->n);
+  SNMP_CFG->bonds++;
+}
+
+snmp_proto_opts:
+   /* empty */
+ | snmp_proto_opts snmp_proto_item ';'
+ ;
+
+snmp_proto_start: proto_start SNMP
+{
+  this_proto = proto_config_new(&proto_snmp, $1);
+
+  init_list(&SNMP_CFG->bgp_entries);
+  SNMP_CFG->bonds = 0;
+
+  SNMP_CFG->local_ip = IPA_NONE;
+  SNMP_CFG->master_ip = IPA_NONE;
+  SNMP_CFG->master_port = SNMP_PORT;
+  SNMP_CFG->master_path = agentx_master_addr;
+  SNMP_CFG->trans_type = SNMP_TRANS_DEFAULT;
+  SNMP_CFG->bgp4_local_as = 0;
+  SNMP_CFG->bgp4_local_id = 0;
+  SNMP_CFG->verbose = 0;
+
+  SNMP_CFG->description = "bird";
+  SNMP_CFG->timeout = 15;
+  SNMP_CFG->priority = AGENTX_PRIORITY;
+}
+
+
+CF_CODE
+
+CF_END
diff --git a/proto/snmp/mib_tree.c b/proto/snmp/mib_tree.c
new file mode 100644
index 00000000..b857cec0
--- /dev/null
+++ b/proto/snmp/mib_tree.c
@@ -0,0 +1,877 @@
+#include "mib_tree.h"
+#include "snmp_utils.h"
+
+#ifdef allocz
+#undef allocz
+#endif
+
+#define alloc(size) mb_alloc(p, size)
+#define allocz(size) mb_allocz(p, size)
+#define free(ptr) mb_free(ptr)
+#define realloc(ptr, newsize) mib_mb_realloc(p, ptr, newsize)
+
+/*
+ * mib_mb_realloc - fix mb_realloc for NULL
+ * @p: pool to use for NULL pointers
+ * @ptr: old pointer to be reallocated
+ * @size: new size of allocated memory block
+ *
+ * The mb_realloc() does not work with NULL as ptr.
+ */
+static inline void *
+mib_mb_realloc(pool *p, void *ptr, unsigned size)
+{
+  if (!ptr)
+    return mb_alloc(p, size);
+
+  return mb_realloc(ptr, size);
+}
+
+/**
+ * mib_tree_init - Initialize a MIB tree
+ * @p: allocation source pool
+ * @t: pointer to a tree being initialized
+ *
+ * By default the standard SNMP internet prefix (.1.3.6.1) is inserted into the
+ * tree.
+ */
+void
+mib_tree_init(pool *p, struct mib_tree *t)
+{
+  struct mib_node *node = &t->root;
+  node->c.id = 0;
+  node->c.flags = 0;
+  node->children = NULL;
+  node->child_len = 0;
+
+  struct oid *oid = tmp_alloc(
+    snmp_oid_size_from_len((uint) ARRAY_SIZE(snmp_internet)));
+  oid->n_subid =  ARRAY_SIZE(snmp_internet);
+  oid->prefix = 0;
+  oid->include =  0;
+  oid->reserved = 0;
+
+  for (size_t i = 0; i < ARRAY_SIZE(snmp_internet); i++)
+    oid->ids[i] = snmp_internet[i];
+
+  (void) mib_tree_add(p, t, oid, 0);
+}
+
+/**
+ * mib_tree_hint - preallocate child array for given OID
+ * @p: memory pool to allocated from
+ * @t: MIB tree to hint
+ * @oid: MIB subtree root with upto @size children
+ * @size: number of children in @oid subtree
+ */
+int
+mib_tree_hint(pool *p, struct mib_tree *t, const struct oid *oid, uint size)
+{
+  mib_node_u *node = mib_tree_add(p, t, oid, 0);
+  if (!node || mib_node_is_leaf(node))
+    return 0;
+
+  struct mib_node *inner = &node->inner;
+  if (inner->child_len >= size + 1)
+    return 1;
+
+  u32 old_len = inner->child_len;
+  inner->child_len = size + 1;
+  inner->children = realloc(inner->children,
+    inner->child_len * sizeof(mib_node_u *));
+
+  for (u32 i = old_len; i < inner->child_len; i++)
+    inner->children[i] = NULL;
+  return 1;
+}
+
+/**
+ * mib_tree_add - Insert a new node to the tree
+ * @p: allocation source pool
+ * @t: MIB tree to insert to
+ * @oid: identification of inserted node.
+ * @is_leaf: flag signaling that inserted OID should be leaf node.
+ *
+ * Reinsertion only return already valid node pointer, no allocations are done
+ * in this case. Return pointer to node in the MIB tree @t or NULL if the
+ * requested insertion is invalid. Insertion is invalid if we want to insert
+ * node below a leaf or insert a leaf in place taken by normal node.
+ *
+ */
+mib_node_u *
+mib_tree_add(pool *p, struct mib_tree *t, const struct oid *oid, int is_leaf)
+{
+  // TODO may not function properly in snmp_internet prefix region
+  struct mib_walk_state walk;
+  mib_node_u *node;
+
+  /* The empty prefix is associated with the root tree node */
+  if (snmp_is_oid_empty(oid) && !is_leaf)
+    return (mib_node_u *) &t->root;
+  else if (snmp_is_oid_empty(oid))
+    return NULL;
+
+  mib_tree_walk_init(&walk, t);
+  node = mib_tree_find(t, &walk, oid);
+  ASSERT(walk.id_pos <= oid->n_subid + 1);
+
+  if (node)
+  {
+    if (mib_node_is_leaf(node) == is_leaf)
+      return node;
+
+    /* we are trying to insert a leaf node in place of inner node,
+     * or vice versa */
+    return NULL;
+  }
+
+  ASSERT(walk.id_pos < oid->n_subid + 1);
+
+  node = walk.stack[walk.stack_pos - 1];
+  /* we encounter leaf node before end of OID's id path */
+  if (mib_node_is_leaf(node))
+    return NULL;
+
+  struct mib_node *node_inner = &node->inner;
+  if (snmp_oid_is_prefixed(oid) &&
+      walk.stack_pos <= ARRAY_SIZE(snmp_internet) + 1)
+  {
+    ASSUME(walk.stack_pos && walk.stack[0] == (mib_node_u *) &t->root);
+
+    for (u32 id = walk.stack_pos - 1; id < ARRAY_SIZE(snmp_internet); id++)
+    {
+      if (snmp_internet[id] >= node_inner->child_len)
+      {
+	u32 old_len = node_inner->child_len;
+	node_inner->child_len = snmp_internet[id] + 1;
+	node_inner->children = realloc(node_inner->children,
+	  node_inner->child_len * sizeof(mib_node_u *));
+
+	for (u32 i = old_len; i < node_inner->child_len; i++)
+	  node_inner->children[i] = NULL;
+      }
+
+      node = allocz(sizeof(struct mib_node));
+      /* assign child into a parent's children array */
+      node_inner->children[snmp_internet[id]] = node;
+      node_inner = &node->inner;
+      node_inner->c.id = snmp_internet[id];
+      /* node_inner's fields c.flags, child_len, children defaults to zero or
+       * NULL respectively */
+      walk.stack[walk.stack_pos++] = node;
+    }
+
+    if (walk.stack_pos == ARRAY_SIZE(snmp_internet) + 1)
+    {
+      u32 old_len = node_inner->child_len;
+      node_inner->child_len = MAX(old_len, (u32) oid->prefix + 1);
+      node_inner->children = realloc(node_inner->children,
+	node_inner->child_len * sizeof(mib_node_u *));
+
+      for (u32 i = old_len; i < node_inner->child_len; i++)
+	node_inner->children[i] = NULL;
+
+      if (is_leaf && !oid->n_subid)
+      {
+	node = allocz(sizeof(struct mib_leaf));
+	node->empty.flags = MIB_TREE_LEAF;
+      }
+      else
+      {
+	node = allocz(sizeof(struct mib_node));
+	node->empty.flags = 0;
+      }
+
+      node->empty.id = oid->prefix;
+      /* add node into the parent's children array */
+      node_inner->children[oid->prefix] = node;
+      node_inner = &node->inner;
+      walk.stack[walk.stack_pos++] = node;
+    }
+  }
+
+  /* snmp_internet + 2 = empty + snmp_internet + prefix */
+  if (snmp_oid_is_prefixed(oid) &&
+      walk.stack_pos == ARRAY_SIZE(snmp_internet) + 2 &&
+      oid->n_subid == 0 &&
+      mib_node_is_leaf(node) == is_leaf)
+    return node;
+
+  if (mib_node_is_leaf(node))
+    return node;
+
+  u8 subids = oid->n_subid;
+  u32 old_len = node_inner->child_len;
+  u32 child_id = oid->ids[walk.id_pos];
+  node_inner->child_len = MAX(old_len, child_id + 1);
+  node_inner->children = realloc(node_inner->children,
+    node_inner->child_len * sizeof(mib_node_u *));
+
+  for (u32 i = old_len; i < node_inner->child_len; i++)
+    node_inner->children[i] = NULL;
+
+  struct mib_node *parent;
+  /* break to loop before last node in the oid */
+  for (; walk.id_pos < subids - 1;)
+  {
+    parent = node_inner;
+    node_inner = allocz(sizeof(struct mib_node));
+
+    parent->children[child_id] = (mib_node_u *) node_inner;
+    node_inner->c.id = child_id;
+
+    child_id = oid->ids[++walk.id_pos];
+
+    node_inner->child_len = child_id + 1;
+    node_inner->children = allocz(node_inner->child_len * sizeof(mib_node_u *));
+  }
+
+  parent = node_inner;
+  mib_node_u *last;
+  if (is_leaf)
+  {
+    last = allocz(sizeof(struct mib_leaf));
+    struct mib_leaf *leaf = &last->leaf;
+
+    parent->children[child_id] = (mib_node_u *) leaf;
+    leaf->c.id = child_id;
+
+    leaf->c.flags = MIB_TREE_LEAF;
+  }
+  else
+  {
+    last = allocz(sizeof(struct mib_node));
+    node_inner = &last->inner;
+
+    parent->children[child_id] = (mib_node_u *) node_inner;
+    node_inner->c.id = child_id;
+    /* fields c.flags, child_len and children are set by zeroed allocz() */
+  }
+
+  return last;
+}
+
+/**
+ * mib_tree_delete - delete a MIB subtree
+ * @t: MIB tree
+ * @walk: MIB tree walk state that specify the subtree
+ *
+ * Return number of nodes deleted in the subtree. It is possible to delete an empty
+ * prefix which leads to deletion of all nodes inside the MIB tree. Note that
+ * the empty prefix (tree root) node itself could be deleted therefore 0 may be
+ * returned in case of empty prefix deletion.
+ */
+int
+mib_tree_delete(struct mib_tree *t, struct mib_walk_state *walk)
+{
+  int deleted = 0;
+  if (!t)
+    return 0;
+
+  /* (walk->stack_pos < 2) It is impossible to delete root node */
+  if (!walk || walk->stack_pos == 0)
+    return 0;
+
+  if (walk->stack_pos == 1)
+  {
+    for (u32 child = 0; child < t->root.child_len; child++)
+    {
+      if (!t->root.children[child])
+	continue;
+
+      walk->stack_pos = 2;
+      walk->stack[0] = (mib_node_u*) &t->root;
+      walk->stack[1] = t->root.children[child];
+
+      deleted += mib_tree_delete(t, walk);
+    }
+
+    return deleted;
+  }
+
+  struct mib_node *parent = &walk->stack[walk->stack_pos - 2]->inner;
+  mib_node_u *node = walk->stack[walk->stack_pos - 1];
+
+  struct mib_walk_state delete = {
+    .id_pos = walk->id_pos,
+    .stack_pos = 2,
+    .stack = {
+      (mib_node_u *) parent,
+      node,
+      NULL,
+    },
+  };
+
+  u32 last_id = 0;
+  while (delete.stack_pos > 1)
+  {
+continue_while:	  /* like outer continue, but skip always true condition */
+    parent = (struct mib_node *) delete.stack[delete.stack_pos - 2];
+
+    if (mib_node_is_leaf(node))
+    {
+      /* Free leaf node */
+      last_id = node->leaf.c.id;
+      parent->children[last_id] = NULL;
+      delete.stack[--delete.stack_pos] = NULL;
+      free(node);
+      deleted++;
+      node = delete.stack[delete.stack_pos - 1];
+      continue;	  /* here, we couldn't skip the while condition */
+    }
+
+    struct mib_node *node_inner = &node->inner;
+    mib_node_u *child = NULL;
+    for (u32 id = last_id; id < node_inner->child_len; id++)
+    {
+      /* Recursively traverse child nodes */
+      child = node_inner->children[id];
+
+      if (!child)
+	continue;
+
+      last_id = 0;
+      delete.stack[delete.stack_pos++] = child;
+      parent = node_inner;
+      node = child;
+      goto continue_while;    /* outer continue */
+    }
+
+    /* Free inner node without any children */
+    last_id = node_inner->c.id;
+    parent->children[last_id] = NULL;
+    delete.stack[--delete.stack_pos] = NULL;
+    free(node_inner->children);
+    free(node_inner);
+    deleted++;
+    node = (mib_node_u *) parent;
+
+    /* skip check for deleted node in loop over children */
+    last_id++;
+  }
+
+  /* delete the node from original stack */
+  walk->stack[--walk->stack_pos] = NULL;
+
+  node = walk->stack[walk->stack_pos - 1];
+  struct mib_node *node_inner = &node->inner;
+  u32 id;
+  for (id = 0; id < node_inner->child_len; id++)
+  {
+    if (node_inner->children[id] != NULL)
+      break;
+  }
+
+  if (id == node_inner->child_len)
+  {
+    /* all the children are NULL */
+    free(node_inner->children);
+    node_inner->children = NULL;
+    node_inner->child_len = 0;
+  }
+
+  return deleted;
+}
+
+/**
+ * mib_tree_remove - delete a MIB subtree
+ * @t: MIB tree
+ * @oid: object identifier specifying the subtree
+ *
+ * This is a convenience wrapper around mib_tree_delete(). The mib_tree_remove()
+ * finds the corresponding node and deletes it. Return 0 if the OID was not
+ * found. Otherwise return number of deleted nodes (see mib_tree_delete() for
+ * more details).
+ */
+int
+mib_tree_remove(struct mib_tree *t, const struct oid *oid)
+{
+  struct mib_walk_state walk = { };
+  mib_node_u *node = mib_tree_find(t, &walk, oid);
+
+  if (!node)
+    return 0;
+
+  return mib_tree_delete(t, &walk);
+}
+
+/**
+ * mib_tree_find - Find a OID node in MIB tree
+ * @t: searched tree
+ * @walk: output search state
+ * @oid: searched node identification
+ *
+ * Return valid pointer to node in MIB tree or NULL. The search state @walk is
+ * always updated and contains the longest possible prefix of @oid present
+ * inside the tree @t. The @walk must not be NULL and must be blank (only
+ * initialized).
+ */
+mib_node_u *
+mib_tree_find(const struct mib_tree *t, struct mib_walk_state *walk, const struct oid *oid)
+{
+  ASSERT(t && walk);
+
+  if (!oid || snmp_is_oid_empty(oid))
+  {
+    walk->stack_pos = 1;
+    walk->stack[0] = (mib_node_u *) &t->root;
+    return (snmp_is_oid_empty(oid)) ? (mib_node_u *) &t->root : NULL;
+  }
+
+  mib_node_u *node;
+  struct mib_node *node_inner;
+
+  /* the OID id index to use */
+  u8 oid_pos = walk->id_pos;
+
+  if (walk->stack_pos > 0)
+    node = walk->stack[walk->stack_pos - 1];
+  else
+    node = walk->stack[walk->stack_pos++] = (mib_node_u *) &t->root;
+
+  if (mib_node_is_leaf(node))
+  {
+    /* In any of cases below we did not move in the tree therefore the
+     * walk->id_pos is left untouched. */
+    if (snmp_oid_is_prefixed(oid) &&
+	oid->n_subid + ARRAY_SIZE(snmp_internet) + 1 == walk->id_pos)
+      return node;
+
+    else if (snmp_oid_is_prefixed(oid) &&
+	oid->n_subid + ARRAY_SIZE(snmp_internet) + 1 > walk->id_pos)
+      return NULL;
+
+    else if (!snmp_oid_is_prefixed(oid) && oid->n_subid + 1 == walk->id_pos)
+      return node;
+  }
+
+  node_inner = &node->inner;
+  ASSERT(node); /* node may be leaf if OID is not in tree t */
+
+  /* Handling of prefixed OID */
+  if (snmp_oid_is_prefixed(oid) && walk->stack_pos < 6)
+  {
+    /* The movement inside implicit SNMP internet and following prefix is not
+     * projected to walk->id_pos. */
+    uint i = (uint) walk->stack_pos - 1;
+    /* walking the snmp_internet prefix itself */
+    for (; i < ARRAY_SIZE(snmp_internet); i++)
+    {
+      if (node_inner->child_len <= snmp_internet[i])
+	return NULL;
+
+      node = node_inner->children[snmp_internet[i]];
+      node_inner = &node->inner;
+
+      if (!node)
+	return NULL;
+
+      ASSERT(node->empty.id == snmp_internet[i]);
+      walk->stack[walk->stack_pos++] = node;
+
+      if (mib_node_is_leaf(node))
+	return NULL;
+    }
+
+    /* walking the prefix continuation (OID field oid->prefix) */
+    u8 prefix = oid->prefix;
+    if (node_inner->child_len <= prefix)
+      return NULL;
+
+    node = node_inner->children[prefix];
+    node_inner = &node->inner;
+
+    if (!node)
+      return NULL;
+
+    ASSERT(node->empty.id == prefix);
+    walk->stack[walk->stack_pos++] = node;
+
+    if (mib_node_is_leaf(node) && oid->n_subid > 0)
+      return NULL;
+  }
+
+  u8 subids = oid->n_subid;
+  if (subids == 0)
+    return (node == (mib_node_u *) &t->root) ? NULL : node;
+
+  /* loop for all OID's ids except the last one */
+  for (; oid_pos < subids - 1 && walk->stack_pos < MIB_WALK_STACK_SIZE + 1; oid_pos++)
+  {
+    u32 id = oid->ids[oid_pos];
+    if (node_inner->child_len <= id)
+    {
+      /* The walk->id_pos points after the last accepted OID id.
+       * This is correct because we did not find the last OID in the tree. */
+      walk->id_pos = oid_pos;
+      return NULL;
+    }
+
+    node = node_inner->children[id];
+    node_inner = &node->inner;
+
+    if (!node)
+    {
+      /* Same as above, the last node is not valid therefore the walk->is_pos
+       * points after the last accepted OID id. */
+      walk->id_pos = oid_pos;
+      return NULL;
+    }
+
+    ASSERT(node->empty.id == id);
+    walk->stack[walk->stack_pos++] = node;
+
+    if (mib_node_is_leaf(node))
+    {
+      /* We need to increment the oid_pos because the walk->is_pos suppose the
+       * pointer after the last valid OID id. */
+      walk->id_pos = ++oid_pos;
+      return NULL;
+    }
+  }
+
+  walk->id_pos = oid_pos;
+  u32 last_id = oid->ids[oid_pos];
+  if (node_inner->child_len <= last_id ||
+      walk->stack_pos >= MIB_WALK_STACK_SIZE + 1)
+    return NULL;
+
+  node = node_inner->children[last_id];
+  node_inner = &node->inner;
+
+  if (!node)
+    return NULL;
+
+  /* here, the check of node being a leaf is intentionally omitted
+   * because we may need to search for a inner node */
+  ASSERT(node->empty.id == last_id);
+
+  /* We need to increment the oid_pos because the walk->is_pos suppose the
+   * pointer after the last valid OID id. */
+  walk->id_pos = ++oid_pos;
+  return walk->stack[walk->stack_pos++] = node;
+}
+
+/**
+ * mib_tree_walk_init - Initialize MIB tree walk state
+ * @walk: MIB tree walk state to init
+ * @t: optional MIB tree
+ */
+void
+mib_tree_walk_init(struct mib_walk_state *walk, const struct mib_tree *t)
+{
+  walk->id_pos = 0;
+  walk->stack_pos = (t != NULL) ? 1 : 0;
+  memset(&walk->stack, 0, sizeof(walk->stack));
+
+  if (t != NULL)
+    walk->stack[0] = (mib_node_u *) &t->root;
+}
+
+/*
+ * walk_is_prefixable - test prefixability of MIB walk state
+ * @walk: MIB tree walk state to use
+ *
+ * This function is functionally equivalent to snmp_oid_is_prefixable().
+ */
+static inline int
+walk_is_prefixable(const struct mib_walk_state *walk)
+{
+  /* empty prefix and oid->prefix (+2) */
+  if (walk->stack_pos < ARRAY_SIZE(snmp_internet) + 2)
+    return 0;
+
+  for (uint i = 0; i < ARRAY_SIZE(snmp_internet); i++)
+  {
+    if (walk->stack[i + 1]->empty.id != snmp_internet[i])
+      return 0;
+  }
+
+  u32 id = walk->stack[ARRAY_SIZE(snmp_internet) + 1]->empty.id;
+  return id > 0 && id <= UINT8_MAX;
+}
+
+/*
+ * mib_tree_walk_to_oid - retrieve OID from MIB tree walk state
+ * @walk: MIB tree walk state to transform
+ * @result: destination OID
+ * @subids: Maximal number of subids in available space
+ *
+ * Return 1 if the space is insufficient, 0 otherwise.
+ */
+int
+mib_tree_walk_to_oid(const struct mib_walk_state *walk, struct oid *result, u32 subids)
+{
+  ASSERT(walk && result);
+
+  /* the stack_pos point after last valid index, and the first is always empty
+   * prefix */
+  if (walk->stack_pos <= 1)
+  {
+    /* create a null valued OID; sets all n_subid, prefix, include and reserved */
+    memset(result, 0, sizeof(struct oid));
+    return 0;
+  }
+
+  u32 index;
+  if (walk_is_prefixable(walk))
+  {
+    if (walk->stack_pos - 2 > subids - (ARRAY_SIZE(snmp_internet) + 1))
+      return 1;
+
+    /* skip empty prefix, whole snmp_internet .1.3.6.1 and oid->prefix */
+    index = 2 + ARRAY_SIZE(snmp_internet);
+    result->n_subid = walk->stack_pos - (ARRAY_SIZE(snmp_internet) + 2);
+    result->prefix = \
+      walk->stack[ARRAY_SIZE(snmp_internet) + 1]->empty.id;
+  }
+  else
+  {
+    if (walk->stack_pos - 2 > subids)
+      return 1;
+
+    index = 1;	/* skip empty prefix */
+    result->n_subid = walk->stack_pos - 1;
+    result->prefix = 0;
+  }
+
+  result->include = 0;
+  result->reserved = 0;
+
+  u32 i = 0;
+  /* the index could point after last stack array element */
+  for (; index < walk->stack_pos && index < MIB_WALK_STACK_SIZE; index++)
+    result->ids[i++] = walk->stack[index]->empty.id;
+
+  return 0;
+}
+
+/*
+ * mib_tree_walk_oid_compare - compare MIB tree walk state and OID
+ * @walk: left relation operand
+ * @oid: Object Identifier in cpu native byte order
+ *
+ * Return value semantics is the same as snmp_oid_compare().
+ */
+int
+mib_tree_walk_oid_compare(const struct mib_walk_state *walk, const struct oid *oid)
+{
+  /* code is very similar to snmp_oid_compare() */
+  if (!walk->stack_pos)
+    return -1;
+
+  uint walk_idx = 1;
+  u8 walk_subids = walk->stack_pos;	  /* left_subids */
+  u8 oid_subids = oid->n_subid;  /* right_subids */
+
+  const u8 oid_prefix = oid->prefix;
+
+  if (oid_prefix != 0)
+  {
+    for (; walk_idx < walk_subids && walk_idx < ARRAY_SIZE(snmp_internet) + 1; walk_idx++)
+    {
+      u32 id = walk->stack[walk_idx]->empty.id;
+      if (id < snmp_internet[walk_idx - 1])
+	return -1;
+      else if (id > snmp_internet[walk_idx - 1])
+	return 1;
+    }
+
+    if (walk_idx < ARRAY_SIZE(snmp_internet) + 1)
+      return -1;
+
+    const u8 walk_prefix = walk->stack[walk_idx++]->empty.id;
+    if (walk_prefix < oid_prefix)
+      return -1;
+    else if (walk_prefix > oid_prefix)
+      return 1;
+  }
+
+  uint i = 0;
+  for (; i < oid_subids && walk_idx < walk_subids; i++, walk_idx++)
+  {
+    u32 walk_id = walk->stack[walk_idx]->empty.id;
+    u32 oid_id = oid->ids[i];
+    if (walk_id < oid_id)
+      return -1;
+    else if (walk_id > oid_id)
+      return 1;
+  }
+
+  if (walk_idx == walk_subids && i == oid_subids)
+    return 0;
+  else if (walk_idx == walk_subids)
+    return -1;
+  else /* if (i == oid_subids) */
+    return 1;
+}
+
+
+
+/**
+ * mib_tree_walk_is_oid_descendant - check if OID is in walk subtree
+ * @walk: MIB tree walk state
+ * @oid: OID to use
+ *
+ * Return 0 if @walk specify same path in MIB tree as @oid, return +1 if @oid is
+ * in @walk subtree, return -1 otherwise.
+ */
+int
+mib_tree_walk_is_oid_descendant(const struct mib_walk_state *walk, const struct oid *oid)
+{
+  /* walk stack index skipped zero prefix and OID subidentifier index */
+  u32 i = 1, j = 0;
+
+  if (!walk->stack_pos && snmp_is_oid_empty(oid))
+    return 0;
+
+  if (snmp_oid_is_prefixed(oid))
+  {
+    for (; i < MIN(walk->stack_pos - 1, ARRAY_SIZE(snmp_internet) + 1); i++)
+    {
+      if (walk->stack[i]->empty.id != snmp_internet[i - 1])
+	return -1;
+    }
+
+    if (i == walk->stack_pos)
+      return +1;
+
+    if (i < walk->stack_pos &&
+	walk->stack[i]->empty.id != (u32) oid->prefix)
+      return -1;
+
+    i++;
+  }
+
+  u32 ids = oid->n_subid;
+  for (; i < walk->stack_pos && j < ids; i++, j++)
+  {
+    if (walk->stack[i]->empty.id != oid->ids[j])
+      return -1;
+  }
+
+  if (i < walk->stack_pos)
+    return -1;
+  else if (i == walk->stack_pos && j == ids)
+    return 0;
+  else if (i == walk->stack_pos)
+    return +1;
+  else
+  {
+    die("unreachable");
+    return -1;
+  }
+}
+
+/**
+ * mib_tree_walk_next - find MIB tree node successor in lexicagraphically ordered MIB tree
+ * @t: MIB tree to use
+ * @walk: MIB tree walk state to use
+ */
+mib_node_u *
+mib_tree_walk_next(const struct mib_tree *t, struct mib_walk_state *walk)
+{
+  ASSERT(t && walk);
+
+  u32 next_id = 0;
+
+  if (walk->stack_pos == 0)
+    return NULL;
+
+  mib_node_u *node = walk->stack[walk->stack_pos - 1];
+
+  if (mib_node_is_leaf(node))
+  {
+    next_id = node->leaf.c.id + 1;
+    walk->stack[--walk->stack_pos] = NULL;
+    node = walk->stack[walk->stack_pos - 1];
+  }
+
+  while (walk->stack_pos > 0)
+  {
+    node = walk->stack[walk->stack_pos - 1];
+
+    if (mib_node_is_leaf(node))
+    {
+      walk->stack[walk->stack_pos++] = node;
+      return node;
+    }
+
+    struct mib_node *node_inner = &node->inner;
+    for (u32 id = next_id; id < node_inner->child_len; id++)
+    {
+      mib_node_u *child = node_inner->children[id];
+
+      if (!child)
+	continue;
+
+      walk->stack[walk->stack_pos++] = child;
+      return child;
+    }
+
+    next_id = node_inner->c.id + 1;
+    walk->stack[--walk->stack_pos] = NULL;
+  }
+
+  return NULL;
+}
+
+/**
+ * mib_tree_walk_next_leaf - wrapper around mib_tree_walk_next returning only leafs
+ * @t: MIB tree to use
+ * @walk: MIB tree walk state
+ * @skip: lower value bound for next OID id
+ */
+struct mib_leaf *
+mib_tree_walk_next_leaf(const struct mib_tree *t, struct mib_walk_state *walk, u32 skip)
+{
+  (void)t;
+
+  if (walk->stack_pos == 0)
+    return NULL;
+
+  u32 next_id = skip;
+  mib_node_u *node = walk->stack[walk->stack_pos - 1];
+
+  if (mib_node_is_leaf(node) && walk->stack_pos > 1)
+  {
+    next_id = node->leaf.c.id + 1;
+    walk->stack[--walk->stack_pos] = NULL;
+    node = walk->stack[walk->stack_pos - 1];
+  }
+  else if (mib_node_is_leaf(node))
+  {
+    /* walk->stack_pos == 1, so we NULL out the last stack field */
+    walk->stack[--walk->stack_pos] = NULL;
+    return NULL;
+  }
+
+  while (walk->stack_pos > 0)
+  {
+continue_while:
+    node = walk->stack[walk->stack_pos - 1];
+
+    if (mib_node_is_leaf(node))
+      return (struct mib_leaf *) node;
+
+    struct mib_node *node_inner = &node->inner;
+    for (u32 id = next_id; id < node_inner->child_len; id++)
+    {
+      mib_node_u *child = node_inner->children[id];
+
+      if (!child)
+	continue;
+
+      next_id = 0;
+      walk->stack[walk->stack_pos++] = child;
+      /* node is assign at the beginning of the while loop (from stack) */
+      goto continue_while;
+    }
+
+    next_id = node->empty.id + 1;
+    walk->stack[--walk->stack_pos] = NULL;
+  }
+
+  return NULL;
+}
+
diff --git a/proto/snmp/mib_tree.h b/proto/snmp/mib_tree.h
new file mode 100644
index 00000000..8978daa6
--- /dev/null
+++ b/proto/snmp/mib_tree.h
@@ -0,0 +1,122 @@
+#ifndef _BIRD_SNMP_MIB_TREE_
+#define _BIRD_SNMP_MIB_TREE_
+
+#include "subagent.h"
+
+#include "lib/resource.h"
+#include "lib/lists.h"
+#include "lib/birdlib.h"
+
+#define MIB_TREE_NO_FLAGS 0x00
+#define MIB_TREE_LEAF 0x01
+#define MIB_TREE_HAS_HOOKS 0x02
+
+typedef union mib_node_union mib_node_u;
+
+struct mib_node_core {
+  u32 id;
+  u8 flags;
+};
+
+struct mib_node {
+  struct mib_node_core c;
+  mib_node_u **children;
+  u32 child_len;
+};
+
+struct mib_walk_state;
+
+struct mib_leaf {
+  struct mib_node_core c;
+
+  /**
+   * filler - hook for filling VarBind data value
+   * @state: self referencing MIB tree walk state
+   * @data: box holding destiantion VarBind and SNMP protocol instance
+   *
+   * If corresponding leaf node has filled in AgentX type and/or size, it is
+   * guaranteed that PDU buffer have enough space. Hook mustn't be NULL.
+   * If the leaf node has set valid type, the varbind type will be automatically
+   * set by the snmp_walk_fill() servicing routine. If the field type is set to
+   * AGENTX_INVALID, it is expected that filler() hook will also fill
+   * the VarBind type.
+   */
+  enum snmp_search_res (*filler)(struct mib_walk_state *state, struct snmp_pdu *context);
+
+  /**
+   * call_next - signal multileaf
+   * @state: self referencing MIB tree walk state
+   * @data: box holding destination VarBind and SNMP protocol insntace
+   *
+   * MIB modules can implement subtrees by a single leaf node in MIB node tree.
+   * When the tree is walked, the specific leaf node has to be returned multiple
+   * times. The @call_next hook determines if we should move to next leaf node.
+   * It is expected that call_next() hook may change the VarBind to be filled.
+   *
+   * Hook may be NULL meaning the leaf node is not multileaf/subtree.
+   *
+   */
+  int (*call_next)(struct mib_walk_state *state, struct snmp_pdu *context);
+
+  /**
+   * type of produced VarBind, may be replaced in packet instanciation by
+   * AGENTX_NO_SUCH_OBJECT, AGENTX_NO_SUCH_INSTANCE or AGENTX_END_OF_MIB_VIEW
+   * The field is unspecified if equal to AGENTX_INVALID.
+   */
+  enum agentx_type type;
+
+  /*
+   * Specify upper bound of VarBind data size. If set to -1, all handling must
+   * be done in filler() hook. In all other cases the filler() hook has
+   * guaranteed that the space is available.
+   */
+  int size;
+};
+
+union mib_node_union {
+  struct mib_node_core empty;
+  struct mib_node inner;
+  struct mib_leaf leaf;
+};
+
+/*
+ * The stack size include empty prefix (mib tree root).
+ */
+#define MIB_WALK_STACK_SIZE 33
+STATIC_ASSERT(OID_MAX_LEN < MIB_WALK_STACK_SIZE);
+
+/* walk state for MIB tree */
+struct mib_walk_state {
+  u8 id_pos;  /* points after last matching subid in OID */
+  u32 stack_pos;  /* points after last valid stack node */
+  mib_node_u *stack[MIB_WALK_STACK_SIZE];
+};
+
+struct mib_tree {
+  struct mib_node root;
+};
+
+void mib_tree_init(pool *p, struct mib_tree *t);
+void mib_tree_walk_init(struct mib_walk_state *state, const struct mib_tree *t);
+int mib_tree_walk_to_oid(const struct mib_walk_state *state, struct oid *result, u32 subids);
+int mib_tree_walk_oid_compare(const struct mib_walk_state *state, const struct oid *oid);
+
+mib_node_u *mib_tree_add(pool *p, struct mib_tree *tree, const struct oid *oid, int is_leaf);
+int mib_tree_remove(struct mib_tree *t, const struct oid *oid);
+int mib_tree_delete(struct mib_tree *t, struct mib_walk_state *state);
+mib_node_u *mib_tree_find(const struct mib_tree *tree, struct mib_walk_state *walk, const struct oid *oid);
+mib_node_u *mib_tree_walk_next(const struct mib_tree *t, struct mib_walk_state *walk);
+struct mib_leaf *mib_tree_walk_next_leaf(const struct mib_tree *t, struct mib_walk_state *walk, u32 skip);
+
+int mib_tree_hint(pool *p, struct mib_tree *t, const struct oid *oid, uint size);
+int mib_tree_walk_is_oid_descendant(const struct mib_walk_state *walk, const struct oid *oid);
+
+static inline int
+mib_node_is_leaf(const mib_node_u *node)
+{
+  ASSUME(node);
+  return node->empty.flags & MIB_TREE_LEAF;
+}
+
+#endif
+
diff --git a/proto/snmp/snmp.c b/proto/snmp/snmp.c
new file mode 100644
index 00000000..2e48f776
--- /dev/null
+++ b/proto/snmp/snmp.c
@@ -0,0 +1,686 @@
+/*
+ *	BIRD -- Simple Network Management Procotol (SNMP)
+ *
+ *	(c) 2024 Vojtech Vilimek <vojtech.vilimek@nic.cz>
+ *	(c) 2024 CZ.NIC z.s.p.o.
+ *
+ *	Can be freely distributed and used under the terms of the GNU GPL.
+ */
+
+/**
+ * DOC: Simple Network Management Protocol
+ *
+ * The SNMP protocol is divided into several parts: |snmp.c| which implements
+ * integration with BIRD core, |subagent.c| provides AgentX subagent behaviour
+ * as well as functions for creating and parsing packets. In file |mib_tree.c|
+ * is implemented OID prefix tree for storing supported MIBs. File |bgp4_mib.c|
+ * implements parts of BGP4-MIB, |snmp_utils.c| is collection of helper
+ * functions for whole SNMP protocol.
+ *
+ * Althrough called SNMP the BIRD does not implement SNMP directly but acts as
+ * an AgentX subagent. AgentX subagent connects to AgentX master agent that
+ * processes incomming SNMP requests and passes them down to the correct
+ * subagent. Therefore you need also a running master agent somewhere.
+ * Advantages of this design are that you are capable of doing aggregation of
+ * statuses of multiple BIRDs at the master agent level and much simpler
+ * implementation.
+ *
+ * Before any of the SNMP request could be processed, the SNMP need to
+ * established AgentX session with the master agent and need to register all
+ * subtrees to make them accessible from the master agent. The establishement of
+ * the of session is handled by snmp_start(), snmp_start_locked() and
+ * snmp_start_subagent(). Then we register all MIBs from configuration in
+ * snmp_register_mibs().
+ *
+ * The AgentX request are handled only during MIB subtree registrations and
+ * after then on established session (in states SNMP_REGISTER and SNMP_CONN, see
+ * below). It is also guaranteed that no request is received before MIB subtree
+ * registration because the specific subagent is not authoratitave and also the
+ * master agent has no info about MIB subtree supported by subagent. The AgentX
+ * requests are handled by function snmp_rx() in |subagent.c|.
+ *
+ *
+ *
+ */
+
+/*
+ * SNMP State Machine
+ *
+ *  States with main transitions
+ *
+ *
+ *    +-----------------+
+ *    | SNMP_INIT	|     entry state after call snmp_start()
+ *    +-----------------+
+ *	  |
+ *	  |   acquiring object lock for tcp communication socket
+ *	  V
+ *    +-----------------+
+ *    | SNMP_LOCKED	|     object lock aquired
+ *    +-----------------+
+ *	  |
+ *	  |   opening communication socket
+ *	  V
+ *    +-----------------+
+ *    | SNMP_OPEN	|     socket created, starting subagent
+ *    +-----------------+
+ *	  |
+ *	  |   BIRD receive response for agentx-Open-PDU
+ *	  V
+ *    +-----------------+
+ *    | SNMP_REGISTER   |     session was established, subagent registers MIBs
+ *    +-----------------+
+ *	  |
+ *	  |   subagent received response for any registration requests
+ *	  V
+ *    +-----------------+
+ *    | SNMP_CONN	|     everything is set
+ *    +-----------------+
+ *	  |
+ *	  |   received malformed PDU, protocol disabled,
+ *	  |   BIRD sends agentx-Close-PDU or agentx-Response-PDU with an error
+ *	  V
+ *    +-----------------+
+ *    | SNMP_STOP	|     waiting until the prepared PDUs are sent
+ *    +-----------------+
+ *	  |
+ *	  |   cleaning protocol state
+ *	  V
+ *    +-----------------+
+ *    | SNMP_DOWN	|     session is closed
+ *    +-----------------+
+ *
+ *
+ *
+ *  Erroneous transitions:
+ *    SNMP is UP (PS_UP) in states SNMP_CONN and also in SNMP_REGISTER because
+ *    the session is establised and the GetNext request should be responsed
+ *    without regards to MIB registration.
+ *
+ *    Reconfiguration is done in similar fashion to BGP, the reconfiguration
+ *    request is declined, the protocols is stoped and started with new
+ *    configuration.
+ *
+ */
+
+#include "nest/bird.h"
+#include "nest/cli.h"
+#include "nest/locks.h"
+#include "lib/socket.h"
+#include "lib/lists.h"
+
+#include "snmp.h"
+#include "subagent.h"
+#include "snmp_utils.h"
+#include "mib_tree.h"
+#include "bgp4_mib.h"
+
+const char agentx_master_addr[] = AGENTX_MASTER_ADDR;
+
+static const char *snmp_state_str[] = {
+  [SNMP_INIT]	  = "acquiring address lock",
+  [SNMP_LOCKED]	  = "address lock acquired",
+  [SNMP_OPEN]	  = "starting AgentX subagent",
+  [SNMP_REGISTER] = "registering MIBs",
+  [SNMP_CONN]	  = "AgentX session established",
+  [SNMP_STOP]	  = "stopping AgentX subagent",
+  [SNMP_DOWN]	  = "protocol down",
+};
+
+
+/*
+ *    Callbacks
+ */
+
+/*
+ * snmp_sock_err - handle errors on socket by reopenning the socket
+ * @sk: socket owned by SNMP protocol instance
+ * @err: socket error code
+ */
+static void
+snmp_sock_err(sock *sk, int UNUSED err)
+{
+  struct snmp_proto *p = sk->data;
+  if (err != 0)
+    TRACE(D_EVENTS, "SNMP socket error (%d)", err);
+  snmp_set_state(p, SNMP_DOWN);
+}
+
+/*
+ * snmp_ping_timeout - send a agentx-Ping-PDU
+ * @tm: the ping_timer holding the SNMP protocol instance.
+ *
+ * Send an agentx-Ping-PDU. This function is periodically called by ping
+ * timer.
+ */
+static void
+snmp_ping_timeout(timer *tm)
+{
+  struct snmp_proto *p = tm->data;
+  snmp_ping(p);
+}
+
+
+/*
+ * snmp_stop_timeout - a timeout for non-responding master agent
+ * @tm: the startup_timer holding the SNMP protocol instance.
+ *
+ * We are trying to empty the TX buffer of communication socket. But if it is
+ * not done in reasonable amount of time, the function is called by timeout
+ * timer. We down the whole SNMP protocol with cleanup of associated data
+ * structures.
+ */
+static void
+snmp_stop_timeout(timer *tm)
+{
+  struct snmp_proto *p = tm->data;
+  snmp_set_state(p, SNMP_DOWN);
+}
+
+/*
+ * snmp_connected - start AgentX session on created socket
+ * @sk: socket owned by SNMP protocol instance
+ *
+ * Starts the AgentX communication by sending an agentx-Open-PDU.
+ * This function is internal and shouldn't be used outside the SNMP module.
+ */
+void
+snmp_connected(sock *sk)
+{
+  struct snmp_proto *p = sk->data;
+  snmp_set_state(p, SNMP_OPEN);
+}
+
+/*
+ * snmp_start_locked - open the socket on locked address
+ * @lock: object lock guarding the communication mean (address, ...)
+ *
+ * This function is called when the object lock is acquired. Main goal is to set
+ * socket parameters and try to open configured socket. Function
+ * snmp_connected() handles next stage of SNMP protocol start. When the socket
+ * coundn't be opened, a new try is scheduled after a small delay.
+ */
+static void
+snmp_start_locked(struct object_lock *lock)
+{
+  struct snmp_proto *p = lock->data;
+  if (p->startup_delay)
+  {
+    ASSERT(p->startup_timer);
+    p->startup_timer->hook = snmp_startup_timeout;
+    tm_start(p->startup_timer, p->startup_delay);
+  }
+  else
+    snmp_set_state(p, SNMP_LOCKED);
+}
+
+/*
+ * snmp_startup_timeout - start the initiliazed SNMP protocol
+ * @tm: the startup_timer holding the SNMP protocol instance.
+ *
+ * When the timer rings, the function snmp_startup() is invoked.
+ * This function is internal and shouldn't be used outside the SNMP module.
+ * Used when we delaying the start procedure, or we want to retry opening
+ * the communication socket.
+ */
+void
+snmp_startup_timeout(timer *tm)
+{
+  struct snmp_proto *p = tm->data;
+  snmp_set_state(p, SNMP_LOCKED);
+}
+
+/*
+ * snmp_rx_skip - skip all received data
+ * @sk: communication socket
+ * @size: size of received PDUs
+ *
+ * Socket rx_hook used when we are reseting the connection due to malformed PDU.
+ */
+static int
+snmp_rx_skip(sock UNUSED *sk, uint UNUSED size)
+{
+  return 1;
+}
+
+/*
+ * snmp_tx_skip - handle empty TX buffer during session reset
+ * @sk: communication socket
+ *
+ * The socket tx_hook is called when the TX buffer is empty, i.e. all data was
+ * send. This function is used only when we found malformed PDU and we are
+ * resetting the established session. If called, we perform a SNMP protocol
+ * state change.
+ */
+static void
+snmp_tx_skip(sock *sk)
+{
+  struct snmp_proto *p = sk->data;
+  snmp_set_state(p, SNMP_STOP);
+}
+
+/*
+ * snmp_cleanup - free all resources allocated by SNMP protocol
+ * @p: SNMP protocol instance
+ *
+ * This function forcefully stops and cleans all resources and memory acqiured
+ * by given SNMP protocol instance, such as timers, lists, hash tables etc.
+ */
+static inline void
+snmp_cleanup(struct snmp_proto *p)
+{
+  /* Function tm_stop() is called inside rfree() */
+  rfree(p->startup_timer);
+  p->startup_timer = NULL;
+
+  rfree(p->ping_timer);
+  p->ping_timer = NULL;
+
+  rfree(p->sock);
+  p->sock = NULL;
+
+  rfree(p->lock);
+  p->lock = NULL;
+
+  struct snmp_registration *r, *r2;
+  WALK_LIST_DELSAFE(r, r2, p->registration_queue)
+  {
+    rem_node(&r->n);
+    mb_free(r);
+    r = NULL;
+  }
+
+  HASH_FREE(p->bgp_hash);
+  rfree(p->lp);
+  p->lp = NULL;
+  /* bgp_trie is allocated exclusively from linpool lp */
+  p->bgp_trie = NULL;
+
+  struct mib_walk_state *walk = tmp_alloc(sizeof(struct mib_walk_state));
+  mib_tree_walk_init(walk, p->mib_tree);
+  (void) mib_tree_delete(p->mib_tree, walk);
+  p->mib_tree = NULL;
+
+  p->state = SNMP_DOWN;
+}
+
+/*
+ * snmp_set_state - change state with associated actions
+ * @p: SNMP protocol instance
+ * @state: new SNMP protocol state
+ *
+ * This function does not notify the bird about protocol state. Return current
+ * protocol state (PS_UP, ...).
+ */
+int
+snmp_set_state(struct snmp_proto *p, enum snmp_proto_state state)
+{
+  enum snmp_proto_state last = p->state;
+  const struct snmp_config *cf = (struct snmp_config *) p->p.cf;
+
+  p->state = state;
+
+  switch (state)
+  {
+  case SNMP_INIT:
+    /* We intentionally do not log anything */
+    ASSERT(last == SNMP_DOWN);
+
+    proto_notify_state(&p->p, PS_START);
+    if (cf->trans_type == SNMP_TRANS_TCP)
+    {
+      /* We need to lock the IP address */
+      struct object_lock *lock;
+      lock = p->lock = olock_new(p->pool);
+      lock->addr = p->master_ip;
+      lock->port = p->master_port;
+      lock->type = OBJLOCK_TCP;
+      lock->hook = snmp_start_locked;
+      lock->data = p;
+      olock_acquire(lock);
+      return PS_START;
+    }
+
+    last = SNMP_INIT;
+    p->state = state = SNMP_LOCKED;
+    /* Fall thru */
+
+  case SNMP_LOCKED:
+    TRACE(D_EVENTS, "SNMP Address lock acquired");
+    ASSERT(last == SNMP_INIT);
+    sock *s = sk_new(p->pool);
+
+    if (cf->trans_type == SNMP_TRANS_TCP)
+    {
+      s->type = SK_TCP_ACTIVE;
+      s->daddr = p->master_ip;
+      s->dport = p->master_port;
+      s->rbsize = SNMP_RX_BUFFER_SIZE;
+      s->tbsize = SNMP_TX_BUFFER_SIZE;
+    }
+    else
+    {
+      s->type = SK_UNIX_ACTIVE;
+      s->host = cf->master_path; /* daddr */
+      s->rbsize = SNMP_RX_BUFFER_SIZE;
+      s->tbsize = SNMP_TX_BUFFER_SIZE;
+    }
+
+    s->tx_hook = snmp_connected;
+    s->err_hook = snmp_sock_err;
+
+    p->sock = s;
+    s->data = p;
+
+    /* Try opening the socket, schedule a retry on fail */
+    if (sk_open(s) < 0)
+    {
+      TRACE(D_EVENTS, "SNMP Opening of communication socket failed");
+      rfree(s);
+      p->sock = NULL;
+      // TODO handle 0 timeout
+      tm_start(p->startup_timer, p->timeout);
+    }
+    return PS_START;
+
+  case SNMP_OPEN:
+    TRACE(D_EVENTS, "SNMP Communication socket opened, starting AgentX subagent");
+    ASSERT(last == SNMP_LOCKED);
+
+    p->sock->rx_hook = snmp_rx;
+    p->sock->tx_hook = NULL;
+
+    snmp_start_subagent(p);
+
+    p->startup_timer->hook = snmp_stop_timeout;
+    tm_start(p->startup_timer, 1 S);
+    return PS_START;
+
+  case SNMP_REGISTER:
+    TRACE(D_EVENTS, "SNMP Registering MIBs");
+    ASSERT(last == SNMP_OPEN);
+
+    tm_stop(p->startup_timer); /* stop timeout */
+
+    p->sock->rx_hook = snmp_rx;
+    p->sock->tx_hook = snmp_tx;
+
+    snmp_register_mibs(p);
+
+    // TODO timer for CONN
+
+    return PS_START;
+
+  case SNMP_CONN:
+    TRACE(D_EVENTS, "MIBs registered, AgentX session established");
+    ASSERT(last == SNMP_REGISTER);
+    proto_notify_state(&p->p, PS_UP);
+    return PS_UP;
+
+  case SNMP_STOP:
+    if (p->sock && p->state != SNMP_OPEN && !sk_tx_buffer_empty(p->sock))
+    {
+      TRACE(D_EVENTS, "SNMP Closing AgentX session");
+      if (p->state == SNMP_OPEN || p->state == SNMP_REGISTER ||
+	  p->state == SNMP_CONN)
+	snmp_stop_subagent(p);
+
+      p->sock->rx_hook = snmp_rx_skip;
+      p->sock->tx_hook = snmp_tx_skip;
+
+      p->startup_timer->hook = snmp_stop_timeout;
+      tm_start(p->startup_timer, 150 MS);
+      proto_notify_state(&p->p, PS_STOP);
+      return PS_STOP;
+    }
+
+    p->state = state = SNMP_DOWN;
+    /* Fall thru */
+
+  case SNMP_DOWN:
+    TRACE(D_EVENTS, "SNMP AgentX session closed");
+    snmp_cleanup(p);
+    proto_notify_state(&p->p, PS_DOWN);
+    return PS_DOWN;
+
+  default:
+    die("unknown SNMP state transition");
+    return PS_DOWN;
+  }
+}
+
+/*
+ * snmp_reset - reset AgentX session
+ * @p: SNMP protocol instance
+ *
+ * We wait until the last PDU written into the socket is send while ignoring all
+ * incomming PDUs. Then we hard reset the connection by socket closure. The
+ * protocol instance is automatically restarted by nest.
+ *
+ * Return protocol state (PS_STOP, ...).
+ */
+int
+snmp_reset(struct snmp_proto *p)
+{
+  return snmp_set_state(p, SNMP_STOP);
+}
+
+/*
+ * snmp_up - AgentX session has registered all MIBs, protocols is up
+ * @p: SNMP protocol instance
+ */
+void
+snmp_up(struct snmp_proto *p)
+{
+  if (p->state == SNMP_REGISTER)
+    snmp_set_state(p, SNMP_CONN);
+}
+
+/*
+ * snmp_shutdown - Forcefully stop the SNMP protocol instance
+ * @P: SNMP protocol generic handle
+ *
+ * Simple cast-like wrapper around snmp_reset(), see more info there.
+ */
+static int
+snmp_shutdown(struct proto *P)
+{
+  struct snmp_proto *p = SKIP_BACK(struct snmp_proto, p, P);
+  return snmp_reset(p);
+}
+
+/*
+ * snmp_show_proto_info - print basic information about SNMP protocol instance
+ * @P: SNMP protocol generic handle
+ */
+static void
+snmp_show_proto_info(struct proto *P)
+{
+  struct snmp_proto *p = (void *) P;
+
+  cli_msg(-1006, "  SNMP state: %s", snmp_state_str[p->state]);
+  cli_msg(-1006, "  MIBs");
+
+  snmp_bgp4_show_info(p);
+}
+
+/*
+ * snmp_reconfigure_logic - find changes in configuration
+ * @p: SNMP protocol instance
+ * @new: new SNMP protocol configuration
+ *
+ * Return 1 if only minor changes have occured, 0 if we need full down-up cycle.
+ */
+static inline int
+snmp_reconfigure_logic(struct snmp_proto *p, const struct snmp_config *new)
+{
+  const struct snmp_config *old = SKIP_BACK(struct snmp_config, cf, p->p.cf);
+
+  if ((old->trans_type != SNMP_TRANS_TCP) && (new->trans_type == SNMP_TRANS_TCP)
+    || (old->trans_type == SNMP_TRANS_TCP) && (new->trans_type != SNMP_TRANS_TCP))
+    return 0;
+
+  if (old->trans_type == SNMP_TRANS_TCP &&
+      (ipa_compare(old->master_ip, new->master_ip)
+      || old->master_port != new->master_port))
+    return 0;
+
+  if (old->trans_type != SNMP_TRANS_TCP &&
+      bstrcmp(old->master_path, new->master_path))
+    return 0;
+
+  return (old->bgp4_local_id != new->bgp4_local_id
+      || old->bgp4_local_as != new->bgp4_local_as
+      || old->timeout != new->timeout	// TODO distinguish message timemout
+	//(Open.timeout and timeout for timer)
+      || old->priority != new->priority
+      || strncmp(old->description, new->description, UINT16_MAX - 1));
+}
+
+/*
+ * snmp_reconfigure - Indicate instance reconfigurability
+ * @P - SNMP protocol generic handle, current state
+ * @CF - SNMP protocol configuration generic handle carring new values
+ *
+ * We accept the reconfiguration if the new configuration @CF is identical with
+ * the currently deployed configuration. Otherwise we deny reconfiguration because
+ * the implementation would be cumbersome.
+ */
+static int
+snmp_reconfigure(struct proto *P, struct proto_config *CF)
+{
+  struct snmp_proto *p = SKIP_BACK(struct snmp_proto, p, P);
+  const struct snmp_config *new = SKIP_BACK(struct snmp_config, cf, CF);
+
+  /* We are searching for configuration changes */
+  int reconfigurable = snmp_reconfigure_logic(p, new);
+
+  if (reconfigurable)
+  {
+    /* copy possibly changed values */
+    p->startup_delay = new->startup_delay;
+    p->verbose = new->verbose;
+
+    ASSERT(p->ping_timer);
+    int active = tm_active(p->ping_timer);
+    rfree(p->ping_timer);
+    p->ping_timer = tm_new_init(p->pool, snmp_ping_timeout, p, p->timeout, 0);
+
+    if (active)
+      tm_start(p->ping_timer, p->timeout);
+
+    HASH_FREE(p->bgp_hash);
+    HASH_INIT(p->bgp_hash, p->pool, 10);
+
+    rfree(p->lp);
+    p->lp = lp_new(p->pool);
+    p->bgp_trie = f_new_trie(p->lp, 0);
+
+    /* We repopulate BGP related data structures (bgp_hash, bgp_trie). */
+    snmp_bgp4_start(p, 0);
+  }
+
+  return reconfigurable;
+}
+
+/*
+ * snmp_start - Initialize the SNMP protocol instance
+ * @P: SNMP protocol generic handle
+ *
+ * The first step in AgentX subagent startup is protocol initialition.
+ * We must prepare lists, find BGP peers and finally asynchronously start
+ * a AgentX subagent session.
+ */
+static int
+snmp_start(struct proto *P)
+{
+  struct snmp_proto *p = (void *) P;
+  struct snmp_config *cf = (struct snmp_config *) P->cf;
+
+  p->local_ip = cf->local_ip;
+  p->master_ip = cf->master_ip;
+  p->master_port = cf->master_port;
+  p->bgp4_local_as = cf->bgp4_local_as;
+  p->bgp4_local_id = cf->bgp4_local_id;
+  p->timeout = cf->timeout;
+  p->startup_delay = cf->startup_delay;
+  p->verbose = cf->verbose;
+
+  p->pool = p->p.pool;
+  p->lp = lp_new(p->pool);
+  p->bgp_trie = f_new_trie(p->lp, 0);
+  p->mib_tree = mb_alloc(p->pool, sizeof(struct mib_tree));
+
+  p->startup_timer = tm_new_init(p->pool, snmp_startup_timeout, p, 0, 0);
+  p->ping_timer = tm_new_init(p->pool, snmp_ping_timeout, p, p->timeout, 0);
+
+  init_list(&p->registration_queue);
+
+  /* We create copy of bonds to BGP protocols. */
+  HASH_INIT(p->bgp_hash, p->pool, 10);
+
+  mib_tree_init(p->pool, p->mib_tree);
+  snmp_bgp4_start(p, 1);
+
+  return snmp_set_state(p, SNMP_INIT);
+}
+
+/*
+ * snmp_init - preinitialize SNMP instance
+ * @CF: SNMP configuration generic handle
+ *
+ * Returns a generic handle pointing to preinitialized SNMP procotol
+ * instance.
+ */
+static struct proto *
+snmp_init(struct proto_config *CF)
+{
+  struct proto *P = proto_new(CF);
+  struct snmp_proto *p = SKIP_BACK(struct snmp_proto, p, P);
+
+  p->rl_gen = (struct tbf) TBF_DEFAULT_LOG_LIMITS;
+  p->state = SNMP_DOWN;
+
+  return P;
+}
+
+/*
+ * snmp_postconfig - Check configuration correctness
+ * @CF: SNMP procotol configuration generic handle
+ */
+static void
+snmp_postconfig(struct proto_config *CF)
+{
+  const struct snmp_config *cf  = (struct snmp_config *) CF;
+
+  /* Walk the BGP protocols and cache their references. */
+  if (cf->bgp4_local_as == 0)
+    cf_error("local as not specified");
+}
+
+
+/*
+ * Protocol infrastructure
+ */
+
+struct protocol proto_snmp = {
+  .name =		"SNMP",
+  .template =		"snmp%d",
+  .class =		PROTOCOL_SNMP,
+  .channel_mask =	0,
+  .proto_size =		sizeof(struct snmp_proto),
+  .config_size =	sizeof(struct snmp_config),
+  .postconfig =		snmp_postconfig,
+  .init =		snmp_init,
+  .start =		snmp_start,
+  .reconfigure =	snmp_reconfigure,
+  .show_proto_info = 	snmp_show_proto_info,
+  .shutdown =		snmp_shutdown,
+};
+
+void
+snmp_build(void)
+{
+  proto_build(&proto_snmp);
+}
+
diff --git a/proto/snmp/snmp.h b/proto/snmp/snmp.h
new file mode 100644
index 00000000..06e90c6b
--- /dev/null
+++ b/proto/snmp/snmp.h
@@ -0,0 +1,174 @@
+/*
+ *	BIRD -- Simple Network Management Protocol (SNMP)
+ *
+ *      (c) 2022 Vojtech Vilimek <vojtech.vilimek@nic.cz>
+ *      (c) 2022 CZ.NIC z.s.p.o
+ *
+ *	Can be freely distributed and used under the terms of the GNU GPL.
+ */
+
+#ifndef _BIRD_SNMP_H_
+#define _BIRD_SNMP_H_
+
+#include "nest/bird.h"
+#include "nest/protocol.h"
+#include "lib/resource.h"
+#include "lib/ip.h"
+#include "lib/socket.h"
+#include "lib/timer.h"
+#include "filter/data.h"
+
+#define SNMP_UNDEFINED	0
+#define SNMP_BGP	1
+#define SNMP_OSPF	2
+#define SNMP_INVALID  255
+
+#define SNMP_PORT 705
+
+#define SNMP_RX_BUFFER_SIZE 8192
+#define SNMP_TX_BUFFER_SIZE 8192
+#define SNMP_PKT_SIZE_MAX 4098
+
+#define AGENTX_MASTER_ADDR "/var/agentx/master"
+
+enum snmp_proto_state {
+  SNMP_DOWN = 0,
+  SNMP_INIT = 1,
+  SNMP_LOCKED,
+  SNMP_OPEN,
+  SNMP_REGISTER,
+  SNMP_CONN,
+  SNMP_STOP,
+};
+
+struct snmp_bond {
+  node n;
+  struct proto_config *config;
+  u8 type;
+};
+
+enum snmp_transport_type {
+  SNMP_TRANS_DEFAULT,
+  SNMP_TRANS_UNIX,
+  SNMP_TRANS_TCP,
+};
+
+#define SNMP_BGP_P_REGISTERING	0x01
+#define SNMP_BGP_P_REGISTERED	0x02
+
+struct snmp_bgp_peer {
+  const struct bgp_proto *bgp_proto;
+  ip4_addr peer_ip;		      /* used as hash key */
+  struct snmp_bgp_peer *next;
+};
+
+struct snmp_config {
+  struct proto_config cf;
+  enum snmp_transport_type trans_type;
+  ip_addr local_ip;
+  ip_addr master_ip;		  /* master agentx IP address for TCP transport */
+  u16 master_port;
+  const char *master_path;	  /* master agentx UNIX socket name */
+
+  u32 bgp4_local_id;	  /* BGP4-MIB related fields */
+  u32 bgp4_local_as;
+
+  btime timeout;
+  btime startup_delay;
+  u8 priority;
+  u32 bonds;
+  const char *description;	  /* The order of fields is not arbitrary */
+  list bgp_entries;		  /* We want dynamically allocated fields to be
+				   * at the end of the config struct.
+				   * We use this fact to check differences of
+				   * nonallocated parts of configs with memcpy
+				   */
+  //const struct oid *oid_identifier;	TODO
+  int verbose;
+};
+
+struct snmp_proto {
+  struct proto p;
+  struct object_lock *lock;
+  pool *pool;			  /* a shortcut to the procotol mem. pool */
+  linpool *lp;			  /* linpool for bgp_trie nodes */
+
+  enum snmp_proto_state state;
+
+  ip_addr local_ip;
+  ip_addr master_ip;
+  u16 master_port;
+
+  /* TODO add struct for grouping BGP4-MIB data */
+  u32 bgp4_local_id;		  /* BGP4-MIB related fields */
+  u32 bgp4_local_as;
+
+  sock *sock;
+
+
+  btime timeout;		  /* timeout is part of MIB registration. It
+				    specifies how long should the master
+				    agent wait for request responses. */
+
+  u32 session_id;
+  u32 transaction_id;
+  u32 packet_id;
+
+  list registration_queue;		    /* list containing snmp_register records */
+
+  // map
+  struct f_trie *bgp_trie;
+  HASH(struct snmp_bgp_peer) bgp_hash;
+  struct tbf rl_gen;
+
+  list pending_pdus;
+
+  timer *ping_timer;
+  btime startup_delay;
+  timer *startup_timer;
+
+  struct mib_tree *mib_tree;
+  int verbose;
+  uint pings;
+  u32 ignore_ping_id;
+};
+
+enum agentx_mibs {
+  BGP4_MIB_ID,
+  AGENTX_MIB_COUNT,
+  AGENTX_MIB_UNKNOWN,
+};
+
+struct snmp_registration;
+struct agentx_response; /* declared in subagent.h */
+typedef void (*snmp_reg_hook_t)(struct snmp_proto *p, const struct agentx_response *res, struct snmp_registration *reg);
+
+struct snmp_registration {
+  node n;
+  enum agentx_mibs mib;
+  u32 session_id;
+  u32 transaction_id;
+  u32 packet_id;
+  snmp_reg_hook_t reg_hook_ok; /* hook called when successful response to OID registration is recieved */
+  snmp_reg_hook_t reg_hook_fail; /* hook called when OID registration fail */
+};
+
+void snmp_startup(struct snmp_proto *p);
+void snmp_connected(sock *sk);
+void snmp_startup_timeout(timer *tm);
+void snmp_reconnect(timer *tm);
+int snmp_set_state(struct snmp_proto *p, enum snmp_proto_state state);
+int snmp_reset(struct snmp_proto *p);
+void snmp_up(struct snmp_proto *p);
+
+extern const char agentx_master_addr[sizeof(AGENTX_MASTER_ADDR)];
+
+static inline int
+proto_is_snmp(const struct proto *P)
+{
+  extern struct protocol proto_snmp;
+  return P->proto == &proto_snmp;
+}
+
+
+#endif
diff --git a/proto/snmp/snmp_test.c b/proto/snmp/snmp_test.c
new file mode 100644
index 00000000..ebef7798
--- /dev/null
+++ b/proto/snmp/snmp_test.c
@@ -0,0 +1,1965 @@
+/*
+ *	BIRD -- Simple Network Management Protocol (SNMP) Unit tests
+ *
+ *      (c) 2022 Vojtech Vilimek <vojtech.vilimek@nic.cz>
+ *      (c) 2022 CZ.NIC z.s.p.o
+ *
+ *	Can be freely distributed and used under the terms of the GNU GPL.
+ */
+
+#include <stdarg.h>
+
+#include "test/birdtest.h"
+#include "test/bt-utils.h"
+
+#include "bgp4_mib.h"
+#include "subagent.h"
+#include "snmp.h"
+#include "snmp_utils.h"
+#include "mib_tree.h"
+
+static int t_oid_empty(void);
+static int t_oid_compare(void);
+static int t_varbind_name_to_tx(void);
+static int t_walk_oid_desc(void);
+static int t_walk_oid_compare(void);
+static int t_tree_find(void);
+static int t_tree_traversal(void);
+static int t_tree_leafs(void);
+static int t_tree_add(void);
+static int t_tree_delete(void);
+
+#define SNMP_BUFFER_SIZE 1024
+#define TESTS_NUM   32
+#define SMALL_TESTS_NUM 10
+static int tree_sizes[] = { 0, 1, 10, 100, 1000 };
+
+/* smaller than theoretical maximum (2^32) to fit in memory */
+#define OID_MAX_ID 16
+
+#define SNMP_EXPECTED(actual, expected) \
+  bt_debug("%s  expected: %3u   actual: %3u\n", \
+    #expected, expected, actual);
+
+static inline struct oid *
+oid_allocate(uint size)
+{
+  return tmp_alloc(sizeof(struct oid) + size * sizeof(u32));
+}
+
+static inline void
+oid_init2(struct oid *oid, u8 n_subid, u8 prefix, u8 include, va_list ids)
+{
+  oid->n_subid = n_subid;
+  oid->prefix = prefix;
+  oid->include = include;
+  oid->reserved = 0;
+
+  for (u8 i = 0; i < n_subid; i++)
+  {
+    u32 id = va_arg(ids, u32);
+    oid->ids[i] = id;
+  }
+}
+
+static inline void
+oid_init(struct oid *oid, u8 n_subid, u8 prefix, u8 include, ...)
+{
+  va_list ids;
+  va_start(ids, include);
+  oid_init2(oid, n_subid, prefix, include, ids);
+  va_end(ids);
+}
+
+static inline struct oid *
+oid_create(u8 n_subid, u8 prefix, u8 include, ...)
+{
+  struct oid *result = tmp_alloc(snmp_oid_size_from_len(n_subid));
+  va_list ids;
+
+  va_start(ids, include);
+  oid_init2(result, n_subid, prefix, include, ids);
+  va_end(ids);
+
+  return result;
+}
+
+static u32
+oid_random_id(void)
+{
+  return (bt_random() % (OID_MAX_ID));
+}
+
+static struct oid *
+random_prefixed_oid(void)
+{
+  u32 len = bt_random_n(OID_MAX_LEN + 1 - (ARRAY_SIZE(snmp_internet) + 1));
+
+  u8 prefix = (u8) bt_random_n(UINT8_MAX + 1);
+
+  if (!prefix)
+    return oid_create(0, 0, 0, 0);
+
+  struct oid *random = tmp_alloc(snmp_oid_size_from_len(len));
+  /* (bt_random_n(2) * bt_random()) has 0.5 probability to have value 0 and
+   * 0.5 to have random u32 (including zero) */
+  oid_init(random, 0, prefix, bt_random_n(2) * bt_random());
+  random->n_subid = len;
+
+  for (u32 id = 0; id < len; id++)
+    random->ids[id] = oid_random_id();
+
+  return random;
+}
+
+static struct oid *
+random_no_prefix_oid(void)
+{
+  /* probability that the random OID is prefixable is practically zero */
+  u32 len = bt_random_n(OID_MAX_LEN + 1);
+
+  struct oid *random = tmp_alloc(snmp_oid_size_from_len(len));
+  /* (bt_random_n(2) * bt_random()) has 0.5 probability to have value 0 and
+   * 0.5 to have random u32 (including zero) */
+  oid_init(random, 0, 0, bt_random_n(2) * bt_random());
+  random->n_subid = len;
+
+  for (u32 id = 0; id < len; id++)
+    random->ids[id] = oid_random_id();
+
+  return random;
+}
+
+static struct oid *
+random_prefixable_oid(void)
+{
+  /* generate the len without the snmp_internet prefix included and prefix ID */
+  u32 len = bt_random_n(OID_MAX_LEN + 1 - (ARRAY_SIZE(snmp_internet) + 1));
+
+  struct oid *random = tmp_alloc(
+      snmp_oid_size_from_len(len + ARRAY_SIZE(snmp_internet) + 1));
+  /* (bt_random_n(2) * bt_random()) has 0.5 probability to have value 0 and
+   * 0.5 to have random u32 (including zero) */
+  oid_init(random, 0, 0, bt_random_n(2) * bt_random());
+  random->n_subid = len + ARRAY_SIZE(snmp_internet) + 1;
+
+  for (u32 inet_id = 0; inet_id < ARRAY_SIZE(snmp_internet); inet_id++)
+    random->ids[inet_id] = snmp_internet[inet_id];
+
+  random->ids[ARRAY_SIZE(snmp_internet)] = bt_random_n(UINT8_MAX + 1);
+
+  for (u32 id = 0; id < len; id++)
+    random->ids[id + ARRAY_SIZE(snmp_internet) + 1] = oid_random_id();
+
+  return random;
+}
+
+static struct oid *
+random_oid(void)
+{
+  u32 option = bt_random_n(3);
+
+  if (option == 0)
+    return random_prefixed_oid();
+  else if (option == 1)
+    return random_no_prefix_oid();
+  else
+    return random_prefixable_oid();
+}
+
+static int
+t_oid_empty(void)
+{
+  struct lp_state tmps;
+  lp_save(tmp_linpool, &tmps);
+
+  bt_assert(snmp_is_oid_empty(NULL) == 0);
+
+  {
+    struct oid *blank = oid_create(0, 0, 0 /* no ids */);
+    bt_assert(snmp_is_oid_empty(blank) == 1);
+    lp_restore(tmp_linpool, &tmps);
+  }
+
+
+  {
+    struct oid *prefixed = oid_create(3, 100, 1,
+      /* ids */ ~((u32) 0), 0, 256);
+    bt_assert(snmp_is_oid_empty(prefixed) == 0);
+    lp_restore(tmp_linpool, &tmps);
+  }
+
+
+  {
+    struct oid *to_prefix = oid_create(8, 0, 1,
+      /* ids */ 1, 3, 6, 1, 100, ~((u32) 0), 0, 256);
+    bt_assert(snmp_is_oid_empty(to_prefix) == 0);
+    lp_restore(tmp_linpool, &tmps);
+  }
+
+
+  {
+    struct oid *unprefixable = oid_create(2, 0, 0,
+      /* ids */ 65535, 4);
+    bt_assert(snmp_is_oid_empty(unprefixable) == 0);
+    lp_restore(tmp_linpool, &tmps);
+  }
+
+  {
+    struct oid *unprefixable2 = oid_create(8, 0, 1,
+      /* ids */ 1, 3, 6, 2, 1, 2, 15, 6);
+    bt_assert(snmp_is_oid_empty(unprefixable2) == 0);
+    lp_restore(tmp_linpool, &tmps);
+  }
+
+  tmp_flush();
+  return 1;
+}
+
+static int
+t_oid_compare(void)
+{
+  struct lp_state tmps;
+  lp_save(tmp_linpool, &tmps);
+
+  /* same length, no prefix */
+  struct oid *l1 = oid_create(5, 0, 1,
+      /* ids */ 1, 2, 3, 4, 5);
+
+  struct oid *r1 = oid_create(5, 0, 0,
+      /* ids */ 1, 2, 3, 4, 6);
+
+  bt_assert(snmp_oid_compare(l1, r1) == -1);
+  bt_assert(snmp_oid_compare(r1, l1) ==  1);
+
+  bt_assert(snmp_oid_compare(l1, l1) ==  0);
+  bt_assert(snmp_oid_compare(r1, r1) ==  0);
+
+  /* same results for prefixed oids */
+  l1->prefix = 1;
+  r1->prefix = 1;
+
+  bt_assert(snmp_oid_compare(l1, r1) == -1);
+  bt_assert(snmp_oid_compare(r1, l1) ==  1);
+
+  bt_assert(snmp_oid_compare(l1, l1) ==  0);
+  bt_assert(snmp_oid_compare(r1, r1) ==  0);
+
+  /* different prefix -- has higher priority */
+  l1->prefix = 8;
+  r1->prefix = 4;
+
+  bt_assert(snmp_oid_compare(l1, r1) ==  1);
+  bt_assert(snmp_oid_compare(r1, l1) == -1);
+
+  bt_assert(snmp_oid_compare(l1, l1) ==  0);
+  bt_assert(snmp_oid_compare(r1, r1) ==  0);
+
+  lp_restore(tmp_linpool, &tmps);
+
+
+  /* different length, no prefix */
+  l1 = oid_create(4, 0, 0,
+      /* ids */ 1, 2, 3, 4);
+
+  r1 = oid_create(5, 0, 1,
+      /* ids */ 1, 2, 3, 4, 1);
+
+  bt_assert(snmp_oid_compare(l1, r1) == -1);
+  bt_assert(snmp_oid_compare(r1, l1) ==  1);
+
+  bt_assert(snmp_oid_compare(l1, l1) ==  0);
+  bt_assert(snmp_oid_compare(r1, r1) ==  0);
+
+  /* same results for prefixed oids */
+  l1->prefix = 3;
+  r1->prefix = 3;
+
+  bt_assert(snmp_oid_compare(l1, r1) == -1);
+  bt_assert(snmp_oid_compare(r1, l1) ==  1);
+
+  bt_assert(snmp_oid_compare(l1, l1) ==  0);
+  bt_assert(snmp_oid_compare(r1, r1) ==  0);
+
+  /* different prefix -- has higher priority */
+  l1->prefix = 17;
+  r1->prefix = 14;
+
+  bt_assert(snmp_oid_compare(l1, r1) ==  1);
+  bt_assert(snmp_oid_compare(r1, l1) == -1);
+
+  bt_assert(snmp_oid_compare(l1, l1) ==  0);
+  bt_assert(snmp_oid_compare(r1, r1) ==  0);
+
+  lp_restore(tmp_linpool, &tmps);
+
+
+  /* inverse order different length, no prefix */
+  l1 = oid_create(4, 0, 0,
+      /* ids */ 1, 2, 3, 5);
+
+  r1 = oid_create(5, 0, 0,
+      /* ids */ 1, 2, 3, 4, 1);
+
+  bt_assert(snmp_oid_compare(l1, r1) ==  1);
+  bt_assert(snmp_oid_compare(r1, l1) == -1);
+
+  bt_assert(snmp_oid_compare(l1, l1) ==  0);
+  bt_assert(snmp_oid_compare(r1, r1) ==  0);
+
+  /* same results for prefixed oids */
+  l1->prefix = 254;
+  r1->prefix = 254;
+
+  bt_assert(snmp_oid_compare(l1, r1) ==  1);
+  bt_assert(snmp_oid_compare(r1, l1) == -1);
+
+  bt_assert(snmp_oid_compare(l1, l1) ==  0);
+  bt_assert(snmp_oid_compare(r1, r1) ==  0);
+
+  /* different prefix -- has higher priority */
+  l1->prefix = 127;
+  r1->prefix = 35;
+
+  bt_assert(snmp_oid_compare(l1, r1) ==  1);
+  bt_assert(snmp_oid_compare(r1, l1) == -1);
+
+  lp_restore(tmp_linpool, &tmps);
+
+
+/* ==== MIXED PREFIXED / NON PREFIXED OID compare ==== */
+  /* same length, mixed */
+  l1 = oid_create(6, 0, 1,
+      /* ids */ 1, 2, 17, 3, 21, 4);
+
+  r1 = oid_create(1, 5, 1,
+      /* ids */ 3);
+
+  bt_assert(snmp_oid_compare(l1, r1) == -1);
+  bt_assert(snmp_oid_compare(r1, l1) ==  1);
+
+  bt_assert(snmp_oid_compare(l1, l1) ==  0);
+  bt_assert(snmp_oid_compare(r1, r1) ==  0);
+
+  lp_restore(tmp_linpool, &tmps);
+
+  struct oid *super = oid_create(4, 0, 0, /* ids */ 1, 3, 6, 1);
+  struct oid *weird = oid_create(4, 70, 0, /* ids */ 9, 10, 10, 12);
+
+  bt_assert(snmp_oid_compare(super, weird) != 0);
+
+  struct oid *pref = oid_create(0, 7, 0); // no ids, only prefix
+  struct oid *no_pref = oid_create(5, 0, 0, /* ids */ 1, 3, 6, 1, 7);
+
+  bt_assert(snmp_oid_compare(pref, no_pref) == 0);
+
+  struct oid *inet = oid_create(4, 0, 0, /* ids */ 1, 3, 6, 1);
+
+  bt_assert(snmp_oid_compare(inet, pref) < 0);
+  bt_assert(snmp_oid_compare(pref, inet) > 0);
+  bt_assert(snmp_oid_compare(inet, no_pref) < 0);
+  bt_assert(snmp_oid_compare(no_pref, inet) > 0);
+
+  struct oid *pref2 = oid_create(0, 16, 0); // no ids, only prefix
+  struct oid *no_pref2 = oid_create(5, 0, 0, /* ids */ 1, 3, 6, 1, 16);
+
+  bt_assert(snmp_oid_compare(pref2, no_pref2) == 0);
+  bt_assert(snmp_oid_compare(no_pref2, pref2) == 0);
+
+  bt_assert(snmp_oid_compare(pref, pref2) < 0);
+  bt_assert(snmp_oid_compare(pref2, pref) > 0);
+  bt_assert(snmp_oid_compare(pref, no_pref2) < 0);
+  bt_assert(snmp_oid_compare(no_pref2, pref) > 0);
+  bt_assert(snmp_oid_compare(no_pref, pref2) < 0);
+  bt_assert(snmp_oid_compare(pref2, no_pref) > 0);
+  bt_assert(snmp_oid_compare(no_pref, no_pref2) < 0);
+  bt_assert(snmp_oid_compare(no_pref2, no_pref) > 0);
+
+
+  tmp_flush();
+  return 1;
+}
+
+static inline void
+fix_byteorder(u32 *ids, u32 len)
+{
+  for (u32 i = 0; i < len; i++)
+    STORE_U32(ids[i], ids[i]);
+}
+
+int
+u32cmp_bo(const u32 *cpu_native, const u32 *net_bo, u32 len)
+{
+  for (u32 i = 0; i < len; i++)
+  {
+    if (cpu_native[i] != LOAD_U32(net_bo[i]))
+      return LOAD_U32(net_bo[i]) - cpu_native[i];
+  }
+
+  return 0;
+}
+
+#define CREATE_RANDOM(gen)	\
+  ({  \
+    struct oid *_o = gen(); \
+    fix_byteorder(_o->ids, _o->n_subid);  \
+    _o; \
+  })
+
+static int
+t_varbind_name_to_tx(void)
+{
+  /* Test snmp_vb_name_to_tx() */
+
+  lp_state tmps = { };
+  struct snmp_proto *snmp_proto = tmp_alloc(sizeof(struct snmp_proto));
+  memset(snmp_proto, 0, sizeof(struct snmp_proto));
+  sock *s = sk_new(&root_pool);
+  snmp_proto->sock = s;
+  sk_set_tbsize(s, SNMP_BUFFER_SIZE);
+  void *buffer = s->tbuf;
+
+  struct snmp_pdu copy = {
+    .p = snmp_proto,
+    .sr_vb_start = (void *) buffer,
+    .buffer = buffer,
+  };
+  struct snmp_pdu c = copy;
+  struct oid *new;
+  struct agentx_varbind *vb;
+
+  lp_save(tmp_linpool, &tmps);
+
+  /* testing prefixable OIDs */
+  for (int test = 0; test < TESTS_NUM; test++)
+  {
+    const struct oid *oid = CREATE_RANDOM(random_prefixable_oid);
+
+    /* both LOAD_U8() and STORE_U8() are pointless as it byteorder does not
+     * influence single byte values.
+     */
+
+    u8 subids = oid->n_subid;
+    u8 include = oid->include;
+    u32 pid = LOAD_U32(oid->ids[ARRAY_SIZE(snmp_internet)]);
+
+    /* reset to the default snmp_pdu */
+    c = copy; memset(buffer, 0, snmp_oid_size(oid) + 8);
+
+    vb = snmp_vb_name_to_tx(&c, oid);
+    new = &vb->name;
+
+    bt_assert(new->n_subid == subids - (ARRAY_SIZE(snmp_internet) + 1));
+    bt_assert(new->prefix == pid);
+    bt_assert(!!new->include == !!include);
+    bt_assert(new->reserved == 0);
+
+    for (u32 i = 0; i < new->n_subid; i++)
+    {
+      bt_assert(new->ids[i] == LOAD_U32(oid->ids[i + ARRAY_SIZE(snmp_internet) + 1]));
+    }
+
+    for (u32 j = 0; j < ARRAY_SIZE(snmp_internet); j++)
+      bt_assert(LOAD_U32(oid->ids[j]) == snmp_internet[j]);
+
+    lp_restore(tmp_linpool, &tmps);
+  }
+
+  /* testing already prefixed OIDs */
+  for (int test = 0; test < TESTS_NUM; test++)
+  {
+    const struct oid *prefixed = CREATE_RANDOM(random_prefixed_oid);
+
+    /* reset to the default snmp_pdu */
+    c = copy; memset(buffer, 0, snmp_oid_size(prefixed) + 8);
+
+    vb = snmp_vb_name_to_tx(&c, prefixed);
+    new = &vb->name;
+
+    bt_assert(new->n_subid == prefixed->n_subid);
+    bt_assert(new->prefix == prefixed->prefix);
+    bt_assert(!!new->include == !!prefixed->include);
+    bt_assert(new->reserved == 0);
+    bt_assert(!u32cmp_bo(&new->ids[0], &prefixed->ids[0], new->n_subid));
+
+    lp_restore(tmp_linpool, &tmps);
+  }
+
+  lp_restore(tmp_linpool, &tmps);
+
+  /* testing non-prefixable OIDs */
+  for (int test = 0; test < TESTS_NUM; test++)
+  {
+    const struct oid *oid = CREATE_RANDOM(random_no_prefix_oid);
+
+    /* test that the OID is _really_ not prefixable */
+    if (oid->n_subid > ARRAY_SIZE(snmp_internet) &&
+	LOAD_U32(oid->ids[ARRAY_SIZE(snmp_internet) + 1]) <= UINT8_MAX)
+    {
+      for (u32 i = 0; i < ARRAY_SIZE(snmp_internet); i++)
+	if (LOAD_U32(oid->ids[i]) != snmp_internet[i]) goto continue_testing;
+
+      break; /* outer for loop */
+    }
+
+continue_testing:
+
+    /* reset to the default snmp_pdu */
+    c = copy; memset(buffer, 0, snmp_oid_size(oid) + 8);
+
+    vb = snmp_vb_name_to_tx(&c, oid);
+    new = &vb->name;
+
+    bt_assert(new->n_subid == oid->n_subid);
+    bt_assert(new->prefix == oid->prefix);
+    bt_assert(!!new->include == !!oid->include);
+    bt_assert(new->reserved == 0);
+    bt_assert(!u32cmp_bo(&new->ids[0], &oid->ids[0], new->n_subid));
+
+    lp_restore(tmp_linpool, &tmps);
+  }
+
+  for (int test = 0; test < SMALL_TESTS_NUM; test++)
+  {
+    const struct oid *oid;
+    {
+      struct oid *work = random_prefixable_oid();
+      fix_byteorder(work->ids, work->n_subid);
+
+      /* include also the prefix ID (at index 4) */
+      u32 index = bt_random_n(ARRAY_SIZE(snmp_internet) + 1);
+      /* change randomly picked id at index from 0..5 (included) */
+      u32 random = bt_random();
+      if (index == ARRAY_SIZE(snmp_internet) && random > 255)
+	work->ids[index] = VALUE_U32(random);
+      else if (index != ARRAY_SIZE(snmp_internet) && work->ids[index] != random)
+	work->ids[index] = VALUE_U32(random);
+      else
+	continue;
+      oid = work;
+    }
+
+    /* reset to the default snmp_pdu */
+    c = copy; memset(buffer, 0, snmp_oid_size(oid) + 8);
+
+    vb = snmp_vb_name_to_tx(&c, oid);
+    new = &vb->name;
+
+    bt_assert(new->n_subid == oid->n_subid);
+    bt_assert(new->prefix == oid->prefix);
+    bt_assert(!!new->include == !!oid->include);
+    bt_assert(new->reserved == 0);
+    bt_assert(!u32cmp_bo(&new->ids[0], &oid->ids[0], new->n_subid));
+
+    lp_restore(tmp_linpool, &tmps);
+  }
+
+  rfree(snmp_proto->sock);
+  tmp_flush();
+  return 1;
+}
+
+static inline void
+walk_to_oid_one(pool *pool, const struct oid *oid)
+{
+  struct mib_tree storage, *tree = &storage;
+  mib_tree_init(pool, tree);
+
+  struct mib_walk_state walk;
+  mib_tree_walk_init(&walk, tree);
+
+  const struct oid *inet_pref = oid_create(1, 0, 0, /* ids */ 1);
+  mib_tree_remove(tree, inet_pref);
+
+  (void) mib_tree_add(pool, tree, oid, bt_random_n(2));
+  mib_tree_find(tree, &walk, oid);
+
+  char buf[1024];
+  struct oid *from_walk = (struct oid *) buf;
+
+  int r = mib_tree_walk_to_oid(&walk, from_walk,
+    (1024 - sizeof(struct oid)) / sizeof(u32));
+
+  /* the memory limit should not be breached */
+  bt_assert(r == 0);
+
+  bt_assert(snmp_oid_compare(from_walk, oid) == 0);
+
+  /* cleanup */
+  mib_tree_remove(tree, inet_pref);
+}
+
+/* test MIB tree walk to OID */
+static int
+t_walk_to_oid(void)
+{
+  lp_state tmps;
+  lp_save(tmp_linpool, &tmps);
+
+
+  pool *pool = &root_pool;
+
+  for (int test = 0; test < TESTS_NUM; test++)
+  {
+
+    walk_to_oid_one(pool, random_prefixed_oid());
+    walk_to_oid_one(pool, random_no_prefix_oid());
+    walk_to_oid_one(pool, random_prefixable_oid());
+    /* only a one of above */
+    //walk_to_oid_one(random_oid);
+
+    lp_restore(tmp_linpool, &tmps);
+  }
+
+  tmp_flush();
+
+  return 1;
+}
+
+
+static void
+test_both(void *buffer, uint size, const struct oid *left, const struct oid
+*right, const struct oid *expected)
+{
+  memset(buffer, 0, size);
+  snmp_oid_common_ancestor(left, right, buffer);
+  bt_assert(snmp_oid_compare(buffer, expected) == 0);
+
+  memset(buffer, 0, size);
+  snmp_oid_common_ancestor(right, left, buffer);
+  bt_assert(snmp_oid_compare(buffer, expected) == 0);
+}
+
+#define TEST_BOTH(l, r, e) test_both(buffer, 1024, l, r, e)
+static int
+t_oid_ancestor(void)
+{
+  const struct oid *null = oid_create(0, 0, 0);
+  const struct oid *shorter = oid_create(3, 15, 0, /* ids */ 192, 1, 7);
+  const struct oid *prefixed = oid_create(4, 15, 0, /* ids */ 192, 1, 7, 82);
+  const struct oid *no_prefix = oid_create(9, 0, 0, /* ids */ 1, 3, 6, 1, 15, 192, 1, 7, 82);
+  const struct oid *outside = oid_create(7, 0, 0, /* ids */ 4, 3, 2, 1, 8, 0, 2);
+  const struct oid *prefix_only =  oid_create(0, 15, 0);
+  const struct oid *prefix_only2 = oid_create(0, 9, 0);
+  const struct oid *partial = oid_create(3, 0, 0, /* ids */ 1, 3, 6);
+  const struct oid *no_inet = oid_create(5, 0, 0, /* ids */ 1, 3, 6, 2, 5);
+
+  const struct oid *inet = oid_create(4, 0, 0, /* ids */ 1, 3, 6, 1);
+
+
+  const struct oid *oids[] = {
+    null, shorter, prefixed, no_prefix, outside, prefix_only, partial, no_inet, inet
+  };
+
+  char buffer[1024];
+
+  /* skip null oid */
+  for (size_t o = 1; o < ARRAY_SIZE(oids); o++)
+    TEST_BOTH(null, oids[o], null);
+
+  for (size_t o = 0; o < ARRAY_SIZE(oids); o++)
+    TEST_BOTH(oids[o], oids[o], oids[o]);
+
+  TEST_BOTH(partial, no_prefix, partial);
+  TEST_BOTH(partial, prefixed, partial);
+  TEST_BOTH(partial, prefix_only, partial);
+  TEST_BOTH(partial, prefix_only2, partial);
+
+  TEST_BOTH(prefix_only2, prefixed, inet);
+  TEST_BOTH(prefix_only2, no_prefix, inet);
+
+  TEST_BOTH(prefix_only2, inet, inet);
+
+  TEST_BOTH(prefix_only, prefix_only2, inet);
+
+  TEST_BOTH(prefix_only, prefixed, prefix_only);
+  TEST_BOTH(prefix_only, no_prefix, prefix_only);
+
+  TEST_BOTH(prefix_only, inet, inet);
+
+  /* skip null oid */
+  for (size_t o = 1; o < ARRAY_SIZE(oids); o++)
+  {
+    if (oids[o] == outside) continue;
+
+    TEST_BOTH(outside, oids[o], null);
+  }
+
+  TEST_BOTH(no_inet, partial, partial);
+  TEST_BOTH(no_inet, inet, partial);
+  TEST_BOTH(no_inet, prefix_only, partial);
+  TEST_BOTH(no_inet, prefix_only2, partial);
+  TEST_BOTH(no_inet, prefixed, partial);
+  TEST_BOTH(no_inet, no_prefix, partial);
+
+  TEST_BOTH(shorter, prefixed, shorter);
+  TEST_BOTH(shorter, no_prefix, shorter);
+
+  return 1;
+}
+
+/* really: static int test_snmp_oid_compare(const struct oid **left, const struct oid **right); */
+static int
+test_snmp_oid_compare(const void *left, const void *right)
+{
+  return snmp_oid_compare(
+    *((const struct oid **) left),
+    *((const struct oid **) right)
+  );
+}
+
+static void
+generate_raw_oids(struct oid *oids[], int size, struct oid *(*generator)(void))
+{
+  for (int i = 0; i < size; i++)
+  {
+    /* binary version of ~5% */
+    if (i > 0 && bt_random_n(256) <= 13)
+    {
+      /* at this chance, we create a copy instead of generating new oid */
+      oids[i] = tmp_alloc(snmp_oid_size(oids[i-1]));
+      memcpy(oids[i], oids[i-1], snmp_oid_size(oids[i-1]));
+    }
+    else
+      oids[i] = generator();
+  }
+}
+
+static int
+generate_oids(struct oid *oids[], struct oid *sorted[], int size, struct oid *(*generator)(void))
+{
+  generate_raw_oids(oids, size, generator);
+
+  memcpy(sorted, oids, size * sizeof(struct oid *));
+
+  qsort(sorted, (size_t) size, sizeof(struct oid *),
+      test_snmp_oid_compare);
+
+  // test sizes 0, 1, 2, 10, ...
+  int last_used = 0;
+  for (int index = 0; index < size; index++)
+  {
+    if (snmp_oid_compare(sorted[last_used], sorted[index]) != 0)
+      sorted[++last_used] = sorted[index];
+  }
+
+  /* delete old pointers */
+  for (int i = last_used + 1; i < size; i++)
+    sorted[i] = NULL;
+
+  return (size > 1) ? last_used + 1 : size;
+}
+
+static int
+t_walk_oid_desc(void)
+{
+  lp_state tmps;
+  lp_save(tmp_linpool, &tmps);
+
+  pool *pool = &root_pool;
+
+  struct mib_tree storage, *tree = &storage;
+  mib_tree_init(pool, tree);
+
+  STATIC_ASSERT(ARRAY_SIZE(tree_sizes) > 0);
+  int size = tree_sizes[ARRAY_SIZE(tree_sizes) - 1];
+  ASSERT(size > 0);
+  struct oid **oids = mb_alloc(pool, size * sizeof(struct oid *));
+  struct oid **sorted = mb_alloc(pool, size * sizeof(struct oid *));
+
+  (void) generate_oids(oids, sorted, size, random_oid);
+
+  for (int i = 0; i < size; i++)
+    (void) mib_tree_add(pool, tree, oids[i], 0);
+
+  for (int test = 0; test < size; test++)
+  {
+    int i = bt_random_n(size);
+
+    char buffer[1024];
+    struct oid *oid = (struct oid *) buffer;
+
+    memcpy(oid, oids[i], snmp_oid_size(oids[i]));
+
+    struct mib_walk_state walk;
+    mib_tree_walk_init(&walk, NULL);
+    (void) mib_tree_find(tree, &walk, oid);
+
+    int type = bt_random_n(4);
+    switch (type)
+    {
+      case 0:
+	bt_assert(mib_tree_walk_is_oid_descendant(&walk, oids[i]) == 0);
+	break;
+
+      case 1:
+      {
+	/* oid is longer than walk or has same length */
+	u8 ids = oid->n_subid;
+	u32 upto = MIN(OID_MAX_LEN - ids, 16);
+
+	if (!upto)
+	  continue;
+
+	u32 new = bt_random_n(upto) + 1;
+	oid->n_subid = ids + new;
+
+	for (u32 i = 0; i < new; i++)
+	  oid->ids[ids + i] = bt_random_n(OID_MAX_ID);
+
+	bt_assert(mib_tree_walk_is_oid_descendant(&walk, oid) > 0);
+
+	break;
+      }
+      case 2:
+      case 3:
+      {
+	/* oid is shorter than walk */
+	u8 ids = oid->n_subid;
+
+	if (ids == 0 || ids == OID_MAX_LEN)
+	  continue;
+
+	u32 split = (ids > 1) ? bt_random_n(ids - 1) + 1 : 0;
+	u32 ext = (type == 3) ? bt_random_n(MIN(OID_MAX_LEN - ids, 16)) : 0;
+
+	oid->n_subid = split + ext;
+	for (u32 i = 0; i < ext; i++)
+	  oid->ids[split + i] = bt_random_n(OID_MAX_ID);
+
+	int no_change = 1;
+	for (u32 j = 0; j < MIN(ids - split, ext); j++)
+	{
+	  if (oid->ids[split + j] != oids[i]->ids[split + j])
+	    no_change = 0;
+	}
+
+	if (no_change)
+	  continue;
+
+	bt_assert(mib_tree_walk_is_oid_descendant(&walk, oid) < 0);
+	break;
+      }
+    }
+  }
+
+  {
+    struct mib_walk_state walk;
+    mib_tree_walk_init(&walk, tree);
+
+    u32 zero = 0;
+    const struct oid *null_oid = (struct oid *) &zero;
+    u32 index = bt_random_n(size);
+
+    bt_assert(mib_tree_walk_is_oid_descendant(&walk, null_oid) == 0);
+    if (!snmp_is_oid_empty(oids[index]))
+      bt_assert(mib_tree_walk_is_oid_descendant(&walk, oids[index]) > 0);
+    (void) mib_tree_find(tree, &walk, oids[index]);
+    if (!snmp_is_oid_empty(oids[index]))
+      bt_assert(mib_tree_walk_is_oid_descendant(&walk, null_oid) < 0);
+  }
+
+  u32 null_oid = 0;
+  mib_tree_remove(tree, (struct oid *) &null_oid);
+  lp_restore(tmp_linpool, &tmps);
+
+  return 1;
+}
+
+static int
+t_walk_oid_compare(void)
+{
+  lp_state tmps;
+  lp_save(tmp_linpool, &tmps);
+
+  pool *pool = &root_pool;
+
+  struct mib_tree storage, *tree = &storage;
+  mib_tree_init(pool, tree);
+
+  STATIC_ASSERT(ARRAY_SIZE(tree_sizes) > 0);
+  int size = tree_sizes[ARRAY_SIZE(tree_sizes) - 1];
+  ASSERT(size > 0);
+  struct oid **oids = mb_alloc(pool, size * sizeof(struct oid *));
+  struct oid **sorted = mb_alloc(pool, size * sizeof(struct oid *));
+
+  (void) generate_oids(oids, sorted, size, random_oid);
+
+  for (int i = 0; i < size; i++)
+    (void) mib_tree_add(pool, tree, oids[i], 0);
+
+  for (int test = 0; test < size; test++)
+  {
+    int i = bt_random_n(size);
+
+    char buffer[1024];
+    struct oid *oid = (struct oid *) buffer;
+
+    memcpy(oid, oids[i], snmp_oid_size(oids[i]));
+
+    struct mib_walk_state walk;
+    mib_tree_walk_init(&walk, NULL);
+    (void) mib_tree_find(tree, &walk, oids[i]);
+
+    int type = bt_random_n(4);
+    switch (type)
+    {
+      case 0:
+	bt_assert(mib_tree_walk_oid_compare(&walk, oids[i]) == 0);
+	break;
+
+      case 1:
+      {
+	/* oid is longer than walk or has same length */
+	u8 ids = oid->n_subid;
+	u32 upto = MIN(OID_MAX_LEN - ids, 16);
+
+	if (!upto)
+	  continue;
+
+	u32 new = bt_random_n(upto) + 1;
+	oid->n_subid = ids + new;
+	ASSERT(snmp_oid_size(oid) < 1024);
+
+	for (u32 i = 0; i < new; i++)
+	  oid->ids[ids + i] = bt_random_n(OID_MAX_ID);
+
+
+	bt_assert(mib_tree_walk_oid_compare(&walk, oid) < 0);
+	break;
+      }
+      case 2:
+      case 3:
+      {
+	/* oid is shorter than walk */
+	u8 ids = oid->n_subid;
+
+	if (ids == 0 || ids == OID_MAX_LEN)
+	  continue;
+
+	u32 split = (ids > 1) ? bt_random_n(ids - 1) + 1 : 0;
+	u32 ext = (type == 3) ? bt_random_n(MIN(OID_MAX_LEN - ids, 16)) : 0;
+
+	oid->n_subid = split + ext;
+	for (u32 i = 0; i < ext; i++)
+	  oid->ids[split + i] = bt_random_n(OID_MAX_ID);
+
+	int cmp_res = 0;
+	for (u32 j = 0; j < MIN(ids - split, ext) && !cmp_res; j++)
+	  cmp_res = oids[i]->ids[split + j] - oid->ids[split + j];
+
+	if (!cmp_res && split + ext == ids)
+	  continue;
+
+	if (!cmp_res && split + ext < ids)
+	  cmp_res = +1;
+
+	if (!cmp_res && split + ext > ids)
+	  cmp_res = -1;
+
+	if (cmp_res < 0)
+	  cmp_res = -1;
+	else if (cmp_res > 0)
+	  cmp_res = +1;
+
+	bt_assert(mib_tree_walk_oid_compare(&walk, oid) == cmp_res);
+	break;
+      }
+    }
+  }
+
+  {
+    struct mib_walk_state walk;
+    mib_tree_walk_init(&walk, tree);
+
+    u32 zero = 0;
+    const struct oid *null_oid = (struct oid *) &zero;
+    u32 index = bt_random_n(size);
+
+    bt_assert(mib_tree_walk_oid_compare(&walk, null_oid) == 0);
+    if (!snmp_is_oid_empty(oids[index]))
+      bt_assert(mib_tree_walk_oid_compare(&walk, oids[index]) < 0);
+    else
+      bt_assert(mib_tree_walk_oid_compare(&walk, oids[index]) == 0);
+    (void) mib_tree_find(tree, &walk, oids[index]);
+    if (!snmp_is_oid_empty(oids[index]))
+      bt_assert(mib_tree_walk_oid_compare(&walk, null_oid) > 0);
+  }
+
+  u32 null_oid = 0;
+  mib_tree_remove(tree, (struct oid *) &null_oid);
+  lp_restore(tmp_linpool, &tmps);
+
+  return 1;
+
+}
+
+static void UNUSED
+print_dups(const struct oid *oids[], uint size)
+{
+  for (uint i = 0; i < size; i++)
+    for (uint j = i + 1; j < size; j++)
+      if (snmp_oid_compare(oids[i], oids[j]) == 0)
+	log(L_WARN "pair (%u, %u)", i, j);
+}
+
+static void UNUSED
+print_all(const struct oid *oids[], uint size)
+{
+  for (uint i = 0; i < size; i++)
+    snmp_oid_log(oids[i]);
+}
+
+static inline int
+oid_is_leaf(const struct oid *oid, const struct oid *leafs[], uint leaf_idx)
+{
+  for (uint l = 0; l < leaf_idx; l++)
+    if (snmp_oid_compare(oid, leafs[l]) == 0)
+      return 1;
+
+  return 0;
+}
+
+static int
+all_invalid(const struct oid *oids[], const byte *invalid, uint size, uint index)
+{
+  if (!invalid[index])
+    return 0;
+
+  for (uint i = 0; i < size; i++)
+  {
+    if (i == index) continue;
+
+    if (snmp_oid_compare(oids[i], oids[index]) == 0 &&
+	!invalid[i])
+      return 0;
+  }
+
+  return 1;
+}
+
+static int
+count_error(const struct oid *oids[], const byte *invalid, uint size)
+{
+  int error = 0;
+  for (uint i = 0; i < size; i++)
+  {
+    if (!invalid[i]) continue;
+
+    int skip = 0;
+    for (uint j = 0; j < i; j++)
+    {
+      if (snmp_oid_compare(oids[i], oids[j]) == 0)
+      {
+	skip = 1;
+	break;
+      }
+    }
+
+    if (skip) continue;
+
+    if (all_invalid(oids, invalid, size, i))
+      error++;
+  }
+
+  return error;
+}
+
+static int
+gen_test_add(struct oid *(*generator)(void))
+{
+  lp_state tmps;
+  lp_save(tmp_linpool, &tmps);
+
+  pool *pool = &root_pool;
+
+  for (int test = 0; test < TESTS_NUM; test++)
+  {
+    size_t tsz = ARRAY_SIZE(tree_sizes);
+
+    int size = tree_sizes[test % tsz];
+    int with_leafs = (test % (2 * tsz)) < tsz;
+    int no_inet_prefix = (test % (4 * tsz)) < (2 * tsz);
+
+    struct oid **oids = mb_alloc(pool, size * sizeof(struct oid *));
+    byte *types = mb_alloc(pool, size * sizeof(byte));
+    byte *invalid_hist = mb_alloc(pool, size * sizeof(byte));
+    struct oid **sorted = mb_alloc(pool, size * sizeof(struct oid *));
+    struct oid **leafs = (with_leafs) ? mb_alloc(pool, size * sizeof(struct oid *))
+      : NULL;
+    int leaf_idx = 0;
+    int empty_prefix_added = 0;
+    int distinct = generate_oids(oids, sorted, size, generator);
+
+    struct mib_tree storage, *tree = &storage;
+    mib_tree_init(pool, tree);
+
+    if (no_inet_prefix)
+    {
+      /* remove the node .1 and all children */
+      const struct oid *inet_pref = oid_create(1, 0, 0, /* ids */ 1);
+      mib_tree_remove(tree, inet_pref);
+    }
+
+    int invalid_counter = 0;
+    int counter = 0;
+    int cut = 0;
+    for (int i = 0; i < size; i++)
+    {
+      int invalid = 0;
+      int is_leaf = (with_leafs) ? (int) bt_random_n(2) : 0;
+      types[i] = (byte) is_leaf;
+
+      int will_cut = 0;
+      int oid_nulled = snmp_is_oid_empty(oids[i]);
+
+      if (oid_nulled && is_leaf)
+	invalid = 1;
+
+      if (!no_inet_prefix)
+      {
+	char buffer[1024];
+	struct oid *o = (struct oid *) buffer;
+
+	struct oid *inet = oid_create(4, 0, 0, /* ids */ 1, 3, 6, 1);
+	snmp_oid_common_ancestor(oids[i], inet, o);
+
+	/* If the standard internet prefix is present,
+	 * then the prefix leafs are invalid. */
+	if (snmp_oid_compare(oids[i], o) == 0)
+	  invalid = is_leaf;
+      }
+
+      /* check existence of ancestor node of a new leaf */
+      for (int oi = 0; !invalid && !oid_nulled && oi < i; oi++)
+      {
+	char buffer[1024];
+	struct oid *o = (struct oid *) buffer;
+
+	if (invalid_hist[oi])
+	  continue;
+
+	int other_is_leaf = (int) types[oi];
+
+	if (snmp_oid_compare(oids[oi], oids[i]) == 0 &&
+	    !snmp_is_oid_empty(oids[i]))
+	{
+	  if (other_is_leaf == is_leaf)
+	    will_cut = 1;
+	  else if (other_is_leaf != is_leaf)
+	    invalid = 1;
+
+	  break;
+	}
+
+	snmp_oid_common_ancestor(oids[oi], oids[i], o);
+
+	if ((snmp_oid_compare(oids[i], o) == 0 && is_leaf) ||
+	    (snmp_oid_compare(oids[oi], o) == 0 && other_is_leaf))
+	{
+	  invalid = 1;
+	  break;
+	}
+      }
+
+      if (!invalid && will_cut)
+	cut++;
+
+      if (is_leaf && !invalid)
+	/* leafs could have duplicates */
+	leafs[leaf_idx++] = oids[i];
+
+      mib_node_u *node = mib_tree_add(pool, tree, oids[i], is_leaf);
+
+      bt_assert((node == NULL) == invalid);
+
+      invalid_hist[i] = 0;
+      if (invalid)
+      {
+	invalid_hist[i] = 1;
+	invalid_counter++;
+      }
+
+      if (node != NULL && (!snmp_is_oid_empty(oids[i]) || !empty_prefix_added))
+	counter++;
+
+      if (snmp_is_oid_empty(oids[i]) && !is_leaf)
+	empty_prefix_added = 1;
+    }
+
+    int error = count_error((const struct oid **) oids, invalid_hist, size);
+    bt_assert(counter - cut == distinct - error);
+
+    lp_restore(tmp_linpool, &tmps);
+    mb_free(oids);
+    mb_free(sorted);
+    mb_free(leafs);
+  }
+
+  return 1;
+}
+
+static int
+t_tree_add(void)
+{
+
+  gen_test_add(random_prefixed_oid);
+  gen_test_add(random_no_prefix_oid);
+  gen_test_add(random_prefixable_oid);
+  gen_test_add(random_oid);
+
+  return 1;
+}
+
+static int
+gen_test_find(struct oid *(*generator)(void))
+{
+  lp_state tmps;
+  lp_save(tmp_linpool, &tmps);
+
+  pool *pool = &root_pool;
+
+  for (int test = 0; test < TESTS_NUM; test++)
+  {
+    size_t tsz = ARRAY_SIZE(tree_sizes);
+
+    int size = tree_sizes[test % tsz];
+    int with_leafs = (test % (2 * tsz)) < tsz;
+    int no_inet_prefix = (test % (4 * tsz)) < (2 * tsz);
+
+    struct oid **oids = mb_alloc(pool, size * sizeof(struct oid *));
+    mib_node_u **nodes = mb_alloc(pool, size * sizeof(mib_node_u *));
+    struct oid **searched = mb_alloc(pool, size * sizeof(struct oid *));
+    byte *types = mb_alloc(pool, size * sizeof(byte));
+
+    /* enough to hold snmp_internet copy */
+    uint longest_inet_pref_len = 0;
+    struct oid *longest_inet_pref = oid_create(4, 0, 0, /* ids */ 0, 0, 0, 0);
+
+    generate_raw_oids(oids, size, generator);
+    generate_raw_oids(searched, size, generator);
+
+    struct mib_tree storage, *tree = &storage;
+    mib_tree_init(pool, tree);
+
+    if (no_inet_prefix)
+    {
+      /* remove the node .1 and all children */
+      const struct oid *inet_pref = oid_create(1, 0, 0, /* ids */ 1);
+      mib_tree_remove(tree, inet_pref);
+    }
+
+    for (int i = 0; i < size; i++)
+      types[i] = (byte) ((with_leafs) ? bt_random_n(2) : 0);
+
+    /*
+     * by default initialized MIB tree will have internet prefix have inserted
+     */
+    if (!no_inet_prefix)
+    {
+      memcpy(longest_inet_pref->ids, snmp_internet, sizeof(snmp_internet));
+      longest_inet_pref_len = 4;
+    }
+
+    for (int i = 0; i < size; i++)
+    {
+      nodes[i] = mib_tree_add(pool, tree, oids[i], types[i]);
+
+      if (nodes[i] == NULL) continue;
+
+      if (snmp_oid_is_prefixed(oids[i]))
+      {
+	memcpy(longest_inet_pref->ids, snmp_internet, sizeof(snmp_internet));
+	longest_inet_pref_len = 4;
+      }
+      else
+      {
+	for (uint j = 0; j < MIN(oids[i]->n_subid,
+	    ARRAY_SIZE(snmp_internet)); j++)
+	{
+	  if (oids[i]->ids[j] == snmp_internet[j] &&
+	      j >= longest_inet_pref_len)
+	  {
+	    longest_inet_pref->ids[j] = snmp_internet[j];
+	    longest_inet_pref_len = j + 1;
+	  }
+	  else if (oids[i]->ids[j] == snmp_internet[j])
+	    ;
+	  else
+	    break;
+	}
+      }
+    }
+
+    for (int i = 0; i < size; i++)
+    {
+      for (int j = 0; j < size; j++)
+      {
+	if (nodes[i] != NULL &&
+	    nodes[j] != NULL &&
+	    snmp_oid_compare(oids[i], oids[j]) == 0)
+	  bt_assert(nodes[i] == nodes[j]);
+      }
+    }
+
+    mib_node_u *last = NULL;
+    for (int i = 0; i < size; i++)
+    {
+      /*
+       * This solves cases where we tried to insert
+       * both leaf and inner node for same OID.
+       * Result of insertion should be NULL in cases
+       * when the insertion is inconsistent with the current tree state.
+       * (the first insertion wins)
+       */
+      int expected_precise = 1;
+      mib_node_u *expected = nodes[i];
+
+      if (!no_inet_prefix)
+      {
+	char buf[1024];
+	struct oid *o = (struct oid *) buf;
+	snmp_oid_common_ancestor(oids[i], longest_inet_pref, o);
+	if (snmp_oid_compare(oids[i], o) == 0)
+	  expected_precise = 0;
+      }
+
+      if (snmp_is_oid_empty(oids[i]))
+      {
+	expected_precise = 0;
+      }
+
+      for (int j = 0; expected_precise && j < size; j++)
+      {
+	if (i == j) continue;
+
+	if (snmp_oid_compare(oids[i], oids[j]) == 0 &&
+	    types[i] != types[j] && nodes[i] == NULL)
+	{
+	  if (nodes[j] != NULL)
+	  {
+	    expected = nodes[j];
+	    break;
+	  }
+
+	  /* else expected = NULL; */
+	}
+
+	char buf[1024];
+	struct oid *o = (struct oid *) buf;
+
+	snmp_oid_common_ancestor(oids[i], oids[j], o);
+
+	/* oids[j] lies on path from root to oids[i] */
+	if (snmp_oid_compare(oids[i], o) == 0 &&
+	    nodes[j] != NULL &&
+	    expected == NULL)
+	{
+	  expected_precise = 0;
+	  break;
+	}
+      }
+
+
+      struct mib_walk_state walk;
+      //mib_tree_walk_init(&walk, tree, 0);
+      mib_tree_walk_init(&walk, NULL);
+      mib_node_u *found = mib_tree_find(tree, &walk, oids[i]);
+
+      bt_assert(walk.stack_pos <= MIB_WALK_STACK_SIZE + 1);
+      bt_assert(walk.id_pos <= OID_MAX_LEN);
+
+      if (expected_precise)
+	bt_assert(found == expected);
+      else
+	/* found is an auto-inserted node on path to some dest OID */
+	bt_assert(found != NULL);
+
+      last = found;
+
+      /* test finding with walk state not pointing at the root of the tree */
+      u8 subids = oids[i]->n_subid;
+      if (subids > 0)
+      {
+	found = NULL;
+	u32 new_ids = bt_random_n(subids);
+	mib_tree_walk_init(&walk, (bt_random_n(2)) ? tree : NULL);
+
+	oids[i]->n_subid = new_ids;
+
+	mib_node_u *ignored UNUSED;
+	ignored = mib_tree_find(tree, &walk, oids[i]);
+
+	oids[i]->n_subid = subids;
+
+	found = mib_tree_find(tree, &walk, oids[i]);
+
+	/* see above */
+	if (expected_precise)
+	  bt_assert(found == expected);
+	else
+	{
+	  /* test that the result is same as direct searched from tree root */
+	  bt_assert(found == last);
+	  bt_assert(found != NULL);
+	}
+      }
+    }
+
+    for (int search = 0; search < size; search++)
+    {
+      int has_node = snmp_is_oid_empty(searched[search]);
+
+      for (int stored = 0; stored < size; stored++)
+      {
+	char buf[1024];
+	struct oid *o = (struct oid *) buf;
+	snmp_oid_common_ancestor(oids[stored], searched[search], o);
+
+	/* test if OID oids[stored] is valid and if it forms a path from root
+	 * with OID searched[search] */
+	if (nodes[stored] != NULL && snmp_oid_compare(searched[search], o) == 0)
+	{
+	  has_node = 1;
+	  break;
+	}
+      }
+
+      const struct oid *oid = searched[search];
+      if (!has_node && !snmp_oid_is_prefixed(oid))
+      {
+	for (uint i = 0; i < MIN(ARRAY_SIZE(snmp_internet),
+	    oid->n_subid); i++)
+	{
+	  if (longest_inet_pref->ids[i] != 0 &&
+	      longest_inet_pref->ids[i] == oid->ids[i])
+	    has_node = 1;
+	  else
+	  {
+	    has_node = 0;
+	    break;
+	  }
+	}
+
+	if (has_node && oid->n_subid > ARRAY_SIZE(snmp_internet))
+	  has_node = 0;
+      }
+
+      struct mib_walk_state walk;
+      mib_tree_walk_init(&walk, NULL);
+      mib_node_u *found = mib_tree_find(tree, &walk, searched[search]);
+      bt_assert(has_node == (found != NULL));
+
+      bt_assert(walk.stack_pos <= MIB_WALK_STACK_SIZE + 1);
+      bt_assert(walk.id_pos <= OID_MAX_LEN);
+
+      last = found;
+
+      u8 subids = searched[search]->n_subid;
+      if (subids > 0)
+      {
+	found = NULL;
+	u32 new_ids = bt_random_n(subids);
+	mib_tree_walk_init(&walk, (bt_random_n(2)) ? tree : NULL);
+
+	searched[search]->n_subid = new_ids;
+
+	mib_node_u *ignored UNUSED;
+	ignored = mib_tree_find(tree, &walk, searched[search]);
+
+	searched[search]->n_subid = subids;
+
+	found = mib_tree_find(tree, &walk, searched[search]);
+
+	bt_assert(has_node == (found != NULL));
+
+	bt_assert(walk.stack_pos <= MIB_WALK_STACK_SIZE + 1);
+	bt_assert(walk.id_pos <= OID_MAX_LEN);
+
+	/* test that the result is same as direct search from tree root */
+	bt_assert(last == found);
+      }
+    }
+
+    lp_restore(tmp_linpool, &tmps);
+    mb_free(oids);
+    mb_free(nodes);
+    mb_free(searched);
+    mb_free(types);
+  }
+
+  tmp_flush();
+  return 1;
+}
+
+static int
+t_tree_find(void)
+{
+
+  gen_test_find(random_prefixed_oid);
+  gen_test_find(random_no_prefix_oid);
+  gen_test_find(random_prefixable_oid);
+  gen_test_find(random_oid);
+
+  return 1;
+}
+
+#if 0
+static int
+delete_cleanup(const struct oid *oid, struct oid *oids[], mib_node_u *valid[], int size)
+{
+  uint counter = 0;
+  for (int i = 0; i < size; i++)
+  {
+    char buf[1024];
+    struct oid *o = (struct oid *) buf;
+
+    if (oid == oids[i])
+    {
+      counter++;
+      continue;
+    }
+
+    snmp_oid_common_ancestor(oid, oids[i], o);
+
+    if (snmp_oid_compare(oid, o) == 0)
+    {
+      valid[i] = NULL;
+      counter++;
+    }
+  }
+
+  return counter;
+}
+#endif
+
+static int
+gen_test_delete_remove(struct oid *(*generator)(void), int remove)
+{
+  lp_state tmps;
+  lp_save(tmp_linpool, &tmps);
+
+  pool *pool = &root_pool;
+
+  for (int test = 0; test < TESTS_NUM; test++)
+  {
+    size_t tsz = ARRAY_SIZE(tree_sizes);
+
+    int size = tree_sizes[test % tsz];
+    int with_leafs = (test % (2 * tsz)) < tsz;
+    int no_inet_prefix = (test % (4 * tsz)) < (2 * tsz);
+
+    struct oid **oids = mb_alloc(pool, size * sizeof(struct oid *));
+    struct oid **sorted = mb_alloc(pool, size * sizeof(struct oid *));
+    mib_node_u **nodes = mb_alloc(pool, size * sizeof(mib_node_u *));
+    byte *types = mb_alloc(pool, size * sizeof(byte));
+
+    struct mib_tree storage, *tree = &storage;
+    mib_tree_init(pool, tree);
+
+    if (no_inet_prefix)
+    {
+      /* remove the node .1 and all children */
+      const struct oid *inet_pref = oid_create(1, 0, 0, /* ids */ 1);
+      mib_tree_remove(tree, inet_pref);
+    }
+
+    int distinct = generate_oids(oids, sorted, size, generator);
+
+    for (int i = 0; i < size; i++)
+    {
+      int is_leaf;
+      is_leaf = types[i] = (byte) (with_leafs) ? bt_random_n(2) : 0;
+      (void) mib_tree_add(pool, tree, oids[i], is_leaf);
+    }
+
+    for (int d = 0; d < distinct; d++)
+    {
+      struct mib_walk_state walk;
+      mib_tree_walk_init(&walk, NULL);
+      //mib_tree_walk_init(&walk, tree); TODO
+      nodes[d] = mib_tree_find(tree, &walk, sorted[d]);
+    }
+
+    /* we need to populate the nodes array after all insertions because
+     * some insertion may fail (== NULL) because we try to insert a leaf */
+#if 0
+    for (int i = 0; i < size; i++)
+    {
+      struct mib_walk_state walk;
+      mib_tree_walk_init(&walk, tree, 0);
+      nodes[i] = mib_tree_find(tree, &walk, oids[i]);
+    }
+#endif
+
+    int deleted, invalid_counter;
+    /* test deletion one of the inserted OIDs */
+    for (int round = 0; round < (size + 3) / 4 + remove; round++)
+    {
+      /* note: we do not run any rounds for size zero because bt_random_n(0)
+       * does not exist */
+      int i;
+      struct oid *oid;
+      if (!remove)
+      {
+	/* this way we are also testing remove non-existent tree nodes */
+	i = bt_random_n(size); /* not bt_random_n(distinct) */
+	oid = oids[i];
+      }
+      else
+      {
+	i = -1; /* break fast  */
+	oid = generator();
+      }
+
+      struct mib_walk_state walk;
+      mib_tree_walk_init(&walk, NULL);
+      // mib_tree_walk_init(&walk, tree); TODO
+      mib_node_u *node = mib_tree_find(tree, &walk, oid);
+
+      if (node == NULL)
+	continue;
+
+      if (!remove)
+	deleted = mib_tree_delete(tree, &walk);
+      else
+	deleted = mib_tree_remove(tree, oid);
+
+      bt_assert(deleted > 0 || snmp_is_oid_empty(oid));
+
+      invalid_counter = 0;
+      int counted_removed = 0;
+      for (int j = 0; j < distinct; j++)
+      {
+	//mib_tree_walk_init(&walk, tree, 0);
+	mib_tree_walk_init(&walk, NULL);
+	mib_node_u *node = mib_tree_find(tree, &walk, sorted[j]);
+
+	if (snmp_is_oid_empty(oid))
+	  ;
+	/* the oid could have multiple instances in the oids dataset */
+	else if (snmp_oid_compare(oid, sorted[j]) == 0 && !counted_removed)
+	{
+	  invalid_counter++;
+	  counted_removed = 1;
+	  bt_assert(node == NULL);
+	  nodes[j] = NULL;
+	}
+	else if (node != nodes[j])
+	{
+	  invalid_counter++;
+	  bt_assert(node == NULL);
+	  nodes[j] = NULL;
+	}
+      }
+
+      /* we do not count the internal node that are included in the deleted */
+      bt_assert(deleted >= invalid_counter);
+    }
+
+    lp_restore(tmp_linpool, &tmps);
+    mb_free(oids);
+    mb_free(sorted);
+    mb_free(nodes);
+  }
+
+  tmp_flush();
+
+  return 1;
+}
+
+static int
+t_tree_delete(void)
+{
+
+  gen_test_delete_remove(random_prefixed_oid, 0);
+  gen_test_delete_remove(random_no_prefix_oid, 0);
+  gen_test_delete_remove(random_prefixable_oid, 0);
+  gen_test_delete_remove(random_oid, 0);
+
+  return 1;
+}
+
+static int
+t_tree_remove(void)
+{
+
+  gen_test_delete_remove(random_prefixed_oid, 1);
+  gen_test_delete_remove(random_no_prefix_oid, 1);
+  gen_test_delete_remove(random_prefixable_oid, 1);
+  gen_test_delete_remove(random_oid, 1);
+
+  return 1;
+}
+
+static void
+gen_test_traverse(struct oid *(*generator)(void))
+{
+  lp_state tmps;
+  lp_save(tmp_linpool, &tmps);
+
+  pool *pool = &root_pool;
+
+  for (int test = 0; test < TESTS_NUM; test++)
+  {
+    size_t tsz = ARRAY_SIZE(tree_sizes);
+
+    int size = tree_sizes[test % tsz];
+    int with_leafs = (test % (2 * tsz)) < tsz;
+    int no_inet_prefix = (test % (4 * tsz)) < (2 * tsz);
+
+    struct oid **oids = mb_alloc(pool, size * sizeof(struct oid *));
+    struct oid **sorted = mb_alloc(pool, size * sizeof(struct oid *));
+    mib_node_u **nodes = mb_allocz(pool, size * sizeof(mib_node_u *));
+
+    const int distinct = generate_oids(oids, sorted, size, generator);
+
+    struct mib_tree storage, *tree = &storage;
+    mib_tree_init(pool, tree);
+
+    if (no_inet_prefix)
+    {
+      /* remove the node .1 and all children */
+      const struct oid *inet_pref = oid_create(1, 0, 0, /* ids */ 1);
+      mib_tree_remove(tree, inet_pref);
+    }
+
+    for (int o = 0; o < size; o++)
+    {
+      int is_leaf = (with_leafs) ? (int) bt_random_n(2) : 0;
+      (void) mib_tree_add(pool, tree, oids[o], is_leaf);
+    }
+
+    for (int d = 0; d < distinct; d++)
+    {
+      struct mib_walk_state walk;
+      mib_tree_walk_init(&walk, NULL);
+      nodes[d] = mib_tree_find(tree, &walk, sorted[d]);
+    }
+
+    int bound = 0;
+
+    for (int d = 0; d < distinct; d++)
+    {
+      if (snmp_oid_is_prefixed(sorted[d]))
+	bound += 5;
+      bound += (int) sorted[d]->n_subid;
+    }
+
+    if (!no_inet_prefix)
+      bound += (ARRAY_SIZE(snmp_internet) + 1);
+
+    struct mib_walk_state walk;
+    mib_tree_walk_init(&walk, tree);
+
+    char buf[1024], buf2[1024];
+    struct oid *oid = (struct oid *) buf;
+    struct oid *last = (struct oid *) buf2;
+    memset(oid, 0, sizeof(struct oid));	  /* create a null OID */
+    memset(last, 0, sizeof(struct oid));
+
+    int oid_index = 0;
+    if (size > 0  && snmp_is_oid_empty(sorted[oid_index]))
+      oid_index++;
+
+    mib_node_u *current;
+    int i = 0;
+    while ((current = mib_tree_walk_next(tree, &walk)) != NULL && i++ < bound)
+    {
+      memcpy(last, oid, snmp_oid_size(oid));
+      mib_tree_walk_to_oid(&walk, oid,
+	  (1024 - sizeof(struct oid) / sizeof(u32)));
+
+      bt_assert(snmp_oid_compare(last, oid) < 0);
+
+      while (oid_index < distinct && nodes[oid_index] == NULL)
+	oid_index++;
+
+      if (oid_index < distinct && snmp_oid_compare(sorted[oid_index], oid) == 0)
+	oid_index++;
+    }
+
+    bt_assert(current == NULL);
+    while (oid_index < distinct && nodes[oid_index] == NULL)
+      oid_index++;
+
+    /* the bound check is only for that the loop is finite */
+    bt_assert(i <= bound + 2);
+
+    current = mib_tree_walk_next(tree, &walk);
+    bt_assert(current == NULL);
+    bt_assert(oid_index == distinct);
+
+    mb_free(oids);
+    mb_free(sorted);
+    mb_free(nodes);
+
+    lp_restore(tmp_linpool, &tmps);
+  }
+
+  tmp_flush();
+}
+
+static int
+t_tree_traversal(void)
+{
+  gen_test_traverse(random_prefixed_oid);
+  gen_test_traverse(random_no_prefix_oid);
+  gen_test_traverse(random_prefixable_oid);
+  gen_test_traverse(random_oid);
+
+  return 1;
+}
+
+static void
+gen_test_leafs(struct oid *(*generator)(void))
+{
+  lp_state tmps;
+  lp_save(tmp_linpool, &tmps);
+
+  pool *pool = &root_pool;
+
+  for (int test = 0; test < TESTS_NUM; test++)
+  {
+    size_t tsz = ARRAY_SIZE(tree_sizes);
+
+    int size = tree_sizes[test % tsz];
+    int with_leafs = (test % (2 * tsz)) < tsz;
+    int no_inet_prefix = (test % (4 * tsz)) < (2 * tsz);
+
+    struct oid **oids = mb_alloc(pool, size * sizeof(struct oid *));
+    struct oid **sorted = mb_alloc(pool, size * sizeof(struct oid *));
+    mib_node_u **nodes = mb_allocz(pool, size * sizeof(mib_node_u *));
+
+    const int distinct = generate_oids(oids, sorted, size, generator);
+
+    struct mib_tree storage, *tree = &storage;
+    mib_tree_init(pool, tree);
+
+    if (no_inet_prefix)
+    {
+      /* remove the node .1 and all children */
+      const struct oid *inet_pref = oid_create(1, 0, 0, /* ids */ 1);
+      mib_tree_remove(tree, inet_pref);
+    }
+
+    for (int o = 0; o < size; o++)
+    {
+      int is_leaf = (with_leafs) ? (int) bt_random_n(2) : 0;
+      (void) mib_tree_add(pool, tree, oids[o], is_leaf);
+    }
+
+    int leafs = 0;
+    for (int d = 0; d < distinct; d++)
+    {
+      struct mib_walk_state walk;
+      mib_tree_walk_init(&walk, NULL);
+      nodes[d] = mib_tree_find(tree, &walk, sorted[d]);
+
+      /* count only leafs that was successfully inserted without duplicits */
+      if (nodes[d] != NULL && mib_node_is_leaf(nodes[d]))
+	leafs++;
+    }
+
+    struct mib_walk_state walk;
+    mib_tree_walk_init(&walk, tree);
+    if (!with_leafs)
+    {
+      struct mib_leaf *leaf = mib_tree_walk_next_leaf(tree, &walk, 0);
+      bt_assert(leaf == NULL);
+
+      continue;
+    }
+
+    char buf[1024], buf2[1024];
+    struct oid *oid = (struct oid *) buf;
+    struct oid *last = (struct oid *) buf2;
+    memset(oid, 0, sizeof(struct oid));	  /* create a null OID */
+    memset(last, 0, sizeof(struct oid));
+
+    int oid_index = 0;
+
+    struct mib_leaf *current;
+    int i = 0;	/* iteration counter ~ leafs found */
+    while ((current = mib_tree_walk_next_leaf(tree, &walk, 0)) != NULL && i++ < leafs)
+    {
+      memcpy(last, oid, snmp_oid_size(oid));
+      mib_tree_walk_to_oid(&walk, oid,
+	  (1024 - sizeof(struct oid) / sizeof(u32)));
+
+      bt_assert(snmp_oid_compare(last, oid) < 0);
+      bt_assert(mib_node_is_leaf(((mib_node_u *)current)));
+
+      while (oid_index < distinct &&
+	  (nodes[oid_index] == NULL || !mib_node_is_leaf(nodes[oid_index])))
+	oid_index++;
+
+      if (oid_index < distinct && snmp_oid_compare(sorted[oid_index], oid) == 0)
+	oid_index++;
+    }
+
+    bt_assert(current == NULL);
+    while (oid_index < distinct &&
+	(nodes[oid_index] == NULL || !mib_node_is_leaf(nodes[oid_index])))
+      oid_index++;
+
+    current = mib_tree_walk_next_leaf(tree, &walk, 0);
+    bt_assert(current == NULL);
+    bt_assert(oid_index == distinct);
+    bt_assert(i == leafs);
+
+    mb_free(oids);
+    mb_free(sorted);
+    mb_free(nodes);
+
+    lp_restore(tmp_linpool, &tmps);
+  }
+
+  tmp_flush();
+}
+
+static int
+t_tree_leafs(void)
+{
+
+  gen_test_leafs(random_prefixed_oid);
+  gen_test_leafs(random_no_prefix_oid);
+  gen_test_leafs(random_prefixable_oid);
+  gen_test_leafs(random_oid);
+
+  return 1;
+}
+
+#if 0
+static int
+t_tree_all(void)
+{
+  /* random sequences of insertion/deletion/searches and walks */
+  return 0; /* failed */
+}
+#endif
+
+
+int main(int argc, char **argv)
+{
+  bt_init(argc, argv);
+  bt_bird_init();
+
+  bt_test_suite(t_oid_empty, "Function that determines if the OID is empty");
+  bt_test_suite(t_oid_compare, "Function defining lexicographical order on OIDs");
+  bt_test_suite(t_varbind_name_to_tx, "Function loading OID from RX buffer with prefixation");
+  bt_test_suite(t_oid_ancestor, "Function finding common ancestor of two OIDs");
+  bt_test_suite(t_walk_to_oid, "Function transforming MIB tree walk state to OID");
+  bt_test_suite(t_walk_oid_desc, "Function testing relation being subtree between MIB tree walk and OID");
+  bt_test_suite(t_walk_oid_compare, "Function comparing MIB tree walk and OID");
+
+  bt_test_suite(t_tree_find, "MIB tree search");
+  bt_test_suite(t_tree_traversal, "MIB tree traversal");
+  bt_test_suite(t_tree_leafs, "MIB tree leafs traversal");
+  bt_test_suite(t_tree_add, "MIB tree insertion");
+  bt_test_suite(t_tree_delete, "MIB tree deletion");
+  bt_test_suite(t_tree_remove, "MIB tree removal");
+  //bt_test_suite(t_tree_all, "MIB tree random find, add, delete mix");
+
+  return bt_exit_value();
+}
diff --git a/proto/snmp/snmp_utils.c b/proto/snmp/snmp_utils.c
new file mode 100644
index 00000000..0a795daf
--- /dev/null
+++ b/proto/snmp/snmp_utils.c
@@ -0,0 +1,972 @@
+/*
+ *	BIRD -- Simple Network Management Protocol (SNMP) helper functions
+ *
+ *      (c) 2022 Vojtech Vilimek <vojtech.vilimek@nic.cz>
+ *      (c) 2022 CZ.NIC z.s.p.o
+ *
+ *	Can be freely distributed and used under the terms of the GNU GPL.
+ *
+ */
+
+#include "snmp_utils.h"
+#include <stdio.h>
+
+inline void
+snmp_pdu_context(struct snmp_pdu *pdu, struct snmp_proto *p, sock *sk)
+{
+  pdu->p = p;
+  pdu->error = AGENTX_RES_NO_ERROR;
+  pdu->buffer = sk->tpos;
+  pdu->size = sk->tbuf + sk->tbsize - sk->tpos;
+  pdu->index = 0;
+  pdu->sr_vb_start = NULL;
+  pdu->sr_o_end = NULL;
+}
+
+/*
+ * snmp_session - store packet ids from protocol to header
+ * @p: source SNMP protocol instance
+ * @h: dest PDU header
+ */
+inline void
+snmp_session(const struct snmp_proto *p, struct agentx_header *h)
+{
+  STORE_U32(h->session_id, p->session_id);
+  STORE_U32(h->transaction_id, p->transaction_id);
+  STORE_U32(h->packet_id, p->packet_id);
+}
+
+inline void *
+snmp_varbind_data(const struct agentx_varbind *vb)
+{
+  uint name_size = snmp_oid_size(&vb->name);
+  return (void *) &vb->name + name_size;
+}
+
+/*
+ * snmp_is_oid_empty - check if oid is null-valued
+ * @oid: object identifier to check
+ *
+ * Test if the oid header is full of zeroes. For NULL-pointer @oid returns 0.
+ * We ignore include field to prevent weird behaviour.
+ */
+inline int
+snmp_is_oid_empty(const struct oid *oid)
+{
+  /* We intentionaly ignore padding that should be zeroed */
+  if (oid != NULL)
+    return oid->n_subid == 0 && oid->prefix == 0;
+  else
+    return 0;
+}
+
+/*
+ * snmp_oid_is_prefixable - check for prefixed form conversion possibility
+ * @oid: Object Identifier in packet byte order to check
+ *
+ * Check if it is possible to convert @oid to prefixed form. The condition of
+ * that is standart .1.3.6.1 internet prefix and 5-th id that fits in one byte.
+ */
+inline int
+snmp_pkt_oid_is_prefixable(const struct oid *oid)
+{
+  if (LOAD_U8(oid->n_subid) < 5)
+    return 0;
+
+  for (int i = 0; i < 4; i++)
+    if (LOAD_U32(oid->ids[i]) != snmp_internet[i])
+      return 0;
+
+  if (LOAD_U32(oid->ids[4]) >= 256)
+    return 0;
+
+  return 1;
+}
+
+/*
+ * snmp_oid_copy - copy OID from one place to another
+ * @dest: destination to use
+ * @src: OID to be copied from
+ */
+void
+snmp_oid_copy(struct oid *dest, const struct oid *src)
+{
+  dest->n_subid = src->n_subid;
+  dest->prefix = src->prefix;
+  dest->include = src->include ? 1 : 0;
+  dest->reserved = 0;
+
+  memcpy(dest->ids, src->ids, src->n_subid * sizeof(u32));
+}
+
+/*
+ * snmp_oid_from_buf - copy OID from RX buffer to dest in native byte order
+ * @dst: destination to use (native byte order)
+ * @src: OID to be copied from (packet byte order)
+ */
+void
+snmp_oid_from_buf(struct oid *dst, const struct oid *src)
+{
+  dst->n_subid = LOAD_U8(src->n_subid);
+  dst->prefix = LOAD_U8(src->prefix);
+  dst->include = LOAD_U8(src->include) ? 1 : 0;
+  dst->reserved = 0;
+
+  for (uint i = 0; i < dst->n_subid; i++)
+    dst->ids[i] = LOAD_U32(src->ids[i]);
+}
+
+/*
+ * snmp_oid_to_buf - copy OID to TX buffer with packet byte order
+ * @dst: destination to use (packet byte order)
+ * @src: OID to be copied from (native byte order)
+ */
+void
+snmp_oid_to_buf(struct oid *dst, const struct oid *src)
+{
+  STORE_U8(dst->n_subid, src->n_subid);
+  STORE_U8(dst->prefix, src->prefix);
+  STORE_U8(dst->include, (src->include) ? 1 : 0);
+  STORE_U8(dst->reserved, 0);
+
+  for (uint i = 0; i < src->n_subid; i++)
+    STORE_U32(dst->ids[i], src->ids[i]);
+}
+
+/*
+ * snmp_str_size_from_len - return in-buffer octet string size
+ * @len: length of C-string, returned from strlen()
+ */
+inline size_t
+snmp_str_size_from_len(uint len)
+{
+  return 4 + BIRD_ALIGN(len, 4);
+}
+
+/*
+ * snmp_str_size - return in packet size of supplied string
+ * @str: measured string
+ *
+ * Returned value is string length aligned to 4 byte with 32bit length
+ * annotation included.
+ */
+inline size_t
+snmp_str_size(const char *str)
+{
+  return snmp_str_size_from_len(strlen(str));
+}
+
+/*
+ * snmp_oid_size - measure size of OID in bytes
+ * @o: object identifier to use
+ *
+ * Work for both packet and cpu native byte orders.
+ */
+uint
+snmp_oid_size(const struct oid *o)
+{
+  /* LOAD_U8() is in both cases basic mem read */
+  return 4 + (LOAD_U8(o->n_subid) * 4);
+}
+
+/*
+ * snmp_oid_size_from_len - return size of OID with @n_subid subids in bytes
+ * @n_subid: number of subids in ids array
+ */
+inline size_t
+snmp_oid_size_from_len(uint n_subid)
+{
+  return sizeof(struct oid) + n_subid * sizeof(u32);
+}
+
+static inline uint
+snmp_get_octet_size(const struct agentx_octet_str *str)
+{
+  return str->length;
+}
+
+/*
+ * snmp_varbind_header_size - measure size of VarBind without data in bytes
+ * @vb_name: VarBind OID name
+ *
+ * Return size including whole OID as well as the VarBind header.
+ */
+uint
+snmp_varbind_header_size(const struct oid *vb_name)
+{
+  ASSUME(vb_name);
+  return snmp_oid_size(vb_name) + OFFSETOF(struct agentx_varbind, name);
+}
+
+uint
+snmp_varbind_size_unsafe(const struct agentx_varbind *vb)
+{
+  ASSUME(snmp_test_varbind_type(vb->type));
+  int value_size = agentx_type_size(vb->type);
+  uint vb_header = snmp_varbind_header_size(&vb->name);
+
+  if (value_size == 0)
+    return vb_header;
+
+  if (value_size > 0)
+    return vb_header + value_size;
+
+  switch (vb->type)
+  {
+    case AGENTX_OBJECT_ID:;
+      struct oid *oid = snmp_varbind_data(vb);
+      return vb_header + snmp_oid_size(oid);
+
+    case AGENTX_OCTET_STRING:
+    case AGENTX_IP_ADDRESS:
+    case AGENTX_OPAQUE:;
+      struct agentx_octet_str *string = snmp_varbind_data(vb);
+      return vb_header + snmp_get_octet_size(string);
+
+    default:
+      /* Shouldn't happen */
+      die("getting size of VarBind with unknown type (%u)", vb->type);
+      return 0;
+  }
+}
+
+/*
+ * snmp_varbind_size_from_len - get size in-buffer VarBind for known OID and data
+ * @n_subid: number of subidentifiers of the VarBind's OID name
+ * @type: type of VarBind
+ * @len: length of variably long data
+ *
+ * For types with fixed size the @len is not used. For types such as Octet
+ * String, or OID the @len is used directly.
+ *
+ * Return number of bytes used by VarBind in specified form.
+ */
+inline size_t
+snmp_varbind_size_from_len(uint n_subid, enum agentx_type type, uint len)
+{
+  size_t sz = snmp_oid_size_from_len(n_subid)
+    + sizeof(struct agentx_varbind) - sizeof(struct oid);
+
+  int data_sz = agentx_type_size(type);
+  if (data_sz < 0)
+    sz += len;
+  else
+    sz += data_sz;
+
+  return sz;
+}
+
+/*
+ * snmp_test_varbind - test validity of VarBind type
+ * @type: Type of VarBind in cpu native byte order
+ */
+int
+snmp_test_varbind_type(u16 type)
+{
+  if (type == AGENTX_INTEGER  ||
+      type == AGENTX_OCTET_STRING  ||
+      type == AGENTX_NULL  ||
+      type == AGENTX_OBJECT_ID  ||
+      type == AGENTX_IP_ADDRESS  ||
+      type == AGENTX_COUNTER_32  ||
+      type == AGENTX_GAUGE_32  ||
+      type == AGENTX_TIME_TICKS  ||
+      type == AGENTX_OPAQUE  ||
+      type == AGENTX_COUNTER_64  ||
+      type == AGENTX_NO_SUCH_OBJECT  ||
+      type == AGENTX_NO_SUCH_INSTANCE  ||
+      type == AGENTX_END_OF_MIB_VIEW)
+    return 1;
+  else
+    return 0;
+}
+
+
+/*
+ * snmp_valid_ip4_index - check IPv4 address validity in oid
+ * @o: object identifier holding ip address
+ * @start: index of first address id
+ */
+int
+snmp_valid_ip4_index(const struct oid *o, uint start)
+{
+  if (start + 3 < o->n_subid)
+    return snmp_valid_ip4_index_unsafe(o, start);
+  else
+    return 0;
+}
+
+/*
+ * snmp_valid_ip4_index_unsafe - check validity of IPv4 address in oid
+ * @o: object identifier holding ip address
+ * @start: index of first address id
+ *
+ * This function is unsafe - no checks of object identifier ids
+ * length sufficiency is done.
+ */
+int
+snmp_valid_ip4_index_unsafe(const struct oid *o, uint start)
+{
+  for (int i = 0; i < 4; i++)
+    if (o->ids[start + i] >= 256)
+      return 0;
+
+  return 1;
+}
+
+/*
+ * snmp_put_nstr - copy c-string into buffer with limit
+ * @buf: destination buffer
+ * @str: string to use
+ * @len: number of characters to use from string
+ */
+byte *
+snmp_put_nstr(byte *buf, const char *str, uint len)
+{
+  uint alen = BIRD_ALIGN(len, 4);
+
+  struct agentx_octet_str *octet = (void *) buf;
+  STORE_U32(octet->length, len);
+  memcpy(&octet->data, str, len);
+  buf += len + sizeof(octet->length);
+
+  /* Insert zero padding in the gap at the end */
+  for (uint i = 0; i < alen - len; i++)
+    buf[i] = '\0';
+
+  return buf + (alen - len);
+}
+
+/*
+ * snmp_put_str - put string into SNMP PDU transcieve buffer
+ * @buf: pointer to first unoccupied buffer byte
+ * @str: string to place
+ *
+ * Handles all conditions specified by RFC, namely string length annotation
+ * and padding 4 byte alignment with zeroes. Return NULL if string is too large
+ * for SNMP message.
+ */
+byte *
+snmp_put_str(byte *buf, const char *str)
+{
+  uint len = strlen(str);
+  return snmp_put_nstr(buf, str, len);
+}
+
+byte *
+snmp_put_ip4(byte *buf, ip4_addr addr)
+{
+  /* octet string has size 4 bytes */
+  STATIC_ASSERT(sizeof(ip4_addr) == sizeof(u32));
+  STORE_PTR(buf, sizeof(ip4_addr));
+
+  /* Always use Network byte order */
+  put_u32(buf+4, ip4_to_u32(addr));
+
+  return buf + 8;
+}
+
+byte *
+snmp_put_blank(byte *buf)
+{
+  STORE_PTR(buf, 0);
+  return buf + 4;
+}
+
+/*
+ * snmp_put_fbyte - put one padded byte to SNMP PDU transcieve buffer
+ * @buf: pointer to free buffer byte
+ * @data: byte to use
+ *
+ * Put @data into buffer @buf with 3B zeroed padding.
+ */
+byte *
+snmp_put_fbyte(byte *buf, u8 data)
+{
+  STORE_U8(*buf++, data);
+  memset(buf, 0, 3); /* we fill the 24bit padding with zeros */
+  return buf + 3;
+}
+
+/**
+ * snmp_oid_compare - find the lexicographical order relation between @left and @right
+ * @left: left object id relation operand
+ * @right: right object id relation operand
+ *
+ * both @left and @right has to be non-blank.
+ * function returns 0 if left == right,
+ *   -1 if left < right,
+ *   and 1 otherwise
+ */
+int
+snmp_oid_compare(const struct oid *left, const struct oid *right)
+{
+  const u8 left_subids = left->n_subid;
+  u8 right_subids = right->n_subid; /* see hack for more info */
+
+  const u8 left_prefix = left->prefix;
+  const u8 right_prefix = right->prefix;
+
+  if (left_prefix == 0 && right_prefix == 0)
+    goto test_ids;
+
+  if (right_prefix == 0)
+    return (-1) * snmp_oid_compare(right, left);
+
+  if (left_prefix == 0)
+  {
+    uint bound = MIN((uint) left_subids, (uint) ARRAY_SIZE(snmp_internet));
+    for (uint idx = 0; idx < bound; idx++)
+    {
+      u32 id = left->ids[idx];
+      if (id < snmp_internet[idx])
+	return -1;
+      else if (id > snmp_internet[idx])
+	return 1;
+    }
+
+    if (left_subids <= ARRAY_SIZE(snmp_internet))
+      return -1;
+
+    /* check prefix */
+    if (left->ids[4] < (u32) right_prefix)
+      return -1;
+    else if (left->ids[4] > (u32) right_prefix)
+      return 1;
+
+    /* the right prefix is already checked (+1) */
+    int limit = MIN(left_subids - (int) (ARRAY_SIZE(snmp_internet) + 1),
+      (int) right_subids);
+    for (int i = 0; i < limit; i++)
+    {
+      u32 left_id = left->ids[i + ARRAY_SIZE(snmp_internet) + 1];
+      u32 right_id = right->ids[i];
+      if (left_id < right_id)
+	return -1;
+      else if (left_id > right_id)
+	return 1;
+    }
+
+    /* hack: we known at this point that right has >= 5 subids
+     *   (implicit in snmp_internet and oid->prefix), so
+     *   we simplify to common case by altering left_subids */
+    right_subids += 5;
+    goto all_same;
+  }
+
+  if (left_prefix < right_prefix)
+    return -1;
+  else if (left_prefix > right_prefix)
+    return 1;
+
+test_ids:
+  for (int i = 0; i < MIN(left->n_subid, right->n_subid); i++)
+  {
+    u32 left_id = left->ids[i];
+    u32 right_id = right->ids[i];
+    if (left_id < right_id)
+      return -1;
+    else if (left_id > right_id)
+      return 1;
+  }
+
+all_same:
+  /* shorter sequence is before longer in lexicografical order  */
+  if (left_subids < right_subids)
+    return -1;
+  else if (left_subids > right_subids)
+    return 1;
+  else
+    return 0;
+}
+
+struct snmp_registration *
+snmp_registration_create(struct snmp_proto *p, enum agentx_mibs mib)
+{
+  struct snmp_registration *r;
+  r = mb_alloc(p->p.pool, sizeof(struct snmp_registration));
+
+  r->n.prev = r->n.next = NULL;
+
+  r->session_id = p->session_id;
+  r->transaction_id = p->transaction_id;
+  /* will be incremented by snmp_session() macro during packet assembly */
+  r->packet_id = p->packet_id + 1;
+  r->mib = mib;
+
+  add_tail(&p->registration_queue, &r->n);
+
+  return r;
+}
+
+int
+snmp_registration_match(struct snmp_registration *r, struct agentx_header *h)
+{
+  return (LOAD_U32(r->session_id) == h->session_id) &&
+    (LOAD_U32(r->transaction_id) == h->transaction_id) &&
+    (LOAD_U32(r->packet_id) == h->packet_id);
+}
+
+
+/*
+ * agentx_type_size - get in packet VarBind type size
+ * @type: VarBind type
+ *
+ * Returns length of agentx_type @type in bytes, Variable length types result in
+ * -1.
+ */
+int
+agentx_type_size(enum agentx_type type)
+{
+  /*
+   * AGENTX_NULL, AGENTX_NO_SUCH_OBJECT, AGENTX_NO_SUCH_INSTANCE,
+   * AGENTX_END_OF_MIB_VIEW
+   */
+  if (type >= AGENTX_NO_SUCH_OBJECT || type == AGENTX_NULL)
+    return 0;
+
+  /* AGENTX_INTEGER, AGENTX_COUNTER_32, AGENTX_GAUGE_32, AGENTX_TIME_TICKS */
+  if (type >= AGENTX_COUNTER_32 && type <= AGENTX_TIME_TICKS ||
+      type == AGENTX_INTEGER)
+    return 4;
+
+  if (type == AGENTX_COUNTER_64)
+    return 8;
+
+  if (AGENTX_IP_ADDRESS)
+    return snmp_str_size_from_len(4);
+
+  /* AGENTX_OBJECT_ID, AGENTX_OCTET_STRING, AGENTX_OPAQUE */
+  else
+    return -1;
+}
+
+static inline void
+snmp_varbind_type32(struct agentx_varbind *vb, struct snmp_pdu *c, enum agentx_type type, u32 val)
+{
+  ASSUME(agentx_type_size(type) == 4); /* type as 4B representation */
+
+  vb->type = type;
+  u32 *data = snmp_varbind_data(vb);
+  STORE_PTR(data, val);
+  data++;
+  c->buffer = (byte *) data;
+}
+
+inline void
+snmp_varbind_int(struct snmp_pdu *c, u32 val)
+{
+  snmp_varbind_type32(c->sr_vb_start, c, AGENTX_INTEGER, val);
+}
+
+inline void
+snmp_varbind_counter32(struct snmp_pdu *c, u32 val)
+{
+  snmp_varbind_type32(c->sr_vb_start, c, AGENTX_COUNTER_32, val);
+}
+
+inline void
+snmp_varbind_ticks(struct snmp_pdu *c, u32 val)
+{
+  snmp_varbind_type32(c->sr_vb_start, c, AGENTX_TIME_TICKS, val);
+}
+
+inline void
+snmp_varbind_gauge32(struct snmp_pdu *c, s64 time)
+{
+  snmp_varbind_type32(c->sr_vb_start, c,
+    AGENTX_GAUGE_32, MAX(0, MIN(time, UINT32_MAX)));
+}
+
+inline void
+snmp_varbind_ip4(struct snmp_pdu *c, ip4_addr addr)
+{
+  c->sr_vb_start->type = AGENTX_IP_ADDRESS;
+  c->buffer = snmp_put_ip4(snmp_varbind_data(c->sr_vb_start), addr);
+}
+
+/*
+ * snmp_varbind_nstr - fill varbind context with octet string
+ * @vb: VarBind to use
+ * @c: PDU information
+ * @str: C-string to put as the VarBind data
+ * @len: length of the string @str
+ *
+ * Beware: this function assumes there is enough space in the underlaying
+ * TX buffer. The caller has to provide that, see snmp_str_size_from_len() for
+ * more info.
+ */
+void
+snmp_varbind_nstr(struct snmp_pdu *c, const char *str, uint len)
+{
+  c->sr_vb_start->type = AGENTX_OCTET_STRING;
+  c->buffer = snmp_put_nstr(snmp_varbind_data(c->sr_vb_start), str, len);
+}
+
+/*
+ * snmp_varbind_oid - fill VarBind data with OID @oid_val
+ * @oid_val - Object Identifier in cpu native byte order
+ *
+ * Function puts the @oid_val to the packet byte order.
+ */
+void
+snmp_varbind_oid(struct snmp_pdu *c, const struct oid *oid_val)
+{
+  c->sr_vb_start->type = AGENTX_OBJECT_ID;
+  snmp_oid_to_buf(snmp_varbind_data(c->sr_vb_start), oid_val);
+}
+
+inline enum agentx_type
+snmp_search_res_to_type(enum snmp_search_res r)
+{
+  ASSUME(r != SNMP_SEARCH_OK);
+  enum agentx_type type_arr[] = {
+    [SNMP_SEARCH_NO_OBJECT]   = AGENTX_NO_SUCH_OBJECT,
+    [SNMP_SEARCH_NO_INSTANCE] = AGENTX_NO_SUCH_INSTANCE,
+    [SNMP_SEARCH_END_OF_VIEW] = AGENTX_END_OF_MIB_VIEW,
+  };
+
+  return type_arr[r];
+}
+
+inline int
+snmp_test_close_reason(byte value)
+{
+  if (value >= (byte) AGENTX_CLOSE_OTHER &&
+      value <= (byte) AGENTX_CLOSE_BY_MANAGER)
+    return 1;
+  else
+    return 0;
+}
+
+
+/*
+ *  Debugging
+ */
+
+void UNUSED
+snmp_oid_dump(const struct oid *oid)
+{
+  log(L_WARN "OID DUMP ========");
+
+  if (oid == NULL)
+  {
+    log(L_WARN "is eqaul to NULL");
+    log(L_WARN "OID DUMP END ====");
+    log(L_WARN ".");
+    return;
+  }
+
+  else if (snmp_is_oid_empty(oid))
+  {
+    log(L_WARN "is empty");
+    log(L_WARN "OID DUMP END ====");
+    log(L_WARN ".");
+    return;
+  }
+
+  log(L_WARN "  #ids: %4u  prefix %3u  include: %5s",
+    oid->n_subid, oid->prefix, (oid->include)? "true" : "false");
+  log(L_WARN "IDS -------------");
+
+  for (int i = 0; i < oid->n_subid; i++)
+    log(L_WARN "  %2u:  %11u  ~ 0x%08X", i, oid->ids[i], oid->ids[i]);
+
+  log(L_WARN "OID DUMP END ====");
+  log(L_WARN);
+}
+
+void UNUSED
+snmp_oid_log(const struct oid *oid)
+{
+  char buf[1024] = { };
+  char *pos = buf;
+
+  if (snmp_oid_is_prefixed(oid))
+  {
+    for (uint i = 0; i < ARRAY_SIZE(snmp_internet); i++)
+      pos += snprintf(pos, buf + 1024 - pos, ".%u", snmp_internet[i]);
+
+    pos += snprintf(pos, buf + 1024 - pos, ".%u", oid->prefix);
+  }
+
+  for (int id = 0; id < oid->n_subid; id++)
+    pos += snprintf(pos, buf + 1024 - pos, ".%u", oid->ids[id]);
+
+  log(L_WARN, "%s", buf);
+}
+
+
+/*
+ * snmp_oid_common_ancestor - find a common ancestor
+ * @left: first OID
+ * @right: second OID
+ * @out: buffer for result
+ *
+ * The @out must be large enough to always fit the resulting OID, a safe value
+ * is minimum between number of left subids and right subids. The result might
+ * be NULL OID in cases where there is no common subid. The result could be also
+ * viewed as longest common prefix. Note that if both @left and @right are
+ * prefixable but not prefixed the result in @out will also not be prefixed.
+ *
+ * This function is used intensively by |snmp_test.c|.
+ */
+void
+snmp_oid_common_ancestor(const struct oid *left, const struct oid *right, struct oid *out)
+{
+  ASSERT(left && right && out);
+
+  out->include = 0;
+  out->reserved = 0;
+  out->prefix = 0;
+
+  u32 offset = 0;
+  u8 left_ids = left->n_subid, right_ids = right->n_subid;
+
+  int l = snmp_oid_is_prefixed(left), r = snmp_oid_is_prefixed(right);
+  if (l && r)
+  {
+    if (left->prefix != right->prefix)
+    {
+      out->n_subid = 4;
+
+      for (uint id = 0; id < ARRAY_SIZE(snmp_internet); id++)
+	out->ids[id] = snmp_internet[id];
+
+      return;
+    }
+
+    out->prefix = left->prefix;
+  }
+  else if (!l && r)
+  {
+    if (left_ids == 0)
+    {
+      /* finish creating NULL OID */
+      out->n_subid = 0;
+      return;
+    }
+
+    for (uint id = 0; id < MIN(ARRAY_SIZE(snmp_internet), left_ids); id++)
+    {
+      if (left->ids[id] != snmp_internet[id])
+      {
+	out->n_subid = id;
+	return;
+      }
+
+      out->ids[id] = snmp_internet[id];
+    }
+
+    if (left_ids <= ARRAY_SIZE(snmp_internet))
+    {
+      out->n_subid = left_ids;
+      return;
+    }
+
+    /* index 4 is conresponding to the prefix in prefixed OID */
+    if (left->ids[4] != (u32) right->prefix)
+    {
+      out->n_subid = ARRAY_SIZE(snmp_internet);
+      return;
+    }
+
+    /* delete snmp_internet from out->ids and store OID prefix */
+    offset = ARRAY_SIZE(snmp_internet) + 1;
+    out->n_subid = out->n_subid - ARRAY_SIZE(snmp_internet);
+    out->prefix = right->prefix;
+  }
+  else if (l && !r)
+  {
+    snmp_oid_common_ancestor(right, left, out);
+    return;
+  }
+
+  ASSERT(offset <= left_ids);
+
+  u8 subids = 0;
+  for (u32 id = 0; id < MIN(left_ids - offset, right_ids); id++)
+  {
+    if (left->ids[offset + id] == right->ids[id])
+    {
+      subids++;
+      out->ids[id] = right->ids[id];
+    }
+    else
+      break;
+  }
+  out->n_subid = subids;
+}
+
+/*
+ * SNMP MIB tree walking
+ */
+
+/**
+ * snmp_walk_init - Try to find exactly matching OID packat VarBind in MIB tree
+ * @tree: MIB tree to use
+ * @walk: MIB tree walk state storage
+ * @c: AgentX PDU creation context
+ *
+ * Populate the @walk state and try to find MIB tree leaf equivalent to
+ * c->sr_vb_start which is requested VarBind to fill based on it's OID name.
+ * Return value is either pointer to valid MIB tree leaf or NULL if no leaf
+ * matched.
+ */
+struct mib_leaf *
+snmp_walk_init(struct mib_tree *tree, struct mib_walk_state *walk, struct snmp_pdu *c)
+{
+  mib_tree_walk_init(walk, tree);
+
+  mib_node_u *node = mib_tree_find(tree, walk, &c->sr_vb_start->name);
+
+  // TODO hide me in mib_tree code
+  /* mib_tree_find() returns NULL if the oid is longer than existing any path */
+  if (node == NULL && walk->stack_pos > 0)
+    node = walk->stack[walk->stack_pos - 1];
+
+  return (!node || !mib_node_is_leaf(node)) ? NULL : &node->leaf;
+}
+
+/**
+ * snmp_walk_next - wrapper around MIB tree mib_walk_next() for single call
+ * @tree: MIB tree to use
+ * @walk: MIB tree walk state storage
+ * @c: AgentX PDU creation context
+ *
+ * The snmp_walk_next() function searches MIB tree with updates of the VarBind
+ * OID name with.
+ */
+struct mib_leaf *
+snmp_walk_next(struct mib_tree *tree, struct mib_walk_state *walk, struct snmp_pdu *c)
+{
+  ASSUME(tree && walk);
+
+  if (!walk->stack_pos)
+    return NULL;
+
+  mib_node_u *node = walk->stack[walk->stack_pos - 1];
+
+  int found = 0;
+  struct mib_leaf *leaf = &node->leaf;
+
+  if (mib_node_is_leaf(node) && leaf->call_next)
+  {
+    const struct oid *oid = &c->sr_vb_start->name;
+    if (mib_tree_walk_oid_compare(walk, oid) > 0)
+    {
+      int old = snmp_oid_size(&c->sr_vb_start->name);
+      if (mib_tree_walk_to_oid(walk,
+	  &c->sr_vb_start->name, 20 * sizeof(u32)))
+	return NULL;
+
+      int new = snmp_oid_size(&c->sr_vb_start->name);
+      c->buffer += (new - old);
+    }
+
+    found = !leaf->call_next(walk, c);
+  }
+  else if (mib_node_is_leaf(node) && c->sr_vb_start->name.include)
+  {
+    found = 1;
+    c->sr_vb_start->name.include = 0;
+  }
+
+  const struct oid *oid = &c->sr_vb_start->name;
+  u32 skip = (walk->id_pos < oid->n_subid) ?
+    oid->ids[walk->id_pos] : 0;
+  while (!found && (leaf = mib_tree_walk_next_leaf(tree, walk, skip)) != NULL)
+  {
+    /* mib_tree_walk_next() forces VarBind's name OID overwriting */
+    int old = snmp_oid_size(&c->sr_vb_start->name);
+    // TODO autogrow
+    if (mib_tree_walk_to_oid(walk, &c->sr_vb_start->name, 20 * sizeof(u32)))
+      return NULL;
+
+    int new = snmp_oid_size(&c->sr_vb_start->name);
+    c->buffer += (new - old);
+
+    if (leaf->call_next && !leaf->call_next(walk, c))
+      found = 1;
+    else if (!leaf->call_next)
+      found = 1;
+
+    oid = &c->sr_vb_start->name;
+    skip = (walk->id_pos < oid->n_subid) ?
+      oid->ids[walk->id_pos] : 0;
+  }
+
+  if (!found)
+    return NULL;
+
+  return leaf;
+}
+
+/**
+ * snmp_walk_fill - fill current VarBind by filler hook invocation
+ * @leaf: MIB tree leaf with filler hook
+ * @walk: MIB tree walk state
+ * @c: AgentX PDU creation context
+ *
+ * The function takes responsibility for VarBind type setting (for known VB
+ * types) and for buffer space allocated for VarBind data (based on type or
+ * configured size). This simplifies code of filler hooks in most cases.
+ * We also allow the @leaf to be NULL, in which case we set the VarBind to
+ * error type noSuchObject.
+ */
+enum snmp_search_res
+snmp_walk_fill(struct mib_leaf *leaf, struct mib_walk_state *walk, struct snmp_pdu *c)
+{
+  struct agentx_varbind *vb = c->sr_vb_start;
+
+  enum snmp_search_res res;
+  /* The OID c->sr_vb_start->name is either left untouched for agentx-Get-PDU,
+   * or updated by snmp_walk_next() for agentx-GetNext-PDU and agentx-GetBulk-PDU
+   *
+   * The null OID in c->sr_o_end means no limits. The OID c->sr_o_end is always
+   * null for agentx-Get-PDU and therefore evaluates to 0.
+   */
+  if (!snmp_check_search_limit(&c->sr_vb_start->name, c->sr_o_end))
+  {
+    res = SNMP_SEARCH_END_OF_VIEW;
+    vb->type = snmp_search_res_to_type(res);
+    return res;
+  }
+
+  if (!leaf)
+    return SNMP_SEARCH_NO_OBJECT;
+
+  uint size = 0;
+  enum agentx_type type = AGENTX_NULL;
+  if (leaf->size >= 0)
+  {
+    if (leaf->type == AGENTX_OCTET_STRING || leaf->type == AGENTX_OPAQUE ||
+	  leaf->type == AGENTX_OBJECT_ID)
+    {
+      type = leaf->type;
+      size = leaf->size;
+    }
+    else if (leaf->type != AGENTX_INVALID)
+    {
+      type = leaf->type;
+      size = agentx_type_size(leaf->type);
+    }
+    else
+      size = leaf->size;
+  }
+
+  (void) snmp_tbuf_reserve(c, size);
+  vb->type = (u16) type;
+
+  res = leaf->filler(walk, c);
+
+  vb = c->sr_vb_start;
+
+  if (res != SNMP_SEARCH_OK)
+    vb->type = snmp_search_res_to_type(res);
+
+  ASSUME(vb->type == leaf->type || vb->type == AGENTX_END_OF_MIB_VIEW ||
+    vb->type == AGENTX_NO_SUCH_OBJECT || vb->type == AGENTX_NO_SUCH_INSTANCE);
+
+  return res;
+}
diff --git a/proto/snmp/snmp_utils.h b/proto/snmp/snmp_utils.h
new file mode 100644
index 00000000..870b338c
--- /dev/null
+++ b/proto/snmp/snmp_utils.h
@@ -0,0 +1,127 @@
+#ifndef _BIRD_SNMP_UTILS_H_
+#define _BIRD_SNMP_UTILS_H_
+
+#include "subagent.h"
+#include "mib_tree.h"
+
+/*
+ *
+ *    AgentX Variable Biding (VarBind) utils
+ *
+ */
+
+/*
+ *  AgentX - Variable Binding (VarBind) type utils
+ */
+int agentx_type_size(enum agentx_type t);
+
+/* type Octet String */
+size_t snmp_str_size_from_len(uint len);
+size_t snmp_str_size(const char *str);
+
+/* type OID - Object Identifier */
+int snmp_is_oid_empty(const struct oid *oid);
+int snmp_pkt_oid_is_prefixable(const struct oid *oid);
+uint snmp_oid_size(const struct oid *o);
+size_t snmp_oid_size_from_len(uint n_subid);
+void snmp_oid_copy(struct oid *dest, const struct oid *src);
+int snmp_oid_compare(const struct oid *first, const struct oid *second);
+void snmp_oid_common_ancestor(const struct oid *left, const struct oid *right, struct oid *result);
+void snmp_oid_from_buf(struct oid *dest, const struct oid *src);
+void snmp_oid_to_buf(struct oid *dest, const struct oid *src);
+
+static inline int
+snmp_check_search_limit(const struct oid *search, const struct oid *limit)
+{
+  ASSERT(search && limit);
+  return snmp_is_oid_empty(limit) || snmp_oid_compare(search, limit) < 0;
+}
+
+/*
+ * snmp_oid_is_prefixed - test if OID is prefixed
+ * @oid: OID to use
+ *
+ * Works for both cpu native and packet byte order.
+ */
+static inline int
+snmp_oid_is_prefixed(const struct oid *oid)
+{
+  /* LOAD_U8() is in both cases basic mem load */
+  return LOAD_U8(oid->prefix) != 0;
+}
+
+/* type IPv4 */
+int snmp_valid_ip4_index(const struct oid *o, uint start);
+int snmp_valid_ip4_index_unsafe(const struct oid *o, uint start);
+
+/*
+ *  AgentX - Variable Binding (VarBind) manupulation
+ */
+uint snmp_varbind_header_size(const struct oid *vb_name);
+uint snmp_varbind_size_unsafe(const struct agentx_varbind *vb);
+size_t snmp_varbind_size_from_len(uint n_subid, enum agentx_type t, uint len);
+int snmp_test_varbind_type(u16 type);
+void *snmp_varbind_data(const struct agentx_varbind *vb);
+
+/*
+ *  AgentX - PDU headers, types, contexts
+ */
+void snmp_session(const struct snmp_proto *p, struct agentx_header *h);
+void snmp_pdu_context(struct snmp_pdu *pdu, struct snmp_proto *p, sock *sk);
+
+static inline int
+snmp_has_context(const struct agentx_header *h)
+{
+  return LOAD_U8(h->flags) & AGENTX_NON_DEFAULT_CONTEXT;
+}
+
+int snmp_test_close_reason(byte value);
+
+/*
+ *  AgentX - TX buffer manipulation
+ */
+
+/* Functions filling buffer a typed value */
+void snmp_varbind_int(struct snmp_pdu *c, u32 val);
+void snmp_varbind_counter32(struct snmp_pdu *c, u32 val);
+void snmp_varbind_gauge32(struct snmp_pdu *c, s64 time);
+void snmp_varbind_ticks(struct snmp_pdu *c, u32 val);
+void snmp_varbind_ip4(struct snmp_pdu *c, ip4_addr addr);
+void snmp_varbind_nstr(struct snmp_pdu *c, const char *str, uint len);
+void snmp_varbind_oid(struct snmp_pdu *c, const struct oid *oid_val);
+
+/* Raw */
+byte *snmp_no_such_object(byte *buf, struct agentx_varbind *vb, struct oid *oid);
+byte *snmp_no_such_instance(byte *buf, struct agentx_varbind *vb, struct oid *oid);
+byte *snmp_put_str(byte *buf, const char *str);
+byte *snmp_put_nstr(byte *buf, const char *str, uint len);
+byte *snmp_put_blank(byte *buf);
+byte *snmp_put_ip4(byte *buf, ip4_addr ip4);
+byte *snmp_put_fbyte(byte *buf, u8 data);
+
+
+/*
+ *
+ *    Helpers, Misc, Debugging
+ *
+ */
+struct snmp_registration *snmp_registration_create(struct snmp_proto *p, enum agentx_mibs mib);
+int snmp_registration_match(struct snmp_registration *r, struct agentx_header *h);
+
+void snmp_oid_dump(const struct oid *oid);
+void snmp_oid_log(const struct oid *oid);
+
+enum agentx_type snmp_search_res_to_type(enum snmp_search_res res);
+
+#define AGENTX_TYPE_INT_SIZE ((uint) agentx_type_size(AGENTX_INTEGER))
+#define AGENTX_TYPE_IP4_SIZE ((uint) agentx_type_size(AGENTX_IP_ADDRESS))
+#define AGENTX_TYPE_COUNTER32_SIZE ((uint) agentx_type_size(AGENTX_COUNTER_32))
+
+/*
+ * SNMP MIB tree walking
+ */
+struct mib_leaf *snmp_walk_init(struct mib_tree *tree, struct mib_walk_state *state, struct snmp_pdu *context);
+struct mib_leaf *snmp_walk_next(struct mib_tree *tree, struct mib_walk_state *state, struct snmp_pdu *context);
+enum snmp_search_res snmp_walk_fill(struct mib_leaf *leaf, struct mib_walk_state *state, struct snmp_pdu *context);
+
+#endif
diff --git a/proto/snmp/subagent.c b/proto/snmp/subagent.c
new file mode 100644
index 00000000..55f075c2
--- /dev/null
+++ b/proto/snmp/subagent.c
@@ -0,0 +1,1426 @@
+/*
+ *	BIRD -- Simple Network Management Protocol (SNMP)
+ *
+ *      (c) 2022 Vojtech Vilimek <vojtech.vilimek@nic.cz>
+ *      (c) 2022 CZ.NIC z.s.p.o
+ *
+ *	Can be freely distributed and used under the terms of the GNU GPL.
+ *
+ */
+
+#include "subagent.h"
+#include "mib_tree.h"
+#include "snmp_utils.h"
+#include "bgp4_mib.h"
+
+#include "lib/unaligned.h"
+
+/*
+ * Handling of malformed packet:
+ *
+ * When we find an error in PDU data, we create and send a response with error
+ * defined by the RFC. We await until the packet is send and then we close the
+ * communication socket ignoring any possible response. This implicitly closes
+ * the established session. We chose this approach because we cannot easily
+ * mark the boundary between packets.
+ *
+ *
+ * Partial parsing:
+ *
+ * It may happen that we received only staring part of some PDU from the
+ * communication socket. In most cases, if we recognize this situation, we
+ *
+ */
+
+void snmp_register_ack(struct snmp_proto *p, struct agentx_response *res);
+
+/* standard SNMP internet prefix (.1.3.6.1) */
+const u32 snmp_internet[] = { SNMP_ISO, SNMP_ORG, SNMP_DOD, SNMP_INTERNET };
+
+/*
+ * update_packet_size - set PDU size
+ * @start: pointer to PDU data start (excluding header size)
+ * @end: pointer after the last PDU byte
+ *
+ * Return number of bytes in TX buffer (including header size).
+ */
+static inline uint
+update_packet_size(struct agentx_header *start, byte *end)
+{
+  /* pkt_len */
+  uint s = (end - (byte *) start) - AGENTX_HEADER_SIZE;
+  STORE_U32(start->payload, s);
+  return AGENTX_HEADER_SIZE + s;
+}
+
+/*
+ * response_err_ind - update response error and index
+ * @p: SNMP protocol instance
+ * @res: response PDU header
+ * @err: error status
+ * @ind: index of error, ignored for noAgentXError
+ *
+ * Update agentx-Response-PDU header fields res.error and it's res.index. If the
+ * error is not noError, also set the corrent response PDU payload size.
+ */
+static inline void
+response_err_ind(struct snmp_proto *p, struct agentx_response *res, enum agentx_response_errs err, u16 ind)
+{
+  STORE_U16(res->error, (u16) err);
+  if (err != AGENTX_RES_NO_ERROR && err != AGENTX_RES_GEN_ERROR)
+  {
+    if (p->verbose)
+      TRACE(D_PACKETS, "SNMP last PDU resulted in error %u", err);
+    STORE_U16(res->index, ind);
+    /* Reset VarBindList to null */
+    STORE_U32(res->h.payload,
+      sizeof(struct agentx_response) - AGENTX_HEADER_SIZE);
+  }
+  else if (err == AGENTX_RES_GEN_ERROR)
+  {
+    if (p->verbose)
+      TRACE(D_PACKETS, "SNMP last PDU resulted in error genErr");
+    STORE_U16(res->index, 0);
+    /* Reset VarBindList to null */
+    STORE_U32(res->h.payload,
+      sizeof(struct agentx_response) - AGENTX_HEADER_SIZE);
+  }
+  else
+    STORE_U16(res->index, 0);
+}
+
+/*
+ * snmp_varbind_leave - transform VarBind to packet byte order
+ * @vb: prepared VarBind in cpu native byte order
+ */
+void
+snmp_varbind_leave(struct agentx_varbind *vb)
+{
+  STORE_U16(vb->type, vb->type);
+
+  /* Does nothing */
+  STORE_U16(vb->reserved, 0);
+  struct oid *oid = &vb->name;
+  STORE_U8(oid->n_subid, oid->n_subid);
+  STORE_U8(oid->prefix, oid->prefix);
+  STORE_U8(oid->include, oid->include);
+  STORE_U8(oid->reserved, 0);
+
+  for (u8 i = 0; i < oid->n_subid; i++)
+    STORE_U32(oid->ids[i], oid->ids[i]);
+}
+
+/*
+ * snmp_tbuf_reserve - conditionally grow the TX buffer
+ * @c: transmit PDU context
+ * @size: size to make available
+ *
+ * Return non-zero if the buffer was relocated.
+ */
+int
+snmp_tbuf_reserve(struct snmp_pdu *c, size_t size)
+{
+  if (size >= c->size)
+  {
+    struct snmp_proto *p = c->p;
+    sock *sk = p->sock;
+
+    int start_diff;
+    if (c->sr_vb_start != NULL)
+      start_diff = (char *) c->sr_vb_start - (char *) sk->tbuf;
+
+    sk_set_tbsize(sk, sk->tbsize + 2048);
+    c->size += 2048;
+
+    if (c->sr_vb_start != NULL)
+      c->sr_vb_start = (struct agentx_varbind *) (sk->tbuf + start_diff);
+
+    return 1;
+  }
+
+  return 0;
+}
+
+/*
+ * refresh_ids - Copy current ids from packet to protocol
+ * @p: SNMP protocol instance
+ * @h: PDU header with new transaction_id and packet_id ids.
+ */
+static inline void
+refresh_ids(struct snmp_proto *p, struct agentx_header *h)
+{
+  p->transaction_id = LOAD_U32(h->transaction_id);
+  p->packet_id = LOAD_U32(h->packet_id);
+}
+
+/*
+ * snmp_header - store packet header into buffer
+ * @h: pointer to created packet header in TX buffer
+ * @type: created PDU type
+ * @flags: set flags
+ *
+ * Payload length is set to zero legth. Padding is also zeroed. Real stored
+ * flags depend on compile-time message byte order configuration.
+ */
+static inline void
+snmp_header(struct agentx_header *h, enum agentx_pdu_types type, u8 flags)
+{
+  STORE_U8(h->version, AGENTX_VERSION);
+  STORE_U8(h->type, type);
+  STORE_U8(h->flags, flags | SNMP_BYTE_ORDER);
+  STORE_U8(h->reserved, 0);
+  STORE_U32(h->payload, 0);
+}
+
+/*
+ * snmp_blank_header - create header with no flags except byte order
+ * @h: pointer to created header in TX buffer
+ * @type: create PDU type
+ *
+ * Only flag possibly set may be packet byte order configuration.
+ */
+static inline void
+snmp_blank_header(struct agentx_header *h, enum agentx_pdu_types type)
+{
+  snmp_header(h, type, (u8) 0);
+}
+
+/*
+ * prepare_response - fill buffer with AgentX PDU header
+ * @p: SNMP protocol instance
+ * @c: transmit PDU context to use
+ *
+ * Prepare known parts of AgentX packet header into the TX buffer held by @c.
+ */
+static struct agentx_response *
+prepare_response(struct snmp_proto *p, struct snmp_pdu *c)
+{
+  struct agentx_response *r = (void *) c->buffer;
+  struct agentx_header *h = &r->h;
+
+  snmp_blank_header(h, AGENTX_RESPONSE_PDU);
+  snmp_session(p, h);
+
+  /* protocol doesn't care about subagent upTime */
+  STORE_U32(r->uptime, 0);
+  STORE_U16(r->error, AGENTX_RES_NO_ERROR);
+  STORE_U16(r->index, 0);
+
+  ADVANCE(c->buffer, c->size, sizeof(struct agentx_response));
+  return r;
+}
+
+/*
+ * snmp_oid_prefixize_unsafe - normalize OID to prefixed form
+ * @dest: destination for normalized OID in native byte order
+ * @src: source OID in packet byte order
+ *
+ * Note that again, snmp_oid_prefixize_unsafe is intended to copy Object
+ * Identifier from RX buffer to TX buffer but also optionally swap the byte
+ * order from packet b.o. to cpu native b.o. This is done to simplify the code
+ * dealing with OIDs.
+ */
+static inline void
+snmp_oid_prefixize_unsafe(struct oid *dest, const struct oid *src)
+{
+  dest->n_subid = LOAD_U8(src->n_subid) - 5;
+  dest->prefix = (u8) LOAD_U32(src->ids[ARRAY_SIZE(snmp_internet)]);
+  dest->include = (LOAD_U8(src->include)) ? 1 : 0;
+  dest->reserved = 0;
+
+  /* The LOAD_U32() and STORE_U32() cancel out */
+  for (u8 i = 0; i < dest->n_subid; i++)
+    dest->ids[i] = LOAD_U32(src->ids[i + 5]);
+}
+
+/*
+ * snmp_vb_name_to_tx - create VarBind in TX buffer from RX buffer OID
+ * @c: PDU context
+ * @oid: Object Identifier located in RX buffer with packet byte order
+ *
+ * Create a NULL initialized VarBind inside TX buffer (from @c) whose name
+ * is @oid. Because we want to simplify code dealing with OIDs, the byte order
+ * of the name is optionally swapped to match cpu native byte order.
+ */
+struct agentx_varbind *
+snmp_vb_name_to_tx(struct snmp_pdu *c, const struct oid *oid)
+{
+  uint vb_hdr_size = snmp_varbind_header_size(oid);
+  (void) snmp_tbuf_reserve(c, vb_hdr_size);
+
+  ASSERT(c->size >= vb_hdr_size);
+  struct agentx_varbind *vb = (struct agentx_varbind *) c->buffer;
+  ADVANCE(c->buffer, c->size, sizeof(struct agentx_varbind) - sizeof(struct oid));
+  /* Move the c->buffer so that is points at &vb->name */
+  vb->type = AGENTX_NULL;
+
+  if (snmp_pkt_oid_is_prefixable(oid) && !snmp_oid_is_prefixed(oid))
+  {
+    u8 subids = LOAD_U8(oid->n_subid) - 5;
+    ADVANCE(c->buffer, c->size, snmp_oid_size_from_len(subids));
+    snmp_oid_prefixize_unsafe(&vb->name, oid);
+
+    return vb;
+  }
+
+  ADVANCE(c->buffer, c->size, snmp_oid_size(oid));
+  snmp_oid_from_buf(&vb->name, oid);
+
+  return vb;
+}
+
+// TODO XXX docstring
+int
+snmp_load_oids(byte **pkt_ptr, uint *pkt_sz, struct snmp_pdu *c)
+{
+  byte *pkt = *pkt_ptr;
+  uint pkt_size = *pkt_sz;
+
+  uint sz;
+  /* in packet byte order */
+  const struct oid *start_buf = (const struct oid *) pkt;
+  if ((sz = snmp_oid_size(start_buf)) > pkt_size ||
+      LOAD_U8(start_buf->n_subid) >= OID_MAX_LEN)
+  {
+    c->error = AGENTX_RES_PARSE_ERROR;
+    *pkt_ptr = pkt;
+    *pkt_sz = pkt_size;
+    return 0;
+  }
+
+  ADVANCE(pkt, pkt_size, sz);
+
+  /* in packet byte order */
+  const struct oid *end_buf = (const struct oid *) pkt;
+  if ((sz = snmp_oid_size(end_buf)) > pkt_size ||
+      LOAD_U8(end_buf->n_subid) >= OID_MAX_LEN)
+  {
+    c->error = AGENTX_RES_PARSE_ERROR;
+    *pkt_ptr = pkt;
+    *pkt_sz = pkt_size;
+    return 0;
+  }
+
+  /* in cpu native byte order */
+  struct agentx_varbind *start_vb = snmp_vb_name_to_tx(c, start_buf);
+
+  /* in cpu native byte order */
+  struct oid *end_oid = tmp_alloc(sz);
+  snmp_oid_from_buf(end_oid, end_buf);
+
+  ADVANCE(pkt, pkt_size, sz);
+
+  if (!snmp_is_oid_empty(end_oid) &&
+      snmp_oid_compare(&start_vb->name, end_oid) > 0)
+  {
+    c->error = AGENTX_RES_GEN_ERROR;
+    *pkt_ptr = pkt;
+    *pkt_sz = pkt_size;
+    return 0;
+  }
+
+  ASSERT(start_vb != NULL);
+  ASSERT(end_oid != NULL);
+
+  c->sr_vb_start = start_vb;
+  c->sr_o_end = end_oid;
+  *pkt_ptr = pkt;
+  *pkt_sz = pkt_size;
+  return 1; /* ok */
+}
+
+/*
+ * close_pdu - send an agentx-Close-PDU
+ * @p: SNMP protocol instance
+ * @reason: reason for closure
+ */
+static void
+close_pdu(struct snmp_proto *p, enum agentx_close_reasons reason)
+{
+  sock *sk = p->sock;
+  struct snmp_pdu c;
+  snmp_pdu_context(&c, p, sk);
+
+  TRACE(D_PACKETS, "SNMP sending agentx-Close-PDU with reason %u", reason);
+
+#define REASON_SIZE sizeof(u32)
+  (void) snmp_tbuf_reserve(&c, AGENTX_HEADER_SIZE + REASON_SIZE);
+
+  struct agentx_header *h = (void *) c.buffer;
+  ADVANCE(c.buffer, c.size, AGENTX_HEADER_SIZE);
+  snmp_blank_header(h, AGENTX_CLOSE_PDU);
+  p->packet_id++;
+  snmp_session(p, h);
+
+  (void) snmp_put_fbyte(c.buffer, (u8) reason);
+  ADVANCE(c.buffer, c.size, REASON_SIZE);
+
+  uint s = update_packet_size(h, c.buffer);
+  sk_send(sk, s);
+#undef REASON_SIZE
+}
+
+/*
+ * ping_pdu - send an agentx-Ping-PDU
+ * @p: SNMP protocol instance
+ */
+void
+snmp_ping(struct snmp_proto *p)
+{
+  /* ping_pdu */
+  if (!snmp_is_active(p))
+    return;
+
+  sock *sk = p->sock;
+  struct snmp_pdu c;
+  snmp_pdu_context(&c, p, sk);
+
+  if (c.size < AGENTX_HEADER_SIZE)
+    return;
+
+  int unused = sk->tbuf + sk->tbsize - c.buffer;
+  if (unused < AGENTX_HEADER_SIZE)
+    return;
+
+  struct agentx_header *h = (void *) c.buffer;
+  ADVANCE(c.buffer, c.size, AGENTX_HEADER_SIZE);
+  snmp_blank_header(h, AGENTX_PING_PDU);
+  p->packet_id++;
+  snmp_session(p, h);
+  if (p->verbose)
+    TRACE(D_PACKETS, "SNMP sending agentx-Ping-PDU");
+  p->ignore_ping_id = p->packet_id;
+
+  /* sending only header */
+  uint s = update_packet_size(h, (byte *) h + AGENTX_HEADER_SIZE);
+
+  if (p->packet_id)
+    p->pings++;
+  sk_send(sk, s);
+}
+
+/*
+ * snmp_simple_response - send an agentx-Response-PDU with no data payload
+ * @p: SNMP protocol instance
+ * @error: response PDU error fields value
+ * @index: response PDU error index field value
+ *
+ * This function assumes that the buffer has enough space to fill
+ * in the agentx-Response-PDU.
+ */
+static void
+snmp_simple_response(struct snmp_proto *p, enum agentx_response_errs error, u16 index)
+{
+  sock *sk = p->sock;
+  struct snmp_pdu c;
+  snmp_pdu_context(&c, p, sk);
+
+  ASSUME(c.size >= sizeof(struct agentx_response));
+
+  struct agentx_response *res = prepare_response(p, &c);
+  response_err_ind(p, res, error, index);
+  sk_send(sk, sizeof(struct agentx_response));
+}
+
+/*
+ * send_notify_pdu - send an agentx-Notify-PDU
+ * @p: SNMP protocol instance
+ * @oid: PDU notification Varbind name (OID)
+ * @data: PDU VarBind payload in packet byte order
+ * @size: PDU VarBind payload size
+ * @include_up_time: flag enabling inclusion of sysUpTime.0 OID
+ */
+void
+snmp_notify_pdu(struct snmp_proto *p, struct oid *oid, void *data, uint size, int include_up_time)
+{
+  if (!snmp_is_active(p))
+    return;
+
+  sock *sk = p->sock;
+  TRACE(D_PACKETS, "SNMP sending agentx-Notify-PDU");
+  struct snmp_pdu c;
+  snmp_pdu_context(&c, p, sk);
+
+#define UPTIME_SIZE sizeof(STATIC_OID(4)) /* see sys_up_time_0 */
+#define TRAP0_HEADER_SIZE sizeof(STATIC_OID(6)) /* see snmp_trap_oid_0 */
+
+  uint sz = AGENTX_HEADER_SIZE + TRAP0_HEADER_SIZE + snmp_oid_size(oid) \
+    + size;
+
+  if (include_up_time)
+    sz += UPTIME_SIZE;
+
+  /* Make sure that we have enough space in TX buffer */
+  (void) snmp_tbuf_reserve(&c, sz);
+
+  struct agentx_header *h = (struct agentx_header *) c.buffer;
+  ADVANCE(c.buffer, c.size, AGENTX_HEADER_SIZE);
+  snmp_blank_header(h, AGENTX_NOTIFY_PDU);
+  p->packet_id++;   /* New packet id */
+  snmp_session(p, h);
+
+  if (include_up_time)
+  {
+    /* sysUpTime.0 oid */
+    STATIC_OID(4) sys_up_time_0 = {
+      .n_subid = 4,
+      .prefix = SNMP_MGMT,
+      .include = 0,
+      .reserved = 0,
+      .ids = { SNMP_MIB_2, SNMP_SYSTEM, SNMP_SYS_UP_TIME, 0 },
+    };
+    struct oid *up_time_0 = (struct oid *) &sys_up_time_0;
+
+    struct agentx_varbind *vb = (struct agentx_varbind *) c.buffer;
+    snmp_oid_to_buf(&vb->name, up_time_0);
+
+    /* TODO use time from last reconfiguration instead? [config->load_time] */
+    btime uptime = current_time() - boot_time;
+    snmp_varbind_ticks(&c, (uptime TO_S) / 100);
+    ADVANCE(c.buffer, c.size, snmp_varbind_size_unsafe(vb));
+    STORE_U16(vb->type, vb->type);
+    /* We do not need to call the snmp_varbind_leave() because we used
+     * the packet byte order in the first place.
+     */
+  }
+
+  /* snmpTrapOID.0 oid */
+  STATIC_OID(6) snmp_trap_oid_0 = {
+    .n_subid = 6,
+    .prefix = SNMP_V2,
+    .include = 0,
+    .reserved = 0,
+    .ids = { SNMP_MODULES, SNMP_ALARM_NEXT_INDEX, SNMP_MIB_OBJECTS, SNMP_TRAP, SNMP_TRAP_OID, 0 },
+  };
+  struct oid *trap_0 = (struct oid *) &snmp_trap_oid_0;
+
+  struct agentx_varbind *trap_vb = (struct agentx_varbind *) c.buffer;
+  snmp_oid_to_buf(&trap_vb->name, trap_0);
+  /* snmp_oid_size() works for both byte orders same */
+  c.sr_vb_start = trap_vb;
+  snmp_varbind_oid(&c, oid);
+  ADVANCE(c.buffer, c.size, snmp_varbind_size_unsafe(trap_vb));
+  STORE_U16(trap_vb->type, trap_vb->type);
+  /* We do not need to call the snmp_varbind_leave() because we used the packet
+   * byte order in the first place.
+   */
+
+  memcpy(c.buffer, data, size);
+  ADVANCE(c.buffer, c.size, size);
+
+  uint s = update_packet_size(h, c.buffer);
+  sk_send(sk, s);
+
+#undef TRAP0_HEADER_SIZE
+#undef UPTIME_SIZE
+}
+
+/*
+ * un_register_pdu - common functionality for registration PDUs
+ * @p: SNMP protocol instance
+ * @oid: OID to register/unregister
+ * @bound: OIDs registration upper bound
+ * @index: OIDs registration n_subid index
+ * @type: register/unregister PDU type
+ * @is_instance: flag enabling instance registration (used only for register)
+ *
+ * Both register and unregister PDUs are capable of specifing a number of OIDs
+ * by using a pair of index and upper bound. The index (r.range_subid) points into
+ * the OID's n_subid array to ID being threated as variable. The upper bound
+ * (r.upper_bound) determins maximal value for n_subid selected by the index.
+ * The index and the upper bound are passed as @index, and @bound respectively.
+ *
+ * Zero value for @is_instance means we want to register/unregister OID as a MIB
+ * subtree, for nonzero value we are registering MIB tree an instance (leaf).
+ * Full name of PDUs are agentx-Register-PDU and agentx-Unregister-PDU.
+ *
+ * This function in internal and shoulnd't be used outside the SNMP module,
+ * see snmp_register() and snmp_unregister() functions.
+ */
+static void
+un_register_pdu(struct snmp_proto *p, struct oid *oid, u32 bound, uint index, enum agentx_pdu_types type, u8 is_instance)
+{
+  const struct snmp_config *cf = SKIP_BACK(struct snmp_config, cf, p->p.cf);
+  sock *sk = p->sock;
+  struct snmp_pdu c;
+  snmp_pdu_context(&c, p, sk);
+
+#define BOUND_SIZE sizeof(u32)
+  uint sz = AGENTX_HEADER_SIZE + snmp_oid_size(oid) +
+      ((bound > 1) ? BOUND_SIZE : 0);
+
+  (void) snmp_tbuf_reserve(&c, sz);
+
+  struct agentx_header *h = (void *) c.buffer;
+  ADVANCE(c.buffer, c.size, AGENTX_HEADER_SIZE);
+
+  snmp_header(h, type, is_instance ? AGENTX_FLAG_INSTANCE_REGISTRATION : 0);
+  p->packet_id++;
+  snmp_session(p, h);
+
+  struct agentx_un_register_hdr *ur = (struct agentx_un_register_hdr *) c.buffer;
+
+  /* 0 = do not override session message timeout */
+  STORE_U8(ur->timeout, 0);
+  /* use selected priority */
+  STORE_U8(ur->priority, cf->priority);
+  STORE_U8(ur->range_subid, (bound > 1) ? index : 0);
+  STORE_U8(ur->reserved, 0);
+  ADVANCE(c.buffer, c.size, sizeof(struct agentx_un_register_hdr));
+
+  snmp_oid_to_buf((struct oid *) c.buffer, oid);
+  ADVANCE(c.buffer, c.size, snmp_oid_size(oid));
+
+  /* place upper-bound if needed */
+  if (bound > 1)
+  {
+    STORE_PTR(c.buffer, bound);
+    ADVANCE(c.buffer, c.size, BOUND_SIZE);
+  }
+
+  uint s = update_packet_size(h, c.buffer);
+
+  sk_send(sk, s);
+#undef BOUND_SIZE
+}
+
+/*
+ * snmp_unregister - send an agentx-Unregister-PDU
+ * @p: SNMP protocol instance
+ * @oid: OID to uregister
+ * @bound: OIDs unregistration upper bound
+ * @index: OIDs unregistration n_subid index
+ *
+ * For more detailed description see un_register_pdu() function.
+ */
+void UNUSED
+snmp_unregister(struct snmp_proto *p, struct oid *oid, u32 bound, uint index)
+{
+  TRACE(D_PACKETS, "SNMP sending agentx-Unregister-PDU");
+  un_register_pdu(p, oid, bound, index, AGENTX_UNREGISTER_PDU, 0);
+}
+
+/*
+ * snmp_register - send an agentx-Register-PDU
+ * @p: SNMP protocol instance
+ * @oid: OID to register
+ * @bound: OIDs registration upper bound
+ * @index: OIDs registration n_subid index
+ * @is_instance: flag enabling instance registration
+ *
+ * For more detailed description see un_register_pdu() function.
+ */
+void
+snmp_register(struct snmp_proto *p, struct oid *oid, u32 bound, uint index, u8 is_instance)
+{
+  TRACE(D_PACKETS, "SNMP sending agentx-Register-PDU");
+  un_register_pdu(p, oid, bound, index, AGENTX_REGISTER_PDU, is_instance);
+}
+
+/*
+ * open_pdu - send an agentx-Open-PDU
+ * @p: SNMP protocol instance
+ * @oid: PDU OID description field value
+ *
+ * Other fields are filled based on @p configuration (timeout, subagent
+ * description).
+ */
+static void
+open_pdu(struct snmp_proto *p, struct oid *oid)
+{
+  const struct snmp_config *cf = SKIP_BACK(struct snmp_config, cf, p->p.cf);
+  sock *sk = p->sock;
+
+  TRACE(D_PACKETS, "SNMP sending agentx-Open-PDU");
+
+  struct snmp_pdu c;
+  snmp_pdu_context(&c, p, sk);
+
+#define TIMEOUT_SIZE sizeof(u32) /* 1B timeout, 3B zero padding */
+
+  /* Make sure that we have enough space in TX buffer */
+  uint s = AGENTX_HEADER_SIZE + TIMEOUT_SIZE + snmp_oid_size(oid) +
+    snmp_str_size(cf->description);
+
+  (void) snmp_tbuf_reserve(&c, s);
+
+  struct agentx_header *h = (void *) c.buffer;
+  ADVANCE(c.buffer, c.size, AGENTX_HEADER_SIZE);
+  snmp_blank_header(h, AGENTX_OPEN_PDU);
+
+  STORE_U32(h->session_id, 1);
+  STORE_U32(h->transaction_id, 1);
+  STORE_U32(h->packet_id, 1);
+
+  c.size -= (4 + snmp_oid_size(oid) + snmp_str_size(cf->description));
+
+  if (p->timeout >= 1 S && p->timeout <= 255 S)
+    /* use p->timeout ceiled up to whole second */
+    c.buffer = snmp_put_fbyte(c.buffer,
+      (p->timeout % (1 S) == 0) ? p->timeout TO_S : p->timeout TO_S + 1);
+  /* out of range fallbacks */
+  else if (p->timeout < 1 TO_US)
+    c.buffer = snmp_put_fbyte(c.buffer, (u8) 1);
+  else /* p->timeout > 255 TO_US */
+    c.buffer = snmp_put_fbyte(c.buffer, (u8) 255);
+
+  snmp_oid_to_buf((struct oid *) c.buffer, oid);
+  c.buffer += snmp_oid_size(oid);
+  c.buffer = snmp_put_str(c.buffer, cf->description);
+
+  s = update_packet_size(h, c.buffer);
+  sk_send(sk, s);
+#undef TIMEOUT_SIZE
+}
+
+/*
+ * parse_close_pdu - parse an agentx-Close-PDU
+ * @p: SNMP protocol instance
+ * @pkt_start: pointer to first byte of PDU
+ *
+ * Return number of bytes parsed from RX buffer.
+ */
+static uint
+parse_close_pdu(struct snmp_proto *p, byte * const pkt_start)
+{
+  byte *pkt = pkt_start;
+
+  struct agentx_close_pdu *pdu = (void *) pkt;
+  pkt += sizeof(struct agentx_close_pdu);
+  uint pkt_size = pdu->h.payload;
+
+  if (pkt_size != sizeof(struct agentx_close_pdu))
+  {
+    TRACE(D_PACKETS, "SNMP received agentx-Close-PDU that's malformed, closing anyway");
+    snmp_simple_response(p, AGENTX_RES_GEN_ERROR, 0);
+    snmp_reset(p);
+    return 0;
+  }
+
+  if (!snmp_test_close_reason(pdu->reason))
+  {
+    TRACE(D_PACKETS, "SNMP received agentx-Close-PDU with invalid close reason %u", pdu->reason);
+    snmp_simple_response(p, AGENTX_RES_GEN_ERROR, 0);
+    snmp_reset(p);
+    return 0;
+  }
+
+  enum agentx_close_reasons reason = (enum agentx_close_reasons) pdu->reason;
+  TRACE(D_PACKETS, "SNMP received agentx-Close-PDU with close reason %u", reason);
+  snmp_simple_response(p, AGENTX_RES_NO_ERROR, 0);
+  snmp_reset(p);
+  return pkt_size + AGENTX_HEADER_SIZE;
+}
+
+/*
+ * parse_sets_pdu - common functionality for commit set and undo set PDUs
+ * @p: SNMP protocol instance
+ * @pkt_start: pointer to first byte of on of set related PDU
+ * @error: error status to use
+ *
+ * Return number of bytes parsed from RX buffer.
+ */
+static uint
+parse_sets_pdu(struct snmp_proto *p, byte * const pkt_start, enum agentx_response_errs err)
+{
+  byte *pkt = pkt_start;
+  /* Presence of full header is guaranteed by parse_pkt() caller */
+  struct agentx_header *h = (void *) pkt;
+  pkt += AGENTX_HEADER_SIZE;
+  uint pkt_size = LOAD_U32(h->payload);
+
+  if (pkt_size != 0)
+  {
+    TRACE(D_PACKETS, "SNMP received PDU is malformed (size)");
+    snmp_simple_response(p, AGENTX_RES_PARSE_ERROR, 0);
+    snmp_reset(p);
+    return 0;
+  }
+
+  struct snmp_pdu c;
+  snmp_pdu_context(&c, p, p->sock);
+  (void) snmp_tbuf_reserve(&c, sizeof(struct agentx_response));
+
+  struct agentx_response *r = prepare_response(p, &c);
+
+  // TODO free resource allocated by parse_test_set_pdu()
+  // TODO do something meaningful
+  //mb_free(tr);
+  c.error = err;
+
+  TRACE(D_PACKETS, "SNMP received PDU parsed with error %u", c.error);
+  response_err_ind(p, r, c.error, 0);
+  sk_send(p->sock, AGENTX_HEADER_SIZE);
+
+  /* Reset the connection on unrecoverable error */
+  if (c.error != AGENTX_RES_NO_ERROR && c.error != err)
+  {
+    snmp_reset(p);    /* error */
+    return 0;
+  }
+
+  return pkt - pkt_start;
+}
+
+/*
+ * parse_cleanup_set_pdu - parse an agentx-CleanupSet-PDU
+ * @p: SNMP protocol instance
+ * @pkt_start: pointer to first byte of PDU inside RX buffer
+ *
+ * Return number of bytes parsed from RX buffer.
+ */
+static uint
+parse_cleanup_set_pdu(struct snmp_proto *p, byte * const pkt_start)
+{
+  byte *pkt = pkt_start;
+  struct agentx_header *h = (void *) pkt;
+  uint pkt_size = LOAD_U32(h->payload);
+
+  /* errors are dropped silently, we must not send any agentx-Response-PDU */
+  if (pkt_size != 0)
+  {
+    return AGENTX_HEADER_SIZE;
+    TRACE(D_PACKETS, "SNMP received agentx-CleanupSet-PDU is malformed");
+    snmp_reset(p);
+    return 0;
+  }
+
+  TRACE(D_PACKETS, "SNMP received agentx-CleanupSet-PDU");
+  (void)p;
+  // TODO don't forget to free resources allocated by parse_test_set_pdu()
+  //mb_free(p->tr);
+  /* No agentx-Response-PDU is sent in response to agentx-CleanupSet-PDU */
+  return pkt_size;
+}
+
+/*
+ * parse_undo_set_pdu - parse an agentx-UndoSet-PDU
+ * @p: SNMP protocol instance
+ * @pkt: pointer to first byte of PDU inside RX buffer
+ *
+ * Return number of bytes parsed from buffer.
+ */
+static inline uint
+parse_undo_set_pdu(struct snmp_proto *p, byte *pkt)
+{
+  // don't forget to free resources allocated by parse_test_set_pdu()
+  //mb_free(tr);
+  TRACE(D_PACKETS, "SNMP received agentx-UndoSet-PDU");
+  return parse_sets_pdu(p, pkt, AGENTX_RES_UNDO_FAILED);
+}
+
+/*
+ * parse_commit_set_pdu - parse an agentx-CommitSet-PDU
+ * @p: SNMP protocol instance
+ * @pkt: pointer to first byte of PDU inside RX buffer
+ *
+ * Return number of bytes parsed from RX buffer.
+ */
+static inline uint
+parse_commit_set_pdu(struct snmp_proto *p, byte *pkt)
+{
+  // don't forget to free resoures allocated by parse_test_set_pdu()
+  //mb_free(tr);
+  TRACE(D_PACKETS, "SNMP received agentx-CommitSet-PDU");
+  return parse_sets_pdu(p, pkt, AGENTX_RES_COMMIT_FAILED);
+}
+
+/*
+ * parse_test_set_pdu - parse an agentx-TestSet-PDU in buffer
+ * @p: SNMP protocol instance
+ * @pkt_start: first byte of test set PDU
+ * @size: number of bytes received from a socket
+ *
+ * Return number of bytes parsed from RX buffer.
+ */
+static inline uint
+parse_test_set_pdu(struct snmp_proto *p, byte * const pkt_start)
+{
+  TRACE(D_PACKETS, "SNMP received agentx-TestSet-PDU");
+  byte *pkt = pkt_start;  /* pointer to agentx-TestSet-PDU in RX buffer */
+  uint s; /* final packat size */
+  struct agentx_response *res; /* pointer to reponse in TX buffer */
+
+  /* Presence of full header is guaranteed by parse_pkt() caller */
+  struct agentx_header *h = (void *) pkt;
+  pkt += AGENTX_HEADER_SIZE;
+
+  sock *sk = p->sock;
+  struct snmp_pdu c;
+  snmp_pdu_context(&c, p, sk);
+
+  (void) snmp_tbuf_reserve(&c, AGENTX_HEADER_SIZE);
+
+  res = prepare_response(p, &c);
+
+  /* 0 if there is piece, that we cannot set */
+  int all_possible = 0;
+  /* the all_possible is currently hard-coded with no support for writing to mib
+   * variables, when implementing the mentioned support, change the initializer
+   * to 1
+   */
+  s = update_packet_size(h, c.buffer);
+
+  if (c.error != AGENTX_RES_NO_ERROR)
+  {
+    response_err_ind(p, res, c.error, c.index + 1);
+    snmp_reset(p);
+  }
+  else if (all_possible)
+  {
+    /* All values in the agentx-TestSet-PDU are OK, realy to commit them */
+    response_err_ind(p, res, AGENTX_RES_NO_ERROR, 0);
+  }
+  else
+  {
+    // Currently the only reachable branch
+    TRACE(D_PACKETS, "SNMP SET action failed (not writable)");
+    /* This is a recoverable error, we do not need to reset the connection */
+    response_err_ind(p, res, AGENTX_RES_NOT_WRITABLE, c.index + 1);
+  }
+
+  sk_send(sk, s);
+  return pkt - pkt_start;
+}
+
+/*
+ * AgentX GetPDU, GetNextPDU and GetBulkPDU
+ */
+
+/* agentx-Get-PDU */
+void
+snmp_get_pdu(struct snmp_proto *p, struct snmp_pdu *c, struct mib_walk_state *walk)
+{
+  struct mib_leaf *leaf;
+  leaf = snmp_walk_init(p->mib_tree, walk, c);
+
+  enum snmp_search_res res;
+  res = snmp_walk_fill(leaf, walk, c);
+
+  if (res != SNMP_SEARCH_OK)
+    c->sr_vb_start->type = snmp_search_res_to_type(res);
+}
+
+/* agentx-GetNext-PDU */
+int
+snmp_get_next_pdu(struct snmp_proto *p, struct snmp_pdu *c, struct mib_walk_state *walk)
+{
+  (void) snmp_walk_init(p->mib_tree, walk, c);
+  struct mib_leaf *leaf = snmp_walk_next(p->mib_tree, walk, c);
+
+  enum snmp_search_res res;
+  res = snmp_walk_fill(leaf, walk, c);
+
+  if (res != SNMP_SEARCH_OK)
+    c->sr_vb_start->type = AGENTX_END_OF_MIB_VIEW;
+
+  return res == SNMP_SEARCH_OK;
+}
+
+/* agentx-GetBulk-PDU */
+void
+snmp_get_bulk_pdu(struct snmp_proto *p, struct snmp_pdu *c, struct mib_walk_state *walk)
+{
+  /* TODO */
+  (void) p;
+  (void) c;
+  (void) walk;
+  //if (c->index >= bulk->getbulk.non_repeaters)
+  //  bulk->repeaters++;
+
+  // store the o_start and o_end
+
+  //bulk->has_any |= snmp_get_next_pdu(p, c, walk);
+}
+
+/**
+ * parse_gets_pdu - common parsing of received gets PDUs
+ * @p: SNMP protocol instance
+ * @pkt_start: pointer to first byte of received PDU
+ *
+ * Gets PDUs are agentx-Get-PDU, agentx-GetNext-PDU, agentx-GetBulk-PDU.
+ *
+ * Return number of bytes parsed from RX buffer
+ */
+static uint
+parse_gets_pdu(struct snmp_proto *p, byte * const pkt_start)
+{
+  struct mib_walk_state walk;
+  byte *pkt = pkt_start;
+
+  struct agentx_header *h = (void *) pkt;
+  pkt += AGENTX_HEADER_SIZE;
+  uint pkt_size = LOAD_U32(h->payload);
+
+  sock *sk = p->sock;
+  struct snmp_pdu c;
+  snmp_pdu_context(&c, p, sk);
+
+  /*
+   * Get-Bulk processing stops if all the varbind have type endOfMibView
+   * has_any is true if some varbind has type other than endOfMibView
+   */
+  struct agentx_bulk_state bulk_state = { 0 };
+  if (h->type == AGENTX_GET_BULK_PDU)
+  {
+    (void)bulk_state;
+    die("bulk");
+
+#if 0
+    if (pkt_size < sizeof(struct agentx_getbulk))
+    {
+      snmp_simple_response(p, AGENTX_RES_PARSE_ERROR, 0);
+      snmp_reset(p);
+      return pkt_size + AGENTX_HEADER_SIZE;
+    }
+
+    struct agentx_getbulk *bulk_info = (void *) pkt;
+    ADVANCE(pkt, pkt_size, sizeof(struct agentx_getbulk));
+
+    bulk_state = (struct agentx_bulk_state) {
+      .getbulk = {
+	.non_repeaters = LOAD_U32(bulk_info->non_repeaters),
+	.max_repetitions = LOAD_U32(bulk_info->max_repetitions),
+      },
+      /* In contrast to the RFC, we use 0-based indices. */
+      .index = 0,
+      .repetition = 0,
+      .has_any = 0,
+    };
+#endif
+  }
+
+  struct agentx_response *response_header = prepare_response(p, &c);
+
+  lp_state tmps;
+  lp_save(tmp_linpool, &tmps);
+  while (c.error == AGENTX_RES_NO_ERROR && pkt_size > 0)
+  {
+    lp_restore(tmp_linpool, &tmps);
+
+    if (!snmp_load_oids(&pkt, &pkt_size, &c))
+    {
+      snmp_simple_response(p, c.error,
+	(c.index > UINT16_MAX) ? UINT16_MAX : c.index);
+      snmp_reset(p);
+      return 0;
+    }
+
+    switch (h->type)
+    {
+      case AGENTX_GET_PDU:
+	snmp_get_pdu(p, &c, &walk);
+	break;
+
+      case AGENTX_GET_NEXT_PDU:
+	snmp_get_next_pdu(p, &c, &walk);
+	break;
+
+      case AGENTX_GET_BULK_PDU:
+	snmp_get_bulk_pdu(p, &c, &walk);
+	break;
+
+      default:
+	die("implementation failure");
+    }
+
+    snmp_varbind_leave(c.sr_vb_start);
+
+    c.sr_vb_start = NULL;
+    c.sr_o_end = NULL;
+
+    c.index++;
+  } /* while (c.error == AGENTX_RES_NO_ERROR && size > 0) */
+
+  lp_restore(tmp_linpool, &tmps);
+
+#if 0
+  if (h->type == AGENTX_GET_BULK_PDU)
+  {
+    // TODO: an error for now
+    die("bulk");
+  }
+#endif
+
+  /* We update the error, index pair on the beginning of the packet. */
+  response_err_ind(p, response_header, c.error, c.index + 1);
+  uint s = update_packet_size(&response_header->h, c.buffer);
+
+  /* We send the message in TX buffer. */
+  sk_send(sk, s);
+
+  // TODO think through the error state
+
+  /* number of bytes parsed from RX buffer */
+  return pkt - pkt_start;
+}
+
+/*
+ * do_response - act on agentx-Response-PDU and protocol state
+ * @p: SNMP protocol instance
+ * @pkt: RX buffer with PDU bytes
+ *
+ * Return number of bytes parsed from RX buffer.
+ */
+static void
+do_response(struct snmp_proto *p, byte *pkt)
+{
+  struct agentx_response *r = (void *) pkt;
+  struct agentx_header *h = (void *) r;
+
+  switch (p->state)
+  {
+    case SNMP_INIT:
+    case SNMP_LOCKED:
+      /* silent drop of received packet */
+      break;
+
+    case SNMP_OPEN:
+      /* copy session info from received packet */
+      p->session_id = LOAD_U32(h->session_id);
+      refresh_ids(p, h);
+
+      tm_start(p->ping_timer, 0);
+
+      /* the state needs to be changed before sending registering PDUs to
+       * use correct do_response action on them
+       */
+      snmp_set_state(p, SNMP_REGISTER);
+      break;
+
+    case SNMP_REGISTER:;
+      snmp_register_ack(p, r);
+      break;
+
+    case SNMP_CONN:
+      break;
+
+    case SNMP_STOP:
+    case SNMP_DOWN:
+      break;
+
+    default:
+      die("unkonwn SNMP state");
+  }
+}
+
+/*
+ * parse_response - parse an agentx-Response-PDU
+ * @p: SNMP protocol instance
+ * @res: pointer of agentx-Response-PDU header in RX buffer
+ *
+ * Return number of bytes parsed from RX buffer.
+ */
+static uint
+parse_response(struct snmp_proto *p, byte *res)
+{
+  struct agentx_response *r = (void *) res;
+  struct agentx_header *h = (void *) r;
+
+  uint pkt_size = LOAD_U32(h->payload);
+
+  if (p->ignore_ping_id && LOAD_U32(h->packet_id) == p->ignore_ping_id)
+  {
+    p->pings--;
+    p->ignore_ping_id = 0;
+  }
+
+  /* Number of agentx-Ping-PDU without response */
+  if (p->pings > 5)
+    snmp_reset(p);
+
+  switch (r->error)
+  {
+    case AGENTX_RES_NO_ERROR:
+      if (p->verbose || LOAD_U32(h->packet_id) != p->ignore_ping_id)
+	TRACE(D_PACKETS, "SNMP received agentx-Response-PDU");
+      do_response(p, res);
+      break;
+
+    /* Registration errors */
+    case AGENTX_RES_DUPLICATE_REGISTER:
+    case AGENTX_RES_REQUEST_DENIED:
+    case AGENTX_RES_UNKNOWN_REGISTER:
+      TRACE(D_PACKETS, "SNMP received agentx-Response-PDU with error %u", r->error);
+      snmp_register_ack(p, r);
+      break;
+
+    /*
+     * We found ourselves in an unexpected situation. To enter a well defined
+     * state as well as give the AgentX master agent room to fix the errors on
+     * his side, we perform a hard reset of the connections.
+     */
+    case AGENTX_RES_NOT_OPEN:
+    case AGENTX_RES_OPEN_FAILED:
+    case AGENTX_RES_UNKNOWN_AGENT_CAPS:
+    case AGENTX_RES_UNSUPPORTED_CONTEXT:  /* currently we don't use contexts */
+    case AGENTX_RES_PARSE_ERROR:
+    case AGENTX_RES_PROCESSING_ERR:
+    default:
+      TRACE(D_PACKETS, "SNMP received agentx-Response-PDU with unexepected error %u", r->error);
+      snmp_reset(p);
+      break;
+  }
+
+  return pkt_size + AGENTX_HEADER_SIZE;
+}
+
+/**
+ * parse_pkt - parse received AgentX packet
+ * @p: SNMP protocol instance
+ * @pkt: first byte of PDU inside RX buffer
+ * @size: number of bytes received from a socket
+ *
+ * Return number of bytes parsed from RX buffer.
+ */
+static uint
+parse_pkt(struct snmp_proto *p, byte *pkt, uint size)
+{
+  if (size < AGENTX_HEADER_SIZE)
+    return 0;
+
+  struct agentx_header *h = (struct agentx_header *) pkt;
+  if (h->flags & AGENTX_NETWORK_BYTE_ORDER != SNMP_BYTE_ORDER)
+  {
+    TRACE(D_PACKETS, "SNMP received PDU with unexpected byte order");
+    if (h->type != AGENTX_RESPONSE_PDU)
+      snmp_simple_response(p, AGENTX_RES_GEN_ERROR, 0);
+    snmp_reset(p);
+    return 0;
+  }
+
+  u32 pkt_size = LOAD_U32(h->payload);
+
+  /* RX side checks - too big packet */
+  if (pkt_size > SNMP_PKT_SIZE_MAX)
+  {
+    TRACE(D_PACKETS, "SNMP received PDU is too long");
+    if (h->type != AGENTX_RESPONSE_PDU)
+      snmp_simple_response(p, AGENTX_RES_GEN_ERROR, 0);
+    snmp_reset(p);
+    return 0;
+  }
+
+  /* This guarantees that we have the full packet already received */
+  if (size < pkt_size + AGENTX_HEADER_SIZE)
+    return 0; /* no bytes parsed */
+
+  /*
+   * We need to see the responses for PDU such as
+   * agentx-Open-PDU, agentx-Register-PDU, ...
+   * even when we are outside the SNMP_CONNECTED state
+   */
+  if (h->type == AGENTX_RESPONSE_PDU)
+    return parse_response(p, pkt);
+
+  ASSERT(snmp_is_active(p));
+  if (p->state != SNMP_CONN ||
+      p->session_id != LOAD_U32(h->session_id))
+  {
+    struct agentx_header copy = {
+      .session_id = p->session_id,
+      .transaction_id = p->transaction_id,
+      .packet_id = p->packet_id,
+    };
+
+    TRACE(D_PACKETS, "SNMP received PDU with unknown session id");
+    snmp_simple_response(p, AGENTX_RES_NOT_OPEN, 0);
+
+    p->session_id = copy.session_id;
+    p->transaction_id = copy.transaction_id;
+    p->packet_id = copy.packet_id;
+
+    /*
+     * After unexpected state, we simply reset the session
+     * only sending the agentx-Response-PDU.
+     */
+    snmp_reset(p);
+    return 0;
+  }
+
+  if (h->flags & AGENTX_NON_DEFAULT_CONTEXT)
+  {
+    TRACE(D_PACKETS, "SNMP received PDU with non-default context");
+    snmp_simple_response(p, AGENTX_RES_UNSUPPORTED_CONTEXT, 0);
+    snmp_reset(p);
+    return 0;
+  }
+
+  refresh_ids(p, h);
+  switch (LOAD_U8(h->type))
+  {
+    case AGENTX_GET_PDU:
+      TRACE(D_PACKETS, "SNMP received agentx-Get-PDU");
+      return parse_gets_pdu(p, pkt);
+
+    case AGENTX_GET_NEXT_PDU:
+      TRACE(D_PACKETS, "SNMP received agentx-GetNext-PDU");
+      return parse_gets_pdu(p, pkt);
+
+    case AGENTX_GET_BULK_PDU:
+      TRACE(D_PACKETS, "SNMP received agentx-GetBulk-PDU");
+      return parse_gets_pdu(p, pkt);
+
+    case AGENTX_CLOSE_PDU:
+      return parse_close_pdu(p, pkt);
+
+    case AGENTX_TEST_SET_PDU:
+      return parse_test_set_pdu(p, pkt);
+
+    case AGENTX_COMMIT_SET_PDU:
+      return parse_commit_set_pdu(p, pkt);
+
+    case AGENTX_UNDO_SET_PDU:
+      return parse_undo_set_pdu(p, pkt);
+
+    case AGENTX_CLEANUP_SET_PDU:
+      return parse_cleanup_set_pdu(p, pkt);
+
+    default:
+      /* We reset the connection for malformed packet (Unknown packet type) */
+      TRACE(D_PACKETS, "SNMP received PDU with unknown type (%u)", LOAD_U8(h->type));
+      snmp_reset(p);
+      return 0;
+  }
+}
+
+/*
+ * snmp_register_ack - handle registration response
+ * @p: SNMP protocol instance
+ * @res: header of agentx-Response-PDU
+ */
+void
+snmp_register_ack(struct snmp_proto *p, struct agentx_response *res)
+{
+  struct snmp_registration *reg;
+  WALK_LIST(reg, p->registration_queue)
+  {
+    if (snmp_registration_match(reg, &res->h))
+    {
+      rem_node(&reg->n);
+
+      if (res->error == AGENTX_RES_NO_ERROR && reg->reg_hook_ok)
+	reg->reg_hook_ok(p, res, reg);
+      else if (res->error != AGENTX_RES_NO_ERROR && reg->reg_hook_fail)
+	reg->reg_hook_fail(p, res, reg);
+
+      mb_free(reg);
+      break;
+    }
+  }
+
+  if (EMPTY_LIST(p->registration_queue))
+    snmp_up(p);
+}
+
+/**
+ * snmp_stop_subagent - close established session
+ * @p: SNMP protocol instance
+ *
+ * Send agentx-Close-PDU on established session.
+ */
+void
+snmp_stop_subagent(struct snmp_proto *p)
+{
+  tm_stop(p->ping_timer);
+  /* This cause problems with net-snmp daemon witch halts afterwards */
+  close_pdu(p, AGENTX_CLOSE_SHUTDOWN);
+}
+
+/**
+ * snmp_register_mibs - register all MIB subtrees
+ * @p: SNMP protocol instance
+ */
+void
+snmp_register_mibs(struct snmp_proto *p)
+{
+  snmp_bgp4_register(p);
+  ASSUME(!EMPTY_LIST(p->registration_queue));
+}
+
+/**
+ * snmp_start_subagent - send session open request
+ * @p: SNMP protocol instance
+ *
+ * Send agentx-Open-PDU with configured OID and string description.
+ */
+void
+snmp_start_subagent(struct snmp_proto *p)
+{
+  ASSUME(p->state == SNMP_OPEN);
+
+  /* blank oid means unsupported */
+  STATIC_OID(0) blank = { 0 };
+  open_pdu(p, (struct oid *) &blank);
+}
+
+/*
+ * snmp_rx - handle received PDUs in RX buffer in normal operation
+ * @sk: communication socket
+ * @size: number of bytes received
+ */
+int
+snmp_rx(sock *sk, uint size)
+{
+  struct snmp_proto *p = (struct snmp_proto *) sk->data;
+  byte *pkt_start = sk->rbuf;
+  byte *end = pkt_start + size;
+
+  while (snmp_is_active(p) && end >= pkt_start + AGENTX_HEADER_SIZE)
+  {
+    uint parsed_len = parse_pkt(p, pkt_start, size);
+
+    if (parsed_len == 0)
+      break;
+
+    pkt_start += parsed_len;
+    size -= parsed_len;
+  }
+
+  /* We flush the RX buffer on errors */
+  if (!snmp_is_active(p) || pkt_start == end)
+    return 1; /* The whole RX buffer was consumed */
+
+  /* Incomplete packet parsing */
+  memmove(sk->rbuf, pkt_start, size);
+  sk->rpos = sk->rbuf + size;
+  return 0;
+}
+
+/*
+ * space_for_response - check if TX buffer has space for agentx-Response-PDU
+ * @sk: communication socket owned by SNMP protocol instance
+ *
+ * In some cases we send only the AgentX header but if we want to signal an
+ * error, we need at least space for agentx-Response-PDU. This simplifies the
+ * PDU space requirements testing.
+ */
+static inline int
+space_for_response(const sock *sk)
+{
+  return (
+    (uint) (sk->tbuf + sk->tbsize - sk->tpos) >= sizeof(struct agentx_response)
+  );
+}
+
+/*
+ * snmp_tx - handle TX buffer
+ * @sk: communication socket owned by SNMP protocol instance
+ *
+ * The snmp_tx hook is used only to delay the processing in cases we don't have
+ * enough space in TX buffer. Therefore we simply call the snmp_rx hook.
+ */
+void
+snmp_tx(sock *sk)
+{
+  /* We still not have enough space */
+  if (!space_for_response(sk))
+    return;
+
+  /* There is nothing to process, no bytes in RX buffer */
+  if (sk_tx_buffer_empty(sk))
+    return;
+
+  snmp_rx(sk, sk->tpos - sk->tbuf);
+}
+
diff --git a/proto/snmp/subagent.h b/proto/snmp/subagent.h
new file mode 100644
index 00000000..7aab4623
--- /dev/null
+++ b/proto/snmp/subagent.h
@@ -0,0 +1,359 @@
+
+#ifndef _BIRD_SNMP_SUBAGENT_H_
+#define _BIRD_SNMP_SUBAGENT_H_
+
+#include "nest/bird.h"
+#include "snmp.h"
+#include "lib/macro.h"
+
+#define AGENTX_VERSION              1
+
+/* standard snmp internet prefix */
+#define SNMP_ISO	  1	      /* last of oid .1		      */
+#define SNMP_ORG	  3	      /* last of oid .1.3	      */
+#define SNMP_DOD	  6	      /* last of oid .1.3.6	      */
+#define SNMP_INTERNET	  1	      /* last of oid .1.3.6.1	      */
+
+#define SNMP_MGMT	  2	      /* last of oid .1.3.6.1.2	      */
+#define SNMP_MIB_2	  1	      /* last of oid .1.3.6.1.2.1     */
+#define SNMP_SYSTEM	  1	      /* last of oid .1.3.6.1.2.1.1   */
+#define SNMP_OSPF_MIB	 14	      /* last of oid .1.3.6.1.2.1.14  */
+#define SNMP_BGP4_MIB	 15	      /* last of oid .1.3.6.1.2.1.15  */
+#define SNMP_OSPFv3_MIB	192	      /* last of oid .1.3.6.1.2.1.192 */
+
+/* sysUpTime */
+#define SNMP_SYS_UP_TIME  3	      /* last of oid .1.3.6.1.2.1.1.3 */
+
+/* snmpTrapOID */
+#define SNMP_V2		  6	      /* last of oid .1.3.6.1.6		  */
+#define SNMP_MODULES	  3	      /* last of oid .1.3.6.1.6.3	  */
+#define SNMP_ALARM_NEXT_INDEX 1	      /* last of oid .1.3.6.1.6.3.1	  */
+#define SNMP_MIB_OBJECTS  1	      /* last of oid .1.3.6.1.6.3.1.1	  */
+#define SNMP_TRAP	  4	      /* last of oid .1.3.6.1.6.3.1.1.4	  */
+#define SNMP_TRAP_OID	  1	      /* last of oid .1.3.6.1.6.3.1.1.4.1 */
+
+extern const u32 snmp_internet[4];
+
+#define SNMP_DEFAULT_CONTEXT 0
+
+enum agentx_type {
+  AGENTX_INTEGER	    =   2,
+  AGENTX_OCTET_STRING	    =   4,
+  AGENTX_NULL		    =   5,
+  AGENTX_OBJECT_ID	    =   6,
+  AGENTX_IP_ADDRESS	    =  64,
+  AGENTX_COUNTER_32	    =  65,
+  AGENTX_GAUGE_32	    =  66,
+  AGENTX_TIME_TICKS	    =  67,
+  AGENTX_OPAQUE		    =  68,
+  AGENTX_COUNTER_64	    =  70,
+  AGENTX_NO_SUCH_OBJECT	    = 128,
+  AGENTX_NO_SUCH_INSTANCE   = 129,
+  AGENTX_END_OF_MIB_VIEW    = 130,
+
+  AGENTX_INVALID	    =   0,
+} PACKED;
+
+enum snmp_search_res {
+  SNMP_SEARCH_OK	  = 0,
+  SNMP_SEARCH_NO_OBJECT	  = 1,
+  SNMP_SEARCH_NO_INSTANCE = 2,
+  SNMP_SEARCH_END_OF_VIEW = 3,
+};
+
+
+#define AGENTX_PRIORITY		127
+
+#define SNMP_REGISTER_TREE 0
+#define SNMP_REGISTER_INSTANCE 1
+
+enum agentx_flags {
+  AGENTX_FLAG_BLANK		    = 0x00,
+  AGENTX_FLAG_INSTANCE_REGISTRATION = 0x01,
+  AGENTX_FLAG_NEW_INDEX		    = 0x02,
+  AGENTX_FLAG_ANY_INDEX		    = 0x04,
+  AGENTX_NON_DEFAULT_CONTEXT	    = 0x08,
+  AGENTX_NETWORK_BYTE_ORDER	    = 0x10,
+} PACKED;
+
+#define AGENTX_FLAGS_MASK (AGENTX_FLAG_INSTANCE_REGISTRATION		      \
+  | AGENTX_FLAG_NEW_INDEX						      \
+  | AGENTX_FLAG_ANY_INDEX						      \
+  | AGENTX_NON_DEFAULT_CONTEXT						      \
+  | AGENTX_NETWORK_BYTE_ORDER)
+
+// TODO - make me compile time option
+#define SNMP_NETWORK_BYTE_ORDER
+
+#if !(defined(SNMP_NATIVE) || defined(SNMP_NETWORK_BYTE_ORDER))
+# error "SNMP: currently support only native byte order or network byte order."
+#endif
+
+#if defined(SNMP_NATIVE) && defined(SNMP_NETWORK_BYTE_ORDER) && !defined(CPU_BIG_ENDIAN)
+# error "SNMP: couldn't use both native byte order and network byte order " \
+  "(big endian) on little endian machine."
+#endif
+
+#if (defined(SNMP_NATIVE) && defined(CPU_BIG_ENDIAN)) || defined(SNMP_NETWORK_BYTE_ORDER)
+#define SNMP_BYTE_ORDER AGENTX_NETWORK_BYTE_ORDER
+#else
+#define SNMP_BYTE_ORDER 0
+#endif
+
+/* We recommend using STORE_U32 over VALUE_U32 when possible */
+#ifdef SNMP_NATIVE
+#define STORE_U32(dest, val)  ((u32) ((dest) = (u32) (val)))
+#define STORE_U16(dest, val)  ((u16) ((dest) = (u16) (val)))
+#define STORE_U8(dest, val)   ((u8) ((dest) = (u8) (val)))
+#define STORE_PTR(ptr, val)   (*((u32 *) (ptr)) = (u32) (val))
+
+#define VALUE_U32(val)	      ((u32) (val))
+#define VALUE_U16(val)	      ((u16) (val))
+#define VALUE_U8(val)	      ((u8) (val))
+
+#define LOAD_U32(src)	      *((u32 *) &(src))
+#define LOAD_U16(src)	      *((u16 *) &(src))
+#define LOAD_U8(src)	      *((u8 *) &(src))
+#define LOAD_PTR(ptr)	      *((u32 *) (ptr))
+#endif
+
+#if  defined(SNMP_NETWORK_BYTE_ORDER) && (!defined(SNMP_NATIVE) || defined(CPU_BIG_ENDIAN))
+#define STORE_U32(dest, val)  put_u32(&(dest), (val))
+#define STORE_U16(dest, val)  put_u16(&(dest), (val))
+#define STORE_U8(dest, val)   put_u8(&(dest), (val))
+#define STORE_PTR(ptr, val)   put_u32(ptr, val)
+
+#define VALUE_U32(val)	      htonl(val)
+#define VALUE_U16(val)	      htons(val)
+#define VALUE_U8(val)	      ((u8) (val))
+
+
+#define LOAD_U32(src)	      get_u32(&(src))
+#define LOAD_U16(src)	      get_u16(&(src))
+#define LOAD_U8(src)	      get_u8(&(src))
+#define LOAD_PTR(src)	      get_u32(ptr)
+#endif
+
+struct agentx_header {
+  u8 version;
+  u8 type;
+  u8 flags;
+  u8 reserved;		/* always zero filled */
+  u32 session_id;	/* AgentX sessionID established by Open-PDU */
+  u32 transaction_id;	/* last transactionID seen/used */
+  u32 packet_id;	/* last packetID seen/used */
+  u32 payload;		/* payload_length of the packet without header */
+};
+
+#define AGENTX_HEADER_SIZE 20
+STATIC_ASSERT(AGENTX_HEADER_SIZE == sizeof(struct agentx_header));
+
+struct oid {
+  u8 n_subid;
+  u8 prefix;
+  u8 include;
+  u8 reserved;	/* always zero filled */
+  u32 ids[];
+};
+
+#define STATIC_OID(sbids)						      \
+  struct {								      \
+    u8 n_subid;								      \
+    u8 prefix;								      \
+    u8 include;								      \
+    u8 reserved;							      \
+    u32 ids[sbids];							      \
+  }
+
+#define STATIC_OID_INITIALIZER(sbids, pref, ...)			      \
+  {									      \
+    .n_subid = sbids,							      \
+    .prefix = pref,							      \
+    .include = 0,							      \
+    .reserved = 0,							      \
+    .ids = { __VA_ARGS__ },						      \
+  }
+
+/* enforced by MIB tree, see mib_tree.h for more info */
+#define OID_MAX_LEN 32
+
+/*
+ * AgentX VarBind -- Variable Binding
+ * During the processing of the VarBind, the fields @type and @name are in cpu
+ * native byte order. This should be fixed by running snmp_varbind_leave()
+ * before VarBind control pointer abondonment or before packet transmission.
+ * The data following the structure should always follow the packet byte order.
+ */
+struct agentx_varbind {
+  u16 type;
+  u16 reserved; /* always zero filled */
+  /* oid part */
+  struct oid name;
+  /* AgentX variable binding data optionally here */
+};
+
+/* AgentX Octet String */
+struct agentx_octet_str {
+  u32 length;
+  byte data[0];
+};
+
+struct agentx_response {
+  struct agentx_header h;
+  u32 uptime;
+  u16 error;
+  u16 index;
+};
+
+STATIC_ASSERT(4 + 2 + 2 + AGENTX_HEADER_SIZE == sizeof(struct agentx_response));
+
+struct agentx_open_pdu {
+  struct agentx_header h;
+  u8 timeout;
+  u8 reserved1;	  /* reserved u24 */
+  u16 reserved2;  /* whole u24 is always zero filled */
+};
+
+struct agentx_close_pdu {
+  struct agentx_header h;
+  u8 reason;
+  u8 reserved1; /* reserved u24 */
+  u16 reserved2; /* whole u24 is always zero filled */
+};
+
+struct agentx_un_register_hdr {
+  u8 timeout;
+  u8 priority;
+  u8 range_subid;
+  u8 reserved;	/* always zero filled */
+};
+
+struct agentx_getbulk {
+  u16 non_repeaters;
+  u16 max_repetitions;
+};
+
+struct agentx_bulk_state {
+  struct agentx_getbulk getbulk;
+  u16 index;
+  u16 repetition;
+  u32 repeaters;
+  int has_any;	    /* flag is clear when all responses are EndOfMibView */
+};
+
+enum agentx_pdu_types {
+  AGENTX_OPEN_PDU		=  1,	  /* agentx-Open-PDU */
+  AGENTX_CLOSE_PDU		=  2,	  /* agentx-Close-PDU */
+  AGENTX_REGISTER_PDU		=  3,	  /* agentx-Regiter-PDU */
+  AGENTX_UNREGISTER_PDU		=  4,	  /* agentx-Unregister-PDU */
+  AGENTX_GET_PDU		=  5,	  /* agentx-Get-PDU */
+  AGENTX_GET_NEXT_PDU		=  6,	  /* agentx-GetNext-PDU */
+  AGENTX_GET_BULK_PDU		=  7,	  /* agentx-GetBulk-PDU */
+  AGENTX_TEST_SET_PDU		=  8,	  /* agentx-TestSet-PDU */
+  AGENTX_COMMIT_SET_PDU		=  9,	  /* agentx-CommitSet-PDU */
+  AGENTX_UNDO_SET_PDU		= 10,	  /* agentx-UndoSet-PDU */
+  AGENTX_CLEANUP_SET_PDU	= 11,	  /* agentx-CleanupSet-PDU */
+  AGENTX_NOTIFY_PDU		= 12,	  /* agentx-Notify-PDU */
+  AGENTX_PING_PDU		= 13,	  /* agentx-Ping-PDU */
+  AGENTX_INDEX_ALLOCATE_PDU     = 14,	  /* agentx-IndexAllocate-PDU */
+  AGENTX_INDEX_DEALLOCATE_PDU   = 15,	  /* agentx-IndexDeallocate-PDU */
+  AGENTX_ADD_AGENT_CAPS_PDU     = 16,	  /* agentx-AddAgentCaps-PDU */
+  AGENTX_REMOVE_AGENT_CAPS_PDU  = 17,	  /* agentx-RemoveAgentCaps-PDU */
+  AGENTX_RESPONSE_PDU		= 18,	  /* agentx-Response-PDU */
+} PACKED;
+
+/* agentx-Close-PDU close reasons */
+enum agentx_close_reasons {
+  AGENTX_CLOSE_OTHER	      = 1,
+  AGENTX_CLOSE_PARSE_ERROR    = 2,
+  AGENTX_CLOSE_PROTOCOL_ERROR = 3,
+  AGENTX_CLOSE_TIMEOUTS	      = 4,
+  AGENTX_CLOSE_SHUTDOWN	      = 5,
+  AGENTX_CLOSE_BY_MANAGER     = 6,
+} PACKED;
+
+
+/* agentx-Response-PDU - result errors */
+enum agentx_response_errs {
+  /* response error to both Administrative and SNMP messages */
+  AGENTX_RES_NO_ERROR		    =   0,	/* noAgentXError */
+  /* response errors to SNMP messages */
+  AGENTX_RES_GEN_ERROR		    =   5,	/* genError */
+  AGENTX_RES_NO_ACCESS		    =   6,	/* noAccess */
+  AGENTX_RES_WRONG_TYPE		    =   7,	/* wrongType */
+  AGENTX_RES_WRONG_LENGTH	    =   8,	/* wrongLength */
+  AGENTX_RES_WRONG_ENCODING	    =   9,	/* wrongEncoding */
+  AGENTX_RES_WRONG_VALUE	    =  10,	/* wrongValue*/
+  AGENTX_RES_NO_CREATION	    =  11,	/* noCreation */
+  AGENTX_RES_INCONSISTENT_VALUE	    =  12,	/* inconsistentValue */
+  AGENTX_RES_RESOURCE_UNAVAILABLE   =  13,	/* resourceUnavailable */
+  AGENTX_RES_COMMIT_FAILED	    =  14,	/* commitFailed */
+  AGENTX_RES_UNDO_FAILED	    =  15,	/* undoFailed */
+  AGENTX_RES_NOT_WRITABLE	    =  17,	/* notWritable */
+  AGENTX_RES_INCONSISTENT_NAME	    =  18,	/* inconsistentName */
+  /* response error to Administrative messages */
+  AGENTX_RES_OPEN_FAILED	    = 256,	/* openFailed */
+  AGENTX_RES_NOT_OPEN		    = 257,	/* notOpen */
+  AGENTX_RES_INDEX_WRONG_TYPE	    = 258,	/* indexWrongType */
+  AGENTX_RES_INDEX_ALREADY_ALLOC    = 259,	/* indexAlreadyAlloc */
+  AGENTX_RES_INDEX_NONE_AVAIL	    = 260,	/* indexNoneAvail */
+  AGENTX_RES_NOT_ALLOCATED	    = 261,	/* notAllocated */
+  AGENTX_RES_UNSUPPORTED_CONTEXT    = 262,	/* unsupportedContext */
+  AGENTX_RES_DUPLICATE_REGISTER	    = 263,	/* duplicateRegister */
+  AGENTX_RES_UNKNOWN_REGISTER	    = 264,	/* unknownRegister */
+  AGENTX_RES_UNKNOWN_AGENT_CAPS	    = 265,	/* unknownAgentCaps */
+  AGENTX_RES_PARSE_ERROR	    = 266,	/* parseError */
+  AGENTX_RES_REQUEST_DENIED	    = 267,	/* requestDenied */
+  AGENTX_RES_PROCESSING_ERR	    = 268,	/* processingError */
+} PACKED;
+
+/* SNMP PDU info */
+struct snmp_pdu {
+  struct snmp_proto *p;
+
+  /* TX buffer */
+  byte *buffer;			    /* pointer to buffer */
+  uint size;			    /* unused space in buffer */
+
+  /* Search Range */
+  struct agentx_varbind *sr_vb_start; /* search range starting OID inside TX buffer (final storage) */
+  const struct oid *sr_o_end;	      /* search range ending OID */
+
+  /* Control */
+  enum agentx_response_errs error;  /* storage for result of current action */
+  u32 index;			    /* index on which the error was found */
+};
+
+#if 0
+struct snmp_packet_info {
+  node n;
+  u8 type; // enum type
+  u32 session_id;
+  u32 transaction_id;
+  u32 packet_id;
+  void *data;
+};
+#endif
+
+void snmp_start_subagent(struct snmp_proto *p);
+void snmp_stop_subagent(struct snmp_proto *p);
+void snmp_ping(struct snmp_proto *p);
+int snmp_rx(sock *sk, uint size);
+void snmp_tx(sock *sk);
+void snmp_register(struct snmp_proto *p, struct oid *oid, uint index, uint len, u8 is_instance);
+void snmp_unregister(struct snmp_proto *p, struct oid *oid, uint index, uint len);
+void snmp_notify_pdu(struct snmp_proto *p, struct oid *oid, void *data, uint size, int include_uptime);
+void snmp_register_mibs(struct snmp_proto *p);
+struct agentx_varbind *snmp_vb_name_to_tx(struct snmp_pdu *c, const struct oid *oid);
+int snmp_tbuf_reserve(struct snmp_pdu *c, size_t bytes);
+
+static inline int
+snmp_is_active(const struct snmp_proto *p)
+{
+  /* Note: states in which we have opened socket */
+  return p->state == SNMP_OPEN || p->state == SNMP_REGISTER ||
+      p->state == SNMP_CONN;
+}
+
+
+#endif