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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
uxsnmp.cpp
资源名称：snmp++v3.2.21.tar.gz　[点击查看]
上传用户：cnryan
上传日期：2008-12-15
资源大小：260k
文件大小：66k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

uxsnmp.cpp：源码内容
  1. /*_############################################################################
  2.   _## 
  3.   _##  uxsnmp.cpp  
  4.   _##
  5.   _##  SNMP++v3.2.21
  6.   _##  -----------------------------------------------
  7.   _##  Copyright (c) 2001-2006 Jochen Katz, Frank Fock
  8.   _##
  9.   _##  This software is based on SNMP++2.6 from Hewlett Packard:
  10.   _##  
  11.   _##    Copyright (c) 1996
  12.   _##    Hewlett-Packard Company
  13.   _##  
  14.   _##  ATTENTION: USE OF THIS SOFTWARE IS SUBJECT TO THE FOLLOWING TERMS.
  15.   _##  Permission to use, copy, modify, distribute and/or sell this software 
  16.   _##  and/or its documentation is hereby granted without fee. User agrees 
  17.   _##  to display the above copyright notice and this license notice in all 
  18.   _##  copies of the software and any documentation of the software. User 
  19.   _##  agrees to assume all liability for the use of the software; 
  20.   _##  Hewlett-Packard and Jochen Katz make no representations about the 
  21.   _##  suitability of this software for any purpose. It is provided 
  22.   _##  "AS-IS" without warranty of any kind, either express or implied. User 
  23.   _##  hereby grants a royalty-free license to any and all derivatives based
  24.   _##  upon this software code base. 
  25.   _##  
  26.   _##  Stuttgart, Germany, Fri Jun 16 17:48:57 CEST 2006 
  27.   _##  
  28.   _##########################################################################*/
  29. /*===================================================================
  31.       U X S N M P . C P P
  33.       UXSNMP CLASS DECLARATION
  36.       Description:    HPUX version of Snmp class
  38.       Language:       ANSI C++
  40.       Author:         Peter E Mellquist
  42. =====================================================================*/
  44. char snmp_cpp_version[]="#(@) SNMP++ $Id: uxsnmp.cpp,v 1.32 2006/04/05 19:28:09 katz Exp $";
  46. /* CK Ng    added support for WIN32 in the whole file */
  48. //-----[ includes ]----------------------------------------------------
  49. #ifdef WIN32
  50. #include <winsock.h>
  51. #include <sys/types.h>     // system types
  52. #include <sys/timeb.h>     // _timeb and _ftime
  53. #else
  54. #include <unistd.h>        // unix
  55. #include <sys/socket.h>    // bsd socket stuff
  56. #include <netinet/in.h>    // network types
  57. #include <arpa/inet.h>     // arpa types
  58. #include <sys/types.h>     // system types
  59. #if !(defined CPU && CPU == PPC603)
  60. #include <sys/time.h>      // time stuff
  61. #endif
  62. #endif
  63. #ifdef _AIX
  64. #define ss_family __ss_family
  65. #endif
  67. #include <stdlib.h>        // need for malloc
  68. #include <errno.h>         // ux errs
  70. #define _INCLUDE_SNMP_ERR_STRINGS
  72. //----[ snmp++ includes ]----------------------------------------------
  73. #include "snmp_pp/uxsnmp.h"        // class def for this module
  74. #include "snmp_pp/oid_def.h"       // class def for well known trap oids
  75. #include "snmp_pp/v3.h"
  76. #include "snmp_pp/msgqueue.h"      // message queue
  77. #include "snmp_pp/notifyqueue.h"   // notification queue
  78. #include "snmp_pp/snmpmsg.h"       // asn serialization class
  79. #include "snmp_pp/eventlistholder.h"
  80. #include "snmp_pp/usm_v3.h"
  81. #include "snmp_pp/vb.h"
  83. #if defined (CPU) && CPU == PPC603
  84. #include <sockLib.h> 
  85. #include <taskLib.h> 
  86. #endif
  88. #ifdef SNMP_PP_NAMESPACE
  89. namespace Snmp_pp {
  90. #endif
  92. //-----[ special includes ]-------------------------------------------
  93. extern "C"
  94. {
  95.   //------------[ if using Wind-U, then bring in the ms-windows header ]
  96. #ifndef WIN32
  97. #ifdef WU_APP
  98.   WORD app_hinst;
  99. #else
  100.   typedef short WORD;
  101.   typedef long DWORD;
  102. #endif
  103. #endif
  104. }
  106. //-----[ macros ]------------------------------------------------------
  107. #define DEFAULT_TIMEOUT 1000  // one second default timeout
  108. #define DEFAULT_RETRIES 1     // no retry default
  109. #define SNMP_PORT 161         // port # for SNMP
  110. #define SNMP_TRAP_PORT 162    // port # for SNMP traps
  112. #ifdef WIN32
  113. #ifdef __BCPLUSPLUS__
  114. #define _timeb timeb
  115. #define _ftime ftime
  116. #endif
  117. #define close closesocket
  118. #endif
  120. //--------[ globals ]---------------------------------------------------
  122. //--------------[ well known trap ids ]-----------------------------------
  123. const coldStartOid coldStart;
  124. const warmStartOid warmStart;
  125. const linkDownOid linkDown;
  126. const linkUpOid linkUp;
  127. const authenticationFailureOid authenticationFailure;
  128. const egpNeighborLossOid egpNeighborLoss;
  129. const snmpTrapEnterpriseOid snmpTrapEnterprise;
  132. #ifdef _SNMPv3
  134. void v3CallBack(int reason, Snmp *snmp, Pdu &pdu, SnmpTarget &target, void *v3cd)
  135. {
  136.   Snmp::V3CallBackData *cbData;
  137.   cbData = (Snmp::V3CallBackData*)v3cd;
  139.   Vb tmpvb;
  140.   pdu.get_vb(tmpvb,0);
  142.   debugprintf(5, "v3CallBack: received oid: %s with value: %s",
  143.               tmpvb.get_printable_oid(), tmpvb.get_printable_value());
  144.   debugprintf(5, "v3CallBack: error_msg (%s), pdu_type (%i)",
  145.       snmp->error_msg(tmpvb.get_oid()), pdu.get_type());
  147.   if ((pdu.get_type() == REPORT_MSG) &&
  148.       (((tmpvb.get_oid() == oidUsmStatsUnknownEngineIDs) &&
  149. (cbData->reports_received == 0)) ||
  150.        ((tmpvb.get_oid() == oidUsmStatsNotInTimeWindows) &&
  151. (cbData->reports_received <= 1)))) {
  152.     // hide those reports from user
  153.     int rc;
  154.     if ((cbData->pdu) && (cbData->target)) {
  155.       rc = snmp->snmp_engine(*(cbData->pdu), cbData->non_reps,
  156.                              cbData->max_reps, *(cbData->target),
  157.                              (snmp_callback)(cbData->oldCallback),
  158.                              (void *)cbData->cbd, INVALID_SOCKET,
  159.      cbData->reports_received + 1);
  160.       debugprintf(3,"v3CallBack: snmp_engine called, rc (%i)", rc);
  161.     }
  162.     else
  163.       rc = SNMP_CLASS_ERROR;
  165.     if (rc != SNMP_CLASS_SUCCESS) {
  166.       // call callback if snmp_engine failed or pdu or target was 0
  167.       debugprintf(3,"v3CallBack: calling user callback");
  168.       snmp_callback tmp_callBack;
  169.       tmp_callBack = (snmp_callback)(cbData->oldCallback);
  170.       tmp_callBack(rc, snmp, pdu, target, (void *)cbData->cbd);
  171.     }
  172.   }
  173.   else {
  174.     debugprintf(3,"v3CallBack: calling user callback");
  175.     snmp_callback tmp_callBack;
  176.     tmp_callBack = (snmp_callback)(cbData->oldCallback);
  177.     tmp_callBack(reason, snmp, pdu, target, (void *)cbData->cbd);
  178.   }
  179.   // save to delete it here, because either snmp_engine created a new
  180.   // callback entry or the user specified callback has been called
  181.   if (cbData->pdu) {
  182.     delete cbData->pdu;
  183.     cbData->pdu = 0;
  184.   }
  185.   if (cbData->target) {
  186.     delete cbData->target;
  187.     cbData->target = 0;
  188.   }
  189.   delete cbData;
  190.   return;
  191. }
  193. #endif
  195. //--------[ make the pdu request id ]-----------------------------------
  196. // return a unique rid, clock can be too slow , so use current_rid
  197. long Snmp::MyMakeReqId()
  198. {
  199.   long rid;
  200.   eventListHolder->snmpEventList()->lock();
  201.   do {
  202.     rid = ++current_rid;
  204. #ifdef INVALID_REQID
  205.     debugprintf(-10, "nWARNING: Using constand RequestID!n");
  206.     rid = 0xc0de;
  207. #endif
  209.     if ( current_rid > PDU_MAX_RID)
  210.     {
  211.       current_rid = rid = PDU_MIN_RID;
  212.       // let other tasks proceed
  213.       eventListHolder->snmpEventList()->unlock();
  214.       struct timeval tv;
  215.       tv.tv_sec = 0;
  216.       tv.tv_usec = 100;
  217.       select(0, 0, 0, 0, &tv);
  218.       eventListHolder->snmpEventList()->lock();
  219.     }
  220.   } while (eventListHolder->snmpEventList()->GetEntry(rid));
  221.   eventListHolder->snmpEventList()->unlock();
  223.   return rid;
  224. }
  226. //---------[ Send SNMP Request ]---------------------------------------
  227. // Send out a snmp request
  228. DLLOPT int send_snmp_request(SnmpSocket sock, unsigned char *send_buf,
  229.                              size_t send_len, Address & address)
  230. {
  231.   // UX only supports UDP type addresses (addr and port) right now
  232.   if (address.get_type() != Address::type_udp)
  233.     return -1;// unsupported address type
  235.   debugprintf(1, "++ SNMP++: sending to %s:",
  236.               ((UdpAddress &)address).UdpAddress::get_printable());
  237.   debughexprintf(5, send_buf, SAFE_UINT_CAST(send_len));
  239.   int send_result;
  241.   if (((UdpAddress &)address).get_ip_version() == Address::version_ipv4)
  242.   {
  243.     // prepare the destination address
  244.     struct sockaddr_in agent_addr;  // send socket struct
  245.     memset(&agent_addr, 0, sizeof(agent_addr));
  246.     agent_addr.sin_family = AF_INET;
  247.     agent_addr.sin_addr.s_addr
  248.               = inet_addr(((IpAddress &)address).IpAddress::get_printable());
  249.     agent_addr.sin_port = htons(((UdpAddress &)address).get_port());
  251.     send_result = sendto(sock, (char*) send_buf, SAFE_INT_CAST(send_len), 0,
  252.                          (struct sockaddr*) &agent_addr, sizeof(agent_addr));
  253.   }
  254.   else
  255.   {
  256. #ifdef SNMP_PP_IPv6
  257.     struct sockaddr_in6 agent_addr;
  258.     memset(&agent_addr, 0, sizeof(agent_addr));
  259.     inet_pton(AF_INET6, ((IpAddress &)address).IpAddress::get_printable(),
  260.               &agent_addr.sin6_addr);
  261.     agent_addr.sin6_family = AF_INET6;
  262.     agent_addr.sin6_port = htons(((UdpAddress &)address).get_port());
  264.     send_result = sendto( sock, (char*) send_buf, send_len, 0,
  265.                           (struct sockaddr*) &agent_addr, sizeof(agent_addr));
  266. #else
  267.     debugprintf(0, "User error: Enable IPv6 and recompile snmp++.");
  268.     return -1;
  269. #endif
  270.   }
  272.   if (send_result < 0)
  273.   {
  274.     debugprintf(0, "Error sending packet: %s", strerror(errno));
  275.     return -1; // send error!
  276.   }
  278.   return 0;
  279. }
  281. //---------[ receive a snmp response ]---------------------------------
  282. // Receive a response from the specified socket.
  283. // This function does not set the request id in the pdu if
  284. // any error occur in receiving or parsing.  This is important
  285. // because the caller initializes this to zero and checks it to
  286. // see whether it has been changed to a valid value.  The
  287. // return value is the normal PDU status or SNMP_CLASS_SUCCESS.
  288. // when we are successful in receiving a pdu.  Otherwise it
  289. // is an error status.
  291. int receive_snmp_response(SnmpSocket sock, Snmp &snmp_session,
  292.                           Pdu &pdu, UdpAddress &fromaddress,
  293.   bool process_msg = true)
  294. {
  295.   unsigned char receive_buffer[MAX_SNMP_PACKET + 1];
  296.   long receive_buffer_len; // len of received data
  297. #ifdef SNMP_PP_IPv6
  298.   struct sockaddr_storage from_addr;
  299. #else
  300.   struct sockaddr_in from_addr;
  301. #endif
  302. #if !(defined (CPU) && CPU == PPC603) && (defined __GNUC__ || defined __FreeBSD__ || defined _AIX) && ! defined __MINGW32__
  303.   socklen_t fromlen;
  304. #else
  305.   int fromlen;
  306. #endif
  307.   fromlen = sizeof(from_addr);
  309.   memset(&from_addr, 0, sizeof(from_addr));
  311.   // do the read
  312.   do {
  313.     receive_buffer_len = (long) recvfrom(sock, (char *) receive_buffer,
  314.                                          MAX_SNMP_PACKET + 1, 0,
  315.                                          (struct sockaddr*) &from_addr,
  316.                                          &fromlen);
  317.     debugprintf(2, "++ SNMP++: something received...");
  318.   } while ((receive_buffer_len < 0) && (EINTR == errno));
  320.   if (receive_buffer_len < 0 )                // error or no data pending
  321.     return SNMP_CLASS_TL_FAILED;
  322.   debugprintf(6, "Length received %i from socket %i; fromlen %i",
  323.               receive_buffer_len, sock, fromlen);
  325.   if (receive_buffer_len == MAX_SNMP_PACKET + 1)
  326.   {
  327.     // Message is too long...
  328.     debugprintf(1, "Received message is ignored (packet too long)");
  329.     return SNMP_CLASS_ERROR;
  330.   }
  332.   if (((sockaddr_in&)from_addr).sin_family == AF_INET)
  333.   {
  334.     // IPv4
  335.     fromaddress = inet_ntoa(((sockaddr_in&)from_addr).sin_addr);
  336.     fromaddress.set_port(ntohs(((sockaddr_in&)from_addr).sin_port));
  337.   }
  338. #ifdef SNMP_PP_IPv6
  339.   else if (from_addr.ss_family == AF_INET6)
  340.   {
  341.     // IPv6
  342.     char tmp_buffer[INET6_ADDRSTRLEN+1];
  344.     inet_ntop(AF_INET6, &(((sockaddr_in6&)from_addr).sin6_addr),
  345.               tmp_buffer, INET6_ADDRSTRLEN);
  347.     fromaddress = tmp_buffer;
  348.     fromaddress.set_port(ntohs(((sockaddr_in6&)from_addr).sin6_port));
  349.   }
  350. #endif // SNMP_PP_IPv6
  351.   else
  352.   {
  353.     debugprintf(0, "Unknown socket address family (%i).",
  354.                 ((sockaddr_in&)from_addr).sin_family);
  355.     return SNMP_CLASS_ERROR;
  356.   }
  358.   debugprintf(1, "++ SNMP++: data received from %s.",
  359.               fromaddress.get_printable());
  360.   debughexprintf(5, receive_buffer, receive_buffer_len);
  362.   if (process_msg == false)
  363.     return SNMP_CLASS_SUCCESS;   // return success
  365.   SnmpMessage snmpmsg;
  366.   if ( snmpmsg.load( receive_buffer, receive_buffer_len) != SNMP_CLASS_SUCCESS)
  367.     return SNMP_CLASS_ERROR;
  369.   OctetStr community_name;
  370.   snmp_version version;
  371.   OctetStr engine_id;
  372.   OctetStr security_name;
  374. #ifdef _SNMPv3
  375.   long int security_model;
  376.   if (snmpmsg.is_v3_message() == TRUE)
  377.   {
  378.     int returncode = snmpmsg.unloadv3(pdu, version, engine_id,
  379.                                       security_name, security_model,
  380.                                       fromaddress, snmp_session);
  381.     if (returncode != SNMP_CLASS_SUCCESS)
  382.       return returncode;
  383.   }
  384.   else
  385.   {
  386. #endif
  387.     int returncode = snmpmsg.unload( pdu, community_name, version);
  388.     if (returncode != SNMP_CLASS_SUCCESS)
  389.       return SNMP_CLASS_ERROR;
  390. #ifdef _SNMPv3
  391.   }
  392.   if (version == version3) {
  393.     v3MP::I->add_to_engine_id_table(engine_id,
  394.        (char*)fromaddress.IpAddress::get_printable(),
  395.        fromaddress.get_port());
  397.     debugprintf(4,"receive_snmp_response: engine_id (%s), security_name (%s), "
  398. "security_model (%i), security_level (%i)",
  399.                 engine_id.get_printable(), security_name.get_printable(),
  400.                 security_model, pdu.get_security_level());
  401.     debugprintf(5," addtoengineidtable: (%s)",
  402.                 (unsigned char*)fromaddress.get_printable());
  403.   }
  404. #endif
  406.   //-----[ check for error status stuff..]
  407.   // an error status is a valid pdu,
  408.   // the caller needs to know about it
  409.   if ( pdu.get_error_status() != 0)
  410.     return pdu.get_error_status();
  412.   debugprintf(5,"receive_snmp_response requestID = %li, "
  413.       "returning SUCCESS.", pdu.get_request_id());
  415.   return SNMP_CLASS_SUCCESS;   // Success! return
  416. }
  419. //---------[ receive a snmp trap ]---------------------------------
  420. // Receive a trap from the specified socket
  421. // note: caller has to delete target!
  422. int receive_snmp_notification(SnmpSocket sock, Snmp &snmp_session,
  423.                               Pdu &pdu, SnmpTarget **target)
  424. {
  425.   unsigned char receive_buffer[MAX_SNMP_PACKET + 1];
  426.   long receive_buffer_len; // len of received data
  428. #ifdef SNMP_PP_IPv6
  429.   struct sockaddr_storage from_addr;
  430. #else
  431.   struct sockaddr_in from_addr;
  432. #endif // SNMP_PP_IPv6
  434. #if !(defined (CPU) && CPU == PPC603) && (defined __GNUC__ || defined __FreeBSD__ || defined _AIX) && ! defined __MINGW32__
  435.   socklen_t fromlen;
  436. #else
  437.   int fromlen;
  438. #endif
  439.   fromlen = sizeof(from_addr);
  441.   memset(&from_addr, 0, sizeof(from_addr));
  443.   // do the read
  444.   do {
  445.     receive_buffer_len = (long) recvfrom(sock, (char *) receive_buffer,
  446.                                          MAX_SNMP_PACKET + 1, 0,
  447.                                          (struct sockaddr*)&from_addr,
  448.                                          &fromlen);
  449.   } while (receive_buffer_len < 0 && EINTR == errno);
  451.   if (receive_buffer_len < 0 )                // error or no data pending
  452.     return SNMP_CLASS_TL_FAILED;
  454.   if (receive_buffer_len == MAX_SNMP_PACKET + 1)
  455.   {
  456.     // Message is too long...
  457.     debugprintf(1, "Received message is ignored (packet too long)");
  458.     return SNMP_CLASS_ERROR;
  459.   }
  461.   // copy fromaddress and remote port
  462.   UdpAddress fromaddress;
  464.   if (((sockaddr_in&)from_addr).sin_family == AF_INET)
  465.   {
  466.     // IPv4
  467.     fromaddress = inet_ntoa(((sockaddr_in&)from_addr).sin_addr);
  468.     fromaddress.set_port(ntohs(((sockaddr_in&)from_addr).sin_port));
  469.   }
  470. #ifdef SNMP_PP_IPv6
  471.   else if (from_addr.ss_family == AF_INET6)
  472.   {
  473.     // IPv6
  474.     char tmp_buffer[INET6_ADDRSTRLEN+1];
  476.     inet_ntop(AF_INET6, &(((sockaddr_in6&)from_addr).sin6_addr),
  477.               tmp_buffer, INET6_ADDRSTRLEN);
  479.     fromaddress = tmp_buffer;
  480.     fromaddress.set_port(ntohs(((sockaddr_in6&)from_addr).sin6_port));
  481.   }
  482. #endif // SNMP_PP_IPv6
  483.   else
  484.   {
  485.     debugprintf(0, "Unknown socket address family (%i).",
  486.                 ((sockaddr_in&)from_addr).sin_family);
  487.     return SNMP_CLASS_TL_FAILED;
  488.   }
  490.   debugprintf(1, "++ SNMP++: data received from %s.",
  491.               fromaddress.get_printable());
  492.   debughexprintf(5, receive_buffer, receive_buffer_len);
  494.   SnmpMessage snmpmsg;
  495.   if ( snmpmsg.load( receive_buffer, receive_buffer_len) != SNMP_CLASS_SUCCESS)
  496.     return SNMP_CLASS_ERROR;
  498.   OctetStr community_name;
  499.   snmp_version version;
  500.   OctetStr engine_id;
  501.   OctetStr security_name;
  503. #ifdef _SNMPv3
  504.   long int security_model;
  505.   if (snmpmsg.is_v3_message() == TRUE)
  506.   {
  507.     int returncode = snmpmsg.unloadv3(pdu, version, engine_id,
  508.                                       security_name, security_model,
  509.                                       fromaddress, snmp_session);
  510.     if (returncode != SNMP_CLASS_SUCCESS)
  511.       return returncode;
  512.   }
  513.   else
  514.   {
  515. #endif
  516.     int returncode = snmpmsg.unload( pdu, community_name, version);
  517.     if (returncode != SNMP_CLASS_SUCCESS)
  518.       return SNMP_CLASS_ERROR;
  519. #ifdef _SNMPv3
  520.   }
  522.   if (version == version3) {
  523.     *target = new UTarget();
  524.     (*target)->set_address(fromaddress);
  525.     (*target)->set_version(version);
  526.     ((UTarget*)*target)->set_engine_id(engine_id);
  527.     ((UTarget*)*target)->set_security_name(security_name);
  528.     ((UTarget*)*target)->set_security_model(security_model);
  530.     v3MP::I->add_to_engine_id_table(engine_id,
  531.                          (char*)((IpAddress &)fromaddress).get_printable(),
  532.                          fromaddress.get_port());
  534.     debugprintf(4,"receive_snmp_notification: engine_id (%s), security_name "
  535. "(%s), security_model (%i), security_level (%i)",
  536.                 engine_id.get_printable(), security_name.get_printable(),
  537.                 security_model, pdu.get_security_level());
  538.   }
  539.   else
  540.   {
  541. #endif
  542.     *target = new CTarget();
  543.     (*target)->set_version(version);
  544.     (*target)->set_address(fromaddress);
  545.     ((CTarget*)*target)->set_readcommunity( community_name);
  546.     ((CTarget*)*target)->set_writecommunity( community_name);
  547. #ifdef _SNMPv3
  548.   }
  549. #endif
  550.   return SNMP_CLASS_SUCCESS;   // Success! return
  551. }
  554. //--------[ map action ]------------------------------------------------
  555. // map the snmp++ action to a SMI pdu type
  556. void Snmp::map_action( unsigned short action, unsigned short & pdu_action)
  557. {
  558.   switch( action)
  559.     {
  560.     case sNMP_PDU_GET:
  561.     case sNMP_PDU_GET_ASYNC:
  562.       pdu_action = sNMP_PDU_GET;
  563.       break;
  565.     case sNMP_PDU_SET:
  566.     case sNMP_PDU_SET_ASYNC:
  567.       pdu_action = sNMP_PDU_SET;
  568.       break;
  570.     case sNMP_PDU_GETNEXT:
  571.     case sNMP_PDU_GETNEXT_ASYNC:
  572.       pdu_action = sNMP_PDU_GETNEXT;
  573.       break;
  575.     case sNMP_PDU_GETBULK:
  576.     case sNMP_PDU_GETBULK_ASYNC:
  577.       pdu_action = sNMP_PDU_GETBULK;
  578.       break;
  580.     case sNMP_PDU_RESPONSE:
  581.       pdu_action = sNMP_PDU_RESPONSE;
  582.       break;
  584.     case sNMP_PDU_INFORM:
  585.     case sNMP_PDU_INFORM_ASYNC:
  586.       pdu_action = sNMP_PDU_INFORM;
  587.       break;
  589.     case sNMP_PDU_REPORT:
  590.       pdu_action = sNMP_PDU_REPORT;
  591.       break;
  593.     default:
  594.       pdu_action = sNMP_PDU_GET;  // TM ?? error ??
  595.       break;
  597.     };  // end switch
  598. }
  600. //------[ Snmp Class Constructor ]--------------------------------------
  602. Snmp::Snmp(int &status, const unsigned short port, const bool bind_ipv6)
  603.     : SnmpSynchronized(),
  604.       m_bThreadRunning(false), m_iPollTimeOut(DEFAULT_TIMEOUT)
  605. {
  606.   IpAddress *addresses[2];
  608.   if (bind_ipv6)
  609.   {
  610.     listen_address = "::";
  612.     addresses[0] = NULL;
  613.     addresses[1] = &listen_address;
  615.     init(status, addresses, 0, port);
  616.   }
  617.   else
  618.   {
  619.     listen_address = "0.0.0.0";
  621.     addresses[0] = &listen_address;
  622.     addresses[1] = NULL;
  624.     init(status, addresses, port, 0);
  625.   }
  627. }
  629. Snmp::Snmp( int &status, const UdpAddress& addr)
  630.     : SnmpSynchronized(),
  631.       m_bThreadRunning(false), m_iPollTimeOut(DEFAULT_TIMEOUT)
  632. {
  633.   IpAddress *addresses[2];
  635.   listen_address = addr;
  637.   if (listen_address.get_ip_version() == Address::version_ipv4)
  638.   {
  639.     addresses[0] = &listen_address;
  640.     addresses[1] = NULL;
  641.     init(status, addresses, addr.get_port(), 0);
  642.   }
  643.   else
  644.   {
  645.     addresses[0] = NULL;
  646.     addresses[1] = &listen_address;
  647.     init(status, addresses, 0, addr.get_port());
  648.   }
  649. }
  651. Snmp::Snmp( int &status,  const UdpAddress& addr_v4,
  652.             const UdpAddress& addr_v6)
  653.     : SnmpSynchronized(),
  654.       m_bThreadRunning(false), m_iPollTimeOut(DEFAULT_TIMEOUT)
  655. {
  656.   IpAddress *addresses[2];
  658.   listen_address = addr_v4;
  659.   IpAddress address_v6((IpAddress)addr_v6);
  660.   addresses[0] = &listen_address;
  661.   addresses[1] = &address_v6;
  663.   init(status, addresses, addr_v4.get_port(), addr_v6.get_port());
  664. }
  666. void Snmp::socket_startup()
  667. {
  668. #ifdef WIN32
  669.   WSADATA WSAData;
  670.   (void)WSAStartup(0x0101, &WSAData);
  671. #endif
  672. }
  674. void Snmp::socket_cleanup()
  675. {
  676. #ifdef WIN32
  677.   int iRetValue = WSACleanup();
  678.   debugprintf(4, "WSACleanup: ReturnValue (%i)", iRetValue);
  679. #endif
  680. }
  682. void Snmp::init(int& status, IpAddress *addresses[2],
  683.                 const unsigned short port_v4,
  684.                 const unsigned short port_v6)
  685. {
  686.   eventListHolder = new EventListHolder(this);
  687.   // initialize the request_id
  688.   eventListHolder->snmpEventList()->lock();
  689. //  srand(time(0)); // better than nothing
  690.   current_rid = (rand() % (PDU_MAX_RID - PDU_MIN_RID -1)) + PDU_MIN_RID;
  691.   debugprintf(4, "Initialized request_id to %i.", current_rid);
  692.   eventListHolder->snmpEventList()->unlock();
  694.   // intialize all the trap receiving member variables
  695.   notifycallback = 0;
  696.   notifycallback_data = 0;
  697. #ifdef HPUX
  698.   int errno = 0;
  699. #endif
  701.   status = SNMP_CLASS_ERROR;
  702.   iv_snmp_session = INVALID_SOCKET;
  703.   iv_snmp_session_ipv6 = INVALID_SOCKET;
  705.   /* Open IPv4 socket */
  706.   if (addresses[0])
  707.   {
  708.     // open a socket to be used for the session
  709.     if (( iv_snmp_session = socket( AF_INET, SOCK_DGRAM,0)) == INVALID_SOCKET)
  710.     {
  711. #ifdef WIN32
  712.       int werr = WSAGetLastError();
  713.       debugprintf(1, "Call to socket throws error %d", werr);
  714.       if (EMFILE == werr ||WSAENOBUFS == werr || ENFILE == werr)
  715.         status = SNMP_CLASS_RESOURCE_UNAVAIL;
  716.       else if (WSAEHOSTDOWN == werr)
  717.         status = SNMP_CLASS_TL_FAILED;
  718.       else
  719.         status = SNMP_CLASS_TL_UNSUPPORTED;
  720. #else
  721.       if (EMFILE == errno || ENOBUFS == errno || ENFILE == errno)
  722.         status = SNMP_CLASS_RESOURCE_UNAVAIL;
  723.       else if (EHOSTDOWN == errno)
  724.         status = SNMP_CLASS_TL_FAILED;
  725.       else
  726.         status = SNMP_CLASS_TL_UNSUPPORTED;
  727. #endif
  728.     }
  729.     else
  730.     {
  731.       // set up the manager socket attributes
  732.       unsigned long inaddr = inet_addr(addresses[0]->get_printable());
  733.       struct sockaddr_in mgr_addr;
  734.       memset(&mgr_addr, 0, sizeof(mgr_addr));
  735.       mgr_addr.sin_family = AF_INET;
  736.       mgr_addr.sin_addr.s_addr = inaddr;
  737.       mgr_addr.sin_port = htons( port_v4);
  738. #ifdef CYGPKG_NET_OPENBSD_STACK
  739.       mgr_addr.sin_len = sizeof(mgr_addr);
  740. #endif
  742.       // bind the socket
  743.       if (bind(iv_snmp_session, (struct sockaddr*)&mgr_addr,
  744.                sizeof(mgr_addr)) < 0)
  745.       {
  746. #ifdef WIN32
  747.         int werr = WSAGetLastError();
  748. debugprintf(1, "Call to bind throws error %d", werr);
  749.         if (WSAEADDRINUSE  == werr)
  750.           status = SNMP_CLASS_TL_IN_USE;
  751.         else if (WSAENOBUFS == werr)
  752.           status = SNMP_CLASS_RESOURCE_UNAVAIL;
  753.         else if (werr == WSAEAFNOSUPPORT)
  754.           status = SNMP_CLASS_TL_UNSUPPORTED;
  755.         else if (werr == WSAENETUNREACH)
  756.           status = SNMP_CLASS_TL_FAILED;
  757.         else if (werr == EACCES)
  758.           status = SNMP_CLASS_TL_ACCESS_DENIED;
  759.         else
  760.           status = SNMP_CLASS_INTERNAL_ERROR;
  761. #else
  762.         if (EADDRINUSE  == errno)
  763.           status = SNMP_CLASS_TL_IN_USE;
  764.         else if (ENOBUFS == errno)
  765.           status = SNMP_CLASS_RESOURCE_UNAVAIL;
  766.         else if (errno == EAFNOSUPPORT)
  767.           status = SNMP_CLASS_TL_UNSUPPORTED;
  768.         else if (errno == ENETUNREACH)
  769.           status = SNMP_CLASS_TL_FAILED;
  770.         else if (errno == EACCES)
  771.           status = SNMP_CLASS_TL_ACCESS_DENIED;
  772.         else
  773. {
  774.   debugprintf(0, "Uncatched errno value %d, returning internal error.",
  775.       errno);
  776.           status = SNMP_CLASS_INTERNAL_ERROR;
  777. }
  778. #endif
  779. close(iv_snmp_session);    // close the dynamic socket
  780. iv_snmp_session = INVALID_SOCKET;
  781.       }
  782.       else
  783.       {
  784.         status = SNMP_CLASS_SUCCESS;
  785. #ifdef SNMP_BROADCAST
  786.         int enable_broadcast = 1;
  787.         setsockopt(iv_snmp_session, SOL_SOCKET, SO_BROADCAST,
  788.                    (char*)&enable_broadcast, sizeof(enable_broadcast));
  789. #endif
  790.       }
  791.     }
  792.     if (status != SNMP_CLASS_SUCCESS)
  793.       return;
  794.   }
  796.   /* Open IPv6 socket */
  797.   if (addresses[1])
  798.   {
  799. #ifdef SNMP_PP_IPv6
  800.     // open a socket to be used for the session
  801.     if (( iv_snmp_session_ipv6 = socket( AF_INET6, SOCK_DGRAM,0)) 
  802. == INVALID_SOCKET)
  803.     {
  804. #ifdef WIN32
  805.       int werr = WSAGetLastError();
  806.       if (EMFILE == werr ||WSAENOBUFS == werr || ENFILE == werr)
  807.         status = SNMP_CLASS_RESOURCE_UNAVAIL;
  808.       else if (WSAEHOSTDOWN == werr)
  809.         status = SNMP_CLASS_TL_FAILED;
  810.       else
  811.         status = SNMP_CLASS_TL_UNSUPPORTED;
  812. #else
  813.       if (EMFILE == errno || ENOBUFS == errno || ENFILE == errno)
  814.         status = SNMP_CLASS_RESOURCE_UNAVAIL;
  815.       else if (EHOSTDOWN == errno)
  816.         status = SNMP_CLASS_TL_FAILED;
  817.       else
  818.         status = SNMP_CLASS_TL_UNSUPPORTED;
  819. #endif
  820.     }
  821.     else
  822.     {
  823.       // set up the manager socket attributes
  824.       struct sockaddr_in6 mgr_addr;
  826.       memset(&mgr_addr, 0, sizeof(mgr_addr));
  827.       inet_pton(AF_INET6, addresses[1]->get_printable(), &mgr_addr.sin6_addr);
  828.       mgr_addr.sin6_family = AF_INET6;
  829.       mgr_addr.sin6_port = htons( port_v6);
  830.       // bind the socket
  831.       if (bind(iv_snmp_session_ipv6, (struct sockaddr*) &mgr_addr,
  832.                sizeof(mgr_addr)) < 0)
  833.       {
  834. #ifdef WIN32
  835.         int werr = WSAGetLastError();
  836.         if (WSAEADDRINUSE  == werr)
  837.           status = SNMP_CLASS_TL_IN_USE;
  838.         else if (WSAENOBUFS == werr)
  839.           status = SNMP_CLASS_RESOURCE_UNAVAIL;
  840.         else if (werr == WSAEAFNOSUPPORT)
  841.           status = SNMP_CLASS_TL_UNSUPPORTED;
  842.         else if (werr == WSAENETUNREACH)
  843.           status = SNMP_CLASS_TL_FAILED;
  844.         else if (werr == EACCES)
  845.           status = SNMP_CLASS_TL_ACCESS_DENIED;
  846.         else
  847.           status = SNMP_CLASS_INTERNAL_ERROR;
  848. #else
  849.         if (EADDRINUSE  == errno)
  850.           status = SNMP_CLASS_TL_IN_USE;
  851.         else if (ENOBUFS == errno)
  852.           status = SNMP_CLASS_RESOURCE_UNAVAIL;
  853.         else if (errno == EAFNOSUPPORT)
  854.           status = SNMP_CLASS_TL_UNSUPPORTED;
  855.         else if (errno == ENETUNREACH)
  856.           status = SNMP_CLASS_TL_FAILED;
  857.         else if (errno == EACCES)
  858.           status = SNMP_CLASS_TL_ACCESS_DENIED;
  859.         else
  860.           status = SNMP_CLASS_INTERNAL_ERROR;
  861. #endif
  862. close(iv_snmp_session_ipv6);    // close the dynamic socket
  863. iv_snmp_session_ipv6 = INVALID_SOCKET;
  864.       }
  865.       else
  866.       {
  867.         status = SNMP_CLASS_SUCCESS;
  868. #ifdef SNMP_BROADCAST
  869.         int enable_broadcast = 1;
  870.         setsockopt(iv_snmp_session_ipv6, SOL_SOCKET, SO_BROADCAST,
  871.                    (char*)&enable_broadcast, sizeof(enable_broadcast));
  872. #endif
  873.       }
  874.     }
  875. #else
  876.     debugprintf(0, "User error: Enable IPv6 and recompile snmp++.");
  877. #endif // SNMP_PP_IPv6
  878.   }
  879.   return;
  880. }
  883. //---------[ Snmp Class Destructor ]----------------------------------
  884. Snmp::~Snmp()
  885. {
  886.   stop_poll_thread();
  888.   // if we failed during construction then don't try
  889.   // to free stuff up that was not allocated
  890.   if (iv_snmp_session != INVALID_SOCKET)
  891.   {
  892.     // go through the snmpEventList and delete any outstanding
  893.     // events on this socket
  894.     eventListHolder->snmpEventList()->DeleteSocketEntry(iv_snmp_session);
  896.     close(iv_snmp_session);    // close the dynamic socket
  897.   }
  898.   // if we failed during construction then don't try
  899.   // to free stuff up that was not allocated
  900.   if (iv_snmp_session_ipv6 != INVALID_SOCKET)
  901.   {
  902.     // go through the snmpEventList and delete any outstanding
  903.     // events on this socket
  904.     eventListHolder->snmpEventList()->DeleteSocketEntry(iv_snmp_session_ipv6);
  906.     close(iv_snmp_session_ipv6);    // close the dynamic socket
  907.   }
  909.   // shut down trap reception if used
  910.   notify_unregister();
  912.   delete eventListHolder;
  913. }
  915. // Get the version of the snmp++ library at runtime
  916. // This function MUST stay in the cpp file!
  917. const char *Snmp::get_version()
  918. {
  919.   return SNMP_PP_VERSION_STRING;
  920. }
  922. //-------------------[ returns error string ]--------------------------
  923. const char *Snmp::error_msg(const int c)
  924. {
  925. #ifdef _SNMPv3
  926.   if (c>=SNMPv3_USM_MIN_ERROR)
  927.     return ((c>SNMPv3_USM_MAX_ERROR)?pv3Errs[SNMPv3_USM_ERRORCOUNT]:pv3Errs[c-SNMPv3_USM_MIN_ERROR]);
  928.   if (c<=SNMPv3_MP_MAX_ERROR)
  929.     return ((c<SNMPv3_MP_MIN_ERROR)?nv3Errs[SNMPv3_MP_ERRORCOUNT]:nv3Errs[SNMPv3_MP_MAX_ERROR - c]);
  930. #endif
  931.   return ((c<0)?
  932.           ((c<MAX_NEG_ERROR)?nErrs[-(MAX_NEG_ERROR)+1]:nErrs[-c]):
  933.           ((c>MAX_POS_ERROR)?pErrs[MAX_POS_ERROR+1]:pErrs[c]));
  934. }
  936. #ifdef _SNMPv3
  937. const char* Snmp::error_msg(const Oid& v3Oid)
  938. {
  939.   // UsmStats
  940.   if (v3Oid == oidUsmStatsUnsupportedSecLevels)
  941.     return error_msg(SNMPv3_USM_UNSUPPORTED_SECURITY_LEVEL);
  943.   if (v3Oid == oidUsmStatsNotInTimeWindows)
  944.     return error_msg(SNMPv3_USM_NOT_IN_TIME_WINDOW);
  946.   if (v3Oid == oidUsmStatsUnknownUserNames )
  947.     return error_msg(SNMPv3_USM_UNKNOWN_SECURITY_NAME);
  949.   if (v3Oid == oidUsmStatsUnknownEngineIDs)
  950.     return error_msg(SNMPv3_USM_UNKNOWN_ENGINEID);
  952.   if (v3Oid == oidUsmStatsWrongDigests)
  953.     return error_msg(SNMPv3_USM_AUTHENTICATION_FAILURE);
  955.   if (v3Oid == oidUsmStatsDecryptionErrors)
  956.     return error_msg(SNMPv3_USM_DECRYPTION_ERROR);
  958.   // MPDstats
  959.   if (v3Oid == oidSnmpUnknownSecurityModels)
  960.     return error_msg(SNMPv3_MP_UNSUPPORTED_SECURITY_MODEL);
  962.   if (v3Oid == oidSnmpInvalidMsgs)
  963.     return error_msg(SNMPv3_MP_INVALID_MESSAGE);
  965.   if (v3Oid == oidSnmpUnknownPDUHandlers)
  966.     return error_msg(SNMPv3_MP_UNKNOWN_PDU_HANDLERS);
  968.   if (v3Oid == oidSnmpUnavailableContexts)
  969.     return error_msg(SNMPv3_MP_UNAVAILABLE_CONTEXT);
  971.   if (v3Oid == oidSnmpUnknownContexts)
  972.     return error_msg(SNMPv3_MP_UNKNOWN_CONTEXT);
  974.   return error_msg(MAX_POS_ERROR + 1);
  975. }
  976. #endif
  978. //------------------------[ get ]---------------------------------------
  979. int Snmp::get(Pdu &pdu, const SnmpTarget &target)
  980. {
  981.   pdu.set_type( sNMP_PDU_GET);
  982.   return snmp_engine( pdu, 0, 0, target, NULL, 0);
  983. }
  985. //------------------------[ get async ]----------------------------------
  986. int Snmp::get(Pdu &pdu, const SnmpTarget &target,
  987.               const snmp_callback callback,
  988.               const void * callback_data)
  989. {
  990.   pdu.set_type( sNMP_PDU_GET_ASYNC);
  991.   return snmp_engine( pdu, 0, 0, target, callback, callback_data);
  992. }
  994. //------------------------[ get next ]-----------------------------------
  995. int Snmp::get_next(Pdu &pdu, const SnmpTarget &target)
  996. {
  997.   pdu.set_type( sNMP_PDU_GETNEXT);
  998.   return snmp_engine( pdu, 0, 0, target, NULL, 0);
  999. }
  1001. //------------------------[ get next async ]-----------------------------
  1002. int Snmp::get_next(Pdu &pdu, const SnmpTarget &target,
  1003.                    const snmp_callback callback,
  1004.                    const void * callback_data)
  1005. {
  1006.   pdu.set_type( sNMP_PDU_GETNEXT_ASYNC);
  1007.   return snmp_engine( pdu, 0, 0, target, callback, callback_data);
  1008. }
  1010. //-------------------------[ set ]---------------------------------------
  1011. int Snmp::set(Pdu &pdu, const SnmpTarget &target)
  1012. {
  1013.   pdu.set_type( sNMP_PDU_SET);
  1014.   return snmp_engine( pdu, 0, 0, target, NULL, 0);
  1015. }
  1017. //------------------------[ set async ]----------------------------------
  1018. int Snmp::set(Pdu &pdu, const SnmpTarget &target,
  1019.               const snmp_callback callback,
  1020.               const void * callback_data)
  1021. {
  1022.   pdu.set_type( sNMP_PDU_SET_ASYNC);
  1023.   return snmp_engine( pdu, 0, 0, target, callback, callback_data);
  1024. }
  1026. //-----------------------[ get bulk ]------------------------------------
  1027. int Snmp::get_bulk(Pdu &pdu,                // pdu to use
  1028.                    const SnmpTarget &target,// destination target
  1029.                    const int non_repeaters, // number of non repeaters
  1030.                    const int max_reps)      // maximum number of repetitions
  1031. {
  1032.   pdu.set_type( sNMP_PDU_GETBULK);
  1033.   return snmp_engine( pdu, non_repeaters, max_reps, target, NULL, 0);
  1034. }
  1036. //-----------------------[ get bulk async ]------------------------------
  1037. int Snmp::get_bulk(Pdu &pdu,                 // pdu to use
  1038.                    const SnmpTarget &target, // destination target
  1039.                    const int non_repeaters,  // number of non repeaters
  1040.                    const int max_reps,       // maximum number of repetitions
  1041.                    const snmp_callback callback,// callback to use
  1042.                    const void * callback_data)  // callback data
  1043. {
  1044.   pdu.set_type( sNMP_PDU_GETBULK_ASYNC);
  1045.   return snmp_engine( pdu, non_repeaters, max_reps, target,
  1046.                       callback, callback_data);
  1047. }
  1049. //------------------------[ inform_response ]----------------------------
  1050. int Snmp::response(Pdu &pdu,                 // pdu to use
  1051.                    const SnmpTarget &target, // response target
  1052.    const SnmpSocket fd)
  1053. {
  1054.   pdu.set_type( sNMP_PDU_RESPONSE);
  1055.   return snmp_engine(pdu, 0, 0, target, NULL, 0, fd);
  1056. }
  1058. int Snmp::send_raw_data(unsigned char *send_buf,
  1059.                         size_t send_len, UdpAddress &address, SnmpSocket fd)
  1060.   REENTRANT(
  1061. {
  1062.   if (fd != INVALID_SOCKET)
  1063.     return send_snmp_request(fd, send_buf, send_len, address);
  1064.   else
  1065.   {
  1066.     if (address.get_ip_version() == Address::version_ipv4)
  1067.     {
  1068.       if (iv_snmp_session != INVALID_SOCKET)
  1069. return send_snmp_request(iv_snmp_session, send_buf,
  1070.  send_len, address);
  1071.       else
  1072. address.map_to_ipv6();
  1073.     }
  1074.     return send_snmp_request(iv_snmp_session_ipv6, send_buf,
  1075.      send_len, address);
  1076.   }
  1077. })
  1079. //-----------------------[ cancel ]--------------------------------------
  1080. int Snmp::cancel( const unsigned long request_id)
  1081. {
  1082.   eventListHolder->snmpEventList()->lock();
  1083.   int status = eventListHolder->snmpEventList()->DeleteEntry(request_id);
  1084.   eventListHolder->snmpEventList()->unlock();
  1086.   return status;
  1087. }
  1090. //----------------------[ sending report, V3 only]-----------------------
  1091. int Snmp::report(Pdu &pdu,                // pdu to send
  1092.                  const SnmpTarget &target)// destination target
  1093. {
  1094.   pdu.set_type( sNMP_PDU_REPORT);
  1095.   return snmp_engine( pdu, 0, 0, target, NULL, 0);
  1096. }
  1098. //----------------------[ blocking inform, V2 only]------------------------
  1099. int Snmp::inform(Pdu &pdu,                // pdu to send
  1100.                  const SnmpTarget &target)// destination target
  1101. {
  1102.   pdu.set_type( sNMP_PDU_INFORM);
  1103.   check_notify_timestamp(pdu);
  1104.   return snmp_engine( pdu, 0, 0, target, NULL, 0);
  1105. }
  1107. //----------------------[ asynch inform, V2 only]------------------------
  1108. int Snmp::inform(Pdu &pdu,                // pdu to send
  1109.                  const SnmpTarget &target,      // destination target
  1110.                  const snmp_callback callback,  // callback function
  1111.                  const void * callback_data)    // callback data
  1112. {
  1113.   pdu.set_type( sNMP_PDU_INFORM);
  1114.   check_notify_timestamp(pdu);
  1115.   return snmp_engine( pdu, 0, 0, target, callback, callback_data);
  1116. }
  1119. //---------------------[ send a trap ]-----------------------------------
  1120. int Snmp::trap(Pdu &pdu,                        // pdu to send
  1121.                const SnmpTarget &target)        // destination target
  1122. {
  1123.   OctetStr my_get_community;
  1124.   OctetStr my_set_community;
  1125.   GenAddress address;
  1126.   unsigned long my_timeout;
  1127.   int my_retry;
  1128.   unsigned char version;
  1129.   int status;
  1131.   debugprintf(1, "++ SNMP++, Send a Trap");
  1132.   //---------[ make sure pdu is valid ]---------------------------------
  1133.   if ( !pdu.valid())
  1134.     {
  1135.       debugprintf(0, "-- SNMP++, PDU Object Invalid");
  1136.       return  SNMP_CLASS_INVALID_PDU;
  1137.     }
  1139.   //---------[ make sure target is valid ]------------------------------
  1140.   if ( !target.valid())
  1141.     {
  1142.       debugprintf(0, "-- SNMP++, Target Object Invalid");
  1143.       return SNMP_CLASS_INVALID_TARGET;
  1144.     }
  1146.   CTarget* ctarget = NULL;
  1147.   UTarget* utarget = NULL;
  1148.   OctetStr security_name;
  1149.   int security_model;
  1151.   switch (target.get_type()) {
  1152.     case SnmpTarget::type_ctarget:
  1153.       ctarget = (CTarget*)(&target);
  1154.       break;
  1155.     case SnmpTarget::type_utarget:
  1156.       utarget = (UTarget*)(&target);
  1157.       break;
  1158.     case SnmpTarget::type_base:
  1159.       debugprintf(0, "-- SNMP++, do not use SnmpTarget, use a  CTarget or UTarget");
  1160.       return SNMP_CLASS_INVALID_TARGET;
  1161.     default:
  1162.       // target is not known
  1163.       debugprintf(0, "-- SNMP++, type of target is unknown!");
  1164.       return SNMP_CLASS_UNSUPPORTED;
  1165.   }
  1167.   if (ctarget) {
  1168.     debugprintf(3, "snmp::trap called with CTarget");
  1169.     if (!ctarget->resolve_to_C( my_get_community, my_set_community, address,
  1170.                                 my_timeout, my_retry, version))
  1171.     {
  1172.       debugprintf(0, "-- SNMP++, Resolve Fail (CTarget)");
  1173.       return SNMP_CLASS_UNSUPPORTED;
  1174.     }
  1175. #ifdef _SNMPv3
  1176.     if (version == version3)
  1177.     {
  1178.       debugprintf(0, "-- SNMP++, use UTarget for SNMPv3");
  1179.       return SNMP_CLASS_INVALID_TARGET;
  1180.     }
  1181. #endif
  1182.   }
  1183.   else { // target is not a CTarget:
  1184.     if (utarget) {
  1185.       debugprintf(3, "trap called with UTarget");
  1186.       if (!utarget->resolve_to_U( security_name, security_model, address,
  1187.   my_timeout, my_retry, version))
  1188.       {
  1189.         debugprintf(0, "-- SNMP++, Resolve Fail (UTarget)");
  1190.         return SNMP_CLASS_UNSUPPORTED;
  1191.       }
  1192. #ifdef _SNMPv3
  1193.       if (version != version3) {
  1194. #endif
  1195.         my_get_community = security_name;
  1196.         if ((security_model != SecurityModel_v1) &&
  1197.             (security_model != SecurityModel_v2)) {
  1198.           debugprintf(0, "-- SNMP++, Target contains invalid security_model/version combination");
  1199.           return SNMP_CLASS_INVALID_TARGET;
  1200.         }
  1201. #ifdef _SNMPv3
  1202.       } // end if (version != version3)
  1203. #endif
  1204.     }
  1205.     else { // target is neither CTarget nor UTarget:
  1206.       debugprintf(0, "-- SNMP++, Resolve Fail");
  1207.       return SNMP_CLASS_INVALID_TARGET;
  1208.     }
  1209.   }
  1211.   //--------[ determine request id to use ]------------------------------
  1212.   pdu.set_request_id( MyMakeReqId());
  1214.   //--------[ check timestamp, if null use system time ]-----------------
  1215.   check_notify_timestamp(pdu);
  1217.   //------[ validate address to use ]-------------------------------------
  1218.   if (!address.valid()) {
  1219.     debugprintf(0, "-- SNMP++, Bad address");
  1220.     return SNMP_CLASS_INVALID_TARGET;
  1221.   }
  1223.   if ((address.get_type() != Address::type_ip) &&
  1224.       (address.get_type() != Address::type_udp) )
  1225.     {
  1226.       debugprintf(0, "-- SNMP++, Bad address type");
  1227.       return SNMP_CLASS_TL_UNSUPPORTED;
  1228.     }
  1230.   UdpAddress udp_address(address);
  1231.   if (!udp_address.valid()) {
  1232.     debugprintf(0, "-- SNMP++, copy address failed");
  1233.     return SNMP_CLASS_RESOURCE_UNAVAIL;
  1234.   }
  1236.   //----------[ choose the target address port ]-----------------------
  1237.   if ((address.get_type() == Address::type_ip) || !udp_address.get_port())
  1238.     udp_address.set_port(SNMP_TRAP_PORT);
  1240.   //----------[ based on the target type, choose v1 or v1 trap type ]-----
  1241.   if ( version == version1)
  1242.     pdu.set_type( sNMP_PDU_V1TRAP);
  1243.   else // v2 and v3 use v2TRAP
  1244.     pdu.set_type( sNMP_PDU_TRAP);
  1246.   SnmpMessage snmpmsg;
  1248. #ifdef _SNMPv3
  1249.   if ( version == version3) {
  1251.     OctetStr engine_id = v3MP::I->get_local_engine_id();
  1252.     if (!utarget) {
  1253.       debugprintf(0, "-- SNMP++, dont know how to handle SNMPv3 without UTarget!");
  1254.       return SNMP_CLASS_INVALID_TARGET;
  1255.     }
  1257.     // set context_engine_id of pdu, if it is not set
  1258.     if (pdu.get_context_engine_id().len() == 0)
  1259.     {
  1260.       debugprintf(8, "Setting contextEngineID of Pdu to (%s)",
  1261.                   engine_id.get_printable());
  1262.       pdu.set_context_engine_id(engine_id);
  1263.     }
  1265.     debugprintf(4,"Snmp::trap:");
  1266.     debugprintf(4," engineID (%s), securityName (%s)n securityModel (%i) security_level (%i)",
  1267.                 engine_id.get_printable(), security_name.get_printable(),
  1268.                 security_model, pdu.get_security_level());
  1269.     debugprintf(4," Addr/Port (%s)",udp_address.get_printable());
  1271.     status = snmpmsg.loadv3( pdu, engine_id, security_name,
  1272.                              security_model, (snmp_version)version);
  1273.   }
  1274.   else
  1275. #endif
  1276.     status = snmpmsg.load( pdu, my_get_community, (snmp_version) version);
  1278.   if ( status != SNMP_CLASS_SUCCESS) {
  1279.     debugprintf(0, "snmp message load error!");
  1280.     return status;
  1281.   }
  1283.   lock();
  1284.   //------[ send the trap ]
  1285.   if (udp_address.get_ip_version() == Address::version_ipv4)
  1286.   {
  1287.     if (iv_snmp_session != INVALID_SOCKET)
  1288.       status = send_snmp_request(iv_snmp_session,
  1289.  snmpmsg.data(), (size_t)snmpmsg.len(),
  1290.  udp_address);
  1291.     else
  1292.     {
  1293.       udp_address.map_to_ipv6();
  1294.       status = send_snmp_request(iv_snmp_session_ipv6,
  1295.  snmpmsg.data(), (size_t)snmpmsg.len(),
  1296.  udp_address);
  1297.     }
  1298.   }
  1299.   else
  1300.     status = send_snmp_request(iv_snmp_session_ipv6,
  1301.                                snmpmsg.data(), (size_t)snmpmsg.len(),
  1302.                                udp_address);
  1304.   unlock();
  1305.   if (status != 0)
  1306.     return SNMP_CLASS_TL_FAILED;
  1308.   return SNMP_CLASS_SUCCESS;
  1309. }
  1311. //----------------[ set notify_timestamp if it is null ]-------------
  1312. #if defined (CPU) && CPU == PPC603
  1314.   struct SCommTimer
  1315.   {
  1316. unsigned long NumMS;
  1317. unsigned long FractMS;
  1318.   };
  1320.   extern "C"
  1321.   {
  1322.   void GetTime (struct SCommTimer *  Time);
  1323.   }
  1324. #endif
  1326. void Snmp::check_notify_timestamp(Pdu &pdu)
  1327. {
  1328.   // As we don't know, when the application was started,
  1329.   // use a continuously increasing notify_timestamp
  1330.   TimeTicks timestamp;
  1331.   pdu.get_notify_timestamp( timestamp);
  1332.   if (timestamp <= 0)
  1333.   {
  1334. #ifdef WIN32
  1335.     struct _timeb timebuffer;
  1336.     _ftime( &timebuffer );
  1337.     timebuffer.time -= 1103760000;   // knock off 35 years worth of seconds
  1338.     timestamp = SAFE_ULONG_CAST((timebuffer.time * 100) +
  1339. (timebuffer.millitm / 10));
  1340. #elif defined (CPU) && CPU == PPC603
  1341.     SCommTimer theTime;
  1343.     GetTime(&theTime); // This function must be defined by the application
  1345.     timestamp = theTime.NumMS/10;
  1346. #else
  1347.     struct timeval tp;
  1348.     gettimeofday(&tp, NULL);
  1349.     tp.tv_sec -= 1103760000;   // knock off 35 years worth of seconds
  1350.     timestamp = (tp.tv_sec * 100) + (tp.tv_usec / 10000);
  1351. #endif
  1353.     pdu.set_notify_timestamp( timestamp);
  1354.   }
  1355. }
  1357. //-----------------------[ read the notification filters ]----------------
  1358. int Snmp::get_notify_filter( OidCollection &trapids,
  1359.                              TargetCollection &targets,
  1360.      AddressCollection &listen_addresses)
  1361. {
  1362.   CNotifyEvent *e = eventListHolder->notifyEventList()->GetEntry(this);
  1364.   if (!e)  return SNMP_CLASS_INVALID;
  1366.   e->get_filter(trapids, targets, listen_addresses);
  1368.   return SNMP_CLASS_SUCCESS;
  1369. }
  1373. // Set the port for listening to traps and informs.
  1374. void Snmp::notify_set_listen_port(const int port)
  1375. {
  1376.   eventListHolder->notifyEventList()->set_listen_port(port);
  1377. }
  1379. // Get the port that is used for listening to traps and informs.
  1380. int Snmp::notify_get_listen_port()
  1381. {
  1382.   return eventListHolder->notifyEventList()->get_listen_port();
  1383. }
  1385. //-----------------------[ register to get traps]-------------------------
  1386. int Snmp::notify_register( const OidCollection     &trapids,
  1387.                            const TargetCollection  &targets,
  1388.                            const AddressCollection &addresses,
  1389.                            const snmp_callback      callback,
  1390.                            const void              *callback_data)
  1391. {
  1392.   int status;
  1394.   // assign callback and callback data info
  1395.   notifycallback = callback;
  1396.   notifycallback_data = (void *)callback_data;
  1398.   // remove any previous filters for this session
  1399.   eventListHolder->notifyEventList()->DeleteEntry(this);
  1401.   // add to the notify queue
  1402.   status = eventListHolder->notifyEventList()->AddEntry(this, trapids,
  1403. targets, addresses);
  1405.   iv_notify_fd = eventListHolder->notifyEventList()->get_notify_fd(); // DLD
  1407.   return status;
  1408. }
  1410. // alternate form for local listen specification
  1411. //-----------------------[ register to get traps]-------------------------
  1412. int Snmp::notify_register( const OidCollection    &trapids,
  1413.                            const TargetCollection &targets,
  1414.                            const snmp_callback     callback,
  1415.                            const void             *callback_data)
  1416. {
  1417.   AddressCollection addresses;
  1419.   return notify_register(trapids, targets, addresses,
  1420.                          callback, callback_data);
  1421. }
  1423. //-----------------------[ un-register to get traps]----------------------
  1424. int Snmp::notify_unregister()
  1425. {
  1426.   /// @todo Return error if not registered before!
  1428.   // remove from the notify queue
  1429.   eventListHolder->notifyEventList()->DeleteEntry(this);
  1431.   // null out callback information
  1432.   notifycallback = 0;
  1433.   notifycallback_data = 0;
  1435.   iv_notify_fd = INVALID_SOCKET;
  1437.   return SNMP_CLASS_SUCCESS;
  1438. }
  1440. //---------[ get / set engine ]-----------------------------------------
  1441. // The main snmp engine used for all requests
  1442. // async requests return out early and don't wait in here for
  1443. // the response
  1444. int Snmp::snmp_engine( Pdu &pdu,              // pdu to use
  1445.                        long int non_reps,     // # of non repititions
  1446.                        long int max_reps,     // # of max repititions
  1447.                        const SnmpTarget &target,    // from this target
  1448.                        const snmp_callback cb,// callback for async calls
  1449.                        const void *cbd,      // callback data
  1450.        SnmpSocket fd,
  1451.        int reports_received)
  1453. {
  1454.   long req_id;                       // pdu request id
  1455.   int status;                        // send status
  1457. #ifdef _SNMPv3
  1458.   // save original PDU for later reference
  1459.   Pdu backupPdu = pdu;
  1461.   for (int maxloops=0; maxloops<3; maxloops++)
  1462.   {
  1463. #endif
  1465.     unsigned short pdu_action;        // type of pdu to build
  1466.     unsigned short action;        // type of pdu to build
  1467.     unsigned long my_timeout;        // target specific timeout
  1468.     int my_retry;                // target specific retry
  1470.     OctetStr my_get_community;
  1471.     OctetStr my_set_community;
  1472.     GenAddress address;
  1473.     unsigned char version;
  1475.     //---------[ make sure pdu is valid ]--------------------------
  1476.     if ( !pdu.valid())
  1477.       return  SNMP_CLASS_INVALID_PDU;
  1479.     //---------[ depending on user action, map the correct pdu action]
  1480.     action = pdu.get_type();
  1481.     map_action(action, pdu_action);
  1483.     //---------[ check for correct mode ]---------------------------
  1484.     // if the class was constructed as a blocked model, callback=0
  1485.     // and async calls are attempted, an error is returned
  1486.     if (( cb == 0) &&
  1487.         ((action == sNMP_PDU_GET_ASYNC) ||
  1488.          (action == sNMP_PDU_SET_ASYNC) ||
  1489.          (action == sNMP_PDU_GETNEXT_ASYNC) ||
  1490.          (action == sNMP_PDU_GETBULK_ASYNC) ||
  1491.          (action == sNMP_PDU_INFORM_ASYNC)))
  1492.       return SNMP_CLASS_INVALID_CALLBACK;
  1494.     //---------[ more mode checking ]--------------------------------
  1495.     // if the class was constructed as an async model, callback = something
  1496.     // and blocked calls are attempted, an error is returned
  1497.     if (( cb != 0) &&
  1498.         ((action == sNMP_PDU_GET) ||
  1499.          (action == sNMP_PDU_SET) ||
  1500.          (action == sNMP_PDU_GETNEXT) ||
  1501.          (action == sNMP_PDU_GETBULK) ||
  1502.          (action == sNMP_PDU_INFORM)))
  1503.       return SNMP_CLASS_INVALID_CALLBACK;
  1505.     //---------[ make sure target is valid ]-------------------------
  1506.     // make sure that the target is valid
  1507.     if ( ! target.valid())
  1508.       return SNMP_CLASS_INVALID_TARGET;
  1510.     OctetStr community_string;
  1511.     OctetStr security_name;
  1512.     int security_model;
  1513.     const CTarget* ctarget = NULL;
  1514.     const UTarget* utarget = NULL;
  1516.     switch (target.get_type())
  1517.     {
  1518.       case SnmpTarget::type_ctarget:
  1519.         ctarget = (CTarget*)(&target);
  1520.         break;
  1521.       case SnmpTarget::type_utarget:
  1522.         utarget = (UTarget*)(&target);
  1523.         break;
  1524.       case SnmpTarget::type_base:
  1525.         debugprintf(0, "-- SNMP++, do not use SnmpTarget,"
  1526.                     "use a  CTarget or UTarget");
  1527.         return SNMP_CLASS_INVALID_TARGET;
  1528.       default:
  1529.         /* target is not known */
  1530.         debugprintf(0, "-- SNMP++, type of target is unknown!");
  1531.         return SNMP_CLASS_UNSUPPORTED;
  1532.     }
  1534.     if (ctarget) /* Is is a CTarget? */
  1535.     {
  1536.       debugprintf(3, "snmp_engine called with CTarget");
  1537.       if (!ctarget->resolve_to_C( my_get_community, my_set_community,
  1538.                                   address, my_timeout, my_retry, version))
  1539.       {
  1540.         debugprintf(0, "-- SNMP++, Resolve Fail (CTarget)");
  1541.         return SNMP_CLASS_UNSUPPORTED;
  1542.       }
  1543. #ifdef _SNMPv3
  1544.       if ((version == version3) ||
  1545.           (action == sNMP_PDU_REPORT))
  1546.       {
  1547.         debugprintf(0, "-- SNMP++, use UTarget for SNMPv3");
  1548.         return SNMP_CLASS_INVALID_TARGET;
  1549.       }
  1550. #endif
  1551.       //----------[ use the appropriate community string ]-----------------
  1552.       if (( action == sNMP_PDU_GET) ||
  1553.           ( action == sNMP_PDU_GET_ASYNC) ||
  1554.           ( action == sNMP_PDU_GETNEXT) ||
  1555.           ( action == sNMP_PDU_GETNEXT_ASYNC) ||
  1556.           ( action == sNMP_PDU_GETBULK) ||
  1557.           ( action == sNMP_PDU_GETBULK_ASYNC) ||
  1558.           ( action == sNMP_PDU_INFORM) ||
  1559.           ( action == sNMP_PDU_INFORM_ASYNC) ||
  1560.           ( action == sNMP_PDU_RESPONSE))
  1561.         community_string = my_get_community;
  1562.       else /* got to be a set */
  1563.         community_string = my_set_community;
  1564.     }
  1565.     else if (utarget)  /* Is is a UTarget? */
  1566.     {
  1567.       debugprintf(3, "snmp_engine called with UTarget");
  1568.       if (!utarget->resolve_to_U( security_name, security_model,
  1569.                                   address, my_timeout,
  1570.                                   my_retry, version))
  1571.       {
  1572.         debugprintf(0, "-- SNMP++, Resolve Fail (UTarget)");
  1573.         return SNMP_CLASS_UNSUPPORTED;
  1574.       }
  1575. #ifdef _SNMPv3
  1576.       if (version != version3)
  1577.       {
  1578. #endif
  1579.         community_string = security_name;
  1580.         if ((security_model != SecurityModel_v1) &&
  1581.             (security_model != SecurityModel_v2)) {
  1582.           debugprintf(0, "-- SNMP++, Target contains invalid security_model/version combination");
  1583.           return SNMP_CLASS_INVALID_TARGET;
  1584.         }
  1585. #ifdef _SNMPv3
  1586.       } // end if (version != version3)
  1587. #endif
  1588.     }
  1589.     else
  1590.     { // target is neither CTarget nor UTarget (should not happen)
  1591.       debugprintf(0, "-- SNMP++, Resolve Fail");
  1592.       return SNMP_CLASS_INVALID_TARGET;
  1593.     }
  1595.     if (!address.valid())
  1596.     {
  1597.       debugprintf(0, "-- SNMP++, Target contains invalid address");
  1598.       return SNMP_CLASS_INVALID_TARGET;
  1599.     }
  1601.     //----------[ validate the target address ]--------------------------
  1602.     if ((address.get_type() != Address::type_ip) &&
  1603.         (address.get_type() != Address::type_udp) )
  1604.     {
  1605.       debugprintf(0, "-- SNMP++, Bad address type");
  1606.       return SNMP_CLASS_TL_UNSUPPORTED;
  1607.     }
  1609.     UdpAddress udp_address(address);
  1610.     if (!udp_address.valid())
  1611.     {
  1612.       debugprintf(0, "-- SNMP++, Bad address");
  1613.       return SNMP_CLASS_RESOURCE_UNAVAIL;
  1614.     }
  1616.     //----------[ choose the target address port ]-----------------------
  1617.     if ((address.get_type() == Address::type_ip) || !udp_address.get_port())
  1618.     {
  1619.       if (pdu_action == sNMP_PDU_INFORM)
  1620.         udp_address.set_port(SNMP_TRAP_PORT);
  1621.       else
  1622.         udp_address.set_port(SNMP_PORT);
  1623.     }
  1624.     // otherwise port was already set
  1626.     // check socket to use
  1627.     SnmpSocket iv_session_used = fd;
  1629.     if (fd == INVALID_SOCKET)
  1630.     {
  1631.       if (udp_address.get_ip_version() == Address::version_ipv4)
  1632.       {
  1633.         if (iv_snmp_session != INVALID_SOCKET)
  1634.   iv_session_used = iv_snmp_session;
  1635. else
  1636. {
  1637.   udp_address.map_to_ipv6();
  1638.   iv_session_used = iv_snmp_session_ipv6;
  1639. }
  1640.       }
  1641.       else
  1642. iv_session_used = iv_snmp_session_ipv6;
  1643.     }
  1645.     if ((pdu_action != sNMP_PDU_RESPONSE) &&
  1646.         (pdu_action != sNMP_PDU_REPORT))
  1647.     {
  1648.       // set error index to none
  1649.       pdu.set_error_index(0);
  1651.       // determine request id to use
  1652.       req_id = MyMakeReqId();
  1653.       pdu.set_request_id(req_id);
  1654.     }
  1656.     //---------[ map GetBulk over v1 to GetNext ]-------------------------
  1657.     if (( pdu_action == sNMP_PDU_GETBULK)&&( (snmp_version)version== version1))
  1658.       pdu_action = sNMP_PDU_GETNEXT;
  1659.     if ( pdu_action == sNMP_PDU_GETBULK) {
  1660.       pdu.set_error_status((int) non_reps);
  1661.       pdu.set_error_index((int) max_reps);
  1662.     }
  1664.     pdu.set_type( pdu_action);
  1665.     SnmpMessage snmpmsg;
  1667. #ifdef _SNMPv3
  1668.     if (version == version3)
  1669.     {
  1670.       if (!utarget)
  1671.       {
  1672.         debugprintf(0, "-- SNMP++, need UTarget to send SNMPv3 message!");
  1673.         return SNMP_CLASS_INVALID_TARGET;
  1674.       }
  1675.       OctetStr engine_id;
  1676.       utarget->get_engine_id(engine_id);
  1677.       if (engine_id.len() == 0)
  1678.       {
  1679.         if (v3MP::I->get_from_engine_id_table(engine_id,
  1680.     (char*)udp_address.get_printable())
  1681.             == SNMPv3_MP_OK )
  1682.         {
  1683.   // Override const here
  1684.           ((UTarget*)utarget)->set_engine_id(engine_id);
  1685.         } // else: engineID="" --> automatic engineID discovery
  1686.       }
  1687.       // set context_engine_id of pdu, if it is not set
  1688.       if (pdu.get_context_engine_id().len() == 0)
  1689.       {
  1690.         debugprintf(8, "Setting contextEngineID of Pdu to (%s)",
  1691.                     engine_id.get_printable());
  1692.         pdu.set_context_engine_id(engine_id);
  1693.         backupPdu.set_context_engine_id(engine_id);
  1694.       }
  1696.       debugprintf(4,"Snmp::snmp_engine: engineID (%s), securityName (%s)"
  1697.                   "securityModel (%i) security_level (%i)",
  1698.                   engine_id.get_printable(), security_name.get_printable(),
  1699.                   security_model, pdu.get_security_level());
  1700.       debugprintf(4," Addr/Port (%s)",udp_address.get_printable());
  1702.       status = snmpmsg.loadv3( pdu, engine_id, security_name,
  1703.                                security_model, (snmp_version)version);
  1704.     }
  1705.     else
  1706. #endif
  1707.       status = snmpmsg.load( pdu, community_string,(snmp_version) version);
  1709.     if ( status != SNMP_CLASS_SUCCESS)
  1710.     {
  1711.       debugprintf(0, "snmp message load error!");
  1712.       return status;
  1713.     }
  1715.     //------[ send the request ]
  1716.     lock();
  1717.     status = send_snmp_request(iv_session_used,
  1718.        snmpmsg.data(), (size_t) snmpmsg.len(),
  1719.        udp_address);
  1720.     unlock();
  1722.     if ( status != 0)
  1723.       return SNMP_CLASS_TL_FAILED;
  1725.     if ((pdu_action == sNMP_PDU_RESPONSE) ||
  1726.         (pdu_action == sNMP_PDU_REPORT))
  1727.       return SNMP_CLASS_SUCCESS; // don't wait for an answer
  1729. #ifdef _SNMPv3
  1730.     if ((version == version3) && ((action == sNMP_PDU_GET_ASYNC) ||
  1731.                                   (action == sNMP_PDU_SET_ASYNC) ||
  1732.                                   (action == sNMP_PDU_GETNEXT_ASYNC) ||
  1733.                                   (action == sNMP_PDU_GETBULK_ASYNC) ||
  1734.                                   (action == sNMP_PDU_INFORM_ASYNC))) {
  1735.       // add callback for v3
  1736.       struct V3CallBackData *v3CallBackData;
  1737.       v3CallBackData = new struct V3CallBackData;
  1739.       v3CallBackData->pdu = new Pdu(pdu);
  1740.       v3CallBackData->pdu->set_type(backupPdu.get_type());
  1741.       v3CallBackData->non_reps = non_reps;
  1742.       v3CallBackData->max_reps = max_reps;
  1744.       v3CallBackData->target = new UTarget(*utarget);
  1745.       v3CallBackData->oldCallback = cb;
  1746.       v3CallBackData->cbd = cbd;
  1747.       v3CallBackData->reports_received = reports_received;
  1749.       // Add the message to the message queue
  1750.       eventListHolder->snmpEventList()->AddEntry(req_id, this, iv_session_used,
  1751.  target, pdu,
  1752.  snmpmsg.data(),
  1753.  (size_t) snmpmsg.len(),
  1754.  udp_address,
  1755.  v3CallBack,
  1756.  (void *)v3CallBackData);
  1757.     }
  1758.     else
  1759. #endif
  1760.     {
  1761.       eventListHolder->snmpEventList()->AddEntry( req_id, this,
  1762.   iv_session_used,
  1763.   target, pdu,
  1764.   snmpmsg.data(),
  1765.   (size_t) snmpmsg.len(),
  1766.   udp_address,
  1767.   cb, (void *)cbd);
  1768.     }
  1769.     //----[ if an async mode request then return success ]-----
  1770.     if (( action == sNMP_PDU_GET_ASYNC) ||
  1771.         ( action == sNMP_PDU_SET_ASYNC) ||
  1772.         ( action == sNMP_PDU_GETNEXT_ASYNC) ||
  1773.         ( action == sNMP_PDU_GETBULK_ASYNC) ||
  1774.         ( action == sNMP_PDU_INFORM_ASYNC))
  1775.       return SNMP_CLASS_SUCCESS;
  1777.     // Now wait for the response (or timeout) for our message.
  1778.     // This handles any necessary retries.
  1779.     status = eventListHolder->SNMPBlockForResponse(req_id, pdu);
  1781.     if (pdu.get_type() != REPORT_MSG) {
  1782. #ifdef _SNMPv3
  1783.       if (status == SNMPv3_MP_OK)
  1784.         return SNMP_CLASS_SUCCESS;
  1785.       else
  1786. #endif
  1787.         return status;
  1788.     }
  1789. #ifdef _SNMPv3
  1790.     else
  1791.       if (status == SNMPv3_USM_DECRYPTION_ERROR)
  1792.         return status;
  1794.     // We received a REPORT-MSG, check if we should try another time
  1795.     Vb first_vb;
  1796.     Oid first_oid;
  1797.     pdu.get_vb(first_vb,0);
  1798.     first_vb.get_oid(first_oid);
  1800.     debugprintf(1,"received oid: %s with value: %s",
  1801.                 first_vb.get_printable_oid(), first_vb.get_printable_value());
  1802.     debugprintf(1, "%s", error_msg(first_oid));
  1804.     switch (maxloops)
  1805.     {
  1806.       case 0:
  1807.       {
  1808. // This was our first try, so we may receive a unknown engine id 
  1809. // report or a not in time window report
  1810.         if (first_oid == oidUsmStatsUnknownEngineIDs)
  1811.         {
  1812.   pdu = backupPdu; // restore pdu and try again
  1813.   break;
  1814.         }
  1815.         else if (first_oid == oidUsmStatsNotInTimeWindows)
  1816.         {
  1817.           ++maxloops; // increase it, as the next request must succeed
  1818.   pdu = backupPdu; // restore pdu and try again
  1819.   break;
  1820.         }
  1821.         return (status == SNMPv3_MP_OK) ? SNMP_CLASS_SUCCESS : status;
  1822.       }
  1823.       case 1:
  1824.       {
  1825. // This was the second try, engine id discovery should be ok
  1826. // so test only for not in time report
  1827.         if (first_oid == oidUsmStatsNotInTimeWindows)
  1828.         {
  1829.   pdu = backupPdu; // restore pdu and try again
  1830.   break;
  1831.         }
  1832.         return (status == SNMPv3_MP_OK) ? SNMP_CLASS_SUCCESS : status;
  1833.       }
  1834.       case 2:
  1835.       {
  1836. // We tried three times: one for engine id discovery, one for
  1837. // time sync and we still get a report --> somethings wrong!
  1838.         return (status == SNMPv3_MP_OK) ? SNMP_CLASS_SUCCESS : status;
  1839.       }
  1840.     }
  1841.   }
  1842. #endif
  1843.   return status;
  1844. }
  1846. #ifdef _SNMPv3
  1847. int Snmp::engine_id_discovery(OctetStr &engine_id,
  1848.       const int timeout_sec,
  1849.       const UdpAddress &addr)
  1850. {
  1851.   unsigned char *message;
  1852.   int message_length;
  1853.   SnmpSocket sock;
  1854.   SnmpMessage snmpmsg;
  1856.   unsigned char snmpv3_message[60] = {
  1857.     0x30, 0x3a,
  1858.           0x02, 0x01, 0x03,                   // Version: 3
  1859.           0x30, 0x0f,                         // global header length 15
  1860.                 0x02, 0x03, 0x01, 0x00, 0x00, // message id
  1861.                 0x02, 0x02, 0x10, 0x00,       // message max size
  1862.                 0x04, 0x01, 0x04,             // flags (reportable set)
  1863.                 0x02, 0x01, 0x03,             // security model USM
  1864.           0x04, 0x10,                         // security params
  1865.                 0x30, 0x0e,
  1866.                       0x04, 0x00,             // no engine id
  1867.                       0x02, 0x01, 0x00,       // boots 0
  1868.                       0x02, 0x01, 0x00,       // time 0
  1869.                       0x04, 0x00,             // no user name
  1870.                       0x04, 0x00,             // no auth par
  1871.                       0x04, 0x00,             // no priv par
  1872.           0x30, 0x12,
  1873.                 0x04, 0x00,                   // no context engine id
  1874.                 0x04, 0x00,                   // no context name
  1875.           0xa0, 0x0c,                         // GET PDU
  1876.                 0x02, 0x02, 0x34, 0x26,       // request id
  1877.                 0x02, 0x01, 0x00,             // error status no error
  1878.                 0x02, 0x01, 0x00,             // error index 0
  1879.                 0x30, 0x00                    // no data
  1880.   };
  1882.   message = (unsigned char *)snmpv3_message;
  1883.   message_length = 60;
  1885.   engine_id.clear();
  1887.   UdpAddress uaddr(addr);
  1889.   if (uaddr.get_ip_version() == Address::version_ipv4)
  1890.   {
  1891.     if (iv_snmp_session != INVALID_SOCKET)
  1892.       sock = iv_snmp_session;
  1893.     else
  1894.     {
  1895.       uaddr.map_to_ipv6();
  1896.       sock = iv_snmp_session_ipv6;
  1897.     }
  1898.   }
  1899.   else
  1900.     sock = iv_snmp_session_ipv6;
  1902.   lock();
  1903.   if (send_snmp_request(sock, message, message_length, uaddr) < 0)
  1904.   {
  1905.     debugprintf(0, "Error sending message.");
  1906.     unlock();
  1907.     return SNMP_CLASS_TL_FAILED;
  1908.   }
  1910.   // now wait for the responses
  1911.   Pdu dummy_pdu;
  1912.   fd_set readfds;
  1913.   int nfound = 0;
  1914.   struct timeval fd_timeout;
  1915.   msec end_time;
  1917.   end_time += timeout_sec * 1000;
  1919.   do
  1920.   {
  1921.     FD_ZERO(&readfds);
  1923.     FD_SET(sock, &readfds);
  1925.     end_time.GetDeltaFromNow(fd_timeout);
  1927.     nfound = select((int)(sock + 1), &readfds, NULL, NULL, &fd_timeout);
  1929.     if ((nfound > 0) && (FD_ISSET(sock, &readfds)))
  1930.     {
  1931.       // receive message
  1932.       UdpAddress from;
  1933.       int res = receive_snmp_response(sock, *this, dummy_pdu,
  1934.       from, true /* process_msg */);
  1935.       if ((res == SNMP_CLASS_SUCCESS) ||
  1936.   (res == SNMPv3_MP_UNKNOWN_PDU_HANDLERS))
  1937.       {
  1938. dummy_pdu.get_context_engine_id(engine_id);
  1939. debugprintf(3, "Response received from (%s) id %s.",
  1940.     from.get_printable(), engine_id.get_printable());
  1941. return SNMP_CLASS_SUCCESS;
  1942.       }
  1943.       else
  1944.       {
  1945. debugprintf(0, "Error receiving discovery response.");
  1946.       }
  1947.     }
  1948.   } while ((nfound > 0) ||
  1949.    (fd_timeout.tv_sec > 0) || (fd_timeout.tv_usec > 0));
  1950.   unlock();
  1952.   return SNMP_CLASS_TIMEOUT;
  1953. }
  1954. #endif
  1956. // Send a SNMP Broadcast message.
  1957. int Snmp::broadcast_discovery(UdpAddressCollection &addresses,
  1958.       const int timeout_sec,
  1959.       const UdpAddress &addr,
  1960.       const snmp_version version,
  1961.       const OctetStr *community)
  1962. {
  1963.   unsigned char *message;
  1964.   int message_length;
  1965.   SnmpSocket sock;
  1966.   SnmpMessage snmpmsg;
  1968. #ifdef _SNMPv3
  1969.   unsigned char snmpv3_broadcast_message[60] = {
  1970.     0x30, 0x3a,
  1971.           0x02, 0x01, 0x03,                   // Version: 3
  1972.           0x30, 0x0f,                         // global header length 15
  1973.                 0x02, 0x03, 0x01, 0x00, 0x00, // message id
  1974.                 0x02, 0x02, 0x10, 0x00,       // message max size
  1975.                 0x04, 0x01, 0x04,             // flags (reportable set)
  1976.                 0x02, 0x01, 0x03,             // security model USM
  1977.           0x04, 0x10,                         // security params
  1978.                 0x30, 0x0e,
  1979.                       0x04, 0x00,             // no engine id
  1980.                       0x02, 0x01, 0x00,       // boots 0
  1981.                       0x02, 0x01, 0x00,       // time 0
  1982.                       0x04, 0x00,             // no user name
  1983.                       0x04, 0x00,             // no auth par
  1984.                       0x04, 0x00,             // no priv par
  1985.           0x30, 0x12,
  1986.                 0x04, 0x00,                   // no context engine id
  1987.                 0x04, 0x00,                   // no context name
  1988.           0xa0, 0x0c,                         // GET PDU
  1989.                 0x02, 0x02, 0x34, 0x26,       // request id
  1990.                 0x02, 0x01, 0x00,             // error status no error
  1991.                 0x02, 0x01, 0x00,             // error index 0
  1992.                 0x30, 0x00                    // no data
  1993.   };
  1995.   if (version == version3)
  1996.   {
  1997.     message = (unsigned char *)snmpv3_broadcast_message;
  1998.     message_length = 60;
  1999.   }
  2000.   else
  2001. #endif
  2002.   {
  2003.     Pdu pdu;
  2004.     Vb vb;
  2005.     OctetStr get_community;
  2007.     vb.set_oid("1.3.6.1.2.1.1.1.0");
  2008.     pdu +=vb;
  2009.     pdu.set_error_index(0);            // set error index to none
  2010.     pdu.set_request_id(MyMakeReqId()); // determine request id to use
  2011.     pdu.set_type(sNMP_PDU_GET);        // set pdu type
  2013.     if (community)
  2014.       get_community = *community;
  2015.     else
  2016.       get_community = "public";
  2018.     int status = snmpmsg.load(pdu, get_community, version);
  2019.     if (status != SNMP_CLASS_SUCCESS)
  2020.     {
  2021.       debugprintf(0, "Error encoding broadcast pdu (%i).", status);
  2022.       return status;
  2023.     }
  2024.     message        = snmpmsg.data();
  2025.     message_length = snmpmsg.len();
  2026.   }
  2028.   UdpAddress uaddr(addr);
  2030.   if (uaddr.get_ip_version() == Address::version_ipv4)
  2031.   {
  2032.     if (iv_snmp_session != INVALID_SOCKET)
  2033.       sock = iv_snmp_session;
  2034.     else
  2035.     {
  2036.       uaddr.map_to_ipv6();
  2037.       sock = iv_snmp_session_ipv6;
  2038.     }
  2039.   }
  2040.   else
  2041.     sock = iv_snmp_session_ipv6;
  2043.   lock();
  2044.   if (send_snmp_request(sock, message, message_length, uaddr) < 0)
  2045.   {
  2046.     debugprintf(0, "Error sending broadast.");
  2047.     unlock();
  2048.     return SNMP_CLASS_TL_FAILED;
  2049.   }
  2051.   // now wait for the responses
  2052.   Pdu dummy_pdu;
  2053.   fd_set readfds;
  2054.   int nfound = 0;
  2055.   struct timeval fd_timeout;
  2056.   msec end_time;
  2058.   end_time += timeout_sec * 1000;
  2060.   do
  2061.   {
  2062.     FD_ZERO(&readfds);
  2064.     FD_SET(sock, &readfds);
  2066.     end_time.GetDeltaFromNow(fd_timeout);
  2068.     nfound = select((int)(sock + 1), &readfds, NULL, NULL, &fd_timeout);
  2070.     if ((nfound > 0) && (FD_ISSET(sock, &readfds)))
  2071.     {
  2072.       // receive message
  2073.       UdpAddress from;
  2074.       if (receive_snmp_response(sock, *this, dummy_pdu,
  2075. from, false /* process_msg */)
  2076.   == SNMP_CLASS_SUCCESS)
  2077.       {
  2078. addresses += from;
  2079.       }
  2080.       else
  2081.       {
  2082. debugprintf(0, "Error receiving broadcast response.");
  2083.       }
  2084.     }
  2085.   } while ((nfound > 0) ||
  2086.    (fd_timeout.tv_sec > 0) || (fd_timeout.tv_usec > 0));
  2087.   unlock();
  2089. #ifdef __DEBUG
  2090.   for (int i=0; i < addresses.size(); ++i)
  2091.   {
  2092.     debugprintf(3, "Broadcast response received from (%s).",
  2093. addresses[i].get_printable());
  2094.   }
  2095. #endif
  2096.   return 0;
  2097. }
  2099. //     Starts the working thread for the recovery of the pending events
  2100. bool Snmp::start_poll_thread(const int select_timeout)
  2101. {
  2102. #ifdef _THREADS
  2103.     // store the timeout value for later
  2104.     m_iPollTimeOut = select_timeout;
  2106.     // if we are already running return ok
  2107.     if (m_bThreadRunning == true) return true;
  2109.     // since we are here, things must be fine so far...
  2110.     m_bThreadRunning = true;
  2112.     // start the ProcessThread function....
  2113. #ifdef WIN32
  2114.     DWORD id;
  2115.     m_hThread = CreateThread(NULL, 0,
  2116.        (LPTHREAD_START_ROUTINE)&Snmp::process_thread,
  2117.        this, 0, &id);
  2118.     if (m_hThread == NULL)
  2119.     {
  2120.         debugprintf(0, "Could not create ProcessThread");
  2121. m_bThreadRunning = false;
  2122.     }
  2123. #elif defined (CPU) && CPU == PPC603
  2124. m_hThread = taskSpawn("Snmp::process_thread",  0, 0, 10000, (int (*)(...))Snmp::process_thread,  (int)this, 0, 0, 0, 0, 0, 0, 0, 0, 0);
  2125.     if (m_hThread == ERROR)
  2126.     {
  2127. // Could not create thread.
  2128.         debugprintf(0, "Could not create ProcessThread");
  2129. m_bThreadRunning = false;
  2130.     }
  2131. #else
  2132.     int rc = pthread_create(&m_hThread, NULL, Snmp::process_thread,
  2133.     (void*) this);
  2134.     if (rc)
  2135.     {
  2136. // Could not create thread.
  2137.         debugprintf(0, "Could not create ProcessThread");
  2138. m_bThreadRunning = false;
  2139.     }
  2140. #endif
  2141. #endif
  2142.     return m_bThreadRunning;
  2143. }
  2145. ///////////////////////////////////////////////////////////////////////////////
  2146. // stop_poll_thread
  2147. //     Stops the recovery of the pending events
  2148. //
  2149. ///////////////////////////////////////////////////////////////////////////////
  2150. void Snmp::stop_poll_thread()
  2151. {
  2152.     if (m_bThreadRunning == false) return;
  2154. #ifdef _THREADS
  2155.     // stop the thread
  2156.     m_bThreadRunning = false;
  2158.     // Wait for the working thread to stop....
  2159. #ifdef WIN32
  2160.     ::WaitForSingleObject(m_hThread, INFINITE);
  2161. #elif defined (CPU) && CPU == PPC603
  2162. while (taskIdVerify(m_hThread) == OK)
  2163. taskDelay(10);
  2164. #else
  2165.     int status;
  2166.     pthread_join(m_hThread, (void**) &status); 
  2167. #endif
  2168. #endif
  2169. }
  2171. #ifdef WIN32
  2172. int Snmp::process_thread(Snmp *pSnmp)
  2173. {
  2174. #else
  2175. void* Snmp::process_thread(void *arg)
  2176. {
  2177.     Snmp* pSnmp = (Snmp*) arg;
  2178. #endif // !WIN32
  2180.     // Loop as long as we haven't stopped
  2181.     while (pSnmp->is_running())
  2182.     {
  2183. pSnmp->eventListHolder
  2184.      ->SNMPProcessEvents(pSnmp->m_iPollTimeOut);
  2185.     }
  2187. #ifdef _THREADS
  2188. #ifndef WIN32
  2189. #if defined (CPU) && CPU == PPC603
  2190. exit(0);
  2191. #else
  2192.     pthread_exit(0);
  2193. #endif
  2194. #endif
  2195. #endif
  2196.     return 0;
  2197. }
  2199. #ifdef SNMP_PP_NAMESPACE
  2200. }; // end of namespace Snmp_pp
  2201. #endif