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

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.   
  15.   P D U . C P P
  16.   PDU CLASS IMPLEMENTATION
  17.   VERSION:
  18.   2.8
  19.   DESIGN:
  20.   Peter E Mellquist
  21.   AUTHOR:
  22.   Peter E Mellquist
  23.   LANGUAGE:
  24.   ANSI C++
  25.   OPERATING SYSTEMS:
  26.   MS-Windows Win32
  27.   BSD UNIX
  28.   DESCRIPTION:
  29.   Pdu class implementation. Encapsulation of an SMI Protocol
  30.   Data Unit (PDU) in C++.
  31. =====================================================================*/
  32. char pdu_cpp_version[]="#(@)SNMP++ 2.8 $Header: pdu.cpp,v 1.14 96/03/07 08:14:52 hmgr Exp $";
  33. #include "pdu.h"       // include Pdu class definition
  34. //=====================[ constructor no args ]=========================
  35. Pdu::Pdu( void)
  36. {
  37.    // init all instance vars to null and invalid
  38.    vb_count = 0;
  39.    pdu_type = 0;
  40.    validity = TRUE;
  41.    error_status = 0;
  42.    error_index = 0;
  43.    request_id = 0;
  44.    notify_timestamp = 0;
  45. };
  46. //=====================[ constructor with vbs and count ]==============
  47. Pdu::Pdu( Vb* pvbs, const int pvb_count)
  48. {
  49.    int z;  // looping variable
  50.    // Initialize all mv's
  51.    vb_count = 0;
  52.    pdu_type = 0;
  53.    error_status = 0;
  54.    error_index = 0;
  55.    request_id = 0;
  56.    notify_timestamp = 0;
  57.    // zero is ok
  58.    if ( pvb_count == 0) 
  59.    {
  60.       validity = TRUE;
  61.       return;
  62.    }
  63.    // check for over then max
  64.    if ( pvb_count > MAX_VBS) 
  65.    {
  66.        validity = FALSE;
  67.        return;
  68.    }
  69.    // loop through and assign internal vbs
  70.    for (z=0;z<pvb_count;z++) 
  71.    {
  72.      vbs[z] = new Vb( pvbs[z]);
  73.      // check for new fail
  74.      if ( vbs[z] == 0) 
  75.      {
  76.         validity = FALSE;
  77.         return;
  78.      }
  79.    }
  80.    // assign the vb count
  81.    vb_count = pvb_count;
  82.    validity = TRUE;
  83.    return;
  84. };
  85. //=====================[ constructor with another Pdu instance ]========
  86. Pdu::Pdu( const Pdu &pdu)
  87. {
  88.    vb_count = 0;
  89.    *this = pdu;
  90.    return;
  91. };
  92. //=====================[ destructor ]====================================
  93. Pdu::~Pdu()
  94. {
  95.   for ( int z=0;z<vb_count;z++)
  96.      delete vbs[z];
  97. };
  98. //=====================[ assignment to another Pdu object overloaded ]===
  99. Pdu& Pdu::operator=( const Pdu &pdu)
  100. {
  101.    int z;   // looping variable
  102.    // Initialize all mv's
  103.    error_status = pdu.error_status;
  104.    error_index = pdu.error_index;
  105.    request_id = pdu.request_id;
  106.    pdu_type = pdu.pdu_type;
  107.    notify_id = pdu.notify_id;
  108.    notify_timestamp = pdu.notify_timestamp;
  109.    notify_enterprise = pdu.notify_enterprise;
  110.    validity = TRUE;
  111.    // free up old vbs
  112.    for ( z=0;z<vb_count;z++)
  113.      delete vbs[z];
  114.    vb_count = 0;
  115.    // check for zero case
  116.    if ( pdu.vb_count == 0)
  117.    {
  118.       return *this;
  119.    }
  120.    // loop through and fill em up
  121.    for (z=0;z<pdu.vb_count;z++)
  122.    {
  123.      vbs[z] = new Vb ( *(pdu.vbs[z]));
  124.      // new failure
  125.      if ( vbs[z] == 0)
  126.      {
  127.         validity = FALSE;
  128.         return *this;
  129.      }
  130.    }
  131.    vb_count = pdu.vb_count;
  132.    return *this;
  133. };
  134. // append operator, appends a string
  135. Pdu& Pdu::operator+=( Vb &vb)
  136. {
  137.   // do we have room?
  138.   if ( vb_count+1> MAX_VBS)
  139.     return *this;      
  140.   // add the new one
  141.   vbs[vb_count] = new Vb (vb);
  142.   // up the vb count
  143.   vb_count++;
  144.   // set up validity
  145.   validity = TRUE;
  146.   // return self reference
  147.   return *this;
  148. };
  149. //=====================[ extract Vbs from Pdu ]==========================
  150. // how do you know that the caler has enough memory???
  151. // should I self allocate this in here and require the
  152. // caller then to free it up at soem later time
  153. int Pdu::get_vblist( Vb* pvbs, const int pvb_count)
  154. {
  155.    if ((!pvbs) || ( pvb_count < 0) || ( pvb_count > vb_count))
  156.       return FALSE;
  157.    // loop through all vbs and assign to params
  158.    for (int z=0;z<pvb_count;z++)
  159.       pvbs[z] = *vbs[z];
  160.    return TRUE;
  161. };
  162. //=====================[ deposit Vbs ]===================================
  163. int Pdu::set_vblist( Vb* pvbs, const int pvb_count)
  164. {
  165.    int z;
  166.    // if invalid then don't destroy
  167.    if ((!pvbs) || ( pvb_count < 0) || ( pvb_count > MAX_VBS))
  168.      return FALSE;
  169.    // free up current vbs
  170.    for ( z=0;z<vb_count;z++)
  171.      delete vbs[z];
  172.    vb_count = 0;
  173.    // check for zero case
  174.    if ( pvb_count == 0)
  175.    {  
  176.       validity = TRUE;
  177.       error_status = 0;
  178.       error_index = 0;
  179.       request_id = 0;
  180.       return FALSE;
  181.    }
  182.      
  183.    // loop through all vbs and reassign them
  184.    for ( z=0;z<pvb_count;z++)
  185.    {
  186.      vbs[z] = new Vb (pvbs[z]);
  187.      // check for new fail
  188.      if ( vbs[z] == 0)
  189.      {
  190.          validity = FALSE;
  191.          return FALSE;
  192.      }
  193.    }
  194.    
  195.    vb_count = pvb_count;
  196.    // clear error status and index since no longer valid
  197.    // request id may still apply so don't reassign it
  198.    error_status = 0;
  199.    error_index = 0;
  200.    validity = TRUE;
  201.    return TRUE;
  202. };
  203. //===================[ get a particular vb ]=============================
  204. // here the caller has already instantiated a vb object
  205. // index is zero based
  206. int Pdu::get_vb( Vb &vb, const int index) const
  207. {
  208.    // can't have an index less than 0
  209.    if ( index < 0) 
  210.      return FALSE;
  211.    // can't ask for something not there
  212.    if ( index > (vb_count-1))
  213.       return FALSE;
  214.    // asssign it
  215.    vb = *vbs[index];
  216.    return TRUE;
  217. };
  218. //===================[ set a particular vb ]=============================
  219. int Pdu::set_vb( Vb &vb, const int index)
  220. {
  221.    // can't set a vb at index less than 0
  222.    if ( index < 0)
  223.      return FALSE;
  224.    // can't ask for something not there
  225.    if ( index > (vb_count-1))
  226.       return FALSE;
  227.    // delete what is there
  228.    delete vbs[index];
  229.    // assign it
  230.    vbs[index] = new Vb (vb);
  231.    return TRUE;
  232. };
  233. //=====================[ return number of vbs ]==========================
  234. int Pdu::get_vb_count() const
  235. {
  236.    return vb_count;
  237. };
  238. //=====================[ return the error status ]=======================
  239. int Pdu::get_error_status()
  240. {
  241.    return error_status;
  242. };
  243. //=====================[ set the error status ]==========================
  244. // friend
  245. void set_error_status( Pdu *pdu, const int status)
  246. {
  247.    if (pdu)
  248.      pdu->error_status = status;
  249. };
  250. //=====================[ return the error index ]========================
  251. int Pdu::get_error_index()
  252. {
  253.    return error_index;
  254. };
  255. //=====================[ set the error index ]===========================
  256. // friend
  257. void set_error_index( Pdu *pdu, const int index)
  258. {
  259.    if (pdu)
  260.      pdu->error_index = index;
  261. };
  262. //=====================[ clear error status ]=============================
  263. void clear_error_status( Pdu *pdu)
  264. {
  265.    if (pdu)
  266.      pdu->error_status = 0;
  267. };
  268. //=====================[ clear error index ]==============================
  269. void clear_error_index( Pdu *pdu)
  270. {
  271.    if (pdu)
  272.      pdu->error_index = 0;
  273. };
  274. //=====================[ return the request id ]==========================
  275. unsigned long Pdu::get_request_id()
  276. {
  277.    return request_id;
  278. };
  279. //=====================[ set the request id ]=============================
  280. // friend function
  281. void set_request_id( Pdu *pdu, const unsigned long rid)
  282. {
  283.    if (pdu)
  284.      pdu->request_id = rid;
  285. };
  286. //=====================[ returns validity of Pdu instance ]===============
  287. int Pdu::valid() const 
  288. {
  289.    return validity;
  290. };
  291. //=====================[ get the pdu type ]===============================
  292. unsigned short Pdu::get_type()
  293. {
  294.    return pdu_type;
  295. };
  296. // set the pdu type
  297. void Pdu::set_type( unsigned short type)
  298. {
  299.    pdu_type = type;
  300. };
  301. // trim off the last vb
  302. int Pdu::trim(const int p)
  303. {
  304.    int lp = p;
  305.    // verify that lp is legal
  306.    if ( lp < 0 || lp > vb_count)
  307.      return FALSE;
  308.    while ( lp !=0)   
  309.    {
  310.      if ( vb_count > 0)
  311.      {
  312.          delete vbs[vb_count-1];
  313.          vb_count--;
  314.      }
  315.      lp--;
  316.    }
  317.    return TRUE;
  318. };
  319. // delete a Vb anywhere within the Pdu
  320. int Pdu::delete_vb( const int p)
  321. {
  322.    // position has to be in range
  323.    if (( p<0) || (p>(vb_count-1)))
  324.       return FALSE;
  325.    // safe to remove it
  326.    delete vbs[ p];
  327.    for ( int z=p;z < (vb_count-1);z++)
  328.    {
  329.       vbs[z] = vbs[z+1];
  330.    }  
  331.    vb_count--;
  332.    return TRUE;
  333. };
  334. // set notify timestamp
  335. void Pdu::set_notify_timestamp( const TimeTicks & timestamp)
  336. {
  337.    notify_timestamp = timestamp;
  338. };
  339. // get notify timestamp
  340. void Pdu::get_notify_timestamp( TimeTicks & timestamp)
  341. {
  342.     timestamp = notify_timestamp;
  343. };
  344. // set the notify id
  345. void Pdu::set_notify_id( const Oid id)
  346. {
  347.     notify_id = id;
  348. };
  349. // get the notify id
  350. void Pdu::get_notify_id( Oid &id)
  351. {
  352.    id = notify_id;
  353. };
  354. // set the notify enterprise
  355. void Pdu::set_notify_enterprise( const Oid &enterprise)
  356. {
  357.    notify_enterprise = enterprise;
  358. };
  359. // get the notify enterprise
  360. void Pdu::get_notify_enterprise( Oid & enterprise)
  361. {
  362.     enterprise = notify_enterprise;
  363. };