pdu.h
上传用户:uncom666
上传日期:2020-03-30
资源大小:1426k
文件大小:14k
源码类别:

SNMP编程

开发平台:

Visual C++

  1. /*_############################################################################
  2.   _## 
  3.   _##  pdu.h  
  4.   _##
  5.   _##  SNMP++v3.2.24
  6.   _##  -----------------------------------------------
  7.   _##  Copyright (c) 2001-2009 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, Fri May 29 22:35:14 CEST 2009 
  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++ P D U . H
  43.   PDU CLASS DEFINITION
  44.   DESIGN + AUTHOR:  Peter E Mellquist
  45.   DESCRIPTION:
  46.   Pdu class definition. Encapsulation of an SMI Protocol
  47.   Data Unit (PDU) in C++.
  48. =====================================================================*/
  49. // $Id: pdu.h 288 2007-03-22 22:37:09Z katz $
  50. #ifndef _PDU_CLS
  51. #define _PDU_CLS
  52. #include "snmp_pp/config_snmp_pp.h"
  53. #include "snmp_pp/address.h"
  54. #include "snmp_pp/timetick.h"
  55. #include "snmp_pp/octet.h"
  56. #include "snmp_pp/oid.h"
  57. #ifdef SNMP_PP_NAMESPACE
  58. namespace Snmp_pp {
  59. #endif
  60. class Vb;
  61. #define PDU_MAX_RID 32767         ///< max request id to use
  62. #define PDU_MIN_RID 1000          ///< min request id to use
  63. //=======================================================================
  64. //      Pdu Class
  65. //=======================================================================
  66. /**
  67.  * Pdu class...
  68.  */
  69. class DLLOPT Pdu
  70. {
  71.  public:
  72.   /**
  73.    * Constructor no args.
  74.    *
  75.    * This constructor creates a valid empty Pdu object.
  76.    */
  77.   Pdu();
  78.   /**
  79.    * Constructor with vbs.
  80.    *
  81.    * The Pdu class does not take ownership of the array and the Vb
  82.    * objects, so if these were allocated with new, they must be freed
  83.    * by te user with delete.
  84.    *
  85.    * @param pvbs      - Array of pointers to Vb objects
  86.    * @param pvb_count - Length of the array
  87.    */
  88.   Pdu(Vb* pvbs, const int pvb_count);
  89.   /**
  90.    * Constructor with another Pdu instance.
  91.    *
  92.    * @param pdu - source pdu object
  93.    */
  94.   Pdu(const Pdu &pdu) : vbs(0), vbs_size(0), vb_count(0) { *this = pdu; };
  95.   /**
  96.    * Destructor
  97.    */
  98.   virtual ~Pdu();
  99.   /**
  100.    * Overloaded assignment operator.
  101.    *
  102.    * @param pdu - Pdu that should be assigned to this object
  103.    */
  104.   Pdu& operator=(const Pdu &pdu);
  105.   /**
  106.    * Append a vb to the pdu.
  107.    *
  108.    * @param vb - The Vb that should be added (as last vb) to the pdu
  109.    */
  110.   Pdu& operator+=(const Vb &vb);
  111.   /**
  112.    * Clone a Pdu object.
  113.    *
  114.    * @return Pointer to a newly created Pdu object, that is identical to this
  115.    */
  116.   Pdu *clone() const { return new Pdu(*this); };
  117.   /**
  118.    * Get Pointers to all Vbs from Pdu.
  119.    *
  120.    * The caller has to allocate the array. The returned pointers point
  121.    * to the Vb objects that are internally used by the pdu. So any
  122.    * changes to the returned Vb objects will change the pdu. If the
  123.    * pdu is modified (e.g. through Pdu::trim()) afterwards, the
  124.    * returned array will contain invalid pointers.
  125.    *
  126.    * @param pvbs - Array of empty pointers of size pvb_count
  127.    * @param pvb_count - Amount of Vb pointers to get
  128.    *
  129.    * @return TRUE on success
  130.    */
  131.   int get_vblist(Vb* pvbs, const int pvb_count) const;
  132.   /**
  133.    * Deposit all Vbs to Pdu.
  134.    *
  135.    * The vb objects of the pdu will be freed and the objects from the
  136.    * array will be cloned and added to the pdu. If this method returns
  137.    * FALSE, the pdu will not conatin any Vb objects.
  138.    *
  139.    * @param pvbs - Array of valid pointers of size pvb_count
  140.    * @param pvb_count - Amount of Vb pointers i the array
  141.    *
  142.    * @return TRUE on success
  143.    */
  144.   int set_vblist(Vb* pvbs, const int pvb_count);
  145.   /**
  146.    * Get a particular Vb.
  147.    *
  148.    * @param vb - Object to store the vb
  149.    * @param index - The vb to get (zero is the first vb)
  150.    *
  151.    * @return TRUE on success
  152.    */
  153.   int get_vb(Vb &vb, const int index) const;
  154.   /**
  155.    * Return a reference to a particular Vb.
  156.    *
  157.    * @note Before calling this method, make sure that there
  158.    *       is a Vb using get_vb_count().
  159.    *
  160.    * @param index - The Vb to return starting with 0.
  161.    * @return A const reference to the Vb
  162.    */
  163.   const Vb &get_vb(const int index) const { return *vbs[index]; };
  164.   /**
  165.    * Set a particular vb.
  166.    *
  167.    * If this method returns FALSE, the pdu has not been modified.
  168.    *
  169.    * @param vb - Source vb
  170.    * @param index - The vb to set (zero is the first vb)
  171.    *
  172.    * @return TRUE on success
  173.    */
  174.   int set_vb(Vb &vb, const int index);
  175.   /**
  176.    * Get the number of vbs.
  177.    *
  178.    * @return The number of Vb objects within the pdu.
  179.    */
  180.   int get_vb_count() const { return vb_count; };
  181.   /**
  182.    * Get a Vb.
  183.    *
  184.    * @note The index has to be checked by the caller.
  185.    *
  186.    * @param i zero based index
  187.    */
  188.   Vb& operator[](const int i) { return *vbs[i]; };
  189.   /**
  190.    * Get the error status.
  191.    *
  192.    * @return The SNMP error status
  193.    */
  194.   int get_error_status() const { return error_status; };
  195.   /**
  196.    * Set the error status.
  197.    *
  198.    * @param err - The new SNMP error status.
  199.    */
  200.   void set_error_status(const int err) {  error_status = err; };
  201.   /**
  202.    * Clear the error status.
  203.    */
  204.   void clear_error_status() { error_status = 0; };
  205.   /**
  206.    * Get the error index.
  207.    *
  208.    * @return The SNMP error index
  209.    */
  210.   int get_error_index() const { return error_index; };
  211.   /**
  212.    * Set the error index.
  213.    *
  214.    * @param err - The new SNMP error index.
  215.    */
  216.   void set_error_index(const int index) { error_index = index; };
  217.   /**
  218.    * Clear the error index.
  219.    */
  220.   void clear_error_index() { error_index = 0; };
  221.   /**
  222.    * Clear error status and error index.
  223.    */
  224.   void clear_error() { set_error_status(0); set_error_index(0); }
  225.   /**
  226.    * Get the request id.
  227.    *
  228.    * @return The SNMP request id
  229.    */
  230.   unsigned long get_request_id() const { return request_id; };
  231.   /**
  232.    * Set the request id.
  233.    *
  234.    * @param rid - The new SNMP request id
  235.    */
  236.   void set_request_id(const unsigned long rid) { request_id = rid; };
  237.   /**
  238.    * Get the pdu type.
  239.    */
  240.   unsigned short get_type() const { return pdu_type; };
  241.   /**
  242.    * Set the pdu type.
  243.    */
  244.   void set_type(unsigned short type) { pdu_type = type; };
  245.   /**
  246.    * Returns validity of Pdu instance.
  247.    */
  248.   bool valid() const { return validity; };
  249.   /**
  250.    * Trim off vbs.
  251.    *
  252.    * @param count - number of vbs to trim of, starting with the last
  253.    * @return TRUE on success, FALSE if nothing was done
  254.    */
  255.   int trim(const int count=1);
  256.   /**
  257.    * Delete a Vb anywhere within the Pdu.
  258.    *
  259.    * @param position - Delete the Vb at this position (starting with 0)
  260.    * @return TRUE on success
  261.    */
  262.   int delete_vb(const int position);
  263.   /**
  264.    * Set notify timestamp.
  265.    */
  266.   void set_notify_timestamp(const TimeTicks &ts) { notify_timestamp = ts; };
  267.   /**
  268.    * Get notify timestamp.
  269.    */
  270.   void get_notify_timestamp(TimeTicks &ts) const { ts = notify_timestamp; };
  271.   /**
  272.    * Set the notify id.
  273.    *
  274.    * @return true if the set succeeded.
  275.    */
  276.   bool set_notify_id(const Oid &id)
  277.     { notify_id = id; return (notify_id.len() == id.len()); };
  278.   /**
  279.    * Get the notify id.
  280.    *
  281.    * @return true if the get succeeded.
  282.    */
  283.   bool get_notify_id(Oid &id) const
  284.     { id = notify_id; return (notify_id.len() == id.len()); };
  285.   /**
  286.    * Set the notify enterprise.
  287.    *
  288.    * @return true if the set succeeded.
  289.    */
  290.   bool set_notify_enterprise(const Oid &e)
  291.     { notify_enterprise = e; return (notify_enterprise.len() == e.len()); };
  292.   /**
  293.    * Get the notify enterprise.
  294.    *
  295.    * @return true if the get succeeded.
  296.    */
  297.   bool get_notify_enterprise(Oid & e) const
  298.     { e = notify_enterprise;  return (notify_enterprise.len() == e.len()); };
  299. #ifdef _SNMPv3
  300.   /**
  301.    * Set the security level that should be used when this Pdu is sent.
  302.    * The default security level of a Pdu is SNMP_SECURITY_LEVEL_NOAUTH_NOPRIV.
  303.    *
  304.    * @param level - One of SNMP_SECURITY_LEVEL_NOAUTH_NOPRIV,
  305.    *                SNMP_SECURITY_LEVEL_AUTH_NOPRIV,
  306.    *                SNMP_SECURITY_LEVEL_AUTH_PRIV
  307.    */
  308.   void set_security_level(const int level) { security_level = level; };
  309.   /**
  310.    * Return the security level of the Pdu.
  311.    *
  312.    * @return - the security level
  313.    */
  314.   int get_security_level() const { return security_level; };
  315.   /**
  316.    * Set the context name of the Pdu.
  317.    *
  318.    * @param name - The context name
  319.    */
  320.   bool set_context_name(const OctetStr &name)
  321.     { context_name = name; return (context_name.valid() && name.valid()); };
  322.   /**
  323.    * Set the context name of the Pdu.
  324.    *
  325.    * @param name - The context name
  326.    */
  327.   bool set_context_name(const char *name)
  328.     { context_name = name; return context_name.valid(); };
  329.   /**
  330.    * Get the context name of the Pdu.
  331.    *
  332.    * @param name - Object fot the context name
  333.    */
  334.   bool get_context_name(OctetStr &name) const
  335.     { name = context_name; return (context_name.valid() && name.valid()); };
  336.   /**
  337.    * Get the context name of the Pdu.
  338.    *
  339.    * @return - Return the context name as an OctetStr
  340.    */
  341.   const OctetStr& get_context_name() const { return context_name; };
  342.   /**
  343.    * Set the context engine id of the Pdu.
  344.    *
  345.    * @param id - The new context engine id
  346.    */
  347.   bool set_context_engine_id(const OctetStr &id) { context_engine_id = id;
  348.     return (context_engine_id.valid() && id.valid()); };
  349.   /**
  350.    * Set the context engine id of the Pdu.
  351.    *
  352.    * @param id - The new context engine id
  353.    */
  354.   bool set_context_engine_id(const char *id)
  355.     { context_engine_id = id; return context_engine_id.valid(); };
  356.   /**
  357.    * Get the context engine id of the Pdu.
  358.    *
  359.    * @param id - Object for the context engine
  360.    */
  361.   bool get_context_engine_id(OctetStr &id) const { id = context_engine_id;
  362.     return (context_engine_id.valid() && id.valid()); };
  363.   /**
  364.    * Get the context engine id of the Pdu.
  365.    *
  366.    * @return - Return the context engine id as an OctetStr
  367.    */
  368.   const OctetStr& get_context_engine_id() const { return context_engine_id; };
  369.   /**
  370.    * Set the SNMPv3 message id (msgID)
  371.    *
  372.    * @param msg_id - the message id of the received message
  373.    */
  374.   void set_message_id(const unsigned long msg_id) { message_id = msg_id; }
  375.   /**
  376.    * Get the SNMPv3 message id (msgID)
  377.    *
  378.    * @return - the message id of the received message
  379.    */
  380.   unsigned long get_message_id() const { return message_id; }
  381.   /**
  382.    * Set the maximum size of the scoped pdu to be included in a
  383.    * possible response message.
  384.    *
  385.    * @param l - the maximum size
  386.    */
  387.   void set_maxsize_scopedpdu(unsigned long l) { maxsize_scopedpdu = l; };
  388.   /**
  389.    * Get the maximum size of the scoped pdu to be included in a
  390.    * possible response message.
  391.    *
  392.    * @return - the maximum size
  393.    */
  394.   unsigned long get_maxsize_scopedpdu() const { return maxsize_scopedpdu; };
  395. #endif // _SNMPv3
  396.   /**
  397.    * Get the SNMPv1 trap address
  398.    */
  399.   int get_v1_trap_address(GenAddress &address) const;
  400.   /**
  401.    * Set the SNMPv1 trap address
  402.    */
  403.   int set_v1_trap_address(const Address &address);
  404.   /**
  405.    * Return the length of the encoded vbs with pdu header.
  406.    *
  407.    * @note this method wll not work for v1 traps.
  408.    */
  409.   int get_asn1_length() const;
  410.   /**
  411.    * Clear the Pdu contents (destruct and construct in one go)
  412.    */
  413.   void clear();
  414.   /**
  415.    * Does the type of response match the type of request.
  416.    */
  417.   static bool match_type(const int request, const int response);
  418.   //-------------[ protected members ]--------------------------
  419.  protected:
  420.   /**
  421.    * Extend the vbs array.
  422.    *
  423.    * @return true on success
  424.    */
  425.   bool extend_vbs();
  426.   Vb **vbs;                    // pointer to array of Vbs
  427.   int vbs_size;                // Size of array
  428.   int vb_count;                // count of Vbs
  429.   int error_status;            // SMI error status
  430.   int error_index;             // SMI error index
  431.   bool validity;               // valid boolean
  432.   unsigned long request_id;  // SMI request id
  433.   unsigned short pdu_type;  // derived at run time based on request type
  434.   // for notify Pdu objects only
  435.   // traps & notifies
  436.   TimeTicks notify_timestamp;      // a timestamp associated with an infor
  437.   Oid notify_id;                   // an id
  438.   Oid notify_enterprise;
  439.   GenAddress v1_trap_address;      // address object
  440.   int        v1_trap_address_set;
  441. #ifdef _SNMPv3
  442.   // specific Objects for SNMPv3
  443.   int security_level;            // the securityLevel with which this Pdu
  444.                                  // should be sent or was received
  445.   unsigned long message_id;
  446.   unsigned long maxsize_scopedpdu;
  447.   OctetStr context_name;
  448.   OctetStr context_engine_id;
  449. #endif // _SNMPv3
  450. };
  451. #ifdef SNMP_PP_NAMESPACE
  452. } // end of namespace Snmp_pp
  453. #endif 
  454. #endif //_PDU_CLS