octet.cpp

SNMP++程序源码 for ll .8snmp++2_8.tar.Z 嵌入式linux环境下的SNMP开发代码

/*===================================================================

  Copyright (c) 1999
  Hewlett-Packard Company

  ATTENTION: USE OF THIS SOFTWARE IS SUBJECT TO THE FOLLOWING TERMS.
  Permission to use, copy, modify, distribute and/or sell this software 
  and/or its documentation is hereby granted without fee. User agrees 
  to display the above copyright notice and this license notice in all 
  copies of the software and any documentation of the software. User 
  agrees to assume all liability for the use of the software; Hewlett-Packard 
  makes no representations about the suitability of this software for any 
  purpose. It is provided "AS-IS without warranty of any kind,either express 
  or implied. User hereby grants a royalty-free license to any and all 
  derivatives based upon this software code base. 



  O C T E T . C P P

  OCTETSTR CLASS IMPLEMENTATION

  VERSION:
  2.8

  DESIGN:
  Peter E Mellquist

  AUTHOR:
  Peter E Mellquist

  LANGUAGE:
  ANSI C++

  OPERATING SYSTEMS:
  MS-WINDOWS Win32
  BSD UNIX

  DESCRIPTION:
  This class is fully contained and does not rely on or any other
  SNMP libraries. This class is portable across any platform
  which supports C++.


=====================================================================*/
char octet_cpp_version[]="@(#)SNMP++ 2.8 $Header: octet.cpp,v 1.18 96/09/11 14:01:57 hmgr Exp $";

#include "octet.h"    // include definition for octet class
#include <ctype.h>    // for isprint() used by get_printable()
#include <stdio.h>    // for sprintf() used by get_printable_hex()


//============[ syntax type ]=========================================
SmiUINT32 OctetStr::get_syntax()
{ return sNMP_SYNTAX_OCTETS; };

//============[ constructor using no arguments ]======================
OctetStr::OctetStr( void): 
  output_buffer(NULL), validity(TRUE)
{
  smival.syntax = sNMP_SYNTAX_OCTETS;
  smival.value.string.ptr = 0;
  smival.value.string.len = 0;
};

//============[ constructor using a  string ]=========================
OctetStr::OctetStr( const char  * string):
  output_buffer(NULL), validity(TRUE)
{
  smival.syntax = sNMP_SYNTAX_OCTETS;
  smival.value.string.ptr = 0;
  smival.value.string.len = 0;

  size_t z;

  // check for null string
  if ( !string || !(z = (size_t) STRLEN( string)))
  {
    return;
  }

  // get mem needed
  smival.value.string.ptr = (SmiLPBYTE) new  unsigned char [z];
  // if new was a success, then fil it up
  if ( smival.value.string.ptr != 0)
  {
    MEMCPY( smival.value.string.ptr, string, (size_t) z);	
    smival.value.string.len = z;
  }
  else
    validity = FALSE;
};


//============[ constructor using an unsigned char * ]================
OctetStr::OctetStr( const unsigned char  * string, unsigned long int size): 
  output_buffer(NULL), validity(TRUE)
{
  smival.syntax = sNMP_SYNTAX_OCTETS;
  smival.value.string.ptr = 0;
  smival.value.string.len = 0;

  // check for zero len
  if ( !string || !size)
  {
    return;
  }

  // get the mem needed
  smival.value.string.ptr = (SmiLPBYTE) new  unsigned char [ size];
  // if successful then fill it up
  if ( smival.value.string.ptr != 0)
  {
    MEMCPY( smival.value.string.ptr, string, (size_t) size);
    smival.value.string.len = size;
  }
  else
    validity = FALSE;
};

//============[ set the data on an already constructed Octet ]============
void OctetStr::set_data( const unsigned char  * string,
			             unsigned long int size)
{
  // free up already used space
  if ( smival.value.string.ptr )
  {
    delete [] smival.value.string.ptr;
    smival.value.string.ptr = NULL;
  }
  smival.value.string.len = 0;

  // check for zero len
  if ( !string || !size)
  {
    validity = TRUE;
    return;
  }

  // get the mem needed
  smival.value.string.ptr = (SmiLPBYTE) new  unsigned char [ size];
  // if successful then fill it up
  if ( smival.value.string.ptr != 0)
  {
    MEMCPY( smival.value.string.ptr, string, (size_t) size);  
    smival.value.string.len = size;
    validity = TRUE;
  }
  else
    validity = FALSE;
};

//============[ constructor using another octet object ]==============
OctetStr::OctetStr ( const OctetStr &octet): 
  output_buffer(NULL), validity(TRUE)
{
  smival.syntax = sNMP_SYNTAX_OCTETS;
  smival.value.string.ptr = 0;
  smival.value.string.len = 0;

   // check for zero len case
   if ( octet.smival.value.string.len == 0)
   {
      return;
   }

   // must be a valid object
   if ( !octet.validity)
   {
      validity = FALSE;
      return;
   }

   // get the mem needed
   smival.value.string.ptr = (SmiLPBYTE) new  unsigned char [ octet.smival.value.string.len];
   // if successful then fill it up
   if ( smival.value.string.ptr != 0)
   {
      MEMCPY( smival.value.string.ptr,		       
	          octet.smival.value.string.ptr,	   
	          (size_t) octet.smival.value.string.len);  
      smival.value.string.len = octet.smival.value.string.len;
   }
   else
     validity = FALSE;
};

//=============[ destructor ]=========================================
OctetStr::~OctetStr()
{
   // if not empty, free it up
   if ( smival.value.string.ptr )
      delete [] smival.value.string.ptr;
   if (output_buffer != NULL)
      delete [] output_buffer;
};


//=============[ assignment to a string operator overloaded ]=========
OctetStr& OctetStr::operator=( const char  *string)
{
   // get the string size
   size_t nz;

   // free up previous memory if needed
   if ( smival.value.string.ptr )
   {
     delete [] smival.value.string.ptr;
     smival.value.string.ptr = NULL;
     smival.value.string.len = 0;
   }
   
   // if empty then we are done
   if (!string || !(nz = (size_t) STRLEN( string)))
   {
     validity = TRUE;
     return *this;
   }

   // get memory needed
   smival.value.string.ptr = (SmiLPBYTE) new  unsigned char [ nz];
   // if not null, fill it up
   if ( smival.value.string.ptr != 0)
   {
      MEMCPY( smival.value.string.ptr,	      	// dest
	          string,	      		// source
	          (size_t) nz);   		// size
      smival.value.string.len = nz;
      validity = TRUE;
   }
   else
     validity = FALSE;

   return *this;	     // return self reference
};

//=============[ assignment to another oid object overloaded ]========
OctetStr& OctetStr::operator=( const OctetStr &octet)
{
   // protect against assignment from self
   if ( this == &octet )
       return *this;

   // don't assign from invalid objs
   if (!octet.validity)
   {
     return *this;
   }

   // free up previous memory if needed
   if ( smival.value.string.len )
   {
     delete [] smival.value.string.ptr;
     smival.value.string.ptr = NULL;
     smival.value.string.len = 0;
   }

   if (!octet.smival.value.string.len)
   {
     validity = TRUE;
     return *this;
   }

   // get some new memory
   smival.value.string.ptr = (SmiLPBYTE) new  unsigned char [ octet.smival.value.string.len];
   // if not null, fill it up
   if ( smival.value.string.ptr != 0)
   {
      MEMCPY( smival.value.string.ptr, 
	      octet.smival.value.string.ptr,	          
	      (size_t) octet.smival.value.string.len);      
      smival.value.string.len = octet.smival.value.string.len;
      validity = TRUE;
   }
   else
     validity = FALSE;

   return *this;		       // return self reference
};

//==============[ equivlence operator overloaded ]====================
int operator==( const OctetStr &lhs, const OctetStr &rhs)
{
   if( lhs.nCompare( rhs.smival.value.string.len, rhs)==0) return TRUE; else return FALSE;
};

//==============[ not equivlence operator overloaded ]================
int operator!=( const OctetStr &lhs, const OctetStr &rhs)
{
   if( lhs.nCompare( rhs.smival.value.string.len, rhs)!=0) return TRUE; else return FALSE;
};

//==============[ less than < overloaded ]============================
int operator<( const OctetStr &lhs, const OctetStr &rhs)
{
   if( lhs.nCompare( rhs.smival.value.string.len, rhs)<0) 
      return TRUE; 
   else 
      return FALSE;
};

//==============[ less than <= overloaded ]===========================
int operator<=( const OctetStr &lhs, const OctetStr &rhs)
{
   if(( lhs.nCompare( rhs.smival.value.string.len, rhs)<0) ||
      ( lhs.nCompare( rhs.smival.value.string.len, rhs)==0))
      return TRUE;
   else
      return FALSE;
};

//===============[ greater than > overloaded ]========================
int operator>( const OctetStr &lhs, const OctetStr &rhs)
{
  if( lhs.nCompare( rhs.smival.value.string.len, rhs)>0) 
      return TRUE; 
  else 
      return FALSE;
};

//===============[ greater than >= overloaded ]=======================
int operator>=( const OctetStr &lhs, const OctetStr &rhs)
{
  if(( lhs.nCompare( rhs.smival.value.string.len, rhs)>0) ||
     ( lhs.nCompare( rhs.smival.value.string.len, rhs)==0))
     return TRUE;
  else
     return FALSE;
};

//===============[ equivlence operator overloaded ]===================
int operator==( const OctetStr &lhs,const char  *rhs)
{
   OctetStr to( rhs);
   if( lhs.nCompare( to.smival.value.string.len,to)==0) 
       return TRUE; 
   else 
       return FALSE;
};

//===============[ not equivlence operator overloaded ]===============
int operator!=( const OctetStr &lhs,const char  *rhs)
{
   OctetStr to( rhs);