vb.cpp
上传用户:czjinwang
上传日期:2007-01-12
资源大小:2484k
文件大小:11k
源码类别:

SNMP编程

开发平台:

Visual C++

  1. /*===================================================================
  2.   Copyright (c) 1999
  3.   Hewlett-Packard Company
  4.   ATTENTION: USE OF THIS SOFTWARE IS SUBJECT TO THE FOLLOWING TERMS.
  5.   Permission to use, copy, modify, distribute and/or sell this software 
  6.   and/or its documentation is hereby granted without fee. User agrees 
  7.   to display the above copyright notice and this license notice in all 
  8.   copies of the software and any documentation of the software. User 
  9.   agrees to assume all liability for the use of the software; Hewlett-Packard 
  10.   makes no representations about the suitability of this software for any 
  11.   purpose. It is provided "AS-IS without warranty of any kind,either express 
  12.   or implied. User hereby grants a royalty-free license to any and all 
  13.   derivatives based upon this software code base. 
  14.   V B . C P P
  15.   VARIABLE BINDING CLASS IMPLEMENTATION
  16.   DESCRIPTION:
  17.   This module contains the class implementation of the VB class.
  18.   The Vb class is an encapsulation of the snmp variable binding.
  19.   DESIGN:
  20.   Peter E Mellquist
  21.   AUTHOR:
  22.   Peter E Mellquist
  23.   LANGAUGE:
  24.   ANSI C++
  25.   OPERATING SYSTEMS:
  26.   MS-Windows Win32
  27.   BSD UNIX
  28. =====================================================================*/
  29. char vb_cpp_version[]="#(@) SNMP++ 2.8 $Header: vb.cpp,v 1.19 96/09/11 14:02:18 hmgr Exp $";
  30. #include "oid.h"        // include oid class defs
  31. #include "vb.h"        // include vb class defs
  32. #include "snmperrs.h"      // error codes
  33. #define IP_ADDR_SIZE  4
  34. #define IPX_ADDR_SIZE 10
  35. #define MAC_ADDR_SIZE 6
  36. //---------------[ Vb::Vb( void) ]--------------------------------------
  37. // constructor with no arguments
  38. // makes an vb, unitialized
  39. Vb::Vb( void)
  40.   { iv_vb_value = NULL;
  41.     exception_status = SNMP_CLASS_SUCCESS; };
  42. //---------------[ Vb::Vb( const Oid &oid) ]-----------------------------
  43. // constructor to initialize the oid
  44. // makes a vb with oid portion initialized
  45. Vb::Vb( const Oid &oid)
  46. { iv_vb_oid = oid;
  47.   iv_vb_value = NULL;
  48.   exception_status = SNMP_CLASS_SUCCESS;  };
  49. //---------------[ Vb::Vb( const Vb &vb) ]-----------------------------
  50. // copy constructor
  51. Vb::Vb( const Vb &vb)
  52. {  iv_vb_value = NULL;
  53.    *this = vb; 
  54. };
  55. //--------------[ Vb::valid() ]-----------------------------------------
  56. // returns validity of a Vb object
  57. // must have a valid oid and value
  58. int Vb::valid() const
  59. {
  60. #ifdef WHEN_WE_HAVE_SNMPNULL_CLASS
  61.    if ( iv_vb_oid.valid() && iv_vb_value && iv_vb_value->valid() )
  62. #else  // WHEN_WE_HAVE_SNMPNULL_CLASS
  63.    if ( iv_vb_oid.valid() && 
  64. ((iv_vb_value == NULL) || (iv_vb_value && iv_vb_value->valid())) )
  65. #endif // WHEN_WE_HAVE_SNMPNULL_CLASS
  66.      return TRUE;
  67.    else
  68.      return FALSE;
  69. }
  70. //---------------[ Vb::~Vb() ]------------------------------------------
  71. // destructor
  72. // if the vb has a oid or an octect string then
  73. // the associated memory needs to be freed
  74. Vb::~Vb()
  75. { free_vb(); };
  76. //---------------[ Vb& Vb::operator=( const Vb &vb) ]--------------------
  77. // overloaded assignment allows assigning one Vb to another
  78. // this involves deep memory thus target vb needs to be freed
  79. // before assigning source
  80. Vb& Vb::operator=( const Vb &vb)
  81. {
  82.    free_vb();  // free up target to begin with
  83.    //-----[ reassign the Oid portion 1st ]
  84.    vb.get_oid( iv_vb_oid);
  85.    //-----[ next set the vb value portion ]
  86.    if (vb.iv_vb_value == NULL){
  87.      iv_vb_value = NULL;
  88.    }
  89.    else{
  90.      iv_vb_value = vb.iv_vb_value->clone();
  91.    }
  92.    exception_status = vb.exception_status;
  93.    return *this; // return self reference
  94. };
  95. //---------------[ Vb::set_oid( const Oid oid ) ]-----------------------
  96. // set value oid only with another oid
  97. void Vb::set_oid( const Oid oid)
  98. { iv_vb_oid = oid;};
  99. //---------------[ Vb::get_oid( Oid &oid) ]-----------------------------
  100. // get oid portion
  101. void Vb::get_oid( Oid &oid) const
  102. { oid = iv_vb_oid;};
  103. //----------------[ void Vb::free_vb() ]--------------------------------
  104. // protected method to free memory
  105. // this methos is used to free memory when assigning new vbs
  106. // or destructing
  107. // in the case of oids and octets, we need to do a deep free
  108. void Vb::free_vb()
  109. {
  110.   if (iv_vb_value)
  111.     delete iv_vb_value;
  112.   exception_status = SNMP_CLASS_SUCCESS;
  113.   iv_vb_value = NULL;
  114. };
  115. //---------------[ Vb::set_value( int i) ]-------------------------------
  116. // set the value with an int
  117. // C++ int maps to SMI int
  118. void Vb::set_value( const int i)
  119. {
  120.   free_vb();
  121.   iv_vb_value = new SnmpInt32(i);
  122. };
  123. //----------------[ Vb::set_value( long int i) ]--------------------------
  124. // set the value with a long signed int
  125. // C++ long int maps to SMI int 32
  126. void Vb::set_value( const long int i)
  127. {
  128.   free_vb();
  129.   iv_vb_value = new SnmpInt32(i);
  130. };
  131.  // set a Vb null, if its not already
  132.  void Vb::set_null()
  133.  {
  134.     free_vb();
  135.  };
  136. //-----------------[ Vb::set_value( unsigned long int i) ]------------------
  137. // set the value with an unsigned long int
  138. // C++ unsigned long int maps to SMI UINT32
  139. void Vb::set_value( const unsigned long int i)
  140. {
  141.   free_vb();
  142.   iv_vb_value = new SnmpUInt32(i);
  143. };
  144. //------------[Vb::set_value ( general value) ]----------------------------
  145. void Vb::set_value ( const SnmpSyntax &val)
  146. {
  147.   free_vb();
  148.   iv_vb_value = val.clone();
  149. };
  150. //--------------[ Vb::set_value( char WINFAR * ptr) ]-------------------
  151. // set value on a string
  152. // makes the string an octet
  153. // this must be a null terminates string
  154. void Vb::set_value( const char WINFAR * ptr)
  155. {
  156.   free_vb();
  157.   iv_vb_value = new OctetStr(ptr);
  158. };
  159. //---------------------[ Vb::get_value( int &i) ]----------------------
  160. // get value int
  161. // returns 0 on success and value
  162. int Vb::get_value( int &i)
  163. {
  164.    if (iv_vb_value &&
  165.        iv_vb_value->valid() &&
  166.        (iv_vb_value->get_syntax() == sNMP_SYNTAX_INT ))
  167.    {
  168.      long lval;
  169.      lval = *((SnmpInt32 *)iv_vb_value);// SnmpInt32 includes cast to long,
  170.      i = (int) lval;     // but not to int.
  171.      return SNMP_CLASS_SUCCESS;
  172.    }
  173.    else
  174.      return SNMP_CLASS_INVALID;
  175. };
  176. //--------------[ Vb::get_value( long int &i) ]-------------------------
  177. // get the signed long int
  178. // returns 0 on success and a value
  179. int Vb::get_value( long int &i)
  180. {
  181.    if (iv_vb_value &&
  182.        iv_vb_value->valid() &&
  183.        (iv_vb_value->get_syntax() == sNMP_SYNTAX_INT32 ))
  184.    {
  185.      i = *((SnmpInt32 *)iv_vb_value); // SnmpInt32 includes cast to long
  186.      return SNMP_CLASS_SUCCESS;
  187.    }
  188.    else
  189.     return SNMP_CLASS_INVALID;
  190. };
  191. //-----------------[  Vb::get_value( unsigned long int &i) ]--------------
  192. // get the unsigned long int
  193. // returns 0 on success and a value
  194. int Vb::get_value( unsigned long int &i)
  195. {
  196.    if (iv_vb_value &&
  197.        iv_vb_value->valid() &&
  198.        ((iv_vb_value->get_syntax() == sNMP_SYNTAX_UINT32 ) ||
  199. (iv_vb_value->get_syntax() == sNMP_SYNTAX_CNTR32 ) ||
  200. (iv_vb_value->get_syntax() == sNMP_SYNTAX_GAUGE32 ) ||
  201. (iv_vb_value->get_syntax() == sNMP_SYNTAX_TIMETICKS )))
  202.    {
  203.      i = *((SnmpUInt32 *)iv_vb_value); // SnmpUint32 has includes to ulong
  204.      return SNMP_CLASS_SUCCESS;
  205.    }
  206.    else
  207.      return SNMP_CLASS_INVALID;
  208. };
  209. //--------------[ Vb::get_value( unsigned char WINFAR * ptr, unsigned long &len)
  210. // get a unsigned char string value
  211. // destructive, copies into given ptr
  212. // also returned is the length
  213. //
  214. // Note!! The user must provide a target string
  215. // which is big enough to hold the string
  216. int Vb::get_value( unsigned char WINFAR * ptr, unsigned long &len)
  217. {
  218.    if (iv_vb_value &&
  219.        iv_vb_value->valid() &&
  220.        ( iv_vb_value->get_syntax() == sNMP_SYNTAX_OCTETS))
  221.    {
  222.      OctetStr *p_os = (OctetStr *)iv_vb_value;
  223.      len = p_os->len();
  224.      for ( int i=0; i<(int)len ; i++ ) {
  225.    ptr[i] = (*p_os)[i]; // use OctetStr[] for "raw" access
  226.      }
  227.      return SNMP_CLASS_SUCCESS;
  228.    }
  229.    else
  230.    {
  231.      ptr[0] = '0';
  232.      len = 0;
  233.      return SNMP_CLASS_INVALID;
  234.    }
  235. };
  236. //---------------[ Vb::get_value ]-------------------------------------
  237. // get an unsigned char array
  238. // caller specifies max len of target space
  239. int Vb::get_value( unsigned char WINFAR * ptr, // pointer to target space
  240.    unsigned long &len, // returned len
  241.    unsigned long maxlen) // max len of target space
  242. {
  243.    if ( iv_vb_value &&
  244.         iv_vb_value->valid() &&
  245. (iv_vb_value->get_syntax() == sNMP_SYNTAX_OCTETS))
  246.    {
  247.      OctetStr *p_os = (OctetStr *)iv_vb_value;
  248.      len = p_os->len();
  249.      if (len > maxlen) len = maxlen;
  250.      for ( int i=0; i<(int)len ; i++ ) {
  251.    ptr[i] = (*p_os)[i]; // use OctetStr[] for "raw" access
  252.      }
  253.      return SNMP_CLASS_SUCCESS;
  254.    }
  255.    else
  256.    {
  257.      ptr[0] = '0';
  258.      len = 0;
  259.      return SNMP_CLASS_INVALID;
  260.    }
  261. };
  262. //---------------[ Vb::get_value( Value &val) ]--------
  263. int Vb::get_value( SnmpSyntax &val)
  264. {
  265.   if (iv_vb_value){
  266.     val = *iv_vb_value;
  267.     if (val.valid())
  268. return SNMP_CLASS_SUCCESS;
  269.     else
  270. return SNMP_CLASS_INVALID;
  271.   }
  272.   else
  273.   {
  274. //TM: should set val to be invalid
  275.     return SNMP_CLASS_INVALID;
  276.   }
  277. };
  278. //--------------[ Vb::get_value( char WINFAR *ptr) ]-------------------
  279. // get a char * from an octet string
  280. // the user must provide space or
  281. // memory will be stepped on
  282. int Vb::get_value( char WINFAR *ptr)
  283. {
  284.    if (iv_vb_value &&
  285.        iv_vb_value->valid() &&
  286.        ( iv_vb_value->get_syntax() == sNMP_SYNTAX_OCTETS))
  287.    {
  288.      OctetStr *p_os = (OctetStr *)iv_vb_value;
  289.      unsigned long len = p_os->len();
  290.      for ( int i=0; i<(int)len ; i++ ) {
  291.    ptr[i] = (*p_os)[i]; // use OctetStr[] for "raw" access
  292.      }
  293.      ptr[len] = 0;
  294.      return SNMP_CLASS_SUCCESS;
  295.    }
  296.    else
  297.      return SNMP_CLASS_INVALID;
  298. };
  299. //-----[ misc]--------------------------------------------------------
  300. // return the current syntax
  301. // This method violates Object Orientation but may be useful if
  302. // the caller has a vb object and does not know what it is.
  303. // This would be useful in the implementation of a browser.
  304. SmiUINT32 Vb::get_syntax()
  305. if ( exception_status != SNMP_CLASS_SUCCESS)
  306. return exception_status;
  307. else
  308.         return ( iv_vb_value ? iv_vb_value->get_syntax() : sNMP_SYNTAX_NULL);
  309. };
  310. static char blank_string[] = "";
  311. // return the printabel value
  312. char WINFAR *Vb::get_printable_value()
  313. {
  314.   if (iv_vb_value)
  315.     return iv_vb_value->get_printable();
  316.   else
  317.     return blank_string;
  318. }
  319. // return the printable oid
  320. char WINFAR *Vb::get_printable_oid()
  321. { return iv_vb_oid.get_printable(); };
  322. // friend function to set exception status
  323. void set_exception_status( Vb *vb, const SmiUINT32 status)
  324. {
  325.    vb->exception_status = status;
  326. };