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