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