/dep/acelite/ace/INET_Addr.inl

// -*- C++ -*-



#include "ace/OS_NS_string.h"

#include "ace/Global_Macros.h"

#include "ace/OS_NS_arpa_inet.h"



ACE_BEGIN_VERSIONED_NAMESPACE_DECL



ACE_INLINE void

ACE_INET_Addr::reset_i (void)

{

  ACE_OS::memset (&this->inet_addr_, 0, sizeof (this->inet_addr_));

  if (this->get_type() == AF_INET)

    {

#ifdef ACE_HAS_SOCKADDR_IN_SIN_LEN

      this->inet_addr_.in4_.sin_len = sizeof (this->inet_addr_.in4_);

#endif

      this->inet_addr_.in4_.sin_family = AF_INET;

    }

#if defined (ACE_HAS_IPV6)

  else if (this->get_type() == AF_INET6)

    {

#ifdef ACE_HAS_SOCKADDR_IN6_SIN6_LEN

      this->inet_addr_.in6_.sin6_len = sizeof (this->inet_addr_.in6_);

#endif

      this->inet_addr_.in6_.sin6_family = AF_INET6;

    }

#endif  /* ACE_HAS_IPV6 */

  this->inet_addrs_.clear ();

  this->inet_addrs_iter_ = this->inet_addrs_.end ();



}



ACE_INLINE int

ACE_INET_Addr::determine_type (void) const

{

#if defined (ACE_HAS_IPV6)

#  if defined (ACE_USES_IPV4_IPV6_MIGRATION)

  return ACE::ipv6_enabled () ? AF_INET6 : AF_INET;

#  else

  return AF_INET6;

#  endif /* ACE_USES_IPV4_IPV6_MIGRATION */

#else

  return AF_INET;

#endif /* ACE_HAS_IPV6 */

}



ACE_INLINE void *

ACE_INET_Addr::ip_addr_pointer (void) const

{

#if defined (ACE_HAS_IPV6)

  if (this->get_type () == PF_INET)

    return (void*)&this->inet_addr_.in4_.sin_addr;

  else

    return (void*)&this->inet_addr_.in6_.sin6_addr;

#else

  return (void*)&this->inet_addr_.in4_.sin_addr;

#endif

}



ACE_INLINE int

ACE_INET_Addr::ip_addr_size (void) const

{

  // Since this size value is used to pass to other host db-type

  // functions (gethostbyaddr, etc.) the length is of int type.

  // Thus, cast all these sizes back to int. They're all well

  // within the range of an int anyway.

#if defined (ACE_HAS_IPV6)

  if (this->get_type () == PF_INET)

    return static_cast<int> (sizeof this->inet_addr_.in4_.sin_addr);

  else

    return static_cast<int> (sizeof this->inet_addr_.in6_.sin6_addr);

#else

  return static_cast<int> (sizeof this->inet_addr_.in4_.sin_addr.s_addr);

#endif /* ACE_HAS_IPV6 */

}



// Return the port number, converting it into host byte order...



ACE_INLINE u_short

ACE_INET_Addr::get_port_number (void) const

{

  ACE_TRACE ("ACE_INET_Addr::get_port_number");

#if defined (ACE_HAS_IPV6)

  if (this->get_type () == PF_INET)

    return ACE_NTOHS (this->inet_addr_.in4_.sin_port);

  else

    return ACE_NTOHS (this->inet_addr_.in6_.sin6_port);

#else

# if defined (ACE_VXWORKS) && ACE_VXWORKS >= 0x690

  return static_cast<u_short> (ACE_NTOHS (this->inet_addr_.in4_.sin_port));

# else

  return ACE_NTOHS (this->inet_addr_.in4_.sin_port);

# endif

#endif /* ACE_HAS_IPV6 */

}



ACE_INLINE int

ACE_INET_Addr::get_addr_size (void) const

{

  ACE_TRACE ("ACE_INET_Addr::get_addr_size");

#if defined (ACE_HAS_IPV6)

  if (this->get_type () == PF_INET)

    return sizeof this->inet_addr_.in4_;

  else

    return sizeof this->inet_addr_.in6_;

#else

  return sizeof this->inet_addr_.in4_;

#endif /* ACE_HAS_IPV6 */

}



ACE_INLINE bool

ACE_INET_Addr::operator < (const ACE_INET_Addr &rhs) const

{

#if defined (ACE_HAS_IPV6)

  if (this->get_type() != rhs.get_type())

  {

    return this->get_type() < rhs.get_type();

  }



  if (this->get_type() == PF_INET6)

  {

    int memval = ACE_OS::memcmp (this->ip_addr_pointer(),

                                 rhs.ip_addr_pointer(),

                                 this->ip_addr_size());



    return memval < 0

            || (memval == 0

                && (this->get_port_number() < rhs.get_port_number()

                    || (this->get_port_number() == rhs.get_port_number()

                        && this->inet_addr_.in6_.sin6_scope_id <

                            rhs.inet_addr_.in6_.sin6_scope_id)));

  }

#endif



  return this->get_ip_address () < rhs.get_ip_address ()

    || (this->get_ip_address () == rhs.get_ip_address ()

        && this->get_port_number () < rhs.get_port_number ());

}



#if defined (ACE_HAS_WCHAR)

ACE_INLINE int

ACE_INET_Addr::set (u_short port_number,

                    const wchar_t host_name[],

                    int encode,

                    int address_family)

{

  return this->set (port_number,

                    ACE_Wide_To_Ascii (host_name).char_rep (),

                    encode,

                    address_family);

}



ACE_INLINE int

ACE_INET_Addr::set (const wchar_t port_name[],

                    const wchar_t host_name[],

                    const wchar_t protocol[])

{

  return this->set (ACE_Wide_To_Ascii (port_name).char_rep (),

                    ACE_Wide_To_Ascii (host_name).char_rep (),

                    ACE_Wide_To_Ascii (protocol).char_rep ());

}



ACE_INLINE int

ACE_INET_Addr::set (const wchar_t port_name[],

                    ACE_UINT32 ip_addr,

                    const wchar_t protocol[])

{

  return this->set (ACE_Wide_To_Ascii (port_name).char_rep (),

                    ip_addr,

                    ACE_Wide_To_Ascii (protocol).char_rep ());

}



ACE_INLINE int

ACE_INET_Addr::set (const wchar_t addr[], int address_family)

{

  return this->set (ACE_Wide_To_Ascii (addr).char_rep (), address_family);

}



#endif /* ACE_HAS_WCHAR */



// Return @c true if the IP address is INADDR_ANY or IN6ADDR_ANY.

ACE_INLINE bool

ACE_INET_Addr::is_any (void) const

{

#if defined (ACE_HAS_IPV6)

  if (this->get_type () == AF_INET6)

      return IN6_IS_ADDR_UNSPECIFIED (&this->inet_addr_.in6_.sin6_addr);

#endif /* ACE_HAS_IPV6 */



  return (this->inet_addr_.in4_.sin_addr.s_addr == INADDR_ANY);

}



// Return @c true if the IP address is IPv4/IPv6 loopback address.

ACE_INLINE bool

ACE_INET_Addr::is_loopback (void) const

{

#if defined (ACE_HAS_IPV6)

  if (this->get_type () == AF_INET6)

      return IN6_IS_ADDR_LOOPBACK (&this->inet_addr_.in6_.sin6_addr);

#endif /* ACE_HAS_IPV6 */



  // RFC 3330 defines loopback as any address with 127.x.x.x

  return ((this->get_ip_address () & 0XFF000000) == (INADDR_LOOPBACK & 0XFF000000));

}



// Return @c true if the IP address is IPv4/IPv6 multicast address.

ACE_INLINE bool

ACE_INET_Addr::is_multicast (void) const

{

#if defined (ACE_HAS_IPV6)

  if (this->get_type() == AF_INET6)

    return this->inet_addr_.in6_.sin6_addr.s6_addr[0] == 0xFF;

#endif /* ACE_HAS_IPV6 */

  return

    (*static_cast<const unsigned char*> (

        static_cast<const void*> (&this->inet_addr_.in4_.sin_addr.s_addr)) & 0xf0) == 0xe0;

}



#if defined (ACE_HAS_IPV6)

// Return @c true if the IP address is IPv6 linklocal address.

ACE_INLINE bool

ACE_INET_Addr::is_linklocal (void) const

{

  if (this->get_type () == AF_INET6)

      return IN6_IS_ADDR_LINKLOCAL (&this->inet_addr_.in6_.sin6_addr);



  return false;

}



// Return @c true if the IP address is IPv4 mapped IPv6 address.

ACE_INLINE bool

ACE_INET_Addr::is_ipv4_mapped_ipv6 (void) const

{

  if (this->get_type () == AF_INET6)

      return IN6_IS_ADDR_V4MAPPED (&this->inet_addr_.in6_.sin6_addr);



  return false;

}



// Return @c true if the IP address is IPv4-compatible IPv6 address.

ACE_INLINE bool

ACE_INET_Addr::is_ipv4_compat_ipv6 (void) const

{

  if (this->get_type () == AF_INET6)

      return IN6_IS_ADDR_V4COMPAT (&this->inet_addr_.in6_.sin6_addr);



  return false;

}

#endif /* ACE_HAS_IPV6 */



ACE_END_VERSIONED_NAMESPACE_DECL