address.cpp

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

   if (tmp != NULL)
   {
     *tmp=0;   // new null terminator
     tmp++;
     socketid = atoi(tmp);
   }
   set_socket(socketid);
   return IpxAddress::parse_address(buffer);
}



//-------------[ set the socket number ]----------------------------------
void IpxSockAddress::set_socket(const unsigned short s)
{
  unsigned short sock_nbo = htons(s);
  MEMCPY(&address_buffer[IPXLEN], &sock_nbo, 2);
  addr_changed = true;
}

//--------------[ get the socket number ]---------------------------------
unsigned short IpxSockAddress::get_socket() const
{
  if (valid_flag)
  {
    unsigned short sock_nbo;
    MEMCPY(&sock_nbo, &address_buffer[IPXLEN], 2);
    return ntohs(sock_nbo);
  }
  return 0; // don't use uninitialized memory
}
#endif // _IPX_ADDRESS

#ifdef _MAC_ADDRESS
//========================================================================
//======== MACAddress Implementation =====================================
//========================================================================

//--------[ constructor, no arguments ]-----------------------------------
MacAddress::MacAddress() : Address()
{
  // always initialize SMI info
  smival.syntax = sNMP_SYNTAX_OCTETS;
  smival.value.string.len = MACLEN;
  smival.value.string.ptr = address_buffer;

  valid_flag = false;
  addr_changed = true;
}

//-----[ MAC Address copy constructor ]---------------------------------
MacAddress::MacAddress(const MacAddress &macaddr)
{
  // always initialize SMI info
  smival.syntax = sNMP_SYNTAX_OCTETS;
  smival.value.string.len = MACLEN;
  smival.value.string.ptr = address_buffer;

  valid_flag = macaddr.valid_flag;
  if (valid_flag)
    MEMCPY(address_buffer, macaddr.address_buffer, MACLEN);
  addr_changed = true;
}

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

  valid_flag = parse_address(inaddr);
  addr_changed = true;
}

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

  valid_flag = false;
  // allow use of mac address
  if (genaddr.get_type() == type_mac)
  {
    valid_flag = genaddr.valid();
    if (valid_flag)
    {
      // copy in the Mac address data
      *this = genaddr.cast_macaddress();
    }
  }
  addr_changed = true;
}

//------[ assignment to another ipaddress object overloaded ]--------------
MacAddress& MacAddress::operator=(const MacAddress &macaddress)
{
  if (this == &macaddress) return *this;// protect against assignment from self

  valid_flag = macaddress.valid_flag;
  if (valid_flag)
    MEMCPY(address_buffer, macaddress.address_buffer, MACLEN);
  addr_changed = true;
  return *this;
}



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

  valid_flag = false;              // will set to TRUE if really valid
  if (val.valid())
  {
    switch (val.get_syntax())
    {
      case sNMP_SYNTAX_OCTETS:
	if (((MacAddress &)val).smival.value.string.len == MACLEN)
	{
	  MEMCPY(address_buffer, ((MacAddress &)val).smival.value.string.ptr,
		 MACLEN);
	  valid_flag = true;
	}
	break;
    }
  }
  addr_changed = true;
  return *this;
}

//-----[ MAC Address parse Address ]--------------------------------------
// Convert a string to a six byte MAC address
// On success sets validity TRUE or FALSE
//
//     MAC address format
//
//   MAC ADDRESS
//   01 02 03 04 05 06
//   XX:XX:XX:XX:XX:XX
//   Valid input format
//
//   XXXXXXXXXXXX
//   Total length must be 17
//   Each char must take on value 0-F
//
//
bool MacAddress::parse_address(const char *inaddr)
{
  char temp[30];    // don't destroy original
  char unsigned *tmp;
  size_t z;


  // save the orginal source
  if (!inaddr || (strlen(inaddr) > 30)) return FALSE;
  strcpy(temp, inaddr);
  trim_white_space(temp);

  // bad total length check
  if (strlen(temp) != 17)
     return FALSE;

  // check for colons
  if ((temp[2] != ':')||(temp[5] != ':')||(temp[8]!=':')||(temp[11]!=':')||(temp[14] !=':'))
     return FALSE;

  // strip off the colons
  tmp = (unsigned char *) temp;
  int i = 0;
  while (*tmp != 0)
  {
     if (*tmp != ':')
     {
        temp[i] = *tmp;
        i++;
     }
     tmp++;
  }
  temp[i] = 0;

  // convert to lower
  for(z=0;z<strlen(temp);z++)
     temp[z] = tolower(temp[z]);


  // check out the MAC address
  tmp = (unsigned char *) temp;
  while(*tmp != 0)
    if (((*tmp >= '0') && (*tmp <= '9'))||   // good 0-9
        ((*tmp >= 'a') && (*tmp <= 'f')))    // or a-f
      tmp++;
    else
      return FALSE;

  // convert to target string
  tmp = (unsigned char *) temp;
  while (*tmp != 0)
  {
  if ((*tmp >= '0') && (*tmp <= '9'))
    *tmp = *tmp - (char unsigned )'0';
  else
    *tmp = *tmp - (char unsigned) 'a' + (char unsigned) 10;
  tmp++;
  }

  address_buffer[0] =  (temp[0]*16) + temp[1];
  address_buffer[1] =  (temp[2]*16) + temp[3];
  address_buffer[2] =  (temp[4]*16) + temp[5];
  address_buffer[3] =  (temp[6]*16) + temp[7];
  address_buffer[4] =  (temp[8]*16) + temp[9];
  address_buffer[5] =  (temp[10]*16) + temp[11];

  return TRUE;
}

//----[ MAC address format output ]---------------------------------
void MacAddress::format_output() const
{
  if (valid_flag)
    sprintf((char*)output_buffer,"%02x:%02x:%02x:%02x:%02x:%02x",
	    address_buffer[0], address_buffer[1], address_buffer[2],
	    address_buffer[3], address_buffer[4], address_buffer[5]);
  else
    *(char*)output_buffer = 0;
  MacAddress *nc_this = PP_CONST_CAST(MacAddress*, this);
  nc_this->addr_changed = false;
}

unsigned int MacAddress::hashFunction() const
{
  return ((((address_buffer[0] << 8) + address_buffer[1]) * HASH0)
	+ (((address_buffer[2] << 8) + address_buffer[3]) * HASH1)
        + (((address_buffer[4] << 8) + address_buffer[5]) * HASH2));
}
#endif // _MAC_ADDRESS

//========================================================================
//========== Generic Address Implementation ==============================
//========================================================================

//-----------[ constructor, no arguments ]--------------------------------
GenAddress::GenAddress() : Address()
{
  ADDRESS_TRACE;

  // initialize SMI info
  // BOK: this is generally not used for GenAddress,
  // but we need this to be a replica of the real address'
  // smival info so that operator=SnmpSyntax will work.
  smival.syntax = sNMP_SYNTAX_NULL;                // to be overridden
  smival.value.string.len = 0;                        // to be overridden
  smival.value.string.ptr = address_buffer;        // constant

  valid_flag = false;
  address = 0;
  output_buffer[0] = 0;
}

//-----------[ constructor with a string argument ]----------------------
GenAddress::GenAddress(const char  *addr,
		       const Address::addr_type use_type)
{
  ADDRESS_TRACE;

  // initialize SMI info
  // BOK: smival is generally not used for GenAddress, but
  //      we need this to be a replica of the real address'
  //      smival info so that <class>::operator=SnmpSyntax
  //      will work.
  smival.syntax = sNMP_SYNTAX_NULL;                // to be overridden
  smival.value.string.len = 0;                        // to be overridden
  smival.value.string.ptr = address_buffer;        // constant

  address = 0;
  parse_address(addr, use_type);

  // Copy real address smival info into GenAddr smival
  // BOK: smival is generally not used for GenAddress, but
  //      we need this to be a replica of the real address'
  //      smival info so that <class>::operator=SnmpSyntax
  //      will work.
  if (valid_flag ) {
      smival.syntax = ((GenAddress *)address)->smival.syntax;
      smival.value.string.len =
          ((GenAddress *)address)->smival.value.string.len;
      memcpy(smival.value.string.ptr,
          ((GenAddress *)address)->smival.value.string.ptr,
          (size_t)smival.value.string.len);
  }
  output_buffer[0] = 0;
}

//-----------[ constructor with an Address argument ]--------------------
GenAddress::GenAddress(const Address &addr)
{
  ADDRESS_TRACE;

  output_buffer[0] = 0;
  // initialize SMI info
  // BOK: this is generally not used for GenAddress,
  // but we need this to be a replica of the real address'
  // smival info so that operator=SnmpSyntax will work.
  smival.syntax = sNMP_SYNTAX_NULL;                // to be overridden
  smival.value.string.len = 0;                        // to be overridden
  smival.value.string.ptr = address_buffer;        // constant

  valid_flag = false;
  // make sure that the object is valid
  if (!addr.valid()) {
    address = 0;
    return;
  }

  // addr can be a GenAddress object and calling clone() on that is bad...
  if (addr.is_gen_address())
    address = (Address *)(((const GenAddress&)addr).address->clone());
  else
    address = (Address*)addr.clone();

  if (address)
    valid_flag = address->valid();

  // Copy real address smival info into GenAddr smival
  // BOK: smival is generally not used for GenAddress, but
  //      we need this to be a replica of the real address'
  //      smival info so that <class>::operator=SnmpSyntax
  //      will work.
  if (valid_flag )
  {
    smival.syntax = address->get_syntax();
    smival.value.string.len = ((GenAddress *)address)->smival.value.string.len;
    memcpy(smival.value.string.ptr,
           ((GenAddress *)address)->smival.value.string.ptr,
           (size_t)smival.value.string.len);
  }
}

//-----------------[ constructor with another GenAddress object ]-------------
GenAddress::GenAddress(const GenAddress &addr)
{
  ADDRESS_TRACE;

  output_buffer[0] = 0;
  // initialize SMI info
  // BOK: this is generally not used for GenAddress,
  // but we need this to be a replica of the real address'
  // smival info so that operator=SnmpSyntax will work.
  smival.syntax = sNMP_SYNTAX_OCTETS;
  smival.value.string.len = 0;
  smival.value.string.ptr = address_buffer;

  valid_flag = false;
  // make sure that the object is valid
  if (!addr.valid_flag)
  {
    address = 0;
    return;
  }

  address = (Address *)addr.address->clone();
  if (address)
    valid_flag = address->valid();

  // Copy real address smival info into GenAddr smival
  // BOK: smival is generally not used for GenAddress, but
  //      we need this to be a replica of the real address'
  //      smival info so that <class>::operator=SnmpSyntax
  //      will work.
  if (valid_flag )
  {
    smival.syntax = ((GenAddress *)address)->smival.syntax;
    smival.value.string.len = ((GenAddress *)address)->smival.value.string.len;
    memcpy(smival.value.string.ptr,
           ((GenAddress *)address)->smival.value.string.ptr,
           (size_t)smival.value.string.len);
  }
}

//------[ assignment GenAddress = GenAddress ]-----------------------------
GenAddress& GenAddress::operator=(const GenAddress &addr)
{
  ADDRESS_TRACE;

  if (this == &addr) return *this;  // protect against assignment from itself

  valid_flag = false;
  if (address)
  {
    delete address;
    address = 0;
  }
  if (addr.address)
    address = (Address *)(addr.address->clone());
  if (address)
    valid_flag = address->valid();

  // Copy real address smival info into GenAddr smival
  // BOK: smival is generally not used for GenAddress, but
  //      we need this to be a replica of the real address'
  //      smival info so that <class>::operator=SnmpSyntax
  //      will work.
  if (valid_flag )
  {
    smival.syntax = ((GenAddress *)address)->smival.syntax;
    smival.value.string.len = ((GenAddress *)address)->smival.value.string.len;
    memcpy(smival.value.string.ptr,
           ((GenAddress *)address)->smival.value.string.ptr,
           (size_t)smival.value.string.len);
  }

  return *this;
}

//------[ assignment GenAddress = Address ]--------------------------------
GenAddress& GenAddress::operator=(const Address &addr)
{
  ADDRESS_TRACE;

  if (this == &addr) return *this;  // protect against assignment from itself

  valid_flag = false;
  if (address)
  {
    delete address;
    address = 0;
  }

  // addr can be a GenAddress object and calling clone() on that is bad...
  if (addr.is_gen_address())
    address = (Address *)(((const GenAddress&)addr).address->clone());
  else
    address = (Address*)addr.clone();

  if (address)
    valid_flag = address->valid();

  // Copy real address smival info into GenAddr smival
  // BOK: smival is generally not used for GenAddress, but
  //      we need this to be a replica of the real address'
  //      smival info so that <class>::operator=SnmpSyntax
  //      will work.
  if (valid_flag )
  {
    smival.syntax = ((GenAddress *)address)->smival.syntax;
    smival.value.string.len = ((GenAddress *)address)->smival.value.string.len;
    memcpy(smival.value.string.ptr,
           ((GenAddress *)address)->smival.value.string.ptr,
           (size_t)smival.value.string.len);
  }

  return *this;
}


//------[ assignment GenAddress = any SnmpSyntax ]-----------------------
SnmpSyntax& GenAddress::operator=(const SnmpSyntax &val)
{
  ADDRESS_TRACE;

  if (this == &val) return *this; // protect against assignment from itself

  valid_flag = false;             // will get set to TRUE if really valid
  if (address)
  {
    delete address;
    address = 0;
  }

  if (val.valid())
  {
    switch (val.get_syntax() )
    {
      //-----[ ip address case ]-------------
      // BOK: this case shouldn't be needed since there is an explicit
      // GenAddr=Address assignment that will override this assignment.
      // Left here for posterity.
      case sNMP_SYNTAX_IPADDR:
      {
        address = new IpAddress