bgpd/bgp_snmp_bgp4v2.c

   1 /* BGP4V2-MIB SNMP support
   2  *
   3  * Copyright (C) 2022 Donatas Abraitis <donatas@opensourcerouting.org>
   4  *
   5  * This file is part of GNU Zebra.
   6  *
   7  * GNU Zebra is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License as published by the
   9  * Free Software Foundation; either version 2, or (at your option) any
  10  * later version.
  11  *
  12  * GNU Zebra is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; see the file COPYING; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include <zebra.h>
  23
  24 #include <net-snmp/net-snmp-config.h>
  25 #include <net-snmp/net-snmp-includes.h>
  26
  27 #include "if.h"
  28 #include "log.h"
  29 #include "prefix.h"
  30 #include "command.h"
  31 #include "thread.h"
  32 #include "smux.h"
  33 #include "filter.h"
  34 #include "hook.h"
  35 #include "libfrr.h"
  36 #include "lib/version.h"
  37
  38 #include "bgpd/bgpd.h"
  39 #include "bgpd/bgp_table.h"
  40 #include "bgpd/bgp_aspath.h"
  41 #include "bgpd/bgp_attr.h"
  42 #include "bgpd/bgp_debug.h"
  43 #include "bgpd/bgp_route.h"
  44 #include "bgpd/bgp_fsm.h"
  45 #include "bgpd/bgp_snmp.h"
  46 #include "bgpd/bgp_snmp_bgp4v2.h"
  47
  48 SNMP_LOCAL_VARIABLES
  49
  50 static oid bgpv2_oid[] = {BGP4V2MIB};
  51 static struct in_addr bgp_empty_addr = {};
  52
  53 static struct peer *peer_lookup_all_vrf(struct ipaddr *addr)
  54 {
  55         struct bgp *bgp;
  56         struct peer *peer;
  57         struct listnode *node;
  58         struct listnode *bgpnode;
  59
  60         for (ALL_LIST_ELEMENTS_RO(bm->bgp, bgpnode, bgp)) {
  61                 for (ALL_LIST_ELEMENTS_RO(bgp->peer, node, peer)) {
  62                         switch (sockunion_family(&peer->su)) {
  63                         case AF_INET:
  64                                 if (IPV4_ADDR_SAME(&peer->su.sin.sin_addr,
  65                                                    &addr->ip._v4_addr))
  66                                         return peer;
  67                                 break;
  68                         case AF_INET6:
  69                                 if (IPV6_ADDR_SAME(&peer->su.sin6.sin6_addr,
  70                                                    &addr->ip._v6_addr))
  71                                         return peer;
  72                                 break;
  73                         default:
  74                                 break;
  75                         }
  76                 }
  77         }
  78
  79         return NULL;
  80 }
  81
  82 static struct peer *peer_lookup_all_vrf_next(struct ipaddr *addr, oid *offset,
  83                                              sa_family_t family)
  84 {
  85         struct bgp *bgp;
  86         struct peer *peer;
  87         struct peer *next_peer = NULL;
  88         struct listnode *node;
  89         struct listnode *bgpnode;
  90
  91         for (ALL_LIST_ELEMENTS_RO(bm->bgp, bgpnode, bgp)) {
  92                 for (ALL_LIST_ELEMENTS_RO(bgp->peer, node, peer)) {
  93                         sa_family_t peer_family = sockunion_family(&peer->su);
  94
  95                         if (peer_family != family)
  96                                 continue;
  97
  98                         switch (sockunion_family(&peer->su)) {
  99                         case AF_INET:
 100                                 oid2in_addr(offset, IN_ADDR_SIZE,
 101                                             &addr->ip._v4_addr);
 102                                 if (IPV4_ADDR_CMP(&peer->su.sin.sin_addr,
 103                                                   &addr->ip._v4_addr) < 0 ||
 104                                     IPV4_ADDR_SAME(&peer->su.sin.sin_addr,
 105                                                    &addr->ip._v4_addr))
 106                                         continue;
 107
 108                                 if (!next_peer ||
 109                                     IPV4_ADDR_CMP(&next_peer->su.sin.sin_addr,
 110                                                   &peer->su.sin.sin_addr) > 0)
 111                                         next_peer = peer;
 112
 113                                 break;
 114                         case AF_INET6:
 115                                 oid2in6_addr(offset, &addr->ip._v6_addr);
 116                                 if (IPV6_ADDR_CMP(&peer->su.sin6.sin6_addr,
 117                                                   &addr->ip._v6_addr) < 0 ||
 118                                     IPV6_ADDR_SAME(&peer->su.sin6.sin6_addr,
 119                                                    &addr->ip._v6_addr))
 120                                         continue;
 121
 122                                 if (!next_peer ||
 123                                     IPV6_ADDR_CMP(&next_peer->su.sin6.sin6_addr,
 124                                                   &peer->su.sin6.sin6_addr) > 0)
 125                                         next_peer = peer;
 126
 127                                 break;
 128                         default:
 129                                 break;
 130                         }
 131                 }
 132         }
 133
 134         if (next_peer)
 135                 return next_peer;
 136
 137         return NULL;
 138 }
 139
 140 static struct peer *bgpv2PeerTable_lookup(struct variable *v, oid name[],
 141                                           size_t *length, int exact,
 142                                           struct ipaddr *addr)
 143 {
 144         struct peer *peer = NULL;
 145         size_t namelen = v ? v->namelen : BGP4V2_PEER_ENTRY_OFFSET;
 146         oid *offset = name + namelen;
 147         sa_family_t family = name[namelen - 1] == 4 ? AF_INET : AF_INET6;
 148         int afi_len = IN_ADDR_SIZE;
 149         size_t offsetlen = *length - namelen;
 150
 151         if (family == AF_INET6)
 152                 afi_len = IN6_ADDR_SIZE;
 153
 154         /* Somehow with net-snmp 5.7.3, every OID item in an array
 155          * is uninitialized and has a max random value, let's zero it.
 156          * With 5.8, 5.9, it works fine even without this hack.
 157          */
 158         if (!offsetlen) {
 159                 for (int i = 0; i < afi_len; i++)
 160                         *(offset + i) = 0;
 161         }
 162
 163         if (exact) {
 164                 if (family == AF_INET) {
 165                         oid2in_addr(offset, afi_len, &addr->ip._v4_addr);
 166                         peer = peer_lookup_all_vrf(addr);
 167                         return peer;
 168                 } else if (family == AF_INET6) {
 169                         oid2in6_addr(offset, &addr->ip._v6_addr);
 170                         return peer_lookup_all_vrf(addr);
 171                 }
 172         } else {
 173                 peer = peer_lookup_all_vrf_next(addr, offset, family);
 174                 if (peer == NULL)
 175                         return NULL;
 176
 177                 switch (sockunion_family(&peer->su)) {
 178                 case AF_INET:
 179                         oid_copy_in_addr(offset, &peer->su.sin.sin_addr);
 180                         *length = afi_len + namelen;
 181                         return peer;
 182                 case AF_INET6:
 183                         oid_copy_in6_addr(offset, &peer->su.sin6.sin6_addr);
 184                         *length = afi_len + namelen;
 185                         return peer;
 186                 default:
 187                         break;
 188                 }
 189         }
 190
 191         return NULL;
 192 }
 193
 194 static uint8_t *bgpv2PeerTable(struct variable *v, oid name[], size_t *length,
 195                                int exact, size_t *var_len,
 196                                WriteMethod **write_method)
 197 {
 198         struct peer *peer;
 199         struct ipaddr addr = {};
 200
 201         if (smux_header_table(v, name, length, exact, var_len, write_method) ==
 202             MATCH_FAILED)
 203                 return NULL;
 204
 205         peer = bgpv2PeerTable_lookup(v, name, length, exact, &addr);
 206         if (!peer)
 207                 return NULL;
 208
 209         switch (v->magic) {
 210         case BGP4V2_PEER_INSTANCE:
 211                 return SNMP_INTEGER(peer->bgp->vrf_id);
 212         case BGP4V2_PEER_LOCAL_ADDR_TYPE:
 213                 if (peer->su_local)
 214                         return SNMP_INTEGER(peer->su_local->sa.sa_family ==
 215                                                             AF_INET
 216                                                     ? AFI_IP
 217                                                     : AFI_IP6);
 218                 else
 219                         return SNMP_INTEGER(0);
 220         case BGP4V2_PEER_LOCAL_ADDR:
 221                 if (peer->su_local)
 222                         if (peer->su_local->sa.sa_family == AF_INET)
 223                                 return SNMP_IPADDRESS(
 224                                         peer->su_local->sin.sin_addr);
 225                         else
 226                                 return SNMP_IP6ADDRESS(
 227                                         peer->su_local->sin6.sin6_addr);
 228                 else
 229                         return SNMP_IPADDRESS(bgp_empty_addr);
 230         case BGP4V2_PEER_REMOTE_ADDR_TYPE:
 231                 if (peer->su_remote)
 232                         return SNMP_INTEGER(peer->su_remote->sa.sa_family ==
 233                                                             AF_INET
 234                                                     ? AFI_IP
 235                                                     : AFI_IP6);
 236                 else
 237                         return SNMP_INTEGER(0);
 238         case BGP4V2_PEER_REMOTE_ADDR:
 239                 if (peer->su_remote)
 240                         if (peer->su_remote->sa.sa_family == AF_INET)
 241                                 return SNMP_IPADDRESS(
 242                                         peer->su_remote->sin.sin_addr);
 243                         else
 244                                 return SNMP_IP6ADDRESS(
 245                                         peer->su_remote->sin6.sin6_addr);
 246                 else
 247                         return SNMP_IPADDRESS(bgp_empty_addr);
 248         case BGP4V2_PEER_LOCAL_PORT:
 249                 if (peer->su_local)
 250                         if (peer->su_local->sa.sa_family == AF_INET)
 251                                 return SNMP_INTEGER(
 252                                         ntohs(peer->su_local->sin.sin_port));
 253                         else
 254                                 return SNMP_INTEGER(
 255                                         ntohs(peer->su_local->sin6.sin6_port));
 256                 else
 257                         return SNMP_INTEGER(0);
 258         case BGP4V2_PEER_LOCAL_AS:
 259                 return SNMP_INTEGER(peer->local_as);
 260         case BGP4V2_PEER_LOCAL_IDENTIFIER:
 261                 return SNMP_IPADDRESS(peer->local_id);
 262         case BGP4V2_PEER_REMOTE_PORT:
 263                 if (peer->su_remote)
 264                         if (peer->su_remote->sa.sa_family == AF_INET)
 265                                 return SNMP_INTEGER(
 266                                         ntohs(peer->su_remote->sin.sin_port));
 267                         else
 268                                 return SNMP_INTEGER(
 269                                         ntohs(peer->su_remote->sin6.sin6_port));
 270                 else
 271                         return SNMP_INTEGER(0);
 272         case BGP4V2_PEER_REMOTE_AS:
 273                 return SNMP_INTEGER(peer->as);
 274         case BGP4V2_PEER_REMOTE_IDENTIFIER:
 275                 return SNMP_IPADDRESS(peer->remote_id);
 276         case BGP4V2_PEER_ADMIN_STATUS:
 277 #define BGP_PEER_ADMIN_STATUS_HALTED 1
 278 #define BGP_PEER_ADMIN_STATUS_RUNNING 2
 279                 if (BGP_PEER_START_SUPPRESSED(peer))
 280                         return SNMP_INTEGER(BGP_PEER_ADMIN_STATUS_HALTED);
 281                 else
 282                         return SNMP_INTEGER(BGP_PEER_ADMIN_STATUS_RUNNING);
 283         case BGP4V2_PEER_STATE:
 284                 return SNMP_INTEGER(peer->status);
 285         case BGP4V2_PEER_DESCRIPTION:
 286                 if (peer->desc)
 287                         return SNMP_STRING(peer->desc);
 288                 break;
 289         default:
 290                 break;
 291         }
 292
 293         return NULL;
 294 }
 295
 296 static uint8_t *bgpv2PeerErrorsTable(struct variable *v, oid name[],
 297                                      size_t *length, int exact, size_t *var_len,
 298                                      WriteMethod **write_method)
 299 {
 300         struct peer *peer;
 301         struct ipaddr addr = {};
 302
 303         if (smux_header_table(v, name, length, exact, var_len, write_method) ==
 304             MATCH_FAILED)
 305                 return NULL;
 306
 307         peer = bgpv2PeerTable_lookup(v, name, length, exact, &addr);
 308         if (!peer)
 309                 return NULL;
 310
 311         switch (v->magic) {
 312         case BGP4V2_PEER_LAST_ERROR_CODE_RECEIVED:
 313                 if (peer->last_reset == PEER_DOWN_NOTIFY_RECEIVED)
 314                         return SNMP_INTEGER(peer->notify.code);
 315                 else
 316                         return SNMP_INTEGER(0);
 317         case BGP4V2_PEER_LAST_ERROR_SUBCODE_RECEIVED:
 318                 if (peer->last_reset == PEER_DOWN_NOTIFY_RECEIVED)
 319                         return SNMP_INTEGER(peer->notify.subcode);
 320                 else
 321                         return SNMP_INTEGER(0);
 322         case BGP4V2_PEER_LAST_ERROR_RECEIVED_TIME:
 323                 if (peer->last_reset == PEER_DOWN_NOTIFY_RECEIVED)
 324                         return SNMP_INTEGER(peer->resettime);
 325                 else
 326                         return SNMP_INTEGER(0);
 327         case BGP4V2_PEER_LAST_ERROR_RECEIVED_TEXT:
 328                 if (peer->last_reset == PEER_DOWN_NOTIFY_RECEIVED) {
 329                         struct bgp_notify notify = peer->notify;
 330                         char msg_buf[255];
 331                         const char *msg_str = NULL;
 332
 333                         if (notify.code == BGP_NOTIFY_CEASE &&
 334                             (notify.subcode ==
 335                                      BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN ||
 336                              notify.subcode == BGP_NOTIFY_CEASE_ADMIN_RESET)) {
 337                                 msg_str = bgp_notify_admin_message(
 338                                         msg_buf, sizeof(msg_buf),
 339                                         (uint8_t *)notify.data, notify.length);
 340                                 return SNMP_STRING(msg_str);
 341                         }
 342                 }
 343                 return SNMP_STRING("");
 344         case BGP4V2_PEER_LAST_ERROR_RECEIVED_DATA:
 345                 if (peer->last_reset == PEER_DOWN_NOTIFY_RECEIVED)
 346                         return SNMP_STRING(peer->notify.data);
 347                 else
 348                         return SNMP_STRING("");
 349         case BGP4V2_PEER_LAST_ERROR_CODE_SENT:
 350                 if (peer->last_reset != PEER_DOWN_NOTIFY_RECEIVED)
 351                         return SNMP_INTEGER(peer->notify.code);
 352                 else
 353                         return SNMP_INTEGER(0);
 354         case BGP4V2_PEER_LAST_ERROR_SUBCODE_SENT:
 355                 if (peer->last_reset != PEER_DOWN_NOTIFY_RECEIVED)
 356                         return SNMP_INTEGER(peer->notify.subcode);
 357                 else
 358                         return SNMP_INTEGER(0);
 359         case BGP4V2_PEER_LAST_ERROR_SENT_TIME:
 360                 if (peer->last_reset != PEER_DOWN_NOTIFY_RECEIVED)
 361                         return SNMP_INTEGER(peer->resettime);
 362                 else
 363                         return SNMP_INTEGER(0);
 364         case BGP4V2_PEER_LAST_ERROR_SENT_TEXT:
 365                 if (peer->last_reset == PEER_DOWN_NOTIFY_SEND ||
 366                     peer->last_reset == PEER_DOWN_RTT_SHUTDOWN ||
 367                     peer->last_reset == PEER_DOWN_USER_SHUTDOWN) {
 368                         struct bgp_notify notify = peer->notify;
 369                         char msg_buf[255];
 370                         const char *msg_str = NULL;
 371
 372                         if (notify.code == BGP_NOTIFY_CEASE &&
 373                             (notify.subcode ==
 374                                      BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN ||
 375                              notify.subcode == BGP_NOTIFY_CEASE_ADMIN_RESET)) {
 376                                 msg_str = bgp_notify_admin_message(
 377                                         msg_buf, sizeof(msg_buf),
 378                                         (uint8_t *)notify.data, notify.length);
 379                                 return SNMP_STRING(msg_str);
 380                         }
 381                 }
 382                 return SNMP_STRING("");
 383         case BGP4V2_PEER_LAST_ERROR_SENT_DATA:
 384                 if ((peer->last_reset == PEER_DOWN_NOTIFY_SEND ||
 385                      peer->last_reset == PEER_DOWN_RTT_SHUTDOWN ||
 386                      peer->last_reset == PEER_DOWN_USER_SHUTDOWN) &&
 387                     peer->notify.data)
 388                         return SNMP_STRING(peer->notify.data);
 389                 else
 390                         return SNMP_STRING("");
 391         default:
 392                 break;
 393         }
 394
 395         return NULL;
 396 }
 397
 398 static uint8_t *bgpv2PeerEventTimesTable(struct variable *v, oid name[],
 399                                          size_t *length, int exact,
 400                                          size_t *var_len,
 401                                          WriteMethod **write_method)
 402 {
 403         struct peer *peer;
 404         struct ipaddr addr = {};
 405
 406         if (smux_header_table(v, name, length, exact, var_len, write_method) ==
 407             MATCH_FAILED)
 408                 return NULL;
 409
 410         peer = bgpv2PeerTable_lookup(v, name, length, exact, &addr);
 411         if (!peer)
 412                 return NULL;
 413
 414         switch (v->magic) {
 415         case BGP4V2_PEER_FSM_ESTABLISHED_TIME:
 416                 if (!peer->uptime)
 417                         return SNMP_INTEGER(0);
 418                 else
 419                         return SNMP_INTEGER(monotime(NULL) - peer->uptime);
 420         case BGP4V2_PEER_PEER_IN_UPDATES_ELAPSED_TIME:
 421                 if (!peer->update_time)
 422                         return SNMP_INTEGER(0);
 423                 else
 424                         return SNMP_INTEGER(monotime(NULL) - peer->update_time);
 425         default:
 426                 break;
 427         }
 428
 429         return NULL;
 430 }
 431
 432 static struct bgp_path_info *
 433 bgp4v2PathAttrLookup(struct variable *v, oid name[], size_t *length,
 434                      struct bgp *bgp, struct prefix *addr, int exact)
 435 {
 436         oid *offset;
 437         int offsetlen;
 438         struct bgp_path_info *path, *min;
 439         struct bgp_dest *dest;
 440         union sockunion su;
 441         unsigned int len;
 442         struct ipaddr paddr = {};
 443         size_t namelen = v ? v->namelen : BGP4V2_NLRI_ENTRY_OFFSET;
 444         sa_family_t family = name[namelen - 1] == 4 ? AF_INET : AF_INET6;
 445         afi_t afi = AFI_IP;
 446         size_t afi_len = IN_ADDR_SIZE;
 447
 448         if (family == AF_INET6) {
 449                 afi = AFI_IP6;
 450                 afi_len = IN6_ADDR_SIZE;
 451         }
 452
 453 #define BGP_NLRI_ENTRY_OFFSET (afi_len + 1 + afi_len)
 454
 455         sockunion_init(&su);
 456
 457         if (exact) {
 458                 if (*length - namelen != BGP_NLRI_ENTRY_OFFSET)
 459                         return NULL;
 460
 461                 /* Set OID offset for prefix */
 462                 offset = name + namelen;
 463                 if (family == AF_INET)
 464                         oid2in_addr(offset, afi_len, &addr->u.prefix4);
 465                 else
 466                         oid2in6_addr(offset, &addr->u.prefix6);
 467                 offset += afi_len;
 468
 469                 /* Prefix length */
 470                 addr->prefixlen = *offset;
 471                 addr->family = family;
 472                 offset++;
 473
 474                 /* Peer address */
 475                 su.sin.sin_family = family;
 476                 if (family == AF_INET)
 477                         oid2in_addr(offset, afi_len, &su.sin.sin_addr);
 478                 else
 479                         oid2in6_addr(offset, &su.sin6.sin6_addr);
 480
 481                 /* Lookup node */
 482                 dest = bgp_node_lookup(bgp->rib[afi][SAFI_UNICAST], addr);
 483                 if (dest) {
 484                         for (path = bgp_dest_get_bgp_path_info(dest); path;
 485                              path = path->next)
 486                                 if (sockunion_same(&path->peer->su, &su))
 487                                         return path;
 488
 489                         bgp_dest_unlock_node(dest);
 490                 }
 491
 492                 return NULL;
 493         }
 494
 495         offset = name + namelen;
 496         offsetlen = *length - namelen;
 497         len = offsetlen;
 498
 499         if (offsetlen == 0) {
 500                 dest = bgp_table_top(bgp->rib[afi][SAFI_UNICAST]);
 501         } else {
 502                 if (len > afi_len)
 503                         len = afi_len;
 504
 505                 if (family == AF_INET)
 506                         oid2in_addr(offset, len, &addr->u.prefix4);
 507                 else
 508                         oid2in6_addr(offset, &addr->u.prefix6);
 509
 510                 offset += afi_len;
 511                 offsetlen -= afi_len;
 512
 513                 if (offsetlen > 0)
 514                         addr->prefixlen = *offset;
 515                 else
 516                         addr->prefixlen = len * 8;
 517
 518                 addr->family = family;
 519
 520                 dest = bgp_node_get(bgp->rib[afi][SAFI_UNICAST], addr);
 521
 522                 offset++;
 523                 offsetlen--;
 524         }
 525
 526         if (offsetlen > 0) {
 527                 len = offsetlen;
 528                 if (len > afi_len)
 529                         len = afi_len;
 530
 531                 if (family == AF_INET)
 532                         oid2in_addr(offset, len, &paddr.ip._v4_addr);
 533                 else
 534                         oid2in6_addr(offset, &paddr.ip._v6_addr);
 535         } else {
 536                 if (family == AF_INET)
 537                         memset(&paddr.ip._v4_addr, 0, afi_len);
 538                 else
 539                         memset(&paddr.ip._v6_addr, 0, afi_len);
 540         }
 541
 542         if (!dest)
 543                 return NULL;
 544
 545         do {
 546                 min = NULL;
 547
 548                 for (path = bgp_dest_get_bgp_path_info(dest); path;
 549                      path = path->next) {
 550                         sa_family_t path_family =
 551                                 sockunion_family(&path->peer->su);
 552
 553                         if (path_family == AF_INET &&
 554                             IPV4_ADDR_CMP(&paddr.ip._v4_addr,
 555                                           &path->peer->su.sin.sin_addr) < 0) {
 556                                 if (!min ||
 557                                     (min &&
 558                                      IPV4_ADDR_CMP(
 559                                              &path->peer->su.sin.sin_addr,
 560                                              &min->peer->su.sin.sin_addr) < 0))
 561                                         min = path;
 562                         } else if (path_family == AF_INET6 &&
 563                                    IPV6_ADDR_CMP(
 564                                            &paddr.ip._v6_addr,
 565                                            &path->peer->su.sin6.sin6_addr) <
 566                                            0) {
 567                                 if (!min ||
 568                                     (min &&
 569                                      IPV6_ADDR_CMP(
 570                                              &path->peer->su.sin6.sin6_addr,
 571                                              &min->peer->su.sin6.sin6_addr) <
 572                                              0))
 573                                         min = path;
 574                         }
 575                 }
 576
 577                 if (min) {
 578                         const struct prefix *rn_p = bgp_dest_get_prefix(dest);
 579
 580                         *length = namelen + BGP_NLRI_ENTRY_OFFSET;
 581
 582                         offset = name + namelen;
 583
 584                         /* Encode prefix into OID */
 585                         if (family == AF_INET)
 586                                 oid_copy_in_addr(offset, &rn_p->u.prefix4);
 587                         else
 588                                 oid_copy_in6_addr(offset, &rn_p->u.prefix6);
 589
 590                         offset += afi_len;
 591                         *offset = rn_p->prefixlen;
 592                         offset++;
 593
 594                         /* Encode peer's IP into OID */
 595                         if (family == AF_INET) {
 596                                 oid_copy_in_addr(offset,
 597                                                  &min->peer->su.sin.sin_addr);
 598                                 addr->u.prefix4 = rn_p->u.prefix4;
 599                         } else {
 600                                 oid_copy_in6_addr(
 601                                         offset, &min->peer->su.sin6.sin6_addr);
 602                                 addr->u.prefix6 = rn_p->u.prefix6;
 603                         }
 604
 605                         addr->prefixlen = rn_p->prefixlen;
 606                         addr->family = rn_p->family;
 607
 608                         bgp_dest_unlock_node(dest);
 609
 610                         return min;
 611                 }
 612
 613                 if (family == AF_INET)
 614                         memset(&paddr.ip._v4_addr, 0, afi_len);
 615                 else
 616                         memset(&paddr.ip._v6_addr, 0, afi_len);
 617         } while ((dest = bgp_route_next(dest)));
 618
 619         return NULL;
 620 }
 621
 622 static uint8_t *bgp4v2PathAttrTable(struct variable *v, oid name[],
 623                                     size_t *length, int exact, size_t *var_len,
 624                                     WriteMethod **write_method)
 625 {
 626         struct bgp *bgp;
 627         struct bgp_path_info *path;
 628         struct peer_af *paf = NULL;
 629         struct prefix addr = {};
 630         const struct prefix *prefix = NULL;
 631         enum bgp_af_index index;
 632
 633         bgp = bgp_get_default();
 634         if (!bgp)
 635                 return NULL;
 636
 637         if (smux_header_table(v, name, length, exact, var_len, write_method) ==
 638             MATCH_FAILED)
 639                 return NULL;
 640
 641         path = bgp4v2PathAttrLookup(v, name, length, bgp, &addr, exact);
 642         if (!path)
 643                 return NULL;
 644
 645         prefix = bgp_dest_get_prefix(path->net);
 646
 647         AF_FOREACH (index) {
 648                 paf = path->peer->peer_af_array[index];
 649                 if (paf)
 650                         break;
 651         }
 652
 653         switch (v->magic) {
 654         case BGP4V2_NLRI_INDEX:
 655                 return SNMP_INTEGER(0);
 656         case BGP4V2_NLRI_AFI:
 657                 if (paf)
 658                         return SNMP_INTEGER(paf->afi);
 659                 else
 660                         return SNMP_INTEGER(0);
 661         case BGP4V2_NLRI_SAFI:
 662                 if (paf)
 663                         return SNMP_INTEGER(paf->safi);
 664                 else
 665                         return SNMP_INTEGER(0);
 666         case BGP4V2_NLRI_PREFIX_TYPE:
 667                 if (paf)
 668                         return SNMP_INTEGER(paf->afi);
 669                 else
 670                         return SNMP_INTEGER(0);
 671         case BGP4V2_NLRI_PREFIX:
 672                 if (prefix->family == AF_INET6)
 673                         return SNMP_IP6ADDRESS(prefix->u.prefix6);
 674                 else
 675                         return SNMP_IPADDRESS(prefix->u.prefix4);
 676         case BGP4V2_NLRI_PREFIX_LEN:
 677                 return SNMP_INTEGER(prefix->prefixlen);
 678         case BGP4V2_NLRI_BEST:
 679                 if (CHECK_FLAG(path->flags, BGP_PATH_SELECTED))
 680                         return SNMP_INTEGER(1);
 681                 else
 682                         return SNMP_INTEGER(0);
 683         case BGP4V2_NLRI_CALC_LOCAL_PREF:
 684                 if (CHECK_FLAG(path->attr->flag,
 685                                ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF)))
 686                         return SNMP_INTEGER(path->attr->local_pref);
 687                 else
 688                         return SNMP_INTEGER(0);
 689         case BGP4V2_NLRI_ORIGIN:
 690                 switch (path->attr->origin) {
 691                 case BGP_ORIGIN_IGP:
 692                         return SNMP_INTEGER(1);
 693                 case BGP_ORIGIN_EGP:
 694                         return SNMP_INTEGER(2);
 695                 case BGP_ORIGIN_INCOMPLETE:
 696                         return SNMP_INTEGER(3);
 697                 default:
 698                         return SNMP_INTEGER(0);
 699                 }
 700         case BGP4V2_NLRI_NEXT_HOP_ADDR_TYPE:
 701                 switch (path->attr->mp_nexthop_len) {
 702                 case BGP_ATTR_NHLEN_IPV4:
 703                         return SNMP_INTEGER(1);
 704                 case BGP_ATTR_NHLEN_IPV6_GLOBAL:
 705                         return SNMP_INTEGER(2);
 706                 case BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL:
 707                         if (path->attr->mp_nexthop_prefer_global)
 708                                 return SNMP_INTEGER(2);
 709                         else
 710                                 return SNMP_INTEGER(4);
 711                 default:
 712                         return SNMP_INTEGER(1);
 713                 }
 714         case BGP4V2_NLRI_NEXT_HOP_ADDR:
 715                 switch (path->attr->mp_nexthop_len) {
 716                 case BGP_ATTR_NHLEN_IPV4:
 717                         return SNMP_IPADDRESS(path->attr->mp_nexthop_global_in);
 718                 case BGP_ATTR_NHLEN_IPV6_GLOBAL:
 719                         return SNMP_IP6ADDRESS(path->attr->mp_nexthop_global);
 720                 case BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL:
 721                         if (path->attr->mp_nexthop_prefer_global)
 722                                 return SNMP_IP6ADDRESS(
 723                                         path->attr->mp_nexthop_global);
 724                         else
 725                                 return SNMP_IP6ADDRESS(
 726                                         path->attr->mp_nexthop_local);
 727                 default:
 728                         return SNMP_IPADDRESS(path->attr->nexthop);
 729                 }
 730                 break;
 731         case BGP4V2_NLRI_LINK_LOCAL_NEXT_HOP_ADDR_TYPE:
 732         case BGP4V2_NLRI_LINK_LOCAL_NEXT_HOP_ADDR:
 733                 /* Not properly defined in specification what should be here. */
 734                 break;
 735         case BGP4V2_NLRI_LOCAL_PREF_PRESENT:
 736                 if (CHECK_FLAG(path->attr->flag,
 737                                ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF)))
 738                         return SNMP_INTEGER(1);
 739                 else
 740                         return SNMP_INTEGER(0);
 741         case BGP4V2_NLRI_LOCAL_PREF:
 742                 if (CHECK_FLAG(path->attr->flag,
 743                                ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF)))
 744                         return SNMP_INTEGER(path->attr->local_pref);
 745                 else
 746                         return SNMP_INTEGER(0);
 747         case BGP4V2_NLRI_MED_PRESENT:
 748                 if (CHECK_FLAG(path->attr->flag,
 749                                ATTR_FLAG_BIT(BGP_ATTR_MULTI_EXIT_DISC)))
 750                         return SNMP_INTEGER(1);
 751                 else
 752                         return SNMP_INTEGER(0);
 753         case BGP4V2_NLRI_MED:
 754                 if (CHECK_FLAG(path->attr->flag,
 755                                ATTR_FLAG_BIT(BGP_ATTR_MULTI_EXIT_DISC)))
 756                         return SNMP_INTEGER(path->attr->med);
 757                 else
 758                         return SNMP_INTEGER(0);
 759         case BGP4V2_NLRI_ATOMIC_AGGREGATE:
 760                 if (CHECK_FLAG(path->attr->flag,
 761                                ATTR_FLAG_BIT(BGP_ATTR_ATOMIC_AGGREGATE)))
 762                         return SNMP_INTEGER(1);
 763                 else
 764                         return SNMP_INTEGER(0);
 765         case BGP4V2_NLRI_AGGREGATOR_PRESENT:
 766                 if (CHECK_FLAG(path->attr->flag,
 767                                ATTR_FLAG_BIT(BGP_ATTR_AGGREGATOR)))
 768                         return SNMP_INTEGER(1);
 769                 else
 770                         return SNMP_INTEGER(0);
 771         case BGP4V2_NLRI_AGGREGATOR_AS:
 772                 if (CHECK_FLAG(path->attr->flag,
 773                                ATTR_FLAG_BIT(BGP_ATTR_AGGREGATOR)))
 774                         return SNMP_INTEGER(path->attr->aggregator_as);
 775                 else
 776                         return SNMP_INTEGER(0);
 777         case BGP4V2_NLRI_AGGREGATOR_ADDR:
 778                 if (CHECK_FLAG(path->attr->flag,
 779                                ATTR_FLAG_BIT(BGP_ATTR_AGGREGATOR)))
 780                         return SNMP_IPADDRESS(path->attr->aggregator_addr);
 781                 else
 782                         return SNMP_IPADDRESS(bgp_empty_addr);
 783         case BGP4V2_NLRI_AS_PATH_CALC_LENGTH:
 784                 return SNMP_INTEGER(path->attr->aspath->segments->length);
 785         case BGP4V2_NLRI_AS_PATH:
 786                 return aspath_snmp_pathseg(path->attr->aspath, var_len);
 787         case BGP4V2_NLRI_PATH_ATTR_UNKNOWN:
 788                 *var_len = 0;
 789                 return NULL;
 790         }
 791         return NULL;
 792 }
 793
 794 static struct variable bgpv2_variables[] = {
 795         /* bgp4V2PeerEntry */
 796         {BGP4V2_PEER_INSTANCE,
 797          ASN_UNSIGNED,
 798          RONLY,
 799          bgpv2PeerTable,
 800          6,
 801          {1, 2, 1, BGP4V2_PEER_INSTANCE, 1, 4}},
 802         {BGP4V2_PEER_INSTANCE,
 803          ASN_UNSIGNED,
 804          RONLY,
 805          bgpv2PeerTable,
 806          6,
 807          {1, 2, 1, BGP4V2_PEER_INSTANCE, 2, 16}},
 808         {BGP4V2_PEER_LOCAL_ADDR_TYPE,
 809          ASN_INTEGER,
 810          RONLY,
 811          bgpv2PeerTable,
 812          6,
 813          {1, 2, 1, BGP4V2_PEER_LOCAL_ADDR_TYPE, 1, 4}},
 814         {BGP4V2_PEER_LOCAL_ADDR_TYPE,
 815          ASN_INTEGER,
 816          RONLY,
 817          bgpv2PeerTable,
 818          6,
 819          {1, 2, 1, BGP4V2_PEER_LOCAL_ADDR_TYPE, 2, 16}},
 820         {BGP4V2_PEER_LOCAL_ADDR,
 821          ASN_OCTET_STR,
 822          RONLY,
 823          bgpv2PeerTable,
 824          6,
 825          {1, 2, 1, BGP4V2_PEER_LOCAL_ADDR, 1, 4}},
 826         {BGP4V2_PEER_LOCAL_ADDR,
 827          ASN_OCTET_STR,
 828          RONLY,
 829          bgpv2PeerTable,
 830          6,
 831          {1, 2, 1, BGP4V2_PEER_LOCAL_ADDR, 2, 16}},
 832         {BGP4V2_PEER_REMOTE_ADDR_TYPE,
 833          ASN_INTEGER,
 834          RONLY,
 835          bgpv2PeerTable,
 836          6,
 837          {1, 2, 1, BGP4V2_PEER_REMOTE_ADDR_TYPE, 1, 4}},
 838         {BGP4V2_PEER_REMOTE_ADDR_TYPE,
 839          ASN_INTEGER,
 840          RONLY,
 841          bgpv2PeerTable,
 842          6,
 843          {1, 2, 1, BGP4V2_PEER_REMOTE_ADDR_TYPE, 2, 16}},
 844         {BGP4V2_PEER_REMOTE_ADDR,
 845          ASN_OCTET_STR,
 846          RONLY,
 847          bgpv2PeerTable,
 848          6,
 849          {1, 2, 1, BGP4V2_PEER_REMOTE_ADDR, 1, 4}},
 850         {BGP4V2_PEER_REMOTE_ADDR,
 851          ASN_OCTET_STR,
 852          RONLY,
 853          bgpv2PeerTable,
 854          6,
 855          {1, 2, 1, BGP4V2_PEER_REMOTE_ADDR, 2, 16}},
 856         {BGP4V2_PEER_LOCAL_PORT,
 857          ASN_UNSIGNED,
 858          RONLY,
 859          bgpv2PeerTable,
 860          6,
 861          {1, 2, 1, BGP4V2_PEER_LOCAL_PORT, 1, 4}},
 862         {BGP4V2_PEER_LOCAL_PORT,
 863          ASN_UNSIGNED,
 864          RONLY,
 865          bgpv2PeerTable,
 866          6,
 867          {1, 2, 1, BGP4V2_PEER_LOCAL_PORT, 2, 16}},
 868         {BGP4V2_PEER_LOCAL_AS,
 869          ASN_UNSIGNED,
 870          RONLY,
 871          bgpv2PeerTable,
 872          6,
 873          {1, 2, 1, BGP4V2_PEER_LOCAL_AS, 1, 4}},
 874         {BGP4V2_PEER_LOCAL_AS,
 875          ASN_UNSIGNED,
 876          RONLY,
 877          bgpv2PeerTable,
 878          6,
 879          {1, 2, 1, BGP4V2_PEER_LOCAL_AS, 2, 16}},
 880         {BGP4V2_PEER_LOCAL_IDENTIFIER,
 881          ASN_OCTET_STR,
 882          RONLY,
 883          bgpv2PeerTable,
 884          6,
 885          {1, 2, 1, BGP4V2_PEER_LOCAL_IDENTIFIER, 1, 4}},
 886         {BGP4V2_PEER_LOCAL_IDENTIFIER,
 887          ASN_OCTET_STR,
 888          RONLY,
 889          bgpv2PeerTable,
 890          6,
 891          {1, 2, 1, BGP4V2_PEER_LOCAL_IDENTIFIER, 2, 16}},
 892         {BGP4V2_PEER_REMOTE_PORT,
 893          ASN_UNSIGNED,
 894          RONLY,
 895          bgpv2PeerTable,
 896          6,
 897          {1, 2, 1, BGP4V2_PEER_REMOTE_PORT, 1, 4}},
 898         {BGP4V2_PEER_REMOTE_PORT,
 899          ASN_UNSIGNED,
 900          RONLY,
 901          bgpv2PeerTable,
 902          6,
 903          {1, 2, 1, BGP4V2_PEER_REMOTE_PORT, 2, 16}},
 904         {BGP4V2_PEER_REMOTE_AS,
 905          ASN_UNSIGNED,
 906          RONLY,
 907          bgpv2PeerTable,
 908          6,
 909          {1, 2, 1, BGP4V2_PEER_REMOTE_AS, 1, 4}},
 910         {BGP4V2_PEER_REMOTE_AS,
 911          ASN_UNSIGNED,
 912          RONLY,
 913          bgpv2PeerTable,
 914          6,
 915          {1, 2, 1, BGP4V2_PEER_REMOTE_AS, 2, 16}},
 916         {BGP4V2_PEER_REMOTE_IDENTIFIER,
 917          ASN_OCTET_STR,
 918          RONLY,
 919          bgpv2PeerTable,
 920          6,
 921          {1, 2, 1, BGP4V2_PEER_REMOTE_IDENTIFIER, 1, 4}},
 922         {BGP4V2_PEER_REMOTE_IDENTIFIER,
 923          ASN_OCTET_STR,
 924          RONLY,
 925          bgpv2PeerTable,
 926          6,
 927          {1, 2, 1, BGP4V2_PEER_REMOTE_IDENTIFIER, 2, 16}},
 928         {BGP4V2_PEER_ADMIN_STATUS,
 929          ASN_INTEGER,
 930          RONLY,
 931          bgpv2PeerTable,
 932          6,
 933          {1, 2, 1, BGP4V2_PEER_ADMIN_STATUS, 1, 4}},
 934         {BGP4V2_PEER_ADMIN_STATUS,
 935          ASN_INTEGER,
 936          RONLY,
 937          bgpv2PeerTable,
 938          6,
 939          {1, 2, 1, BGP4V2_PEER_ADMIN_STATUS, 2, 16}},
 940         {BGP4V2_PEER_STATE,
 941          ASN_INTEGER,
 942          RONLY,
 943          bgpv2PeerTable,
 944          6,
 945          {1, 2, 1, BGP4V2_PEER_STATE, 1, 4}},
 946         {BGP4V2_PEER_STATE,
 947          ASN_INTEGER,
 948          RONLY,
 949          bgpv2PeerTable,
 950          6,
 951          {1, 2, 1, BGP4V2_PEER_STATE, 2, 16}},
 952         {BGP4V2_PEER_DESCRIPTION,
 953          ASN_OCTET_STR,
 954          RONLY,
 955          bgpv2PeerTable,
 956          6,
 957          {1, 2, 1, BGP4V2_PEER_DESCRIPTION, 1, 4}},
 958         {BGP4V2_PEER_DESCRIPTION,
 959          ASN_OCTET_STR,
 960          RONLY,
 961          bgpv2PeerTable,
 962          6,
 963          {1, 2, 1, BGP4V2_PEER_DESCRIPTION, 2, 16}},
 964         /* bgp4V2PeerErrorsEntry */
 965         {BGP4V2_PEER_LAST_ERROR_CODE_RECEIVED,
 966          ASN_UNSIGNED,
 967          RONLY,
 968          bgpv2PeerErrorsTable,
 969          6,
 970          {1, 3, 1, BGP4V2_PEER_LAST_ERROR_CODE_RECEIVED, 1, 4}},
 971         {BGP4V2_PEER_LAST_ERROR_CODE_RECEIVED,
 972          ASN_UNSIGNED,
 973          RONLY,
 974          bgpv2PeerErrorsTable,
 975          6,
 976          {1, 3, 1, BGP4V2_PEER_LAST_ERROR_CODE_RECEIVED, 2, 16}},
 977         {BGP4V2_PEER_LAST_ERROR_SUBCODE_RECEIVED,
 978          ASN_UNSIGNED,
 979          RONLY,
 980          bgpv2PeerErrorsTable,
 981          6,
 982          {1, 3, 1, BGP4V2_PEER_LAST_ERROR_SUBCODE_RECEIVED, 1, 4}},
 983         {BGP4V2_PEER_LAST_ERROR_SUBCODE_RECEIVED,
 984          ASN_UNSIGNED,
 985          RONLY,
 986          bgpv2PeerErrorsTable,
 987          6,
 988          {1, 3, 1, BGP4V2_PEER_LAST_ERROR_SUBCODE_RECEIVED, 2, 16}},
 989         {BGP4V2_PEER_LAST_ERROR_RECEIVED_TIME,
 990          ASN_UNSIGNED,
 991          RONLY,
 992          bgpv2PeerErrorsTable,
 993          6,
 994          {1, 3, 1, BGP4V2_PEER_LAST_ERROR_RECEIVED_TIME, 1, 4}},
 995         {BGP4V2_PEER_LAST_ERROR_RECEIVED_TIME,
 996          ASN_UNSIGNED,
 997          RONLY,
 998          bgpv2PeerErrorsTable,
 999          6,
1000          {1, 3, 1, BGP4V2_PEER_LAST_ERROR_RECEIVED_TIME, 2, 16}},
1001         {BGP4V2_PEER_LAST_ERROR_RECEIVED_TEXT,
1002          ASN_OCTET_STR,
1003          RONLY,
1004          bgpv2PeerErrorsTable,
1005          6,
1006          {1, 3, 1, BGP4V2_PEER_LAST_ERROR_RECEIVED_TEXT, 1, 4}},
1007         {BGP4V2_PEER_LAST_ERROR_RECEIVED_TEXT,
1008          ASN_OCTET_STR,
1009          RONLY,
1010          bgpv2PeerErrorsTable,
1011          6,
1012          {1, 3, 1, BGP4V2_PEER_LAST_ERROR_RECEIVED_TEXT, 2, 16}},
1013         {BGP4V2_PEER_LAST_ERROR_RECEIVED_DATA,
1014          ASN_OCTET_STR,
1015          RONLY,
1016          bgpv2PeerErrorsTable,
1017          6,
1018          {1, 3, 1, BGP4V2_PEER_LAST_ERROR_RECEIVED_DATA, 1, 4}},
1019         {BGP4V2_PEER_LAST_ERROR_RECEIVED_DATA,
1020          ASN_OCTET_STR,
1021          RONLY,
1022          bgpv2PeerErrorsTable,
1023          6,
1024          {1, 3, 1, BGP4V2_PEER_LAST_ERROR_RECEIVED_DATA, 2, 16}},
1025         {BGP4V2_PEER_LAST_ERROR_CODE_SENT,
1026          ASN_UNSIGNED,
1027          RONLY,
1028          bgpv2PeerErrorsTable,
1029          6,
1030          {1, 3, 1, BGP4V2_PEER_LAST_ERROR_CODE_SENT, 1, 4}},
1031         {BGP4V2_PEER_LAST_ERROR_CODE_SENT,
1032          ASN_UNSIGNED,
1033          RONLY,
1034          bgpv2PeerErrorsTable,
1035          6,
1036          {1, 3, 1, BGP4V2_PEER_LAST_ERROR_CODE_SENT, 2, 16}},
1037         {BGP4V2_PEER_LAST_ERROR_SUBCODE_SENT,
1038          ASN_UNSIGNED,
1039          RONLY,
1040          bgpv2PeerErrorsTable,
1041          6,
1042          {1, 3, 1, BGP4V2_PEER_LAST_ERROR_SUBCODE_SENT, 1, 4}},
1043         {BGP4V2_PEER_LAST_ERROR_SUBCODE_SENT,
1044          ASN_UNSIGNED,
1045          RONLY,
1046          bgpv2PeerErrorsTable,
1047          6,
1048          {1, 3, 1, BGP4V2_PEER_LAST_ERROR_SUBCODE_SENT, 2, 16}},
1049         {BGP4V2_PEER_LAST_ERROR_SENT_TIME,
1050          ASN_UNSIGNED,
1051          RONLY,
1052          bgpv2PeerErrorsTable,
1053          6,
1054          {1, 3, 1, BGP4V2_PEER_LAST_ERROR_SENT_TIME, 1, 4}},
1055         {BGP4V2_PEER_LAST_ERROR_SENT_TIME,
1056          ASN_UNSIGNED,
1057          RONLY,
1058          bgpv2PeerErrorsTable,
1059          6,
1060          {1, 3, 1, BGP4V2_PEER_LAST_ERROR_SENT_TIME, 2, 16}},
1061         {BGP4V2_PEER_LAST_ERROR_SENT_TEXT,
1062          ASN_OCTET_STR,
1063          RONLY,
1064          bgpv2PeerErrorsTable,
1065          6,
1066          {1, 3, 1, BGP4V2_PEER_LAST_ERROR_SENT_TEXT, 1, 4}},
1067         {BGP4V2_PEER_LAST_ERROR_SENT_TEXT,
1068          ASN_OCTET_STR,
1069          RONLY,
1070          bgpv2PeerErrorsTable,
1071          6,
1072          {1, 3, 1, BGP4V2_PEER_LAST_ERROR_SENT_TEXT, 2, 16}},
1073         {BGP4V2_PEER_LAST_ERROR_SENT_DATA,
1074          ASN_OCTET_STR,
1075          RONLY,
1076          bgpv2PeerErrorsTable,
1077          6,
1078          {1, 3, 1, BGP4V2_PEER_LAST_ERROR_SENT_DATA, 1, 4}},
1079         {BGP4V2_PEER_LAST_ERROR_SENT_DATA,
1080          ASN_OCTET_STR,
1081          RONLY,
1082          bgpv2PeerErrorsTable,
1083          6,
1084          {1, 3, 1, BGP4V2_PEER_LAST_ERROR_SENT_DATA, 2, 16}},
1085         /* bgp4V2PeerEventTimesEntry */
1086         {BGP4V2_PEER_FSM_ESTABLISHED_TIME,
1087          ASN_UNSIGNED,
1088          RONLY,
1089          bgpv2PeerEventTimesTable,
1090          6,
1091          {1, 4, 1, BGP4V2_PEER_FSM_ESTABLISHED_TIME, 1, 4}},
1092         {BGP4V2_PEER_FSM_ESTABLISHED_TIME,
1093          ASN_UNSIGNED,
1094          RONLY,
1095          bgpv2PeerEventTimesTable,
1096          6,
1097          {1, 4, 1, BGP4V2_PEER_FSM_ESTABLISHED_TIME, 2, 16}},
1098         {BGP4V2_PEER_PEER_IN_UPDATES_ELAPSED_TIME,
1099          ASN_UNSIGNED,
1100          RONLY,
1101          bgpv2PeerEventTimesTable,
1102          6,
1103          {1, 4, 1, BGP4V2_PEER_PEER_IN_UPDATES_ELAPSED_TIME, 1, 4}},
1104         {BGP4V2_PEER_PEER_IN_UPDATES_ELAPSED_TIME,
1105          ASN_UNSIGNED,
1106          RONLY,
1107          bgpv2PeerEventTimesTable,
1108          6,
1109          {1, 4, 1, BGP4V2_PEER_PEER_IN_UPDATES_ELAPSED_TIME, 2, 16}},
1110         /* bgp4V2NlriTable */
1111         {BGP4V2_NLRI_INDEX,
1112          ASN_UNSIGNED,
1113          RONLY,
1114          bgp4v2PathAttrTable,
1115          6,
1116          {1, 9, 1, BGP4V2_NLRI_INDEX, 1, 4}},
1117         {BGP4V2_NLRI_INDEX,
1118          ASN_UNSIGNED,
1119          RONLY,
1120          bgp4v2PathAttrTable,
1121          6,
1122          {1, 9, 1, BGP4V2_NLRI_INDEX, 2, 16}},
1123         {BGP4V2_NLRI_AFI,
1124          ASN_INTEGER,
1125          RONLY,
1126          bgp4v2PathAttrTable,
1127          6,
1128          {1, 9, 1, BGP4V2_NLRI_AFI, 1, 4}},
1129         {BGP4V2_NLRI_AFI,
1130          ASN_INTEGER,
1131          RONLY,
1132          bgp4v2PathAttrTable,
1133          6,
1134          {1, 9, 1, BGP4V2_NLRI_AFI, 2, 16}},
1135         {BGP4V2_NLRI_SAFI,
1136          ASN_INTEGER,
1137          RONLY,
1138          bgp4v2PathAttrTable,
1139          6,
1140          {1, 9, 1, BGP4V2_NLRI_SAFI, 1, 4}},
1141         {BGP4V2_NLRI_SAFI,
1142          ASN_INTEGER,
1143          RONLY,
1144          bgp4v2PathAttrTable,
1145          6,
1146          {1, 9, 1, BGP4V2_NLRI_SAFI, 2, 16}},
1147         {BGP4V2_NLRI_PREFIX_TYPE,
1148          ASN_INTEGER,
1149          RONLY,
1150          bgp4v2PathAttrTable,
1151          6,
1152          {1, 9, 1, BGP4V2_NLRI_PREFIX_TYPE, 1, 4}},
1153         {BGP4V2_NLRI_PREFIX_TYPE,
1154          ASN_INTEGER,
1155          RONLY,
1156          bgp4v2PathAttrTable,
1157          6,
1158          {1, 9, 1, BGP4V2_NLRI_PREFIX_TYPE, 2, 16}},
1159         {BGP4V2_NLRI_PREFIX,
1160          ASN_OCTET_STR,
1161          RONLY,
1162          bgp4v2PathAttrTable,
1163          6,
1164          {1, 9, 1, BGP4V2_NLRI_PREFIX, 1, 4}},
1165         {BGP4V2_NLRI_PREFIX,
1166          ASN_OCTET_STR,
1167          RONLY,
1168          bgp4v2PathAttrTable,
1169          6,
1170          {1, 9, 1, BGP4V2_NLRI_PREFIX, 2, 16}},
1171         {BGP4V2_NLRI_PREFIX_LEN,
1172          ASN_UNSIGNED,
1173          RONLY,
1174          bgp4v2PathAttrTable,
1175          6,
1176          {1, 9, 1, BGP4V2_NLRI_PREFIX_LEN, 1, 4}},
1177         {BGP4V2_NLRI_PREFIX_LEN,
1178          ASN_UNSIGNED,
1179          RONLY,
1180          bgp4v2PathAttrTable,
1181          6,
1182          {1, 9, 1, BGP4V2_NLRI_PREFIX_LEN, 2, 16}},
1183         {BGP4V2_NLRI_BEST,
1184          ASN_INTEGER,
1185          RONLY,
1186          bgp4v2PathAttrTable,
1187          6,
1188          {1, 9, 1, BGP4V2_NLRI_BEST, 1, 4}},
1189         {BGP4V2_NLRI_BEST,
1190          ASN_INTEGER,
1191          RONLY,
1192          bgp4v2PathAttrTable,
1193          6,
1194          {1, 9, 1, BGP4V2_NLRI_BEST, 2, 16}},
1195         {BGP4V2_NLRI_CALC_LOCAL_PREF,
1196          ASN_UNSIGNED,
1197          RONLY,
1198          bgp4v2PathAttrTable,
1199          6,
1200          {1, 9, 1, BGP4V2_NLRI_CALC_LOCAL_PREF, 1, 4}},
1201         {BGP4V2_NLRI_CALC_LOCAL_PREF,
1202          ASN_UNSIGNED,
1203          RONLY,
1204          bgp4v2PathAttrTable,
1205          6,
1206          {1, 9, 1, BGP4V2_NLRI_CALC_LOCAL_PREF, 2, 16}},
1207         {BGP4V2_NLRI_ORIGIN,
1208          ASN_INTEGER,
1209          RONLY,
1210          bgp4v2PathAttrTable,
1211          6,
1212          {1, 9, 1, BGP4V2_NLRI_ORIGIN, 1, 4}},
1213         {BGP4V2_NLRI_ORIGIN,
1214          ASN_INTEGER,
1215          RONLY,
1216          bgp4v2PathAttrTable,
1217          6,
1218          {1, 9, 1, BGP4V2_NLRI_ORIGIN, 2, 16}},
1219         {BGP4V2_NLRI_NEXT_HOP_ADDR_TYPE,
1220          ASN_INTEGER,
1221          RONLY,
1222          bgp4v2PathAttrTable,
1223          6,
1224          {1, 9, 1, BGP4V2_NLRI_NEXT_HOP_ADDR_TYPE, 1, 4}},
1225         {BGP4V2_NLRI_NEXT_HOP_ADDR_TYPE,
1226          ASN_INTEGER,
1227          RONLY,
1228          bgp4v2PathAttrTable,
1229          6,
1230          {1, 9, 1, BGP4V2_NLRI_NEXT_HOP_ADDR_TYPE, 2, 16}},
1231         {BGP4V2_NLRI_NEXT_HOP_ADDR,
1232          ASN_OCTET_STR,
1233          RONLY,
1234          bgp4v2PathAttrTable,
1235          6,
1236          {1, 9, 1, BGP4V2_NLRI_NEXT_HOP_ADDR, 1, 4}},
1237         {BGP4V2_NLRI_NEXT_HOP_ADDR,
1238          ASN_OCTET_STR,
1239          RONLY,
1240          bgp4v2PathAttrTable,
1241          6,
1242          {1, 9, 1, BGP4V2_NLRI_NEXT_HOP_ADDR, 2, 16}},
1243         {BGP4V2_NLRI_LINK_LOCAL_NEXT_HOP_ADDR_TYPE,
1244          ASN_INTEGER,
1245          RONLY,
1246          bgp4v2PathAttrTable,
1247          6,
1248          {1, 9, 1, BGP4V2_NLRI_LINK_LOCAL_NEXT_HOP_ADDR_TYPE, 1, 4}},
1249         {BGP4V2_NLRI_LINK_LOCAL_NEXT_HOP_ADDR_TYPE,
1250          ASN_INTEGER,
1251          RONLY,
1252          bgp4v2PathAttrTable,
1253          6,
1254          {1, 9, 1, BGP4V2_NLRI_LINK_LOCAL_NEXT_HOP_ADDR_TYPE, 2, 16}},
1255         {BGP4V2_NLRI_LINK_LOCAL_NEXT_HOP_ADDR,
1256          ASN_OCTET_STR,
1257          RONLY,
1258          bgp4v2PathAttrTable,
1259          6,
1260          {1, 9, 1, BGP4V2_NLRI_LINK_LOCAL_NEXT_HOP_ADDR, 1, 4}},
1261         {BGP4V2_NLRI_LINK_LOCAL_NEXT_HOP_ADDR,
1262          ASN_OCTET_STR,
1263          RONLY,
1264          bgp4v2PathAttrTable,
1265          6,
1266          {1, 9, 1, BGP4V2_NLRI_LINK_LOCAL_NEXT_HOP_ADDR, 2, 16}},
1267         {BGP4V2_NLRI_LOCAL_PREF_PRESENT,
1268          ASN_INTEGER,
1269          RONLY,
1270          bgp4v2PathAttrTable,
1271          6,
1272          {1, 9, 1, BGP4V2_NLRI_LOCAL_PREF_PRESENT, 1, 4}},
1273         {BGP4V2_NLRI_LOCAL_PREF_PRESENT,
1274          ASN_INTEGER,
1275          RONLY,
1276          bgp4v2PathAttrTable,
1277          6,
1278          {1, 9, 1, BGP4V2_NLRI_LOCAL_PREF_PRESENT, 2, 16}},
1279         {BGP4V2_NLRI_LOCAL_PREF,
1280          ASN_UNSIGNED,
1281          RONLY,
1282          bgp4v2PathAttrTable,
1283          6,
1284          {1, 9, 1, BGP4V2_NLRI_LOCAL_PREF, 1, 4}},
1285         {BGP4V2_NLRI_LOCAL_PREF,
1286          ASN_UNSIGNED,
1287          RONLY,
1288          bgp4v2PathAttrTable,
1289          6,
1290          {1, 9, 1, BGP4V2_NLRI_LOCAL_PREF, 2, 16}},
1291         {BGP4V2_NLRI_MED_PRESENT,
1292          ASN_INTEGER,
1293          RONLY,
1294          bgp4v2PathAttrTable,
1295          6,
1296          {1, 9, 1, BGP4V2_NLRI_MED_PRESENT, 1, 4}},
1297         {BGP4V2_NLRI_MED_PRESENT,
1298          ASN_INTEGER,
1299          RONLY,
1300          bgp4v2PathAttrTable,
1301          6,
1302          {1, 9, 1, BGP4V2_NLRI_MED_PRESENT, 2, 16}},
1303         {BGP4V2_NLRI_MED,
1304          ASN_UNSIGNED,
1305          RONLY,
1306          bgp4v2PathAttrTable,
1307          6,
1308          {1, 9, 1, BGP4V2_NLRI_MED, 1, 4}},
1309         {BGP4V2_NLRI_MED,
1310          ASN_UNSIGNED,
1311          RONLY,
1312          bgp4v2PathAttrTable,
1313          6,
1314          {1, 9, 1, BGP4V2_NLRI_MED, 2, 16}},
1315         {BGP4V2_NLRI_ATOMIC_AGGREGATE,
1316          ASN_INTEGER,
1317          RONLY,
1318          bgp4v2PathAttrTable,
1319          6,
1320          {1, 9, 1, BGP4V2_NLRI_ATOMIC_AGGREGATE, 1, 4}},
1321         {BGP4V2_NLRI_ATOMIC_AGGREGATE,
1322          ASN_INTEGER,
1323          RONLY,
1324          bgp4v2PathAttrTable,
1325          6,
1326          {1, 9, 1, BGP4V2_NLRI_ATOMIC_AGGREGATE, 2, 16}},
1327         {BGP4V2_NLRI_AGGREGATOR_PRESENT,
1328          ASN_INTEGER,
1329          RONLY,
1330          bgp4v2PathAttrTable,
1331          6,
1332          {1, 9, 1, BGP4V2_NLRI_AGGREGATOR_PRESENT, 1, 4}},
1333         {BGP4V2_NLRI_AGGREGATOR_PRESENT,
1334          ASN_INTEGER,
1335          RONLY,
1336          bgp4v2PathAttrTable,
1337          6,
1338          {1, 9, 1, BGP4V2_NLRI_AGGREGATOR_PRESENT, 2, 16}},
1339         {BGP4V2_NLRI_AGGREGATOR_AS,
1340          ASN_UNSIGNED,
1341          RONLY,
1342          bgp4v2PathAttrTable,
1343          6,
1344          {1, 9, 1, BGP4V2_NLRI_AGGREGATOR_AS, 1, 4}},
1345         {BGP4V2_NLRI_AGGREGATOR_AS,
1346          ASN_UNSIGNED,
1347          RONLY,
1348          bgp4v2PathAttrTable,
1349          6,
1350          {1, 9, 1, BGP4V2_NLRI_AGGREGATOR_AS, 2, 16}},
1351         {BGP4V2_NLRI_AGGREGATOR_ADDR,
1352          ASN_OCTET_STR,
1353          RONLY,
1354          bgp4v2PathAttrTable,
1355          6,
1356          {1, 9, 1, BGP4V2_NLRI_AGGREGATOR_ADDR, 1, 4}},
1357         {BGP4V2_NLRI_AGGREGATOR_ADDR,
1358          ASN_OCTET_STR,
1359          RONLY,
1360          bgp4v2PathAttrTable,
1361          6,
1362          {1, 9, 1, BGP4V2_NLRI_AGGREGATOR_ADDR, 2, 16}},
1363         {BGP4V2_NLRI_AS_PATH_CALC_LENGTH,
1364          ASN_UNSIGNED,
1365          RONLY,
1366          bgp4v2PathAttrTable,
1367          6,
1368          {1, 9, 1, BGP4V2_NLRI_AS_PATH_CALC_LENGTH, 1, 4}},
1369         {BGP4V2_NLRI_AS_PATH_CALC_LENGTH,
1370          ASN_UNSIGNED,
1371          RONLY,
1372          bgp4v2PathAttrTable,
1373          6,
1374          {1, 9, 1, BGP4V2_NLRI_AS_PATH_CALC_LENGTH, 2, 16}},
1375         {BGP4V2_NLRI_AS_PATH_STRING,
1376          ASN_OCTET_STR,
1377          RONLY,
1378          bgp4v2PathAttrTable,
1379          6,
1380          {1, 9, 1, BGP4V2_NLRI_AS_PATH_STRING, 1, 4}},
1381         {BGP4V2_NLRI_AS_PATH_STRING,
1382          ASN_OCTET_STR,
1383          RONLY,
1384          bgp4v2PathAttrTable,
1385          6,
1386          {1, 9, 1, BGP4V2_NLRI_AS_PATH_STRING, 2, 16}},
1387         {BGP4V2_NLRI_AS_PATH,
1388          ASN_OCTET_STR,
1389          RONLY,
1390          bgp4v2PathAttrTable,
1391          6,
1392          {1, 9, 1, BGP4V2_NLRI_AS_PATH, 1, 4}},
1393         {BGP4V2_NLRI_AS_PATH,
1394          ASN_OCTET_STR,
1395          RONLY,
1396          bgp4v2PathAttrTable,
1397          6,
1398          {1, 9, 1, BGP4V2_NLRI_AS_PATH, 2, 16}},
1399         {BGP4V2_NLRI_PATH_ATTR_UNKNOWN,
1400          ASN_OCTET_STR,
1401          RONLY,
1402          bgp4v2PathAttrTable,
1403          6,
1404          {1, 9, 1, BGP4V2_NLRI_PATH_ATTR_UNKNOWN, 1, 4}},
1405         {BGP4V2_NLRI_PATH_ATTR_UNKNOWN,
1406          ASN_OCTET_STR,
1407          RONLY,
1408          bgp4v2PathAttrTable,
1409          6,
1410          {1, 9, 1, BGP4V2_NLRI_PATH_ATTR_UNKNOWN, 2, 16}},
1411 };
1412
1413 int bgp_snmp_bgp4v2_init(struct thread_master *tm)
1414 {
1415         REGISTER_MIB("mibII/bgpv2", bgpv2_variables, variable, bgpv2_oid);
1416         return 0;
1417 }