bgpd/bgp_snmp.c

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