octet.cpp

来自「JdonFramework need above jdk 1.4.0 This」· C++ 代码 · 共 846 行 · 第 1/2 页

/*_############################################################################
  _## 
  _##  octet.cpp  
  _##
  _##  SNMP++v3.2.21a
  _##  -----------------------------------------------
  _##  Copyright (c) 2001-2006 Jochen Katz, Frank Fock
  _##
  _##  This software is based on SNMP++2.6 from Hewlett Packard:
  _##  
  _##    Copyright (c) 1996
  _##    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 and Jochen Katz make 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. 
  _##  
  _##  Stuttgart, Germany, Tue Nov 21 22:12:16 CET 2006 
  _##  
  _##########################################################################*/
/*===================================================================

  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

  DESIGN + AUTHOR:  Peter E Mellquist

  LANGUAGE:         ANSI C++

  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++ $Id: octet.cpp,v 1.12 2006/03/25 11:46:19 katz Exp $";

#include "snmp_pp/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()
#include <string.h>   // for strlen() and memcpy()

#ifdef SNMP_PP_NAMESPACE
namespace Snmp_pp {
#endif

enum OctetStr::OutputType OctetStr::hex_output_type
                                               = OctetStr::OutputHexAndClear;
char OctetStr::nonprintable_char = '.';

#ifdef __unix
    char OctetStr::linefeed_chars[3] = "\n";
#else
    char OctetStr::linefeed_chars[3] = "\r\n";
#endif // __unix


//============[ constructor using no arguments ]======================
OctetStr::OctetStr()
  : output_buffer(0), output_buffer_len(0), m_changed(true), 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 *str)
  : output_buffer(0), output_buffer_len(0), m_changed(true), 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 (!str || !(z = strlen(str)))
    return;

  // get mem needed
  smival.value.string.ptr = (SmiLPBYTE) new unsigned char[z];

  if (smival.value.string.ptr)
  {
    MEMCPY(smival.value.string.ptr, str, z);
    smival.value.string.len = SAFE_INT_CAST(z);
  }
  else
    validity = false;
}


//============[ constructor using an unsigned char * ]================
OctetStr::OctetStr(const unsigned char *str, unsigned long len)
  : output_buffer(0), output_buffer_len(0), m_changed(true), validity(true)
{
  smival.syntax = sNMP_SYNTAX_OCTETS;
  smival.value.string.ptr = 0;
  smival.value.string.len = 0;

  if (!str || !len)  return;   // check for zero len

  // get the mem needed
  smival.value.string.ptr = (SmiLPBYTE) new unsigned char[len];

  if (smival.value.string.ptr)
  {
    MEMCPY(smival.value.string.ptr, str, (size_t) len);
    smival.value.string.len = len;
  }
  else
    validity = false;
}

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

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

  // 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 (smival.value.string.ptr)
  {
    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;
  smival.value.string.len = 0;
  smival.value.string.ptr = 0;
  if (output_buffer)           delete [] output_buffer;
  output_buffer = 0;
  output_buffer_len = 0;
}


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

  // check for zero len
  if (!str || !len)
  {
    validity = true;
    return;
  }

  // get the mem needed
  smival.value.string.ptr = (SmiLPBYTE) new unsigned char[len];

  if (smival.value.string.ptr)
  {
    MEMCPY(smival.value.string.ptr, str, len);
    smival.value.string.len = len;
    validity = true;
  }
  else
    validity = false;
}

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

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

  m_changed = true;

  // if empty then we are done; get the string size
  if (!str || !(nz = strlen(str)))
  {
    validity = true;
    return *this;
  }

  // get memory needed
  smival.value.string.ptr = (SmiLPBYTE) new unsigned char[nz];

  if (smival.value.string.ptr)
  {
    MEMCPY(smival.value.string.ptr, str, nz);
    smival.value.string.len = SAFE_INT_CAST(nz);
    validity = true;
  }
  else
    validity = false;

  return *this;	     // return self reference
}

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

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

  set_data(octet.smival.value.string.ptr, octet.smival.value.string.len);

  return *this;		       // return self reference
}

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

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

//==============[ less than < overloaded ]============================
int operator<(const OctetStr &lhs, const OctetStr &rhs)
{
  int maxlen = lhs.smival.value.string.len > rhs.smival.value.string.len
             ? lhs.smival.value.string.len : rhs.smival.value.string.len;
  return (lhs.nCompare(maxlen, rhs) < 0);
}

//==============[ less than <= overloaded ]===========================
int operator<=(const OctetStr &lhs, const OctetStr &rhs)
{
  int maxlen = lhs.smival.value.string.len > rhs.smival.value.string.len
             ? lhs.smival.value.string.len : rhs.smival.value.string.len;
  return (lhs.nCompare(maxlen, rhs) <= 0);
}

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

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

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

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

//===============[ less than < operator overloaded ]==================
int operator<(const OctetStr &lhs, const char *rhs)
{
  OctetStr to(rhs);
  int maxlen = lhs.smival.value.string.len > to.smival.value.string.len
             ? lhs.smival.value.string.len : to.smival.value.string.len;
  return (lhs.nCompare(maxlen,to) < 0);
}

//===============[ less than <= operator overloaded ]=================
int operator<=(const OctetStr &lhs, const char *rhs)
{
  OctetStr to(rhs);
  int maxlen = lhs.smival.value.string.len > to.smival.value.string.len
             ? lhs.smival.value.string.len : to.smival.value.string.len;
  return (lhs.nCompare(maxlen, to) <= 0);
}

//===============[ greater than > operator overloaded ]===============
int operator>(const OctetStr &lhs, const char *rhs)
{
  OctetStr to(rhs);
  int maxlen = lhs.smival.value.string.len > to.smival.value.string.len
             ? lhs.smival.value.string.len : to.smival.value.string.len;
  return (lhs.nCompare(maxlen, to) > 0);
}

//===============[ greater than >= operator overloaded ]==============
int operator>=(const OctetStr &lhs, const char *rhs)
{
  OctetStr to(rhs);
  int maxlen = lhs.smival.value.string.len > to.smival.value.string.len
             ? lhs.smival.value.string.len : to.smival.value.string.len;
  return (lhs.nCompare(maxlen, to) >= 0);
}

//===============[ append operator, appends a string ]================
OctetStr& OctetStr::operator+=(const char *a)
{
  unsigned char *tmp;
  size_t slen, nlen;

  // get len of string
  if (!a || ((slen = strlen(a)) == 0))
    return *this;

  nlen = slen + (size_t) smival.value.string.len;  // total len of new octet
  tmp = (SmiLPBYTE) new unsigned char[nlen];  // get mem needed

  if (tmp)
  {
    // copy in the original 1st
    MEMCPY(tmp, smival.value.string.ptr, smival.value.string.len);
    // copy in the string
    MEMCPY(tmp + smival.value.string.len, a, slen);
    // delete the original
    if (smival.value.string.ptr)
      delete [] smival.value.string.ptr;
    // point to the new one
    smival.value.string.ptr = tmp;
    smival.value.string.len = SAFE_INT_CAST(nlen);

    m_changed = true;
  }
  return *this;
}

//================[ append one OctetStr to another ]==================
OctetStr& OctetStr::operator+=(const OctetStr& octet)
{
  unsigned char *tmp;
  size_t slen, nlen;

  if (!octet.validity || !(slen = (size_t)octet.len()))
    return *this;

  nlen = slen + (size_t) smival.value.string.len;  // total len of new octet
  tmp = (SmiLPBYTE) new unsigned char[nlen];  // get mem needed

  if (tmp)
  {
    // copy in the original 1st
    MEMCPY(tmp, smival.value.string.ptr, smival.value.string.len);
    // copy in the string
    MEMCPY(tmp + smival.value.string.len, octet.data(), slen);
    // delete the original
    if (smival.value.string.ptr )
      delete [] smival.value.string.ptr;
    // point to the new one
    smival.value.string.ptr = tmp;
    smival.value.string.len = SAFE_INT_CAST(nlen);