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

SNMP编程

开发平台:

Visual C++

  1. /*_############################################################################
  2.   _## 
  3.   _##  oid.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 I D. H
  43.   OID CLASS DEFINITION
  44.   DESIGN + AUTHOR:   Peter E Mellquist
  45.   LANGUAGE:          ANSI C++
  46.   DESCRIPTION:
  47.   This class is fully contained and does not rely on or any other
  48.   SNMP libraries. This class is portable across any platform
  49.   which supports C++.
  50. =====================================================================*/
  51. // $Id: oid.h 287 2007-03-22 22:37:09Z katz $
  52. #ifndef _OID_H_
  53. #define _OID_H_
  54. //------------------------------------------------------------------------
  55. #include "snmp_pp/smival.h"                // derived class for all values
  56. #include "snmp_pp/collect.h"
  57. #ifdef SNMP_PP_NAMESPACE
  58. namespace Snmp_pp {
  59. #endif
  60. /**
  61.  * The Object Identifier Class.
  62.  *
  63.  * The Object Identification (Oid) class is the encapsulation of an
  64.  * SMI object identifier. The SMI object is a data identifier for a
  65.  * data element found in a Management Information Base (MIB), as
  66.  * defined by a MIB definition. The SMI Oid, its related structures
  67.  * and functions, are a natural fit for object orientation. In fact,
  68.  * the Oid class shares many common features to the C++ String
  69.  * class. For those of you familiar with the C++ String class or
  70.  * Microsoft's Foundation Classes (MFC) CString class, the Oid class
  71.  * will be familiar and easy to use. The Oid class is designed to be
  72.  * efficient and fast. The Oid class allows definition and
  73.  * manipulation of object identifiers. 
  74.  *
  75.  * @note Oid holds two internal buffers for get_printable() functions.
  76.  *       The buffer returned by get_printable() is valid until the
  77.  *       Oid object is modified. The functions get_printable(len) and
  78.  *       get_printable(start, len) share the same buffer which is
  79.  *       freed and newly allocated for each call.
  80.  */
  81. class DLLOPT Oid : public SnmpSyntax
  82. {
  83.  public:
  84.   /**
  85.    * Construct an invalid Oid.
  86.    */
  87.   Oid();
  88.   /**
  89.    * Construct an Oid from a string.
  90.    *
  91.    * Depending on the second param, the oid_string can either be
  92.    * - a dotted oid string (like "1.3.6.1.6"). An arbitrary part
  93.    *   of the oid can be given as a string value enclosed in
  94.    *   '$' characters. For example the oid string
  95.    *   "1.3.6.1.6.1.12.1.3.$public0$" will result to the oid
  96.    *   1.3.6.1.6.1.12.1.3.112.117.98.108.105.99.95.48
  97.    * - a normal string (like "public"). The Oid will have the
  98.    *   ASCII values of the string characters. So "public" will
  99.    *   result to the oid 112.117.98.108.105.99
  100.    * 
  101.    * @param oid_string - for example "1.3.1.6.1.10"
  102.    * @param is_dotted_oid_string - Select format within oid_string
  103.    */
  104.   Oid(const char *oid_string, const bool is_dotted_oid_string = true);
  105.   /**
  106.    * Constructor using another oid object (copy constructor).
  107.    *
  108.    * @param oid - Source Oid
  109.    */
  110.   Oid(const Oid &oid);
  111.   /**
  112.    * Constructor from array.
  113.    *
  114.    * @param raw_oid - array of oid values
  115.    * @param oid_len - length of array
  116.    */
  117.   Oid(const unsigned long *raw_oid, int oid_len);
  118. #if 0 // can be done through Oid o; o.set_data("public", 6); 
  119.   /**
  120.    * Constructor from standard C string array.
  121.    *
  122.    * @note This constructor does not take a dotted oid string as argument.
  123.    *
  124.    * @param str     - Array of new values (a string)
  125.    * @param str_len - Length of the array raw_oid
  126.    */
  127.   Oid(const char *str, const unsigned int str_len);
  128. #endif
  129.   /**
  130.    * Destructor.
  131.    */
  132.   virtual ~Oid();
  133.   /**
  134.    * Return the current syntax.
  135.    *
  136.    * @return always sNMP_SYNTAX_OID
  137.    */
  138.   SmiUINT32 get_syntax() const { return sNMP_SYNTAX_OID; };
  139.   /**
  140.    * Assignment from a string.
  141.    *
  142.    * @param dotted_oid_string - New value (for example "1.3.6.1.6.0");
  143.    */
  144.   virtual Oid& operator=(const char *dotted_oid_string);
  145.   /**
  146.    * Assign one Oid to another.
  147.    */
  148.   virtual Oid& operator=(const Oid &oid);
  149.   /**
  150.    * Return the space needed for serialization.
  151.    */
  152.   int get_asn1_length() const;
  153.   /**
  154.    * Overloaded equal operator.
  155.    */
  156.   DLLOPT friend int operator==(const Oid &lhs, const Oid &rhs);
  157.   /**
  158.    * Overloaded not equal operator.
  159.    */
  160.   DLLOPT friend int operator!=(const Oid &lhs, const Oid &rhs)
  161.       { return (!(lhs == rhs)); };  // just invert ==
  162.   /**
  163.    * Overloaded less than < operator.
  164.    */
  165.   DLLOPT friend int operator<(const Oid &lhs, const Oid &rhs);
  166.   /**
  167.    * Overloaded less than <= operator.
  168.    */
  169.   DLLOPT friend int operator<=(const Oid &lhs, const Oid &rhs)
  170.       { return ((lhs < rhs) || (lhs == rhs)); };
  171.   /**
  172.    * Overloaded greater than > operator.
  173.    */
  174.   DLLOPT friend int operator>(const Oid &lhs, const Oid &rhs)
  175.       { return (!(lhs <= rhs)); };  // just invert existing <=
  176.   /**
  177.    * Overloaded greater than >= operator.
  178.    */
  179.   DLLOPT friend int operator>=(const Oid &lhs, const Oid &rhs)
  180.       { return (!(lhs < rhs)); };  // just invert existing <
  181.   /**
  182.    * Overloaded equal operator operator.
  183.    */
  184.   DLLOPT friend int operator==(const Oid &lhs, const char *rhs);
  185.   /**
  186.    * Overloaded not equal operator.
  187.    */
  188.   DLLOPT friend int operator!=(const Oid &lhs, const char *rhs);
  189.   /**
  190.    * Overloaded less than < operator.
  191.    */
  192.   DLLOPT friend int operator<(const Oid &lhs, const char *rhs);
  193.   /**
  194.    * Overloaded less than <= operator.
  195.    */
  196.   DLLOPT friend int operator<=(const Oid &lhs, char *rhs);
  197.   /**
  198.    * Overloaded greater than > operator.
  199.    */
  200.   DLLOPT friend int operator>(const Oid &lhs, const char *rhs);
  201.   /**
  202.    * Overloaded greater than >= operator.
  203.    */
  204.   DLLOPT friend int operator>=(const Oid &lhs, const char *rhs);
  205.   /**
  206.    * Overloaded operator +, Concatenate two Oids.
  207.    */
  208.   DLLOPT friend Oid operator +(const Oid &lhs, const Oid &rhs)
  209.     { Oid tmp(lhs); tmp += rhs; return tmp;};
  210.   /**
  211.    * Append operator, appends the dotted oid string.
  212.    *
  213.    * @param a - dotted oid string, for example "5.192.14.6"
  214.    */
  215.   Oid& operator+=(const char *a);
  216.   /**
  217.    * Appends an int.
  218.    *
  219.    * @param i - Value to add at the end of the Oid
  220.    */
  221.   Oid& operator+=(const unsigned long i);
  222.   /**
  223.    * Appends an Oid.
  224.    *
  225.    * @param o - Oid to add at the end
  226.    */
  227.   Oid& operator+=(const Oid &o);
  228.   /**
  229.    * Allows element access as an array.
  230.    * This method behaves like real array: if your index
  231.    * is out of bounds, you're lost!
  232.    *
  233.    * @param index - valid index -- 0 to (len() - 1)
  234.    *
  235.    * @return Value on the given index
  236.    */
  237.   unsigned long &operator[](const unsigned int index)
  238.     { m_changed = true; return smival.value.oid.ptr[index]; };
  239.   /**
  240.    * Allows element access as an array for const objects.
  241.    * This method behaves like real array: if your index
  242.    * is out of bounds, you're lost!
  243.    *
  244.    * @param index - valid index -- 0 to (len() - 1)
  245.    *
  246.    * @return Value on the given position
  247.    */
  248.   unsigned long operator[](const unsigned int index) const
  249.     { return (index >= len()) ? 0 : smival.value.oid.ptr[index]; };
  250.   /**
  251.    * Get the WinSnmp oid part.
  252.    * @note This method returns a pointer to internal data.
  253.    *       If it is modified, the Oid changes too.
  254.    *
  255.    * @return pointer to the internal oid structure.
  256.    */
  257.   SmiLPOID oidval() { return (SmiLPOID) &smival.value.oid; };
  258.   /**
  259.    * Set the data from raw form.
  260.    *
  261.    * @param raw_oid - Array of new values
  262.    * @param oid_len - Length of the array raw_oid
  263.    */
  264.   void set_data(const unsigned long *raw_oid, const unsigned int oid_len);
  265.   /**
  266.    * Set the data from raw form.
  267.    *
  268.    * @param str     - Array of new values (a string)
  269.    * @param str_len - Length of the array raw_oid
  270.    */
  271.   void set_data(const char *str, const unsigned int str_len);
  272.   /**
  273.    * Get the length of the oid.
  274.    */
  275.   unsigned long len() const { return smival.value.oid.len; };
  276.   /**
  277.    * Trim off the rightmost values of an oid.
  278.    *
  279.    * @param n - Trim off n values from the right (default is one)
  280.    */
  281.   void trim(const unsigned long n = 1);
  282.   /**
  283.    * Compare two Oids from the left in direction left-to-right.
  284.    *
  285.    * @param n - Subvalues to compare
  286.    * @param o - The Oid to compare with
  287.    *
  288.    * @return 0 if equal / -1 if less / 1 if greater
  289.    */
  290.   int nCompare(const unsigned long n, const Oid &o) const;
  291.   /**
  292.    * Return validity of the object.
  293.    */
  294.   bool valid() const { return (smival.value.oid.ptr ? true : false); };
  295.   /**
  296.    * Get a printable ASCII string of the whole value.
  297.    *
  298.    * @return Dotted oid string (for example "1.3.6.1.6.0")
  299.    */
  300.   const char *get_printable() const
  301.     { return get_printable(1, smival.value.oid.len, (char*&)iv_str); };
  302.   /**
  303.    * Get a printable ASCII string of the right part of the value.
  304.    *
  305.    * @param n - positions to print, counted from right.
  306.    *
  307.    * @return Dotted oid string (for example "6.0")
  308.    */
  309.   const char *get_printable(const unsigned long n) const
  310.     { return get_printable(smival.value.oid.len - n + 1, n, (char*&)iv_part_str); };
  311.   /**
  312.    * Get a printable ASCII string of a part of the value.
  313.    *
  314.    * @param start - First position to print, starting with 1 (not zero!)
  315.    * @param n - positions to print.
  316.    * @param buffer - pointer to the returned buffer
  317.    *
  318.    * @note If buffer is not NULL, this function calls "delete [] buffer",
  319.    *       a new buffer is allocated using "new" and the caller has
  320.    *       to delete it.
  321.    *
  322.    * @return Dotted oid string (for example "3.6.1.6")
  323.    */
  324.   const char *get_printable(const unsigned long start,
  325.     const unsigned long n,
  326.     char *&buffer) const;
  327.   /**
  328.    * Get a printable ASCII string of a part of the value.
  329.    *
  330.    * @param start - First position to print, starting with 1 (not zero!)
  331.    * @param n - positions to print.
  332.    *
  333.    * @return Dotted oid string (for example "3.6.1.6")
  334.    */
  335.   const char *get_printable(const unsigned long start,
  336.     const unsigned long n) const
  337.     { return get_printable(start, n, (char*&)iv_part_str); };
  338.   /**
  339.    * Clone this object.
  340.    *
  341.    * @return Pointer to the newly created object (allocated through new).
  342.    */
  343.   SnmpSyntax *clone() const { return (SnmpSyntax *) new Oid(*this); };
  344.   /**
  345.    * Map other SnmpSyntax objects to Oid.
  346.    */
  347.   SnmpSyntax& operator=(const SnmpSyntax &val);
  348.   /**
  349.    * Clear the Oid.
  350.    */
  351.   void clear() { delete_oid_ptr(); };
  352.  protected:
  353.   /**
  354.    * Convert a string to an smi oid.
  355.    *
  356.    * @param string - input string
  357.    * @param dstOid - destination oid
  358.    */
  359.   virtual int StrToOid(const char *string, SmiLPOID dstOid) const;
  360.   /**
  361.    * Clone an smi oid.
  362.    *
  363.    * @param srcOid - source oid
  364.    * @param dstOid - destination oid
  365.    */
  366.   virtual int OidCopy(SmiLPOID srcOid, SmiLPOID dstOid) const;
  367.   /**
  368.    * Convert an smi oid to its string representation.
  369.    *
  370.    * @param srcOid - source oid
  371.    * @param size   - size of string
  372.    * @param string - pointer to string
  373.    */
  374.   virtual int OidToStr(const SmiOID *srcOid,
  375.        SmiUINT32 size,
  376.        char *string) const;
  377.   /**
  378.    * Free the internal oid pointer and set the pointer and the length to zero.
  379.    */
  380.   inline void delete_oid_ptr();
  381.   //----[ instance variables ]
  382.   SNMP_PP_MUTABLE char *iv_str;      // used for returning complete oid string
  383.   SNMP_PP_MUTABLE char *iv_part_str; // used for returning part oid string
  384.   SNMP_PP_MUTABLE bool m_changed;
  385. };
  386. //-----------[ End Oid Class ]-------------------------------------
  387. // create OidCollection type
  388. typedef SnmpCollection <Oid> OidCollection;
  389. inline void Oid::delete_oid_ptr()
  390. {
  391.   // delete the old value
  392.   if (smival.value.oid.ptr)
  393.   {
  394.     delete [] smival.value.oid.ptr;
  395.     smival.value.oid.ptr = 0;
  396.   }
  397.   smival.value.oid.len = 0;
  398.   m_changed = true;
  399. }
  400. #ifdef SNMP_PP_NAMESPACE
  401. } // end of namespace Snmp_pp
  402. #endif 
  403. #endif //_OID_H_