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

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

SNMP编程

开发平台：

Visual C++

snmpmsg.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. 
  18.   SNMP++ S N M P M E S S A G E . C P P   
  19.       
  20.   SNMPMESSAGE CLASS DEFINITION
  21.        
  22.   VERSION:
  23.   2.8
  24.   
  25.   RCS INFO:
  26.   $Header: Exp $
  27.        
  28.   DESIGN:
  29.   Peter E Mellquist
  30.                 
  31.   AUTHOR:      
  32.   Peter E Mellquist
  33.               
  34.   LANGUAGE:
  35.   ANSI C++ 
  36.       
  37.   OPERATING SYSTEMS:
  38.   Win 32
  39.   BSD UNIX
  40.       
  41.   DESCRIPTION:
  42.   ASN.1 encoding / decoding class
  43.         
  44. =====================================================================*/ 
  46. #include "snmpmsg.h"                 // header file for SnmpMessage
  47. #include "asn1.h"                       // ASN.1 header file
  48. #include "stdio.h"                      // standard io file 
  52. //--------------[ well known trap ids ]-----------------------------------
  53. // SMI trap oid def
  54. class snmpTrapsOid: public Oid {
  55.    public: 
  56.    snmpTrapsOid (void):Oid("1.3.6.1.6.3.1.1.5"){};
  57. }; 
  59. // SMI Enterprise Oid
  60. class snmpTrapEnterpriseOid: public Oid {
  61.    public: 
  62.    snmpTrapEnterpriseOid(void):Oid("1.3.6.1.6.3.1.1.4.3.0"){};
  63. }; 
  65. // SMI Cold Start Oid
  66. class coldStartOid: public snmpTrapsOid {
  67.    public: 
  68.    coldStartOid( void){*this+=".1";};
  69. };
  71. // SMI WarmStart Oid
  72. class warmStartOid: public snmpTrapsOid {
  73.    public: 
  74.    warmStartOid( void){*this+=".2";};
  75. };
  77. // SMI LinkDown Oid
  78. class linkDownOid: public snmpTrapsOid {
  79.    public: 
  80.    linkDownOid( void){*this+=".3";};
  81. }; 
  84. // SMI LinkUp Oid
  85. class linkUpOid: public snmpTrapsOid {
  86.    public: 
  87.    linkUpOid( void){*this+=".4";};
  88. };
  90. // SMI Authentication Failure Oid
  91. class authenticationFailureOid: public snmpTrapsOid {
  92.    public: 
  93.    authenticationFailureOid( void){*this+=".5";};
  94. }; 
  96. // SMI egpneighborloss Oid
  97. class egpNeighborLossOid: public snmpTrapsOid {
  98.    public: 
  99.    egpNeighborLossOid( void){*this+=".6";};
  100. };
  102. const coldStartOid coldStart;
  103. const warmStartOid warmStart;
  104. const linkDownOid linkDown;
  105. const linkUpOid linkUp;
  106. const authenticationFailureOid authenticationFailure;
  107. const egpNeighborLossOid egpNeighborLoss;
  108. const snmpTrapEnterpriseOid snmpTrapEnterprise;
  110. //------------[ convert SNMP++ VB to WinSNMP smiVALUE ]----------------
  111. int convertVbToSmival( Vb &tempvb, SmiVALUE *smival )
  112. {
  113.    smival->syntax = tempvb.get_syntax();
  114.    switch ( smival->syntax ) {
  116.   // case sNMP_SYNTAX_NULL
  117.   case sNMP_SYNTAX_NULL:
  118.       break;
  120.   // case sNMP_SYNTAX_INT32:
  121.       case sNMP_SYNTAX_INT:
  122.   tempvb.get_value(smival->value.sNumber);
  123.   break;
  125.       //    case sNMP_SYNTAX_UINT32:
  126.       case sNMP_SYNTAX_GAUGE32:
  127.       case sNMP_SYNTAX_CNTR32:
  128.       case sNMP_SYNTAX_TIMETICKS:
  129.   case sNMP_SYNTAX_UINT32:
  130.   tempvb.get_value(smival->value.uNumber);
  131.   break;
  133.   // case Counter64
  134.       case sNMP_SYNTAX_CNTR64:
  135.       {
  136.      Counter64 c64;
  137.      tempvb.get_value(c64);
  138.      smival->value.hNumber.hipart = c64.high();
  139.      smival->value.hNumber.lopart = c64.low();
  140.   }
  141.   break;
  143.       case sNMP_SYNTAX_BITS:
  144.       case sNMP_SYNTAX_OCTETS:
  145.       case sNMP_SYNTAX_IPADDR:
  146.       {
  147.      OctetStr os;
  148.      tempvb.get_value(os);
  149.      smival->value.string.ptr = NULL;
  150.      smival->value.string.len = os.len();
  151.      if ( smival->value.string.len > 0 ) 
  152.  {
  153. smival->value.string.ptr = (SmiLPBYTE) new  unsigned char [smival->value.string.len];
  154.         if ( smival->value.string.ptr ) 
  155.     {
  156.                for (int i=0; i<(int) smival->value.string.len ; i++)
  157.           smival->value.string.ptr[i] = os[i];
  158.         } 
  159.     else 
  160.     { 
  161.            smival->syntax = sNMP_SYNTAX_NULL;  // invalidate the smival
  162.            return SNMP_CLASS_RESOURCE_UNAVAIL;
  163.         }
  164.      }
  165.       }
  166.       break;
  168.       case sNMP_SYNTAX_OID:
  169.   {
  170.      Oid oid;
  171.      tempvb.get_value(oid);
  172.      smival->value.oid.ptr = NULL;
  173.      smival->value.oid.len = oid.len();
  174.      if ( smival->value.oid.len > 0 ) 
  175.  {
  176. smival->value.oid.ptr = (SmiLPUINT32) new unsigned long [ smival->value.oid.len];
  177.         if ( smival->value.oid.ptr ) 
  178. {
  179.                for (int i=0; i<(int)smival->value.oid.len ; i++)
  180.           smival->value.oid.ptr[i] = oid[i];
  181.         } 
  182. else 
  183. {
  184.             smival->syntax = sNMP_SYNTAX_NULL;  // invalidate the smival
  185.             return SNMP_CLASS_RESOURCE_UNAVAIL;
  186.         }
  187.     }
  188.   }
  189.   break;
  191.       default:
  192.         return SNMP_CLASS_INTERNAL_ERROR;
  193.    }
  194.    return SNMP_CLASS_SUCCESS;
  195. };
  197. // free a SMI value
  198. void freeSmivalDescriptor( SmiVALUE *smival )
  199. {
  200.    switch ( smival->syntax ) {
  201.      case sNMP_SYNTAX_OCTETS:
  202.      case sNMP_SYNTAX_OPAQUE:
  203.      case sNMP_SYNTAX_IPADDR:
  204.      case sNMP_SYNTAX_BITS:     // obsoleted in SNMPv2 Draft Std
  205.           delete [] smival->value.string.ptr;    
  206.        break;
  208.      case sNMP_SYNTAX_OID:
  209.   delete [] smival->value.oid.ptr;
  210.        break;
  211.    }
  212.    smival->syntax = sNMP_SYNTAX_NULL;
  213. };
  216. // load up a SnmpMessage
  217. int SnmpMessage::load( Pdu pdu,                      // Pdu object to load
  218.    OctetStr community,           // community to use
  219.    snmp_version version)         // version 1 or 2
  220. {
  221. int status;
  223. bufflen = SNMP_MSG_LENGTH;
  224.     valid_flag = FALSE;
  226. // create a raw pdu
  227. snmp_pdu *raw_pdu;
  228. raw_pdu = snmp_pdu_create( (int) pdu.get_type());
  230. Oid enterprise;
  232. // make sure pdu is valid
  233. if ( !pdu.valid()) 
  234. SNMP_CLASS_INVALID_PDU;
  236. // load it up
  237. raw_pdu->reqid = pdu.get_request_id();
  238. raw_pdu->errstat= (unsigned long) pdu.get_error_status();
  239. raw_pdu->errindex= (unsigned long) pdu.get_error_index();
  241. // if its a V1 trap then load up other values
  242. // for v2, use normal pdu format
  243. if ( raw_pdu->command == sNMP_PDU_V1TRAP)
  244. {         
  245.        char addrString[256];
  246.        if (gethostname(addrString, 255) == 0) {
  247.           int status = 0;
  248.           IpAddress my_address;
  249.           hostent *lookupResult;
  250.           char    *namePtr = NULL;
  251.           in_addr ipAddr;
  252.             
  253.           if ((ipAddr.s_addr = inet_addr(addrString)) == -1){
  254.              lookupResult = gethostbyname(addrString);
  255.              if (lookupResult) {
  256.                 if (lookupResult->h_length == sizeof(in_addr)){
  257.                    memcpy((void *) &ipAddr, (void *) lookupResult->h_addr_list[0],sizeof(in_addr));
  258.                    my_address = inet_ntoa(ipAddr);
  259.                 }
  260.              }
  261.           } 
  262.           else
  263.              my_address = addrString;
  265.           struct sockaddr_in agent_addr;  // agent address socket struct
  267.           // prepare the agent address
  268.           memset(&agent_addr, 0, sizeof(agent_addr));
  269.           agent_addr.sin_family = AF_INET;
  270.           agent_addr.sin_addr.s_addr = inet_addr(((IpAddress&)my_address).IpAddress::get_printable());
  271.           raw_pdu->agent_addr = agent_addr;
  272.        }
  274.    //-----[ compute generic trap value ]-------------------------------
  275.        // determine the generic value
  276.        // 0 - cold start
  277.        // 1 - warm start
  278.        // 2 - link down
  279.        // 3 - link up
  280.        // 4 - authentication failure
  281.        // 5 - egpneighborloss
  282.        // 6 - enterprise specific
  283.    Oid trapid;
  284.    pdu.get_notify_id( trapid);
  285.    if ( !trapid.valid() || trapid.len() < 2 ) 
  286.    {
  287.          snmp_free_pdu( raw_pdu);
  288.        return SNMP_CLASS_INVALID_NOTIFYID;
  289.        }
  290.    raw_pdu->specific_type=0;
  291.        if ( trapid == coldStart)
  292.           raw_pdu->trap_type = 0;  // cold start
  293.        else if ( trapid == warmStart)
  294.           raw_pdu->trap_type = 1;  // warm start
  295.        else if( trapid == linkDown)
  296.           raw_pdu->trap_type = 2;  // link down
  297.        else if ( trapid == linkUp)
  298.           raw_pdu->trap_type = 3;  // link up
  299.        else if ( trapid == authenticationFailure )
  300.           raw_pdu->trap_type = 4;  // authentication failure
  301.        else if ( trapid == egpNeighborLoss)
  302.           raw_pdu->trap_type = 5;  // egp neighbor loss
  303.        else {
  304.       raw_pdu->trap_type = 6;     // enterprise specific
  305.                                   // last oid subid is the specific value
  306.                                   // if 2nd to last subid is "0", remove it 
  307.                           // enterprise is always the notify oid prefix
  308.       raw_pdu->specific_type = (int) trapid[(int) (trapid.len()-1)]; 
  309.           trapid.trim(1);
  310.       if ( trapid[(int)(trapid.len()-1)] == 0 )
  311.       trapid.trim(1);
  312.           enterprise = trapid;      
  313.        }
  315.    if ( raw_pdu->trap_type !=6)
  316.       pdu.get_notify_enterprise( enterprise);
  317.    if ( enterprise.len() >0) {
  318.    // note!!
  319.    // these are hooks into an SNMP++ oid
  320.    // and therefor the raw_pdu enterprise
  321.    // should not free them. null them out!!
  322.    SmiLPOID rawOid;
  323.    rawOid = enterprise.oidval();
  324.    raw_pdu->enterprise = rawOid->ptr;
  325.    raw_pdu->enterprise_length = (int) rawOid->len;
  326.    }
  328.    // timestamp
  329.    TimeTicks timestamp;
  330.    pdu.get_notify_timestamp( timestamp);
  331.    raw_pdu->time = ( unsigned long) timestamp;
  332.    
  333. }
  335. // if its a v2 trap then we need to make a few adjustments
  336. // vb #1 is the timestamp
  337. // vb #2 is the id, represented as an Oid
  338. if ( raw_pdu->command == sNMP_PDU_TRAP)
  339. {
  340. Pdu temppdu;
  341. Vb tempvb;
  343. // vb #1 is the timestamp
  344. TimeTicks timestamp;
  345. tempvb.set_oid("1.3.6.1.2.1.1.3.0");   // sysuptime
  346. pdu.get_notify_timestamp( timestamp);
  347. tempvb.set_value ( timestamp);
  348. temppdu += tempvb;                 
  350. // vb #2 is the id
  351. Oid trapid;
  352. tempvb.set_oid("1.3.6.1.6.3.1.1.5");
  353. pdu.get_notify_id( trapid);
  354. tempvb.set_value( trapid);
  355. temppdu += tempvb;
  357. // append the remaining vbs
  358. for ( int z=0;z<pdu.get_vb_count();z++) {
  359. pdu.get_vb( tempvb,z);
  360. temppdu += tempvb;
  361. }
  363.         pdu = temppdu;          // reassign the pdu to the temp one
  364. }
  365. // load up the payload
  366. // for all Vbs in list, add them to the pdu
  367. int vb_count;
  368. Vb tempvb;
  369. Oid tempoid;
  370. SmiLPOID smioid;
  371. SmiVALUE smival;
  373. vb_count = pdu.get_vb_count();
  374. for (int z=0;z<vb_count;z++) {
  375. pdu.get_vb( tempvb,z);
  376. tempvb.get_oid( tempoid);
  377. smioid = tempoid.oidval();
  378. // clear the value portion, in case its
  379. // not already been done so by the app
  380. // writer
  381. // only do it in the case its a get,next or bulk
  382. if ((raw_pdu->command == sNMP_PDU_GET) ||
  383. (raw_pdu->command == sNMP_PDU_GETNEXT) ||
  384.             (raw_pdu->command == sNMP_PDU_GETBULK))
  385. tempvb.set_null();
  386. status = convertVbToSmival( tempvb, 
  387.                         &smival );
  388. if ( status != SNMP_CLASS_SUCCESS)
  389. return status;
  391. // add the vb to the raw pdu
  392.     snmp_add_var( raw_pdu, 
  393.           smioid->ptr, 
  394.           (int) smioid->len,
  395.           &smival);
  397. freeSmivalDescriptor( &smival);
  399. }
  401. // ASN1 encode the pdu
  402. status = snmp_build( raw_pdu,
  403.                      databuff,
  404.  (int *) &bufflen,
  405.  version,
  406.  community.data(),
  407.  (int) community.len());
  410. if ( status != 0) {
  411. valid_flag = FALSE;
  412. return SNMP_ERROR_WRONG_ENCODING;
  413. }
  414. valid_flag = TRUE;
  416. // prevention of SNMP++ Enterprise Oid death
  417. if ( enterprise.len() >0) {
  418. raw_pdu->enterprise = 0;
  419. raw_pdu->enterprise_length=0;
  420. }
  422. snmp_free_pdu( raw_pdu);
  424. return SNMP_CLASS_SUCCESS;
  425. };
  427. // load up a SnmpMessage
  428. int SnmpMessage::load( unsigned char *data, 
  429.    unsigned long len)
  430. {
  431.    bufflen = SNMP_MSG_LENGTH;
  432.    valid_flag = FALSE;
  434.    if ( len <= SNMP_MSG_LENGTH) {
  435.    memcpy( (unsigned char *) databuff,
  436.        (unsigned char *) data,
  437.    (unsigned int) len);
  438.    bufflen = len;
  439.    valid_flag = TRUE;
  440.    }
  441.    else
  442.    return SNMP_ERROR_WRONG_LENGTH;
  444.    return SNMP_CLASS_SUCCESS;
  445. };
  448. // unload the data into SNMP++ objects
  449. int SnmpMessage::unload( Pdu &pdu,                 // Pdu object
  450.  OctetStr &community,      // community object
  451.  snmp_version &version)    // SNMP version #
  452. {
  453.    unsigned char community_name[255];
  454.    unsigned long community_len;
  456.    Pdu tmppdu;
  458.    pdu = tmppdu;
  460.    if ( !valid_flag)
  461.    return SNMP_CLASS_INVALID;
  463.    snmp_pdu *raw_pdu;
  464.    raw_pdu = snmp_pdu_create(0);
  466.    int status = snmp_parse( raw_pdu,
  467.                             databuff,
  468. community_name,
  469. community_len,
  470. version,
  471.                             (int) bufflen);
  472.    
  473.    if ( status != 0) 
  474.    return SNMP_CLASS_INTERNAL_ERROR;
  476.    
  477.    // load up the SNMP++ variables
  478.    community.set_data( community_name,
  479.                community_len);
  480.    set_request_id( &pdu,raw_pdu->reqid);
  481.    set_error_status( &pdu,(int) raw_pdu->errstat);
  482.    set_error_index( &pdu,(int) raw_pdu->errindex);
  483.    pdu.set_type( raw_pdu->command);
  485.    // deal with trap parameters
  486.    TimeTicks timestamp;
  487.    timestamp = raw_pdu->time;
  488.    pdu.set_notify_timestamp( timestamp);
  490.    // vbs
  491.    Vb tempvb;
  492.    Oid tempoid;
  493.    struct   variable_list *vp;
  494.    for(vp = raw_pdu->variables; vp; vp = vp->next_variable) {
  496.  // extract the oid portion
  497.  tempoid.set_data( (unsigned long *)vp->name,
  498.                        ( unsigned int) vp->name_length);
  499.  tempvb.set_oid( tempoid);
  501.  // extract the value portion
  502.  switch(vp->type){
  504.  // octet string
  505.  case sNMP_SYNTAX_OCTETS:
  506.      case sNMP_SYNTAX_OPAQUE:
  507.  {
  508.     OctetStr octets( (unsigned char *) vp->val.string,
  509.                          (unsigned long) vp->val_len);
  510.     tempvb.set_value( octets);
  511.  }
  512.  break;
  514.  // object id
  515.  case sNMP_SYNTAX_OID:
  516.  {
  517.     Oid oid( (unsigned long*) vp->val.objid,
  518.      (int) vp->val_len);
  519. tempvb.set_value( oid);
  520.  }
  521.      break;
  523.  // timeticks
  524.  case sNMP_SYNTAX_TIMETICKS:
  525.  {
  526.  TimeTicks timeticks( (unsigned long) *(vp->val.integer));
  527.  tempvb.set_value( timeticks);
  528.  }
  529.  break;
  531.  // 32 bit counter
  532.  case sNMP_SYNTAX_CNTR32:
  533.  {
  534.      Counter32 counter32( (unsigned long) *(vp->val.integer));
  535.  tempvb.set_value( counter32);
  536.  }
  537.  break;
  539.  // 32 bit gauge
  540.  case sNMP_SYNTAX_GAUGE32:
  541.  {
  542.      Gauge32 gauge32( (unsigned long) *(vp->val.integer));
  543.  tempvb.set_value( gauge32);
  544.  }
  545.  break;
  547.  // ip address
  548.  case sNMP_SYNTAX_IPADDR:
  549.  {
  550.  char buffer[20];
  551.  sprintf( buffer,"%d.%d.%d.%d",
  552.       vp->val.string[0],
  553.   vp->val.string[1],
  554.   vp->val.string[2],
  555.   vp->val.string[3]);
  556.      IpAddress ipaddress( buffer);
  557.  tempvb.set_value( ipaddress);
  558.  }
  559.  break;
  561.  // 32 bit integer
  562.  case sNMP_SYNTAX_INT:
  563.  {
  564.     SnmpInt32 int32( (long) *(vp->val.integer));
  565. tempvb.set_value( int32);
  566.  }
  567.  break;
  569.  // 32 bit unsigned integer
  570.  case sNMP_SYNTAX_UINT32:
  571.  {
  572. SnmpUInt32 uint32( (unsigned long) *(vp->val.integer));
  573. tempvb.set_value( uint32);
  574.  }
  575.      break;
  577.  // v2 counter 64's
  578.  case sNMP_SYNTAX_CNTR64:
  579.      break;
  581.    case sNMP_SYNTAX_NULL:
  582.    tempvb.set_null();
  583.  break;
  585.  // v2 vb exceptions
  586.  case sNMP_SYNTAX_NOSUCHOBJECT:
  587.  case sNMP_SYNTAX_NOSUCHINSTANCE:
  588.  case sNMP_SYNTAX_ENDOFMIBVIEW:
  589.  set_exception_status( &tempvb, vp->type);
  590.      break;
  592.  default:
  593.  tempvb.set_null();
  595.     } // end switch
  597.  // append the vb to the pdu
  598.  pdu += tempvb;
  599.    }
  600.    
  601.    snmp_free_pdu( raw_pdu);
  603.    return SNMP_CLASS_SUCCESS;
  604. };