ACE_INET_Addr Class Reference

Defines a C++ wrapper facade for the Internet domain address family format. More...

#include <INET_Addr.h>

Inheritance diagram for ACE_INET_Addr:

[legend]Collaboration diagram for ACE_INET_Addr:

[legend]List of all members.

Public Member Functions
	ACE_INET_Addr (void)
	Default constructor.
	ACE_INET_Addr (const ACE_INET_Addr &)
	Copy constructor.
	ACE_INET_Addr (const sockaddr_in *addr, int len)
	Creates an ACE_INET_Addr from a sockaddr_in structure.
	ACE_INET_Addr (u_short port_number, const char host_name[], int address_family=AF_UNSPEC)
	ACE_INET_Addr (const char address[], int address_family=AF_UNSPEC)
	ACE_INET_Addr (u_short port_number, ACE_UINT32 ip_addr=INADDR_ANY)
	ACE_INET_Addr (const char port_name[], const char host_name[], const char protocol[]="tcp")
	ACE_INET_Addr (const char port_name[], ACE_UINT32 ip_addr, const char protocol[]="tcp")
	ACE_INET_Addr (u_short port_number, const wchar_t host_name[], int address_family=AF_UNSPEC)
	ACE_INET_Addr (const wchar_t address[], int address_family=AF_UNSPEC)
	ACE_INET_Addr (const wchar_t port_name[], const wchar_t host_name[], const wchar_t protocol[]=ACE_TEXT_WIDE("tcp"))
	ACE_INET_Addr (const wchar_t port_name[], ACE_UINT32 ip_addr, const wchar_t protocol[]=ACE_TEXT_WIDE("tcp"))
	~ACE_INET_Addr (void)
	Default dtor.
int	set (const ACE_INET_Addr &)
	Initializes from another ACE_INET_Addr.
int	set (u_short port_number, const char host_name[], int encode=1, int address_family=AF_UNSPEC)
int	set (u_short port_number, ACE_UINT32 ip_addr=INADDR_ANY, int encode=1, int map=0)
int	set (const char port_name[], const char host_name[], const char protocol[]="tcp")
int	set (const char port_name[], ACE_UINT32 ip_addr, const char protocol[]="tcp")
int	set (const char addr[], int address_family=AF_UNSPEC)
int	set (const sockaddr_in *, int len)
	Creates an ACE_INET_Addr from a sockaddr_in structure.
int	set (u_short port_number, const wchar_t host_name[], int encode=1, int address_family=AF_UNSPEC)
int	set (const wchar_t port_name[], const wchar_t host_name[], const wchar_t protocol[]=ACE_TEXT_WIDE("tcp"))
int	set (const wchar_t port_name[], ACE_UINT32 ip_addr, const wchar_t protocol[]=ACE_TEXT_WIDE("tcp"))
int	set (const wchar_t addr[], int address_family=AF_UNSPEC)
virtual void *	get_addr (void) const
	Return a pointer to the underlying network address.
int	get_addr_size (void) const
virtual void	set_addr (void *, int len)
	Set a pointer to the address.
virtual void	set_addr (void *, int len, int map)
	Set a pointer to the address.
virtual int	addr_to_string (ACE_TCHAR buffer[], size_t size, int ipaddr_format=1) const
virtual int	string_to_addr (const char address[], int address_family=AF_UNSPEC)
void	set_port_number (u_short, int encode=1)
int	set_address (const char *ip_addr, int len, int encode=1, int map=0)
int	set_interface (const char *intf_name)
u_short	get_port_number (void) const
	Return the port number, converting it into host byte-order.
int	get_host_name (char hostname[], size_t hostnamelen) const
int	get_host_name (wchar_t hostname[], size_t hostnamelen) const
const char *	get_host_name (void) const
const char *	get_host_addr (char *addr, int addr_size) const
const char *	get_host_addr (void) const
ACE_UINT32	get_ip_address (void) const
bool	is_any (void) const
	Return true if the IP address is INADDR_ANY or IN6ADDR_ANY.
bool	is_loopback (void) const
	Return true if the IP address is IPv4/IPv6 loopback address.
bool	is_multicast (void) const
	Return true if the IP address is IPv4/IPv6 multicast address.
bool	is_linklocal (void) const
	Return true if the IP address is IPv6 linklocal address.
bool	is_ipv4_mapped_ipv6 (void) const
	Return true if the IP address is IPv4-mapped IPv6 address.
bool	is_ipv4_compat_ipv6 (void) const
	Return true if the IP address is IPv4-compatible IPv6 address.
bool	operator< (const ACE_INET_Addr &rhs) const
bool	operator== (const ACE_INET_Addr &SAP) const
bool	operator!= (const ACE_INET_Addr &SAP) const
	Compare two addresses for inequality.
bool	is_ip_equal (const ACE_INET_Addr &SAP) const
virtual u_long	hash (void) const
	Computes and returns hash value.
void	dump (void) const
	Dump the state of an object.
Public Attributes
	ACE_ALLOC_HOOK_DECLARE
	Declare the dynamic allocation hooks.
Private Member Functions
int	get_host_name_i (char hostname[], size_t hostnamelen) const
	Insure that hostname is properly null-terminated.
void *	ip_addr_pointer (void) const
int	ip_addr_size (void) const
int	determine_type (void) const
void	reset (void)
	Initialize underlying inet_addr_ to default values.
Private Attributes
union {
sockaddr_in   in4_
sockaddr_in6   in6_
}	inet_addr_

---

Detailed Description

Defines a C++ wrapper facade for the Internet domain address family format.

Definition at line 38 of file INET_Addr.h.

---

Constructor & Destructor Documentation

ACE_INET_Addr::ACE_INET_Addr (  void   )

Default constructor. Definition at line 160 of file INET_Addr.cpp. References reset(). : ACE_Addr (determine_type (), sizeof (inet_addr_)) { // ACE_TRACE ("ACE_INET_Addr::ACE_INET_Addr"); this->reset (); }

ACE_INET_Addr::ACE_INET_Addr (  const ACE_INET_Addr &   )

Copy constructor. Definition at line 280 of file INET_Addr.cpp. References ACE_TRACE, reset(), and set(). : ACE_Addr (sa.get_type (), sa.get_size()) { ACE_TRACE ("ACE_INET_Addr::ACE_INET_Addr"); this->reset (); this->set (sa); }

ACE_INET_Addr::ACE_INET_Addr (  const sockaddr_in *  addr, int  len )

Creates an ACE_INET_Addr from a sockaddr_in structure. Definition at line 623 of file INET_Addr.cpp. References ACE_TRACE, reset(), and set(). : ACE_Addr (determine_type (), sizeof (inet_addr_)) { ACE_TRACE ("ACE_INET_Addr::ACE_INET_Addr"); this->reset (); this->set (addr, len); }

ACE_INET_Addr::ACE_INET_Addr (  u_short  port_number, const char  host_name[], int  address_family = AF_UNSPEC )

Creates an ACE_INET_Addr from a and the remote . The port number is assumed to be in host byte order. To set a port already in network byte order, please See also: set(). Use address_family to select IPv6 (PF_INET6) vs. IPv4 (PF_INET). Definition at line 504 of file INET_Addr.cpp. References ACE_ERROR, ACE_TEXT, ACE_TEXT_CHAR_TO_TCHAR, ACE_TRACE, LM_ERROR, ACE_OS::memset(), and set(). : ACE_Addr (determine_type (), sizeof (inet_addr_)) { ACE_TRACE ("ACE_INET_Addr::ACE_INET_Addr"); ACE_OS::memset (&this->inet_addr_, 0, sizeof (this->inet_addr_)); if (this->set (port_number, host_name, 1, address_family) == -1) ACE_ERROR ((LM_ERROR, ACE_TEXT ("ACE_INET_Addr::ACE_INET_Addr: %p\n"), ACE_TEXT_CHAR_TO_TCHAR ((host_name == 0) ? "<unknown>" : host_name))); }

ACE_INET_Addr::ACE_INET_Addr (  const char  address[], int  address_family = AF_UNSPEC )  [explicit]

Initializes an ACE_INET_Addr from the , which can be "ip-number:port-number" (e.g., "tango.cs.wustl.edu:1234" or "128.252.166.57:1234"). If there is no ':' in the it is assumed to be a port number, with the IP address being INADDR_ANY. Definition at line 259 of file INET_Addr.cpp. References ACE_TRACE, reset(), and set(). : ACE_Addr (determine_type (), sizeof (inet_addr_)) { ACE_TRACE ("ACE_INET_Addr::ACE_INET_Addr"); this->reset (); this->set (address, address_family); }

ACE_INET_Addr::ACE_INET_Addr (  u_short  port_number, ACE_UINT32  ip_addr = INADDR_ANY )  [explicit]

Creates an ACE_INET_Addr from a and an Internet . This method assumes that and are in host byte order. If you have addressing information in network byte order, See also: set(). Definition at line 633 of file INET_Addr.cpp. References ACE_ERROR, ACE_TEXT, ACE_TRACE, LM_ERROR, reset(), and set(). : ACE_Addr (determine_type (), sizeof (inet_addr_)) { ACE_TRACE ("ACE_INET_Addr::ACE_INET_Addr"); this->reset (); if (this->set (port_number, inet_address) == -1) ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("ACE_INET_Addr::ACE_INET_Addr"))); }

ACE_INET_Addr::ACE_INET_Addr (  const char  port_name[], const char  host_name[], const char  protocol[] = "tcp" )

Uses to create an ACE_INET_Addr from a , the remote , and the . Definition at line 648 of file INET_Addr.cpp. References ACE_ERROR, ACE_TEXT, ACE_TRACE, LM_ERROR, reset(), and set(). : ACE_Addr (determine_type (), sizeof (inet_addr_)) { ACE_TRACE ("ACE_INET_Addr::ACE_INET_Addr"); this->reset (); if (this->set (port_name, host_name, protocol) == -1) ACE_ERROR ((LM_ERROR, ACE_TEXT ("ACE_INET_Addr::ACE_INET_Addr"))); }

ACE_INET_Addr::ACE_INET_Addr (  const char  port_name[], ACE_UINT32  ip_addr, const char  protocol[] = "tcp" )

Uses to create an ACE_INET_Addr from a , an Internet , and the . This method assumes that is in host byte order. Definition at line 680 of file INET_Addr.cpp. References ACE_ERROR, ACE_TEXT, ACE_TRACE, LM_ERROR, reset(), and set(). : ACE_Addr (determine_type (), sizeof (inet_addr_)) { ACE_TRACE ("ACE_INET_Addr::ACE_INET_Addr"); #if !defined (ACE_LACKS_HTONL) this->reset (); if (this->set (port_name, htonl (inet_address), protocol) == -1) ACE_ERROR ((LM_ERROR, ACE_TEXT ("ACE_INET_Addr::ACE_INET_Addr"))); #else ACE_UNUSED_ARG (port_name); ACE_UNUSED_ARG (inet_address); ACE_UNUSED_ARG (protocol); #endif }

ACE_INET_Addr::ACE_INET_Addr (  u_short  port_number, const wchar_t  host_name[], int  address_family = AF_UNSPEC )

Definition at line 522 of file INET_Addr.cpp. References ACE_ERROR, ACE_TEXT, ACE_TEXT_WCHAR_TO_TCHAR, ACE_TEXT_WIDE, ACE_TRACE, LM_ERROR, ACE_OS::memset(), and set(). : ACE_Addr (determine_type (), sizeof (inet_addr_)) { ACE_TRACE ("ACE_INET_Addr::ACE_INET_Addr"); ACE_OS::memset (&this->inet_addr_, 0, sizeof (this->inet_addr_)); if (this->set (port_number, host_name, 1, address_family) == -1) ACE_ERROR ((LM_ERROR, ACE_TEXT ("ACE_INET_Addr::ACE_INET_Addr: %p\n"), ACE_TEXT_WCHAR_TO_TCHAR ((host_name == 0) ? ACE_TEXT_WIDE ("<unknown>") : host_name))); }

ACE_INET_Addr::ACE_INET_Addr (  const wchar_t  address[], int  address_family = AF_UNSPEC )  [explicit]

Definition at line 268 of file INET_Addr.cpp. References ACE_TRACE, reset(), and set(). : ACE_Addr (determine_type (), sizeof (inet_addr_)) { ACE_TRACE ("ACE_INET_Addr::ACE_INET_Addr"); this->reset (); this->set (address, address_family); }

ACE_INET_Addr::ACE_INET_Addr (  const wchar_t  port_name[], const wchar_t  host_name[], const wchar_t  protocol[] = ACE_TEXT_WIDE("tcp") )

Definition at line 663 of file INET_Addr.cpp. References ACE_ERROR, ACE_TEXT, ACE_TRACE, LM_ERROR, reset(), and set(). : ACE_Addr (determine_type (), sizeof (inet_addr_)) { ACE_TRACE ("ACE_INET_Addr::ACE_INET_Addr"); this->reset (); if (this->set (port_name, host_name, protocol) == -1) ACE_ERROR ((LM_ERROR, ACE_TEXT ("ACE_INET_Addr::ACE_INET_Addr"))); }

ACE_INET_Addr::ACE_INET_Addr (  const wchar_t  port_name[], ACE_UINT32  ip_addr, const wchar_t  protocol[] = ACE_TEXT_WIDE("tcp") )

Definition at line 701 of file INET_Addr.cpp. References ACE_ERROR, ACE_TEXT, ACE_TRACE, LM_ERROR, reset(), and set(). : ACE_Addr (determine_type (), sizeof (inet_addr_)) { ACE_TRACE ("ACE_INET_Addr::ACE_INET_Addr"); #if !defined (ACE_LACKS_HTONL) this->reset (); if (this->set (port_name, htonl (inet_address), protocol) == -1) ACE_ERROR ((LM_ERROR, ACE_TEXT ("ACE_INET_Addr::ACE_INET_Addr"))); #else ACE_UNUSED_ARG (port_name); ACE_UNUSED_ARG (inet_address); ACE_UNUSED_ARG (protocol); #endif }

ACE_INET_Addr::~ACE_INET_Addr (  void   )

Default dtor. Definition at line 722 of file INET_Addr.cpp. { }

---

Member Function Documentation

ACE_BEGIN_VERSIONED_NAMESPACE_DECL int ACE_INET_Addr::addr_to_string (  ACE_TCHAR  buffer[], size_t  size, int  ipaddr_format = 1 )  const [virtual]

Transform the current ACE_INET_Addr address into string format. If is non-0 this produces "ip-number:port-number" (e.g., "128.252.166.57:1234"), whereas if is 0 this produces "ip-name:port-number" (e.g., "tango.cs.wustl.edu:1234"). Returns -1 if the size of the is too small, else 0. Definition at line 32 of file INET_Addr.cpp. References ACE_TCHAR, ACE_TEXT, ACE_TEXT_CHAR_TO_TCHAR, ACE_TRACE, get_host_addr(), get_host_name(), MAXHOSTNAMELEN, ACE_OS::sprintf(), ACE_OS::strchr(), and ACE_OS::strlen(). Referenced by ACE_SDM_helpers::addr_to_string(), and dump(). { 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. + 1 // sizeof (':'), addr/port sep + 1; // sizeof ('\0'), terminating NUL #if !defined (ACE_WIN32) && defined (ACE_USES_WCHAR) ACE_TCHAR const *format = ACE_TEXT("%ls:%d"); #else ACE_TCHAR const *format = ACE_TEXT("%s:%d"); #endif /* !ACE_WIN32 && ACE_USES_WCHAR */ #if defined (ACE_HAS_IPV6) if (ACE_OS::strchr (hoststr, ACE_TEXT (':')) != 0) { total_len += 2; // ACE_OS::strlen ("[]") IPv6 addr frames # if !defined (ACE_WIN32) && defined (ACE_USES_WCHAR) format = ACE_TEXT("[%ls]:%d"); # else format = ACE_TEXT("[%s]:%d"); # endif /* !ACE_WIN32 && ACE_USES_WCHAR */ } #endif // ACE_HAS_IPV6 if (size < total_len) return -1; else ACE_OS::sprintf (s, format, ACE_TEXT_CHAR_TO_TCHAR (hoststr), this->get_port_number ()); return 0; }

ACE_INLINE int ACE_INET_Addr::determine_type (  void   )  const [private]

Definition at line 35 of file INET_Addr.inl. References AF_INET, and ACE::ipv6_enabled(). { #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 */ }

void ACE_INET_Addr::dump (  void   )  const

Dump the state of an object. Reimplemented from ACE_Addr. Definition at line 82 of file INET_Addr.cpp. References ACE_BEGIN_DUMP, ACE_DEBUG, ACE_END_DUMP, ACE_MAX_FULLY_QUALIFIED_NAME_LEN, ACE_TCHAR, ACE_TEXT, ACE_TRACE, addr_to_string(), and LM_DEBUG. Referenced by ACE_TSS_Connection::dump(). { #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 */ }

void * ACE_INET_Addr::get_addr (  void   )  const [virtual]

Return a pointer to the underlying network address. Reimplemented from ACE_Addr. Definition at line 576 of file INET_Addr.cpp. References ACE_TRACE, and inet_addr_. Referenced by ACE::bind_port(), ACE_Multihomed_INET_Addr::get_addresses(), ACE::get_fqdn(), ACE_SOCK_Dgram::make_multicast_ifaddr6(), and ACE_SOCK_SEQPACK_Acceptor::shared_open(). { ACE_TRACE ("ACE_INET_Addr::get_addr"); return (void*)&this->inet_addr_; }

ACE_INLINE int ACE_INET_Addr::get_addr_size (  void   )  const

Definition at line 104 of file INET_Addr.inl. References ACE_TRACE, ACE_Addr::get_type(), inet_addr_, and PF_INET. { 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 */ }

const char * ACE_INET_Addr::get_host_addr (  void   )  const

Return the "dotted decimal" Internet address representation of the hostname. This version is non-reentrant since it returns a pointer to a static data area. You should therefore either (1) do a "deep copy" of the address returned by get_host_addr(), e.g., using strdup() or (2) use the "reentrant" version of get_host_addr() described above. Definition at line 1104 of file INET_Addr.cpp. References ACE_TRACE, INET6_ADDRSTRLEN, and ACE_OS::inet_ntoa(). Referenced by addr_to_string(). { ACE_TRACE ("ACE_INET_Addr::get_host_addr"); #if defined (ACE_HAS_IPV6) static char buf[INET6_ADDRSTRLEN]; return this->get_host_addr (buf, INET6_ADDRSTRLEN); #else /* ACE_HAS_IPV6 */ # if defined (ACE_VXWORKS) // It would be nice to be able to encapsulate this into // ACE_OS::inet_ntoa(), but that would lead to either inefficiencies // on vxworks or lack of thread safety. // // So, we use the way that vxworks suggests. ACE_INET_Addr *ncthis = const_cast<ACE_INET_Addr *> (this); inet_ntoa_b (this->inet_addr_.in4_.sin_addr, ncthis->buf_); return &buf_[0]; # else /* ACE_VXWORKS */ return ACE_OS::inet_ntoa (this->inet_addr_.in4_.sin_addr); # endif /* !ACE_VXWORKS */ #endif /* !ACE_HAS_IPV6 */ }

const char * ACE_INET_Addr::get_host_addr (  char *  addr, int  addr_size )  const

Return the "dotted decimal" Internet address representation of the hostname storing it in the addr (which is assumed to be bytes long). This version is reentrant. Definition at line 1030 of file INET_Addr.cpp. References ACE_Addr::get_size(), ACE_Addr::get_type(), inet_addr_, ACE_OS::inet_ntoa(), ACE_OS::inet_ntop(), ACE_OS::set_errno_to_wsa_last_error(), ACE_OS::sprintf(), ACE_OS::strcat(), ACE_OS::strlen(), and ACE_OS::strsncpy(). { #if defined (ACE_HAS_IPV6) if (this->get_type () == AF_INET6) { // mcorino@remedy.nl - Aug-26, 2005 // I don't think this should be done because it results in a decimal address // 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; // addr = this->get_ip_address(); // 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 (), dst, size, 0, 0, // Don't want service name NI_NUMERICHOST)) return dst; ACE_OS::set_errno_to_wsa_last_error (); return 0; # else const char *ch = ACE_OS::inet_ntop (AF_INET6, &this->inet_addr_.in6_.sin6_addr, dst, size); #if defined (__linux__) if ((IN6_IS_ADDR_LINKLOCAL (&this->inet_addr_.in6_.sin6_addr) || IN6_IS_ADDR_MC_LINKLOCAL (&this->inet_addr_.in6_.sin6_addr)) && this->inet_addr_.in6_.sin6_scope_id != 0) { char scope_buf[32]; ACE_OS::sprintf (scope_buf, "%%%u", this->inet_addr_.in6_.sin6_scope_id); if ((ACE_OS::strlen (ch)+ACE_OS::strlen (scope_buf)) < (size_t)size) { ACE_OS::strcat (dst, scope_buf); } } #endif return ch; # endif /* ACE_WIN32 */ } #endif /* ACE_HAS_IPV6 */ #if defined (ACE_VXWORKS) ACE_UNUSED_ARG (dst); ACE_UNUSED_ARG (size); // It would be nice to be able to encapsulate this into // ACE_OS::inet_ntoa(), but that would lead to either inefficiencies // on vxworks or lack of thread safety. // // So, we use the way that vxworks suggests. ACE_INET_Addr *ncthis = const_cast<ACE_INET_Addr *> (this); inet_ntoa_b(this->inet_addr_.in4_.sin_addr, ncthis->buf_); ACE_OS::strsncpy (dst, &buf_[0], size); return &buf_[0]; #else /* ACE_VXWORKS */ char *ch = ACE_OS::inet_ntoa (this->inet_addr_.in4_.sin_addr); ACE_OS::strsncpy (dst, ch, size); return ch; #endif }

const char * ACE_INET_Addr::get_host_name (  void   )  const

Return the character representation of the hostname. This version is non-reentrant since it returns a pointer to a static data area. You should therefore either (1) do a "deep copy" of the address returned by get_host_name(), e.g., using strdup() or (2) use the "reentrant" version of get_host_name() described above. Definition at line 787 of file INET_Addr.cpp. References ACE_TRACE, MAXHOSTNAMELEN, and ACE_OS::strcpy(). Referenced by addr_to_string(), and get_host_name(). { 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; }

int ACE_INET_Addr::get_host_name (  wchar_t  hostname[], size_t  hostnamelen )  const

Definition at line 761 of file INET_Addr.cpp. References ACE_TRACE, get_host_name(), MAXHOSTNAMELEN, and ACE_OS::strcpy(). { 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; }

int ACE_INET_Addr::get_host_name (  char  hostname[], size_t  hostnamelen )  const

Return the character representation of the name of the host, storing it in the (which is assumed to be bytes long). This version is reentrant. If is greater than 0 then will be NUL-terminated even if -1 is returned. Definition at line 727 of file INET_Addr.cpp. References ACE_TRACE, and get_host_name_i(). Referenced by ACE_Service_Manager::handle_input(). { ACE_TRACE ("ACE_INET_Addr::get_host_name"); int result; if (len > 1) { result = get_host_name_i (hostname,len); if (result < 0) { if (result == -2) // We know that hostname is nul-terminated result = -1; else { //result == -1; // This could be worse than hostname[len -1] = '\0'? hostname[0] = '\0'; } } } else { if (len == 1) hostname[0] = '\0'; result = -1; } return result; }

int ACE_INET_Addr::get_host_name_i (  char  hostname[], size_t  hostnamelen )  const [private]

Insure that hostname is properly null-terminated. Definition at line 816 of file INET_Addr.cpp. References ACE_HOSTENT_DATA, ACE_TRACE, ACE_Addr::get_type(), ACE_OS::gethostbyaddr(), ACE_OS::gethostbyaddr_r(), ACE_OS::hostname(), INADDR_ANY, inet_addr_, ip_addr_size(), ACE_OS::memcmp(), ACE_OS::memcpy(), PF_INET, ACE_OS::strcpy(), and ACE_OS::strlen(). Referenced by get_host_name(). { 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, &in6addr_any, sizeof (this->inet_addr_.in6_.sin6_addr))) || (this->get_type () == PF_INET && this->inet_addr_.in4_.sin_addr.s_addr == INADDR_ANY)) #else if (this->inet_addr_.in4_.sin_addr.s_addr == INADDR_ANY) #endif /* ACE_HAS_IPV6 */ { if (ACE_OS::hostname (hostname, len) == -1) return -1; else return 0; } else { #if defined (ACE_VXWORKS) && defined (ACE_LACKS_GETHOSTBYADDR) ACE_UNUSED_ARG (len); int error = ::hostGetByAddr ((int) this->inet_addr_.in4_.sin_addr.s_addr, hostname); if (error == OK) return 0; else { errno = error; return -1; } #else # if defined (DIGITAL_UNIX) && defined (__GNUC__) hostent *hp = ACE_OS::gethostbyaddr ((char *)this->ip_addr_pointer (), this->ip_addr_size (), this->get_type ()); # else int h_error; // Not the same as errno! hostent hentry; ACE_HOSTENT_DATA buf; hostent *hp = ACE_OS::gethostbyaddr_r ((char *)this->ip_addr_pointer (), this->ip_addr_size (), this->get_type (), &hentry, 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 if (len > 0) { ACE_OS::memcpy (hostname, hp->h_name, len - 1); hostname[len-1]= '\0'; } errno = ENOSPC; return -2; // -2 Means that we have a good string // Using errno looks ok, but ENOSPC could be set on // other places. } ACE_OS::strcpy (hostname, hp->h_name); return 0; #endif /* ACE_VXWORKS */ } }

ACE_UINT32 ACE_INET_Addr::get_ip_address (  void   )  const

Return the 4-byte IP address, converting it into host byte order. Definition at line 1128 of file INET_Addr.cpp. References ACE_ERROR, ACE_NTOHL, ACE_TEXT, ACE_TRACE, EAFNOSUPPORT, ACE_Addr::get_type(), ip_addr_pointer(), LM_ERROR, and ACE_OS::memcpy(). Referenced by hash(), is_ip_equal(), is_loopback(), ACE_SOCK_Dgram::make_multicast_ifaddr(), and operator<(). { ACE_TRACE ("ACE_INET_Addr::get_ip_address"); #if defined (ACE_HAS_IPV6) if (this->get_type () == AF_INET6) { if (IN6_IS_ADDR_V4MAPPED (&this->inet_addr_.in6_.sin6_addr) || IN6_IS_ADDR_V4COMPAT (&this->inet_addr_.in6_.sin6_addr) ) { ACE_UINT32 addr; // Return the last 32 bits of the address char *thisaddrptr = (char*)this->ip_addr_pointer (); thisaddrptr += 128/8 - 32/8; 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; return 0; } #endif /* ACE_HAS_IPV6 */ return ACE_NTOHL (ACE_UINT32 (this->inet_addr_.in4_.sin_addr.s_addr)); }

ACE_INLINE u_short ACE_INET_Addr::get_port_number (  void   )  const

Return the port number, converting it into host byte-order. Definition at line 88 of file INET_Addr.inl. References ACE_NOTSUP_RETURN, ACE_TRACE, ACE_Addr::get_type(), and PF_INET. Referenced by ACE_MEM_Acceptor::accept(), ACE_MEM_Acceptor::get_local_addr(), ACE_Service_Manager::handle_input(), hash(), ACE_Service_Manager::info(), ACE_SOCK_Dgram_Mcast::join(), ACE_SOCK_Dgram::make_multicast_ifaddr(), ACE_Pipe::open(), ACE_SOCK_Dgram_Mcast::open_i(), and operator<(). { ACE_TRACE ("ACE_INET_Addr::get_port_number"); #if defined (ACE_LACKS_NTOHS) ACE_NOTSUP_RETURN (0); #elif defined (ACE_HAS_IPV6) if (this->get_type () == PF_INET) return ntohs (this->inet_addr_.in4_.sin_port); else return ntohs (this->inet_addr_.in6_.sin6_port); #else return ntohs (this->inet_addr_.in4_.sin_port); #endif /* ACE_HAS_IPV6 */ }

u_long ACE_INET_Addr::hash (  void   )  const [virtual]

Computes and returns hash value. Reimplemented from ACE_Addr. Definition at line 147 of file INET_Addr.cpp. References get_ip_address(), get_port_number(), ACE_Addr::get_type(), and ip_addr_pointer(). { #if defined (ACE_HAS_IPV6) if (this->get_type () == PF_INET6) { const unsigned int *addr = (const unsigned int*)this->ip_addr_pointer(); return addr[0] + addr[1] + addr[2] + addr[3] + this->get_port_number(); } else #endif /* ACE_HAS_IPV6 */ return this->get_ip_address () + this->get_port_number (); }

ACE_INLINE void * ACE_INET_Addr::ip_addr_pointer (  void   )  const [private]

Definition at line 49 of file INET_Addr.inl. References ACE_Addr::get_type(), inet_addr_, and PF_INET. Referenced by get_ip_address(), hash(), is_ip_equal(), and operator<(). { #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 [private]

Definition at line 62 of file INET_Addr.inl. References ACE_Addr::get_type(), inet_addr_, and PF_INET. Referenced by get_host_name_i(), and operator<(). { // 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 // These _UNICOS changes were picked up from pre-IPv6 code in // get_host_name_i... the IPv6 section above may need something // similar, so keep an eye out for it. # if !defined(_UNICOS) return static_cast<int> (sizeof this->inet_addr_.in4_.sin_addr.s_addr); # else /* _UNICOS */ return static_cast<int> (sizeof this->inet_addr_.in4_.sin_addr); # endif /* ! _UNICOS */ #endif /* ACE_HAS_IPV6 */ }

ACE_INLINE bool ACE_INET_Addr::is_any (  void   )  const

Return true if the IP address is INADDR_ANY or IN6ADDR_ANY. Definition at line 189 of file INET_Addr.inl. References ACE_Addr::get_type(), INADDR_ANY, and inet_addr_. Referenced by ACE_SOCK_Dgram_Mcast::join(). { #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); }

bool ACE_INET_Addr::is_ip_equal (  const ACE_INET_Addr &  SAP  )  const

A variation of the equality operator, this method only compares the IP address and ignores the port number. Definition at line 122 of file INET_Addr.cpp. References get_ip_address(), ACE_Addr::get_size(), ACE_Addr::get_type(), and ip_addr_pointer(). { 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) { const unsigned int *addr = reinterpret_cast<const unsigned int*>(this->ip_addr_pointer()); const unsigned int *saddr = reinterpret_cast<const unsigned int*>(sap.ip_addr_pointer()); return (addr[0] == saddr[0] && addr[1] == saddr[1] && addr[2] == saddr[2] && addr[3] == saddr[3]); } else #endif /* ACE_HAS_IPV6 */ return this->get_ip_address () == sap.get_ip_address(); }

ACE_INLINE bool ACE_INET_Addr::is_ipv4_compat_ipv6 (  void   )  const

Return true if the IP address is IPv4-compatible IPv6 address. Definition at line 248 of file INET_Addr.inl. References ACE_Addr::get_type(). { if (this->get_type () == AF_INET6) return IN6_IS_ADDR_V4COMPAT (&this->inet_addr_.in6_.sin6_addr); return false; }

ACE_INLINE bool ACE_INET_Addr::is_ipv4_mapped_ipv6 (  void   )  const

Return true if the IP address is IPv4-mapped IPv6 address. Definition at line 238 of file INET_Addr.inl. References ACE_Addr::get_type(). { if (this->get_type () == AF_INET6) return IN6_IS_ADDR_V4MAPPED (&this->inet_addr_.in6_.sin6_addr); return false; }

ACE_INLINE bool ACE_INET_Addr::is_linklocal (  void   )  const

Return true if the IP address is IPv6 linklocal address. Definition at line 228 of file INET_Addr.inl. References ACE_Addr::get_type(). { if (this->get_type () == AF_INET6) return IN6_IS_ADDR_LINKLOCAL (&this->inet_addr_.in6_.sin6_addr); return false; }

ACE_INLINE bool ACE_INET_Addr::is_loopback (  void   )  const

Return true if the IP address is IPv4/IPv6 loopback address. Definition at line 201 of file INET_Addr.inl. References get_ip_address(), ACE_Addr::get_type(), and INADDR_LOOPBACK. Referenced by ACE_SOCK_Dgram_Mcast::subscribe_ifs(), and ACE_SOCK_Dgram_Mcast::unsubscribe_ifs(). { #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)); }

ACE_INLINE bool ACE_INET_Addr::is_multicast (  void   )  const

Return true if the IP address is IPv4/IPv6 multicast address. Definition at line 214 of file INET_Addr.inl. References ACE_Addr::get_type(), and inet_addr_. { #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 this->inet_addr_.in4_.sin_addr.s_addr >= 0xE0000000 && // 224.0.0.0 this->inet_addr_.in4_.sin_addr.s_addr <= 0xEFFFFFFF; // 239.255.255.255 }

bool ACE_INET_Addr::operator!= (  const ACE_INET_Addr &  SAP  )  const

Compare two addresses for inequality. Definition at line 99 of file INET_Addr.cpp. References ACE_TRACE. { ACE_TRACE ("ACE_INET_Addr::operator !="); return !((*this) == sap); }

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

Returns true if this is less than rhs. In this context, "less than" is defined in terms of IP address and TCP port number. This operator makes it possible to use ACE_INET_Addrs in STL maps. Definition at line 118 of file INET_Addr.inl. References get_ip_address(), get_port_number(), ACE_Addr::get_type(), inet_addr_, ip_addr_pointer(), ip_addr_size(), and ACE_OS::memcmp(). { #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 ()); }

bool ACE_INET_Addr::operator== (  const ACE_INET_Addr &  SAP  )  const

Compare two addresses for equality. The addresses are considered equal if they contain the same IP address and port number. Definition at line 108 of file INET_Addr.cpp. References ACE_TRACE, ACE_Addr::get_size(), ACE_Addr::get_type(), inet_addr_, and ACE_OS::memcmp(). { 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); }

ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE void ACE_INET_Addr::reset (  void   )  [private]

Initialize underlying inet_addr_ to default values. Definition at line 13 of file INET_Addr.inl. References AF_INET, ACE_Addr::get_type(), inet_addr_, and ACE_OS::memset(). Referenced by ACE_INET_Addr(). { 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 */ }

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

Definition at line 180 of file INET_Addr.inl. References set(). { return this->set (ACE_Wide_To_Ascii (addr).char_rep (), address_family); }

ACE_INLINE int ACE_INET_Addr::set (  const wchar_t  port_name[], ACE_UINT32  ip_addr, const wchar_t  protocol[] = ACE_TEXT_WIDE("tcp") )

Definition at line 170 of file INET_Addr.inl. References set(). { 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  port_name[], const wchar_t  host_name[], const wchar_t  protocol[] = ACE_TEXT_WIDE("tcp") )

Definition at line 160 of file INET_Addr.inl. References set(). { 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 (  u_short  port_number, const wchar_t  host_name[], int  encode = 1, int  address_family = AF_UNSPEC )

Definition at line 148 of file INET_Addr.inl. References set(). { return this->set (port_number, ACE_Wide_To_Ascii (host_name).char_rep (), encode, address_family); }

int ACE_INET_Addr::set (  const sockaddr_in *  , int  len )

Creates an ACE_INET_Addr from a sockaddr_in structure. Definition at line 544 of file INET_Addr.cpp. References ACE_TRACE, AF_INET, ACE_Addr::base_set(), EAFNOSUPPORT, inet_addr_, and ACE_OS::memcpy(). { ACE_TRACE ("ACE_INET_Addr::set"); if (addr->sin_family == AF_INET) { int maxlen = static_cast<int> (sizeof (this->inet_addr_.in4_)); if (len > maxlen) len = maxlen; ACE_OS::memcpy (&this->inet_addr_.in4_, addr, len); this->base_set (AF_INET, len); return 0; } #if defined (ACE_HAS_IPV6) else if (addr->sin_family == AF_INET6) { int maxlen = static_cast<int> (sizeof (this->inet_addr_.in6_)); if (len > maxlen) len = maxlen; ACE_OS::memcpy (&this->inet_addr_.in6_, addr, len); this->base_set (AF_INET6, len); return 0; } #endif /* ACE_HAS_IPV6 */ errno = EAFNOSUPPORT; return -1; }

int ACE_INET_Addr::set (  const char  addr[], int  address_family = AF_UNSPEC )

Initializes an ACE_INET_Addr from the addr, which can be "ip-number:port-number" (e.g., "tango.cs.wustl.edu:1234" or "128.252.166.57:1234"). If there is no ':' in the it is assumed to be a port number, with the IP address being INADDR_ANY. Definition at line 253 of file INET_Addr.cpp. References ACE_TRACE, and string_to_addr(). { ACE_TRACE ("ACE_INET_Addr::set"); return this->string_to_addr (address, address_family); }

int ACE_INET_Addr::set (  const char  port_name[], ACE_UINT32  ip_addr, const char  protocol[] = "tcp" )

Uses to initialize an ACE_INET_Addr from a , an , and the . This assumes that is already in network byte order. Definition at line 484 of file INET_Addr.cpp. References ACE_NOTSUP_RETURN, ACE_TRACE, get_port_number_from_name(), and set(). { ACE_TRACE ("ACE_INET_Addr::set"); int const port_number = get_port_number_from_name (port_name, protocol); if (port_number == -1) { ACE_UNUSED_ARG (inet_address); ACE_NOTSUP_RETURN (-1); } return this->set (static_cast<u_short> (port_number), inet_address, 0); }

int ACE_INET_Addr::set (  const char  port_name[], const char  host_name[], const char  protocol[] = "tcp" )

Uses to initialize an ACE_INET_Addr from a , the remote , and the . Definition at line 457 of file INET_Addr.cpp. References ACE_NOTSUP_RETURN, ACE_TEXT, ACE_TEXT_CHAR_TO_TCHAR, ACE_TRACE, get_port_number_from_name(), PF_UNSPEC, set(), and ACE_OS::strcmp(). { ACE_TRACE ("ACE_INET_Addr::set"); int port_number = get_port_number_from_name (port_name, protocol); if (port_number == -1) { ACE_UNUSED_ARG (host_name); 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); }

int ACE_INET_Addr::set (  u_short  port_number, ACE_UINT32  ip_addr = INADDR_ANY, int  encode = 1, int  map = 0 )

Initializes an ACE_INET_Addr from a port_number and an Internet ip_addr. If encode is non-zero then the port number and IP address are converted into network byte order, otherwise they are assumed to be in network byte order already and are passed straight through. If is non-zero and IPv6 support has been compiled in, then this address will be set to the IPv4-mapped IPv6 address of it. Definition at line 292 of file INET_Addr.cpp. References ACE_TRACE, set_address(), and set_port_number(). { ACE_TRACE ("ACE_INET_Addr::set"); this->set_address (reinterpret_cast<const char *> (&inet_address), sizeof inet_address, encode, map); this->set_port_number (port_number, encode); return 0; }

int ACE_INET_Addr::set (  u_short  port_number, const char  host_name[], int  encode = 1, int  address_family = AF_UNSPEC )

Initializes an ACE_INET_Addr from a and the remote . If is non-zero then is converted into network byte order, otherwise it is assumed to be in network byte order already and are passed straight through. address_family can be used to select IPv4/IPv6 if the OS has IPv6 capability (ACE_HAS_IPV6 is defined). To specify IPv6, use the value AF_INET6. To specify IPv4, use AF_INET. Definition at line 311 of file INET_Addr.cpp. References ACE_HOSTENT_DATA, ACE_NTOHL, ACE_TRACE, AF_INET, AF_UNSPEC, ACE_OS::gethostbyname(), ACE_OS::gethostbyname_r(), inet_addr_, ACE_OS::inet_aton(), ACE::ipv6_enabled(), ACE_OS::memcpy(), ACE_OS::memset(), set(), set_addr(), set_port_number(), and ACE_Addr::set_type(). { 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; int error = 0; ACE_OS::memset (&hints, 0, sizeof (hints)); # if defined (ACE_USES_IPV4_IPV6_MIGRATION) if (address_family == AF_UNSPEC && !ACE::ipv6_enabled()) address_family = AF_INET; # endif /* ACE_USES_IPV4_IPV6_MIGRATION */ if (address_family == AF_UNSPEC || address_family == AF_INET6) { hints.ai_family = AF_INET6; error = ::getaddrinfo (host_name, 0, &hints, &res); if (error) { if (address_family == AF_INET6) { if (res) ::freeaddrinfo(res); return -1; } address_family = AF_INET; } } if (address_family == AF_INET) { hints.ai_family = AF_INET; error = ::getaddrinfo (host_name, 0, &hints, &res); if (error) { if (res) ::freeaddrinfo(res); return -1; } } this->set_type (res->ai_family); this->set_addr (res->ai_addr, res->ai_addrlen); this->set_port_number (port_number, encode); ::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); this->inet_addr_.in4_.sin_family = static_cast<short> (address_family); struct in_addr addrv4; if (ACE_OS::inet_aton (host_name, &addrv4) == 1) return this->set (port_number, encode ? ACE_NTOHL (addrv4.s_addr) : addrv4.s_addr, encode); else { # if defined (ACE_VXWORKS) && defined (ACE_LACKS_GETHOSTBYNAME) hostent *hp = ACE_OS::gethostbyname (host_name); # else hostent hentry; ACE_HOSTENT_DATA buf; int h_error; // Not the same as errno! hostent *hp = ACE_OS::gethostbyname_r (host_name, &hentry, buf, &h_error); # endif /* ACE_VXWORKS */ if (hp == 0) { return -1; } else { (void) ACE_OS::memcpy ((void *) &addrv4.s_addr, hp->h_addr, hp->h_length); return this->set (port_number, encode ? ACE_NTOHL (addrv4.s_addr) : addrv4.s_addr, encode); } } #endif /* ACE_HAS_IPV6 */ }

int ACE_INET_Addr::set (  const ACE_INET_Addr &   )

Initializes from another ACE_INET_Addr. Definition at line 168 of file INET_Addr.cpp. References ACE_TRACE, AF_ANY, ACE_Addr::get_size(), ACE_Addr::get_type(), inet_addr_, ACE_OS::memcpy(), ACE_OS::memset(), ACE_Addr::set_size(), and ACE_Addr::set_type(). Referenced by ACE_INET_Addr(), ACE_Multihomed_INET_Addr::ACE_Multihomed_INET_Addr(), ACE::bind_port(), ACE::get_ip_interfaces(), get_ip_interfaces_win32(), ACE_Multihomed_INET_Addr::get_secondary_addresses(), ACE_Service_Manager::init(), ACE_SOCK_Dgram::make_multicast_ifaddr(), ACE_Remote_Name_Space::open(), ACE_SOCK_Dgram_Mcast::open_i(), ACE_Multihomed_INET_Addr::set(), set(), ACE_SOCK_Dgram::set_nic(), and string_to_addr(). { 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_)); else { // It's ok to make the copy. 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; }

void ACE_INET_Addr::set_addr (  void *  , int  len, int  map )  [virtual]

Set a pointer to the address. Definition at line 590 of file INET_Addr.cpp. References ACE_TRACE, AF_INET, inet_addr_, set_address(), set_port_number(), and ACE_Addr::set_type(). { 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) if (map) this->set_type (AF_INET6); else #endif /* ACE_HAS_IPV6 */ this->set_type (AF_INET); this->set_port_number (getfamily->sin_port, 0); this->set_address (reinterpret_cast<const char*> (&getfamily->sin_addr), sizeof (getfamily->sin_addr), 0, map); } #if defined (ACE_HAS_IPV6) else if (getfamily->sin_family == AF_INET6) { struct sockaddr_in6 *in6 = static_cast<struct sockaddr_in6*> (addr); this->set_port_number (in6->sin6_port, 0); this->set_address (reinterpret_cast<const char*> (&in6->sin6_addr), sizeof (in6->sin6_addr), 0); this->inet_addr_.in6_.sin6_scope_id = in6->sin6_scope_id; } #endif // ACE_HAS_IPV6 }

void ACE_INET_Addr::set_addr (  void *  , int  len )  [virtual]

Set a pointer to the address. Reimplemented from ACE_Addr. Definition at line 583 of file INET_Addr.cpp. Referenced by ACE_SOCK_SEQPACK_Association::get_local_addrs(), ACE_SOCK_SEQPACK_Association::get_remote_addrs(), and set(). { this->set_addr (addr, len, 0); }

int ACE_INET_Addr::set_address (  const char *  ip_addr, int  len, int  encode = 1, int  map = 0 )

Sets the address without affecting the port number. If is enabled then is converted into network byte order, otherwise it is assumed to be in network byte order already and are passed straight through. The size of the address is specified in the len parameter. If is non-zero, IPv6 support has been compiled in, and is an IPv4 address, then this address is set to the IPv4-mapped IPv6 address of it. Definition at line 892 of file INET_Addr.cpp. References ACE_HTONL, ACE_TRACE, AF_INET, ACE_Addr::base_set(), EAFNOSUPPORT, ACE_Addr::get_type(), INADDR_ANY, INADDR_LOOPBACK, inet_addr_, ACE_OS::memcpy(), ACE_OS::memset(), and ACE_Addr::set_size(). Referenced by set(), and set_addr(). { ACE_TRACE ("ACE_INET_Addr::set_address"); // This is really intended for IPv4. If the object is IPv4, or the type // hasn't been set but it's a 4-byte address, go ahead. If this is an // IPv6 object and <encode> is requested, refuse. if (encode && len != 4) { 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 this->inet_addr_.in4_.sin_len = sizeof (this->inet_addr_.in4_); #endif this->inet_addr_.in4_.sin_family = AF_INET; this->set_size (sizeof (this->inet_addr_.in4_)); ACE_OS::memcpy (&this->inet_addr_.in4_.sin_addr, &ip4, len); } #if defined (ACE_HAS_IPV6) else if (map == 0) { // this->set_type (AF_INET); this->base_set (AF_INET, sizeof (this->inet_addr_.in4_)); #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; this->set_size (sizeof (this->inet_addr_.in4_)); ACE_OS::memcpy (&this->inet_addr_.in4_.sin_addr, &ip4, len); } // If given an IPv4 address to copy to an IPv6 object, map it to // an IPv4-mapped IPv6 address. else { this->base_set (AF_INET6, sizeof (this->inet_addr_.in6_)); #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; this->set_size (sizeof (this->inet_addr_.in6_)); if (ip4 == INADDR_ANY) { in6_addr ip6 = in6addr_any; ACE_OS::memcpy (&this->inet_addr_.in6_.sin6_addr, &ip6, sizeof (ip6)); return 0; } // RFC 3330 defines loopback as any address with 127.x.x.x if ((ip4 & 0XFF000000) == (INADDR_LOOPBACK & 0XFF000000)) { in6_addr ip6 = in6addr_loopback; ACE_OS::memcpy (&this->inet_addr_.in6_.sin6_addr, &ip6, 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 */ ACE_OS::memset (&this->inet_addr_.in6_.sin6_addr, 0, 16); this->inet_addr_.in6_.sin6_addr.s6_addr[10] = this->inet_addr_.in6_.sin6_addr.s6_addr[11] = 0xff; ACE_OS::memcpy (&this->inet_addr_.in6_.sin6_addr.s6_addr[12], &ip4, 4); } #endif /* ACE_HAS_IPV6 */ return 0; } /* end if (len == 4) */ #if defined (ACE_HAS_IPV6) else if (len == 16) { if (this->get_type () != PF_INET6) { errno = EAFNOSUPPORT; return -1; } // We protect ourselves up above so IPv6 must be possible here. this->base_set (AF_INET6, sizeof (this->inet_addr_.in6_)); this->inet_addr_.in6_.sin6_family = AF_INET6; 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; }

int ACE_INET_Addr::set_interface (  const char *  intf_name  )

Sets the interface that should be used for this address. This only has an effect when the address is link local, otherwise it does nothing. Definition at line 1004 of file INET_Addr.cpp. References ACE_OS::atoi(), ACE_Addr::get_type(), and inet_addr_. { if (this->get_type () == PF_INET6 && (IN6_IS_ADDR_LINKLOCAL (&this->inet_addr_.in6_.sin6_addr) || IN6_IS_ADDR_MC_LINKLOCAL (&this->inet_addr_.in6_.sin6_addr))) { #if defined (__linux__) this->inet_addr_.in6_.sin6_scope_id = ACE_OS::if_nametoindex (intf_name); #else this->inet_addr_.in6_.sin6_scope_id = intf_name ? ACE_OS::atoi (intf_name) : 0; #endif // check to see if the interface lookup succeeded if (this->inet_addr_.in6_.sin6_scope_id != 0) return 0; else return -1; } else return 0; }

void ACE_INET_Addr::set_port_number (  u_short  , int  encode = 1 )

Sets the port number without affecting the host name. If is enabled then is converted into network byte order, otherwise it is assumed to be in network byte order already and are passed straight through. Reimplemented in ACE_Multihomed_INET_Addr. Definition at line 798 of file INET_Addr.cpp. References ACE_HTONS, ACE_TRACE, ACE_Addr::get_type(), and inet_addr_. Referenced by ACE_SOCK_Dgram_Mcast::join(), ACE_SOCK_Dgram_Mcast::open_i(), ACE_SOCK_Dgram_Bcast::send(), set(), set_addr(), and ACE_Multihomed_INET_Addr::set_port_number(). { 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; else #endif /* ACE_HAS_IPV6 */ this->inet_addr_.in4_.sin_port = port_number; }

int ACE_INET_Addr::string_to_addr (  const char  address[], int  address_family = AF_UNSPEC )  [virtual]

Initializes an ACE_INET_Addr from the address, which can be "ip-addr:port-number" (e.g., "tango.cs.wustl.edu:1234"), "ip-addr:port-name" (e.g., "tango.cs.wustl.edu:telnet"), "ip-number:port-number" (e.g., "128.252.166.57:1234"), or "ip-number:port-name" (e.g., "128.252.166.57:telnet"). If there is no ':' in the it is assumed to be a port number, with the IP address being INADDR_ANY. Definition at line 192 of file INET_Addr.cpp. References ACE_ALLOCATOR_RETURN, ACE_MALLOC_T, ACE_TRACE, ACE_OS::free(), INADDR_ANY, set(), ACE_OS::strchr(), ACE_OS::strrchr(), and ACE_OS::strtol(). Referenced by set(). { ACE_TRACE ("ACE_INET_Addr::string_to_addr"); 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), -1); ip_addr = ip_buf; // We use strrchr because of IPv6 addresses. char *port_p = ACE_OS::strrchr (ip_addr, ':'); #if defined (ACE_HAS_IPV6) // Check for extended IPv6 format : '[' <ipv6 address> ']' ':' <port> if (ip_addr[0] == '[') { // find closing bracket char *cp_pos = ACE_OS::strchr (ip_addr, ']'); // check for port separator after closing bracket // if not found leave it, error will come later if (cp_pos) { *cp_pos = '\0'; // blank out ']' ++ip_addr; // skip over '[' if (cp_pos[1] == ':') port_p = cp_pos + 1; else port_p = cp_pos; // leads to error on missing port } } #endif /* ACE_HAS_IPV6 */ if (port_p == 0) // Assume it's a port number. { char *endp = 0; u_short port = static_cast<u_short> (ACE_OS::strtol (ip_addr, &endp, 10)); if (*endp == '\0') // strtol scanned the entire string - all digits result = this->set (port, ACE_UINT32 (INADDR_ANY)); else // port name result = this->set (ip_addr, ACE_UINT32 (INADDR_ANY)); } else { *port_p = '\0'; ++port_p; // skip over ':' char *endp = 0; u_short port = static_cast<u_short> (ACE_OS::strtol (port_p, &endp, 10)); if (*endp == '\0') // strtol scanned the entire string - all digits result = this->set (port, ip_addr, 1, address_family); else result = this->set (port_p, ip_addr); } ACE_OS::free (ACE_MALLOC_T (ip_buf)); return result; }

---

Member Data Documentation

ACE_INET_Addr::ACE_ALLOC_HOOK_DECLARE

Declare the dynamic allocation hooks. Reimplemented from ACE_Addr. Definition at line 361 of file INET_Addr.h.

sockaddr_in ACE_INET_Addr::in4_ [private]

Definition at line 381 of file INET_Addr.h.

sockaddr_in6 ACE_INET_Addr::in6_ [private]

Definition at line 383 of file INET_Addr.h.

union { ... } ACE_INET_Addr::inet_addr_ [private]

Underlying representation. This union uses the knowledge that the two structures share the first member, sa_family (as all sockaddr structures do). Referenced by get_addr(), get_addr_size(), get_host_addr(), get_host_name_i(), ip_addr_pointer(), ip_addr_size(), is_any(), is_multicast(), operator<(), operator==(), reset(), set(), set_addr(), set_address(), set_interface(), and set_port_number().

---

The documentation for this class was generated from the following files:

• INET_Addr.h
• INET_Addr.cpp
• INET_Addr.inl

---