address.cpp

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

  // if valid format else null it
  if (valid_flag)
  {
    if (ip_version == version_ipv4)
      sprintf((char *) output_buffer,"%d.%d.%d.%d",address_buffer[0],
               address_buffer[1], address_buffer[2], address_buffer[3]);
    else
      sprintf((char *) output_buffer,
               "%02x%02x:%02x%02x:%02x%02x:%02x%02x:"
               "%02x%02x:%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], address_buffer[10], address_buffer[11],
               address_buffer[12], address_buffer[13], address_buffer[14],
               address_buffer[15]);
  }
  else
    *(char *)output_buffer = 0;
  IpAddress *nc_this = PP_CONST_CAST(IpAddress*, this);
  nc_this->addr_changed = false;
}

//-----------------------------------------------------------------
// logically and two IPaddresses and
// return the new one
void IpAddress::mask(const IpAddress& ipaddr)
{
  ADDRESS_TRACE;

  if (valid() && ipaddr.valid())
  {
    int count = (ip_version == version_ipv4) ? IPLEN : IP6LEN;

    for (int i = 0; i < count; i++)
      address_buffer[i] = address_buffer[i] & ipaddr.address_buffer[i];
    addr_changed = true;
  }
}


// Get the count of matching bits from the left.
int IpAddress::get_match_bits(const IpAddress match_ip) const
{
  ADDRESS_TRACE;

  int bits = 0;

  if (valid() && match_ip.valid() &&
      (ip_version == match_ip.ip_version))
  {
    int count = (ip_version == version_ipv4) ? IPLEN : IP6LEN;

    for (int i = 0; i < count; i++)
    {
	if (address_buffer[i] == match_ip.address_buffer[i])
	    bits += 8;
	else
	{
	    bits += 7;
	    unsigned char c1 = address_buffer[i] >> 1;
	    unsigned char c2 = match_ip.address_buffer[i] >> 1;
	    while (c1 != c2)
	    {
		c1 = c1 >> 1;
		c2 = c2 >> 1;
		bits--;
	    }
	    break;
	}
    }
  }

  return bits;
}

// Map a IPv4 Address to a IPv6 address.
int IpAddress::map_to_ipv6()
{
  ADDRESS_TRACE;

  if (!valid())
    return FALSE;

  if (ip_version != version_ipv4)
    return FALSE;

  /* just copy IPv4 address to the end of  the buffer
     zero the first 10 bytes and fill 2 Bytes with 0xff */
  memcpy(&address_buffer[12], address_buffer, 4);
  memset(address_buffer, 0, 10);
  address_buffer[10] = 0xff;
  address_buffer[11] = 0xff;

  smival.value.string.len = IP6LEN;
  ip_version = version_ipv6;

  addr_changed = true;
  return TRUE;
}

// Reset the object
void IpAddress::clear()
{
  Address::clear();
  memset(output_buffer, 0, sizeof(output_buffer));
  iv_friendly_name_status = 0;
  ip_version = version_ipv4;
  memset(iv_friendly_name, 0, sizeof(char) * MAX_FRIENDLY_NAME);
  smival.value.string.len = IPLEN;
}

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

//-------[ construct an IP address with no agrs ]----------------------
UdpAddress::UdpAddress()
  : IpAddress()
{
  ADDRESS_TRACE;

  // 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;

  sep = ':';
  set_port(0);
}

//-----------------[ construct an Udp address with another Udp address ]---
UdpAddress::UdpAddress(const UdpAddress &udpaddr)
  : IpAddress(udpaddr)
{
  ADDRESS_TRACE;

  // always initialize SMI info
  smival.syntax = sNMP_SYNTAX_OCTETS;
  smival.value.string.len = udpaddr.smival.value.string.len;
  smival.value.string.ptr = address_buffer;

  // Copy the port value
  sep = ':';
  set_port(udpaddr.get_port());

  if (!udpaddr.addr_changed)
  {
    memcpy(output_buffer, udpaddr.output_buffer,
	   sizeof(unsigned char) * OUTBUFF);
    addr_changed = false;
  }
}

// constructor with a dotted string
UdpAddress::UdpAddress(const char *inaddr) : IpAddress()
{
  ADDRESS_TRACE;

  // always initialize SMI info
  smival.syntax = sNMP_SYNTAX_OCTETS;
  smival.value.string.len = UDPIPLEN;
  smival.value.string.ptr = address_buffer;

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

//-----------------[ construct a UdpAddress from a GenAddress ]--------------
UdpAddress::UdpAddress(const GenAddress &genaddr) : IpAddress()
{
  ADDRESS_TRACE;

  // always initialize SMI info
  smival.syntax = sNMP_SYNTAX_OCTETS;
  smival.value.string.len = UDPIPLEN;
  smival.value.string.ptr = address_buffer;

  valid_flag = genaddr.valid();

  // allow use of an ip or udp genaddress
  if (valid_flag)
  {
    if (genaddr.get_type() == type_udp)
    {
      *this = genaddr.cast_udpaddress();      // copy in the IP address data
    }
    else if (genaddr.get_type() == type_ip)
    {
      *this = genaddr.cast_ipaddress();      // copy in the IP address data
    }
    else
    {
      valid_flag = false;
    }
  }
  sep = ':';
}


//--------[ construct a udp from an IpAddress ]--------------------------
UdpAddress::UdpAddress(const IpAddress &ipaddr):IpAddress(ipaddr)
{
  ADDRESS_TRACE;

  // always initialize SMI info
  smival.syntax = sNMP_SYNTAX_OCTETS;
  if (ip_version == version_ipv4)
      smival.value.string.len = UDPIPLEN;
  else
      smival.value.string.len = UDPIP6LEN;
  smival.value.string.ptr = address_buffer;

  sep = ':';
  addr_changed = true;
  set_port(0);
}

// copy an instance of this Value
SnmpSyntax& UdpAddress::operator=(const SnmpSyntax &val)
{
  ADDRESS_TRACE;

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

  valid_flag = false;                // will get set TRUE if really valid
  addr_changed = true;
  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);
	  memset(iv_friendly_name, 0, sizeof(char) * MAX_FRIENDLY_NAME);
          valid_flag = true;
          ip_version = version_ipv4;
          smival.value.string.len = UDPIPLEN;
        }
        else if (((UdpAddress &)val).smival.value.string.len == UDPIP6LEN)
        {
          MEMCPY(address_buffer,((UdpAddress &)val).smival.value.string.ptr,
                 UDPIP6LEN);
	  memset(iv_friendly_name, 0, sizeof(char) * MAX_FRIENDLY_NAME);
          valid_flag = true;
          ip_version = version_ipv6;
          smival.value.string.len = UDPIP6LEN;
        }
        break;
        // NOTE: as a value add, other types could have "logical"
        // mappings, i.e. integer32 and unsigned32
    }
  }
  return *this;
}

// assignment to another UdpAddress object overloaded
UdpAddress& UdpAddress::operator=(const UdpAddress &udpaddr)
{
  ADDRESS_TRACE;

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

  (IpAddress &)*this = udpaddr; // use ancestor assignment for ipaddr value
  if (ip_version == version_ipv4)
    smival.value.string.len = UDPIPLEN;
  else
    smival.value.string.len = UDPIP6LEN;

  set_port(udpaddr.get_port());        // copy to port value
  if (udpaddr.addr_changed)
  {
    addr_changed = true;
  }
  else
  {
    memcpy(output_buffer, udpaddr.output_buffer,
	   sizeof(unsigned char) * OUTBUFF);
    addr_changed = false;
  }

  return *this;
}

// assignment to another UdpAddress object overloaded
UdpAddress& UdpAddress::operator=(const IpAddress &ipaddr)
{
  ADDRESS_TRACE;

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

  (IpAddress &)*this = ipaddr; // use ancestor assignment for ipaddr value
  if (ip_version == version_ipv4)
    smival.value.string.len = UDPIPLEN;
  else
    smival.value.string.len = UDPIP6LEN;

  set_port(0);        // copy to port value
  addr_changed = true;
  return *this;
}

UdpAddress& UdpAddress::operator=(const char *inaddr)
{
  ADDRESS_TRACE;

  valid_flag = parse_address(inaddr);
  addr_changed = true;
  return *this;
}

//-----[ IP Address parse Address ]---------------------------------
bool UdpAddress::parse_address(const char *inaddr)
{
  ADDRESS_TRACE;

  addr_changed = true;

  char buffer[MAX_FRIENDLY_NAME];

  unsigned short port = 0;
  if (inaddr && (strlen(inaddr)< MAX_FRIENDLY_NAME))
  {
    strcpy(buffer, inaddr);
    trim_white_space(buffer);
  }
  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

  int remove_brackets = FALSE;
  int found = FALSE;
  int pos = (int)strlen(buffer) - 1; // safe to cast as max is MAX_FRIENDLY_NAME
  int do_loop = TRUE;
  int another_colon_found = FALSE;

  if (pos < 0)
  {
    valid_flag = false;
    return FALSE;
  }

  // search from the end, to find the start of the port 
  // [ipv4]:port [ipv4]/port ipv4/port ipv4:port [ipv4] ipv4
  // [ipv6]:port [ipv6]/port ipv6/port           [ipv6] ipv6
  while (do_loop)
  {
    if (buffer[pos] == '/')
    {
      found = TRUE;
      sep='/';
      if (buffer[pos -1] == ']')
        remove_brackets = TRUE;
      break;
    }
    if (buffer[pos] == ':')
    {
      if ((pos > 1) && (buffer[pos -1] == ']'))
      {
        found = TRUE;
        remove_brackets = TRUE;
        sep=':';
        break;
      }

      for (int i=pos - 1; i >= 0 ; i--)
        if (buffer[i] == ':')
        {
          another_colon_found = TRUE;
        }
      if (!another_colon_found)
      {
        sep=':';
        found = TRUE;
        break;
      }
    }
    if (buffer[pos] == ']')
    {
      // we found a ] without following a port, so increase pos
      ++pos;
      remove_brackets = TRUE;
      break;
    }
    pos--;
    do_loop = ((found == FALSE) && (pos >= 0) &&
               (another_colon_found == FALSE));
  }

  if (remove_brackets)
  {
    buffer[pos-1] = 0;
    buffer[0] = ' ';
  }

  bool result;

  if (found)
  {
    buffer[pos] = 0;
    port = atoi(&buffer[pos+1]);
    result = IpAddress::parse_address(buffer);
  }
  else
  {
    port = 0;
    result = IpAddress::parse_address(buffer);
  }

  if (ip_version == version_ipv4)
    smival.value.string.len = UDPIPLEN;
  else
    smival.value.string.len = UDPIP6LEN;

  set_port(port);
  return result;
}


//--------[ set the port number ]---------------------------------------
void UdpAddress::set_port(const unsigned short p)
{
  ADDRESS_TRACE;

  unsigned short *port_nbo;
  if (ip_version == version_ipv4)
    port_nbo = (unsigned short*)(address_buffer + IPLEN);
  else
    port_nbo = (unsigned short*)(address_buffer + IP6LEN);
  *port_nbo = htons(p);
  addr_changed = true;
}

//---------[ get the port number ]--------------------------------------
unsigned short UdpAddress::get_port() const
{
  ADDRESS_TRACE;

  if (valid_flag)
  {
    unsigned short *port_nbo;
    if (ip_version == version_ipv4)
      port_nbo = (unsigned short*)(address_buffer + IPLEN);
    else
      port_nbo = (unsigned short*)(address_buffer + IP6LEN);
    return ntohs(*port_nbo);
  }
  return 0;// don't use uninitialized memory
}

//----[ UDP address format output ]------------------------------------
void UdpAddress::format_output() const
{
  ADDRESS_TRACE;

  IpAddress::format_output(); // allow ancestors to format their buffers

  // if valid format else null it
  if (valid_flag)
  {
    if (ip_version == version_ipv4)
      sprintf((char *) output_buffer,"%s%c%d",
               IpAddress::get_printable(),
               '/',//TODO:look for problems in old code and change to "sep"
               get_port() );
      else
        sprintf((char *) output_buffer,"[%s]%c%d",
                 IpAddress::get_printable(),
                 '/',//TODO:look for problems in old code and change to "sep"
                 get_port() );