Adding upstream version 9.1.upstream/9.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1522 insertions, 0 deletions

diff --git a/bgpd/bgp_snmp_bgp4v2.c b/bgpd/bgp_snmp_bgp4v2.c
new file mode 100644
index 0000000..f022284
--- /dev/null
+++ b/bgpd/bgp_snmp_bgp4v2.c
@@ -0,0 +1,1522 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/* BGP4V2-MIB SNMP support
+ *
+ * Copyright (C) 2022 Donatas Abraitis <donatas@opensourcerouting.org>
+ */
+
+#include <zebra.h>
+
+#include <net-snmp/net-snmp-config.h>
+#include <net-snmp/net-snmp-includes.h>
+
+#include "if.h"
+#include "log.h"
+#include "prefix.h"
+#include "command.h"
+#include "frrevent.h"
+#include "smux.h"
+#include "filter.h"
+#include "hook.h"
+#include "libfrr.h"
+
+#include "bgpd/bgpd.h"
+#include "bgpd/bgp_table.h"
+#include "bgpd/bgp_aspath.h"
+#include "bgpd/bgp_attr.h"
+#include "bgpd/bgp_debug.h"
+#include "bgpd/bgp_route.h"
+#include "bgpd/bgp_fsm.h"
+#include "bgpd/bgp_snmp.h"
+#include "bgpd/bgp_snmp_bgp4v2.h"
+
+SNMP_LOCAL_VARIABLES
+
+static oid bgpv2_oid[] = {BGP4V2MIB};
+static struct in_addr bgp_empty_addr = {};
+
+static struct peer *peer_lookup_all_vrf(struct ipaddr *addr)
+{
+	struct bgp *bgp;
+	struct peer *peer;
+	struct listnode *node;
+	struct listnode *bgpnode;
+
+	for (ALL_LIST_ELEMENTS_RO(bm->bgp, bgpnode, bgp)) {
+		for (ALL_LIST_ELEMENTS_RO(bgp->peer, node, peer)) {
+			switch (sockunion_family(&peer->connection->su)) {
+			case AF_INET:
+				if (IPV4_ADDR_SAME(&peer->connection->su.sin
+							    .sin_addr,
+						   &addr->ip._v4_addr))
+					return peer;
+				break;
+			case AF_INET6:
+				if (IPV6_ADDR_SAME(&peer->connection->su.sin6
+							    .sin6_addr,
+						   &addr->ip._v6_addr))
+					return peer;
+				break;
+			default:
+				break;
+			}
+		}
+	}
+
+	return NULL;
+}
+
+static struct peer *peer_lookup_all_vrf_next(struct ipaddr *addr, oid *offset,
+					     sa_family_t family)
+{
+	struct bgp *bgp;
+	struct peer *peer;
+	struct peer *next_peer = NULL;
+	struct listnode *node;
+	struct listnode *bgpnode;
+
+	for (ALL_LIST_ELEMENTS_RO(bm->bgp, bgpnode, bgp)) {
+		for (ALL_LIST_ELEMENTS_RO(bgp->peer, node, peer)) {
+			sa_family_t peer_family =
+				sockunion_family(&peer->connection->su);
+
+			if (peer_family != family)
+				continue;
+
+			switch (peer_family) {
+			case AF_INET:
+				oid2in_addr(offset, IN_ADDR_SIZE,
+					    &addr->ip._v4_addr);
+				if (IPV4_ADDR_CMP(&peer->connection->su.sin
+							   .sin_addr,
+						  &addr->ip._v4_addr) < 0 ||
+				    IPV4_ADDR_SAME(&peer->connection->su.sin
+							    .sin_addr,
+						   &addr->ip._v4_addr))
+					continue;
+
+				if (!next_peer ||
+				    IPV4_ADDR_CMP(&next_peer->connection->su.sin
+							   .sin_addr,
+						  &peer->connection->su.sin
+							   .sin_addr) > 0)
+					next_peer = peer;
+
+				break;
+			case AF_INET6:
+				oid2in6_addr(offset, &addr->ip._v6_addr);
+				if (IPV6_ADDR_CMP(&peer->connection->su.sin6
+							   .sin6_addr,
+						  &addr->ip._v6_addr) < 0 ||
+				    IPV6_ADDR_SAME(&peer->connection->su.sin6
+							    .sin6_addr,
+						   &addr->ip._v6_addr))
+					continue;
+
+				if (!next_peer ||
+				    IPV6_ADDR_CMP(&next_peer->connection->su
+							   .sin6.sin6_addr,
+						  &peer->connection->su.sin6
+							   .sin6_addr) > 0)
+					next_peer = peer;
+
+				break;
+			default:
+				break;
+			}
+		}
+	}
+
+	if (next_peer)
+		return next_peer;
+
+	return NULL;
+}
+
+static struct peer *bgpv2PeerTable_lookup(struct variable *v, oid name[],
+					  size_t *length, int exact,
+					  struct ipaddr *addr)
+{
+	struct peer *peer = NULL;
+	size_t namelen = v ? v->namelen : BGP4V2_PEER_ENTRY_OFFSET;
+	oid *offset = name + namelen;
+	sa_family_t family = name[namelen - 1] == 1 ? AF_INET : AF_INET6;
+	int afi_len = IN_ADDR_SIZE;
+	size_t offsetlen = *length - namelen;
+
+	if (family == AF_INET6)
+		afi_len = IN6_ADDR_SIZE;
+
+	/* Somehow with net-snmp 5.7.3, every OID item in an array
+	 * is uninitialized and has a max random value, let's zero it.
+	 * With 5.8, 5.9, it works fine even without this hack.
+	 */
+	if (!offsetlen) {
+		for (int i = 0; i < afi_len; i++)
+			*(offset + i) = 0;
+	}
+
+	if (exact) {
+		if (family == AF_INET) {
+			oid2in_addr(offset, afi_len, &addr->ip._v4_addr);
+			peer = peer_lookup_all_vrf(addr);
+			return peer;
+		} else if (family == AF_INET6) {
+			oid2in6_addr(offset, &addr->ip._v6_addr);
+			return peer_lookup_all_vrf(addr);
+		}
+	} else {
+		peer = peer_lookup_all_vrf_next(addr, offset, family);
+		if (peer == NULL)
+			return NULL;
+
+		switch (sockunion_family(&peer->connection->su)) {
+		case AF_INET:
+			oid_copy_in_addr(offset,
+					 &peer->connection->su.sin.sin_addr);
+			*length = afi_len + namelen;
+			return peer;
+		case AF_INET6:
+			oid_copy_in6_addr(offset,
+					  &peer->connection->su.sin6.sin6_addr);
+			*length = afi_len + namelen;
+			return peer;
+		default:
+			break;
+		}
+	}
+
+	return NULL;
+}
+
+static uint8_t *bgpv2PeerTable(struct variable *v, oid name[], size_t *length,
+			       int exact, size_t *var_len,
+			       WriteMethod **write_method)
+{
+	struct peer *peer;
+	struct ipaddr addr = {};
+
+	if (smux_header_table(v, name, length, exact, var_len, write_method) ==
+	    MATCH_FAILED)
+		return NULL;
+
+	peer = bgpv2PeerTable_lookup(v, name, length, exact, &addr);
+	if (!peer)
+		return NULL;
+
+	switch (v->magic) {
+	case BGP4V2_PEER_INSTANCE:
+		return SNMP_INTEGER(peer->bgp->vrf_id);
+	case BGP4V2_PEER_LOCAL_ADDR_TYPE:
+		if (peer->su_local)
+			return SNMP_INTEGER(peer->su_local->sa.sa_family ==
+							    AF_INET
+						    ? AFI_IP
+						    : AFI_IP6);
+		else
+			return SNMP_INTEGER(0);
+	case BGP4V2_PEER_LOCAL_ADDR:
+		if (peer->su_local)
+			if (peer->su_local->sa.sa_family == AF_INET)
+				return SNMP_IPADDRESS(
+					peer->su_local->sin.sin_addr);
+			else
+				return SNMP_IP6ADDRESS(
+					peer->su_local->sin6.sin6_addr);
+		else
+			return SNMP_IPADDRESS(bgp_empty_addr);
+	case BGP4V2_PEER_REMOTE_ADDR_TYPE:
+		if (peer->su_remote)
+			return SNMP_INTEGER(peer->su_remote->sa.sa_family ==
+							    AF_INET
+						    ? AFI_IP
+						    : AFI_IP6);
+		else
+			return SNMP_INTEGER(0);
+	case BGP4V2_PEER_REMOTE_ADDR:
+		if (peer->su_remote)
+			if (peer->su_remote->sa.sa_family == AF_INET)
+				return SNMP_IPADDRESS(
+					peer->su_remote->sin.sin_addr);
+			else
+				return SNMP_IP6ADDRESS(
+					peer->su_remote->sin6.sin6_addr);
+		else
+			return SNMP_IPADDRESS(bgp_empty_addr);
+	case BGP4V2_PEER_LOCAL_PORT:
+		if (peer->su_local)
+			if (peer->su_local->sa.sa_family == AF_INET)
+				return SNMP_INTEGER(
+					ntohs(peer->su_local->sin.sin_port));
+			else
+				return SNMP_INTEGER(
+					ntohs(peer->su_local->sin6.sin6_port));
+		else
+			return SNMP_INTEGER(0);
+	case BGP4V2_PEER_LOCAL_AS:
+		return SNMP_INTEGER(peer->local_as);
+	case BGP4V2_PEER_LOCAL_IDENTIFIER:
+		return SNMP_IPADDRESS(peer->local_id);
+	case BGP4V2_PEER_REMOTE_PORT:
+		if (peer->su_remote)
+			if (peer->su_remote->sa.sa_family == AF_INET)
+				return SNMP_INTEGER(
+					ntohs(peer->su_remote->sin.sin_port));
+			else
+				return SNMP_INTEGER(
+					ntohs(peer->su_remote->sin6.sin6_port));
+		else
+			return SNMP_INTEGER(0);
+	case BGP4V2_PEER_REMOTE_AS:
+		return SNMP_INTEGER(peer->as);
+	case BGP4V2_PEER_REMOTE_IDENTIFIER:
+		return SNMP_IPADDRESS(peer->remote_id);
+	case BGP4V2_PEER_ADMIN_STATUS:
+#define BGP_PEER_ADMIN_STATUS_HALTED 1
+#define BGP_PEER_ADMIN_STATUS_RUNNING 2
+		if (BGP_PEER_START_SUPPRESSED(peer))
+			return SNMP_INTEGER(BGP_PEER_ADMIN_STATUS_HALTED);
+		else
+			return SNMP_INTEGER(BGP_PEER_ADMIN_STATUS_RUNNING);
+	case BGP4V2_PEER_STATE:
+		return SNMP_INTEGER(peer->connection->status);
+	case BGP4V2_PEER_DESCRIPTION:
+		if (peer->desc)
+			return SNMP_STRING(peer->desc);
+		break;
+	default:
+		break;
+	}
+
+	return NULL;
+}
+
+static uint8_t *bgpv2PeerErrorsTable(struct variable *v, oid name[],
+				     size_t *length, int exact, size_t *var_len,
+				     WriteMethod **write_method)
+{
+	struct peer *peer;
+	struct ipaddr addr = {};
+
+	if (smux_header_table(v, name, length, exact, var_len, write_method) ==
+	    MATCH_FAILED)
+		return NULL;
+
+	peer = bgpv2PeerTable_lookup(v, name, length, exact, &addr);
+	if (!peer)
+		return NULL;
+
+	switch (v->magic) {
+	case BGP4V2_PEER_LAST_ERROR_CODE_RECEIVED:
+		if (peer->last_reset == PEER_DOWN_NOTIFY_RECEIVED)
+			return SNMP_INTEGER(peer->notify.code);
+		else
+			return SNMP_INTEGER(0);
+	case BGP4V2_PEER_LAST_ERROR_SUBCODE_RECEIVED:
+		if (peer->last_reset == PEER_DOWN_NOTIFY_RECEIVED)
+			return SNMP_INTEGER(peer->notify.subcode);
+		else
+			return SNMP_INTEGER(0);
+	case BGP4V2_PEER_LAST_ERROR_RECEIVED_TIME:
+		if (peer->last_reset == PEER_DOWN_NOTIFY_RECEIVED)
+			return SNMP_INTEGER(peer->resettime);
+		else
+			return SNMP_INTEGER(0);
+	case BGP4V2_PEER_LAST_ERROR_RECEIVED_TEXT:
+		if (peer->last_reset == PEER_DOWN_NOTIFY_RECEIVED) {
+			struct bgp_notify notify = peer->notify;
+			char msg_buf[255];
+			const char *msg_str = NULL;
+
+			if (notify.code == BGP_NOTIFY_CEASE &&
+			    (notify.subcode ==
+				     BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN ||
+			     notify.subcode == BGP_NOTIFY_CEASE_ADMIN_RESET)) {
+				msg_str = bgp_notify_admin_message(
+					msg_buf, sizeof(msg_buf),
+					(uint8_t *)notify.data, notify.length);
+				return SNMP_STRING(msg_str);
+			}
+		}
+		return SNMP_STRING("");
+	case BGP4V2_PEER_LAST_ERROR_RECEIVED_DATA:
+		if (peer->last_reset == PEER_DOWN_NOTIFY_RECEIVED)
+			return SNMP_STRING(peer->notify.data);
+		else
+			return SNMP_STRING("");
+	case BGP4V2_PEER_LAST_ERROR_CODE_SENT:
+		if (peer->last_reset != PEER_DOWN_NOTIFY_RECEIVED)
+			return SNMP_INTEGER(peer->notify.code);
+		else
+			return SNMP_INTEGER(0);
+	case BGP4V2_PEER_LAST_ERROR_SUBCODE_SENT:
+		if (peer->last_reset != PEER_DOWN_NOTIFY_RECEIVED)
+			return SNMP_INTEGER(peer->notify.subcode);
+		else
+			return SNMP_INTEGER(0);
+	case BGP4V2_PEER_LAST_ERROR_SENT_TIME:
+		if (peer->last_reset != PEER_DOWN_NOTIFY_RECEIVED)
+			return SNMP_INTEGER(peer->resettime);
+		else
+			return SNMP_INTEGER(0);
+	case BGP4V2_PEER_LAST_ERROR_SENT_TEXT:
+		if (peer->last_reset == PEER_DOWN_NOTIFY_SEND ||
+		    peer->last_reset == PEER_DOWN_RTT_SHUTDOWN ||
+		    peer->last_reset == PEER_DOWN_USER_SHUTDOWN) {
+			struct bgp_notify notify = peer->notify;
+			char msg_buf[255];
+			const char *msg_str = NULL;
+
+			if (notify.code == BGP_NOTIFY_CEASE &&
+			    (notify.subcode ==
+				     BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN ||
+			     notify.subcode == BGP_NOTIFY_CEASE_ADMIN_RESET)) {
+				msg_str = bgp_notify_admin_message(
+					msg_buf, sizeof(msg_buf),
+					(uint8_t *)notify.data, notify.length);
+				return SNMP_STRING(msg_str);
+			}
+		}
+		return SNMP_STRING("");
+	case BGP4V2_PEER_LAST_ERROR_SENT_DATA:
+		if ((peer->last_reset == PEER_DOWN_NOTIFY_SEND ||
+		     peer->last_reset == PEER_DOWN_RTT_SHUTDOWN ||
+		     peer->last_reset == PEER_DOWN_USER_SHUTDOWN) &&
+		    peer->notify.data)
+			return SNMP_STRING(peer->notify.data);
+		else
+			return SNMP_STRING("");
+	default:
+		break;
+	}
+
+	return NULL;
+}
+
+static uint8_t *bgpv2PeerEventTimesTable(struct variable *v, oid name[],
+					 size_t *length, int exact,
+					 size_t *var_len,
+					 WriteMethod **write_method)
+{
+	struct peer *peer;
+	struct ipaddr addr = {};
+
+	if (smux_header_table(v, name, length, exact, var_len, write_method) ==
+	    MATCH_FAILED)
+		return NULL;
+
+	peer = bgpv2PeerTable_lookup(v, name, length, exact, &addr);
+	if (!peer)
+		return NULL;
+
+	switch (v->magic) {
+	case BGP4V2_PEER_FSM_ESTABLISHED_TIME:
+		if (!peer->uptime)
+			return SNMP_INTEGER(0);
+		else
+			return SNMP_INTEGER(monotime(NULL) - peer->uptime);
+	case BGP4V2_PEER_PEER_IN_UPDATES_ELAPSED_TIME:
+		if (!peer->update_time)
+			return SNMP_INTEGER(0);
+		else
+			return SNMP_INTEGER(monotime(NULL) - peer->update_time);
+	default:
+		break;
+	}
+
+	return NULL;
+}
+
+static struct bgp_path_info *
+bgp4v2PathAttrLookup(struct variable *v, oid name[], size_t *length,
+		     struct bgp *bgp, struct prefix *addr, int exact)
+{
+	oid *offset;
+	int offsetlen;
+	struct bgp_path_info *path, *min;
+	struct bgp_dest *dest;
+	union sockunion su;
+	unsigned int len;
+	struct ipaddr paddr = {};
+	size_t namelen = v ? v->namelen : BGP4V2_NLRI_ENTRY_OFFSET;
+	sa_family_t family;
+	sa_family_t min_family = 0; /* family of the selected min path */
+	afi_t afi;
+	safi_t safi;
+	size_t afi_len;
+	long prefix_type = 0;
+	long peer_addr_type = 0;
+
+	/* Bgp4V2AddressFamilyIdentifierTC limited to IPv6 */
+	if (name[namelen - 1] > IANA_AFI_IPV6)
+		return NULL;
+	afi = afi_iana2int(name[namelen - 1]);
+	afi_len = afi == AFI_IP ? IN_ADDR_SIZE : IN6_ADDR_SIZE;
+
+#define BGP_NLRI_ENTRY_OFFSET namelen
+
+
+	sockunion_init(&su);
+
+	if (exact) {
+		if (*length - namelen != BGP_NLRI_ENTRY_OFFSET)
+			return NULL;
+
+		/* Set OID offset for prefix type */
+		offset = name + namelen;
+
+		/* Bgp4V2SubsequentAddressFamilyIdentifierTC  */
+		/* limited to Labeled unicast */
+		if (*offset > IANA_SAFI_LABELED_UNICAST)
+			return NULL;
+		safi = safi_iana2int(*offset);
+		offset++;
+
+		/* get bgp4V2NlriPrefixType */
+		prefix_type = *offset;
+		offset++;
+
+		/* get bgp4V2NlriPrefix */
+		if (prefix_type == IANA_AFI_IPV4) {
+			oid2in_addr(offset, IN_ADDR_SIZE, &addr->u.prefix4);
+			addr->family = AF_INET;
+			offset += IN_ADDR_SIZE;
+		} else if (prefix_type == IANA_AFI_IPV6) {
+			oid2in6_addr(offset, &addr->u.prefix6);
+			addr->family = AF_INET6;
+			offset += IN6_ADDR_SIZE;
+		}
+
+		/* get bgp4V2NlriPrefixLen */
+		addr->prefixlen = *offset;
+		offset++;
+
+		/* get bgp4V2PeerRemoteAddrType */
+		peer_addr_type = *offset;
+		if (peer_addr_type == IANA_AFI_IPV4)
+			family = AF_INET;
+		else
+			family = AF_INET6;
+		offset++;
+
+		/* Peer address */
+		su.sin.sin_family = family;
+
+		/* get bgp4V2PeerRemoteAddr*/
+		if (family == AF_INET)
+			oid2in_addr(offset, IN_ADDR_SIZE, &su.sin.sin_addr);
+		else
+			oid2in6_addr(offset, &su.sin6.sin6_addr);
+
+		/* bgp4V2NlriIndex currently ignored */
+
+		/* Lookup node */
+		dest = bgp_node_lookup(bgp->rib[afi][safi], addr);
+		if (dest) {
+			for (path = bgp_dest_get_bgp_path_info(dest); path;
+			     path = path->next)
+				if (sockunion_same(&path->peer->connection->su,
+						   &su))
+					return path;
+
+			bgp_dest_unlock_node(dest);
+		}
+
+		return NULL;
+	}
+
+	/* Set OID offset for prefix type */
+	offset = name + namelen;
+	offsetlen = *length - namelen;
+	len = offsetlen;
+
+	if (offsetlen == 0) {
+		dest = bgp_table_top(bgp->rib[afi][SAFI_UNICAST]);
+		safi = SAFI_UNICAST;
+	} else {
+
+		/* bgp4V2NlriAfi  is already get  */
+		/* it is comming from the name parameter */
+
+		/* get bgp4V2NlriSafi */
+		/* Bgp4V2SubsequentAddressFamilyIdentifierTC */
+		/* limited to Labeled unicast */
+		if (*offset > IANA_SAFI_LABELED_UNICAST)
+			return NULL;
+		safi = safi_iana2int(*offset);
+		offset++;
+
+		/* get bgp4V2NlriPrefixType */
+		prefix_type = *offset;
+		offset++;
+		/* get bgp4V2NlriPrefix */
+		if (prefix_type == IANA_AFI_IPV4) {
+			oid2in_addr(offset, IN_ADDR_SIZE, &addr->u.prefix4);
+			addr->family = AF_INET;
+			offset += IN_ADDR_SIZE;
+			offsetlen -= IN_ADDR_SIZE;
+		} else if (prefix_type == IANA_AFI_IPV6) {
+			oid2in6_addr(offset, &addr->u.prefix6);
+			addr->family = AF_INET6;
+			offset += IN6_ADDR_SIZE;
+			offsetlen -= IN6_ADDR_SIZE;
+		}
+
+		/* get bgp4V2NlriPrefixLen */
+		if (offsetlen > 0)
+			addr->prefixlen = *offset;
+		else
+			addr->prefixlen = afi_len * 8;
+
+		offset++;
+		offsetlen--;
+
+		/* get node */
+		dest = bgp_node_get(bgp->rib[afi][safi], addr);
+	}
+
+	if (!dest)
+		return NULL;
+
+	if (offsetlen > 0) {
+		len = offsetlen;
+		if (len > afi_len)
+			len = afi_len;
+
+
+		/* get bgp4V2PeerRemoteAddrType */
+		peer_addr_type = *offset;
+		if (peer_addr_type == IANA_AFI_IPV4)
+			family = AF_INET;
+		else
+			family = AF_INET6;
+		offset++;
+
+		if (family == AF_INET)
+			oid2in_addr(offset, IN_ADDR_SIZE, &paddr.ip._v4_addr);
+		else
+			oid2in6_addr(offset, &paddr.ip._v6_addr);
+	} else {
+		/* default case  start with ipv4*/
+		if (afi == AFI_IP)
+			family = AF_INET;
+		else
+			family = AF_INET6;
+		memset(&paddr.ip, 0, sizeof(paddr.ip));
+	}
+
+	do {
+		min = NULL;
+		min_family = 0;
+
+		for (path = bgp_dest_get_bgp_path_info(dest); path;
+		     path = path->next) {
+			sa_family_t path_family =
+				sockunion_family(&path->peer->connection->su);
+			/* the next addr must be > to the current */
+			if (path_family < family)
+				continue;
+
+			if (family == AF_INET
+			    && IPV4_ADDR_CMP(&paddr.ip._v4_addr,
+					     &path->peer->connection->su.sin.sin_addr)
+				       >= 0)
+				continue;
+			else if (family == AF_INET6
+				 && IPV6_ADDR_CMP(
+					    &paddr.ip._v6_addr,
+					    &path->peer->connection->su.sin6.sin6_addr)
+					    >= 0)
+				continue;
+
+			/* first valid path its the  min*/
+			if (!min) {
+				min = path;
+				min_family = path_family;
+				continue;
+			}
+
+			/* consider path < min */
+			if (path_family < min_family) {
+				min = path;
+				min_family = path_family;
+				continue;
+			}
+
+			if (path_family == AF_INET
+			    && IPV4_ADDR_CMP(&path->peer->connection->su.sin.sin_addr,
+					     &min->peer->connection->su.sin.sin_addr)
+				       < 0) {
+				min = path;
+				min_family = path_family;
+
+			} else if (path_family == AF_INET6
+				   && IPV6_ADDR_CMP(
+					      &path->peer->connection->su.sin6.sin6_addr,
+					      &min->peer->connection->su.sin6.sin6_addr)
+					      < 0) {
+				min = path;
+				min_family = path_family;
+			}
+		}
+
+		if (min) {
+			const struct prefix *rn_p = bgp_dest_get_prefix(dest);
+
+			offset = name + namelen;
+
+			/* encode bgp4V2NlriSafi*/
+			*offset = SAFI_UNICAST;
+			offset++;
+			/* encode bgp4V2NlriPrefixType into index*/
+			/* encode  bgp4V2NlriPrefix into index */
+			if (rn_p->family == AF_INET) {
+				*offset = IANA_AFI_IPV4;
+				offset++;
+				oid_copy_in_addr(offset, &rn_p->u.prefix4);
+				offset += IN_ADDR_SIZE;
+			} else {
+				*offset = IANA_AFI_IPV6;
+				offset++;
+				oid_copy_in6_addr(offset, &rn_p->u.prefix6);
+				offset += IN6_ADDR_SIZE;
+			}
+			/* encode bgp4V2NlriPrefixLen into index*/
+			*offset = rn_p->prefixlen;
+			offset++;
+
+			/* Encode bgp4V2PeerRemoteAddrType */
+			/* Encode bgp4V2PeerRemoteAddr */
+			if (min_family == AF_INET) {
+				*offset = IANA_AFI_IPV4;
+				offset++;
+				oid_copy_in_addr(offset,
+						 &min->peer->connection->su.sin.sin_addr);
+				offset += IN_ADDR_SIZE;
+				addr->u.prefix4 = rn_p->u.prefix4;
+			} else {
+				*offset = IANA_AFI_IPV6;
+				offset++;
+				oid_copy_in6_addr(
+					offset, &min->peer->connection->su.sin6.sin6_addr);
+				offset += IN6_ADDR_SIZE;
+				addr->u.prefix6 = rn_p->u.prefix6;
+			}
+
+			/* Encode bgp4V2NlriIndex*/
+
+			*offset = 1;
+			offset++;
+
+			*length = offset - name;
+
+			addr->prefixlen = rn_p->prefixlen;
+			addr->family = rn_p->family;
+
+			bgp_dest_unlock_node(dest);
+
+			return min;
+		}
+
+		memset(&paddr.ip, 0, sizeof(paddr.ip));
+
+	} while ((dest = bgp_route_next(dest)));
+
+	return NULL;
+}
+
+static uint8_t *bgp4v2PathAttrTable(struct variable *v, oid name[],
+				    size_t *length, int exact, size_t *var_len,
+				    WriteMethod **write_method)
+{
+	struct bgp *bgp;
+	struct bgp_path_info *path;
+	struct peer_af *paf = NULL;
+	struct prefix addr = {};
+	const struct prefix *prefix = NULL;
+	enum bgp_af_index index;
+
+	bgp = bgp_get_default();
+	if (!bgp)
+		return NULL;
+
+	if (smux_header_table(v, name, length, exact, var_len, write_method) ==
+	    MATCH_FAILED)
+		return NULL;
+
+	path = bgp4v2PathAttrLookup(v, name, length, bgp, &addr, exact);
+	if (!path)
+		return NULL;
+
+	prefix = bgp_dest_get_prefix(path->net);
+
+	AF_FOREACH (index) {
+		paf = path->peer->peer_af_array[index];
+		if (paf)
+			break;
+	}
+
+	switch (v->magic) {
+	case BGP4V2_NLRI_INDEX:
+		return SNMP_INTEGER(0);
+	case BGP4V2_NLRI_AFI:
+		if (paf)
+			return SNMP_INTEGER(paf->afi);
+		else
+			return SNMP_INTEGER(0);
+	case BGP4V2_NLRI_SAFI:
+		if (paf)
+			return SNMP_INTEGER(paf->safi);
+		else
+			return SNMP_INTEGER(0);
+	case BGP4V2_NLRI_PREFIX_TYPE:
+		if (paf)
+			return SNMP_INTEGER(paf->afi);
+		else
+			return SNMP_INTEGER(0);
+	case BGP4V2_NLRI_PREFIX:
+		if (prefix->family == AF_INET6)
+			return SNMP_IP6ADDRESS(prefix->u.prefix6);
+		else
+			return SNMP_IPADDRESS(prefix->u.prefix4);
+	case BGP4V2_NLRI_PREFIX_LEN:
+		return SNMP_INTEGER(prefix->prefixlen);
+	case BGP4V2_NLRI_BEST:
+		if (CHECK_FLAG(path->flags, BGP_PATH_SELECTED))
+			return SNMP_INTEGER(1);
+		else
+			return SNMP_INTEGER(0);
+	case BGP4V2_NLRI_CALC_LOCAL_PREF:
+		if (CHECK_FLAG(path->attr->flag,
+			       ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF)))
+			return SNMP_INTEGER(path->attr->local_pref);
+		else
+			return SNMP_INTEGER(0);
+	case BGP4V2_NLRI_ORIGIN:
+		switch (path->attr->origin) {
+		case BGP_ORIGIN_IGP:
+			return SNMP_INTEGER(1);
+		case BGP_ORIGIN_EGP:
+			return SNMP_INTEGER(2);
+		case BGP_ORIGIN_INCOMPLETE:
+			return SNMP_INTEGER(3);
+		default:
+			return SNMP_INTEGER(0);
+		}
+	case BGP4V2_NLRI_NEXT_HOP_ADDR_TYPE:
+		switch (path->attr->mp_nexthop_len) {
+		case BGP_ATTR_NHLEN_IPV4:
+			return SNMP_INTEGER(1);
+		case BGP_ATTR_NHLEN_IPV6_GLOBAL:
+			return SNMP_INTEGER(2);
+		case BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL:
+			if (path->attr->mp_nexthop_prefer_global)
+				return SNMP_INTEGER(2);
+			else
+				return SNMP_INTEGER(4);
+		default:
+			return SNMP_INTEGER(1);
+		}
+	case BGP4V2_NLRI_NEXT_HOP_ADDR:
+		switch (path->attr->mp_nexthop_len) {
+		case BGP_ATTR_NHLEN_IPV4:
+			return SNMP_IPADDRESS(path->attr->mp_nexthop_global_in);
+		case BGP_ATTR_NHLEN_IPV6_GLOBAL:
+			return SNMP_IP6ADDRESS(path->attr->mp_nexthop_global);
+		case BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL:
+			if (path->attr->mp_nexthop_prefer_global)
+				return SNMP_IP6ADDRESS(
+					path->attr->mp_nexthop_global);
+			else
+				return SNMP_IP6ADDRESS(
+					path->attr->mp_nexthop_local);
+		default:
+			return SNMP_IPADDRESS(path->attr->nexthop);
+		}
+		break;
+	case BGP4V2_NLRI_LINK_LOCAL_NEXT_HOP_ADDR_TYPE:
+	case BGP4V2_NLRI_LINK_LOCAL_NEXT_HOP_ADDR:
+		/* Not properly defined in specification what should be here. */
+		break;
+	case BGP4V2_NLRI_LOCAL_PREF_PRESENT:
+		if (CHECK_FLAG(path->attr->flag,
+			       ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF)))
+			return SNMP_INTEGER(1);
+		else
+			return SNMP_INTEGER(0);
+	case BGP4V2_NLRI_LOCAL_PREF:
+		if (CHECK_FLAG(path->attr->flag,
+			       ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF)))
+			return SNMP_INTEGER(path->attr->local_pref);
+		else
+			return SNMP_INTEGER(0);
+	case BGP4V2_NLRI_MED_PRESENT:
+		if (CHECK_FLAG(path->attr->flag,
+			       ATTR_FLAG_BIT(BGP_ATTR_MULTI_EXIT_DISC)))
+			return SNMP_INTEGER(1);
+		else
+			return SNMP_INTEGER(0);
+	case BGP4V2_NLRI_MED:
+		if (CHECK_FLAG(path->attr->flag,
+			       ATTR_FLAG_BIT(BGP_ATTR_MULTI_EXIT_DISC)))
+			return SNMP_INTEGER(path->attr->med);
+		else
+			return SNMP_INTEGER(0);
+	case BGP4V2_NLRI_ATOMIC_AGGREGATE:
+		if (CHECK_FLAG(path->attr->flag,
+			       ATTR_FLAG_BIT(BGP_ATTR_ATOMIC_AGGREGATE)))
+			return SNMP_INTEGER(1);
+		else
+			return SNMP_INTEGER(0);
+	case BGP4V2_NLRI_AGGREGATOR_PRESENT:
+		if (CHECK_FLAG(path->attr->flag,
+			       ATTR_FLAG_BIT(BGP_ATTR_AGGREGATOR)))
+			return SNMP_INTEGER(1);
+		else
+			return SNMP_INTEGER(0);
+	case BGP4V2_NLRI_AGGREGATOR_AS:
+		if (CHECK_FLAG(path->attr->flag,
+			       ATTR_FLAG_BIT(BGP_ATTR_AGGREGATOR)))
+			return SNMP_INTEGER(path->attr->aggregator_as);
+		else
+			return SNMP_INTEGER(0);
+	case BGP4V2_NLRI_AGGREGATOR_ADDR:
+		if (CHECK_FLAG(path->attr->flag,
+			       ATTR_FLAG_BIT(BGP_ATTR_AGGREGATOR)))
+			return SNMP_IPADDRESS(path->attr->aggregator_addr);
+		else
+			return SNMP_IPADDRESS(bgp_empty_addr);
+	case BGP4V2_NLRI_AS_PATH_CALC_LENGTH:
+		return SNMP_INTEGER(path->attr->aspath->segments->length);
+	case BGP4V2_NLRI_AS_PATH:
+		return aspath_snmp_pathseg(path->attr->aspath, var_len);
+	case BGP4V2_NLRI_PATH_ATTR_UNKNOWN:
+		*var_len = 0;
+		return NULL;
+	}
+	return NULL;
+}
+
+static struct variable bgpv2_variables[] = {
+	/* bgp4V2PeerEntry */
+	{BGP4V2_PEER_INSTANCE,
+	 ASN_UNSIGNED,
+	 RONLY,
+	 bgpv2PeerTable,
+	 6,
+	 {1, 2, 1, BGP4V2_PEER_INSTANCE, 1, 1}},
+	{BGP4V2_PEER_INSTANCE,
+	 ASN_UNSIGNED,
+	 RONLY,
+	 bgpv2PeerTable,
+	 6,
+	 {1, 2, 1, BGP4V2_PEER_INSTANCE, 1, 2}},
+	{BGP4V2_PEER_LOCAL_ADDR_TYPE,
+	 ASN_INTEGER,
+	 RONLY,
+	 bgpv2PeerTable,
+	 6,
+	 {1, 2, 1, BGP4V2_PEER_LOCAL_ADDR_TYPE, 1, 1}},
+	{BGP4V2_PEER_LOCAL_ADDR_TYPE,
+	 ASN_INTEGER,
+	 RONLY,
+	 bgpv2PeerTable,
+	 6,
+	 {1, 2, 1, BGP4V2_PEER_LOCAL_ADDR_TYPE, 1, 2}},
+	{BGP4V2_PEER_LOCAL_ADDR,
+	 ASN_OCTET_STR,
+	 RONLY,
+	 bgpv2PeerTable,
+	 6,
+	 {1, 2, 1, BGP4V2_PEER_LOCAL_ADDR, 1, 1}},
+	{BGP4V2_PEER_LOCAL_ADDR,
+	 ASN_OCTET_STR,
+	 RONLY,
+	 bgpv2PeerTable,
+	 6,
+	 {1, 2, 1, BGP4V2_PEER_LOCAL_ADDR, 1, 2}},
+	{BGP4V2_PEER_REMOTE_ADDR_TYPE,
+	 ASN_INTEGER,
+	 RONLY,
+	 bgpv2PeerTable,
+	 6,
+	 {1, 2, 1, BGP4V2_PEER_REMOTE_ADDR_TYPE, 1, 1}},
+	{BGP4V2_PEER_REMOTE_ADDR_TYPE,
+	 ASN_INTEGER,
+	 RONLY,
+	 bgpv2PeerTable,
+	 6,
+	 {1, 2, 1, BGP4V2_PEER_REMOTE_ADDR_TYPE, 1, 2}},
+	{BGP4V2_PEER_REMOTE_ADDR,
+	 ASN_OCTET_STR,
+	 RONLY,
+	 bgpv2PeerTable,
+	 6,
+	 {1, 2, 1, BGP4V2_PEER_REMOTE_ADDR, 1, 1}},
+	{BGP4V2_PEER_REMOTE_ADDR,
+	 ASN_OCTET_STR,
+	 RONLY,
+	 bgpv2PeerTable,
+	 6,
+	 {1, 2, 1, BGP4V2_PEER_REMOTE_ADDR, 1, 2}},
+	{BGP4V2_PEER_LOCAL_PORT,
+	 ASN_UNSIGNED,
+	 RONLY,
+	 bgpv2PeerTable,
+	 6,
+	 {1, 2, 1, BGP4V2_PEER_LOCAL_PORT, 1, 1}},
+	{BGP4V2_PEER_LOCAL_PORT,
+	 ASN_UNSIGNED,
+	 RONLY,
+	 bgpv2PeerTable,
+	 6,
+	 {1, 2, 1, BGP4V2_PEER_LOCAL_PORT, 1, 2}},
+	{BGP4V2_PEER_LOCAL_AS,
+	 ASN_UNSIGNED,
+	 RONLY,
+	 bgpv2PeerTable,
+	 6,
+	 {1, 2, 1, BGP4V2_PEER_LOCAL_AS, 1, 1}},
+	{BGP4V2_PEER_LOCAL_AS,
+	 ASN_UNSIGNED,
+	 RONLY,
+	 bgpv2PeerTable,
+	 6,
+	 {1, 2, 1, BGP4V2_PEER_LOCAL_AS, 1, 2}},
+	{BGP4V2_PEER_LOCAL_IDENTIFIER,
+	 ASN_OCTET_STR,
+	 RONLY,
+	 bgpv2PeerTable,
+	 6,
+	 {1, 2, 1, BGP4V2_PEER_LOCAL_IDENTIFIER, 1, 1}},
+	{BGP4V2_PEER_LOCAL_IDENTIFIER,
+	 ASN_OCTET_STR,
+	 RONLY,
+	 bgpv2PeerTable,
+	 6,
+	 {1, 2, 1, BGP4V2_PEER_LOCAL_IDENTIFIER, 1, 2}},
+	{BGP4V2_PEER_REMOTE_PORT,
+	 ASN_UNSIGNED,
+	 RONLY,
+	 bgpv2PeerTable,
+	 6,
+	 {1, 2, 1, BGP4V2_PEER_REMOTE_PORT, 1, 1}},
+	{BGP4V2_PEER_REMOTE_PORT,
+	 ASN_UNSIGNED,
+	 RONLY,
+	 bgpv2PeerTable,
+	 6,
+	 {1, 2, 1, BGP4V2_PEER_REMOTE_PORT, 1, 2}},
+	{BGP4V2_PEER_REMOTE_AS,
+	 ASN_UNSIGNED,
+	 RONLY,
+	 bgpv2PeerTable,
+	 6,
+	 {1, 2, 1, BGP4V2_PEER_REMOTE_AS, 1, 1}},
+	{BGP4V2_PEER_REMOTE_AS,
+	 ASN_UNSIGNED,
+	 RONLY,
+	 bgpv2PeerTable,
+	 6,
+	 {1, 2, 1, BGP4V2_PEER_REMOTE_AS, 1, 2}},
+	{BGP4V2_PEER_REMOTE_IDENTIFIER,
+	 ASN_OCTET_STR,
+	 RONLY,
+	 bgpv2PeerTable,
+	 6,
+	 {1, 2, 1, BGP4V2_PEER_REMOTE_IDENTIFIER, 1, 1}},
+	{BGP4V2_PEER_REMOTE_IDENTIFIER,
+	 ASN_OCTET_STR,
+	 RONLY,
+	 bgpv2PeerTable,
+	 6,
+	 {1, 2, 1, BGP4V2_PEER_REMOTE_IDENTIFIER, 1, 2}},
+	{BGP4V2_PEER_ADMIN_STATUS,
+	 ASN_INTEGER,
+	 RONLY,
+	 bgpv2PeerTable,
+	 6,
+	 {1, 2, 1, BGP4V2_PEER_ADMIN_STATUS, 1, 1}},
+	{BGP4V2_PEER_ADMIN_STATUS,
+	 ASN_INTEGER,
+	 RONLY,
+	 bgpv2PeerTable,
+	 6,
+	 {1, 2, 1, BGP4V2_PEER_ADMIN_STATUS, 1, 2}},
+	{BGP4V2_PEER_STATE,
+	 ASN_INTEGER,
+	 RONLY,
+	 bgpv2PeerTable,
+	 6,
+	 {1, 2, 1, BGP4V2_PEER_STATE, 1, 1}},
+	{BGP4V2_PEER_STATE,
+	 ASN_INTEGER,
+	 RONLY,
+	 bgpv2PeerTable,
+	 6,
+	 {1, 2, 1, BGP4V2_PEER_STATE, 1, 2}},
+	{BGP4V2_PEER_DESCRIPTION,
+	 ASN_OCTET_STR,
+	 RONLY,
+	 bgpv2PeerTable,
+	 6,
+	 {1, 2, 1, BGP4V2_PEER_DESCRIPTION, 1, 1}},
+	{BGP4V2_PEER_DESCRIPTION,
+	 ASN_OCTET_STR,
+	 RONLY,
+	 bgpv2PeerTable,
+	 6,
+	 {1, 2, 1, BGP4V2_PEER_DESCRIPTION, 1, 2}},
+	/* bgp4V2PeerErrorsEntry */
+	{BGP4V2_PEER_LAST_ERROR_CODE_RECEIVED,
+	 ASN_UNSIGNED,
+	 RONLY,
+	 bgpv2PeerErrorsTable,
+	 6,
+	 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_CODE_RECEIVED, 1, 1}},
+	{BGP4V2_PEER_LAST_ERROR_CODE_RECEIVED,
+	 ASN_UNSIGNED,
+	 RONLY,
+	 bgpv2PeerErrorsTable,
+	 6,
+	 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_CODE_RECEIVED, 1, 2}},
+	{BGP4V2_PEER_LAST_ERROR_SUBCODE_RECEIVED,
+	 ASN_UNSIGNED,
+	 RONLY,
+	 bgpv2PeerErrorsTable,
+	 6,
+	 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_SUBCODE_RECEIVED, 1, 1}},
+	{BGP4V2_PEER_LAST_ERROR_SUBCODE_RECEIVED,
+	 ASN_UNSIGNED,
+	 RONLY,
+	 bgpv2PeerErrorsTable,
+	 6,
+	 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_SUBCODE_RECEIVED, 1, 2}},
+	{BGP4V2_PEER_LAST_ERROR_RECEIVED_TIME,
+	 ASN_TIMETICKS,
+	 RONLY,
+	 bgpv2PeerErrorsTable,
+	 6,
+	 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_RECEIVED_TIME, 1, 1}},
+	{BGP4V2_PEER_LAST_ERROR_RECEIVED_TIME,
+	 ASN_TIMETICKS,
+	 RONLY,
+	 bgpv2PeerErrorsTable,
+	 6,
+	 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_RECEIVED_TIME, 1, 2}},
+	{BGP4V2_PEER_LAST_ERROR_RECEIVED_TEXT,
+	 ASN_OCTET_STR,
+	 RONLY,
+	 bgpv2PeerErrorsTable,
+	 6,
+	 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_RECEIVED_TEXT, 1, 1}},
+	{BGP4V2_PEER_LAST_ERROR_RECEIVED_TEXT,
+	 ASN_OCTET_STR,
+	 RONLY,
+	 bgpv2PeerErrorsTable,
+	 6,
+	 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_RECEIVED_TEXT, 1, 2}},
+	{BGP4V2_PEER_LAST_ERROR_RECEIVED_DATA,
+	 ASN_OCTET_STR,
+	 RONLY,
+	 bgpv2PeerErrorsTable,
+	 6,
+	 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_RECEIVED_DATA, 1, 1}},
+	{BGP4V2_PEER_LAST_ERROR_RECEIVED_DATA,
+	 ASN_OCTET_STR,
+	 RONLY,
+	 bgpv2PeerErrorsTable,
+	 6,
+	 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_RECEIVED_DATA, 1, 2}},
+	{BGP4V2_PEER_LAST_ERROR_CODE_SENT,
+	 ASN_UNSIGNED,
+	 RONLY,
+	 bgpv2PeerErrorsTable,
+	 6,
+	 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_CODE_SENT, 1, 1}},
+	{BGP4V2_PEER_LAST_ERROR_CODE_SENT,
+	 ASN_UNSIGNED,
+	 RONLY,
+	 bgpv2PeerErrorsTable,
+	 6,
+	 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_CODE_SENT, 1, 2}},
+	{BGP4V2_PEER_LAST_ERROR_SUBCODE_SENT,
+	 ASN_UNSIGNED,
+	 RONLY,
+	 bgpv2PeerErrorsTable,
+	 6,
+	 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_SUBCODE_SENT, 1, 1}},
+	{BGP4V2_PEER_LAST_ERROR_SUBCODE_SENT,
+	 ASN_UNSIGNED,
+	 RONLY,
+	 bgpv2PeerErrorsTable,
+	 6,
+	 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_SUBCODE_SENT, 1, 2}},
+	{BGP4V2_PEER_LAST_ERROR_SENT_TIME,
+	 ASN_TIMETICKS,
+	 RONLY,
+	 bgpv2PeerErrorsTable,
+	 6,
+	 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_SENT_TIME, 1, 1}},
+	{BGP4V2_PEER_LAST_ERROR_SENT_TIME,
+	 ASN_TIMETICKS,
+	 RONLY,
+	 bgpv2PeerErrorsTable,
+	 6,
+	 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_SENT_TIME, 1, 2}},
+	{BGP4V2_PEER_LAST_ERROR_SENT_TEXT,
+	 ASN_OCTET_STR,
+	 RONLY,
+	 bgpv2PeerErrorsTable,
+	 6,
+	 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_SENT_TEXT, 1, 1}},
+	{BGP4V2_PEER_LAST_ERROR_SENT_TEXT,
+	 ASN_OCTET_STR,
+	 RONLY,
+	 bgpv2PeerErrorsTable,
+	 6,
+	 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_SENT_TEXT, 1, 2}},
+	{BGP4V2_PEER_LAST_ERROR_SENT_DATA,
+	 ASN_OCTET_STR,
+	 RONLY,
+	 bgpv2PeerErrorsTable,
+	 6,
+	 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_SENT_DATA, 1, 1}},
+	{BGP4V2_PEER_LAST_ERROR_SENT_DATA,
+	 ASN_OCTET_STR,
+	 RONLY,
+	 bgpv2PeerErrorsTable,
+	 6,
+	 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_SENT_DATA, 1, 2}},
+	/* bgp4V2PeerEventTimesEntry */
+	{BGP4V2_PEER_FSM_ESTABLISHED_TIME,
+	 ASN_UNSIGNED,
+	 RONLY,
+	 bgpv2PeerEventTimesTable,
+	 6,
+	 {1, 4, 1, BGP4V2_PEER_FSM_ESTABLISHED_TIME, 1, 1}},
+	{BGP4V2_PEER_FSM_ESTABLISHED_TIME,
+	 ASN_UNSIGNED,
+	 RONLY,
+	 bgpv2PeerEventTimesTable,
+	 6,
+	 {1, 4, 1, BGP4V2_PEER_FSM_ESTABLISHED_TIME, 1, 2}},
+	{BGP4V2_PEER_PEER_IN_UPDATES_ELAPSED_TIME,
+	 ASN_UNSIGNED,
+	 RONLY,
+	 bgpv2PeerEventTimesTable,
+	 6,
+	 {1, 4, 1, BGP4V2_PEER_PEER_IN_UPDATES_ELAPSED_TIME, 1, 1}},
+	{BGP4V2_PEER_PEER_IN_UPDATES_ELAPSED_TIME,
+	 ASN_UNSIGNED,
+	 RONLY,
+	 bgpv2PeerEventTimesTable,
+	 6,
+	 {1, 4, 1, BGP4V2_PEER_PEER_IN_UPDATES_ELAPSED_TIME, 1, 2}},
+	/* bgp4V2NlriTable */
+	{BGP4V2_NLRI_INDEX,
+	 ASN_UNSIGNED,
+	 RONLY,
+	 bgp4v2PathAttrTable,
+	 6,
+	 {1, 9, 1, BGP4V2_NLRI_INDEX, 1, 1}},
+	{BGP4V2_NLRI_INDEX,
+	 ASN_UNSIGNED,
+	 RONLY,
+	 bgp4v2PathAttrTable,
+	 6,
+	 {1, 9, 1, BGP4V2_NLRI_INDEX, 1, 2}},
+	{BGP4V2_NLRI_AFI,
+	 ASN_INTEGER,
+	 RONLY,
+	 bgp4v2PathAttrTable,
+	 6,
+	 {1, 9, 1, BGP4V2_NLRI_AFI, 1, 1}},
+	{BGP4V2_NLRI_AFI,
+	 ASN_INTEGER,
+	 RONLY,
+	 bgp4v2PathAttrTable,
+	 6,
+	 {1, 9, 1, BGP4V2_NLRI_AFI, 1, 2}},
+	{BGP4V2_NLRI_SAFI,
+	 ASN_INTEGER,
+	 RONLY,
+	 bgp4v2PathAttrTable,
+	 6,
+	 {1, 9, 1, BGP4V2_NLRI_SAFI, 1, 1}},
+	{BGP4V2_NLRI_SAFI,
+	 ASN_INTEGER,
+	 RONLY,
+	 bgp4v2PathAttrTable,
+	 6,
+	 {1, 9, 1, BGP4V2_NLRI_SAFI, 1, 2}},
+	{BGP4V2_NLRI_PREFIX_TYPE,
+	 ASN_INTEGER,
+	 RONLY,
+	 bgp4v2PathAttrTable,
+	 6,
+	 {1, 9, 1, BGP4V2_NLRI_PREFIX_TYPE, 1, 1}},
+	{BGP4V2_NLRI_PREFIX_TYPE,
+	 ASN_INTEGER,
+	 RONLY,
+	 bgp4v2PathAttrTable,
+	 6,
+	 {1, 9, 1, BGP4V2_NLRI_PREFIX_TYPE, 1, 2}},
+	{BGP4V2_NLRI_PREFIX,
+	 ASN_OCTET_STR,
+	 RONLY,
+	 bgp4v2PathAttrTable,
+	 6,
+	 {1, 9, 1, BGP4V2_NLRI_PREFIX, 1, 1}},
+	{BGP4V2_NLRI_PREFIX,
+	 ASN_OCTET_STR,
+	 RONLY,
+	 bgp4v2PathAttrTable,
+	 6,
+	 {1, 9, 1, BGP4V2_NLRI_PREFIX, 1, 2}},
+	{BGP4V2_NLRI_PREFIX_LEN,
+	 ASN_UNSIGNED,
+	 RONLY,
+	 bgp4v2PathAttrTable,
+	 6,
+	 {1, 9, 1, BGP4V2_NLRI_PREFIX_LEN, 1, 1}},
+	{BGP4V2_NLRI_PREFIX_LEN,
+	 ASN_UNSIGNED,
+	 RONLY,
+	 bgp4v2PathAttrTable,
+	 6,
+	 {1, 9, 1, BGP4V2_NLRI_PREFIX_LEN, 1, 2}},
+	{BGP4V2_NLRI_BEST,
+	 ASN_INTEGER,
+	 RONLY,
+	 bgp4v2PathAttrTable,
+	 6,
+	 {1, 9, 1, BGP4V2_NLRI_BEST, 1, 1}},
+	{BGP4V2_NLRI_BEST,
+	 ASN_INTEGER,
+	 RONLY,
+	 bgp4v2PathAttrTable,
+	 6,
+	 {1, 9, 1, BGP4V2_NLRI_BEST, 1, 2}},
+	{BGP4V2_NLRI_CALC_LOCAL_PREF,
+	 ASN_UNSIGNED,
+	 RONLY,
+	 bgp4v2PathAttrTable,
+	 6,
+	 {1, 9, 1, BGP4V2_NLRI_CALC_LOCAL_PREF, 1, 1}},
+	{BGP4V2_NLRI_CALC_LOCAL_PREF,
+	 ASN_UNSIGNED,
+	 RONLY,
+	 bgp4v2PathAttrTable,
+	 6,
+	 {1, 9, 1, BGP4V2_NLRI_CALC_LOCAL_PREF, 1, 2}},
+	{BGP4V2_NLRI_ORIGIN,
+	 ASN_INTEGER,
+	 RONLY,
+	 bgp4v2PathAttrTable,
+	 6,
+	 {1, 9, 1, BGP4V2_NLRI_ORIGIN, 1, 1}},
+	{BGP4V2_NLRI_ORIGIN,
+	 ASN_INTEGER,
+	 RONLY,
+	 bgp4v2PathAttrTable,
+	 6,
+	 {1, 9, 1, BGP4V2_NLRI_ORIGIN, 1, 2}},
+	{BGP4V2_NLRI_NEXT_HOP_ADDR_TYPE,
+	 ASN_INTEGER,
+	 RONLY,
+	 bgp4v2PathAttrTable,
+	 6,
+	 {1, 9, 1, BGP4V2_NLRI_NEXT_HOP_ADDR_TYPE, 1, 1}},
+	{BGP4V2_NLRI_NEXT_HOP_ADDR_TYPE,
+	 ASN_INTEGER,
+	 RONLY,
+	 bgp4v2PathAttrTable,
+	 6,
+	 {1, 9, 1, BGP4V2_NLRI_NEXT_HOP_ADDR_TYPE, 1, 2}},
+	{BGP4V2_NLRI_NEXT_HOP_ADDR,
+	 ASN_OCTET_STR,
+	 RONLY,
+	 bgp4v2PathAttrTable,
+	 6,
+	 {1, 9, 1, BGP4V2_NLRI_NEXT_HOP_ADDR, 1, 1}},
+	{BGP4V2_NLRI_NEXT_HOP_ADDR,
+	 ASN_OCTET_STR,
+	 RONLY,
+	 bgp4v2PathAttrTable,
+	 6,
+	 {1, 9, 1, BGP4V2_NLRI_NEXT_HOP_ADDR, 1, 2}},
+	{BGP4V2_NLRI_LINK_LOCAL_NEXT_HOP_ADDR_TYPE,
+	 ASN_INTEGER,
+	 RONLY,
+	 bgp4v2PathAttrTable,
+	 6,
+	 {1, 9, 1, BGP4V2_NLRI_LINK_LOCAL_NEXT_HOP_ADDR_TYPE, 1, 1}},
+	{BGP4V2_NLRI_LINK_LOCAL_NEXT_HOP_ADDR_TYPE,
+	 ASN_INTEGER,
+	 RONLY,
+	 bgp4v2PathAttrTable,
+	 6,
+	 {1, 9, 1, BGP4V2_NLRI_LINK_LOCAL_NEXT_HOP_ADDR_TYPE, 1, 2}},
+	{BGP4V2_NLRI_LINK_LOCAL_NEXT_HOP_ADDR,
+	 ASN_OCTET_STR,
+	 RONLY,
+	 bgp4v2PathAttrTable,
+	 6,
+	 {1, 9, 1, BGP4V2_NLRI_LINK_LOCAL_NEXT_HOP_ADDR, 1, 1}},
+	{BGP4V2_NLRI_LINK_LOCAL_NEXT_HOP_ADDR,
+	 ASN_OCTET_STR,
+	 RONLY,
+	 bgp4v2PathAttrTable,
+	 6,
+	 {1, 9, 1, BGP4V2_NLRI_LINK_LOCAL_NEXT_HOP_ADDR, 1, 2}},
+	{BGP4V2_NLRI_LOCAL_PREF_PRESENT,
+	 ASN_INTEGER,
+	 RONLY,
+	 bgp4v2PathAttrTable,
+	 6,
+	 {1, 9, 1, BGP4V2_NLRI_LOCAL_PREF_PRESENT, 1, 1}},
+	{BGP4V2_NLRI_LOCAL_PREF_PRESENT,
+	 ASN_INTEGER,
+	 RONLY,
+	 bgp4v2PathAttrTable,
+	 6,
+	 {1, 9, 1, BGP4V2_NLRI_LOCAL_PREF_PRESENT, 1, 2}},
+	{BGP4V2_NLRI_LOCAL_PREF,
+	 ASN_UNSIGNED,
+	 RONLY,
+	 bgp4v2PathAttrTable,
+	 6,
+	 {1, 9, 1, BGP4V2_NLRI_LOCAL_PREF, 1, 1}},
+	{BGP4V2_NLRI_LOCAL_PREF,
+	 ASN_UNSIGNED,
+	 RONLY,
+	 bgp4v2PathAttrTable,
+	 6,
+	 {1, 9, 1, BGP4V2_NLRI_LOCAL_PREF, 1, 2}},
+	{BGP4V2_NLRI_MED_PRESENT,
+	 ASN_INTEGER,
+	 RONLY,
+	 bgp4v2PathAttrTable,
+	 6,
+	 {1, 9, 1, BGP4V2_NLRI_MED_PRESENT, 1, 1}},
+	{BGP4V2_NLRI_MED_PRESENT,
+	 ASN_INTEGER,
+	 RONLY,
+	 bgp4v2PathAttrTable,
+	 6,
+	 {1, 9, 1, BGP4V2_NLRI_MED_PRESENT, 1, 2}},
+	{BGP4V2_NLRI_MED,
+	 ASN_UNSIGNED,
+	 RONLY,
+	 bgp4v2PathAttrTable,
+	 6,
+	 {1, 9, 1, BGP4V2_NLRI_MED, 1, 1}},
+	{BGP4V2_NLRI_MED,
+	 ASN_UNSIGNED,
+	 RONLY,
+	 bgp4v2PathAttrTable,
+	 6,
+	 {1, 9, 1, BGP4V2_NLRI_MED, 1, 2}},
+	{BGP4V2_NLRI_ATOMIC_AGGREGATE,
+	 ASN_INTEGER,
+	 RONLY,
+	 bgp4v2PathAttrTable,
+	 6,
+	 {1, 9, 1, BGP4V2_NLRI_ATOMIC_AGGREGATE, 1, 1}},
+	{BGP4V2_NLRI_ATOMIC_AGGREGATE,
+	 ASN_INTEGER,
+	 RONLY,
+	 bgp4v2PathAttrTable,
+	 6,
+	 {1, 9, 1, BGP4V2_NLRI_ATOMIC_AGGREGATE, 1, 2}},
+	{BGP4V2_NLRI_AGGREGATOR_PRESENT,
+	 ASN_INTEGER,
+	 RONLY,
+	 bgp4v2PathAttrTable,
+	 6,
+	 {1, 9, 1, BGP4V2_NLRI_AGGREGATOR_PRESENT, 1, 1}},
+	{BGP4V2_NLRI_AGGREGATOR_PRESENT,
+	 ASN_INTEGER,
+	 RONLY,
+	 bgp4v2PathAttrTable,
+	 6,
+	 {1, 9, 1, BGP4V2_NLRI_AGGREGATOR_PRESENT, 1, 2}},
+	{BGP4V2_NLRI_AGGREGATOR_AS,
+	 ASN_UNSIGNED,
+	 RONLY,
+	 bgp4v2PathAttrTable,
+	 6,
+	 {1, 9, 1, BGP4V2_NLRI_AGGREGATOR_AS, 1, 1}},
+	{BGP4V2_NLRI_AGGREGATOR_AS,
+	 ASN_UNSIGNED,
+	 RONLY,
+	 bgp4v2PathAttrTable,
+	 6,
+	 {1, 9, 1, BGP4V2_NLRI_AGGREGATOR_AS, 1, 2}},
+	{BGP4V2_NLRI_AGGREGATOR_ADDR,
+	 ASN_OCTET_STR,
+	 RONLY,
+	 bgp4v2PathAttrTable,
+	 6,
+	 {1, 9, 1, BGP4V2_NLRI_AGGREGATOR_ADDR, 1, 1}},
+	{BGP4V2_NLRI_AGGREGATOR_ADDR,
+	 ASN_OCTET_STR,
+	 RONLY,
+	 bgp4v2PathAttrTable,
+	 6,
+	 {1, 9, 1, BGP4V2_NLRI_AGGREGATOR_ADDR, 1, 2}},
+	{BGP4V2_NLRI_AS_PATH_CALC_LENGTH,
+	 ASN_UNSIGNED,
+	 RONLY,
+	 bgp4v2PathAttrTable,
+	 6,
+	 {1, 9, 1, BGP4V2_NLRI_AS_PATH_CALC_LENGTH, 1, 1}},
+	{BGP4V2_NLRI_AS_PATH_CALC_LENGTH,
+	 ASN_UNSIGNED,
+	 RONLY,
+	 bgp4v2PathAttrTable,
+	 6,
+	 {1, 9, 1, BGP4V2_NLRI_AS_PATH_CALC_LENGTH, 1, 2}},
+	{BGP4V2_NLRI_AS_PATH_STRING,
+	 ASN_OCTET_STR,
+	 RONLY,
+	 bgp4v2PathAttrTable,
+	 6,
+	 {1, 9, 1, BGP4V2_NLRI_AS_PATH_STRING, 1, 1}},
+	{BGP4V2_NLRI_AS_PATH_STRING,
+	 ASN_OCTET_STR,
+	 RONLY,
+	 bgp4v2PathAttrTable,
+	 6,
+	 {1, 9, 1, BGP4V2_NLRI_AS_PATH_STRING, 1, 2}},
+	{BGP4V2_NLRI_AS_PATH,
+	 ASN_OCTET_STR,
+	 RONLY,
+	 bgp4v2PathAttrTable,
+	 6,
+	 {1, 9, 1, BGP4V2_NLRI_AS_PATH, 1, 1}},
+	{BGP4V2_NLRI_AS_PATH,
+	 ASN_OCTET_STR,
+	 RONLY,
+	 bgp4v2PathAttrTable,
+	 6,
+	 {1, 9, 1, BGP4V2_NLRI_AS_PATH, 1, 2}},
+	{BGP4V2_NLRI_PATH_ATTR_UNKNOWN,
+	 ASN_OCTET_STR,
+	 RONLY,
+	 bgp4v2PathAttrTable,
+	 6,
+	 {1, 9, 1, BGP4V2_NLRI_PATH_ATTR_UNKNOWN, 1, 1}},
+	{BGP4V2_NLRI_PATH_ATTR_UNKNOWN,
+	 ASN_OCTET_STR,
+	 RONLY,
+	 bgp4v2PathAttrTable,
+	 6,
+	 {1, 9, 1, BGP4V2_NLRI_PATH_ATTR_UNKNOWN, 1, 2}},
+};
+
+int bgp_snmp_bgp4v2_init(struct event_loop *tm)
+{
+	REGISTER_MIB("mibII/bgpv2", bgpv2_variables, variable, bgpv2_oid);
+	return 0;
+}