address.cpp

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

  }
  else
    *(char*)output_buffer = 0;
  UdpAddress *nc_this = PP_CONST_CAST(UdpAddress*, this);
  nc_this->addr_changed = false;
}

/**
 * Map a IPv4 UDP address to a IPv6 UDP address.
 *
 * @return - TRUE if no error occured.
 */
int UdpAddress::map_to_ipv6()
{
  ADDRESS_TRACE;

  /* Save the port, as IpAddress::map_to_ipv6 destroys it */
  unsigned short old_port = get_port();

  /* Map IpAddress */
  if (!IpAddress::map_to_ipv6())
    return FALSE;

  set_port(old_port);
  smival.value.string.len = UDPIP6LEN;
  ip_version = version_ipv6;

  addr_changed = true;
  return TRUE;
}


#ifdef _IPX_ADDRESS
//=======================================================================
//=========== IPX Address Implementation ================================
//=======================================================================

//----------[ constructor no args ]--------------------------------------
IpxAddress::IpxAddress() : 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;
  addr_changed = true;
}


//----------[ 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(inaddr);
  addr_changed = true;
}


//-----[ 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);
  addr_changed = true;
}


//----[ 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 = genaddr.valid();
  // allow use of an ipx or ipxsock address
  if (valid_flag)
  {
    if ((genaddr.get_type() == type_ipx) )
    {
      *this = genaddr.cast_ipxaddress();     // copy in the Ipx address data
    }
    else if ((genaddr.get_type() == type_ipxsock) )
    {
      *this = genaddr.cast_ipxsockaddress();  // copy in the Ipx address data
    }
    else
      valid_flag = false;
  }
}

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

  valid_flag = false;              // 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 = true;
      }
    break;
    }
  }
  addr_changed = true;
  return *this;
}

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

  valid_flag = ipxaddress.valid_flag;
  if (valid_flag)
    MEMCPY(address_buffer, ipxaddress.address_buffer, IPXLEN);
  addr_changed = true;
  return *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
bool 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
  // 123456789012345678901
  // XXXXXXXX-XXXXXXXXXXXX  21 len
  //
  // XXXXXXXX-XXXXXX-XXXXXX 22 len
  // need at least 21 chars and no more than 22
  if ((tmplen <21) || (tmplen >22))
    return FALSE;

  // convert the string to all lower case
  // this allows hex values to be in upper or lower
  for (z=0;z< tmplen;z++)
    temp[z] = tolower(temp[z]);

  // check for separated nodeid
  // if found remove it
  if (temp[15] == '-')
  {
     for(z=16;z<tmplen;z++)
        temp[z-1] = temp[z];
     temp[tmplen-1] = 0;
  }

  // no dot or colon separator check
  separator = temp[8];
  if ((separator != ':') &&
      (separator != '.') &&
      (separator != '-') &&
      (separator != ' '))
    return FALSE;

  // separate the strings
  str1 = (unsigned char *) temp;
  while(*str1 != separator) str1++;
  str2 = str1 + 1;
  *str1 = 0;
  str1= (unsigned char *) temp;

  // check len of the network portion
  if (strlen((char *) str1) != 8) return FALSE;

  // check len of mac portion
  if (strlen((char *) str2) != 12) return FALSE;

  // ok we like then lens, make sure that all chars are 0-f
  // check out the net id
  tmp = str1;
  while(*tmp != 0)
    if (((*tmp >= '0') && (*tmp <= '9'))||   // good 0-9
        ((*tmp >= 'a') && (*tmp <= 'f')))    // or a-f
      tmp++;
    else
      return FALSE;

  // check out the MAC address
  tmp = str2;
  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 = str1;
  while (*tmp != 0)
  {
  if ((*tmp >= '0') && (*tmp <= '9'))
    *tmp = *tmp - (char unsigned )'0';
  else
    *tmp = *tmp - (char unsigned) 'a' + (char unsigned) 10;
  tmp++;
  }

  // network id portion
  address_buffer[0] = (str1[0]*16) + str1[1];
  address_buffer[1] = (str1[2]*16) + str1[3];
  address_buffer[2] = (str1[4]*16) + str1[5];
  address_buffer[3] = (str1[6]*16) + str1[7];

  tmp = str2;
  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[4] = (str2[0]*16)  + str2[1];
  address_buffer[5] = (str2[2]*16)  + str2[3];
  address_buffer[6] = (str2[4]*16)  + str2[5];
  address_buffer[7] = (str2[6]*16)  + str2[7];
  address_buffer[8] = (str2[8]*16)  + str2[9];
  address_buffer[9] = (str2[10]*16) + str2[11];

  return TRUE;
}

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


#ifdef _MAC_ADDRESS
// get the host id portion of an ipx address
int IpxAddress::get_hostid(MacAddress& mac) const
{
   if (valid_flag)
   {
       char buffer[18];
       sprintf(buffer,"%02x:%02x:%02x:%02x:%02x:%02x", address_buffer[4],
                address_buffer[5], address_buffer[6], address_buffer[7],
                address_buffer[8], address_buffer[9]);
       MacAddress temp(buffer);
       mac = temp;
       if (mac.valid())
	 return TRUE;
   }
   return FALSE;
}
#endif // function that needs _MAC_ADDRESS

//========================================================================
//======== IpxSockAddress Implementation =================================
//========================================================================

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

  set_socket(0);
  addr_changed = true;
}

//-----------[ construct an IpxSockAddress with another IpxSockAddress]----
IpxSockAddress::IpxSockAddress(const IpxSockAddress &ipxaddr)
  : IpxAddress(ipxaddr)
{
  // always initialize SMI info
  smival.syntax = sNMP_SYNTAX_OCTETS;
  smival.value.string.len = IPXSOCKLEN;
  smival.value.string.ptr = address_buffer;

  // copy the socket value
  set_socket(ipxaddr.get_socket());
  addr_changed = true;
}


//---------------[ construct a IpxSockAddress from a string ]--------------
IpxSockAddress::IpxSockAddress(const char *inaddr):IpxAddress()
{
  // always initialize SMI info
  smival.syntax = sNMP_SYNTAX_OCTETS;
  smival.value.string.len = IPXSOCKLEN;
  smival.value.string.ptr = address_buffer;

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


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

  valid_flag = false;
  unsigned short socketid = 0;
  // 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;
      //  socketid info since are making an IpxSockAddress
      socketid = temp_ipxsock.get_socket();
    }
  }
  set_socket(socketid);
  addr_changed = true;
}

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

  set_socket(0);
  addr_changed = true;
}

// copy an instance of this Value
SnmpSyntax& IpxSockAddress::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:
      {
        // See if it is of the Ipx address family
        // This handles IpxSockAddress == IpxAddress
        IpxSockAddress temp_ipx(val.get_printable());
        if (temp_ipx.valid()){
          *this = temp_ipx;                // ipxsock = ipxsock
        }
        // See if it is an OctetStr of appropriate length
        else if (((IpxSockAddress &)val).smival.value.string.len == IPXSOCKLEN){
          MEMCPY(address_buffer,
                 ((IpxSockAddress &)val).smival.value.string.ptr,
                 IPXSOCKLEN);
          valid_flag = true;
        }
      }
      break;
    }
  }
  addr_changed = true;
  return *this;
}

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

  (IpxAddress&)*this = ipxaddr;         // use ancestor assignment for ipx addr
  set_socket(ipxaddr.get_socket());        // copy socket value
  addr_changed = true;
  return *this;
}

//----[ IPX address format output ]-------------------------------------
void IpxSockAddress::format_output() const
{
  IpxAddress::format_output(); // allow ancestors to format their buffers

  if (valid_flag)
    sprintf((char *) output_buffer,"%s/%d",
            IpxAddress::get_printable(), get_socket());
  else
    *(char*)output_buffer = 0;
  IpxSockAddress *nc_this = PP_CONST_CAST(IpxSockAddress*, this);
  nc_this->addr_changed = false;
}

//-----[ IP Address parse Address ]---------------------------------
bool IpxSockAddress::parse_address(const char *inaddr)
{
   char buffer[MAX_FRIENDLY_NAME];
   unsigned short socketid=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,"/");