bgpd/bgp_snmp_bgp4.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /* BGP4 SNMP support
   3  * Copyright (C) 1999, 2000 Kunihiro Ishiguro
   4  */
   5
   6 #include <zebra.h>
   7
   8 #include <net-snmp/net-snmp-config.h>
   9 #include <net-snmp/net-snmp-includes.h>
  10
  11 #include "if.h"
  12 #include "log.h"
  13 #include "prefix.h"
  14 #include "command.h"
  15 #include "thread.h"
  16 #include "smux.h"
  17 #include "filter.h"
  18 #include "hook.h"
  19 #include "libfrr.h"
  20
  21 #include "bgpd/bgpd.h"
  22 #include "bgpd/bgp_table.h"
  23 #include "bgpd/bgp_aspath.h"
  24 #include "bgpd/bgp_attr.h"
  25 #include "bgpd/bgp_route.h"
  26 #include "bgpd/bgp_fsm.h"
  27 #include "bgpd/bgp_snmp.h"
  28 #include "bgpd/bgp_snmp_bgp4.h"
  29 #include "bgpd/bgp_mplsvpn_snmp.h"
  30
  31 /* Declare static local variables for convenience. */
  32 SNMP_LOCAL_VARIABLES
  33
  34 /* BGP-MIB instances. */
  35 static oid bgp_oid[] = {BGP4MIB};
  36 static oid bgp_trap_oid[] = {BGP4MIB, 0};
  37
  38 /* IP address 0.0.0.0. */
  39 static struct in_addr bgp_empty_addr = {.s_addr = 0};
  40
  41 static uint8_t *bgpVersion(struct variable *v, oid name[], size_t *length,
  42                            int exact, size_t *var_len,
  43                            WriteMethod **write_method)
  44 {
  45         static uint8_t version;
  46
  47         if (smux_header_generic(v, name, length, exact, var_len,
  48                                 write_method) == MATCH_FAILED)
  49                 return NULL;
  50
  51         /* Return BGP version.  Zebra bgpd only support version 4. */
  52         version = (0x80 >> (BGP_VERSION_4 - 1));
  53
  54         /* Return octet string length 1. */
  55         *var_len = 1;
  56         return &version;
  57 }
  58
  59 static uint8_t *bgpLocalAs(struct variable *v, oid name[], size_t *length,
  60                            int exact, size_t *var_len,
  61                            WriteMethod **write_method)
  62 {
  63         struct bgp *bgp;
  64
  65         if (smux_header_generic(v, name, length, exact, var_len,
  66                                 write_method) == MATCH_FAILED)
  67                 return NULL;
  68
  69         /* Get BGP structure. */
  70         bgp = bgp_get_default();
  71         if (!bgp)
  72                 return NULL;
  73
  74         return SNMP_INTEGER(bgp->as);
  75 }
  76
  77 static struct peer *peer_lookup_addr_ipv4(struct in_addr *src)
  78 {
  79         struct bgp *bgp;
  80         struct peer *peer;
  81         struct listnode *node;
  82         struct listnode *bgpnode;
  83
  84         for (ALL_LIST_ELEMENTS_RO(bm->bgp, bgpnode, bgp)) {
  85                 for (ALL_LIST_ELEMENTS_RO(bgp->peer, node, peer)) {
  86                         if (sockunion_family(&peer->su) != AF_INET)
  87                                 continue;
  88
  89                         if (sockunion2ip(&peer->su) == src->s_addr)
  90                                 return peer;
  91                 }
  92         }
  93
  94         return NULL;
  95 }
  96
  97 static struct peer *bgp_peer_lookup_next(struct in_addr *src)
  98 {
  99         struct bgp *bgp;
 100         struct peer *peer;
 101         struct peer *next_peer = NULL;
 102         struct listnode *node;
 103         struct listnode *bgpnode;
 104
 105         for (ALL_LIST_ELEMENTS_RO(bm->bgp, bgpnode, bgp)) {
 106                 for (ALL_LIST_ELEMENTS_RO(bgp->peer, node, peer)) {
 107                         if (sockunion_family(&peer->su) != AF_INET)
 108                                 continue;
 109                         if (ntohl(sockunion2ip(&peer->su)) <=
 110                             ntohl(src->s_addr))
 111                                 continue;
 112
 113                         if (!next_peer ||
 114                             ntohl(sockunion2ip(&next_peer->su)) >
 115                                     ntohl(sockunion2ip(&peer->su))) {
 116                                 next_peer = peer;
 117                         }
 118                 }
 119         }
 120
 121         if (next_peer) {
 122                 src->s_addr = sockunion2ip(&next_peer->su);
 123                 return next_peer;
 124         }
 125
 126         return NULL;
 127 }
 128
 129 /* 1.3.6.1.2.1.15.3.1.x  = 10 */
 130 #define PEERTAB_NAMELEN 10
 131
 132 static struct peer *bgpPeerTable_lookup(struct variable *v, oid name[],
 133                                         size_t *length, struct in_addr *addr,
 134                                         int exact)
 135 {
 136         struct peer *peer = NULL;
 137         size_t namelen = v ? v->namelen : PEERTAB_NAMELEN;
 138         int len;
 139
 140         if (exact) {
 141                 /* Check the length. */
 142                 if (*length - namelen != sizeof(struct in_addr))
 143                         return NULL;
 144
 145                 oid2in_addr(name + namelen, IN_ADDR_SIZE, addr);
 146
 147                 peer = peer_lookup_addr_ipv4(addr);
 148                 return peer;
 149         } else {
 150                 len = *length - namelen;
 151                 if (len > 4)
 152                         len = 4;
 153
 154                 oid2in_addr(name + namelen, len, addr);
 155
 156                 peer = bgp_peer_lookup_next(addr);
 157
 158                 if (peer == NULL)
 159                         return NULL;
 160
 161                 oid_copy_in_addr(name + namelen, addr);
 162                 *length = sizeof(struct in_addr) + namelen;
 163
 164                 return peer;
 165         }
 166         return NULL;
 167 }
 168
 169 /* BGP write methods. */
 170 static int write_bgpPeerTable(int action, uint8_t *var_val,
 171                               uint8_t var_val_type, size_t var_val_len,
 172                               uint8_t *statP, oid *name, size_t length)
 173 {
 174         struct in_addr addr;
 175         struct peer *peer;
 176         long intval;
 177
 178         if (var_val_type != ASN_INTEGER) {
 179                 return SNMP_ERR_WRONGTYPE;
 180         }
 181         if (var_val_len != sizeof(long)) {
 182                 return SNMP_ERR_WRONGLENGTH;
 183         }
 184
 185         intval = *(long *)var_val;
 186
 187         memset(&addr, 0, sizeof(addr));
 188
 189         peer = bgpPeerTable_lookup(NULL, name, &length, &addr, 1);
 190         if (!peer)
 191                 return SNMP_ERR_NOSUCHNAME;
 192
 193         if (action != SNMP_MSG_INTERNAL_SET_COMMIT)
 194                 return SNMP_ERR_NOERROR;
 195
 196         zlog_info("%s: SNMP write .%ld = %ld", peer->host,
 197                   (long)name[PEERTAB_NAMELEN - 1], intval);
 198
 199         switch (name[PEERTAB_NAMELEN - 1]) {
 200         case BGPPEERADMINSTATUS:
 201 #define BGP_PeerAdmin_stop 1
 202 #define BGP_PeerAdmin_start 2
 203                 /* When the peer is established,   */
 204                 if (intval == BGP_PeerAdmin_stop)
 205                         BGP_EVENT_ADD(peer, BGP_Stop);
 206                 else if (intval == BGP_PeerAdmin_start)
 207                         ; /* Do nothing. */
 208                 else
 209                         return SNMP_ERR_NOSUCHNAME;
 210                 break;
 211         case BGPPEERCONNECTRETRYINTERVAL:
 212                 peer_flag_set(peer, PEER_FLAG_TIMER_CONNECT);
 213                 peer->connect = intval;
 214                 peer->v_connect = intval;
 215                 break;
 216         case BGPPEERHOLDTIMECONFIGURED:
 217                 peer_flag_set(peer, PEER_FLAG_TIMER);
 218                 peer->holdtime = intval;
 219                 peer->v_holdtime = intval;
 220                 break;
 221         case BGPPEERKEEPALIVECONFIGURED:
 222                 peer_flag_set(peer, PEER_FLAG_TIMER);
 223                 peer->keepalive = intval;
 224                 peer->v_keepalive = intval;
 225                 break;
 226         case BGPPEERMINROUTEADVERTISEMENTINTERVAL:
 227                 peer->v_routeadv = intval;
 228                 break;
 229         }
 230         return SNMP_ERR_NOERROR;
 231 }
 232
 233 static uint8_t *bgpPeerTable(struct variable *v, oid name[], size_t *length,
 234                              int exact, size_t *var_len,
 235                              WriteMethod **write_method)
 236 {
 237         static struct in_addr addr;
 238         struct peer *peer;
 239         uint32_t ui, uo;
 240
 241         if (smux_header_table(v, name, length, exact, var_len, write_method) ==
 242             MATCH_FAILED)
 243                 return NULL;
 244         memset(&addr, 0, sizeof(addr));
 245
 246         peer = bgpPeerTable_lookup(v, name, length, &addr, exact);
 247         if (!peer)
 248                 return NULL;
 249
 250         switch (v->magic) {
 251         case BGPPEERIDENTIFIER:
 252                 return SNMP_IPADDRESS(peer->remote_id);
 253         case BGPPEERSTATE:
 254                 return SNMP_INTEGER(peer->status);
 255         case BGPPEERADMINSTATUS:
 256                 *write_method = write_bgpPeerTable;
 257 #define BGP_PeerAdmin_stop 1
 258 #define BGP_PeerAdmin_start 2
 259                 if (CHECK_FLAG(peer->flags, PEER_FLAG_SHUTDOWN))
 260                         return SNMP_INTEGER(BGP_PeerAdmin_stop);
 261                 else
 262                         return SNMP_INTEGER(BGP_PeerAdmin_start);
 263         case BGPPEERNEGOTIATEDVERSION:
 264                 return SNMP_INTEGER(BGP_VERSION_4);
 265         case BGPPEERLOCALADDR:
 266                 if (peer->su_local)
 267                         return SNMP_IPADDRESS(peer->su_local->sin.sin_addr);
 268                 else
 269                         return SNMP_IPADDRESS(bgp_empty_addr);
 270         case BGPPEERLOCALPORT:
 271                 if (peer->su_local)
 272                         return SNMP_INTEGER(
 273                                 ntohs(peer->su_local->sin.sin_port));
 274                 else
 275                         return SNMP_INTEGER(0);
 276         case BGPPEERREMOTEADDR:
 277                 if (peer->su_remote)
 278                         return SNMP_IPADDRESS(peer->su_remote->sin.sin_addr);
 279                 else
 280                         return SNMP_IPADDRESS(bgp_empty_addr);
 281         case BGPPEERREMOTEPORT:
 282                 if (peer->su_remote)
 283                         return SNMP_INTEGER(
 284                                 ntohs(peer->su_remote->sin.sin_port));
 285                 else
 286                         return SNMP_INTEGER(0);
 287         case BGPPEERREMOTEAS:
 288                 return SNMP_INTEGER(peer->as);
 289         case BGPPEERINUPDATES:
 290                 ui = atomic_load_explicit(&peer->update_in,
 291                                           memory_order_relaxed);
 292                 return SNMP_INTEGER(ui);
 293         case BGPPEEROUTUPDATES:
 294                 uo = atomic_load_explicit(&peer->update_out,
 295                                           memory_order_relaxed);
 296                 return SNMP_INTEGER(uo);
 297         case BGPPEERINTOTALMESSAGES:
 298                 return SNMP_INTEGER(PEER_TOTAL_RX(peer));
 299         case BGPPEEROUTTOTALMESSAGES:
 300                 return SNMP_INTEGER(PEER_TOTAL_TX(peer));
 301         case BGPPEERLASTERROR: {
 302                 static uint8_t lasterror[2];
 303                 lasterror[0] = peer->notify.code;
 304                 lasterror[1] = peer->notify.subcode;
 305                 *var_len = 2;
 306                 return (uint8_t *)&lasterror;
 307         }
 308         case BGPPEERFSMESTABLISHEDTRANSITIONS:
 309                 return SNMP_INTEGER(peer->established);
 310         case BGPPEERFSMESTABLISHEDTIME:
 311                 if (peer->uptime == 0)
 312                         return SNMP_INTEGER(0);
 313                 else
 314                         return SNMP_INTEGER(monotime(NULL) - peer->uptime);
 315         case BGPPEERCONNECTRETRYINTERVAL:
 316                 *write_method = write_bgpPeerTable;
 317                 return SNMP_INTEGER(peer->v_connect);
 318         case BGPPEERHOLDTIME:
 319                 return SNMP_INTEGER(peer->v_holdtime);
 320         case BGPPEERKEEPALIVE:
 321                 return SNMP_INTEGER(peer->v_keepalive);
 322         case BGPPEERHOLDTIMECONFIGURED:
 323                 *write_method = write_bgpPeerTable;
 324                 if (CHECK_FLAG(peer->flags, PEER_FLAG_TIMER))
 325                         return SNMP_INTEGER(peer->holdtime);
 326                 else
 327                         return SNMP_INTEGER(peer->v_holdtime);
 328         case BGPPEERKEEPALIVECONFIGURED:
 329                 *write_method = write_bgpPeerTable;
 330                 if (CHECK_FLAG(peer->flags, PEER_FLAG_TIMER))
 331                         return SNMP_INTEGER(peer->keepalive);
 332                 else
 333                         return SNMP_INTEGER(peer->v_keepalive);
 334         case BGPPEERMINROUTEADVERTISEMENTINTERVAL:
 335                 *write_method = write_bgpPeerTable;
 336                 return SNMP_INTEGER(peer->v_routeadv);
 337         case BGPPEERINUPDATEELAPSEDTIME:
 338                 if (peer->update_time == 0)
 339                         return SNMP_INTEGER(0);
 340                 else
 341                         return SNMP_INTEGER(monotime(NULL) - peer->update_time);
 342         default:
 343                 return NULL;
 344         }
 345         return NULL;
 346 }
 347
 348 static uint8_t *bgpIdentifier(struct variable *v, oid name[], size_t *length,
 349                               int exact, size_t *var_len,
 350                               WriteMethod **write_method)
 351 {
 352         struct bgp *bgp;
 353
 354         if (smux_header_generic(v, name, length, exact, var_len,
 355                                 write_method) == MATCH_FAILED)
 356                 return NULL;
 357
 358         bgp = bgp_get_default();
 359         if (!bgp)
 360                 return NULL;
 361
 362         return SNMP_IPADDRESS(bgp->router_id);
 363 }
 364
 365 static uint8_t *bgpRcvdPathAttrTable(struct variable *v, oid name[],
 366                                      size_t *length, int exact, size_t *var_len,
 367                                      WriteMethod **write_method)
 368 {
 369         /* Received Path Attribute Table.  This table contains, one entry
 370            per path to a network, path attributes received from all peers
 371            running BGP version 3 or less.  This table is obsolete, having
 372            been replaced in functionality with the bgp4PathAttrTable.  */
 373         return NULL;
 374 }
 375
 376 static struct bgp_path_info *bgp4PathAttrLookup(struct variable *v, oid name[],
 377                                                 size_t *length, struct bgp *bgp,
 378                                                 struct prefix_ipv4 *addr,
 379                                                 int exact)
 380 {
 381         oid *offset;
 382         int offsetlen;
 383         struct bgp_path_info *path;
 384         struct bgp_path_info *min;
 385         struct bgp_dest *dest;
 386         union sockunion su;
 387         unsigned int len;
 388         struct in_addr paddr;
 389
 390         sockunion_init(&su);
 391
 392 #define BGP_PATHATTR_ENTRY_OFFSET (IN_ADDR_SIZE + 1 + IN_ADDR_SIZE)
 393
 394         if (exact) {
 395                 if (*length - v->namelen != BGP_PATHATTR_ENTRY_OFFSET)
 396                         return NULL;
 397
 398                 /* Set OID offset for prefix. */
 399                 offset = name + v->namelen;
 400                 oid2in_addr(offset, IN_ADDR_SIZE, &addr->prefix);
 401                 offset += IN_ADDR_SIZE;
 402
 403                 /* Prefix length. */
 404                 addr->prefixlen = *offset;
 405                 offset++;
 406
 407                 /* Peer address. */
 408                 su.sin.sin_family = AF_INET;
 409                 oid2in_addr(offset, IN_ADDR_SIZE, &su.sin.sin_addr);
 410
 411                 /* Lookup node. */
 412                 dest = bgp_node_lookup(bgp->rib[AFI_IP][SAFI_UNICAST],
 413                                        (struct prefix *)addr);
 414                 if (dest) {
 415                         for (path = bgp_dest_get_bgp_path_info(dest); path;
 416                              path = path->next)
 417                                 if (sockunion_same(&path->peer->su, &su))
 418                                         return path;
 419
 420                         bgp_dest_unlock_node(dest);
 421                 }
 422         } else {
 423                 offset = name + v->namelen;
 424                 offsetlen = *length - v->namelen;
 425                 len = offsetlen;
 426
 427                 if (offsetlen == 0)
 428                         dest = bgp_table_top(bgp->rib[AFI_IP][SAFI_UNICAST]);
 429                 else {
 430                         if (len > IN_ADDR_SIZE)
 431                                 len = IN_ADDR_SIZE;
 432
 433                         oid2in_addr(offset, len, &addr->prefix);
 434
 435                         offset += IN_ADDR_SIZE;
 436                         offsetlen -= IN_ADDR_SIZE;
 437
 438                         if (offsetlen > 0)
 439                                 addr->prefixlen = *offset;
 440                         else
 441                                 addr->prefixlen = len * 8;
 442
 443                         dest = bgp_node_get(bgp->rib[AFI_IP][SAFI_UNICAST],
 444                                             (struct prefix *)addr);
 445
 446                         offset++;
 447                         offsetlen--;
 448                 }
 449
 450                 if (offsetlen > 0) {
 451                         len = offsetlen;
 452                         if (len > IN_ADDR_SIZE)
 453                                 len = IN_ADDR_SIZE;
 454
 455                         oid2in_addr(offset, len, &paddr);
 456                 } else
 457                         paddr.s_addr = INADDR_ANY;
 458
 459                 if (!dest)
 460                         return NULL;
 461
 462                 do {
 463                         min = NULL;
 464
 465                         for (path = bgp_dest_get_bgp_path_info(dest); path;
 466                              path = path->next) {
 467                                 if (path->peer->su.sin.sin_family == AF_INET &&
 468                                     ntohl(paddr.s_addr) <
 469                                             ntohl(path->peer->su.sin.sin_addr
 470                                                           .s_addr)) {
 471                                         if (min) {
 472                                                 if (ntohl(path->peer->su.sin
 473                                                                   .sin_addr
 474                                                                   .s_addr) <
 475                                                     ntohl(min->peer->su.sin
 476                                                                   .sin_addr
 477                                                                   .s_addr))
 478                                                         min = path;
 479                                         } else
 480                                                 min = path;
 481                                 }
 482                         }
 483
 484                         if (min) {
 485                                 const struct prefix *rn_p =
 486                                         bgp_dest_get_prefix(dest);
 487
 488                                 *length =
 489                                         v->namelen + BGP_PATHATTR_ENTRY_OFFSET;
 490
 491                                 offset = name + v->namelen;
 492                                 oid_copy_in_addr(offset, &rn_p->u.prefix4);
 493                                 offset += IN_ADDR_SIZE;
 494                                 *offset = rn_p->prefixlen;
 495                                 offset++;
 496                                 oid_copy_in_addr(offset,
 497                                                  &min->peer->su.sin.sin_addr);
 498                                 addr->prefix = rn_p->u.prefix4;
 499                                 addr->prefixlen = rn_p->prefixlen;
 500
 501                                 bgp_dest_unlock_node(dest);
 502
 503                                 return min;
 504                         }
 505
 506                         paddr.s_addr = INADDR_ANY;
 507                 } while ((dest = bgp_route_next(dest)) != NULL);
 508         }
 509         return NULL;
 510 }
 511
 512 static uint8_t *bgp4PathAttrTable(struct variable *v, oid name[],
 513                                   size_t *length, int exact, size_t *var_len,
 514                                   WriteMethod **write_method)
 515 {
 516         struct bgp *bgp;
 517         struct bgp_path_info *path;
 518         struct prefix_ipv4 addr;
 519
 520         bgp = bgp_get_default();
 521         if (!bgp)
 522                 return NULL;
 523
 524         if (smux_header_table(v, name, length, exact, var_len, write_method) ==
 525             MATCH_FAILED)
 526                 return NULL;
 527         memset(&addr, 0, sizeof(addr));
 528
 529         path = bgp4PathAttrLookup(v, name, length, bgp, &addr, exact);
 530         if (!path)
 531                 return NULL;
 532
 533         switch (v->magic) {
 534         case BGP4PATHATTRPEER: /* 1 */
 535                 return SNMP_IPADDRESS(path->peer->su.sin.sin_addr);
 536         case BGP4PATHATTRIPADDRPREFIXLEN: /* 2 */
 537                 return SNMP_INTEGER(addr.prefixlen);
 538         case BGP4PATHATTRIPADDRPREFIX: /* 3 */
 539                 return SNMP_IPADDRESS(addr.prefix);
 540         case BGP4PATHATTRORIGIN: /* 4 */
 541                 return SNMP_INTEGER(path->attr->origin);
 542         case BGP4PATHATTRASPATHSEGMENT: /* 5 */
 543                 return aspath_snmp_pathseg(path->attr->aspath, var_len);
 544         case BGP4PATHATTRNEXTHOP: /* 6 */
 545                 return SNMP_IPADDRESS(path->attr->nexthop);
 546         case BGP4PATHATTRMULTIEXITDISC: /* 7 */
 547                 return SNMP_INTEGER(path->attr->med);
 548         case BGP4PATHATTRLOCALPREF: /* 8 */
 549                 return SNMP_INTEGER(path->attr->local_pref);
 550         case BGP4PATHATTRATOMICAGGREGATE: /* 9 */
 551                 return SNMP_INTEGER(1);
 552         case BGP4PATHATTRAGGREGATORAS: /* 10 */
 553                 return SNMP_INTEGER(path->attr->aggregator_as);
 554         case BGP4PATHATTRAGGREGATORADDR: /* 11 */
 555                 return SNMP_IPADDRESS(path->attr->aggregator_addr);
 556         case BGP4PATHATTRCALCLOCALPREF: /* 12 */
 557                 return SNMP_INTEGER(-1);
 558         case BGP4PATHATTRBEST: /* 13 */
 559 #define BGP4_PathAttrBest_false 1
 560 #define BGP4_PathAttrBest_true 2
 561                 if (CHECK_FLAG(path->flags, BGP_PATH_SELECTED))
 562                         return SNMP_INTEGER(BGP4_PathAttrBest_true);
 563                 else
 564                         return SNMP_INTEGER(BGP4_PathAttrBest_false);
 565         case BGP4PATHATTRUNKNOWN: /* 14 */
 566                 *var_len = 0;
 567                 return NULL;
 568         }
 569         return NULL;
 570 }
 571
 572 /* BGP Traps. */
 573 static struct trap_object bgpTrapList[] = {{3, {3, 1, BGPPEERREMOTEADDR}},
 574                                            {3, {3, 1, BGPPEERLASTERROR}},
 575                                            {3, {3, 1, BGPPEERSTATE}}};
 576
 577 static struct variable bgp_variables[] = {
 578         /* BGP version. */
 579         {BGPVERSION, OCTET_STRING, RONLY, bgpVersion, 1, {1}},
 580         /* BGP local AS. */
 581         {BGPLOCALAS, INTEGER, RONLY, bgpLocalAs, 1, {2}},
 582         /* BGP peer table. */
 583         {BGPPEERIDENTIFIER, IPADDRESS, RONLY, bgpPeerTable, 3, {3, 1, 1}},
 584         {BGPPEERSTATE, INTEGER, RONLY, bgpPeerTable, 3, {3, 1, 2}},
 585         {BGPPEERADMINSTATUS, INTEGER, RWRITE, bgpPeerTable, 3, {3, 1, 3}},
 586         {BGPPEERNEGOTIATEDVERSION,
 587          INTEGER32,
 588          RONLY,
 589          bgpPeerTable,
 590          3,
 591          {3, 1, 4}},
 592         {BGPPEERLOCALADDR, IPADDRESS, RONLY, bgpPeerTable, 3, {3, 1, 5}},
 593         {BGPPEERLOCALPORT, INTEGER, RONLY, bgpPeerTable, 3, {3, 1, 6}},
 594         {BGPPEERREMOTEADDR, IPADDRESS, RONLY, bgpPeerTable, 3, {3, 1, 7}},
 595         {BGPPEERREMOTEPORT, INTEGER, RONLY, bgpPeerTable, 3, {3, 1, 8}},
 596         {BGPPEERREMOTEAS, INTEGER, RONLY, bgpPeerTable, 3, {3, 1, 9}},
 597         {BGPPEERINUPDATES, COUNTER32, RONLY, bgpPeerTable, 3, {3, 1, 10}},
 598         {BGPPEEROUTUPDATES, COUNTER32, RONLY, bgpPeerTable, 3, {3, 1, 11}},
 599         {BGPPEERINTOTALMESSAGES, COUNTER32, RONLY, bgpPeerTable, 3, {3, 1, 12}},
 600         {BGPPEEROUTTOTALMESSAGES,
 601          COUNTER32,
 602          RONLY,
 603          bgpPeerTable,
 604          3,
 605          {3, 1, 13}},
 606         {BGPPEERLASTERROR, OCTET_STRING, RONLY, bgpPeerTable, 3, {3, 1, 14}},
 607         {BGPPEERFSMESTABLISHEDTRANSITIONS,
 608          COUNTER32,
 609          RONLY,
 610          bgpPeerTable,
 611          3,
 612          {3, 1, 15}},
 613         {BGPPEERFSMESTABLISHEDTIME,
 614          GAUGE32,
 615          RONLY,
 616          bgpPeerTable,
 617          3,
 618          {3, 1, 16}},
 619         {BGPPEERCONNECTRETRYINTERVAL,
 620          INTEGER,
 621          RWRITE,
 622          bgpPeerTable,
 623          3,
 624          {3, 1, 17}},
 625         {BGPPEERHOLDTIME, INTEGER, RONLY, bgpPeerTable, 3, {3, 1, 18}},
 626         {BGPPEERKEEPALIVE, INTEGER, RONLY, bgpPeerTable, 3, {3, 1, 19}},
 627         {BGPPEERHOLDTIMECONFIGURED,
 628          INTEGER,
 629          RWRITE,
 630          bgpPeerTable,
 631          3,
 632          {3, 1, 20}},
 633         {BGPPEERKEEPALIVECONFIGURED,
 634          INTEGER,
 635          RWRITE,
 636          bgpPeerTable,
 637          3,
 638          {3, 1, 21}},
 639         {BGPPEERMINROUTEADVERTISEMENTINTERVAL,
 640          INTEGER,
 641          RWRITE,
 642          bgpPeerTable,
 643          3,
 644          {3, 1, 23}},
 645         {BGPPEERINUPDATEELAPSEDTIME,
 646          GAUGE32,
 647          RONLY,
 648          bgpPeerTable,
 649          3,
 650          {3, 1, 24}},
 651         /* BGP identifier. */
 652         {BGPIDENTIFIER, IPADDRESS, RONLY, bgpIdentifier, 1, {4}},
 653         /* BGP received path attribute table. */
 654         {BGPPATHATTRPEER, IPADDRESS, RONLY, bgpRcvdPathAttrTable, 3, {5, 1, 1}},
 655         {BGPPATHATTRDESTNETWORK,
 656          IPADDRESS,
 657          RONLY,
 658          bgpRcvdPathAttrTable,
 659          3,
 660          {5, 1, 2}},
 661         {BGPPATHATTRORIGIN, INTEGER, RONLY, bgpRcvdPathAttrTable, 3, {5, 1, 3}},
 662         {BGPPATHATTRASPATH,
 663          OCTET_STRING,
 664          RONLY,
 665          bgpRcvdPathAttrTable,
 666          3,
 667          {5, 1, 4}},
 668         {BGPPATHATTRNEXTHOP,
 669          IPADDRESS,
 670          RONLY,
 671          bgpRcvdPathAttrTable,
 672          3,
 673          {5, 1, 5}},
 674         {BGPPATHATTRINTERASMETRIC,
 675          INTEGER32,
 676          RONLY,
 677          bgpRcvdPathAttrTable,
 678          3,
 679          {5, 1, 6}},
 680         /* BGP-4 received path attribute table. */
 681         {BGP4PATHATTRPEER, IPADDRESS, RONLY, bgp4PathAttrTable, 3, {6, 1, 1}},
 682         {BGP4PATHATTRIPADDRPREFIXLEN,
 683          INTEGER,
 684          RONLY,
 685          bgp4PathAttrTable,
 686          3,
 687          {6, 1, 2}},
 688         {BGP4PATHATTRIPADDRPREFIX,
 689          IPADDRESS,
 690          RONLY,
 691          bgp4PathAttrTable,
 692          3,
 693          {6, 1, 3}},
 694         {BGP4PATHATTRORIGIN, INTEGER, RONLY, bgp4PathAttrTable, 3, {6, 1, 4}},
 695         {BGP4PATHATTRASPATHSEGMENT,
 696          OCTET_STRING,
 697          RONLY,
 698          bgp4PathAttrTable,
 699          3,
 700          {6, 1, 5}},
 701         {BGP4PATHATTRNEXTHOP,
 702          IPADDRESS,
 703          RONLY,
 704          bgp4PathAttrTable,
 705          3,
 706          {6, 1, 6}},
 707         {BGP4PATHATTRMULTIEXITDISC,
 708          INTEGER,
 709          RONLY,
 710          bgp4PathAttrTable,
 711          3,
 712          {6, 1, 7}},
 713         {BGP4PATHATTRLOCALPREF,
 714          INTEGER,
 715          RONLY,
 716          bgp4PathAttrTable,
 717          3,
 718          {6, 1, 8}},
 719         {BGP4PATHATTRATOMICAGGREGATE,
 720          INTEGER,
 721          RONLY,
 722          bgp4PathAttrTable,
 723          3,
 724          {6, 1, 9}},
 725         {BGP4PATHATTRAGGREGATORAS,
 726          INTEGER,
 727          RONLY,
 728          bgp4PathAttrTable,
 729          3,
 730          {6, 1, 10}},
 731         {BGP4PATHATTRAGGREGATORADDR,
 732          IPADDRESS,
 733          RONLY,
 734          bgp4PathAttrTable,
 735          3,
 736          {6, 1, 11}},
 737         {BGP4PATHATTRCALCLOCALPREF,
 738          INTEGER,
 739          RONLY,
 740          bgp4PathAttrTable,
 741          3,
 742          {6, 1, 12}},
 743         {BGP4PATHATTRBEST, INTEGER, RONLY, bgp4PathAttrTable, 3, {6, 1, 13}},
 744         {BGP4PATHATTRUNKNOWN,
 745          OCTET_STRING,
 746          RONLY,
 747          bgp4PathAttrTable,
 748          3,
 749          {6, 1, 14}},
 750 };
 751
 752 int bgpTrapEstablished(struct peer *peer)
 753 {
 754         int ret;
 755         struct in_addr addr;
 756         oid index[sizeof(oid) * IN_ADDR_SIZE];
 757
 758         /* Check if this peer just went to Established */
 759         if ((peer->ostatus != OpenConfirm) || !(peer_established(peer)))
 760                 return 0;
 761
 762         ret = inet_aton(peer->host, &addr);
 763         if (ret == 0)
 764                 return 0;
 765
 766         oid_copy_in_addr(index, &addr);
 767
 768         smux_trap(bgp_variables, array_size(bgp_variables), bgp_trap_oid,
 769                   array_size(bgp_trap_oid), bgp_oid,
 770                   sizeof(bgp_oid) / sizeof(oid), index, IN_ADDR_SIZE,
 771                   bgpTrapList, array_size(bgpTrapList), BGPESTABLISHED);
 772         return 0;
 773 }
 774
 775 int bgpTrapBackwardTransition(struct peer *peer)
 776 {
 777         int ret;
 778         struct in_addr addr;
 779         oid index[sizeof(oid) * IN_ADDR_SIZE];
 780
 781         ret = inet_aton(peer->host, &addr);
 782         if (ret == 0)
 783                 return 0;
 784
 785         oid_copy_in_addr(index, &addr);
 786
 787         smux_trap(bgp_variables, array_size(bgp_variables), bgp_trap_oid,
 788                   array_size(bgp_trap_oid), bgp_oid,
 789                   sizeof(bgp_oid) / sizeof(oid), index, IN_ADDR_SIZE,
 790                   bgpTrapList, array_size(bgpTrapList), BGPBACKWARDTRANSITION);
 791         return 0;
 792 }
 793
 794 int bgp_snmp_bgp4_init(struct thread_master *tm)
 795 {
 796         REGISTER_MIB("mibII/bgp", bgp_variables, variable, bgp_oid);
 797         return 0;
 798 }