josh/TCPlayerbotCore
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

*Backed out changeset 3be01fb200a5

Browse Source 
--HG--
branch : trunk
This commit is contained in:
maximius
2009-10-17 15:51:44 -07:00
parent 26b5e033ff
commit e585187b24
2257 changed files with 103863 additions and 761 deletions
Download Patch File Download Diff File Expand all files Collapse all files
dep/ACE_wrappers/ace/INET_Addr.cpp
+135
View File
@@ -1,9 +1,13 @@
// $Id: INET_Addr.cpp 82434 2008-07-28 11:40:36Z johnnyw $
// Defines the Internet domain address family address format.
#include "ace/INET_Addr.h"
#if !defined (__ACE_INLINE__)
#include "ace/INET_Addr.inl"
#endif /* __ACE_INLINE__ */
#include "ace/Log_Msg.h"
#include "ace/OS_NS_stdio.h"
#include "ace/OS_NS_errno.h"
@@ -13,27 +17,36 @@
#include "ace/OS_NS_netdb.h"
#include "ace/OS_NS_unistd.h"
#include "ace/OS_NS_sys_socket.h"
ACE_RCSID (ace,
INET_Addr,
"$Id: INET_Addr.cpp 82434 2008-07-28 11:40:36Z johnnyw $")
ACE_BEGIN_VERSIONED_NAMESPACE_DECL
ACE_ALLOC_HOOK_DEFINE(ACE_INET_Addr)
// Transform the current address into string format.
int
ACE_INET_Addr::addr_to_string (ACE_TCHAR s[],
size_t size,
int ipaddr_format) const
{
ACE_TRACE ("ACE_INET_Addr::addr_to_string");
// XXX Can we (should we) include the scope id for IPv6 addresses?
char hoststr[MAXHOSTNAMELEN+1];
bool result = false;
if (ipaddr_format == 0)
result = (this->get_host_name (hoststr, MAXHOSTNAMELEN+1) == 0);
else
result = (this->get_host_addr (hoststr, MAXHOSTNAMELEN+1) != 0);
if (!result)
return -1;
size_t total_len =
ACE_OS::strlen (hoststr)
+ 5 // ACE_OS::strlen ("65535"), Assuming the max port number.
@@ -55,6 +68,7 @@ ACE_INET_Addr::addr_to_string (ACE_TCHAR s[],
# endif /* !ACE_WIN32 && ACE_USES_WCHAR */
}
#endif // ACE_HAS_IPV6
if (size < total_len)
return -1;
else
@@ -63,43 +77,54 @@ ACE_INET_Addr::addr_to_string (ACE_TCHAR s[],
this->get_port_number ());
return 0;
}
void
ACE_INET_Addr::dump (void) const
{
#if defined (ACE_HAS_DUMP)
ACE_TRACE ("ACE_INET_Addr::dump");
ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
ACE_TCHAR s[ACE_MAX_FULLY_QUALIFIED_NAME_LEN + 16];
this->addr_to_string(s, ACE_MAX_FULLY_QUALIFIED_NAME_LEN + 16);
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("%s"), s));
ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
#endif /* ACE_HAS_DUMP */
}
// Compare two addresses for inequality.
bool
ACE_INET_Addr::operator != (const ACE_INET_Addr &sap) const
{
ACE_TRACE ("ACE_INET_Addr::operator !=");
return !((*this) == sap);
}
// Compare two addresses for equality.
bool
ACE_INET_Addr::operator == (const ACE_INET_Addr &sap) const
{
ACE_TRACE ("ACE_INET_Addr::operator ==");
if (this->get_type () != sap.get_type ()
|| this->get_size () != sap.get_size ())
return false;
return (ACE_OS::memcmp (&this->inet_addr_,
&sap.inet_addr_,
this->get_size ()) == 0);
}
bool
ACE_INET_Addr::is_ip_equal (const ACE_INET_Addr &sap) const
{
if (this->get_type () != sap.get_type ()
|| this->get_size () != sap.get_size ())
return false;
#if defined (ACE_HAS_IPV6)
if (this->get_type () == PF_INET6)
{
@@ -117,6 +142,7 @@ ACE_INET_Addr::is_ip_equal (const ACE_INET_Addr &sap) const
return this->get_ip_address () == sap.get_ip_address();
}
u_long
ACE_INET_Addr::hash (void) const
{
@@ -130,16 +156,19 @@ ACE_INET_Addr::hash (void) const
#endif /* ACE_HAS_IPV6 */
return this->get_ip_address () + this->get_port_number ();
}
ACE_INET_Addr::ACE_INET_Addr (void)
: ACE_Addr (determine_type (), sizeof (inet_addr_))
{
// ACE_TRACE ("ACE_INET_Addr::ACE_INET_Addr");
this->reset ();
}
int
ACE_INET_Addr::set (const ACE_INET_Addr &sa)
{
ACE_TRACE ("ACE_INET_Addr::set");
if (sa.get_type () == AF_ANY)
// Ugh, this is really a base class, so don't copy it.
ACE_OS::memset (&this->inet_addr_, 0, sizeof (this->inet_addr_));
@@ -149,12 +178,16 @@ ACE_INET_Addr::set (const ACE_INET_Addr &sa)
ACE_OS::memcpy (&this->inet_addr_,
&sa.inet_addr_,
sa.get_size ());
this->set_type (sa.get_type());
this->set_size (sa.get_size());
}
return 0;
}
// Transform the string into the current addressing format.
int
ACE_INET_Addr::string_to_addr (const char s[], int address_family)
{
@@ -162,6 +195,7 @@ ACE_INET_Addr::string_to_addr (const char s[], int address_family)
int result;
char *ip_buf = 0;
char *ip_addr = 0;
// Need to make a duplicate since we'll be overwriting the string.
ACE_ALLOCATOR_RETURN (ip_buf,
ACE_OS::strdup (s),
@@ -188,10 +222,12 @@ ACE_INET_Addr::string_to_addr (const char s[], int address_family)
}
}
#endif /* ACE_HAS_IPV6 */
if (port_p == 0) // Assume it's a port number.
{
char *endp = 0;
long const port = ACE_OS::strtol (ip_addr, &endp, 10);
if (*endp == '\0') // strtol scanned the entire string - all digits
{
if (port < 0 || port > ACE_MAX_DEFAULT_PORT)
@@ -205,8 +241,10 @@ ACE_INET_Addr::string_to_addr (const char s[], int address_family)
else
{
*port_p = '\0'; ++port_p; // skip over ':'
char *endp = 0;
long port = ACE_OS::strtol (port_p, &endp, 10);
if (*endp == '\0') // strtol scanned the entire string - all digits
{
if (port < 0 || port > ACE_MAX_DEFAULT_PORT)
@@ -217,15 +255,18 @@ ACE_INET_Addr::string_to_addr (const char s[], int address_family)
else
result = this->set (port_p, ip_addr);
}
ACE_OS::free (ACE_MALLOC_T (ip_buf));
return result;
}
int
ACE_INET_Addr::set (const char address[], int address_family)
{
ACE_TRACE ("ACE_INET_Addr::set");
return this->string_to_addr (address, address_family);
}
ACE_INET_Addr::ACE_INET_Addr (const char address[], int address_family)
: ACE_Addr (determine_type (), sizeof (inet_addr_))
{
@@ -233,6 +274,7 @@ ACE_INET_Addr::ACE_INET_Addr (const char address[], int address_family)
this->reset ();
this->set (address, address_family);
}
#if defined (ACE_HAS_WCHAR)
ACE_INET_Addr::ACE_INET_Addr (const wchar_t address[], int address_family)
: ACE_Addr (determine_type (), sizeof (inet_addr_))
@@ -241,8 +283,11 @@ ACE_INET_Addr::ACE_INET_Addr (const wchar_t address[], int address_family)
this->reset ();
this->set (address, address_family);
}
#endif /* ACE_HAS_WCHAR */
// Copy constructor.
ACE_INET_Addr::ACE_INET_Addr (const ACE_INET_Addr &sa)
: ACE_Addr (sa.get_type (), sa.get_size())
{
@@ -250,8 +295,10 @@ ACE_INET_Addr::ACE_INET_Addr (const ACE_INET_Addr &sa)
this->reset ();
this->set (sa);
}
// Initializes a ACE_INET_Addr from a PORT_NUMBER and a 32 bit Internet
// address.
int
ACE_INET_Addr::set (u_short port_number,
ACE_UINT32 inet_address,
@@ -263,11 +310,14 @@ ACE_INET_Addr::set (u_short port_number,
sizeof inet_address,
encode, map);
this->set_port_number (port_number, encode);
return 0;
}
// Initializes a ACE_INET_Addr from a PORT_NUMBER and the remote
// HOST_NAME.
int
ACE_INET_Addr::set (u_short port_number,
const char host_name[],
@@ -275,15 +325,18 @@ ACE_INET_Addr::set (u_short port_number,
int address_family)
{
ACE_TRACE ("ACE_INET_Addr::set");
// Yow, someone gave us a NULL host_name!
if (host_name == 0)
{
errno = EINVAL;
return -1;
}
ACE_OS::memset ((void *) &this->inet_addr_,
0,
sizeof this->inet_addr_);
#if defined (ACE_HAS_IPV6)
struct addrinfo hints;
struct addrinfo *res = 0;
@@ -327,6 +380,7 @@ ACE_INET_Addr::set (u_short port_number,
::freeaddrinfo (res);
return 0;
#else /* ACE_HAS_IPV6 */
// IPv6 not supported... insure the family is set to IPv4
address_family = AF_INET;
this->set_type (address_family);
@@ -348,11 +402,13 @@ ACE_INET_Addr::set (u_short port_number,
hostent hentry;
ACE_HOSTENT_DATA buf;
int h_error = 0; // Not the same as errno!
hostent *hp = ACE_OS::gethostbyname_r (host_name, &hentry,
buf, &h_error);
if (hp == 0)
errno = h_error;
# endif /* ACE_VXWORKS */
if (hp == 0)
{
return -1;
@@ -369,26 +425,33 @@ ACE_INET_Addr::set (u_short port_number,
}
#endif /* ACE_HAS_IPV6 */
}
// Helper function to get a port number from a port name.
static int get_port_number_from_name (const char port_name[],
const char protocol[])
{
// Maybe port_name is directly a port number?
char *endp = 0;
long port_number = ACE_OS::strtol (port_name, &endp, 10);
if (*endp == '\0')
{
// port_name was really a number, and nothing else.
// Check for overflow.
if (port_number < 0 || port_number > ACE_MAX_DEFAULT_PORT)
return -1;
// Return the port number. NOTE: this number must
// be returned in network byte order!
u_short n = static_cast<u_short> (port_number);
n = ACE_HTONS (n);
return n;
}
// We try to resolve port number from its name.
#if defined (ACE_LACKS_GETSERVBYNAME)
port_number = 0;
ACE_UNUSED_ARG (port_name);
@@ -404,47 +467,59 @@ static int get_port_number_from_name (const char port_name[],
if (sp != 0)
port_number = sp->s_port;
#endif /* ACE_LACKS_GETSERVBYNAME */
return port_number;
}
// Initializes a ACE_INET_Addr from a <port_name> and the remote
// <host_name>.
int
ACE_INET_Addr::set (const char port_name[],
const char host_name[],
const char protocol[])
{
ACE_TRACE ("ACE_INET_Addr::set");
int const port_number = get_port_number_from_name (port_name, protocol);
if (port_number == -1)
{
ACE_NOTSUP_RETURN (-1);
}
int address_family = PF_UNSPEC;
# if defined (ACE_HAS_IPV6)
if (ACE_OS::strcmp (ACE_TEXT_CHAR_TO_TCHAR(protocol), ACE_TEXT ("tcp6")) == 0)
address_family = AF_INET6;
# endif /* ACE_HAS_IPV6 */
return this->set (static_cast<u_short> (port_number),
host_name, 0, address_family);
}
// Initializes a ACE_INET_Addr from a <port_name> and a 32 bit
// Internet address.
int
ACE_INET_Addr::set (const char port_name[],
ACE_UINT32 inet_address,
const char protocol[])
{
ACE_TRACE ("ACE_INET_Addr::set");
int const port_number = get_port_number_from_name (port_name, protocol);
if (port_number == -1)
{
ACE_NOTSUP_RETURN (-1);
}
return this->set (static_cast<u_short> (port_number),
inet_address, 0);
}
// Creates a ACE_INET_Addr from a PORT_NUMBER and the remote
// HOST_NAME.
ACE_INET_Addr::ACE_INET_Addr (u_short port_number,
const char host_name[],
int address_family)
@@ -461,6 +536,7 @@ ACE_INET_Addr::ACE_INET_Addr (u_short port_number,
ACE_TEXT_CHAR_TO_TCHAR ((host_name == 0) ?
"<unknown>" : host_name)));
}
#if defined (ACE_HAS_WCHAR)
ACE_INET_Addr::ACE_INET_Addr (u_short port_number,
const wchar_t host_name[],
@@ -480,11 +556,14 @@ ACE_INET_Addr::ACE_INET_Addr (u_short port_number,
host_name)));
}
#endif /* ACE_HAS_WCHAR */
// Creates a ACE_INET_Addr from a sockaddr_in structure.
int
ACE_INET_Addr::set (const sockaddr_in *addr, int len)
{
ACE_TRACE ("ACE_INET_Addr::set");
if (addr->sin_family == AF_INET)
{
int maxlen = static_cast<int> (sizeof (this->inet_addr_.in4_));
@@ -505,27 +584,33 @@ ACE_INET_Addr::set (const sockaddr_in *addr, int len)
return 0;
}
#endif /* ACE_HAS_IPV6 */
errno = EAFNOSUPPORT;
return -1;
}
// Return the address.
void *
ACE_INET_Addr::get_addr (void) const
{
ACE_TRACE ("ACE_INET_Addr::get_addr");
return (void*)&this->inet_addr_;
}
void
ACE_INET_Addr::set_addr (void *addr, int len)
{
this->set_addr (addr, len, 0);
}
// Set a pointer to the address.
void
ACE_INET_Addr::set_addr (void *addr, int /* len */, int map)
{
ACE_TRACE ("ACE_INET_Addr::set_addr");
struct sockaddr_in *getfamily = static_cast<struct sockaddr_in *> (addr);
if (getfamily->sin_family == AF_INET)
{
#if defined (ACE_HAS_IPV6)
@@ -551,7 +636,9 @@ ACE_INET_Addr::set_addr (void *addr, int /* len */, int map)
}
#endif // ACE_HAS_IPV6
}
// Creates a ACE_INET_Addr from a sockaddr_in structure.
ACE_INET_Addr::ACE_INET_Addr (const sockaddr_in *addr, int len)
: ACE_Addr (determine_type (), sizeof (inet_addr_))
{
@@ -559,7 +646,9 @@ ACE_INET_Addr::ACE_INET_Addr (const sockaddr_in *addr, int len)
this->reset ();
this->set (addr, len);
}
// Creates a ACE_INET_Addr from a PORT_NUMBER and an Internet address.
ACE_INET_Addr::ACE_INET_Addr (u_short port_number,
ACE_UINT32 inet_address)
: ACE_Addr (determine_type (), sizeof (inet_addr_))
@@ -571,8 +660,10 @@ ACE_INET_Addr::ACE_INET_Addr (u_short port_number,
ACE_TEXT ("%p\n"),
ACE_TEXT ("ACE_INET_Addr::ACE_INET_Addr")));
}
// Creates a ACE_INET_Addr from a PORT_NAME and the remote
// HOST_NAME.
ACE_INET_Addr::ACE_INET_Addr (const char port_name[],
const char host_name[],
const char protocol[])
@@ -586,6 +677,7 @@ ACE_INET_Addr::ACE_INET_Addr (const char port_name[],
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("ACE_INET_Addr::ACE_INET_Addr")));
}
#if defined (ACE_HAS_WCHAR)
ACE_INET_Addr::ACE_INET_Addr (const wchar_t port_name[],
const wchar_t host_name[],
@@ -601,7 +693,9 @@ ACE_INET_Addr::ACE_INET_Addr (const wchar_t port_name[],
ACE_TEXT ("ACE_INET_Addr::ACE_INET_Addr")));
}
#endif /* ACE_HAS_WCHAR */
// Creates a ACE_INET_Addr from a PORT_NAME and an Internet address.
ACE_INET_Addr::ACE_INET_Addr (const char port_name[],
ACE_UINT32 inet_address,
const char protocol[])
@@ -621,6 +715,7 @@ ACE_INET_Addr::ACE_INET_Addr (const char port_name[],
ACE_UNUSED_ARG (protocol);
#endif
}
#if defined (ACE_HAS_WCHAR)
ACE_INET_Addr::ACE_INET_Addr (const wchar_t port_name[],
ACE_UINT32 inet_address,
@@ -642,14 +737,17 @@ ACE_INET_Addr::ACE_INET_Addr (const wchar_t port_name[],
#endif
}
#endif /* ACE_HAS_WCHAR */
ACE_INET_Addr::~ACE_INET_Addr (void)
{
}
int
ACE_INET_Addr::get_host_name (char hostname[],
size_t len) const
{
ACE_TRACE ("ACE_INET_Addr::get_host_name");
int result;
if (len > 1)
{
@@ -673,44 +771,57 @@ ACE_INET_Addr::get_host_name (char hostname[],
hostname[0] = '\0';
result = -1;
}
return result;
}
#if defined (ACE_HAS_WCHAR)
int
ACE_INET_Addr::get_host_name (wchar_t hostname[],
size_t len) const
{
ACE_TRACE ("ACE_INET_Addr::get_host_name");
char char_hostname [MAXHOSTNAMELEN + 1];
// We have a build in limitation of MAXHOSTNAMELEN
if (len > MAXHOSTNAMELEN + 1)
len = MAXHOSTNAMELEN + 1;
// Call the char version
int result = this->get_host_name (char_hostname, len);
// And copy it over, if successful
if (result == 0)
ACE_OS::strcpy (hostname,
ACE_Ascii_To_Wide (char_hostname).wchar_rep ());
return result;
}
#endif /* ACE_HAS_WCHAR */
// Return the character representation of the hostname.
const char *
ACE_INET_Addr::get_host_name (void) const
{
ACE_TRACE ("ACE_INET_Addr::get_host_name");
static char name[MAXHOSTNAMELEN + 1];
if (this->get_host_name (name, MAXHOSTNAMELEN + 1) == -1)
ACE_OS::strcpy (name, "<unknown>");
return name;
}
void
ACE_INET_Addr::set_port_number (u_short port_number,
int encode)
{
ACE_TRACE ("ACE_INET_Addr::set_port_number");
if (encode)
port_number = ACE_HTONS (port_number);
#if defined (ACE_HAS_IPV6)
if (this->get_type () == AF_INET6)
this->inet_addr_.in6_.sin6_port = port_number;
@@ -718,11 +829,13 @@ ACE_INET_Addr::set_port_number (u_short port_number,
#endif /* ACE_HAS_IPV6 */
this->inet_addr_.in4_.sin_port = port_number;
}
// returns -2 when the hostname is truncated
int
ACE_INET_Addr::get_host_name_i (char hostname[], size_t len) const
{
ACE_TRACE ("ACE_INET_Addr::get_host_name_i");
#if defined (ACE_HAS_IPV6)
if ((this->get_type () == PF_INET6 &&
0 == ACE_OS::memcmp (&this->inet_addr_.in6_.sin6_addr,
@@ -758,6 +871,7 @@ ACE_INET_Addr::get_host_name_i (char hostname[], size_t len) const
void* addr = this->ip_addr_pointer ();
int size = this->ip_addr_size ();
int type = this->get_type ();
# if defined (ACE_HAS_IPV6) && defined (ACE_HAS_BROKEN_GETHOSTBYADDR_V4MAPPED)
// Most OS can not handle IPv6-mapped-IPv4 addresses (even
// though they are meant to) so map them back to IPv4 addresses
@@ -772,6 +886,7 @@ ACE_INET_Addr::get_host_name_i (char hostname[], size_t len) const
type = PF_INET;
}
# endif /* ACE_HAS_IPV6 */
# if defined (DIGITAL_UNIX) && defined (__GNUC__)
hostent * const hp =
ACE_OS::gethostbyaddr (static_cast <char *> (addr), size, type);
@@ -787,8 +902,10 @@ ACE_INET_Addr::get_host_name_i (char hostname[], size_t len) const
buf,
&h_error);
# endif /* DIGITAL_UNIX */
if (hp == 0 || hp->h_name == 0)
return -1;
if (ACE_OS::strlen (hp->h_name) >= len)
{
// We know the length, so use memcpy
@@ -802,11 +919,13 @@ ACE_INET_Addr::get_host_name_i (char hostname[], size_t len) const
// Using errno looks ok, but ENOSPC could be set on
// other places.
}
ACE_OS::strcpy (hostname, hp->h_name);
return 0;
#endif /* ACE_VXWORKS */
}
}
int ACE_INET_Addr::set_address (const char *ip_addr,
int len,
int encode /* = 1 */,
@@ -821,12 +940,14 @@ int ACE_INET_Addr::set_address (const char *ip_addr,
errno = EAFNOSUPPORT;
return -1;
}
if (len == 4)
{
ACE_UINT32 ip4 = *reinterpret_cast<const ACE_UINT32 *> (ip_addr);
if (encode)
ip4 = ACE_HTONL (ip4);
if (this->get_type () == AF_INET && map == 0) {
this->base_set (AF_INET, sizeof (this->inet_addr_.in4_));
#ifdef ACE_HAS_SOCKADDR_IN_SIN_LEN
@@ -869,6 +990,7 @@ int ACE_INET_Addr::set_address (const char *ip_addr,
sizeof (ip6));
return 0;
}
// Build up a 128 bit address. An IPv4-mapped IPv6 address
// is defined as 0:0:0:0:0:ffff:IPv4_address. This is defined
// in RFC 1884 */
@@ -896,13 +1018,17 @@ int ACE_INET_Addr::set_address (const char *ip_addr,
this->inet_addr_.in6_.sin6_len = sizeof (this->inet_addr_.in6_);
#endif
ACE_OS::memcpy (&this->inet_addr_.in6_.sin6_addr, ip_addr, len);
return 0;
} /* end len == 16 */
#endif /* ACE_HAS_IPV6 */
// Here with an unrecognized length.
errno = EAFNOSUPPORT;
return -1;
}
#if (defined (__linux__) || defined (ACE_WIN32)) && defined (ACE_HAS_IPV6)
int
ACE_INET_Addr::set_interface (const char *intf_name)
@@ -926,8 +1052,10 @@ ACE_INET_Addr::set_interface (const char *intf_name)
}
else
return 0;
}
#endif /* __linux && ACE_HAS_IPV6 */
const char *
ACE_INET_Addr::get_host_addr (char *dst, int size) const
{
@@ -939,6 +1067,7 @@ ACE_INET_Addr::get_host_addr (char *dst, int size) const
// representation which is not distinguishable from the IPv4 form which makes
// it impossible to resolve back to an IPv6 INET_Addr without prior knowledge
// that this was such an address to begin with.
//if (IN6_IS_ADDR_V4MAPPED (&this->inet_addr_.in6_.sin6_addr))
//{
// ACE_UINT32 addr;
@@ -946,6 +1075,7 @@ ACE_INET_Addr::get_host_addr (char *dst, int size) const
// addr = ACE_HTONL (addr);
// return ACE_OS::inet_ntop (AF_INET, &addr, dst, size);
//}
# if defined (ACE_WIN32)
if (0 == ::getnameinfo (reinterpret_cast<const sockaddr*> (&this->inet_addr_.in6_),
this->get_size (),
@@ -978,11 +1108,13 @@ ACE_INET_Addr::get_host_addr (char *dst, int size) const
# endif /* ACE_WIN32 */
}
#endif /* ACE_HAS_IPV6 */
return ACE_OS::inet_ntop (AF_INET,
&this->inet_addr_.in4_.sin_addr,
dst,
size);
}
// Return the dotted Internet address.
const char *
ACE_INET_Addr::get_host_addr (void) const
@@ -996,6 +1128,7 @@ ACE_INET_Addr::get_host_addr (void) const
return this->get_host_addr (buf, INET_ADDRSTRLEN);
#endif /* !ACE_HAS_IPV6 */
}
// Return the 4-byte IP address, converting it into host byte order.
ACE_UINT32
ACE_INET_Addr::get_ip_address (void) const
@@ -1014,6 +1147,7 @@ ACE_INET_Addr::get_ip_address (void) const
ACE_OS::memcpy (&addr, thisaddrptr, sizeof (addr));
return ACE_NTOHL (addr);
}
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("ACE_INET_Addr::get_ip_address: address is a IPv6 address not IPv4\n")));
errno = EAFNOSUPPORT;
@@ -1022,5 +1156,6 @@ ACE_INET_Addr::get_ip_address (void) const
#endif /* ACE_HAS_IPV6 */
return ACE_NTOHL (ACE_UINT32 (this->inet_addr_.in4_.sin_addr.s_addr));
}
ACE_END_VERSIONED_NAMESPACE_DECL