bgpd/bgp_snmp_bgp4v2.c

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