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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > SNMP编程 > 查看源码
uxsnmp.cpp
资源名称：snmp_pp.rar　[点击查看]
上传用户：ets1996
上传日期：2014-09-30
资源大小：353k
文件大小：66k
源码类别：

SNMP编程

开发平台：

Visual C++

uxsnmp.cpp：源码内容
  1. /*_############################################################################
  2.   _## 
  3.   _##  uxsnmp.cpp  
  4.   _##
  5.   _##  SNMP++v3.2.22
  6.   _##  -----------------------------------------------
  7.   _##  Copyright (c) 2001-2007 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, Wed May  2 23:22:30 CEST 2007 
  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 282 2007-03-22 22:03:45Z katz $";
  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"
  82. #include "snmp_pp/log.h"
  84. #if defined (CPU) && CPU == PPC603
  85. #include <sockLib.h> 
  86. #include <taskLib.h> 
  87. #endif
  89. #ifdef SNMP_PP_NAMESPACE
  90. namespace Snmp_pp {
  91. #endif
  93. //-----[ special includes ]-------------------------------------------
  94. extern "C"
  95. {
  96.   //------------[ if using Wind-U, then bring in the ms-windows header ]
  97. #ifndef WIN32
  98. #ifdef WU_APP
  99.   WORD app_hinst;
  100. #else
  101.   typedef short WORD;
  102.   typedef long DWORD;
  103. #endif
  104. #endif
  105. }
  107. //-----[ macros ]------------------------------------------------------
  108. #define DEFAULT_TIMEOUT 1000  // one second default timeout
  109. #define DEFAULT_RETRIES 1     // no retry default
  110. #define SNMP_PORT 161         // port # for SNMP
  111. #define SNMP_TRAP_PORT 162    // port # for SNMP traps
  113. #ifdef WIN32
  114. #ifdef __BCPLUSPLUS__
  115. #define _timeb timeb
  116. #define _ftime ftime
  117. #endif
  118. #define close closesocket
  119. #endif
  121. //--------[ globals ]---------------------------------------------------
  123. //--------------[ well known trap ids ]-----------------------------------
  124. const coldStartOid coldStart;
  125. const warmStartOid warmStart;
  126. const linkDownOid linkDown;
  127. const linkUpOid linkUp;
  128. const authenticationFailureOid authenticationFailure;
  129. const egpNeighborLossOid egpNeighborLoss;
  130. const snmpTrapEnterpriseOid snmpTrapEnterprise;
  133. #ifdef _SNMPv3
  135. void v3CallBack(int reason, Snmp *snmp, Pdu &pdu, SnmpTarget &target, void *v3cd)
  136. {
  137.   Snmp::V3CallBackData *cbData;
  138.   cbData = (Snmp::V3CallBackData*)v3cd;
  140.   Vb tmpvb;
  141.   pdu.get_vb(tmpvb,0);
  143.   debugprintf(5, "v3CallBack: received oid: %s with value: %s",
  144.               tmpvb.get_printable_oid(), tmpvb.get_printable_value());
  145.   debugprintf(5, "v3CallBack: error_msg (%s), pdu_type (%i)",
  146.       snmp->error_msg(tmpvb.get_oid()), pdu.get_type());
  148.   if ((pdu.get_type() == REPORT_MSG) &&
  149.       (((tmpvb.get_oid() == oidUsmStatsUnknownEngineIDs) &&
  150. (cbData->reports_received == 0)) ||
  151.        ((tmpvb.get_oid() == oidUsmStatsNotInTimeWindows) &&
  152. (cbData->reports_received <= 1)))) {
  153.     // hide those reports from user
  154.     int rc;
  155.     if ((cbData->pdu) && (cbData->target)) {
  156.       rc = snmp->snmp_engine(*(cbData->pdu), cbData->non_reps,
  157.                              cbData->max_reps, *(cbData->target),
  158.                              (snmp_callback)(cbData->oldCallback),
  159.                              (void *)cbData->cbd, INVALID_SOCKET,
  160.      cbData->reports_received + 1);
  161.       debugprintf(3,"v3CallBack: snmp_engine called, rc (%i)", rc);
  162.     }
  163.     else
  164.       rc = SNMP_CLASS_ERROR;
  166.     if (rc != SNMP_CLASS_SUCCESS) {
  167.       // call callback if snmp_engine failed or pdu or target was 0
  168.       debugprintf(3,"v3CallBack: calling user callback");
  169.       snmp_callback tmp_callBack;
  170.       tmp_callBack = (snmp_callback)(cbData->oldCallback);
  171.       tmp_callBack(rc, snmp, pdu, target, (void *)cbData->cbd);
  172.     }
  173.   }
  174.   else {
  175.     debugprintf(3,"v3CallBack: calling user callback");
  176.     snmp_callback tmp_callBack;
  177.     tmp_callBack = (snmp_callback)(cbData->oldCallback);
  178.     tmp_callBack(reason, snmp, pdu, target, (void *)cbData->cbd);
  179.   }
  180.   // save to delete it here, because either snmp_engine created a new
  181.   // callback entry or the user specified callback has been called
  182.   if (cbData->pdu) {
  183.     delete cbData->pdu;
  184.     cbData->pdu = 0;
  185.   }
  186.   if (cbData->target) {
  187.     delete cbData->target;
  188.     cbData->target = 0;
  189.   }
  190.   delete cbData;
  191.   return;
  192. }
  194. #endif
  196. //--------[ make the pdu request id ]-----------------------------------
  197. // return a unique rid, clock can be too slow , so use current_rid
  198. long Snmp::MyMakeReqId()
  199. {
  200.   long rid;
  201.   eventListHolder->snmpEventList()->lock();
  202.   do {
  203.     rid = ++current_rid;
  205. #ifdef INVALID_REQID
  206.     debugprintf(-10, "nWARNING: Using constand RequestID!n");
  207.     rid = 0xc0de;
  208. #endif
  210.     if ( current_rid > PDU_MAX_RID)
  211.     {
  212.       current_rid = rid = PDU_MIN_RID;
  213.       // let other tasks proceed
  214.       eventListHolder->snmpEventList()->unlock();
  215.       struct timeval tv;
  216.       tv.tv_sec = 0;
  217.       tv.tv_usec = 100;
  218.       select(0, 0, 0, 0, &tv);
  219.       eventListHolder->snmpEventList()->lock();
  220.     }
  221.   } while (eventListHolder->snmpEventList()->GetEntry(rid));
  222.   eventListHolder->snmpEventList()->unlock();
  224.   return rid;
  225. }
  227. //---------[ Send SNMP Request ]---------------------------------------
  228. // Send out a snmp request
  229. DLLOPT int send_snmp_request(SnmpSocket sock, unsigned char *send_buf,
  230.                              size_t send_len, Address & address)
  231. {
  232.   // UX only supports UDP type addresses (addr and port) right now
  233.   if (address.get_type() != Address::type_udp)
  234.     return -1;// unsupported address type
  236.   debugprintf(1, "++ SNMP++: sending to %s:",
  237.               ((UdpAddress &)address).UdpAddress::get_printable());
  238.   debughexprintf(5, send_buf, SAFE_UINT_CAST(send_len));
  240.   int send_result;
  242.   if (((UdpAddress &)address).get_ip_version() == Address::version_ipv4)
  243.   {
  244.     // prepare the destination address
  245.     struct sockaddr_in agent_addr;  // send socket struct
  246.     memset(&agent_addr, 0, sizeof(agent_addr));
  247.     agent_addr.sin_family = AF_INET;
  248.     agent_addr.sin_addr.s_addr
  249.               = inet_addr(((IpAddress &)address).IpAddress::get_printable());
  250.     agent_addr.sin_port = htons(((UdpAddress &)address).get_port());
  252.     send_result = sendto(sock, (char*) send_buf, SAFE_INT_CAST(send_len), 0,
  253.                          (struct sockaddr*) &agent_addr, sizeof(agent_addr));
  254.   }
  255.   else
  256.   {
  257. #ifdef SNMP_PP_IPv6
  258.     struct sockaddr_in6 agent_addr;
  259.     memset(&agent_addr, 0, sizeof(agent_addr));
  260.     inet_pton(AF_INET6, ((IpAddress &)address).IpAddress::get_printable(),
  261.               &agent_addr.sin6_addr);
  262.     agent_addr.sin6_family = AF_INET6;
  263.     agent_addr.sin6_port = htons(((UdpAddress &)address).get_port());
  265.     send_result = sendto( sock, (char*) send_buf, send_len, 0,
  266.                           (struct sockaddr*) &agent_addr, sizeof(agent_addr));
  267. #else
  268.     debugprintf(0, "User error: Enable IPv6 and recompile snmp++.");
  269.     return -1;
  270. #endif
  271.   }
  273.   if (send_result < 0)
  274.   {
  275.     debugprintf(0, "Error sending packet: %s", strerror(errno));
  276.     return -1; // send error!
  277.   }
  279.   return 0;
  280. }
  282. //---------[ receive a snmp response ]---------------------------------
  283. // Receive a response from the specified socket.
  284. // This function does not set the request id in the pdu if
  285. // any error occur in receiving or parsing.  This is important
  286. // because the caller initializes this to zero and checks it to
  287. // see whether it has been changed to a valid value.  The
  288. // return value is the normal PDU status or SNMP_CLASS_SUCCESS.
  289. // when we are successful in receiving a pdu.  Otherwise it
  290. // is an error status.
  292. int receive_snmp_response(SnmpSocket sock, Snmp &snmp_session,
  293.                           Pdu &pdu, UdpAddress &fromaddress,
  294.   OctetStr &engine_id, bool process_msg = true)
  295. {
  296.   unsigned char receive_buffer[MAX_SNMP_PACKET + 1];
  297.   long receive_buffer_len; // len of received data
  298. #ifdef SNMP_PP_IPv6
  299.   struct sockaddr_storage from_addr;
  300. #else
  301.   struct sockaddr_in from_addr;
  302. #endif
  303. #if !(defined (CPU) && CPU == PPC603) && (defined __GNUC__ || defined __FreeBSD__ || defined _AIX) && ! defined __MINGW32__
  304.   socklen_t fromlen;
  305. #else
  306.   int fromlen;
  307. #endif
  308.   fromlen = sizeof(from_addr);
  310.   memset(&from_addr, 0, sizeof(from_addr));
  312.   // do the read
  313.   do {
  314.     receive_buffer_len = (long) recvfrom(sock, (char *) receive_buffer,
  315.                                          MAX_SNMP_PACKET + 1, 0,
  316.                                          (struct sockaddr*) &from_addr,
  317.                                          &fromlen);
  318.     debugprintf(2, "++ SNMP++: something received...");
  319.   } while ((receive_buffer_len < 0) && (EINTR == errno));
  321.   if (receive_buffer_len < 0 )                // error or no data pending
  322.     return SNMP_CLASS_TL_FAILED;
  323.   debugprintf(6, "Length received %i from socket %i; fromlen %i",
  324.               receive_buffer_len, sock, fromlen);
  326.   if (receive_buffer_len == MAX_SNMP_PACKET + 1)
  327.   {
  328.     // Message is too long...
  329.     debugprintf(1, "Received message is ignored (packet too long)");
  330.     return SNMP_CLASS_ERROR;
  331.   }
  333.   if (((sockaddr_in&)from_addr).sin_family == AF_INET)
  334.   {
  335.     // IPv4
  336.     fromaddress = inet_ntoa(((sockaddr_in&)from_addr).sin_addr);
  337.     fromaddress.set_port(ntohs(((sockaddr_in&)from_addr).sin_port));
  338.   }
  339. #ifdef SNMP_PP_IPv6
  340.   else if (from_addr.ss_family == AF_INET6)
  341.   {
  342.     // IPv6
  343.     char tmp_buffer[INET6_ADDRSTRLEN+1];
  345.     inet_ntop(AF_INET6, &(((sockaddr_in6&)from_addr).sin6_addr),
  346.               tmp_buffer, INET6_ADDRSTRLEN);
  348.     fromaddress = tmp_buffer;
  349.     fromaddress.set_port(ntohs(((sockaddr_in6&)from_addr).sin6_port));
  350.   }
  351. #endif // SNMP_PP_IPv6
  352.   else
  353.   {
  354.     debugprintf(0, "Unknown socket address family (%i).",
  355.                 ((sockaddr_in&)from_addr).sin_family);
  356.     return SNMP_CLASS_ERROR;
  357.   }
  359.   debugprintf(1, "++ SNMP++: data received from %s.",
  360.               fromaddress.get_printable());
  361.   debughexprintf(5, receive_buffer, receive_buffer_len);
  363.   if (process_msg == false)
  364.     return SNMP_CLASS_SUCCESS;   // return success
  366.   SnmpMessage snmpmsg;
  367.   if ( snmpmsg.load( receive_buffer, receive_buffer_len) != SNMP_CLASS_SUCCESS)
  368.     return SNMP_CLASS_ERROR;
  370.   OctetStr community_name;
  371.   snmp_version version;
  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.   {
  394.     debugprintf(4,"receive_snmp_response: engine_id (%s), security_name (%s), "
  395. "security_model (%i), security_level (%i)",
  396.                 engine_id.get_printable(), security_name.get_printable(),
  397.                 security_model, pdu.get_security_level());
  398.     debugprintf(5," addtoengineidtable: (%s)",
  399.                 (unsigned char*)fromaddress.get_printable());
  400.   }
  401. #endif
  403.   //-----[ check for error status stuff..]
  404.   // an error status is a valid pdu,
  405.   // the caller needs to know about it
  406.   if ( pdu.get_error_status() != 0)
  407.     return pdu.get_error_status();
  409.   debugprintf(5,"receive_snmp_response requestID = %li, "
  410.       "returning SUCCESS.", pdu.get_request_id());
  412.   return SNMP_CLASS_SUCCESS;   // Success! return
  413. }
  416. //---------[ receive a snmp trap ]---------------------------------
  417. // Receive a trap from the specified socket
  418. // note: caller has to delete target!
  419. int receive_snmp_notification(SnmpSocket sock, Snmp &snmp_session,
  420.                               Pdu &pdu, SnmpTarget **target)
  421. {
  422.   unsigned char receive_buffer[MAX_SNMP_PACKET + 1];
  423.   long receive_buffer_len; // len of received data
  425. #ifdef SNMP_PP_IPv6
  426.   struct sockaddr_storage from_addr;
  427. #else
  428.   struct sockaddr_in from_addr;
  429. #endif // SNMP_PP_IPv6
  431. #if !(defined (CPU) && CPU == PPC603) && (defined __GNUC__ || defined __FreeBSD__ || defined _AIX) && ! defined __MINGW32__
  432.   socklen_t fromlen;
  433. #else
  434.   int fromlen;
  435. #endif
  436.   fromlen = sizeof(from_addr);
  438.   memset(&from_addr, 0, sizeof(from_addr));
  440.   // do the read
  441.   do {
  442.     receive_buffer_len = (long) recvfrom(sock, (char *) receive_buffer,
  443.                                          MAX_SNMP_PACKET + 1, 0,
  444.                                          (struct sockaddr*)&from_addr,
  445.                                          &fromlen);
  446.   } while (receive_buffer_len < 0 && EINTR == errno);
  448.   if (receive_buffer_len < 0 )                // error or no data pending
  449.     return SNMP_CLASS_TL_FAILED;
  451.   if (receive_buffer_len == MAX_SNMP_PACKET + 1)
  452.   {
  453.     // Message is too long...
  454.     debugprintf(1, "Received message is ignored (packet too long)");
  455.     return SNMP_CLASS_ERROR;
  456.   }
  458.   // copy fromaddress and remote port
  459.   UdpAddress fromaddress;
  461.   if (((sockaddr_in&)from_addr).sin_family == AF_INET)
  462.   {
  463.     // IPv4
  464.     fromaddress = inet_ntoa(((sockaddr_in&)from_addr).sin_addr);
  465.     fromaddress.set_port(ntohs(((sockaddr_in&)from_addr).sin_port));
  466.   }
  467. #ifdef SNMP_PP_IPv6
  468.   else if (from_addr.ss_family == AF_INET6)
  469.   {
  470.     // IPv6
  471.     char tmp_buffer[INET6_ADDRSTRLEN+1];
  473.     inet_ntop(AF_INET6, &(((sockaddr_in6&)from_addr).sin6_addr),
  474.               tmp_buffer, INET6_ADDRSTRLEN);
  476.     fromaddress = tmp_buffer;
  477.     fromaddress.set_port(ntohs(((sockaddr_in6&)from_addr).sin6_port));
  478.   }
  479. #endif // SNMP_PP_IPv6
  480.   else
  481.   {
  482.     debugprintf(0, "Unknown socket address family (%i).",
  483.                 ((sockaddr_in&)from_addr).sin_family);
  484.     return SNMP_CLASS_TL_FAILED;
  485.   }
  487.   debugprintf(1, "++ SNMP++: data received from %s.",
  488.               fromaddress.get_printable());
  489.   debughexprintf(5, receive_buffer, receive_buffer_len);
  491.   SnmpMessage snmpmsg;
  492.   if ( snmpmsg.load( receive_buffer, receive_buffer_len) != SNMP_CLASS_SUCCESS)
  493.     return SNMP_CLASS_ERROR;
  495.   OctetStr community_name;
  496.   snmp_version version;
  497.   OctetStr engine_id;
  498.   OctetStr security_name;
  500. #ifdef _SNMPv3
  501.   long int security_model;
  502.   if (snmpmsg.is_v3_message() == TRUE)
  503.   {
  504.     int returncode = snmpmsg.unloadv3(pdu, version, engine_id,
  505.                                       security_name, security_model,
  506.                                       fromaddress, snmp_session);
  507.     if (returncode != SNMP_CLASS_SUCCESS)
  508.       return returncode;
  509.   }
  510.   else
  511.   {
  512. #endif
  513.     int returncode = snmpmsg.unload( pdu, community_name, version);
  514.     if (returncode != SNMP_CLASS_SUCCESS)
  515.       return SNMP_CLASS_ERROR;
  516. #ifdef _SNMPv3
  517.   }
  519.   if (version == version3) {
  520.     *target = new UTarget();
  521.     (*target)->set_address(fromaddress);
  522.     (*target)->set_version(version);
  523.     ((UTarget*)*target)->set_engine_id(engine_id);
  524.     ((UTarget*)*target)->set_security_name(security_name);
  525.     ((UTarget*)*target)->set_security_model(security_model);
  527.     v3MP::I->add_to_engine_id_table(engine_id,
  528.                          (char*)(fromaddress.IpAddress::get_printable()),
  529.                          fromaddress.get_port());
  531.     debugprintf(4,"receive_snmp_notification: engine_id (%s), security_name "
  532. "(%s), security_model (%i), security_level (%i)",
  533.                 engine_id.get_printable(), security_name.get_printable(),
  534.                 security_model, pdu.get_security_level());
  535.   }
  536.   else
  537.   {
  538. #endif
  539.     *target = new CTarget();
  540.     (*target)->set_version(version);
  541.     (*target)->set_address(fromaddress);
  542.     ((CTarget*)*target)->set_readcommunity( community_name);
  543.     ((CTarget*)*target)->set_writecommunity( community_name);
  544. #ifdef _SNMPv3
  545.   }
  546. #endif
  547.   return SNMP_CLASS_SUCCESS;   // Success! return
  548. }
  551. //--------[ map action ]------------------------------------------------
  552. // map the snmp++ action to a SMI pdu type
  553. void Snmp::map_action( unsigned short action, unsigned short & pdu_action)
  554. {
  555.   switch( action)
  556.     {
  557.     case sNMP_PDU_GET:
  558.     case sNMP_PDU_GET_ASYNC:
  559.       pdu_action = sNMP_PDU_GET;
  560.       break;
  562.     case sNMP_PDU_SET:
  563.     case sNMP_PDU_SET_ASYNC:
  564.       pdu_action = sNMP_PDU_SET;
  565.       break;
  567.     case sNMP_PDU_GETNEXT:
  568.     case sNMP_PDU_GETNEXT_ASYNC:
  569.       pdu_action = sNMP_PDU_GETNEXT;
  570.       break;
  572.     case sNMP_PDU_GETBULK:
  573.     case sNMP_PDU_GETBULK_ASYNC:
  574.       pdu_action = sNMP_PDU_GETBULK;
  575.       break;
  577.     case sNMP_PDU_RESPONSE:
  578.       pdu_action = sNMP_PDU_RESPONSE;
  579.       break;
  581.     case sNMP_PDU_INFORM:
  582.     case sNMP_PDU_INFORM_ASYNC:
  583.       pdu_action = sNMP_PDU_INFORM;
  584.       break;
  586.     case sNMP_PDU_REPORT:
  587.       pdu_action = sNMP_PDU_REPORT;
  588.       break;
  590.     default:
  591.       pdu_action = sNMP_PDU_GET;  // TM ?? error ??
  592.       break;
  594.     };  // end switch
  595. }
  597. //------[ Snmp Class Constructor ]--------------------------------------
  599. Snmp::Snmp(int &status, const unsigned short port, const bool bind_ipv6)
  600.     : SnmpSynchronized(),
  601.       m_bThreadRunning(false), m_iPollTimeOut(DEFAULT_TIMEOUT)
  602. {
  603.   IpAddress *addresses[2];
  605.   if (bind_ipv6)
  606.   {
  607.     listen_address = "::";
  609.     addresses[0] = NULL;
  610.     addresses[1] = &listen_address;
  612.     init(status, addresses, 0, port);
  613.   }
  614.   else
  615.   {
  616.     listen_address = "0.0.0.0";
  618.     addresses[0] = &listen_address;
  619.     addresses[1] = NULL;
  621.     init(status, addresses, port, 0);
  622.   }
  624. }
  626. Snmp::Snmp( int &status, const UdpAddress& addr)
  627.     : SnmpSynchronized(),
  628.       m_bThreadRunning(false), m_iPollTimeOut(DEFAULT_TIMEOUT)
  629. {
  630.   IpAddress *addresses[2];
  632.   listen_address = addr;
  634.   if (listen_address.get_ip_version() == Address::version_ipv4)
  635.   {
  636.     addresses[0] = &listen_address;
  637.     addresses[1] = NULL;
  638.     init(status, addresses, addr.get_port(), 0);
  639.   }
  640.   else
  641.   {
  642.     addresses[0] = NULL;
  643.     addresses[1] = &listen_address;
  644.     init(status, addresses, 0, addr.get_port());
  645.   }
  646. }
  648. Snmp::Snmp( int &status,  const UdpAddress& addr_v4,
  649.             const UdpAddress& addr_v6)
  650.     : SnmpSynchronized(),
  651.       m_bThreadRunning(false), m_iPollTimeOut(DEFAULT_TIMEOUT)
  652. {
  653.   IpAddress *addresses[2];
  655.   listen_address = addr_v4;
  656.   IpAddress address_v6((IpAddress)addr_v6);
  657.   addresses[0] = &listen_address;
  658.   addresses[1] = &address_v6;
  660.   init(status, addresses, addr_v4.get_port(), addr_v6.get_port());
  661. }
  663. void Snmp::socket_startup()
  664. {
  665. #ifdef WIN32
  666.   WSADATA WSAData;
  667.   (void)WSAStartup(0x0101, &WSAData);
  668. #endif
  669. }
  671. void Snmp::socket_cleanup()
  672. {
  673. #ifdef WIN32
  674.   int iRetValue = WSACleanup();
  675.   debugprintf(4, "WSACleanup: ReturnValue (%i)", iRetValue);
  676. #endif
  677. }
  679. void Snmp::init(int& status, IpAddress *addresses[2],
  680.                 const unsigned short port_v4,
  681.                 const unsigned short port_v6)
  682. {
  683. #ifdef WIN32
  684.   m_hThread = INVALID_HANDLE_VALUE;
  685.   m_hThreadEndEvent = ::CreateEvent(NULL, true, false, NULL);
  686. #endif
  688.   eventListHolder = new EventListHolder(this);
  689.   // initialize the request_id
  690.   eventListHolder->snmpEventList()->lock();
  691. //  srand(time(0)); // better than nothing
  692.   current_rid = (rand() % (PDU_MAX_RID - PDU_MIN_RID -1)) + PDU_MIN_RID;
  693.   debugprintf(4, "Initialized request_id to %i.", current_rid);
  694.   eventListHolder->snmpEventList()->unlock();
  696.   // intialize all the trap receiving member variables
  697.   notifycallback = 0;
  698.   notifycallback_data = 0;
  699. #ifdef HPUX
  700.   int errno = 0;
  701. #endif
  703.   status = SNMP_CLASS_ERROR;
  704.   iv_snmp_session = INVALID_SOCKET;
  705.   iv_snmp_session_ipv6 = INVALID_SOCKET;
  707.   /* Open IPv4 socket */
  708.   if (addresses[0])
  709.   {
  710.     // open a socket to be used for the session
  711.     if (( iv_snmp_session = socket( AF_INET, SOCK_DGRAM,0)) == INVALID_SOCKET)
  712.     {
  713. #ifdef WIN32
  714.       int werr = WSAGetLastError();
  715.       debugprintf(1, "Call to socket throws error %d", werr);
  716.       if (EMFILE == werr ||WSAENOBUFS == werr || ENFILE == werr)
  717.         status = SNMP_CLASS_RESOURCE_UNAVAIL;
  718.       else if (WSAEHOSTDOWN == werr)
  719.         status = SNMP_CLASS_TL_FAILED;
  720.       else
  721.         status = SNMP_CLASS_TL_UNSUPPORTED;
  722. #else
  723.       if (EMFILE == errno || ENOBUFS == errno || ENFILE == errno)
  724.         status = SNMP_CLASS_RESOURCE_UNAVAIL;
  725.       else if (EHOSTDOWN == errno)
  726.         status = SNMP_CLASS_TL_FAILED;
  727.       else
  728.         status = SNMP_CLASS_TL_UNSUPPORTED;
  729. #endif
  730.     }
  731.     else
  732.     {
  733.       // set up the manager socket attributes
  734.       unsigned long inaddr = inet_addr(addresses[0]->get_printable());
  735.       struct sockaddr_in mgr_addr;
  736.       memset(&mgr_addr, 0, sizeof(mgr_addr));
  737.       mgr_addr.sin_family = AF_INET;
  738.       mgr_addr.sin_addr.s_addr = inaddr;
  739.       mgr_addr.sin_port = htons( port_v4);
  740. #ifdef CYGPKG_NET_OPENBSD_STACK
  741.       mgr_addr.sin_len = sizeof(mgr_addr);
  742. #endif
  744.       // bind the socket
  745.       if (bind(iv_snmp_session, (struct sockaddr*)&mgr_addr,
  746.                sizeof(mgr_addr)) < 0)
  747.       {
  748. #ifdef WIN32
  749.         int werr = WSAGetLastError();
  750. debugprintf(1, "Call to bind throws error %d", werr);
  751.         if (WSAEADDRINUSE  == werr)
  752.           status = SNMP_CLASS_TL_IN_USE;
  753.         else if (WSAENOBUFS == werr)
  754.           status = SNMP_CLASS_RESOURCE_UNAVAIL;
  755.         else if (werr == WSAEAFNOSUPPORT)
  756.           status = SNMP_CLASS_TL_UNSUPPORTED;
  757.         else if (werr == WSAENETUNREACH)
  758.           status = SNMP_CLASS_TL_FAILED;
  759.         else if (werr == EACCES)
  760.           status = SNMP_CLASS_TL_ACCESS_DENIED;
  761.         else
  762.           status = SNMP_CLASS_INTERNAL_ERROR;
  763. #else
  764.         if (EADDRINUSE  == errno)
  765.           status = SNMP_CLASS_TL_IN_USE;
  766.         else if (ENOBUFS == errno)
  767.           status = SNMP_CLASS_RESOURCE_UNAVAIL;
  768.         else if (errno == EAFNOSUPPORT)
  769.           status = SNMP_CLASS_TL_UNSUPPORTED;
  770.         else if (errno == ENETUNREACH)
  771.           status = SNMP_CLASS_TL_FAILED;
  772.         else if (errno == EACCES)
  773.           status = SNMP_CLASS_TL_ACCESS_DENIED;
  774.         else
  775. {
  776.   debugprintf(0, "Uncatched errno value %d, returning internal error.",
  777.       errno);
  778.           status = SNMP_CLASS_INTERNAL_ERROR;
  779. }
  780. #endif
  781. close(iv_snmp_session);    // close the dynamic socket
  782. iv_snmp_session = INVALID_SOCKET;
  783.       }
  784.       else
  785.       {
  786.         status = SNMP_CLASS_SUCCESS;
  787. #ifdef SNMP_BROADCAST
  788.         int enable_broadcast = 1;
  789.         setsockopt(iv_snmp_session, SOL_SOCKET, SO_BROADCAST,
  790.                    (char*)&enable_broadcast, sizeof(enable_broadcast));
  791. #endif
  792.       }
  793.     }
  794.     if (status != SNMP_CLASS_SUCCESS)
  795.       return;
  796.   }
  798.   /* Open IPv6 socket */
  799.   if (addresses[1])
  800.   {
  801. #ifdef SNMP_PP_IPv6
  802.     // open a socket to be used for the session
  803.     if (( iv_snmp_session_ipv6 = socket( AF_INET6, SOCK_DGRAM,0)) 
  804. == INVALID_SOCKET)
  805.     {
  806. #ifdef WIN32
  807.       int werr = WSAGetLastError();
  808.       if (EMFILE == werr ||WSAENOBUFS == werr || ENFILE == werr)
  809.         status = SNMP_CLASS_RESOURCE_UNAVAIL;
  810.       else if (WSAEHOSTDOWN == werr)
  811.         status = SNMP_CLASS_TL_FAILED;
  812.       else
  813.         status = SNMP_CLASS_TL_UNSUPPORTED;
  814. #else
  815.       if (EMFILE == errno || ENOBUFS == errno || ENFILE == errno)
  816.         status = SNMP_CLASS_RESOURCE_UNAVAIL;
  817.       else if (EHOSTDOWN == errno)
  818.         status = SNMP_CLASS_TL_FAILED;
  819.       else
  820.         status = SNMP_CLASS_TL_UNSUPPORTED;
  821. #endif
  822.     }
  823.     else
  824.     {
  825.       // set up the manager socket attributes
  826.       struct sockaddr_in6 mgr_addr;
  828.       memset(&mgr_addr, 0, sizeof(mgr_addr));
  829.       inet_pton(AF_INET6, addresses[1]->get_printable(), &mgr_addr.sin6_addr);
  830.       mgr_addr.sin6_family = AF_INET6;
  831.       mgr_addr.sin6_port = htons( port_v6);
  832.       // bind the socket
  833.       if (bind(iv_snmp_session_ipv6, (struct sockaddr*) &mgr_addr,
  834.                sizeof(mgr_addr)) < 0)
  835.       {
  836. #ifdef WIN32
  837.         int werr = WSAGetLastError();
  838.         if (WSAEADDRINUSE  == werr)
  839.           status = SNMP_CLASS_TL_IN_USE;
  840.         else if (WSAENOBUFS == werr)
  841.           status = SNMP_CLASS_RESOURCE_UNAVAIL;
  842.         else if (werr == WSAEAFNOSUPPORT)
  843.           status = SNMP_CLASS_TL_UNSUPPORTED;
  844.         else if (werr == WSAENETUNREACH)
  845.           status = SNMP_CLASS_TL_FAILED;
  846.         else if (werr == EACCES)
  847.           status = SNMP_CLASS_TL_ACCESS_DENIED;
  848.         else
  849.           status = SNMP_CLASS_INTERNAL_ERROR;
  850. #else
  851.         if (EADDRINUSE  == errno)
  852.           status = SNMP_CLASS_TL_IN_USE;
  853.         else if (ENOBUFS == errno)
  854.           status = SNMP_CLASS_RESOURCE_UNAVAIL;
  855.         else if (errno == EAFNOSUPPORT)
  856.           status = SNMP_CLASS_TL_UNSUPPORTED;
  857.         else if (errno == ENETUNREACH)
  858.           status = SNMP_CLASS_TL_FAILED;
  859.         else if (errno == EACCES)
  860.           status = SNMP_CLASS_TL_ACCESS_DENIED;
  861.         else
  862.           status = SNMP_CLASS_INTERNAL_ERROR;
  863. #endif
  864. close(iv_snmp_session_ipv6);    // close the dynamic socket
  865. iv_snmp_session_ipv6 = INVALID_SOCKET;
  866.       }
  867.       else
  868.       {
  869.         status = SNMP_CLASS_SUCCESS;
  870. #ifdef SNMP_BROADCAST
  871.         int enable_broadcast = 1;
  872.         setsockopt(iv_snmp_session_ipv6, SOL_SOCKET, SO_BROADCAST,
  873.                    (char*)&enable_broadcast, sizeof(enable_broadcast));
  874. #endif
  875.       }
  876.     }
  877. #else
  878.     debugprintf(0, "User error: Enable IPv6 and recompile snmp++.");
  879. #endif // SNMP_PP_IPv6
  880.   }
  881.   return;
  882. }
  885. //---------[ Snmp Class Destructor ]----------------------------------
  886. Snmp::~Snmp()
  887. {
  888.   stop_poll_thread();
  890. #ifdef WIN32
  891.   ::CloseHandle(m_hThreadEndEvent);
  892. #endif
  894.   // if we failed during construction then don't try
  895.   // to free stuff up that was not allocated
  896.   if (iv_snmp_session != INVALID_SOCKET)
  897.   {
  898.     // go through the snmpEventList and delete any outstanding
  899.     // events on this socket
  900.     eventListHolder->snmpEventList()->DeleteSocketEntry(iv_snmp_session);
  902.     close(iv_snmp_session);    // close the dynamic socket
  903.   }
  904.   // if we failed during construction then don't try
  905.   // to free stuff up that was not allocated
  906.   if (iv_snmp_session_ipv6 != INVALID_SOCKET)
  907.   {
  908.     // go through the snmpEventList and delete any outstanding
  909.     // events on this socket
  910.     eventListHolder->snmpEventList()->DeleteSocketEntry(iv_snmp_session_ipv6);
  912.     close(iv_snmp_session_ipv6);    // close the dynamic socket
  913.   }
  915.   // shut down trap reception if used
  916.   notify_unregister();
  918.   delete eventListHolder;
  919. }
  921. // Get the version of the snmp++ library at runtime
  922. // This function MUST stay in the cpp file!
  923. const char *Snmp::get_version()
  924. {
  925.   return SNMP_PP_VERSION_STRING;
  926. }
  928. //-------------------[ returns error string ]--------------------------
  929. const char *Snmp::error_msg(const int c)
  930. {
  931. #ifdef _SNMPv3
  932.   if (c>=SNMPv3_USM_MIN_ERROR)
  933.     return ((c>SNMPv3_USM_MAX_ERROR)?pv3Errs[SNMPv3_USM_ERRORCOUNT]:pv3Errs[c-SNMPv3_USM_MIN_ERROR]);
  934.   if (c<=SNMPv3_MP_MAX_ERROR)
  935.     return ((c<SNMPv3_MP_MIN_ERROR)?nv3Errs[SNMPv3_MP_ERRORCOUNT]:nv3Errs[SNMPv3_MP_MAX_ERROR - c]);
  936. #endif
  937.   return ((c<0)?
  938.           ((c<MAX_NEG_ERROR)?nErrs[-(MAX_NEG_ERROR)+1]:nErrs[-c]):
  939.           ((c>MAX_POS_ERROR)?pErrs[MAX_POS_ERROR+1]:pErrs[c]));
  940. }
  942. #ifdef _SNMPv3
  943. const char* Snmp::error_msg(const Oid& v3Oid)
  944. {
  945.   // UsmStats
  946.   if (v3Oid == oidUsmStatsUnsupportedSecLevels)
  947.     return error_msg(SNMPv3_USM_UNSUPPORTED_SECURITY_LEVEL);
  949.   if (v3Oid == oidUsmStatsNotInTimeWindows)
  950.     return error_msg(SNMPv3_USM_NOT_IN_TIME_WINDOW);
  952.   if (v3Oid == oidUsmStatsUnknownUserNames )
  953.     return error_msg(SNMPv3_USM_UNKNOWN_SECURITY_NAME);
  955.   if (v3Oid == oidUsmStatsUnknownEngineIDs)
  956.     return error_msg(SNMPv3_USM_UNKNOWN_ENGINEID);
  958.   if (v3Oid == oidUsmStatsWrongDigests)
  959.     return error_msg(SNMPv3_USM_AUTHENTICATION_FAILURE);
  961.   if (v3Oid == oidUsmStatsDecryptionErrors)
  962.     return error_msg(SNMPv3_USM_DECRYPTION_ERROR);
  964.   // MPDstats
  965.   if (v3Oid == oidSnmpUnknownSecurityModels)
  966.     return error_msg(SNMPv3_MP_UNSUPPORTED_SECURITY_MODEL);
  968.   if (v3Oid == oidSnmpInvalidMsgs)
  969.     return error_msg(SNMPv3_MP_INVALID_MESSAGE);
  971.   if (v3Oid == oidSnmpUnknownPDUHandlers)
  972.     return error_msg(SNMPv3_MP_UNKNOWN_PDU_HANDLERS);
  974.   if (v3Oid == oidSnmpUnavailableContexts)
  975.     return error_msg(SNMPv3_MP_UNAVAILABLE_CONTEXT);
  977.   if (v3Oid == oidSnmpUnknownContexts)
  978.     return error_msg(SNMPv3_MP_UNKNOWN_CONTEXT);
  980.   return error_msg(MAX_POS_ERROR + 1);
  981. }
  982. #endif
  984. //------------------------[ get ]---------------------------------------
  985. int Snmp::get(Pdu &pdu, const SnmpTarget &target)
  986. {
  987.   pdu.set_type( sNMP_PDU_GET);
  988.   return snmp_engine( pdu, 0, 0, target, NULL, 0);
  989. }
  991. //------------------------[ get async ]----------------------------------
  992. int Snmp::get(Pdu &pdu, const SnmpTarget &target,
  993.               const snmp_callback callback,
  994.               const void * callback_data)
  995. {
  996.   pdu.set_type( sNMP_PDU_GET_ASYNC);
  997.   return snmp_engine( pdu, 0, 0, target, callback, callback_data);
  998. }
  1000. //------------------------[ get next ]-----------------------------------
  1001. int Snmp::get_next(Pdu &pdu, const SnmpTarget &target)
  1002. {
  1003.   pdu.set_type( sNMP_PDU_GETNEXT);
  1004.   return snmp_engine( pdu, 0, 0, target, NULL, 0);
  1005. }
  1007. //------------------------[ get next async ]-----------------------------
  1008. int Snmp::get_next(Pdu &pdu, const SnmpTarget &target,
  1009.                    const snmp_callback callback,
  1010.                    const void * callback_data)
  1011. {
  1012.   pdu.set_type( sNMP_PDU_GETNEXT_ASYNC);
  1013.   return snmp_engine( pdu, 0, 0, target, callback, callback_data);
  1014. }
  1016. //-------------------------[ set ]---------------------------------------
  1017. int Snmp::set(Pdu &pdu, const SnmpTarget &target)
  1018. {
  1019.   pdu.set_type( sNMP_PDU_SET);
  1020.   return snmp_engine( pdu, 0, 0, target, NULL, 0);
  1021. }
  1023. //------------------------[ set async ]----------------------------------
  1024. int Snmp::set(Pdu &pdu, const SnmpTarget &target,
  1025.               const snmp_callback callback,
  1026.               const void * callback_data)
  1027. {
  1028.   pdu.set_type( sNMP_PDU_SET_ASYNC);
  1029.   return snmp_engine( pdu, 0, 0, target, callback, callback_data);
  1030. }
  1032. //-----------------------[ get bulk ]------------------------------------
  1033. int Snmp::get_bulk(Pdu &pdu,                // pdu to use
  1034.                    const SnmpTarget &target,// destination target
  1035.                    const int non_repeaters, // number of non repeaters
  1036.                    const int max_reps)      // maximum number of repetitions
  1037. {
  1038.   pdu.set_type( sNMP_PDU_GETBULK);
  1039.   return snmp_engine( pdu, non_repeaters, max_reps, target, NULL, 0);
  1040. }
  1042. //-----------------------[ get bulk async ]------------------------------
  1043. int Snmp::get_bulk(Pdu &pdu,                 // pdu to use
  1044.                    const SnmpTarget &target, // destination target
  1045.                    const int non_repeaters,  // number of non repeaters
  1046.                    const int max_reps,       // maximum number of repetitions
  1047.                    const snmp_callback callback,// callback to use
  1048.                    const void * callback_data)  // callback data
  1049. {
  1050.   pdu.set_type( sNMP_PDU_GETBULK_ASYNC);
  1051.   return snmp_engine( pdu, non_repeaters, max_reps, target,
  1052.                       callback, callback_data);
  1053. }
  1055. //------------------------[ inform_response ]----------------------------
  1056. int Snmp::response(Pdu &pdu,                 // pdu to use
  1057.                    const SnmpTarget &target, // response target
  1058.    const SnmpSocket fd)
  1059. {
  1060.   pdu.set_type( sNMP_PDU_RESPONSE);
  1061.   return snmp_engine(pdu, 0, 0, target, NULL, 0, fd);
  1062. }
  1064. int Snmp::send_raw_data(unsigned char *send_buf,
  1065.                         size_t send_len, UdpAddress &address, SnmpSocket fd)
  1066.   REENTRANT(
  1067. {
  1068.   if (fd != INVALID_SOCKET)
  1069.     return send_snmp_request(fd, send_buf, send_len, address);
  1070.   else
  1071.   {
  1072.     if (address.get_ip_version() == Address::version_ipv4)
  1073.     {
  1074.       if (iv_snmp_session != INVALID_SOCKET)
  1075. return send_snmp_request(iv_snmp_session, send_buf,
  1076.  send_len, address);
  1077.       else
  1078. address.map_to_ipv6();
  1079.     }
  1080.     return send_snmp_request(iv_snmp_session_ipv6, send_buf,
  1081.      send_len, address);
  1082.   }
  1083. })
  1085. //-----------------------[ cancel ]--------------------------------------
  1086. int Snmp::cancel( const unsigned long request_id)
  1087. {
  1088.   eventListHolder->snmpEventList()->lock();
  1089.   int status = eventListHolder->snmpEventList()->DeleteEntry(request_id);
  1090.   eventListHolder->snmpEventList()->unlock();
  1092.   return status;
  1093. }
  1096. //----------------------[ sending report, V3 only]-----------------------
  1097. int Snmp::report(Pdu &pdu,                // pdu to send
  1098.                  const SnmpTarget &target)// destination target
  1099. {
  1100.   pdu.set_type( sNMP_PDU_REPORT);
  1101.   return snmp_engine( pdu, 0, 0, target, NULL, 0);
  1102. }
  1104. //----------------------[ blocking inform, V2 only]------------------------
  1105. int Snmp::inform(Pdu &pdu,                // pdu to send
  1106.                  const SnmpTarget &target)// destination target
  1107. {
  1108.   if (target.get_version() == version1)
  1109.   {
  1110.     LOG_BEGIN(ERROR_LOG | 1);
  1111.     LOG("Snmp: Invalid Operation: Inform not defined for SNMPv1");
  1112.     LOG_END;
  1114.     return SNMP_CLASS_INVALID_OPERATION;
  1115.   }
  1117.   pdu.set_type( sNMP_PDU_INFORM);
  1118.   check_notify_timestamp(pdu);
  1119.   return snmp_engine( pdu, 0, 0, target, NULL, 0);
  1120. }
  1122. //----------------------[ asynch inform, V2 only]------------------------
  1123. int Snmp::inform(Pdu &pdu,                // pdu to send
  1124.                  const SnmpTarget &target,      // destination target
  1125.                  const snmp_callback callback,  // callback function
  1126.                  const void * callback_data)    // callback data
  1127. {
  1128.   if (target.get_version() == version1)
  1129.   {
  1130.     LOG_BEGIN(ERROR_LOG | 1);
  1131.     LOG("Snmp: Invalid Operation: Inform not defined for SNMPv1");
  1132.     LOG_END;
  1134.     return SNMP_CLASS_INVALID_OPERATION;
  1135.   }
  1137.   pdu.set_type( sNMP_PDU_INFORM);
  1138.   check_notify_timestamp(pdu);
  1139.   return snmp_engine( pdu, 0, 0, target, callback, callback_data);
  1140. }
  1143. //---------------------[ send a trap ]-----------------------------------
  1144. int Snmp::trap(Pdu &pdu,                        // pdu to send
  1145.                const SnmpTarget &target)        // destination target
  1146. {
  1147.   OctetStr my_get_community;
  1148.   OctetStr my_set_community;
  1149.   GenAddress address;
  1150.   unsigned long my_timeout;
  1151.   int my_retry;
  1152.   unsigned char version;
  1153.   int status;
  1155.   debugprintf(1, "++ SNMP++, Send a Trap");
  1156.   //---------[ make sure pdu is valid ]---------------------------------
  1157.   if (!pdu.valid())
  1158.   {
  1159.     debugprintf(0, "-- SNMP++, PDU Object Invalid");
  1160.     return  SNMP_CLASS_INVALID_PDU;
  1161.   }
  1163.   //---------[ make sure target is valid ]------------------------------
  1164.   if (!target.valid())
  1165.   {
  1166.     debugprintf(0, "-- SNMP++, Target Object Invalid");
  1167.     return SNMP_CLASS_INVALID_TARGET;
  1168.   }
  1170.   CTarget* ctarget = NULL;
  1171.   UTarget* utarget = NULL;
  1172.   OctetStr security_name;
  1173.   int security_model;
  1175.   switch (target.get_type()) {
  1176.     case SnmpTarget::type_ctarget:
  1177.       ctarget = (CTarget*)(&target);
  1178.       break;
  1179.     case SnmpTarget::type_utarget:
  1180.       utarget = (UTarget*)(&target);
  1181.       break;
  1182.     case SnmpTarget::type_base:
  1183.       debugprintf(0, "-- SNMP++, do not use SnmpTarget, use a  CTarget or UTarget");
  1184.       return SNMP_CLASS_INVALID_TARGET;
  1185.     default:
  1186.       // target is not known
  1187.       debugprintf(0, "-- SNMP++, type of target is unknown!");
  1188.       return SNMP_CLASS_UNSUPPORTED;
  1189.   }
  1191.   if (ctarget) {
  1192.     debugprintf(3, "snmp::trap called with CTarget");
  1193.     if (!ctarget->resolve_to_C( my_get_community, my_set_community, address,
  1194.                                 my_timeout, my_retry, version))
  1195.     {
  1196.       debugprintf(0, "-- SNMP++, Resolve Fail (CTarget)");
  1197.       return SNMP_CLASS_UNSUPPORTED;
  1198.     }
  1199. #ifdef _SNMPv3
  1200.     if (version == version3)
  1201.     {
  1202.       debugprintf(0, "-- SNMP++, use UTarget for SNMPv3");
  1203.       return SNMP_CLASS_INVALID_TARGET;
  1204.     }
  1205. #endif
  1206.   }
  1207.   else { // target is not a CTarget:
  1208.     if (utarget) {
  1209.       debugprintf(3, "trap called with UTarget");
  1210.       if (!utarget->resolve_to_U( security_name, security_model, address,
  1211.   my_timeout, my_retry, version))
  1212.       {
  1213.         debugprintf(0, "-- SNMP++, Resolve Fail (UTarget)");
  1214.         return SNMP_CLASS_UNSUPPORTED;
  1215.       }
  1216. #ifdef _SNMPv3
  1217.       if (version != version3) {
  1218. #endif
  1219.         my_get_community = security_name;
  1220.         if ((security_model != SecurityModel_v1) &&
  1221.             (security_model != SecurityModel_v2)) {
  1222.           debugprintf(0, "-- SNMP++, Target contains invalid security_model/version combination");
  1223.           return SNMP_CLASS_INVALID_TARGET;
  1224.         }
  1225. #ifdef _SNMPv3
  1226.       } // end if (version != version3)
  1227. #endif
  1228.     }
  1229.     else { // target is neither CTarget nor UTarget:
  1230.       debugprintf(0, "-- SNMP++, Resolve Fail");
  1231.       return SNMP_CLASS_INVALID_TARGET;
  1232.     }
  1233.   }
  1235.   //--------[ determine request id to use ]------------------------------
  1236.   pdu.set_request_id( MyMakeReqId());
  1238.   //--------[ check timestamp, if null use system time ]-----------------
  1239.   check_notify_timestamp(pdu);
  1241.   //------[ validate address to use ]-------------------------------------
  1242.   if (!address.valid()) {
  1243.     debugprintf(0, "-- SNMP++, Bad address");
  1244.     return SNMP_CLASS_INVALID_TARGET;
  1245.   }
  1247.   if ((address.get_type() != Address::type_ip) &&
  1248.       (address.get_type() != Address::type_udp) )
  1249.     {
  1250.       debugprintf(0, "-- SNMP++, Bad address type");
  1251.       return SNMP_CLASS_TL_UNSUPPORTED;
  1252.     }
  1254.   UdpAddress udp_address(address);
  1255.   if (!udp_address.valid()) {
  1256.     debugprintf(0, "-- SNMP++, copy address failed");
  1257.     return SNMP_CLASS_RESOURCE_UNAVAIL;
  1258.   }
  1260.   //----------[ choose the target address port ]-----------------------
  1261.   if ((address.get_type() == Address::type_ip) || !udp_address.get_port())
  1262.     udp_address.set_port(SNMP_TRAP_PORT);
  1264.   //----------[ based on the target type, choose v1 or v1 trap type ]-----
  1265.   if ( version == version1)
  1266.     pdu.set_type( sNMP_PDU_V1TRAP);
  1267.   else // v2 and v3 use v2TRAP
  1268.     pdu.set_type( sNMP_PDU_TRAP);
  1270.   SnmpMessage snmpmsg;
  1272. #ifdef _SNMPv3
  1273.   if ( version == version3) {
  1275.     OctetStr engine_id = v3MP::I->get_local_engine_id();
  1276.     if (!utarget) {
  1277.       debugprintf(0, "-- SNMP++, dont know how to handle SNMPv3 without UTarget!");
  1278.       return SNMP_CLASS_INVALID_TARGET;
  1279.     }
  1281.     // set context_engine_id of pdu, if it is not set
  1282.     if (pdu.get_context_engine_id().len() == 0)
  1283.     {
  1284.       debugprintf(8, "Setting contextEngineID of Pdu to (%s)",
  1285.                   engine_id.get_printable());
  1286.       pdu.set_context_engine_id(engine_id);
  1287.     }
  1289.     debugprintf(4,"Snmp::trap:");
  1290.     debugprintf(4," engineID (%s), securityName (%s)n securityModel (%i) security_level (%i)",
  1291.                 engine_id.get_printable(), security_name.get_printable(),
  1292.                 security_model, pdu.get_security_level());
  1293.     debugprintf(4," Addr/Port (%s)",udp_address.get_printable());
  1295.     status = snmpmsg.loadv3( pdu, engine_id, security_name,
  1296.                              security_model, (snmp_version)version);
  1297.   }
  1298.   else
  1299. #endif
  1300.     status = snmpmsg.load( pdu, my_get_community, (snmp_version) version);
  1302.   if ( status != SNMP_CLASS_SUCCESS) {
  1303.     debugprintf(0, "snmp message load error!");
  1304.     return status;
  1305.   }
  1307.   lock();
  1308.   //------[ send the trap ]
  1309.   if (udp_address.get_ip_version() == Address::version_ipv4)
  1310.   {
  1311.     if (iv_snmp_session != INVALID_SOCKET)
  1312.       status = send_snmp_request(iv_snmp_session,
  1313.  snmpmsg.data(), (size_t)snmpmsg.len(),
  1314.  udp_address);
  1315.     else
  1316.     {
  1317.       udp_address.map_to_ipv6();
  1318.       status = send_snmp_request(iv_snmp_session_ipv6,
  1319.  snmpmsg.data(), (size_t)snmpmsg.len(),
  1320.  udp_address);
  1321.     }
  1322.   }
  1323.   else
  1324.     status = send_snmp_request(iv_snmp_session_ipv6,
  1325.                                snmpmsg.data(), (size_t)snmpmsg.len(),
  1326.                                udp_address);
  1328.   unlock();
  1329.   if (status != 0)
  1330.     return SNMP_CLASS_TL_FAILED;
  1332.   return SNMP_CLASS_SUCCESS;
  1333. }
  1335. //----------------[ set notify_timestamp if it is null ]-------------
  1336. #if defined (CPU) && CPU == PPC603
  1338.   struct SCommTimer
  1339.   {
  1340. unsigned long NumMS;
  1341. unsigned long FractMS;
  1342.   };
  1344.   extern "C"
  1345.   {
  1346.   void GetTime (struct SCommTimer *  Time);
  1347.   }
  1348. #endif
  1350. void Snmp::check_notify_timestamp(Pdu &pdu)
  1351. {
  1352.   // As we don't know, when the application was started,
  1353.   // use a continuously increasing notify_timestamp
  1354.   TimeTicks timestamp;
  1355.   pdu.get_notify_timestamp( timestamp);
  1356.   if (timestamp <= 0)
  1357.   {
  1358. #ifdef WIN32
  1359.     struct _timeb timebuffer;
  1360.     _ftime( &timebuffer );
  1361.     timebuffer.time -= 1103760000;   // knock off 35 years worth of seconds
  1362.     timestamp = SAFE_ULONG_CAST((timebuffer.time * 100) +
  1363. (timebuffer.millitm / 10));
  1364. #elif defined (CPU) && CPU == PPC603
  1365.     SCommTimer theTime;
  1367.     GetTime(&theTime); // This function must be defined by the application
  1369.     timestamp = theTime.NumMS/10;
  1370. #else
  1371.     struct timeval tp;
  1372.     gettimeofday(&tp, NULL);
  1373.     tp.tv_sec -= 1103760000;   // knock off 35 years worth of seconds
  1374.     timestamp = (tp.tv_sec * 100) + (tp.tv_usec / 10000);
  1375. #endif
  1377.     pdu.set_notify_timestamp( timestamp);
  1378.   }
  1379. }
  1381. //-----------------------[ read the notification filters ]----------------
  1382. int Snmp::get_notify_filter( OidCollection &trapids,
  1383.                              TargetCollection &targets,
  1384.      AddressCollection &listen_addresses)
  1385. {
  1386.   CNotifyEvent *e = eventListHolder->notifyEventList()->GetEntry(this);
  1388.   if (!e)  return SNMP_CLASS_INVALID;
  1390.   e->get_filter(trapids, targets, listen_addresses);
  1392.   return SNMP_CLASS_SUCCESS;
  1393. }
  1397. // Set the port for listening to traps and informs.
  1398. void Snmp::notify_set_listen_port(const int port)
  1399. {
  1400.   eventListHolder->notifyEventList()->set_listen_port(port);
  1401. }
  1403. // Get the port that is used for listening to traps and informs.
  1404. int Snmp::notify_get_listen_port()
  1405. {
  1406.   return eventListHolder->notifyEventList()->get_listen_port();
  1407. }
  1409. //-----------------------[ register to get traps]-------------------------
  1410. int Snmp::notify_register( const OidCollection     &trapids,
  1411.                            const TargetCollection  &targets,
  1412.                            const AddressCollection &addresses,
  1413.                            const snmp_callback      callback,
  1414.                            const void              *callback_data)
  1415. {
  1416.   int status;
  1418.   // assign callback and callback data info
  1419.   notifycallback = callback;
  1420.   notifycallback_data = (void *)callback_data;
  1422.   // remove any previous filters for this session
  1423.   eventListHolder->notifyEventList()->DeleteEntry(this);
  1425.   // add to the notify queue
  1426.   status = eventListHolder->notifyEventList()->AddEntry(this, trapids,
  1427. targets, addresses);
  1429.   iv_notify_fd = eventListHolder->notifyEventList()->get_notify_fd(); // DLD
  1431.   return status;
  1432. }
  1434. // alternate form for local listen specification
  1435. //-----------------------[ register to get traps]-------------------------
  1436. int Snmp::notify_register( const OidCollection    &trapids,
  1437.                            const TargetCollection &targets,
  1438.                            const snmp_callback     callback,
  1439.                            const void             *callback_data)
  1440. {
  1441.   AddressCollection addresses;
  1443.   return notify_register(trapids, targets, addresses,
  1444.                          callback, callback_data);
  1445. }
  1447. //-----------------------[ un-register to get traps]----------------------
  1448. int Snmp::notify_unregister()
  1449. {
  1450.   /// @todo Return error if not registered before!
  1452.   // remove from the notify queue
  1453.   eventListHolder->notifyEventList()->DeleteEntry(this);
  1455.   // null out callback information
  1456.   notifycallback = 0;
  1457.   notifycallback_data = 0;
  1459.   iv_notify_fd = INVALID_SOCKET;
  1461.   return SNMP_CLASS_SUCCESS;
  1462. }
  1464. //---------[ get / set engine ]-----------------------------------------
  1465. // The main snmp engine used for all requests
  1466. // async requests return out early and don't wait in here for
  1467. // the response
  1468. int Snmp::snmp_engine( Pdu &pdu,              // pdu to use
  1469.                        long int non_reps,     // # of non repititions
  1470.                        long int max_reps,     // # of max repititions
  1471.                        const SnmpTarget &target,    // from this target
  1472.                        const snmp_callback cb,// callback for async calls
  1473.                        const void *cbd,      // callback data
  1474.        SnmpSocket fd,
  1475.        int reports_received)
  1477. {
  1478.   long req_id = 0;                   // pdu request id
  1479.   int status;                        // send status
  1481. #ifdef _SNMPv3
  1482.   // save original PDU for later reference
  1483.   Pdu backupPdu = pdu;
  1485.   for (int maxloops=0; maxloops<3; maxloops++)
  1486.   {
  1487. #endif
  1489.     unsigned short pdu_action;        // type of pdu to build
  1490.     unsigned short action;        // type of pdu to build
  1491.     unsigned long my_timeout;        // target specific timeout
  1492.     int my_retry;                // target specific retry
  1494.     OctetStr my_get_community;
  1495.     OctetStr my_set_community;
  1496.     GenAddress address;
  1497.     unsigned char version;
  1499.     //---------[ make sure pdu is valid ]--------------------------
  1500.     if ( !pdu.valid())
  1501.       return  SNMP_CLASS_INVALID_PDU;
  1503.     //---------[ depending on user action, map the correct pdu action]
  1504.     action = pdu.get_type();
  1505.     map_action(action, pdu_action);
  1507.     //---------[ check for correct mode ]---------------------------
  1508.     // if the class was constructed as a blocked model, callback=0
  1509.     // and async calls are attempted, an error is returned
  1510.     if (( cb == 0) &&
  1511.         ((action == sNMP_PDU_GET_ASYNC) ||
  1512.          (action == sNMP_PDU_SET_ASYNC) ||
  1513.          (action == sNMP_PDU_GETNEXT_ASYNC) ||
  1514.          (action == sNMP_PDU_GETBULK_ASYNC) ||
  1515.          (action == sNMP_PDU_INFORM_ASYNC)))
  1516.       return SNMP_CLASS_INVALID_CALLBACK;
  1518.     //---------[ more mode checking ]--------------------------------
  1519.     // if the class was constructed as an async model, callback = something
  1520.     // and blocked calls are attempted, an error is returned
  1521.     if (( cb != 0) &&
  1522.         ((action == sNMP_PDU_GET) ||
  1523.          (action == sNMP_PDU_SET) ||
  1524.          (action == sNMP_PDU_GETNEXT) ||
  1525.          (action == sNMP_PDU_GETBULK) ||
  1526.          (action == sNMP_PDU_INFORM)))
  1527.       return SNMP_CLASS_INVALID_CALLBACK;
  1529.     //---------[ make sure target is valid ]-------------------------
  1530.     // make sure that the target is valid
  1531.     if ( ! target.valid())
  1532.       return SNMP_CLASS_INVALID_TARGET;
  1534.     OctetStr community_string;
  1535.     OctetStr security_name;
  1536.     int security_model;
  1537.     const CTarget* ctarget = NULL;
  1538.     const UTarget* utarget = NULL;
  1540.     switch (target.get_type())
  1541.     {
  1542.       case SnmpTarget::type_ctarget:
  1543.         ctarget = (CTarget*)(&target);
  1544.         break;
  1545.       case SnmpTarget::type_utarget:
  1546.         utarget = (UTarget*)(&target);
  1547.         break;
  1548.       case SnmpTarget::type_base:
  1549.         debugprintf(0, "-- SNMP++, do not use SnmpTarget,"
  1550.                     "use a  CTarget or UTarget");
  1551.         return SNMP_CLASS_INVALID_TARGET;
  1552.       default:
  1553.         /* target is not known */
  1554.         debugprintf(0, "-- SNMP++, type of target is unknown!");
  1555.         return SNMP_CLASS_UNSUPPORTED;
  1556.     }
  1558.     if (ctarget) /* Is is a CTarget? */
  1559.     {
  1560.       debugprintf(3, "snmp_engine called with CTarget");
  1561.       if (!ctarget->resolve_to_C( my_get_community, my_set_community,
  1562.                                   address, my_timeout, my_retry, version))
  1563.       {
  1564.         debugprintf(0, "-- SNMP++, Resolve Fail (CTarget)");
  1565.         return SNMP_CLASS_UNSUPPORTED;
  1566.       }
  1567. #ifdef _SNMPv3
  1568.       if ((version == version3) ||
  1569.           (action == sNMP_PDU_REPORT))
  1570.       {
  1571.         debugprintf(0, "-- SNMP++, use UTarget for SNMPv3");
  1572.         return SNMP_CLASS_INVALID_TARGET;
  1573.       }
  1574. #endif
  1575.       //----------[ use the appropriate community string ]-----------------
  1576.       if (( action == sNMP_PDU_GET) ||
  1577.           ( action == sNMP_PDU_GET_ASYNC) ||
  1578.           ( action == sNMP_PDU_GETNEXT) ||
  1579.           ( action == sNMP_PDU_GETNEXT_ASYNC) ||
  1580.           ( action == sNMP_PDU_GETBULK) ||
  1581.           ( action == sNMP_PDU_GETBULK_ASYNC) ||
  1582.           ( action == sNMP_PDU_INFORM) ||
  1583.           ( action == sNMP_PDU_INFORM_ASYNC) ||
  1584.           ( action == sNMP_PDU_RESPONSE))
  1585.         community_string = my_get_community;
  1586.       else /* got to be a set */
  1587.         community_string = my_set_community;
  1588.     }
  1589.     else if (utarget)  /* Is is a UTarget? */
  1590.     {
  1591.       debugprintf(3, "snmp_engine called with UTarget");
  1592.       if (!utarget->resolve_to_U( security_name, security_model,
  1593.                                   address, my_timeout,
  1594.                                   my_retry, version))
  1595.       {
  1596.         debugprintf(0, "-- SNMP++, Resolve Fail (UTarget)");
  1597.         return SNMP_CLASS_UNSUPPORTED;
  1598.       }
  1599. #ifdef _SNMPv3
  1600.       if (version != version3)
  1601.       {
  1602. #endif
  1603.         community_string = security_name;
  1604.         if (((version == version1) && (security_model != SecurityModel_v1)) ||
  1605.     ((version == version2c) && (security_model != SecurityModel_v2)))
  1606. {
  1607.           LOG_BEGIN(ERROR_LOG | 1);
  1608.           LOG("Snmp: Target does not match SNMP version: (security model) (version)");
  1609.           LOG(security_model);
  1610.           LOG(version);
  1611.           LOG_END;
  1613.           return SNMP_CLASS_INVALID_TARGET;
  1614.         }
  1615. #ifdef _SNMPv3
  1616.       } // end if (version != version3)
  1617. #endif
  1618.     }
  1619.     else
  1620.     { // target is neither CTarget nor UTarget (should not happen)
  1621.       debugprintf(0, "-- SNMP++, Resolve Fail");
  1622.       return SNMP_CLASS_INVALID_TARGET;
  1623.     }
  1625.     if (!address.valid())
  1626.     {
  1627.       debugprintf(0, "-- SNMP++, Target contains invalid address");
  1628.       return SNMP_CLASS_INVALID_TARGET;
  1629.     }
  1631.     //----------[ validate the target address ]--------------------------
  1632.     if ((address.get_type() != Address::type_ip) &&
  1633.         (address.get_type() != Address::type_udp) )
  1634.     {
  1635.       debugprintf(0, "-- SNMP++, Bad address type");
  1636.       return SNMP_CLASS_TL_UNSUPPORTED;
  1637.     }
  1639.     UdpAddress udp_address(address);
  1640.     if (!udp_address.valid())
  1641.     {
  1642.       debugprintf(0, "-- SNMP++, Bad address");
  1643.       return SNMP_CLASS_RESOURCE_UNAVAIL;
  1644.     }
  1646.     //----------[ choose the target address port ]-----------------------
  1647.     if ((address.get_type() == Address::type_ip) || !udp_address.get_port())
  1648.     {
  1649.       if (pdu_action == sNMP_PDU_INFORM)
  1650.         udp_address.set_port(SNMP_TRAP_PORT);
  1651.       else
  1652.         udp_address.set_port(SNMP_PORT);
  1653.     }
  1654.     // otherwise port was already set
  1656.     // check socket to use
  1657.     SnmpSocket iv_session_used = fd;
  1659.     if (fd == INVALID_SOCKET)
  1660.     {
  1661.       if (udp_address.get_ip_version() == Address::version_ipv4)
  1662.       {
  1663.         if (iv_snmp_session != INVALID_SOCKET)
  1664.   iv_session_used = iv_snmp_session;
  1665. else
  1666. {
  1667.   udp_address.map_to_ipv6();
  1668.   iv_session_used = iv_snmp_session_ipv6;
  1669. }
  1670.       }
  1671.       else
  1672. iv_session_used = iv_snmp_session_ipv6;
  1673.     }
  1675.     if ((pdu_action != sNMP_PDU_RESPONSE) &&
  1676.         (pdu_action != sNMP_PDU_REPORT))
  1677.     {
  1678.       // set error index to none
  1679.       pdu.set_error_index(0);
  1681.       // determine request id to use
  1682.       req_id = MyMakeReqId();
  1683.       pdu.set_request_id(req_id);
  1684.     }
  1686.     //---------[ map GetBulk over v1 to GetNext ]-------------------------
  1687.     if (( pdu_action == sNMP_PDU_GETBULK)&&( (snmp_version)version== version1))
  1688.       pdu_action = sNMP_PDU_GETNEXT;
  1689.     if ( pdu_action == sNMP_PDU_GETBULK) {
  1690.       pdu.set_error_status((int) non_reps);
  1691.       pdu.set_error_index((int) max_reps);
  1692.     }
  1694.     pdu.set_type( pdu_action);
  1695.     SnmpMessage snmpmsg;
  1697. #ifdef _SNMPv3
  1698.     if (version == version3)
  1699.     {
  1700.       if (!utarget)
  1701.       {
  1702.         debugprintf(0, "-- SNMP++, need UTarget to send SNMPv3 message!");
  1703.         return SNMP_CLASS_INVALID_TARGET;
  1704.       }
  1705.       OctetStr engine_id;
  1706.       utarget->get_engine_id(engine_id);
  1707.       if (engine_id.len() == 0)
  1708.       {
  1709.         if (v3MP::I->get_from_engine_id_table(engine_id,
  1710.     (char*)udp_address.get_printable())
  1711.             == SNMPv3_MP_OK )
  1712.         {
  1713.   // Override const here
  1714.           ((UTarget*)utarget)->set_engine_id(engine_id);
  1715.         } // else: engineID="" --> automatic engineID discovery
  1716.       }
  1717.       // set context_engine_id of pdu, if it is not set
  1718.       if (pdu.get_context_engine_id().len() == 0)
  1719.       {
  1720.         debugprintf(8, "Setting contextEngineID of Pdu to (%s)",
  1721.                     engine_id.get_printable());
  1722.         pdu.set_context_engine_id(engine_id);
  1723.         backupPdu.set_context_engine_id(engine_id);
  1724.       }
  1726.       debugprintf(4,"Snmp::snmp_engine: engineID (%s), securityName (%s)"
  1727.                   "securityModel (%i) security_level (%i)",
  1728.                   engine_id.get_printable(), security_name.get_printable(),
  1729.                   security_model, pdu.get_security_level());
  1730.       debugprintf(4," Addr/Port (%s)",udp_address.get_printable());
  1732.       status = snmpmsg.loadv3( pdu, engine_id, security_name,
  1733.                                security_model, (snmp_version)version);
  1734.     }
  1735.     else
  1736. #endif
  1737.       status = snmpmsg.load( pdu, community_string,(snmp_version) version);
  1739.     if ( status != SNMP_CLASS_SUCCESS)
  1740.     {
  1741.       debugprintf(0, "snmp message load error!");
  1742.       return status;
  1743.     }
  1745.     //------[ send the request ]
  1746.     lock();
  1747.     status = send_snmp_request(iv_session_used,
  1748.        snmpmsg.data(), (size_t) snmpmsg.len(),
  1749.        udp_address);
  1750.     unlock();
  1752.     if ( status != 0)
  1753.       return SNMP_CLASS_TL_FAILED;
  1755.     if ((pdu_action == sNMP_PDU_RESPONSE) ||
  1756.         (pdu_action == sNMP_PDU_REPORT))
  1757.       return SNMP_CLASS_SUCCESS; // don't wait for an answer
  1759. #ifdef _SNMPv3
  1760.     if ((version == version3) && ((action == sNMP_PDU_GET_ASYNC) ||
  1761.                                   (action == sNMP_PDU_SET_ASYNC) ||
  1762.                                   (action == sNMP_PDU_GETNEXT_ASYNC) ||
  1763.                                   (action == sNMP_PDU_GETBULK_ASYNC) ||
  1764.                                   (action == sNMP_PDU_INFORM_ASYNC))) {
  1765.       // add callback for v3
  1766.       struct V3CallBackData *v3CallBackData;
  1767.       v3CallBackData = new struct V3CallBackData;
  1769.       v3CallBackData->pdu = new Pdu(pdu);
  1770.       v3CallBackData->pdu->set_type(backupPdu.get_type());
  1771.       v3CallBackData->non_reps = non_reps;
  1772.       v3CallBackData->max_reps = max_reps;
  1774.       v3CallBackData->target = new UTarget(*utarget);
  1775.       v3CallBackData->oldCallback = cb;
  1776.       v3CallBackData->cbd = cbd;
  1777.       v3CallBackData->reports_received = reports_received;
  1779.       // Add the message to the message queue
  1780.       eventListHolder->snmpEventList()->AddEntry(req_id, this, iv_session_used,
  1781.  target, pdu,
  1782.  snmpmsg.data(),
  1783.  (size_t) snmpmsg.len(),
  1784.  udp_address,
  1785.  v3CallBack,
  1786.  (void *)v3CallBackData);
  1787.     }
  1788.     else
  1789. #endif
  1790.     {
  1791.       eventListHolder->snmpEventList()->AddEntry( req_id, this,
  1792.   iv_session_used,
  1793.   target, pdu,
  1794.   snmpmsg.data(),
  1795.   (size_t) snmpmsg.len(),
  1796.   udp_address,
  1797.   cb, (void *)cbd);
  1798.     }
  1799.     //----[ if an async mode request then return success ]-----
  1800.     if (( action == sNMP_PDU_GET_ASYNC) ||
  1801.         ( action == sNMP_PDU_SET_ASYNC) ||
  1802.         ( action == sNMP_PDU_GETNEXT_ASYNC) ||
  1803.         ( action == sNMP_PDU_GETBULK_ASYNC) ||
  1804.         ( action == sNMP_PDU_INFORM_ASYNC))
  1805.       return SNMP_CLASS_SUCCESS;
  1807.     // Now wait for the response (or timeout) for our message.
  1808.     // This handles any necessary retries.
  1809.     status = eventListHolder->SNMPBlockForResponse(req_id, pdu);
  1811.     if (pdu.get_type() != REPORT_MSG) {
  1812. #ifdef _SNMPv3
  1813.       if (status == SNMPv3_MP_OK)
  1814.         return SNMP_CLASS_SUCCESS;
  1815.       else
  1816. #endif
  1817.         return status;
  1818.     }
  1819. #ifdef _SNMPv3
  1820.     else
  1821.       if (status == SNMPv3_USM_DECRYPTION_ERROR)
  1822.         return status;
  1824.     // We received a REPORT-MSG, check if we should try another time
  1825.     Vb first_vb;
  1826.     Oid first_oid;
  1827.     pdu.get_vb(first_vb,0);
  1828.     first_vb.get_oid(first_oid);
  1830.     debugprintf(1,"received oid: %s with value: %s",
  1831.                 first_vb.get_printable_oid(), first_vb.get_printable_value());
  1832.     debugprintf(1, "%s", error_msg(first_oid));
  1834.     switch (maxloops)
  1835.     {
  1836.       case 0:
  1837.       {
  1838. // This was our first try, so we may receive a unknown engine id 
  1839. // report or a not in time window report
  1840.         if (first_oid == oidUsmStatsUnknownEngineIDs)
  1841.         {
  1842.   pdu = backupPdu; // restore pdu and try again
  1843.   break;
  1844.         }
  1845.         else if (first_oid == oidUsmStatsNotInTimeWindows)
  1846.         {
  1847.           ++maxloops; // increase it, as the next request must succeed
  1848.   pdu = backupPdu; // restore pdu and try again
  1849.   break;
  1850.         }
  1851.         return (status == SNMPv3_MP_OK) ? SNMP_CLASS_SUCCESS : status;
  1852.       }
  1853.       case 1:
  1854.       {
  1855. // This was the second try, engine id discovery should be ok
  1856. // so test only for not in time report
  1857.         if (first_oid == oidUsmStatsNotInTimeWindows)
  1858.         {
  1859.   pdu = backupPdu; // restore pdu and try again
  1860.   break;
  1861.         }
  1862.         return (status == SNMPv3_MP_OK) ? SNMP_CLASS_SUCCESS : status;
  1863.       }
  1864.       case 2:
  1865.       {
  1866. // We tried three times: one for engine id discovery, one for
  1867. // time sync and we still get a report --> somethings wrong!
  1868.         return (status == SNMPv3_MP_OK) ? SNMP_CLASS_SUCCESS : status;
  1869.       }
  1870.     }
  1871.   }
  1872. #endif
  1873.   return status;
  1874. }
  1876. #ifdef _SNMPv3
  1877. int Snmp::engine_id_discovery(OctetStr &engine_id,
  1878.       const int timeout_sec,
  1879.       const UdpAddress &addr)
  1880. {
  1881.   unsigned char *message;
  1882.   int message_length;
  1883.   SnmpSocket sock;
  1884.   SnmpMessage snmpmsg;
  1886.   unsigned char snmpv3_message[60] = {
  1887.     0x30, 0x3a,
  1888.           0x02, 0x01, 0x03,                   // Version: 3
  1889.           0x30, 0x0f,                         // global header length 15
  1890.                 0x02, 0x03, 0x01, 0x00, 0x00, // message id
  1891.                 0x02, 0x02, 0x10, 0x00,       // message max size
  1892.                 0x04, 0x01, 0x04,             // flags (reportable set)
  1893.                 0x02, 0x01, 0x03,             // security model USM
  1894.           0x04, 0x10,                         // security params
  1895.                 0x30, 0x0e,
  1896.                       0x04, 0x00,             // no engine id
  1897.                       0x02, 0x01, 0x00,       // boots 0
  1898.                       0x02, 0x01, 0x00,       // time 0
  1899.                       0x04, 0x00,             // no user name
  1900.                       0x04, 0x00,             // no auth par
  1901.                       0x04, 0x00,             // no priv par
  1902.           0x30, 0x12,
  1903.                 0x04, 0x00,                   // no context engine id
  1904.                 0x04, 0x00,                   // no context name
  1905.           0xa0, 0x0c,                         // GET PDU
  1906.                 0x02, 0x02, 0x34, 0x26,       // request id
  1907.                 0x02, 0x01, 0x00,             // error status no error
  1908.                 0x02, 0x01, 0x00,             // error index 0
  1909.                 0x30, 0x00                    // no data
  1910.   };
  1912.   message = (unsigned char *)snmpv3_message;
  1913.   message_length = 60;
  1915.   engine_id.clear();
  1917.   UdpAddress uaddr(addr);
  1919.   if (uaddr.get_ip_version() == Address::version_ipv4)
  1920.   {
  1921.     if (iv_snmp_session != INVALID_SOCKET)
  1922.       sock = iv_snmp_session;
  1923.     else
  1924.     {
  1925.       uaddr.map_to_ipv6();
  1926.       sock = iv_snmp_session_ipv6;
  1927.     }
  1928.   }
  1929.   else
  1930.     sock = iv_snmp_session_ipv6;
  1932.   lock();
  1933.   if (send_snmp_request(sock, message, message_length, uaddr) < 0)
  1934.   {
  1935.     debugprintf(0, "Error sending message.");
  1936.     unlock();
  1937.     return SNMP_CLASS_TL_FAILED;
  1938.   }
  1940.   // now wait for the responses
  1941.   Pdu dummy_pdu;
  1942.   fd_set readfds;
  1943.   int nfound = 0;
  1944.   struct timeval fd_timeout;
  1945.   msec end_time;
  1947.   end_time += timeout_sec * 1000;
  1949.   do
  1950.   {
  1951.     FD_ZERO(&readfds);
  1953.     FD_SET(sock, &readfds);
  1955.     end_time.GetDeltaFromNow(fd_timeout);
  1957.     nfound = select((int)(sock + 1), &readfds, NULL, NULL, &fd_timeout);
  1959.     if ((nfound > 0) && (FD_ISSET(sock, &readfds)))
  1960.     {
  1961.       // receive message
  1962.       UdpAddress from;
  1963.       int res = receive_snmp_response(sock, *this, dummy_pdu,
  1964.       from, engine_id, true /* process_msg */);
  1965.       if ((res == SNMP_CLASS_SUCCESS) ||
  1966.   (res == SNMPv3_MP_UNKNOWN_PDU_HANDLERS))
  1967.       {
  1968.   //dummy_pdu.get_context_engine_id(engine_id);
  1969. debugprintf(3, "Response received from (%s) id %s.",
  1970.     from.get_printable(), engine_id.get_printable());
  1971. unlock();
  1972. return SNMP_CLASS_SUCCESS;
  1973.       }
  1974.       else
  1975.       {
  1976. debugprintf(0, "Error receiving discovery response.");
  1977.       }
  1978.     }
  1979.   } while ((nfound > 0) ||
  1980.    (fd_timeout.tv_sec > 0) || (fd_timeout.tv_usec > 0));
  1981.   unlock();
  1983.   return SNMP_CLASS_TIMEOUT;
  1984. }
  1985. #endif
  1987. // Send a SNMP Broadcast message.
  1988. int Snmp::broadcast_discovery(UdpAddressCollection &addresses,
  1989.       const int timeout_sec,
  1990.       const UdpAddress &addr,
  1991.       const snmp_version version,
  1992.       const OctetStr *community)
  1993. {
  1994.   unsigned char *message;
  1995.   int message_length;
  1996.   SnmpSocket sock;
  1997.   SnmpMessage snmpmsg;
  1999. #ifdef _SNMPv3
  2000.   unsigned char snmpv3_broadcast_message[60] = {
  2001.     0x30, 0x3a,
  2002.           0x02, 0x01, 0x03,                   // Version: 3
  2003.           0x30, 0x0f,                         // global header length 15
  2004.                 0x02, 0x03, 0x01, 0x00, 0x00, // message id
  2005.                 0x02, 0x02, 0x10, 0x00,       // message max size
  2006.                 0x04, 0x01, 0x04,             // flags (reportable set)
  2007.                 0x02, 0x01, 0x03,             // security model USM
  2008.           0x04, 0x10,                         // security params
  2009.                 0x30, 0x0e,
  2010.                       0x04, 0x00,             // no engine id
  2011.                       0x02, 0x01, 0x00,       // boots 0
  2012.                       0x02, 0x01, 0x00,       // time 0
  2013.                       0x04, 0x00,             // no user name
  2014.                       0x04, 0x00,             // no auth par
  2015.                       0x04, 0x00,             // no priv par
  2016.           0x30, 0x12,
  2017.                 0x04, 0x00,                   // no context engine id
  2018.                 0x04, 0x00,                   // no context name
  2019.           0xa0, 0x0c,                         // GET PDU
  2020.                 0x02, 0x02, 0x34, 0x26,       // request id
  2021.                 0x02, 0x01, 0x00,             // error status no error
  2022.                 0x02, 0x01, 0x00,             // error index 0
  2023.                 0x30, 0x00                    // no data
  2024.   };
  2026.   if (version == version3)
  2027.   {
  2028.     message = (unsigned char *)snmpv3_broadcast_message;
  2029.     message_length = 60;
  2030.   }
  2031.   else
  2032. #endif
  2033.   {
  2034.     Pdu pdu;
  2035.     Vb vb;
  2036.     OctetStr get_community;
  2038.     vb.set_oid("1.3.6.1.2.1.1.1.0");
  2039.     pdu +=vb;
  2040.     pdu.set_error_index(0);            // set error index to none
  2041.     pdu.set_request_id(MyMakeReqId()); // determine request id to use
  2042.     pdu.set_type(sNMP_PDU_GET);        // set pdu type
  2044.     if (community)
  2045.       get_community = *community;
  2046.     else
  2047.       get_community = "public";
  2049.     int status = snmpmsg.load(pdu, get_community, version);
  2050.     if (status != SNMP_CLASS_SUCCESS)
  2051.     {
  2052.       debugprintf(0, "Error encoding broadcast pdu (%i).", status);
  2053.       return status;
  2054.     }
  2055.     message        = snmpmsg.data();
  2056.     message_length = snmpmsg.len();
  2057.   }
  2059.   UdpAddress uaddr(addr);
  2061.   if (uaddr.get_ip_version() == Address::version_ipv4)
  2062.   {
  2063.     if (iv_snmp_session != INVALID_SOCKET)
  2064.       sock = iv_snmp_session;
  2065.     else
  2066.     {
  2067.       uaddr.map_to_ipv6();
  2068.       sock = iv_snmp_session_ipv6;
  2069.     }
  2070.   }
  2071.   else
  2072.     sock = iv_snmp_session_ipv6;
  2074.   lock();
  2075.   if (send_snmp_request(sock, message, message_length, uaddr) < 0)
  2076.   {
  2077.     debugprintf(0, "Error sending broadast.");
  2078.     unlock();
  2079.     return SNMP_CLASS_TL_FAILED;
  2080.   }
  2082.   // now wait for the responses
  2083.   Pdu dummy_pdu;
  2084.   OctetStr engine_id;
  2085.   fd_set readfds;
  2086.   int nfound = 0;
  2087.   struct timeval fd_timeout;
  2088.   msec end_time;
  2090.   end_time += timeout_sec * 1000;
  2092.   do
  2093.   {
  2094.     FD_ZERO(&readfds);
  2096.     FD_SET(sock, &readfds);
  2098.     end_time.GetDeltaFromNow(fd_timeout);
  2100.     nfound = select((int)(sock + 1), &readfds, NULL, NULL, &fd_timeout);
  2102.     if ((nfound > 0) && (FD_ISSET(sock, &readfds)))
  2103.     {
  2104.       // receive message
  2105.       UdpAddress from;
  2106.       if (receive_snmp_response(sock, *this, dummy_pdu,
  2107. from, engine_id, false /* process_msg */)
  2108.   == SNMP_CLASS_SUCCESS)
  2109.       {
  2110. addresses += from;
  2111.       }
  2112.       else
  2113.       {
  2114. debugprintf(0, "Error receiving broadcast response.");
  2115.       }
  2116.     }
  2117.   } while ((nfound > 0) ||
  2118.    (fd_timeout.tv_sec > 0) || (fd_timeout.tv_usec > 0));
  2119.   unlock();
  2121. #ifdef __DEBUG
  2122.   for (int i=0; i < addresses.size(); ++i)
  2123.   {
  2124.     debugprintf(3, "Broadcast response received from (%s).",
  2125. addresses[i].get_printable());
  2126.   }
  2127. #endif
  2128.   return 0;
  2129. }
  2131. //     Starts the working thread for the recovery of the pending events
  2132. bool Snmp::start_poll_thread(const int select_timeout)
  2133. {
  2134. #ifdef _THREADS
  2135.     // store the timeout value for later
  2136.     m_iPollTimeOut = select_timeout;
  2138.     // if we are already running return ok
  2139.     if (m_bThreadRunning == true) return true;
  2141.     // since we are here, things must be fine so far...
  2142.     m_bThreadRunning = true;
  2144.     // start the ProcessThread function....
  2145. #ifdef WIN32
  2146.     DWORD id;
  2147.     m_hThread = CreateThread(NULL, 0,
  2148.        (LPTHREAD_START_ROUTINE)&Snmp::process_thread,
  2149.        this, 0, &id);
  2150.     if (m_hThread == NULL)
  2151.     {
  2152.         debugprintf(0, "Could not create ProcessThread");
  2153. m_bThreadRunning = false;
  2154.     }
  2155. #elif defined (CPU) && CPU == PPC603
  2156. m_hThread = taskSpawn("Snmp::process_thread",  0, 0, 10000, (int (*)(...))Snmp::process_thread,  (int)this, 0, 0, 0, 0, 0, 0, 0, 0, 0);
  2157.     if (m_hThread == ERROR)
  2158.     {
  2159. // Could not create thread.
  2160.         debugprintf(0, "Could not create ProcessThread");
  2161. m_bThreadRunning = false;
  2162.     }
  2163. #else
  2164.     int rc = pthread_create(&m_hThread, NULL, Snmp::process_thread,
  2165.     (void*) this);
  2166.     if (rc)
  2167.     {
  2168. // Could not create thread.
  2169.         debugprintf(0, "Could not create ProcessThread");
  2170. m_bThreadRunning = false;
  2171.     }
  2172. #endif
  2173. #endif
  2174.     return m_bThreadRunning;
  2175. }
  2177. ///////////////////////////////////////////////////////////////////////////////
  2178. // stop_poll_thread
  2179. //     Stops the recovery of the pending events
  2180. //
  2181. ///////////////////////////////////////////////////////////////////////////////
  2182. void Snmp::stop_poll_thread()
  2183. {
  2184.     if (m_bThreadRunning == false) return;
  2186. #ifdef _THREADS
  2187.     // stop the thread
  2188.     m_bThreadRunning = false;
  2190.     // Wait for the working thread to stop....
  2191. #ifdef WIN32
  2192.     ::WaitForSingleObject(m_hThreadEndEvent, INFINITE);
  2193.     CloseHandle(m_hThread);
  2194. #elif defined (CPU) && CPU == PPC603
  2195.     while (taskIdVerify(m_hThread) == OK)
  2196. taskDelay(10);
  2197. #else
  2198.     int status;
  2199.     pthread_join(m_hThread, (void**) &status); 
  2200. #endif
  2201. #endif
  2202. }
  2204. #ifdef WIN32
  2205. int Snmp::process_thread(Snmp *pSnmp)
  2206. {
  2207. #else
  2208. void* Snmp::process_thread(void *arg)
  2209. {
  2210.     Snmp* pSnmp = (Snmp*) arg;
  2211. #endif // !WIN32
  2213.     // Loop as long as we haven't stopped
  2214.     while (pSnmp->is_running())
  2215.     {
  2216. pSnmp->eventListHolder
  2217.      ->SNMPProcessEvents(pSnmp->m_iPollTimeOut);
  2218.     }
  2220. #ifdef _THREADS
  2221. #ifdef WIN32
  2222.     ::SetEvent(pSnmp->m_hThreadEndEvent);
  2223. #else
  2224. #if defined (CPU) && CPU == PPC603
  2225. exit(0);
  2226. #else
  2227.     pthread_exit(0);
  2228. #endif
  2229. #endif
  2230. #endif
  2231.     return 0;
  2232. }
  2234. #ifdef SNMP_PP_NAMESPACE
  2235. }; // end of namespace Snmp_pp
  2236. #endif