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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > SNMP编程 > 查看源码
snmp.cpp
资源名称：hp_snmp3.zip　[点击查看]
上传用户：czjinwang
上传日期：2007-01-12
资源大小：2484k
文件大小：88k
源码类别：

SNMP编程

开发平台：

Visual C++

snmp.cpp：源码内容
  1. /*===================================================================
  3.   Copyright (c) 1999
  4.   Hewlett-Packard Company
  6.   ATTENTION: USE OF THIS SOFTWARE IS SUBJECT TO THE FOLLOWING TERMS.
  7.   Permission to use, copy, modify, distribute and/or sell this software 
  8.   and/or its documentation is hereby granted without fee. User agrees 
  9.   to display the above copyright notice and this license notice in all 
  10.   copies of the software and any documentation of the software. User 
  11.   agrees to assume all liability for the use of the software; Hewlett-Packard 
  12.   makes no representations about the suitability of this software for any 
  13.   purpose. It is provided "AS-IS without warranty of any kind,either express 
  14.   or implied. User hereby grants a royalty-free license to any and all 
  15.   derivatives based upon this software code base. 
  19.   S N M P . C P P
  21.   SNMP CLASS IMPLEMENATION FOR WINDOWS WIN32
  23.   DESCRIPTION:
  24.   This module contains the implementation of the SNMP and
  25.   transport init/deinit functions.
  27.   LANGUAGE:
  28.   ANSI C++
  30.   OPERATING SYSTEM:
  31.   Win32
  34.   DESIGN:
  35.   Peter E Mellquist
  37.   AUTHOR:
  38.   Peter E Mellquist
  40.  
  41. =====================================================================*/
  42. char snmp_cpp_version[]="#(@)SNMP++ 2.8 $Header: snmp.cpp,v 1.25 96/09/11 14:02:06 hmgr Exp $";
  44. //-----[ External C includes ]-----------------------------------------
  45. extern "C"
  46. {
  47. #include "winsnmp.h"  // winsnmp include file
  48. #include <stdio.h>    // standard io
  49. }
  51. #define _INCLUDE_SNMP_ERR_STRINGS
  53. //-----[ SNMP++ Includes ]--------------------------------------------
  54. #include "oid.h"        // class def for oids
  55. #include "vb.h"         // class def for vbs
  56. #include "snmp_pp.h"    // class def for this module
  57. #include "pdu_cont.h"   // pdu container class def
  59. //-----[ macros ]------------------------------------------------------
  60. #define MAX_DOTTED_OID_SIZE 255   // maximum size for a dotted string
  61. #define SNMP_MSG WM_USER+176      // winsnmp callback msg
  62. #define SNMP_GWW_HINSTANCE -6     // gww instance
  64. //-----[ snmp engine variables ]--------------------------------------- 
  66. static char SzSnmpClass[] =  "sppcls32";     // pdu handler registered name
  68. DLLOPT Pdu_Container *pdu_container;         // pointer to pdu container class
  69. int pdu_ref_count=0;                         // reference count of transport
  70. int snmp_ref_count=0;                        // reference count for xport
  72. // mutual exclusion variables for thread safety
  73. CRITICAL_SECTION my_critical_section;                           
  75. #define SNMP_WAIT EnterCriticalSection( &my_critical_section)
  76. #define SNMP_SIGNAL LeaveCriticalSection( &my_critical_section)
  78. //-----[ Trap Builder API ]----------------------------------------
  79. typedef SNMPAPI_STATUS (PASCAL *functionTrap)( HSNMP_PDU, smiLPOID, smiLPIPADDR, smiLPINT, smiLPINT, smiLPTIMETICKS);
  81. //-----[ port setting API ]-----------------------------------------
  82. typedef SNMPAPI_STATUS (PASCAL *functionPortSet) (HSNMP_ENTITY hEntity,WORD port);
  85. //--------------[ well known trap ids ]-----------------------------------
  86. // SMI trap oid def
  87. class snmpTrapsOid: public Oid {
  88.    public: 
  89.    snmpTrapsOid (void):Oid("1.3.6.1.6.3.1.1.5"){};
  90. }; 
  92. // SMI Enterprose Oid
  93. class snmpTrapEnterpriseOid: public Oid {
  94.    public: 
  95.    snmpTrapEnterpriseOid(void):Oid("1.3.6.1.6.3.1.1.4.3.0"){};
  96. }; 
  98. // SMI Cold Start Oid
  99. class coldStartOid: public snmpTrapsOid {
  100.    public: 
  101.    coldStartOid( void){*this+=".1";};
  102. };
  104. // SMI WarmStart Oid
  105. class warmStartOid: public snmpTrapsOid {
  106.    public: 
  107.    warmStartOid( void){*this+=".2";};
  108. };
  110. // SMI LinkDown Oid
  111. class linkDownOid: public snmpTrapsOid {
  112.    public: 
  113.    linkDownOid( void){*this+=".3";};
  114. }; 
  117. // SMI LinkUp Oid
  118. class linkUpOid: public snmpTrapsOid {
  119.    public: 
  120.    linkUpOid( void){*this+=".4";};
  121. };
  123. // SMI Authentication Failure Oid
  124. class authenticationFailureOid: public snmpTrapsOid {
  125.    public: 
  126.    authenticationFailureOid( void){*this+=".5";};
  127. }; 
  129. // SMI egpneighborloss Oid
  130. class egpNeighborLossOid: public snmpTrapsOid {
  131.    public: 
  132.    egpNeighborLossOid( void){*this+=".6";};
  133. };
  135. const coldStartOid coldStart;
  136. const warmStartOid warmStart;
  137. const linkDownOid linkDown;
  138. const linkUpOid linkUp;
  139. const authenticationFailureOid authenticationFailure;
  140. const egpNeighborLossOid egpNeighborLoss;
  141. const snmpTrapEnterpriseOid snmpTrapEnterprise;
  144. //-----------------------------------------------------------------------
  145. //--------[ extract_from_varbindlist ]-----------------------------------
  146. //-----------------------------------------------------------------------
  147. // loop through all vbs in the VArbind list extracting each
  148. // vb into the SNMP++ Vb ojbects
  149. int extract_from_varbindlist( HSNMP_VBL hRecvVbl,  // handle to winsnmp vbl
  150.                               Pdu &pdu)            // Snmp++ Pdu to extract into
  151. {
  152.    int z;                            // looping variable
  153.    SNMPAPI_STATUS vb_status;         // status of VB extract
  154.    smiVALUE SnmpValue;               // A received value
  155.    smiOID RecvOid;                   // a received oid
  156.    char stroid[MAX_DOTTED_OID_SIZE]; // string oid
  157.    TimeTicks tt;                     // timeticks object
  158.    Counter32 ctr;                    // counter object
  159.    Gauge32 gge;                      // gauge object
  160.    Vb tempvb;                        // temp vb object
  161.    int vb_count;                     // count of pdu vbs
  163.    //-----[ delete existing vblist from pdu ] --------------------------
  164.    pdu.set_vblist(&tempvb, 0);
  166.    //-----[ loop through and extract response vb's] --------------------
  167.    SNMPDEBUG("++ SNMP++, In Extract From Vb List n");
  168.    vb_count = SnmpCountVbl( hRecvVbl);
  169.    for (z=1;z<=vb_count;z++)
  170.    {
  171.       // get the vb
  172.       SNMPDEBUG("++ SNMP++, Get VB n");
  173.       vb_status = SnmpGetVb( hRecvVbl,
  174.                              z,
  175.                              &RecvOid,
  176.                              &SnmpValue);
  177.       // if it is a good status then extract
  178.       // it into the vb object else the
  179.       // error index should point to it
  180.       // so we just skip it
  181.       //
  182.       // if the status was successful,
  183.       // then we need to copy the oid
  184.       // and value portions to the vb object
  185.       // when finished, we need to free the oid
  186.       // and the smivalue portion if its an oid or octet
  187.       if ( vb_status == SNMPAPI_SUCCESS)
  188.       {
  189.          // copy the smivalue data into the vb object
  190.          // to be returned
  191.          SnmpOidToStr( &RecvOid,MAX_DOTTED_OID_SIZE,stroid);
  192.          tempvb.set_oid(stroid);
  193.          // clean up memory created by WinSnmp
  194.          SnmpFreeDescriptor(SNMP_SYNTAX_OID, (smiLPOPAQUE) &RecvOid);
  195.          switch( SnmpValue.syntax)
  196.          {
  197.             // null , do nothing
  198.             case SNMP_SYNTAX_NULL:
  199.             case SNMP_SYNTAX_NOSUCHOBJECT:
  200.             case SNMP_SYNTAX_NOSUCHINSTANCE:
  201.             case SNMP_SYNTAX_ENDOFMIBVIEW:
  202.             break;
  204.             // octects
  205.             case SNMP_SYNTAX_OCTETS:
  206.             case SNMP_SYNTAX_BITS:
  207.             case SNMP_SYNTAX_OPAQUE:
  208.             {
  209.                OctetStr octetstr( (unsigned char far *) SnmpValue.value.string.ptr,
  210.                                   ( size_t) SnmpValue.value.string.len);
  211.                tempvb.set_value( octetstr);
  212.                SnmpFreeDescriptor( SNMP_SYNTAX_OCTETS,
  213.                                    (smiLPOPAQUE)&SnmpValue.value.string );
  214.             }
  215.             break;
  217.             // ip addresses
  218.             case SNMP_SYNTAX_IPADDR:
  219.             {
  220.                IpAddress ipa("0.0.0.0"); // make it valid first
  221.                ipa[0] = SnmpValue.value.string.ptr[0];
  222.                ipa[1] = SnmpValue.value.string.ptr[1];
  223.                ipa[2] = SnmpValue.value.string.ptr[2];
  224.                ipa[3] = SnmpValue.value.string.ptr[3];
  225.                tempvb.set_value( ipa);
  226.    SnmpFreeDescriptor( SNMP_SYNTAX_IPADDR,
  227.    (smiLPIPADDR) &SnmpValue.value.string );
  228.             }
  229.             break;
  231.             // oid
  232.             case SNMP_SYNTAX_OID:
  233.             {
  234.                SnmpOidToStr( &SnmpValue.value.oid,MAX_DOTTED_OID_SIZE,stroid);
  235.                Oid oidvb(stroid);
  236.                tempvb.set_value( oidvb);
  237.                SnmpFreeDescriptor( SNMP_SYNTAX_OID,
  238.                                    (smiLPOPAQUE)&SnmpValue.value.oid );
  239.             }
  240.             break;
  242.             // int 32
  243.             case SNMP_SYNTAX_INT32:
  244.                tempvb.set_value( (signed long int) SnmpValue.value.sNumber);
  245.             break;
  247.             // time ticks
  248.             case SNMP_SYNTAX_TIMETICKS:
  249.                tt =  (unsigned long) SnmpValue.value.uNumber;
  250.                tempvb.set_value( tt);
  251.             break;
  253.             // counter
  254.             case SNMP_SYNTAX_CNTR32:
  255.                ctr = (unsigned long) SnmpValue.value.uNumber;
  256.                tempvb.set_value( ctr);
  257.             break;
  259.             // gauge
  260.             case SNMP_SYNTAX_GAUGE32:
  261.                gge = (unsigned long) SnmpValue.value.uNumber;
  262.                tempvb.set_value( gge);
  263.             break;
  265.             // u int 32
  266.             case SNMP_SYNTAX_UINT32:
  267.                tempvb.set_value( (unsigned long int) SnmpValue.value.uNumber);
  268.             break;
  270.             // 64 bit counter
  271.             case SNMP_SYNTAX_CNTR64:
  272.                Counter64 c64( (unsigned long int) SnmpValue.value.hNumber.hipart,
  273.                               (unsigned long int) SnmpValue.value.hNumber.lopart);
  274.                tempvb.set_value( c64);
  275.             break;
  277.             } // end switch
  278.          }  // end if vb status is good
  279.          pdu += tempvb;
  280.        } // end for all vb's
  282.    SNMPDEBUG("++ SNMP++, End Extract From Vblist n");
  283.    return 0;
  284. }  // end extract_from_varbindlist
  286. //-------------------[ returns error string ]--------------------------
  287. char * Snmp::error_msg( const int c)
  288. {
  289.    return ((c<0)?
  290.            ((c<MAX_NEG_ERROR)?nErrs[-(MAX_NEG_ERROR)+1]:nErrs[-c]):
  291.             ((c>MAX_POS_ERROR)?pErrs[MAX_POS_ERROR+1]:pErrs[c]));
  292. }
  295. //-----------------------------------------------------------------------
  296. //--------------------[ async handler ]----------------------------------
  297. //-----------------------------------------------------------------------
  298. // Prepares the async message to be callled to the
  299. // callback function
  300. void FAR  process_async_event( int reason,
  301.                                long int lnRecvRequestId,
  302.                                HSNMP_SESSION session_handle,
  303.                                smiINT lnErrorStatus,
  304.                                smiINT lnErrorIndex,
  305.                                HSNMP_VBL hRecvVbl,
  306.                                HSNMP_CONTEXT hRecvContext,
  307.                                HSNMP_ENTITY hDstRecvEnt,
  308.                                Snmp* spp_session,
  309.                                snmp_callback callback,
  310.                                void * personality)
  311. {
  312.    int vb_count;                     // number of vbs
  313.    Vb* vbs;                          // vbs, dynamically instantiated
  314.    SNMPAPI_STATUS gen_status;        // status of getting a vb
  315.    unsigned char agent_addr[40];     // agent address space
  316.    smiOCTETS octet_community;        // octet community name
  317.    unsigned char community_name[255]; // community name for async passing
  318.    CTarget v1target;                // v1 target to use
  319.    Pdu pdu;                          // instantiated pdu object
  322.    // get the var bind list from WinSnmp
  323.    // if vb count is zero then nothing to
  324.    // do return out;
  325.    vb_count = (int) SnmpCountVbl( hRecvVbl);
  326.    if ( vb_count == 0)
  327.    {
  328.       SNMPDEBUG("-- SNMP++, Async Handler Vb count = 0n");
  329.   (callback)(   reason,                    // reason
  330.                  (Snmp*) spp_session,          // snmp++ session who own the req
  331.                  (Pdu&) pdu,                   // pdu
  332.                  (SnmpTarget&) v1target,       // target
  333.                  (void*) personality);         // callback data
  335.       return;
  336.    }
  338.    // dynamically instantiate a list of
  339.    // Vb obejcts
  340.    // return if new error
  341.    vbs = new Vb[vb_count];
  342.    if ( vbs == 0)
  343.    {
  344.      SNMPDEBUG("-- SNMP++, Async Handler new Vb Failn");
  345.      return;  // if new error then return
  346.    }
  348.    // stuff them into the pdu
  349.    pdu.set_vblist( (Vb*) vbs, vb_count);
  351.    // extract vbs from WinSNMP var bind list into
  352.    // Snmp++ pdu objects
  353.    extract_from_varbindlist( hRecvVbl, pdu);
  356.    //------[ prepare the agent address ]-------------------------------------
  357.    gen_status = SnmpEntityToStr( hDstRecvEnt,40, (char *) agent_addr);
  358.    if ( gen_status == SNMPAPI_FAILURE)
  359.    {
  360.       delete [] vbs;                    // free the snmp++ vbs
  361.       SNMPDEBUG("-- SNMP++, Async Handler SnmpEntityToStr Failn");
  362.       return;                           // error case, don't call callback
  363.    }
  366.    //-----[ prepare the agents context ]-------------------------------------
  367.    gen_status = SnmpContextToStr( hRecvContext, &octet_community);
  368.    if ( gen_status == SNMPAPI_FAILURE)
  369.    {
  370.       delete [] vbs;                    // free the snmp++ vbs
  371.       SNMPDEBUG("-- SNMP++, Async Handler SnmpContextToStr Failn");
  372.       return;                           // error case, don't call callback
  373.    }
  375.    //----[ copy SMI octet community into an unsigned char community ]
  376.    // protect againt over running the target string
  377.    MEMCPY( community_name,
  378.              octet_community.ptr,
  379.            (size_t) min(octet_community.len,40));
  381.    //------[ make an target object for the callback ]----------------------
  382.    // set the address portion of the target
  383.    IpxAddress ipxaddress( (char*) agent_addr); 
  384.    if ( ipxaddress.valid())
  385.       v1target.set_address( ipxaddress);
  386.    else {
  387.       IpAddress  ipaddress( (char*) agent_addr); 
  388.       if( ipaddress.valid())
  389.          v1target.set_address( ipaddress);
  390.       else
  391.         return;  //unknown address format
  392.    }
  394.    // fill in the community names
  395.    OctetStr rc( (const unsigned char *) octet_community.ptr, octet_community.len);
  397.    v1target.set_readcommunity( rc);
  398.    v1target.set_writecommunity( rc);
  400.    //------[ make up a pdu onject ]------------------------------------------
  401.    set_request_id( &pdu, lnRecvRequestId);     // friend function call
  402.    set_error_status( &pdu, (int) lnErrorStatus);
  403.    set_error_index( &pdu, (int) lnErrorIndex);
  405.    // change the pdu type for responses
  406.    if ( reason == SNMP_CLASS_ASYNC_RESPONSE)
  407.       pdu.set_type( SNMP_PDU_RESPONSE);
  409.    //------[ call into the callback function ]-------------------------------
  411.    (callback)(   reason,                       // reason
  412.                  (Snmp*) spp_session,          // snmp++ session who own the req
  413.                  (Pdu&) pdu,                   // pdu
  414.                  (SnmpTarget&) v1target,       // target
  415.                  (void*) personality);         // callback data
  417.    //------[ free up the vbs ]
  418.    delete [] vbs;
  420.    //------[ free up winsnmp vars ]------------------------------------------
  421.    SnmpFreeDescriptor( SNMP_SYNTAX_OCTETS, (smiLPOPAQUE) &octet_community);
  422. };
  425. //-----------------------------------------------------------------------
  426. //--------------------[ trap handler ]----------------------------------
  427. //-----------------------------------------------------------------------
  428. // Prepares the trap message to be callled to the
  429. // trap callback function
  430. void FAR  process_trap_event( int reason,
  431.                                long int lnRecvRequestId,
  432.                                HSNMP_SESSION session_handle,
  433.                                smiINT lnErrorStatus,
  434.                                smiINT lnErrorIndex,
  435.                                HSNMP_VBL hRecvVbl,
  436.                                HSNMP_CONTEXT hRecvContext,
  437.                                HSNMP_ENTITY hDstRecvEnt,
  438.                                Snmp* spp_session,
  439.                                snmp_callback callback,
  440.                                void * personality)
  441. {
  442.    int vb_count;                     // number of vbs
  443.    Vb* vbs;                          // vbs, dynamically instantiated
  444.    SNMPAPI_STATUS gen_status;        // status of getting a vb
  445.    unsigned char agent_addr[40];     // agent address space
  446.    smiOCTETS octet_community;        // octet community name
  447.    unsigned char community_name[255]; // community name for async passing
  448.    CTarget target;                   // v1 target to use
  449.    Pdu pdu,sendpdu;                  // instantiated pdu object
  450.    TimeTicks timestamp;              // timestamp on trap
  451.    Oid trapid;                       // type of trap
  452.    Oid enterprise;                   // enterprise of a trap
  455.    SNMPDEBUG("++ SNMP++, In Process Trap Eventn");
  456.    // get the var bind list from WinSnmp
  457.    // if vb count is zero then nothing to
  458.    // do return out;
  459.    vb_count = (int) SnmpCountVbl( hRecvVbl);
  460.    if ( vb_count == 0)
  461.    {
  462.       SNMPDEBUG("-- SNMP++, Trap Handler Vb count = 0n");
  463.       return;
  464.    }
  466.    // dynamically instantiate a list of
  467.    // Vb obejcts
  468.    // return if new error
  469.    vbs = new Vb[vb_count];
  470.    if ( vbs == 0)
  471.    {
  472.      SNMPDEBUG("-- SNMP++, Trap Handler new Vb Failn");
  473.      return;  // if new error then return
  474.    }
  476.    // stuff them into the pdu
  477.    pdu.set_vblist( (Vb*) vbs, vb_count);
  479.    // extract vbs from WinSNMP var bind list into
  480.    // Snmp++ pdu objects
  481.    extract_from_varbindlist( hRecvVbl, pdu);
  483.    // build up the timeticks and trapid portions
  484.    Vb tempvb;
  485.    //skip the first two vbs in the list
  486.    for ( int w=2;w<pdu.get_vb_count();w++)
  487.    {
  488.       pdu.get_vb(tempvb,w);
  489.       sendpdu += tempvb;
  490.    }
  491.    // get the timestamp found in vb #1
  492.    pdu.get_vb(tempvb,0);
  493.    tempvb.get_value( timestamp);
  495.    // get the trapid found in vb #2
  496.    pdu.get_vb( tempvb,1);
  497.    tempvb.get_value( trapid);
  498.    // patch for incorrect ".0" on trap is in WinSNMP
  499.    if ( trapid[ (int) (trapid.len()-1)] == (unsigned long) 0)
  500.       trapid.trim(1);
  502.    // try to pull off the enterprise
  503.    // if its there it will the last vb in the pdu
  504.    Vb enterprise_vb;
  505.    Oid e_oid;
  506.    sendpdu.get_vb( enterprise_vb, sendpdu.get_vb_count() -1);
  507.    enterprise_vb.get_oid( e_oid);
  508.    if ( e_oid == "1.3.6.1.6.3.1.1.4.3.0")
  509.    {
  510.    enterprise_vb.get_value( enterprise);
  511.    sendpdu.trim();
  512.    }
  514.    //------[ prepare the agent address ]-------------------------------------
  515.    gen_status = SnmpEntityToStr( hDstRecvEnt,40, (char *) agent_addr);
  516.    if ( gen_status == SNMPAPI_FAILURE)
  517.    {
  518.       delete [] vbs;                    // free the snmp++ vbs
  519.       SNMPDEBUG("-- SNMP++, Trap Handler SnmpEntityToStr Failn");
  520.       return;                           // error case, don't call callback
  521.    }
  524.    //-----[ prepare the agents context ]-------------------------------------
  525.    gen_status = SnmpContextToStr( hRecvContext, &octet_community);
  526.    if ( gen_status == SNMPAPI_FAILURE)
  527.    {
  528.       delete [] vbs;                    // free the snmp++ vbs
  529.       SNMPDEBUG("-- SNMP++, Trap Handler SnmpContextToStr Failn");
  530.       return;                           // error case, don't call callback
  531.    }
  533.    //----[ copy SMI octet community into an unsigned char community ]
  534.    // protect againt over running the target string
  535.    MEMCPY( community_name,
  536.            octet_community.ptr,
  537.            (size_t) min(octet_community.len,40));
  539.    //------[ make an target object for the callback ]----------------------
  540.    // set the address portion of the target
  541.    GenAddress address( (char *) agent_addr);
  542.    if ( !address.valid())
  543.       return;
  545.    target.set_address( address);
  547.    // fill in the community names
  548.    OctetStr rc( (const unsigned char *) octet_community.ptr, octet_community.len);
  550.    target.set_readcommunity( rc);
  551.    target.set_writecommunity( rc);
  553.    //------[ make up a pdu onject ]------------------------------------------
  554.    set_request_id( &pdu, lnRecvRequestId);     // friend function call
  555.    set_error_status( &pdu, (int) lnErrorStatus);
  556.    set_error_index( &pdu, (int) lnErrorIndex);
  558.    // change the pdu type for responses
  559.    if ( reason == SNMP_CLASS_ASYNC_RESPONSE)
  560.       pdu.set_type( SNMP_PDU_RESPONSE);
  562.    //------[ load up the trap id and timestamp ]-----------------------------
  563.    sendpdu.set_notify_id( trapid);
  564.    sendpdu.set_notify_timestamp( timestamp);
  565.    sendpdu.set_notify_enterprise( enterprise);
  567.  
  568.    //------[ determine if we should call into the callback ]-----------------
  569.    OidCollection trapids;
  570.    TargetCollection targets;
  572.    spp_session->get_notify_filter( trapids, targets);
  574.    SNMPDEBUG("++ SNMP++, Trap Handler Fire Callbackn");
  575.    //------[ call into the callback function ]-------------------------------
  576.    if (trapids.size()==0)
  577.    {
  578.       (callback)(  reason,                      // reason
  579.                  (Snmp*) spp_session,          // snmp++ session who own the req
  580.                  (Pdu&) sendpdu,               // pdu
  581.                  (SnmpTarget&) target,         // target
  582.                  (void*) personality);         // callback data
  583.       SNMPDEBUG("++ SNMP++, Empty Collection, Back From Trap Handler Fire Callbackn");
  584.    }
  585.    else
  586.    {
  587.   Oid cur_id;
  588.       int n = trapids.size();
  589.   for (int z=1;z<=n;z++)
  590.   {
  591.      trapids.get_element( cur_id,z-1);
  592.  if ( cur_id.nCompare( cur_id.len(), trapid)==0)
  593.  {
  594.      (callback)(  reason,                      // reason
  595.                  (Snmp*) spp_session,          // snmp++ session who own the req
  596.                  (Pdu&) sendpdu,               // pdu
  597.                  (SnmpTarget&) target,         // target
  598.                  (void*) personality);         // callback data
  599.                  SNMPDEBUG("++ SNMP++, Explict collection Hit,Back From Trap Handler Fire Callbackn");
  600.  z= n+1;  // stop the loop
  602.  } // end if
  603.   }  // end for
  604.    }  // end else
  605.    //------[ free up the vbs ]
  606.    delete [] vbs;
  608.    //------[ free up winsnmp vars ]------------------------------------------
  609.    SnmpFreeDescriptor( SNMP_SYNTAX_OCTETS, (smiLPOPAQUE) &octet_community);
  610. };
  613. //---------------------------------------------------------------------
  614. //----[ pdu receiver ]-------------------------------------------------
  615. //---------------------------------------------------------------------
  616. // - Receives pdus for all sessions
  617. // - When each session is created, the session handle is set into
  618. //   the WndExtra portion of the created instance. When the WinSnmp
  619. //   dll calls this Windproc its session is extracted via GetWindowWord
  620. //   and is then used to read and decode the pdu. The pdu is registered
  621. //   to the container only if a matching Request id is pending.
  622. //
  623. long FAR PASCAL XPORT SnmpWndProc(HWND hWnd,
  624.                                   UINT message,
  625.                                   UINT wParam,
  626.                                   LONG lParam)
  627. {
  628.    HSNMP_SESSION session_handle; // winsnmp session handle
  629.    HSNMP_PDU hRecvPdu;           // received pdu
  630.    HSNMP_ENTITY hDstRecvEnt,     // received destination
  631.                 hSrcRecvEnt;     // received source
  632.    HSNMP_CONTEXT hRecvContext;   // received context
  633.    SNMPAPI_STATUS Wstatus;       // snmp api status
  634.    smiINT lnRecvPduType;         // received pdu type
  635.    smiINT lnRecvRequestId;       // received pcu status
  636.    smiINT lnErrorStatus;         // received error status
  637.    smiINT lnErrorIndex;          // received error index
  638.    HSNMP_VBL hRecvVbl;           // received variable binding list
  639.    snmp_callback callback;       // callback for async calls
  640.    void * personality;           // personality
  641.    Snmp* spp_session;            // snmp++ session handle
  642.    SNMPAPI_STATUS last_error;    // last WinSnmp error to occur
  643.    int status;
  646.    switch (message)
  647.    {
  649.       // called when window is created
  650.       case WM_CREATE:
  651.         return 0;
  652.       break;
  654.       // called when a pdu is received
  655.       // the session handle is in the WndExtra portion
  656.       // and needs to be extracted
  657.       case SNMP_MSG:
  659.       //-------------------------------------------------------------
  660.       // win32 window handles are 32 bits wide, use GetWindowLong()
  661.       // WinSNMP session handle
  662.       session_handle = (HSNMP_SESSION) GetWindowLong( hWnd,0);
  664.       // snmp++ session
  665.       spp_session = ( Snmp*) GetWindowLong( hWnd,
  666.                                             sizeof( HWND));
  669. //--------------------------------------------------------------
  670. // ACE*COMM specific timeout procesing JR-9/18/97
  671. if ( wParam == SNMPAPI_TL_TIMEOUT) 
  672. {
  673. SNMPDEBUG("SNMP++, ACE*COMM DLL Timeoutn");
  674. // rid is in the lParam
  675. SNMP_WAIT;
  676. pdu_container->timeout();
  677. // check to make sure that this was a
  678. // pending async request
  679. status =  pdu_container->get_cb_info( (long int) lParam,
  680.                                            &callback,
  681.                                            &personality);
  682. SNMP_SIGNAL;
  683. if ( status)
  684. {
  685.          SNMPDEBUG("SNMP++, Found Rid for callback Resolutionn");
  686. // inform the users callback of the timeout
  687. // this was the initial request
  688. process_async_event( (int) SNMP_CLASS_TIMEOUT,
  689.                              lParam,
  690.                              session_handle,
  691.                              0,  // error status
  692.                              0,  // error index
  693.                              0,
  694.                              0,
  695.                              0,
  696.                              spp_session,
  697.                              callback,
  698.                              personality);
  699. }
  700. return 0;
  701. }
  702. // end ACE*COMM msg check
  703. //-------------------------------------------------------------
  705.         SNMPDEBUG("++ SNMP++, Receive msg n");
  706.         // recieve the pdu
  707.         Wstatus = SnmpRecvMsg(session_handle,
  708.                               &hSrcRecvEnt,
  709.                               &hDstRecvEnt,
  710.                               &hRecvContext,
  711.                               &hRecvPdu);
  712.         // if successful process it, else throw it away
  713.         if ( Wstatus != SNMPAPI_FAILURE)
  714.         {
  715.             SNMPDEBUG("++ SNMP++, Get PDU Data n");
  716.             Wstatus = SnmpGetPduData( hRecvPdu,
  717.                                       &lnRecvPduType,
  718.                                       &lnRecvRequestId,
  719.                                       &lnErrorStatus,
  720.                                       &lnErrorIndex,
  721.                                       &hRecvVbl );
  722.             // if the decode was successful stuff it
  723.             // into the pdu container else throw it away
  724.             if ( Wstatus == SNMPAPI_SUCCESS)
  725.             {
  726.                 switch( lnRecvPduType)
  727.                 {
  729.                    //----[ response ]-----------------
  730.                    case SNMP_PDU_RESPONSE:
  731.   SNMP_WAIT;
  732.   status = pdu_container->check_if_pending( (long int) lnRecvRequestId, 
  733.                                         &callback);
  734.   SNMP_SIGNAL;
  735.                       if ( status)
  736.                       {
  737.                          if ( callback ==0)
  738.                          {  // blocking response
  739.                             // memory is freed when extracted using get_slot
  740.                             SNMPDEBUG("++ SNMP++, Process Blocked MSG n");
  741. SNMP_WAIT;
  742.                             pdu_container->set_slot( (long int) lnRecvRequestId,
  743.                                                      session_handle,
  744.                                                      hSrcRecvEnt,
  745.                                                      hDstRecvEnt,
  746.                                                      hRecvContext,
  747.                                                      lnRecvPduType,
  748.                                                      lnRecvRequestId,
  749.                                                      lnErrorStatus,
  750.                                                      lnErrorIndex,
  751.                                                      hRecvVbl);
  752.                             SNMPDEBUG("++ SNMP++, Free PDU n");
  753.                             SnmpFreePdu( hRecvPdu);  
  754.                             // update the pdu count
  755.                             pdu_container->pdu_received();
  756. SNMP_SIGNAL;
  757.                          }
  758.                          else
  759.                          {  // async response
  760.                             SNMPDEBUG("++ SNMP++, Process Async Msg n");
  761.                             // if we can find the request in the pdu container
  762.                             // then get the callback information and process it
  763. SNMP_WAIT;
  764. status =  pdu_container->get_cb_info( (long int) lnRecvRequestId,
  765.                                                         &callback,
  766.                                                         &personality);
  767. SNMP_SIGNAL;
  768.                             if ( status)
  769.                                process_async_event( (int) SNMP_CLASS_ASYNC_RESPONSE,
  770.                                                     lnRecvRequestId,
  771.                                                     session_handle,
  772.                                                     lnErrorStatus,
  773.                                                     lnErrorIndex,
  774.                                                     hRecvVbl,
  775.                                                     hRecvContext,
  776.                                                     hSrcRecvEnt,
  777.                                                     spp_session,
  778.                                                     callback,
  779.                                                     personality);
  780.                             else {
  781.   SNMP_WAIT;
  782.                               pdu_container->stray_response();
  783.   SNMP_SIGNAL;
  784. }
  786.                             SNMPDEBUG("++ SNMP++, Free Vars After process_asyncn");
  787.                             SnmpFreeVbl( hRecvVbl);
  788.                             SnmpFreeEntity( hSrcRecvEnt);
  789.                             SnmpFreeContext( hRecvContext);
  790.                             SnmpFreeEntity( hDstRecvEnt);  // don't need
  791.                             SnmpFreePdu( hRecvPdu);        // don't need
  792.                             // update the pdu count
  793. SNMP_WAIT;
  794.                             pdu_container->pdu_received();
  795. SNMP_SIGNAL;
  796.                          }
  797.                       }
  798.                       else   // not a pending response, toss it
  799.                       {
  800.                          SNMPDEBUG("++ SNMP++, Stray Message n");
  801.                          SnmpFreeEntity( hSrcRecvEnt);
  802.                          SnmpFreeEntity( hDstRecvEnt);
  803.                          SnmpFreeContext( hRecvContext);
  804.                          SnmpFreePdu( hRecvPdu);
  805.                          SnmpFreeVbl( hRecvVbl);
  806.  SNMP_WAIT;
  807.                          pdu_container->stray_response();
  808.  SNMP_SIGNAL;
  809.                       }
  810.                    break;
  812.                    //---[ trap ]----------------------
  813.                    case SNMP_PDU_TRAP:
  814.   SNMP_WAIT;
  815.                       pdu_container->trap_received();
  816.   SNMP_SIGNAL;
  817.                       SNMPDEBUG("++ SNMP++, TRAP Received n");
  818.                       if ( spp_session->get_notify_callback() != 0)
  819.                          process_trap_event( (int) SNMP_CLASS_NOTIFICATION,
  820.                                               lnRecvRequestId,
  821.                                               session_handle,
  822.                                               lnErrorStatus,
  823.                                               lnErrorIndex,
  824.                                               hRecvVbl,
  825.                                               hRecvContext,
  826.                                               hSrcRecvEnt,
  827.                                               spp_session,
  828.                                               spp_session->get_notify_callback(),
  829.                                               spp_session->get_notify_callback_data());
  830.                       SNMPDEBUG("++ SNMP++, Free Entity and PDU n");
  831.                       SnmpFreeEntity( hSrcRecvEnt);
  832.                       SnmpFreeEntity( hDstRecvEnt);
  833.                       SnmpFreeContext( hRecvContext);
  834.                       SnmpFreePdu( hRecvPdu);
  835.                       SnmpFreeVbl( hRecvVbl);
  836.                    break;
  838.                    //----[ unidentified message ]---------------
  839.                    default:
  840.                    {
  841.                       SNMPDEBUG("++ SNMP++, unidentified Message n");
  842.   SNMP_WAIT;
  843.                       pdu_container->stray_response();
  844.                       SnmpFreeEntity( hSrcRecvEnt);
  845.                       SnmpFreeEntity( hDstRecvEnt);
  846.                       SnmpFreeContext( hRecvContext);
  847.                       SnmpFreePdu( hRecvPdu);
  848.                       SnmpFreeVbl( hRecvVbl);
  849.                       pdu_container->invalid_resp_pdu();
  850.   SNMP_SIGNAL;
  851.                    }
  853.                 };  // end switch
  855.             }
  856.             else  //error getting pdu data, so we need to free the vars
  857.             {
  858.                SNMPDEBUG("++ SNMP++, GET PDU ERROR n");
  859.    SNMP_WAIT;
  860.                SnmpFreeEntity( hSrcRecvEnt);
  861.                SnmpFreeEntity( hDstRecvEnt);
  862.                SnmpFreeContext( hRecvContext);
  863.                SnmpFreePdu( hRecvPdu);
  864.                pdu_container->decode_err();
  865.    SNMP_SIGNAL;
  866.             }
  867.         }   // end if recv success
  868.         else
  869.         {
  870.            SNMPDEBUG("++ SNMP++, Receive MSG Fail n");
  871.            // receive message fail, look for timeout case
  872.            last_error = SnmpGetLastError( session_handle);
  873.            if ( last_error == SNMPAPI_TL_TIMEOUT)
  874.            {
  875.               SNMPDEBUG("++ SNMP++, WinSNMP TimeOut Notify n");
  876.               // process a async timeout event
  877.               // we only care about async ones
  878.               // handles from receive message are valid
  879.               SNMPDEBUG("++ SNMP++, Get PDU Data n");
  880.               Wstatus = SnmpGetPduData( hRecvPdu,
  881.                                         &lnRecvPduType,
  882.                                         &lnRecvRequestId,
  883.                                         &lnErrorStatus,
  884.                                         &lnErrorIndex,
  885.                                         &hRecvVbl );
  886.               if ( Wstatus == SNMPAPI_SUCCESS)
  887.               {
  888.  SNMP_WAIT;
  889.                  pdu_container->timeout();
  890.                  // check to make sure that this was a
  891.                  // pending async request
  892.  status = pdu_container->get_cb_info( (long int) lnRecvRequestId,
  893.                                                         &callback,
  894.                                                         &personality);
  895.  SNMP_SIGNAL;
  896.                  if ( status)
  897.                  {
  898.                     // clear the request from the pdu container
  899. SNMP_WAIT;
  900.                     pdu_container->clear_request_id( (long int) lnRecvRequestId);
  901. SNMP_SIGNAL;
  903.                     // inform the users callback of the timeout
  904.                     // this was the initial request
  905.                     process_async_event( (int) SNMP_CLASS_TIMEOUT,
  906.                                          lnRecvRequestId,
  907.                                          session_handle,
  908.                                          0,  // error status
  909.                                          0,  // error index
  910.                                          hRecvVbl,
  911.                                          hRecvContext,
  912.                                          hSrcRecvEnt,
  913.                                          spp_session,
  914.                                          callback,
  915.                                          personality);
  917.                  }
  918.                  SnmpFreeVbl( hRecvVbl);
  919.               }
  920.               // free up the get message vars
  921.               // these are valid on a timeout
  922.               SnmpFreeEntity( hSrcRecvEnt);
  923.               SnmpFreeEntity( hDstRecvEnt);
  924.               SnmpFreeContext( hRecvContext);
  925.               SnmpFreePdu( hRecvPdu);
  926.            }
  927.            else {
  928.  SNMP_WAIT;
  929.              pdu_container->receive_err();
  930.  SNMP_SIGNAL;
  931.    }
  932.         }
  933.         return 0;
  934.       break;
  936.       default:
  937.        return DefWindowProc(hWnd, message, wParam, lParam);
  938.    }
  939.    return 0;
  940. };
  943. //----------------------------------------------------------------------
  944. //--------[ transport layer start up ]----------------------------------
  945. //----------------------------------------------------------------------
  946. // Private function, not exposed to the outside
  947. int transport_start_up( )
  948. {
  949.    SNMPAPI_STATUS status;
  950.    WNDCLASS snmpc;
  951. #ifndef _DLL_ATTACH_OPTION
  952. smiUINT32 nMajVer, nMinVer, nLevel, nTrans, nReTrans;
  953. #endif
  955.    SNMPDEBUG("++ SNMP++, Transport Start UP n");
  957.    // set translation mode to v1
  958.    SnmpSetTranslateMode( SNMPAPI_UNTRANSLATED_V1);
  960.    // register the snmp class
  961.    snmpc.style = 0;
  962.    snmpc.lpfnWndProc = SnmpWndProc;
  963.    snmpc.cbClsExtra = 0;
  964.    snmpc.cbWndExtra = sizeof( HWND) +     // WinSnmp Session
  965.                       sizeof( Snmp*);     // Snmp++ session
  966.     
  967.    snmpc.hInstance = NULL;
  970.    snmpc.hIcon = NULL;
  971.    snmpc.hCursor = NULL;
  972.    snmpc.hbrBackground = NULL;
  973.    snmpc.lpszMenuName = NULL;
  974.    snmpc.lpszClassName = SzSnmpClass;
  975.    // register will fail if the class
  976.    // already exists, in this case
  977.    // we don't care
  978.    // This may happen is someone inadvertently
  979.    // calls transport_start_up more than once!
  980.    status = RegisterClass( &snmpc); 
  981.    if ( status == 0)
  982.    {
  983.       SNMPDEBUG("-- SNMP++, CLASS REGISTER FAIL n"); 
  984.       return SNMP_CLASS_RESOURCE_UNAVAIL;
  985.    }   
  986.    SNMPDEBUG("++ SNMP++, Done Xport Start Up n");
  987.    // create the pdu container class
  988.    // here, multiple pdu container objects per app
  989.    // should not be created
  990.    pdu_ref_count++;    // up the ref count
  991.    if ( pdu_ref_count ==1)
  992.    {
  993.          SNMPDEBUG("++ SNMP++, New PDU Container n");
  994.          pdu_container = new Pdu_Container();
  995.          if ( pdu_container == NULL)
  996.          {
  997.             SNMPDEBUG("-- SNMP++, Pdu Container Create Fail n");
  998.             return SNMP_CLASS_RESOURCE_UNAVAIL;
  999.          }   
  1000.          else 
  1001.          {
  1002. #ifndef _DLL_ATTACH_OPTION   
  1003.    // start up WinSNMP
  1004. status = SnmpStartup(&nMajVer,
  1005.                              &nMinVer,
  1006.                              &nLevel,
  1007.                              &nTrans,
  1008.                              &nReTrans);
  1009.         if ( status !=  SNMPAPI_SUCCESS ) {
  1010. SNMPDEBUG("Unable to Startup WinSNMP!n");
  1011. return 0;
  1012. }
  1013. SNMPDEBUG("Startup WinSNMP OKn");
  1014. #endif
  1016.             return SNMP_CLASS_SUCCESS;
  1017.          }
  1018.     }
  1019.     else
  1020.     {
  1021. #ifndef _DLL_ATTACH_OPTION   
  1022.    // start up WinSNMP
  1023. status = SnmpStartup(&nMajVer,
  1024.                              &nMinVer,
  1025.                              &nLevel,
  1026.                              &nTrans,
  1027.                              &nReTrans);
  1028.         if ( status !=  SNMPAPI_SUCCESS ) {
  1029. SNMPDEBUG("Unable to Startup WinSNMP!n");
  1030. return 0;
  1031. }
  1032. SNMPDEBUG("Startup WinSNMP OKn");
  1033. #endif
  1035.       return SNMP_CLASS_SUCCESS;    // we already have a good pdu object
  1036. }
  1037. };
  1040. //-----------------------------------------------------------------------
  1041. //----------[ transport layer shut down ]--------------------------------
  1042. //-----------------------------------------------------------------------
  1043. // Private function
  1044. int transport_shut_down( )
  1045. {
  1046.    
  1047.    int unreg_status;
  1049.    SNMPDEBUG("++ SNMP++, Transport Shut Down n");
  1050.   
  1051.    // delete the pdu container only when the ref
  1052.    // count reaches 0
  1053.    pdu_ref_count--;
  1055.    if ( pdu_ref_count == 0)
  1056.    {
  1057.      SNMPDEBUG("++ SNMP++, Destroy PDU Container n");
  1058.      delete pdu_container;
  1059.    }
  1061.    // protect against running counter < 0
  1062.    // this allows a new transport_start_up to
  1063.    // resume
  1064.    if ( pdu_ref_count < 0) pdu_ref_count = 0;
  1065.    
  1066.    unreg_status = UnregisterClass( SzSnmpClass,NULL);
  1068.    if ( unreg_status == FALSE) {
  1069.       SNMPDEBUG("-- SNMP++, UnRegister Class Fail n");
  1070.    }
  1072. #ifndef _DLL_ATTACH_OPTION  
  1073.    SnmpCleanup(); 
  1074. #endif
  1076.    return SNMP_CLASS_SUCCESS;
  1078. };
  1081. //----------------------------------------------------------------------
  1082. //------[ Snmp Class Constructor ]--------------------------------------
  1083. //----------------------------------------------------------------------
  1084. Snmp::Snmp( int &status, unsigned short agent_port)  // status of construction
  1085. {
  1086.    SNMPDEBUG("++ SNMP++, SNMP Constructor n");
  1087.    SNMPAPI_STATUS WinSnmpStatus;    // return status for snmp calls
  1088.    
  1089.    SNMP_WAIT;                      
  1090.    // call transport start up if it hasn't been called before 
  1091.    construct_status = SNMP_CLASS_SUCCESS;
  1092.    if ( snmp_ref_count == 0)
  1093.    {
  1094.        status = transport_start_up();
  1095.        construct_status = status;
  1096.        if ( status != SNMP_CLASS_SUCCESS)
  1097.        {
  1098.            SNMPDEBUG("-- SNMP++, Transport Start Up Failure n");
  1099.    SNMP_SIGNAL;
  1100.            return;
  1101.        }    
  1102.    }
  1103.    snmp_ref_count++;                          // bump up the ref count
  1105.    pdu_handler = CreateWindow( SzSnmpClass,   // name of class
  1106.                                NULL,          // window text 
  1107.                                WS_POPUP,      // window style
  1108.                                0,             // xpos
  1109.                                0,             // ypos
  1110.                                0,             // width
  1111.                                0,             // hieght
  1112.                                0,             // parent window handle, none for popup
  1113.                                0 ,            // window id
  1114.                                0,             // parent instance
  1115.                                0);            // pointer to construct data
  1119.    if ( pdu_handler == NULL)
  1120.    {
  1121.      status = SNMP_CLASS_RESOURCE_UNAVAIL;
  1122.      SNMPDEBUG("-- SNMP++, Hidden Window Create Failure n");
  1123.      construct_status = status;
  1124.  SNMP_SIGNAL;
  1125.      return;
  1126.    }
  1127.    else
  1128.    {
  1129.       // create a winsnmp session
  1130.       iv_snmp_session = (SNMPHANDLE) SnmpOpen(  pdu_handler , SNMP_MSG);
  1131.       if ( iv_snmp_session == SNMPAPI_FAILURE) {
  1132.      WinSnmpStatus = SnmpGetLastError( (HSNMP_SESSION) iv_snmp_session);
  1133.      if (SNMPAPI_ALLOC_ERROR == WinSnmpStatus) 
  1134.         status = SNMP_CLASS_RESOURCE_UNAVAIL; 
  1135.      else if (SNMPAPI_OTHER_ERROR == WinSnmpStatus) 
  1136.              status = SNMP_CLASS_ERROR;
  1137.           else  
  1138.              status = SNMP_CLASS_INTERNAL_ERROR; 
  1139.      SNMPDEBUG("-- SNMP++, WinSNMP Session Create Failure n");
  1140.      construct_status = status;
  1141.      SNMP_SIGNAL;
  1142.      return;
  1143.       } 
  1144.   else {
  1146.          // set the pdu handler extra data to the session handle value
  1147.          // WinSnmp session
  1148.          SetWindowLong( pdu_handler,
  1149.                         0,
  1150.                         (LONG) iv_snmp_session);
  1152.          // snmp++ session
  1153.          SetWindowLong( pdu_handler,
  1154.                         0 + sizeof( HWND),
  1155.                         (LONG) this);
  1156.            
  1157.          // intialize all the trap receiving member variables
  1158.          notify_targets = 0;
  1159.          notify_ids = 0;
  1160.          listen_addresses = 0;
  1161.          notifycallback = 0;
  1162.          notifycallback_data = 0;
  1164.          // success
  1165.          status = SNMP_CLASS_SUCCESS;
  1166.  SNMP_SIGNAL;
  1167.          return;
  1168.       }
  1169.    }
  1170. };
  1174. //--------------------------------------------------------------------
  1175. //---------[ Snmp Class Destructor ]----------------------------------
  1176. //--------------------------------------------------------------------
  1177. // destroys instance
  1178. Snmp::~Snmp()
  1179. {
  1180.    SNMPAPI_STATUS status;
  1182.    SNMP_WAIT;   
  1184.    // if we failed during construction then don't try 
  1185.    // to free stuff up that was not allocated
  1186.    if ( construct_status != SNMP_CLASS_SUCCESS) {
  1187.   SNMP_SIGNAL;
  1188.       return;
  1189.    }
  1191.    // shut down trap reception if used
  1192.    notify_unregister();
  1194.    // terminate the session
  1195.    pdu_container->search_and_destroy( (HSNMP_SESSION) iv_snmp_session, this);
  1196.    status = SnmpClose( (HSNMP_SESSION) iv_snmp_session);
  1197.    status = DestroyWindow( (HWND) pdu_handler);
  1199.    snmp_ref_count--;
  1200.    if (snmp_ref_count <0) snmp_ref_count = 0;
  1201.    if ( snmp_ref_count == 0)
  1202.       transport_shut_down( );
  1204.    SNMPDEBUG("++ SNMP++, Exit From ~Snmp n");
  1205.    SNMP_SIGNAL;
  1206. };
  1208. //-----------------------[ access the trap reception info ]---------------
  1209. snmp_callback Snmp::get_notify_callback()
  1210. { return notifycallback; };
  1212. void * Snmp::get_notify_callback_data()
  1213. { return notifycallback_data; };
  1216. //-----------------------[ get notify filters ]---------------------------
  1217. // return back the currently set notification filters
  1218. // if they are not defined then return back empty collections
  1219. // 
  1220. int Snmp::get_notify_filter( OidCollection &trapids,
  1221.                              TargetCollection &targets)
  1222. {
  1223.    if (notify_ids != 0)
  1224. trapids = *notify_ids;
  1225.    if ( notify_targets != 0)
  1226.    targets = *notify_targets;
  1228.    return SNMP_CLASS_SUCCESS;
  1229. };
  1231. //-----------------------[ register to get traps]-------------------------
  1232. // alternate form for local listen specification
  1233. int Snmp::notify_register( const OidCollection &trapids,
  1234.                            const TargetCollection &targets,
  1235.                            const AddressCollection &listen_addresses,
  1236.                            const snmp_callback  callback,
  1237.                            const void *callback_data) 
  1238. {
  1239.      return notify_register( trapids,
  1240.                              targets,
  1241.                              callback,
  1242.                              callback_data);
  1243. };
  1246. //-----------------------[ register to get traps]-------------------------
  1247. int Snmp::notify_register( const OidCollection &trapids,
  1248.                            const TargetCollection &targets,
  1249.                            const snmp_callback  callback,
  1250.                            const void *callback_data) 
  1251. { 
  1252.    SNMPAPI_STATUS status;
  1253.    SNMPAPI_STATUS WinSnmpStatus; // return status for snmp calls
  1254.    int return_status = 0;
  1255.    int already_on = FALSE;
  1257.    // free up local collections
  1258.    if ( notify_targets != 0)
  1259.       delete notify_targets;
  1261.    if ( notify_ids != 0) {
  1262.       delete notify_ids;
  1263.   already_on = TRUE;
  1264.    }
  1267.    // null out callback information
  1268.    notifycallback = 0;
  1269.    notifycallback_data = 0;
  1271.    //-------------------------------------------------------------------------
  1272.    //-----------[ assign new trap filtering info ]----------------------------
  1273.    //-------------------------------------------------------------------------
  1275.    // create a new collection using param passed in
  1276.    notify_targets = new TargetCollection ( targets);
  1277.    // delete current trapid collection if defined
  1278.   
  1279.    // create a new collection using param passed in
  1280.    notify_ids = new OidCollection( trapids);        
  1281.    // assign callback and callback data info
  1282.    notifycallback = callback;
  1283.    notifycallback_data = (void*) callback_data;
  1285.    //--------------------------------------------------------------------
  1286.    //-----------[ Turn the traps on using new info ]---------------------
  1287.    //--------------------------------------------------------------------
  1288.    if ( !already_on) {
  1289.   // listen for everything
  1290.       status = SnmpRegister( (HSNMP_SESSION)iv_snmp_session,// session to use
  1291.                              NULL,                          // source entity
  1292.                              NULL,                          // destination entity, don't care where its directed
  1293.                              NULL,                          // handle send context, don't care what the community name is
  1294.                              NULL,                          // oid mask
  1295.                              SNMPAPI_ON);
  1296.    }
  1297.    else
  1298.    return SNMP_CLASS_SUCCESS; 
  1300.    if ( status == SNMPAPI_FAILURE) {
  1301.        WinSnmpStatus = SnmpGetLastError( (HSNMP_SESSION) iv_snmp_session);
  1302.        if (SNMPAPI_ALLOC_ERROR == WinSnmpStatus) {
  1303.    return SNMP_CLASS_RESOURCE_UNAVAIL;
  1304.        } else if (SNMPAPI_OTHER_ERROR == WinSnmpStatus) {
  1305.    return SNMP_CLASS_ERROR;
  1306.        } else if (SNMPAPI_TL_IN_USE == WinSnmpStatus) {
  1307.    return SNMP_CLASS_TL_IN_USE;   
  1308.        } else if (SNMPAPI_TL_NOT_AVAILABLE == WinSnmpStatus) {
  1309.    return SNMP_CLASS_TL_UNSUPPORTED;
  1310.        } else {
  1311.    return SNMP_CLASS_INTERNAL_ERROR; 
  1312.        }
  1313.    }
  1315.    return SNMP_CLASS_SUCCESS;
  1316. };
  1318. //-----------------------[ un-register to get traps]----------------------
  1319. int Snmp::notify_unregister() 
  1320. { 
  1321.     SNMPAPI_STATUS Wstatus;
  1323.     // free up local collections
  1324.     if ( notify_targets != 0)
  1325.        delete notify_targets;
  1327.     if ( notify_ids != 0)
  1328.        delete notify_ids;
  1330.     // null out callback information
  1331.     notifycallback = 0;
  1332.     notifycallback_data = 0;
  1334.     // invoke WinSNMP register to turn it off
  1335.     Wstatus = SnmpRegister((HSNMP_SESSION)iv_snmp_session,  // session to use
  1336.                            NULL,             // source entity
  1337.                            NULL,             // destination entity, don't care where its directed
  1338.                            NULL,             // handle send context, don't care what the community name is
  1339.                            NULL,             // oid mask
  1340.                            SNMPAPI_OFF);
  1342.     if ( Wstatus == SNMPAPI_FAILURE) {
  1343. Wstatus = SnmpGetLastError( (HSNMP_SESSION) iv_snmp_session);
  1344. if (SNMPAPI_ALLOC_ERROR == Wstatus) {
  1345.     return SNMP_CLASS_RESOURCE_UNAVAIL; 
  1346. } else {
  1347.     return SNMP_CLASS_INTERNAL_ERROR; 
  1348. }
  1349.     }
  1351.     return SNMP_CLASS_SUCCESS; 
  1352. };
  1354. //----------------------[ cancel a pending request ]--------------------
  1355. // cancel a pending request
  1356. // only cancels async requests
  1357. // returns true is canceled and false if nothing to cancel
  1358. int Snmp::cancel( const unsigned long rid)
  1359. {
  1360.    snmpcallback callback;
  1362.    SNMP_WAIT;
  1363.    if ( pdu_container->check_if_pending( (long int) rid, &callback))
  1364.    {
  1365.       if ( callback != 0)
  1366.       {
  1367.          pdu_container->clear_request_id( rid);
  1368.  SNMP_SIGNAL;
  1369.          return SNMP_CLASS_SUCCESS;
  1370.       }
  1371.    }
  1372.    SNMP_SIGNAL;
  1373.    return SNMP_CLASS_INVALID_REQID;  // no requests pending for this rid
  1374. };
  1376. //------------------------[ get ]---------------------------------------
  1377. int Snmp::get( Pdu &pdu,                   // pdu to use
  1378.                SnmpTarget &target)   // get target
  1379. {
  1380.    pdu.set_type( sNMP_PDU_GET);
  1381.    return snmp_engine( pdu,       // get pdu
  1382.                        0,         // max repeaters
  1383.                        0,         // non repeaters
  1384.                        target,    // target
  1385.                        NULL,      // callback for async only
  1386.                        0);        // callback data
  1387. };
  1389. //------------------------[ get async ]----------------------------------
  1390. int Snmp::get( Pdu &pdu,                     // pdu to use
  1391.                SnmpTarget &target,           // destination target
  1392.                const snmp_callback callback, // async callback
  1393.                const void * callback_data)   // callback data
  1394. {
  1395.    if ( ! callback )
  1396.        return SNMP_CLASS_INVALID_CALLBACK;
  1398.    pdu.set_type( sNMP_PDU_GET);
  1399.    return snmp_engine( pdu,            // get async pdu
  1400.                        0,              // max repeaters
  1401.                        0,              // non repeaters
  1402.                        target,         // target
  1403.                        callback,       // callback to use
  1404.                        callback_data); // callback data
  1405. };
  1407. //------------------------[ get next ]-----------------------------------
  1408. int Snmp::get_next( Pdu &pdu,             // pdu to use
  1409.                     SnmpTarget &target)   // get target
  1410. {
  1411.    pdu.set_type( sNMP_PDU_GETNEXT);
  1412.    return snmp_engine( pdu,        // pdu to get next
  1413.                        0,          // max repeaters
  1414.                        0,          // non repeaters
  1415.                        target,     // target
  1416.                        NULL,       // callback for async only
  1417.                        0);         // callback data for async only
  1418. };
  1420. //------------------------[ get next async ]-----------------------------
  1421. int Snmp::get_next( Pdu &pdu,                     // pdu to use
  1422.                     SnmpTarget &target,           // destination target
  1423.                     const snmp_callback callback, // callback to use
  1424.                     const void *callback_data)    // callback data
  1425. {
  1426.    if ( ! callback )
  1427.        return SNMP_CLASS_INVALID_CALLBACK;
  1429.    pdu.set_type( sNMP_PDU_GETNEXT);
  1430.    return snmp_engine( pdu,              // pdu to get next
  1431.                        0,                // max repeaters
  1432.                        0,                // non repeaters
  1433.                        target,           // target
  1434.                        callback,         // callback
  1435.                        callback_data);   // callback data
  1436. };
  1438. //-------------------------[ set ]---------------------------------------
  1439. int Snmp::set( Pdu &pdu,            // pdu to use
  1440.                SnmpTarget &target)  // target address
  1441. {
  1442.    pdu.set_type( sNMP_PDU_SET);
  1443.    return snmp_engine( pdu,         // pdu to set
  1444.                        0,           // max repeaters
  1445.                        0,           // non repeaters
  1446.                        target,      // target
  1447.                        NULL,        // callback for async only
  1448.                        0);          // callback data
  1449. };
  1451. //------------------------[ set async ]----------------------------------
  1452. int Snmp::set( Pdu &pdu,                     // pdu to use
  1453.                SnmpTarget &target,           // destination target
  1454.                const snmp_callback callback, // callback to use
  1455.                const void * callback_data)   // callback data
  1456. {
  1457.    if ( ! callback )
  1458.        return SNMP_CLASS_INVALID_CALLBACK;
  1460.    pdu.set_type( sNMP_PDU_SET);
  1461.    return snmp_engine( pdu,               // pdu to set
  1462.                        0,                 // max repeaters
  1463.                        0,                 // non repeaters
  1464.                        target,            // target
  1465.                        callback,          // callback function
  1466.                        callback_data);    // callback data
  1467. };
  1469. //-----------------------[ get bulk ]------------------------------------
  1470. int Snmp::get_bulk( Pdu &pdu,                // pdu to use
  1471.                     SnmpTarget &target,      // destination target
  1472.                     const int non_repeaters, // number of non repeaters
  1473.                     const int max_reps)      // maximum number of repetitions
  1474. {
  1475.      pdu.set_type( sNMP_PDU_GETBULK);
  1476.      return snmp_engine( pdu,               // pdu to use
  1477.                          non_repeaters,     // # of non repeaters
  1478.                          max_reps,          // max repititions
  1479.                          target,            // target
  1480.                          NULL,              // callback for async only
  1481.                          0);                // callback data
  1482. };
  1484. //-----------------------[ get bulk async ]------------------------------
  1485. int Snmp::get_bulk( Pdu &pdu,                     // pdu to use
  1486.                     SnmpTarget &target,           // destination target
  1487.                     const int non_repeaters,      // number of non repeaters
  1488.                     const int max_reps,           // maximum number of repetitions
  1489.                     const snmp_callback callback, // callback to use
  1490.                     const void *callback_data)    // callback data
  1491. {
  1492.    if ( ! callback )
  1493.        return SNMP_CLASS_INVALID_CALLBACK;
  1495.   pdu.set_type( sNMP_PDU_GETBULK);
  1496.   return snmp_engine( pdu,                    // pdu to use
  1497.                       non_repeaters,          // # of non repeaters
  1498.                       max_reps,               // max repititions
  1499.                       target,                 // target
  1500.                       callback,               // callback function
  1501.                       callback_data);         // callback data
  1502. };
  1505. //----------------------[ blocking inform, V2 only]------------------------
  1506. int Snmp::inform( Pdu &pdu,                // pdu to send
  1507.                   SnmpTarget &target)      // destination target
  1508. {
  1509.    pdu.set_type( sNMP_PDU_INFORM);
  1510.    return snmp_engine( pdu,       // get pdu
  1511.                        0,         // max repeaters
  1512.                        0,         // non repeaters
  1513.                        target,    // target
  1514.                        NULL,      // callback for async only
  1515.                        0);        // callback data
  1516. };
  1518. //----------------------[ asynch inform, V2 only]------------------------
  1519. int Snmp::inform( Pdu &pdu,                     // pdu to send
  1520.                   SnmpTarget &target,           // destination target
  1521.                   const snmp_callback callback, // callback function
  1522.                   const void * callback_data)   // callback data
  1523. {
  1524.    if ( ! callback )
  1525.       return SNMP_CLASS_INVALID_CALLBACK;
  1527.    pdu.set_type( sNMP_PDU_INFORM_ASYNC);
  1528.    return snmp_engine( pdu,               // pdu to set
  1529.                        0,                 // max repeaters
  1530.                        0,                 // non repeaters
  1531.                        target,            // target
  1532.                        callback,          // callback function
  1533.                        callback_data);    // callback data
  1534. };
  1537. //---------------------[ send a trap ]------------------------------------------
  1538. int Snmp::trap( Pdu &pdu,             // pdu to send
  1539.                 SnmpTarget &target)   // destination target
  1540. { 
  1541.    int status;
  1542.    long int request_id;          // unique request id
  1543.    
  1544.    SNMPDEBUG("++ SNMP++, Send a Trapn");
  1546.    //---------[ make sure pdu is valid ]--------------------------
  1547.    if ( !pdu.valid())
  1548.      return  SNMP_CLASS_INVALID_PDU;
  1550.    pdu.set_type( sNMP_PDU_TRAP);
  1552.    SNMP_WAIT;
  1553.    //-----[ get a request id to use ]-------------------------
  1554.    request_id = pdu_container->get_request_id();
  1555.    SNMP_SIGNAL;
  1556.        
  1557.    //-----[ send it out ]----------------------------------------------
  1558.    status = sendMsg(target, pdu,0,0,request_id);
  1560.    // verify the send status
  1561.    if (status != SNMP_CLASS_SUCCESS) {
  1562.       SNMPDEBUG("-- SNMP++, Failure Sending Trap Pdun");
  1563.       return status;  // fail on send message
  1564.    }
  1566.    SNMP_WAIT;
  1567.    pdu_container->traps_sent();
  1568.    SNMP_SIGNAL;
  1569.    
  1570.    return SNMP_CLASS_SUCCESS;
  1571. };
  1573. //------------[ convert SNMP++ VB to WinSNMP smiVALUE ]----------------
  1574. int convertVbToSmival( Vb &tempvb, smiVALUE *smival )
  1575. {
  1576.    smival->syntax = tempvb.get_syntax();
  1577.    switch ( smival->syntax ) {
  1578.       
  1579.    //    case sNMP_SYNTAX_INT32:
  1580.       case sNMP_SYNTAX_INT:
  1581.   tempvb.get_value(smival->value.sNumber);
  1582.   break;
  1584.       //    case sNMP_SYNTAX_UINT32:
  1585.       case sNMP_SYNTAX_GAUGE32:
  1586.       case sNMP_SYNTAX_CNTR32:
  1587.       case sNMP_SYNTAX_TIMETICKS:
  1588.   tempvb.get_value(smival->value.uNumber);
  1589.   break;
  1591.   // case Counter64
  1592.       case sNMP_SYNTAX_CNTR64:
  1593.       {
  1594.      Counter64 c64;
  1595.      tempvb.get_value(c64);
  1596.      smival->value.hNumber.hipart = c64.high();
  1597.      smival->value.hNumber.lopart = c64.low();
  1598.   }
  1599.   break;
  1601.       case sNMP_SYNTAX_BITS:
  1602.       case sNMP_SYNTAX_OCTETS:
  1603.       case sNMP_SYNTAX_IPADDR:
  1604.       {
  1605.      OctetStr os;
  1606.      tempvb.get_value(os);
  1607.      smival->value.string.ptr = NULL;
  1608.      smival->value.string.len = os.len();
  1609.      if ( smival->value.string.len > 0 ) 
  1610.  {
  1611. smival->value.string.ptr = (SmiLPBYTE) new  unsigned char [smival->value.string.len];
  1612.         if ( smival->value.string.ptr ) 
  1613.     {
  1614.                for (int i=0; i<(int) smival->value.string.len ; i++)
  1615.           smival->value.string.ptr[i] = os[i];
  1616.         } 
  1617.     else 
  1618.     { 
  1619.            smival->syntax = sNMP_SYNTAX_NULL;  // invalidate the smival
  1620.            return SNMP_CLASS_RESOURCE_UNAVAIL;
  1621.         }
  1622.      }
  1623.       }
  1624.       break;
  1626.       case sNMP_SYNTAX_OID:
  1627.   {
  1628.      Oid oid;
  1629.      tempvb.get_value(oid);
  1630.      smival->value.oid.ptr = NULL;
  1631.      smival->value.oid.len = oid.len();
  1632.      if ( smival->value.oid.len > 0 ) 
  1633.  {
  1634. smival->value.oid.ptr = (SmiLPUINT32) new unsigned long [ smival->value.oid.len];
  1635.         if ( smival->value.oid.ptr ) 
  1636. {
  1637.                for (int i=0; i<(int)smival->value.oid.len ; i++)
  1638.           smival->value.oid.ptr[i] = oid[i];
  1639.         } 
  1640. else 
  1641. {
  1642.             smival->syntax = sNMP_SYNTAX_NULL;  // invalidate the smival
  1643.             return SNMP_CLASS_RESOURCE_UNAVAIL;
  1644.         }
  1645.     }
  1646.   }
  1647.   break;
  1649.       default:
  1650.         return SNMP_CLASS_INTERNAL_ERROR;
  1651.    }
  1652.    return SNMP_CLASS_SUCCESS;
  1653. }
  1655. //------------[ free WinSNMP smiVALUE descriptors ]---------------------
  1656. void freeSmivalDescriptor( smiVALUE *smival )
  1657. {
  1658.    switch ( smival->syntax ) {
  1659.      case SNMP_SYNTAX_OCTETS:
  1660.      case SNMP_SYNTAX_OPAQUE:
  1661.      case SNMP_SYNTAX_IPADDR:
  1662.      case SNMP_SYNTAX_NSAPADDR: // obsoleted in SNMPv2 Draft Std
  1663.      case SNMP_SYNTAX_BITS:     // obsoleted in SNMPv2 Draft Std
  1664.           delete [] smival->value.string.ptr;    
  1665.        break;
  1667.      case SNMP_SYNTAX_OID:
  1668.   delete [] smival->value.oid.ptr;
  1669.        break;
  1670.    }
  1671.    smival->syntax = SNMP_SYNTAX_NULL;
  1672. }
  1674. //----------------------[ load_varbindlist ]----------------------------
  1675. // load the WinSNMP varbind list with the Snmp++ Vb objects
  1676. int load_varbindlist(HSNMP_SESSION session_handle,
  1677.              HSNMP_VBL hvbl,   // handle to WinSNMP vbl
  1678.                      Pdu &pdu)         // pdu to use
  1679. {
  1680.    int z;                  // looping variable
  1681.    Oid current_oid;        // current oid object
  1682.    smiOID smioid;          // winsnmp oid variable
  1683.    smiVALUE smival;        // winsnmp smi value
  1684.    SNMPAPI_STATUS Wstatus; // return status for snmp calls
  1685.    Vb tempvb;              // temp vb to use
  1686.    int vb_count;           // count of vbs in pdu
  1687.    unsigned short action;  // type of pdu
  1688.    int rc;            // snmp++ result code
  1689.    TimeTicks timestamp;    // timestamp for traps
  1691.    SNMPDEBUG("++ SNMP++, In load var bind list n");
  1692.    vb_count = pdu.get_vb_count();
  1693.    action = pdu.get_type();
  1695.    //------------------------------------------------
  1696.    // if its a trap then build up trap timestamp and id
  1697.    if ( action == sNMP_PDU_TRAP) {
  1699.    // timestamp
  1700.    tempvb.set_oid( (Oid) "1.3.6.1.2.1.1.3.0");
  1701.    pdu.get_notify_timestamp( timestamp);
  1702.    if ( timestamp <= 0) 
  1703.            timestamp = ( long) GetTickCount();
  1704.    tempvb.set_value( timestamp);
  1705.        Wstatus = SnmpStrToOid( tempvb.get_printable_oid(),&smioid);
  1706.        if ( Wstatus == SNMPAPI_FAILURE) 
  1707.    {
  1708.      Wstatus = SnmpGetLastError(NULL);
  1709.      if (SNMPAPI_ALLOC_ERROR == Wstatus) 
  1710.          return SNMP_CLASS_RESOURCE_UNAVAIL; 
  1711.  else 
  1712.  if (SNMPAPI_OID_INVALID == Wstatus) 
  1713.             return SNMP_CLASS_INVALID_OID;
  1714.      else 
  1715.             return SNMP_CLASS_INTERNAL_ERROR; 
  1716.    }
  1717.        rc = convertVbToSmival(tempvb, &smival);
  1719.    if ( rc != SNMP_CLASS_SUCCESS ) 
  1720.    {
  1721.          SnmpFreeDescriptor(SNMP_SYNTAX_OID, (smiLPOPAQUE) &smioid);
  1722.      return rc; 
  1723.    }
  1724.        Wstatus = SnmpSetVb( hvbl,0,&smioid,&smival);
  1725.        if ( Wstatus == SNMPAPI_FAILURE) 
  1726.    {
  1727.      Wstatus = SnmpGetLastError(NULL);
  1728.          SnmpFreeDescriptor(SNMP_SYNTAX_OID, (smiLPOPAQUE) &smioid);
  1729.      freeSmivalDescriptor( &smival);
  1730.      if (SNMPAPI_ALLOC_ERROR == Wstatus) 
  1731.    return SNMP_CLASS_RESOURCE_UNAVAIL; 
  1732.  else 
  1733.    return SNMP_CLASS_INTERNAL_ERROR; 
  1734.        }
  1735.    freeSmivalDescriptor(&smival);
  1736.        // free the smioid descriptor
  1737.        SnmpFreeDescriptor(SNMP_SYNTAX_OID, (smiLPOPAQUE) &smioid);
  1738.         
  1739.    // trap id
  1740.    tempvb.set_oid( (Oid) "1.3.6.1.6.3.1.1.4.1.0");
  1741.    pdu.get_notify_id( current_oid);
  1742.    tempvb.set_value( current_oid);
  1743.        Wstatus = SnmpStrToOid( tempvb.get_printable_oid(),&smioid);
  1744.        if ( Wstatus == SNMPAPI_FAILURE) 
  1745.    {
  1746.      Wstatus = SnmpGetLastError(NULL);
  1747.      if (SNMPAPI_ALLOC_ERROR == Wstatus) 
  1748.          return SNMP_CLASS_RESOURCE_UNAVAIL; 
  1749.  else 
  1750.  if (SNMPAPI_OID_INVALID == Wstatus) 
  1751.             return SNMP_CLASS_INVALID_OID;
  1752.      else 
  1753.             return SNMP_CLASS_INTERNAL_ERROR; 
  1754.    }
  1755.        rc = convertVbToSmival(tempvb, &smival);
  1757.    if ( rc != SNMP_CLASS_SUCCESS ) 
  1758.    {
  1759.          SnmpFreeDescriptor(SNMP_SYNTAX_OID, (smiLPOPAQUE) &smioid);
  1760.      return rc; 
  1761.    }
  1762.        Wstatus = SnmpSetVb( hvbl,0,&smioid,&smival);
  1763.        if ( Wstatus == SNMPAPI_FAILURE) 
  1764.    {
  1765.      Wstatus = SnmpGetLastError(NULL);
  1766.          SnmpFreeDescriptor(SNMP_SYNTAX_OID, (smiLPOPAQUE) &smioid);
  1767.      freeSmivalDescriptor( &smival);
  1768.      if (SNMPAPI_ALLOC_ERROR == Wstatus) 
  1769.    return SNMP_CLASS_RESOURCE_UNAVAIL; 
  1770.  else 
  1771.    return SNMP_CLASS_INTERNAL_ERROR; 
  1772.        }
  1773.    freeSmivalDescriptor(&smival);
  1774.        // free the smioid descriptor
  1775.        SnmpFreeDescriptor(SNMP_SYNTAX_OID, (smiLPOPAQUE) &smioid);
  1776.    
  1777.    };
  1779.    //------------------------------------------------
  1780.    // set all vb's into the vbl for all vb objects
  1781.    for (z=0;z<vb_count;z++)
  1782.    {
  1783.       SNMPDEBUG("++ SNMP++, Loading a Var Bind");
  1784.       // get a vb from the pdu
  1785.       pdu.get_vb( tempvb,z);
  1787.       // extract the oid request from the vb object
  1788.       // put it into a smi oid object
  1789.       tempvb.get_oid( current_oid);
  1790.       Wstatus = SnmpStrToOid( current_oid.get_printable(),&smioid);
  1791.       if ( Wstatus == SNMPAPI_FAILURE) 
  1792.   {
  1793.      Wstatus = SnmpGetLastError(NULL);
  1794.      if (SNMPAPI_ALLOC_ERROR == Wstatus) 
  1795.          return SNMP_CLASS_RESOURCE_UNAVAIL; 
  1796.  else 
  1797.  if (SNMPAPI_OID_INVALID == Wstatus) 
  1798.             return SNMP_CLASS_INVALID_OID;
  1799.      else 
  1800.             return SNMP_CLASS_INTERNAL_ERROR; 
  1801.       }
  1803.       // based on the action set the vb into the vbl
  1804.       // differently
  1805.       switch( action)
  1806.       {
  1807.          //-----[ get action ]
  1808.          // for gets we only need to put the oid portion in
  1809.          // we will get the value portion back
  1810.          case sNMP_PDU_GET:
  1811.          case sNMP_PDU_GETNEXT:
  1812.          case sNMP_PDU_GETBULK:
  1813.          SNMPDEBUG("++ SNMP++, Loading a Var Bind Oid portion only");
  1814.          Wstatus = SnmpSetVb( hvbl,0,&smioid,NULL);
  1815.          if ( Wstatus == SNMPAPI_FAILURE) 
  1816.  {
  1817.         Wstatus = SnmpGetLastError(NULL);
  1818.             SnmpFreeDescriptor(SNMP_SYNTAX_OID, (smiLPOPAQUE) &smioid);
  1819.         if (SNMPAPI_ALLOC_ERROR == Wstatus) 
  1820.        return SNMP_CLASS_RESOURCE_UNAVAIL; 
  1821. else 
  1822.        return SNMP_CLASS_INTERNAL_ERROR; 
  1823.      }
  1824.          break;
  1826.          //-----[ set and notification actions ]
  1827.          // for sets and notifications, we need to put the smivalue portion
  1828.      // as well as the oid portion into the varbind
  1829.          case sNMP_PDU_SET:
  1830.          case sNMP_PDU_TRAP:
  1831.          case sNMP_PDU_INFORM:
  1832.          SNMPDEBUG("++ SNMP++, Loading a Var Bind Oid and Value portion");
  1833.      rc = convertVbToSmival(tempvb, &smival);
  1834.      if ( rc != SNMP_CLASS_SUCCESS ) 
  1835.  {
  1836.             SnmpFreeDescriptor(SNMP_SYNTAX_OID, (smiLPOPAQUE) &smioid);
  1837.         return rc; 
  1838.      }
  1839.          Wstatus = SnmpSetVb( hvbl,0,&smioid,&smival);
  1840.          if ( Wstatus == SNMPAPI_FAILURE) 
  1841.  {
  1842.         Wstatus = SnmpGetLastError(NULL);
  1843.             SnmpFreeDescriptor(SNMP_SYNTAX_OID, (smiLPOPAQUE) &smioid);
  1844.         freeSmivalDescriptor( &smival);
  1845.         if (SNMPAPI_ALLOC_ERROR == Wstatus) 
  1846.       return SNMP_CLASS_RESOURCE_UNAVAIL; 
  1847. else 
  1848.       return SNMP_CLASS_INTERNAL_ERROR; 
  1849.          }
  1850.      freeSmivalDescriptor(&smival);
  1851.          break;
  1853.  default: // Internal error
  1854.          SNMPDEBUG("++ SNMP++, Invalid PDU Type loading a Var Bind list");
  1855.          return SNMP_CLASS_INTERNAL_ERROR;
  1856.          break;
  1858.       }  // end switch
  1860.       // free the smioid descriptor
  1861.       SnmpFreeDescriptor(SNMP_SYNTAX_OID, (smiLPOPAQUE) &smioid);
  1863.    }  //end for z
  1866.    //-----------------------------------------------------------------
  1867.    // check for trap enterprise addition
  1868.    if ( action == sNMP_PDU_TRAP) {
  1869.        tempvb.set_oid( snmpTrapEnterprise);
  1870.    pdu.get_notify_enterprise( current_oid);
  1871.    // enterprise has to be valid
  1872.    if ( current_oid.valid() ) {
  1873.       tempvb.set_value( current_oid);
  1874.           Wstatus = SnmpStrToOid( tempvb.get_printable_oid(),&smioid);
  1875.           if ( Wstatus == SNMPAPI_FAILURE) 
  1876.   {
  1877.         Wstatus = SnmpGetLastError(NULL);
  1878.         if (SNMPAPI_ALLOC_ERROR == Wstatus) 
  1879.             return SNMP_CLASS_RESOURCE_UNAVAIL; 
  1880.     else 
  1881.     if (SNMPAPI_OID_INVALID == Wstatus) 
  1882.                return SNMP_CLASS_INVALID_OID;
  1883.         else 
  1884.                return SNMP_CLASS_INTERNAL_ERROR; 
  1885.   }
  1886.           rc = convertVbToSmival(tempvb, &smival);
  1887.       if ( rc != SNMP_CLASS_SUCCESS ) 
  1888.   {
  1889.              SnmpFreeDescriptor(SNMP_SYNTAX_OID, (smiLPOPAQUE) &smioid);
  1890.          return rc; 
  1891.   }
  1892.           Wstatus = SnmpSetVb( hvbl,0,&smioid,&smival);
  1893.           if ( Wstatus == SNMPAPI_FAILURE) 
  1894.   {
  1895.          Wstatus = SnmpGetLastError(NULL);
  1896.              SnmpFreeDescriptor(SNMP_SYNTAX_OID, (smiLPOPAQUE) &smioid);
  1897.          freeSmivalDescriptor( &smival);
  1898.          if (SNMPAPI_ALLOC_ERROR == Wstatus) 
  1899.         return SNMP_CLASS_RESOURCE_UNAVAIL; 
  1900.      else 
  1901.         return SNMP_CLASS_INTERNAL_ERROR; 
  1902.   }
  1903.       freeSmivalDescriptor(&smival);
  1904.           // free the smioid descriptor
  1905.           SnmpFreeDescriptor(SNMP_SYNTAX_OID, (smiLPOPAQUE) &smioid);
  1906.    } // end if enterprise valid
  1907.    }
  1909.    SNMPDEBUG("++ SNMP++, Out Load VarBind List n");
  1910.    return SNMP_CLASS_SUCCESS;
  1912. }; // end function
  1915. //---------------[ yield pump ]-----------------------
  1916. int yield_pump()
  1917. {
  1918.    MSG msg;                      // message var for blocking
  1920.    // while there are messages, pump em
  1921.    // just look at the message without removing it first
  1922.    while ( PeekMessage( &msg, (HWND) NULL,0,0, PM_NOREMOVE   ))
  1923.    {
  1924.       // get the message
  1925.       GetMessage( &msg, (HWND) NULL,0,0);
  1927.   // check for shutdown
  1928.   if ( msg.message == SNMP_SHUTDOWN_MSG)
  1929.   return SNMP_CLASS_SHUTDOWN;
  1931.       // translate it
  1932.       TranslateMessage( &msg);
  1934.       // dispath it
  1935.       DispatchMessage( &msg);
  1937.    } // end while
  1939.    return SNMP_CLASS_SUCCESS;
  1940. };
  1943. //----------------------------------------------------------------------
  1944. //---------[ snmp++ engine ]--------------------------------------------
  1945. //----------------------------------------------------------------------
  1946. // Snmp engine used for all requests, async and blocked
  1947. // build up the request as a WinSNMP request
  1948. // send it out
  1949. // if it was a async request then return out
  1950. // otherwise wait for response while pumping messages
  1951. // while waiting
  1952. // if request arrived then unload request into snmp++ vb format
  1953. //
  1954. int Snmp::snmp_engine( Pdu &pdu,                 // pdu to use
  1955.                        long int non_reps,        // # of non repititions
  1956.                        long int max_reps,        // # of max repititions
  1957.                        SnmpTarget &target,       // from this target
  1958.                        const snmp_callback cb,   // callback for async calls
  1959.                        const void * cbd)         // callback data
  1961. {
  1962.    long int request_id;          // unique request id
  1963.    int blocked;                  // blocking variable
  1964.    unsigned long start_time;     // starting time of wait
  1965.    HSNMP_ENTITY hDstRecvEnt,     // received destination
  1966.                 hSrcRecvEnt;     // received source
  1967.    HSNMP_CONTEXT hRecvContext;   // received context
  1968.    smiINT lnRecvPduType;         // received pdu type
  1969.    smiINT lnRecvRequestId;       // received pcu status
  1970.    smiINT lnErrorStatus;         // received error status
  1971.    smiINT lnErrorIndex;          // received error index
  1972.    HSNMP_VBL hRecvVbl;           // received variable binding list
  1973.    int return_status;            // return status
  1974.    int error_status;             // pdu error status
  1975.    unsigned long my_timeout;     // target specific timeout
  1976.    int my_retry;                 // target specific retry
  1977.    int yield_value;
  1978.    OctetStr my_get_community;
  1979.    OctetStr my_set_community;
  1980.    snmp_callback my_callback;
  1981.    void * my_callback_data;
  1982.    unsigned long wait_time;
  1983.    GenAddress address; 
  1984.    unsigned char version;  
  1985.    int status;
  1987.    //---------[ make sure target is valid ]-------------------------
  1988.    // make sure that the target is valid
  1989.    if ( ! target.valid()) {
  1990.       SNMPDEBUG("-- SNMP++, Target Object Invalidn");
  1991.       return SNMP_CLASS_INVALID_TARGET;
  1992.    }
  1994.    // try to resolve the target as a v1 target instead
  1995.    if ( !target.resolve_to_C( my_get_community,
  1996.                               my_set_community,
  1997.                               address,
  1998.                               my_timeout,
  1999.                               my_retry,
  2000.                               version)) {
  2001.       SNMPDEBUG("-- SNMP++, V1 Resolve Failn");
  2002.       return SNMP_CLASS_INVALID_TARGET;
  2003.    }
  2005.    //---------[ make sure pdu is valid ]--------------------------
  2006.    if ( !pdu.valid())
  2007.      return  SNMP_CLASS_INVALID_PDU;
  2009.    //----[ build a unique request id ]---------------------------------
  2010.    // each rid is unique by querying the pdu container class for an
  2011.    // available slot. Once an id is issued, no other request can use
  2012.    // it until it is removed from the container
  2013.    SNMP_WAIT;
  2014.    request_id = (smiINT) pdu_container->get_request_id( (HSNMP_SESSION) iv_snmp_session,
  2015.                                                     cb,
  2016.                                                         (void *) cbd);
  2017.    SNMP_SIGNAL;
  2019.    if ( request_id == -1) {
  2020.       return SNMP_CLASS_RESOURCE_UNAVAIL;
  2021.    };
  2023.    //-------[ Send out the PDU ]------------------------------------------
  2024.    SNMPDEBUG("++ SNMP++, Send PDU n");
  2025.    return_status = sendMsg( target, pdu, non_reps, max_reps, request_id);
  2027.    // update
  2028.    SNMP_WAIT;
  2029.    pdu_container->pdu_sent();
  2030.    SNMP_SIGNAL;
  2032.    // verify the send status
  2033.    if (return_status != SNMP_CLASS_SUCCESS) {
  2034.   SNMP_WAIT;
  2035.       pdu_container->clear_request_id( (int) request_id);
  2036.       pdu_container->sent_err();
  2037.   SNMP_SIGNAL;
  2038.       return return_status;  // fail on send message
  2039.    }
  2041.    //---------[ if this was an async call then return out ]
  2042.    // presence of a non-null callback function indicates this is async
  2043.    if ( cb )  
  2044.       return SNMP_CLASS_SUCCESS;
  2046.    //---------[ otherwise we sit and wait for the response pdu ]
  2047.    //---------[ peek and loop until response has arrived or timeout]
  2048.    // Note, the WinSNMP timeout notification is ignored because there
  2049.    // is no support for blocking-mode timeout notification in the 
  2050.    // SnmpWndProc.  Therefore, the following loop checks when the
  2051.    // projected timeout would occur.  
  2053.    blocked = TRUE;
  2054.    start_time = GetTickCount();
  2055.    wait_time = ( unsigned int) my_timeout * (my_retry+1) * 10;
  2056.    while (( blocked) && ( (GetTickCount() - start_time) < wait_time))
  2057.    {
  2059.       //--------------[ yield to windows ]---------------------------
  2060.       // allow other windows messages to be processed
  2061.       yield_value = yield_pump();
  2064.       // after processing any messages, look for responce pdu
  2065.       // did the response pdu arrive?
  2066.   SNMP_WAIT;
  2067.   status = pdu_container->check_if_arrived( (int) request_id);
  2068.       SNMP_SIGNAL;
  2069.       if ( status)
  2070.       {
  2072.          SNMPDEBUG("++ SNMP++, Extract From PDU Cont n");
  2073.          blocked = FALSE;  // no longer blocked on this request
  2074.          // pick up the data
  2075.  SNMP_WAIT;
  2076.          pdu_container->get_slot( (int) request_id,  // for this rid
  2077.                                   &hSrcRecvEnt,      // this source entity
  2078.                                   &hDstRecvEnt,      // this dest entity
  2079.                                   &hRecvContext,     // this community
  2080.                                   &lnRecvPduType,    // this pdu type
  2081.                                   &lnRecvRequestId,  // rid returned
  2082.                                   &lnErrorStatus,    // error status
  2083.                                   &lnErrorIndex,     // error index
  2084.                                   &my_callback,      // callback function
  2085.                                   &my_callback_data, // callback data
  2086.                                   &hRecvVbl);        // vbl returned
  2087.          SNMP_SIGNAL;
  2088.          SNMPDEBUG("++ SNMP++, Get VB Count n");
  2089.      
  2090.          // extract the snmp++ vbs from the winsnmp varbindlist
  2091.          extract_from_varbindlist( hRecvVbl, pdu);
  2093.          // set return error status vals
  2094.          error_status = ( int) lnErrorStatus;
  2095.          set_error_status( &pdu, error_status);
  2096.          set_error_index( &pdu, (int) lnErrorIndex);
  2098.          SNMPDEBUG("++ SNMP++, Free Vbl, Ent, Ent, Context n");
  2099.          // free up the receive resources
  2100.          SnmpFreeVbl( hRecvVbl);
  2101.          SnmpFreeEntity( hSrcRecvEnt);
  2102.          SnmpFreeEntity( hDstRecvEnt);
  2103.          SnmpFreeContext( hRecvContext);
  2104.  SNMP_WAIT;
  2105.          pdu_container->clear_request_id( (int) request_id);
  2106.  SNMP_SIGNAL;
  2108.       }   // end if pdu_received
  2109.   
  2110.       //----------[ did the yield find a stop ]----------------
  2111.       if ( yield_value != SNMP_CLASS_SUCCESS)
  2112.       {
  2113.  SNMP_WAIT;
  2114.          pdu_container->clear_request_id( (int) request_id);
  2115.  SNMP_SIGNAL;
  2116.          return yield_value;
  2117.       };
  2118.   Sleep(1);
  2120.    } // end while blocked & ! timeout
  2122.    //------[ determine if blocked ]-----------------------------
  2123.    // if we are blocked then its a timeout; 
  2124.    // otherwise, it a response.  In the response case,
  2125.    // we return a "warning" if pdu.error_status is set 
  2126.    // by the agent.
  2127.    if ( blocked)
  2128.    {
  2129.   SNMP_WAIT;
  2130.       pdu_container->clear_request_id( (int) request_id);
  2131.   SNMP_SIGNAL;
  2132.       return_status = SNMP_CLASS_TIMEOUT;
  2133.    }
  2134.    else
  2135.    {
  2136.        if ( error_status == 0)
  2137.            return_status = SNMP_CLASS_SUCCESS;
  2138.        else
  2139.            return_status = SNMP_CLASS_ERR_STATUS_SET;
  2140.    }
  2141.    return return_status;
  2142. };
  2145. //-----------------------------------------------------------------
  2146. //--------[ sendMsg ]----------------------------------------------
  2147. //-----------------------------------------------------------------
  2148. int Snmp::sendMsg( SnmpTarget &target,         // target of send
  2149.                    Pdu &pdu,                   // the pdu to send
  2150.    long int non_reps,          // # of non repititions
  2151.                    long int max_reps,          // # of max repititions
  2152.              long int request_id)        // unique request id
  2153. {
  2155.     SNMPAPI_STATUS Wstatus;       // return status for snmp calls
  2156.     HSNMP_PDU hSendPdu;
  2157.     HSNMP_ENTITY hDstEntity;      // destination entity
  2158.     HSNMP_ENTITY hSrcEntity;      // source entity
  2159.     HSNMP_CONTEXT hSendContext;   // send context
  2160.     unsigned long my_timeout;     // target specific timeout
  2161.     int my_retry;                 // target specific retry
  2162.     SmiOCTETS my_community_name;  // community name to use
  2163.     int return_status;
  2164.     OctetStr my_get_community, my_set_community;
  2165.     unsigned short action;
  2166.     GenAddress address;
  2167.     HSNMP_VBL hvbl;
  2168.     unsigned char version; 
  2170.     //---------[ make sure pdu is valid ]---------------------------------
  2171.     if ( !pdu.valid()) {
  2172. SNMPDEBUG("-- SNMP++, PDU Object Invalidn");
  2173. return  SNMP_CLASS_INVALID_PDU;
  2174.     }
  2176.     //---------[ make sure target is valid ]-------------------------
  2177.     // make sure that the target is valid
  2178.     if ( ! target.valid()) {
  2179. SNMPDEBUG("-- SNMP++, Target Object Invalidn");
  2180. return SNMP_CLASS_INVALID_TARGET;
  2181.     }
  2183.     //---------[ get the action from the pdu ]---------------------
  2184.     action = pdu.get_type();
  2186.     // try to resolve the target as a community-based target 
  2187.     if ( !target.resolve_to_C(my_get_community,
  2188.                               my_set_community,
  2189.                               address,
  2190.                               my_timeout,
  2191.                               my_retry,
  2192.                               version)) {
  2193. SNMPDEBUG("-- SNMP++, CTarget Resolve Failn");
  2194. return SNMP_CLASS_INVALID_TARGET;
  2195.     }
  2197.     //-----[ set the translation mode to no translation based on the target type ]
  2198.     Wstatus = SnmpSetTranslateMode( version == version1 ? SNMPAPI_UNTRANSLATED_V1 : SNMPAPI_UNTRANSLATED_V2);
  2200.     if ( Wstatus != SNMPAPI_SUCCESS) {
  2201. Wstatus = SnmpGetLastError( (HSNMP_SESSION) iv_snmp_session);
  2202. SNMPDEBUG("-- SNMP++, Failure setting UNTRANSLATED_V1 moden");
  2204. if (SNMPAPI_ALLOC_ERROR == Wstatus) {
  2205.     return SNMP_CLASS_RESOURCE_UNAVAIL;
  2206. } else {
  2207.     return SNMP_CLASS_INTERNAL_ERROR;
  2208. }
  2209.     }
  2211.     SNMPDEBUG("++ SNMP++, Make Entities, Context & PDU n");
  2212.     //-----[ set destination entity ]--------------------------------
  2213.     // Determine set the port or socket that we should be
  2214.     // sending to.
  2216.     unsigned int port = 0xffff;
  2217.     char * addrStr;
  2218.     int addrType = address.get_type();
  2219.     
  2220.     switch (addrType) {
  2221.       case type_udp:
  2222. {
  2223.   UdpAddress udpAddr(address);
  2224.   port = udpAddr.get_port();
  2225.   addrStr = udpAddr.IpAddress::get_printable();
  2226.   break;
  2227.         }
  2228.       case type_ipxsock:
  2229. {
  2230.   IpxSockAddress ipxsockAddr(address);
  2231.   port = ipxsockAddr.get_socket();
  2232.   addrStr = ipxsockAddr.IpxAddress::get_printable();
  2233.   break;
  2234.         }
  2235.       default:
  2236. // Otherwise we will be sending to the default.
  2237.         addrStr = address.get_printable();
  2238. break;
  2239.     }
  2241.     hDstEntity = SnmpStrToEntity( (HSNMP_SESSION) iv_snmp_session, addrStr);
  2242.     if ( hDstEntity == SNMPAPI_FAILURE) {
  2243. Wstatus = SnmpGetLastError( (HSNMP_SESSION) iv_snmp_session);
  2244. SNMPDEBUG("-- SNMP++, Fail Maiking Dest Entityn");
  2246. if (SNMPAPI_ENTITY_UNKNOWN == Wstatus) {
  2247.     return SNMP_CLASS_TL_UNSUPPORTED;
  2248. } else if (SNMPAPI_ALLOC_ERROR == Wstatus) {
  2249.     return SNMP_CLASS_RESOURCE_UNAVAIL;
  2250. } else {
  2251.     return SNMP_CLASS_INTERNAL_ERROR;
  2252. }
  2253.     }
  2255.    if (port != 0xffff) {
  2256. HMODULE hModule;
  2257. functionPortSet portbuilder;
  2258. hModule = GetModuleHandle("WSNMP32");
  2259. portbuilder = (functionPortSet) GetProcAddress( hModule,"SnmpSetPort");
  2260. if ( portbuilder != NULL) {
  2261.    Wstatus = (portbuilder)(hDstEntity, port);
  2262.    if ( Wstatus != SNMPAPI_SUCCESS) {
  2263.        SNMPDEBUG("-- SNMP++, Failure Setting Dest Entity Portn");
  2264.        SnmpFreeEntity ( hDstEntity);
  2266.        return  SNMP_CLASS_INVALID_ADDRESS;  // cannot set alt port
  2267.    }
  2268. }
  2269.     }
  2271.     hSrcEntity = SnmpStrToEntity( (HSNMP_SESSION) iv_snmp_session,  addrStr);
  2272.     if ( hSrcEntity == SNMPAPI_FAILURE) {
  2273. SNMPDEBUG("-- SNMP++, Fail Making Source Entityn");
  2274. SnmpFreeEntity ( hDstEntity);
  2276. if (SNMPAPI_ENTITY_UNKNOWN == Wstatus) {
  2277.     return SNMP_CLASS_TL_UNSUPPORTED;
  2278. } else if (SNMPAPI_ALLOC_ERROR == Wstatus) {
  2279.     return SNMP_CLASS_RESOURCE_UNAVAIL;
  2280. } else {
  2281.     return SNMP_CLASS_INTERNAL_ERROR;
  2282. }
  2283.     }
  2285.     if (action != sNMP_PDU_TRAP ) {
  2287. // set the retransmit mode on
  2288. Wstatus = SnmpSetRetransmitMode( SNMPAPI_ON);
  2290. if ( Wstatus != SNMPAPI_SUCCESS) {
  2291.     Wstatus = SnmpGetLastError( (HSNMP_SESSION) iv_snmp_session);
  2292.     SNMPDEBUG("-- SNMP++, Fail setting RETRANSMIT_MODE=ONn");
  2294.     SnmpFreeEntity ( hDstEntity);
  2295.     SnmpFreeEntity ( hSrcEntity);
  2297.     if (SNMPAPI_ALLOC_ERROR == Wstatus) {
  2298. return SNMP_CLASS_RESOURCE_UNAVAIL;
  2299.     } else {
  2300. return SNMP_CLASS_INTERNAL_ERROR;
  2301.     }
  2302. }
  2304. // set the timeout
  2305. Wstatus = SnmpSetTimeout( hDstEntity, (SmiTIMETICKS) my_timeout);
  2306. if ( Wstatus != SNMPAPI_SUCCESS) {
  2307.     Wstatus = SnmpGetLastError( (HSNMP_SESSION) iv_snmp_session);
  2308.     SNMPDEBUG("-- SNMP++, Fail setting timeout n");
  2310.     SnmpFreeEntity ( hDstEntity);
  2311.     SnmpFreeEntity ( hSrcEntity);
  2313.     if (SNMPAPI_ALLOC_ERROR == Wstatus) {
  2314. return SNMP_CLASS_RESOURCE_UNAVAIL;
  2315.     } else {
  2316. return SNMP_CLASS_INTERNAL_ERROR;
  2317.     }
  2318. }
  2320. // set the retry
  2321. Wstatus = SnmpSetRetry( hDstEntity, (SmiUINT32) my_retry);
  2322. if ( Wstatus != SNMPAPI_SUCCESS) {
  2323.     Wstatus = SnmpGetLastError( (HSNMP_SESSION) iv_snmp_session);
  2324.     SNMPDEBUG("-- SNMP++, Fail setting retry n");
  2326.     SnmpFreeEntity ( hDstEntity);
  2327.     SnmpFreeEntity ( hSrcEntity);
  2329.     if (SNMPAPI_ALLOC_ERROR == Wstatus) {
  2330. return SNMP_CLASS_RESOURCE_UNAVAIL;
  2331.     } else {
  2332. return SNMP_CLASS_INTERNAL_ERROR;
  2333.     }
  2334. }
  2335.     }
  2337.     //------[ build the context ]--------------------------------------
  2338.     // v1 context is the community name in WinSnmp
  2339.     // use the commnuty from the Target ovject
  2340.     // depending on the action use either the get or set
  2341.     // community name
  2342.     //
  2343.     if ( action == sNMP_PDU_SET) {
  2344. my_community_name.ptr = (unsigned char *) my_set_community.data();
  2345. my_community_name.len = my_set_community.len();
  2346.     } else {
  2347. my_community_name.ptr = (unsigned char *) my_get_community.data();
  2348. my_community_name.len = my_get_community.len();
  2349.     }
  2351.     hSendContext = SnmpStrToContext( (HSNMP_SESSION) iv_snmp_session,(smiLPOCTETS)&my_community_name);
  2352.     if ( hSendContext == SNMPAPI_FAILURE) {
  2353. Wstatus = SnmpGetLastError( (HSNMP_SESSION) iv_snmp_session);
  2354. SNMPDEBUG("-- SNMP++, FailMaiking Contextn");
  2356. SnmpFreeEntity ( hDstEntity);
  2357. SnmpFreeEntity ( hSrcEntity);
  2359. if (SNMPAPI_ALLOC_ERROR == Wstatus) {
  2360.     return SNMP_CLASS_RESOURCE_UNAVAIL; 
  2361. } else {
  2362.     return SNMP_CLASS_INTERNAL_ERROR; 
  2363. }
  2364.     }
  2366.     //-------[ make a WinSNMP vbl without the oid ]---------------------
  2367.     hvbl = SnmpCreateVbl( (HSNMP_SESSION) iv_snmp_session, NULL, NULL);
  2368.     if ( hvbl == SNMPAPI_FAILURE) {
  2369. Wstatus = SnmpGetLastError( (HSNMP_SESSION) iv_snmp_session);
  2370. SNMPDEBUG("-- SNMP++, Fail Making Vbln");
  2372. SnmpFreeEntity ( hDstEntity);
  2373. SnmpFreeEntity ( hSrcEntity);
  2374. SnmpFreeContext( hSendContext);
  2376. if (SNMPAPI_ALLOC_ERROR == Wstatus) {
  2377.     return SNMP_CLASS_RESOURCE_UNAVAIL; 
  2378. } else {
  2379.     return SNMP_CLASS_INTERNAL_ERROR; 
  2380. }
  2381.     }
  2383.     //-------[ load WinSNMP varbind list using Snmp++ Vbs ]----------
  2384.     return_status = load_varbindlist( (HSNMP_SESSION) iv_snmp_session, hvbl, pdu);
  2385.     if ( return_status != SNMP_CLASS_SUCCESS) {
  2386. SnmpFreeEntity ( hDstEntity);
  2387. SnmpFreeEntity ( hSrcEntity);
  2388. SnmpFreeContext( hSendContext);
  2389. SnmpFreeVbl( hvbl);
  2390. SNMPDEBUG("-- SNMP++, Fail Loading Vbln");
  2391. return return_status;
  2392.     }
  2394.     //-----[ make the WinSNMP pdu ]---------------------------------------
  2395.     hSendPdu = SnmpCreatePdu( (HSNMP_SESSION) iv_snmp_session,  // for this session
  2396.                              (smiINT) action,   // defined action
  2397.                              request_id,        // request id
  2398.                              (action == sNMP_PDU_GETBULK) ? (smiINT) non_reps : NULL, // non repeaters
  2399.                              (action == sNMP_PDU_GETBULK) ? (smiINT) max_reps :NULL,  // max repetitions
  2400.                              pdu.get_vb_count() ? hvbl : NULL ); // vbl to send
  2401.  
  2402.     if ( hSendPdu == SNMPAPI_FAILURE) {
  2403. Wstatus = SnmpGetLastError( (HSNMP_SESSION) iv_snmp_session);
  2404. SNMPDEBUG("-- SNMP++, Failure Making Pdun");
  2406. SnmpFreeVbl( hvbl);
  2407. SnmpFreeEntity ( hDstEntity);
  2408. SnmpFreeEntity ( hSrcEntity);
  2409. SnmpFreeContext( hSendContext);
  2411. if (SNMPAPI_ALLOC_ERROR == Wstatus) {
  2412.     return SNMP_CLASS_RESOURCE_UNAVAIL; 
  2413. } else {
  2414.     return SNMP_CLASS_INTERNAL_ERROR; 
  2415. }
  2416.     }
  2418.     
  2419.     //-------[ Send out the PDU ]------------------------------------------
  2420.     SNMPDEBUG("++ SNMP++, Send PDU n");
  2421.     Wstatus = SnmpSendMsg( 
  2422.   (HSNMP_SESSION) iv_snmp_session,  // handle to session
  2423.   hSrcEntity,       // handle to source destination
  2424.   hDstEntity,       // handle to destination entity
  2425.   hSendContext,     // handle to context
  2426.   hSendPdu );       // the pdu to send
  2427.   
  2428.     //-----[ free everything up ]---------------------------------------
  2430.     SnmpFreePdu( hSendPdu);
  2431.     SnmpFreeVbl( hvbl);
  2432.     SnmpFreeEntity ( hDstEntity);
  2433.     SnmpFreeEntity ( hSrcEntity);
  2434.     SnmpFreeContext( hSendContext);
  2435.      
  2436.     if (Wstatus == SNMPAPI_FAILURE) {
  2437. Wstatus = SnmpGetLastError( (HSNMP_SESSION) iv_snmp_session);
  2439. SNMPDEBUG("-- SNMP++, Failure Sending Pdun");
  2441. if (SNMPAPI_ALLOC_ERROR == Wstatus) {
  2442.     return SNMP_CLASS_RESOURCE_UNAVAIL;
  2443. } else if (SNMPAPI_TL_NOT_SUPPORTED == Wstatus) {
  2444.     return SNMP_CLASS_TL_UNSUPPORTED;
  2445. } else if (SNMPAPI_OPERATION_INVALID == Wstatus) {
  2446.     return SNMP_CLASS_INVALID_OPERATION;
  2447. } else if (SNMPAPI_OTHER_ERROR == Wstatus) {
  2448.     return SNMP_CLASS_ERROR;
  2449. } else if (SNMPAPI_SESSION_INVALID == Wstatus ||
  2450.    SNMPAPI_ENTITY_INVALID == Wstatus ||
  2451.    SNMPAPI_CONTEXT_INVALID == Wstatus ||
  2452.    SNMPAPI_PDU_INVALID == Wstatus ||
  2453.    SNMPAPI_NOT_INITIALIZED == Wstatus) {
  2454.     return SNMP_CLASS_INTERNAL_ERROR;
  2455. } else {
  2456.     // The rest of the Wstatus codes are pathalogical
  2457.             // transport layer failures
  2458.     return SNMP_CLASS_TL_FAILED;
  2459. }
  2460.     } else {
  2461. return SNMP_CLASS_SUCCESS;
  2462.     }
  2463. }