开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 网络 > 查看源码
bgp_snmp.c
资源名称：zebra-0.95a.tar.gz　[点击查看]
上传用户：xiaozhuqw
上传日期：2009-11-15
资源大小：1338k
文件大小：24k
源码类别：

网络

开发平台：

Unix_Linux

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