address.cpp

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

// using the currently defined address, do a DNS
// and try to fill up the name
int IpAddress::addr_to_friendly()
{
    IN_ADDR ipAddr;
    hostent *lookupResult;
    char    *namePtr = NULL;
    char    ds[30];

    // can't look up an invalid address
    if ( !valid_flag) return -1;

    // otherwise lets look it up
    // lets try and get the friendly name
    // from the DNS
    strcpy( ds, this->IpAddress::get_printable());

    if ((ipAddr.s_addr = inet_addr((char *) ds)) == -1)
      return -1;    // bad address

    lookupResult = gethostbyaddr((char *) &ipAddr, sizeof(in_addr), AF_INET);

    // if we found the name, then update the
    // iv friendly name
    if ( lookupResult)
    {
      namePtr = lookupResult->h_name;
      strcpy( iv_friendly_name, namePtr);
      return 0;
    }
    else
    {
      iv_friendly_name_status = h_errno;
      return iv_friendly_name_status;
    }

};

//----[ IP address char * cast ]--------------------------------------
IpAddress::operator const char *() const
{
  return (char *)output_buffer;
}
//----[ IP address get char representation ]--------------------------
char * WINFAR IpAddress::get_printable()
{
  return (char *)output_buffer;
}

//----[ IP address format output ]------------------------------------
void IpAddress::format_output()
{
  // if valid format else null it
  if ( valid_flag)
    sprintf( (char *) output_buffer,"%d.%d.%d.%d",address_buffer[0],
	     address_buffer[1], address_buffer[2], address_buffer[3]);
  else
    output_buffer[0]=0;
};

//------[ return the type ]----------------------------------
addr_type IpAddress::get_type()	const
{ return type_ip; };

//-----------------------------------------------------------------
// logically and two IPaddresses and
// return the new one
void IpAddress::mask( const IpAddress& ipaddr)
{ 
  if ( this->valid() && ipaddr.valid())
  {
     this->address_buffer[0] = this->address_buffer[0] & ipaddr.address_buffer[0];
     this->address_buffer[1] = this->address_buffer[1] & ipaddr.address_buffer[1];
     this->address_buffer[2] = this->address_buffer[2] & ipaddr.address_buffer[2];
     this->address_buffer[3] = this->address_buffer[3] & ipaddr.address_buffer[3];
     format_output();
  };
 
};


//=======================================================================
//========== Udp Address Implementation =================================
//=======================================================================

//-----------[ syntax type ]----------------------------------------------
SmiUINT32 UdpAddress::get_syntax()
{ return sNMP_SYNTAX_OCTETS; };

//-------[ construct an IP address with no agrs ]----------------------
UdpAddress::UdpAddress( void):IpAddress()
{ 
  // Inherits IP Address attributes
  // Always initialize (override) what type this object is
  smival.syntax = sNMP_SYNTAX_OCTETS;
  smival.value.string.len = UDPIPLEN;
  smival.value.string.ptr = address_buffer;

  set_port(0);
  format_output();
};

//-----------------[ construct an Udp address with another Udp address ]---
UdpAddress::UdpAddress( const UdpAddress  &udpaddr):IpAddress(udpaddr)
{
  // always initialize SMI info
  smival.syntax = sNMP_SYNTAX_OCTETS;
  smival.value.string.len = UDPIPLEN;
  smival.value.string.ptr = address_buffer;

  // Copy the port value
  set_port(udpaddr.get_port());
  format_output();
};

// constructor with a dotted string
UdpAddress::UdpAddress( const char *inaddr):IpAddress()
{
  // always initialize SMI info
  smival.syntax = sNMP_SYNTAX_OCTETS;
  smival.value.string.len = UDPIPLEN;
  smival.value.string.ptr = address_buffer;

   valid_flag = parse_address( (char *)inaddr); 
   format_output();
}

//-----------------[ construct a UdpAddress from a GenAddress ]--------------
UdpAddress::UdpAddress( const GenAddress &genaddr):IpAddress()
{
  // always initialize SMI info
  smival.syntax = sNMP_SYNTAX_OCTETS;
  smival.value.string.len = UDPIPLEN;
  smival.value.string.ptr = address_buffer;

  unsigned int port = 0;
  valid_flag = FALSE;

  // allow use of an ip or udp genaddress
  if (genaddr.get_type() == type_udp)
  {
    valid_flag = genaddr.valid();
    if ( valid_flag)
    {
      // copy in the IP address data
      UdpAddress temp_udp( (const char *) genaddr);
      *this = temp_udp;

      //  port info since are making an UpAddress
      port = temp_udp.get_port();
    }
  }
  else
  if (genaddr.get_type() == type_ip)
  {
    valid_flag = genaddr.valid();
    if ( valid_flag)
    {
      // copy in the IP address data
      IpAddress temp_ip( (const char *) genaddr);
      *this = temp_ip;
    }
  }
  set_port(port);
  format_output();
};


//--------[ construct a udp from an IpAddress ]--------------------------
UdpAddress::UdpAddress( const IpAddress &ipaddr):IpAddress(ipaddr)
{
  // always initialize SMI info
  smival.syntax = sNMP_SYNTAX_OCTETS;
  smival.value.string.len = UDPIPLEN;
  smival.value.string.ptr = address_buffer;

  set_port(0);
  format_output();
};


//-----[ destructor ]--------------------------------------------------
UdpAddress::~UdpAddress()
{};


  // copy an instance of this Value
SnmpSyntax& UdpAddress::operator=( SnmpSyntax &val)
{
  // protect against assignment from itself
  if ( this == &val )
      return *this;

  valid_flag=0;		// will get set TRUE if really valid
  if (val.valid()){
    switch (val.get_syntax()){
    case sNMP_SYNTAX_IPADDR: 
    {
      UdpAddress temp_udp(val.get_printable());
      *this = temp_udp;	// valid_flag is set by the udp assignment
    }
    break;

    case sNMP_SYNTAX_OCTETS:
      if (((UdpAddress &)val).smival.value.string.len == UDPIPLEN){
         MEMCPY(address_buffer,((UdpAddress &)val).smival.value.string.ptr,UDPIPLEN);
         iv_friendly_name[0]=0;
         valid_flag=1;
      }
    break;

    // NOTE: as a value add, other types could have "logical"
    // mappings, i.e. integer32 and unsigned32 
    }
  }
  format_output();
  return *this;
}

  // assignment to another UdpAddress object overloaded
UdpAddress& UdpAddress::operator=( const UdpAddress &udpaddr)
{
  // protect against assignment from itself
  if ( this == &udpaddr )
      return *this;

  (IpAddress &)*this = udpaddr; // use ancestor assignment for ipaddr value
  set_port(udpaddr.get_port());	// copy to port value
  format_output();
  return *this;
}


//-----[ IP Address parse Address ]---------------------------------
int UdpAddress::parse_address( const char *inaddr)
{
   char buffer[MAX_FRIENDLY_NAME];

   unsigned short port = 0;
   if (inaddr && (strlen( inaddr)< MAX_FRIENDLY_NAME))
     strcpy( buffer, inaddr);
   else
   {
     valid_flag = FALSE;
     return FALSE;
   }
   // look for port info @ the end of the string
   // port can be delineated by a ':' or a '/'
   // if neither are present then just treat it 
   // like a normal IpAddress
   char *tmp;
   tmp = strstr( buffer,":");
   if (tmp==NULL) 
     tmp = strstr(buffer,"/");

   if ( tmp != NULL)
   {
     *tmp=0;   // new null terminator
     tmp++;
     port = atoi( tmp);
	 set_port( port);
     return IpAddress::parse_address( buffer);
   }
   else
   {
       port = 0;
	   set_port( port);
	   return IpAddress::parse_address ( buffer);
   }
};


//----------[ create a new instance of this Value ]------------------------
SnmpSyntax WINFAR *UdpAddress::clone() const 
{ return (SnmpSyntax *) new UdpAddress(*this); };

//--------[ set the port number ]---------------------------------------
void UdpAddress::set_port( const unsigned short p)
{ 
  unsigned short port_nbo = htons(p);
  MEMCPY(&address_buffer[IPLEN], &port_nbo, 2);
  format_output();
};

//---------[ get the port number ]--------------------------------------
unsigned short UdpAddress::get_port() const
{ 
  if (valid_flag) 
  {
    unsigned short port_nbo;
    MEMCPY(&port_nbo, &address_buffer[IPLEN], 2);
    return ntohs(port_nbo); 
  }
  else
    return 0;// don't use uninitialized memory
};

//------[ return the type ]--------------------------------------------
addr_type UdpAddress::get_type() const
{ return type_udp; };

//----[ UDP address char * cast ]--------------------------------------
UdpAddress::operator const char *() const
{
  return (char *)output_buffer;
}
//----[ UDP address get char representation ]--------------------------
char * WINFAR UdpAddress::get_printable()
{
  return (char *)output_buffer;
}

//----[ UDP address format output ]------------------------------------
void UdpAddress::format_output()
{
  IpAddress::format_output(); // allow ancestors to format their buffers

  // if valid format else null it
  if ( valid_flag)
    sprintf( (char *) output_buffer,"%s/%d",
	     IpAddress::get_printable(), 
	     get_port() );
  else
    output_buffer[0]=0;
};



//=======================================================================
//=========== IPX Address Implementation ================================
//=======================================================================

//-----------[ syntax type ]----------------------------------------------
SmiUINT32 IpxAddress::get_syntax()
{ return sNMP_SYNTAX_OCTETS; };

//----------[ constructor no args ]--------------------------------------
IpxAddress::IpxAddress( void):Address()
{
  // always initialize SMI info
  smival.syntax = sNMP_SYNTAX_OCTETS;
  smival.value.string.len = IPXLEN;
  smival.value.string.ptr = address_buffer;

  separator = '\0'; 
  valid_flag=FALSE;
  IpxAddress::format_output();
};


//----------[ constructor with a string arg ]---------------------------
IpxAddress::IpxAddress( const char  *inaddr):Address( )
{ 
  // always initialize SMI info
  smival.syntax = sNMP_SYNTAX_OCTETS;
  smival.value.string.len = IPXLEN;
  smival.value.string.ptr = address_buffer;

  separator = '\0';
  valid_flag = parse_address( (char *) inaddr); 
  IpxAddress::format_output();
};


//-----[ IPX Address copy constructor ]----------------------------------
IpxAddress::IpxAddress(const IpxAddress &ipxaddr)
{
  // always initialize SMI info
  smival.syntax = sNMP_SYNTAX_OCTETS;
  smival.value.string.len = IPXLEN;
  smival.value.string.ptr = address_buffer;

  separator = '\0';
  valid_flag = ipxaddr.valid_flag;
  if (valid_flag)
     MEMCPY(address_buffer, ipxaddr.address_buffer, IPXLEN);
  IpxAddress::format_output();
};


//----[ construct an IpxAddress from a GenAddress ]---------------------------
IpxAddress::IpxAddress( const GenAddress &genaddr)
{
  // always initialize SMI info
  smival.syntax = sNMP_SYNTAX_OCTETS;
  smival.value.string.len = IPXLEN;
  smival.value.string.ptr = address_buffer;

  valid_flag = FALSE;
  // allow use of an ipx or ipxsock address
  if ( (genaddr.get_type() == type_ipx) )
  {
    valid_flag = genaddr.valid();
    if ( valid_flag)
    {
      // copy in the Ipx address data
      IpxAddress temp_ipx( (const char *) genaddr);
      *this = temp_ipx;
    }
  }
  else
  if ( (genaddr.get_type() == type_ipxsock) )
  {
    valid_flag = genaddr.valid();
    if ( valid_flag)
    {
      // copy in the Ipx address data
      IpxSockAddress temp_ipxsock( (const char *) genaddr);
      *this = temp_ipxsock;
    }
  }
  IpxAddress::format_output();
};


//-----[ destructor ]--------------------------------------------------
IpxAddress::~IpxAddress()
{};


//-----[ IPX Address general = operator ]-------------------------------
SnmpSyntax& IpxAddress::operator=( SnmpSyntax &val)
{
  // protect against assignment from itself
  if ( this == &val )
      return *this;

  valid_flag=0;      	// will set to TRUE if really valid
  if (val.valid()){
    switch (val.get_syntax()){
    case sNMP_SYNTAX_OCTETS: 
      if (((IpxAddress &)val).smival.value.string.len == IPXLEN){
	MEMCPY(address_buffer, ((IpxAddress &)val).smival.value.string.ptr, IPXLEN);
	valid_flag=1;
      }
    break;
    }
  }
  IpxAddress::format_output();
  return *this;
};

//--------[ assignment to another IpAddress object overloaded ]----------
IpxAddress& IpxAddress::operator=( const IpxAddress &ipxaddress)
{
  // protect against assignment from itself
  if ( this == &ipxaddress )
      return *this;

  valid_flag = ipxaddress.valid_flag; 
  if (valid_flag)
    MEMCPY(address_buffer, ipxaddress.address_buffer, IPXLEN);
  IpxAddress::format_output();
  return *this;
};


// create a new instance of this Value
SnmpSyntax WINFAR *IpxAddress::clone() const 
{ return (SnmpSyntax *) new IpxAddress(*this); };

//-----[ IPX Address parse Address ]-----------------------------------
// Convert a string to a ten byte ipx address
// On success sets validity  TRUE or FALSE
//
//     IPX address format
//
//  NETWORK ID| MAC ADDRESS
// 01 02 03 04|05 06 07 08 09 10
// XX XX XX XX|XX XX XX XX XX XX
//
//   Valid input format
//
//   XXXXXXXX.XXXXXXXXXXXX
//   Total length must be 21
//   Must have a separator in it
//   First string length must be 8
//   Second string length must be 12
//   Each char must take on value 0-F
//
//
// Input formats recognized
// 
//  XXXXXXXX.XXXXXXXXXXXX
//  XXXXXXXX:XXXXXXXXXXXX
//  XXXXXXXX-XXXXXXXXXXXX
//  XXXXXXXX.XXXXXX-XXXXXX
//  XXXXXXXX:XXXXXX-XXXXXX
//  XXXXXXXX-XXXXXX-XXXXXX
int IpxAddress::parse_address( const char *inaddr)
{
  char unsigned *str1,*str2;
  char temp[30];    // don't destroy original
  char unsigned *tmp;
  size_t z, tmplen;


  // save the orginal source
  if (!inaddr || (strlen( inaddr) >(sizeof(temp)-1))) return FALSE;
  strcpy( temp, inaddr);
  trim_white_space( temp);
  tmplen = strlen(temp);

  // bad total length check