octet.h
上传用户:ets1996
上传日期:2014-09-30
资源大小:353k
文件大小:13k
源码类别:

SNMP编程

开发平台:

Visual C++

  1. /*_############################################################################
  2.   _## 
  3.   _##  octet.h  
  4.   _##
  5.   _##  SNMP++v3.2.22
  6.   _##  -----------------------------------------------
  7.   _##  Copyright (c) 2001-2007 Jochen Katz, Frank Fock
  8.   _##
  9.   _##  This software is based on SNMP++2.6 from Hewlett Packard:
  10.   _##  
  11.   _##    Copyright (c) 1996
  12.   _##    Hewlett-Packard Company
  13.   _##  
  14.   _##  ATTENTION: USE OF THIS SOFTWARE IS SUBJECT TO THE FOLLOWING TERMS.
  15.   _##  Permission to use, copy, modify, distribute and/or sell this software 
  16.   _##  and/or its documentation is hereby granted without fee. User agrees 
  17.   _##  to display the above copyright notice and this license notice in all 
  18.   _##  copies of the software and any documentation of the software. User 
  19.   _##  agrees to assume all liability for the use of the software; 
  20.   _##  Hewlett-Packard and Jochen Katz make no representations about the 
  21.   _##  suitability of this software for any purpose. It is provided 
  22.   _##  "AS-IS" without warranty of any kind, either express or implied. User 
  23.   _##  hereby grants a royalty-free license to any and all derivatives based
  24.   _##  upon this software code base. 
  25.   _##  
  26.   _##  Stuttgart, Germany, Wed May  2 23:22:30 CEST 2007 
  27.   _##  
  28.   _##########################################################################*/
  29. /*===================================================================
  30.   Copyright (c) 1999
  31.   Hewlett-Packard Company
  32.   ATTENTION: USE OF THIS SOFTWARE IS SUBJECT TO THE FOLLOWING TERMS.
  33.   Permission to use, copy, modify, distribute and/or sell this software
  34.   and/or its documentation is hereby granted without fee. User agrees
  35.   to display the above copyright notice and this license notice in all
  36.   copies of the software and any documentation of the software. User
  37.   agrees to assume all liability for the use of the software; Hewlett-Packard
  38.   makes no representations about the suitability of this software for any
  39.   purpose. It is provided "AS-IS without warranty of any kind,either express
  40.   or implied. User hereby grants a royalty-free license to any and all
  41.   derivatives based upon this software code base.
  42.   SNMP++ O C T E T . H
  43.   OCTETSTR CLASS DEFINITION
  44.   DESIGN + AUTHOR:
  45.   Peter E Mellquist
  46.   LANGUAGE:
  47.   ANSI C++
  48.   OPERATING SYSTEMS:
  49.   MS-WINDOWS Win32
  50.   BSD UNIX
  51.   DESCRIPTION:
  52.   This class is fully contained and does not rely on or any other
  53.   SNMP libraries. This class is portable across any platform
  54.   which supports C++.
  55. =====================================================================*/
  56. // $Id: octet.h 287 2007-03-22 22:37:09Z katz $
  57. #ifndef _OCTET_CLS
  58. #define _OCTET_CLS
  59. #include "snmp_pp/smival.h"
  60. #ifdef SNMP_PP_NAMESPACE
  61. namespace Snmp_pp {
  62. #endif
  63. //------------[ SNMP++ OCTETSTR CLASS DEF  ]-----------------------------
  64. class DLLOPT OctetStr: public  SnmpSyntax
  65. {
  66.  public:
  67.   /**
  68.    * Enum for setting the hex output format.
  69.    */
  70.   enum OutputType
  71.   {
  72.     OutputHexAndClear,
  73.     OutputHex,
  74.     OutputClear
  75.   };
  76.   //-----------[ Constructors and Destrucotr ]----------------------
  77.   /**
  78.    * Constructs a valid OctetStr with zero length.
  79.    */
  80.   OctetStr();
  81.   /**
  82.    * Constructs a OctetStr with the given value.
  83.    * The OctetStr will be valid unless a call to new fails.
  84.    *
  85.    * @param str - Null terminated string
  86.    */
  87.   OctetStr(const char *str);
  88.   /**
  89.    * Constructs a OctetStr with the given value.
  90.    * The OctetStr will be valid unless a call to new fails.
  91.    *
  92.    * @param str - string that may contain null bytes
  93.    * @param len - length of the string
  94.    */
  95.   OctetStr(const unsigned char *str, unsigned long len);
  96.   /**
  97.    * Construct a OctetStr from another OctetStr.
  98.    * The OctetStr will be valid unless a call to new fails.
  99.    *
  100.    * @param octet - Value for the new object
  101.    */
  102.   OctetStr(const OctetStr &octet);
  103.   /**
  104.    * Destructor, frees allocated space.
  105.    */
  106.   ~OctetStr();
  107.   //-----------[ Overloaded operators ]----------------------
  108.   /**
  109.    * Assign a char string to a OctetStr.
  110.    */
  111.   OctetStr& operator=(const char *str);
  112.   /**
  113.    * Assign a OctetStr to a OctetStr.
  114.    */
  115.   OctetStr& operator=(const OctetStr &octet);
  116.   /**
  117.    * Equal operator for two OctetStr.
  118.    */
  119.   DLLOPT friend int operator==(const OctetStr &lhs, const OctetStr &rhs);
  120.   /**
  121.    * Not equal operator for two OctetStr.
  122.    */
  123.   DLLOPT friend int operator!=(const OctetStr &lhs, const OctetStr &rhs);
  124.   /**
  125.    * Not equal operator for two OctetStr.
  126.    */
  127.   DLLOPT friend int operator<(const OctetStr &lhs, const OctetStr &rhs);
  128.   /**
  129.    * Less than operator for two OctetStr.
  130.    */
  131.   DLLOPT friend int operator<=(const OctetStr &lhs,const OctetStr &rhs);
  132.   /**
  133.    * Greater than operator for two OctetStr.
  134.    */
  135.   DLLOPT friend int operator>(const OctetStr &lhs, const OctetStr &rhs);
  136.   /**
  137.    * Greater than or equal operator for two OctetStr.
  138.    */
  139.   DLLOPT friend int operator>=(const OctetStr &lhs, const OctetStr &rhs);
  140.   /**
  141.    * Equal operator for OctetStr and char string.
  142.    */
  143.   DLLOPT friend int operator==(const OctetStr &lhs, const char *rhs);
  144.   /**
  145.    * Not equal operator for OctetStr and char string.
  146.    */
  147.   DLLOPT friend int operator!=(const OctetStr &lhs, const char *rhs);
  148.   /**
  149.    * Less than operator for OctetStr and char string.
  150.    */
  151.   DLLOPT friend int operator<(const OctetStr &lhs, const char *rhs);
  152.   /**
  153.    * Less than or equal operator for OctetStr and char string.
  154.    */
  155.   DLLOPT friend int operator<=(const OctetStr &lhs, const char *rhs);
  156.   /**
  157.    * Greater than operator for OctetStr and char string.
  158.    */
  159.   DLLOPT friend int operator>(const OctetStr &lhs, const char *rhs);
  160.   /**
  161.    * Greater than or equal operator for OctetStr and char string.
  162.    */
  163.   DLLOPT friend int operator>=(const OctetStr &lhs, const char *rhs);
  164.   /**
  165.    * Append a char string to this OctetStr.
  166.    */
  167.   OctetStr& operator+=(const char *a);
  168.   /**
  169.    * Append a single char to this OctetStr.
  170.    */
  171.   OctetStr& operator+=(const unsigned char c);
  172.   /**
  173.    * Append another OctetStr to this OctetStr.
  174.    */
  175.   OctetStr& operator+=(const OctetStr& octet);
  176.   /**
  177.    * Allow access as if it was an array.
  178.    *
  179.    * @note The given param is not checked for validity.
  180.    */
  181.   unsigned char &operator[](int i)
  182.     { m_changed = true; return smival.value.string.ptr[i]; };
  183.   /**
  184.    * Allow access as if it was an array for const OctetStr objects.
  185.    *
  186.    * @note The given param is not checked for validity.
  187.    */
  188.   unsigned char operator[](int i) const { return smival.value.string.ptr[i]; };
  189.   /**
  190.    * Return the syntax.
  191.    *
  192.    * @return This method always returns sNMP_SYNTAX_OCTETS.
  193.    */
  194.   SmiUINT32 get_syntax() const { return sNMP_SYNTAX_OCTETS; };
  195.   /**
  196.    * Return the space needed for serialization.
  197.    */
  198.   int get_asn1_length() const;
  199.   /**
  200.    * Return validity of the object.
  201.    */
  202.   bool valid() const { return validity; };
  203.   /**
  204.    * Clone this object.
  205.    *
  206.    * @return Pointer to the newly created object (allocated through new).
  207.    */
  208.   SnmpSyntax *clone() const { return (SnmpSyntax *) new OctetStr(*this); };
  209.   /**
  210.    * Map other SnmpSyntax objects to OctetStr.
  211.    */
  212.   SnmpSyntax& operator=(const SnmpSyntax &val);
  213.   /**
  214.    * Get a printable ASCII value of the string.
  215.    *
  216.    * @note Depending on the selected output format, this method will
  217.    *       return get_printable_hex() or get_printable_clear() if the
  218.    *       string contains not printable characters.
  219.    *
  220.    * @return Printable, null terminated string
  221.    */
  222.   const char *get_printable() const;
  223.   /**
  224.    * Get an ASCII formatted hex dump of the contents.
  225.    * If the output format was set to OctetStr::OutputHexAndClear,
  226.    * the produced string of this method will look like this:
  227.    *                                                                     <pre>
  228.    * 09 4F 63 74 65 74 53 74 72 3A 3A 67 65 74 5F 70    .OctetStr::get_p
  229.    * 72 69 6E 74 61 62 6C 65 5F 68 65 78 28 29          rintable_hex()
  230.    *                                                                     </pre>
  231.    * If the output format was set to OctetStr::OutputHex the
  232.    * produced string will look like this:
  233.    *                                                                     <pre>
  234.    * 09 4F 63 74 65 74 53 74 72 3A 3A 67 65 74 5F 70
  235.    * 72 69 6E 74 61 62 6C 65 5F 68 65 78 28 29
  236.    *                                                                     </pre>
  237.    * @return Printable, null terminated string.
  238.    */
  239.   const char *get_printable_hex() const;
  240.   /**
  241.    * Get the contents with all non printable characters replaced.
  242.    *
  243.    * @return Printable, null terminated string.
  244.    */
  245.   const char *get_printable_clear() const;
  246.   /**
  247.    * Set the output format for get_pritable_hex().
  248.    */
  249.   static void set_hex_output_type(const enum OutputType ot)
  250.     { hex_output_type = ot; };
  251.   /**
  252.    * Set the char get_printable_hex() and get_printable_clear()
  253.    * will use for non printable characters.
  254.    */
  255.   static void set_np_char(const char np) { nonprintable_char = np; };
  256.   /**
  257.    * Set the data on an already constructed OctetStr.
  258.    * The given string is copied to an internal member var, so the
  259.    * params can be destroyed afterwards.
  260.    *
  261.    * @param str - The new string value
  262.    * @param len - Length of the given string
  263.    */
  264.   void set_data(const unsigned char *str, unsigned long len);
  265.   /**
  266.    * Get the length of the string.
  267.    */
  268.   unsigned long len() const { return smival.value.string.len; };
  269.   /**
  270.    * Get a pointer to internal data.
  271.    */
  272.   unsigned char *data() const { return smival.value.string.ptr; };
  273.   // compare n elements of an octet
  274.   int nCompare(const unsigned long n, const OctetStr &o) const;
  275.   /**
  276.    * Build an OctetStr from a hex string.
  277.    * Called with "5465  737469 6e672074686973206D657468 6f 64 21"
  278.    * the returned value will be "Testing this method!"
  279.    *
  280.    * @param hex_string - The hex string (may contain spaces)
  281.    * @return created string
  282.    */
  283.   static OctetStr from_hex_string(const OctetStr &hex_string);
  284.   /**
  285.    * Set the character for linefeeds in get_printable() functions.
  286.    *
  287.    * The default linefeeds are n for Unix and rn on other systems.
  288.    *
  289.    * @param lf_chars - string less than 3 bytes
  290.    * @return true on success
  291.    */
  292.   static bool set_linefeed_chars(const char* lf_chars);
  293.   /**
  294.    * Null out the contents of the string. The string will be empty
  295.    * after calling this method
  296.    */
  297.   void clear();
  298.   /**
  299.    * Append or shorten the internal data buffer.
  300.    *
  301.    * The buffer will either be shortened or extended. In the second case
  302.    * zeroes are added to the end of the string.
  303.    *
  304.    * @param new_len - The new length for the string
  305.    * @return true on success
  306.    */
  307.   bool set_len(const unsigned char new_len);
  308.  protected:
  309.   enum OutputFunction
  310.   {
  311.       OutputFunctionDefault,
  312.       OutputFunctionHex,
  313.       OutputFunctionClear
  314.   };
  315.   SNMP_PP_MUTABLE char *output_buffer;  // formatted Octet value
  316.   SNMP_PP_MUTABLE unsigned int output_buffer_len; // allocated space for string
  317.   SNMP_PP_MUTABLE bool m_changed;
  318.   SNMP_PP_MUTABLE enum OutputType output_last_type;
  319.   SNMP_PP_MUTABLE char output_last_np_char;
  320.   SNMP_PP_MUTABLE enum OutputFunction output_last_function;
  321.   bool validity;          // validity boolean
  322.   static enum OutputType hex_output_type;
  323.   static char nonprintable_char;
  324.   static char linefeed_chars[3];
  325. };
  326. //-----------[ End OctetStr Class ]-------------------------------------
  327. /**
  328.  * The OpaqueStr class represents the Opaque SNMP type. It is derived from
  329.  * the SNMP++ class OctetStr and has the same interfaces and behavior,
  330.  * except that its syntax is sNMP_SYNTAX_OPAQUE.
  331.  */
  332. class OpaqueStr: public OctetStr
  333. {
  334.  public:
  335.   /**
  336.    * Constructor creating a valid zero length OpaqueStr.
  337.    */
  338.   OpaqueStr(): OctetStr()
  339.     { smival.syntax = sNMP_SYNTAX_OPAQUE; };
  340.   /**
  341.    * Constructs a OpaqueStr with the given value.
  342.    * The OpaqueStr will be valid unless a call to new fails.
  343.    *
  344.    * @param str - Null terminated string
  345.    */
  346.   OpaqueStr(const char *str) : OctetStr(str)
  347.     { smival.syntax = sNMP_SYNTAX_OPAQUE; };
  348.   /**
  349.    * Constructs a OpaqueStr with the given value.
  350.    * The OpaqueStr will be valid unless a call to new fails.
  351.    *
  352.    * @param str - string that may contain null bytes
  353.    * @param len - length of the string
  354.    */
  355.   OpaqueStr(const unsigned char *str, unsigned long length)
  356.     : OctetStr(str, length) { smival.syntax = sNMP_SYNTAX_OPAQUE; };
  357.   /**
  358.    * Construct a OpaqueStr from an OctetStr.
  359.    * The OpaqueStr will be valid unless a call to new fails.
  360.    *
  361.    * @param octet - Value for the new object
  362.    */
  363.   OpaqueStr(const OctetStr &octet) : OctetStr(octet)
  364.     { smival.syntax = sNMP_SYNTAX_OPAQUE; };
  365.   /**
  366.    * Construct a OpaqueStr from another OpaqueStr.
  367.    * The OpaqueStr will be valid unless a call to new fails.
  368.    *
  369.    * @param opaque - Value for the new object
  370.    */
  371.   OpaqueStr(const OpaqueStr& opaque) : OctetStr(opaque)
  372.     { smival.syntax = sNMP_SYNTAX_OPAQUE; };
  373.   /**
  374.    * Clone this object.
  375.    *
  376.    * @return Pointer to the newly created object (allocated through new).
  377.    */
  378.   virtual SnmpSyntax *clone() const { return new OpaqueStr(*this); }
  379.   /**
  380.    * Return the syntax.
  381.    *
  382.    * @return This method always returns sNMP_SYNTAX_OPAQUE.
  383.    */
  384.   virtual SmiUINT32 get_syntax() const { return sNMP_SYNTAX_OPAQUE; };
  385.   
  386.   /**
  387.    * Map other SnmpSyntax objects to OpaqueStr.
  388.    */
  389.   SnmpSyntax& operator=(const SnmpSyntax &val) 
  390.    { return OctetStr::operator=(val); }
  391. };
  392. #ifdef SNMP_PP_NAMESPACE
  393. } // end of namespace Snmp_pp
  394. #endif 
  395. #endif // _OCTET_CLS