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 *, 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[])
	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[])
	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	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[])
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[])
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 (void) const
	Return the "dotted decimal" Internet address.
const char *	get_host_addr (char *dst, int size) 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_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.
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 116 of file INET_Addr.cpp. References reset(). : ACE_Addr (this->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 236 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 *  , int  len )

Creates an ACE_INET_Addr from a sockaddr_in structure. Definition at line 565 of file INET_Addr.cpp. References ACE_TRACE, reset(), and set(). : ACE_Addr (this->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 446 of file INET_Addr.cpp. References ACE_ERROR, ACE_LIB_TEXT, ACE_TEXT_CHAR_TO_TCHAR, ACE_TRACE, LM_ERROR, ACE_OS::memset(), and set(). : ACE_Addr (this->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_LIB_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[]  )  [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 215 of file INET_Addr.cpp. References ACE_TRACE, reset(), and set(). : ACE_Addr (this->determine_type(), sizeof (inet_addr_)) { ACE_TRACE ("ACE_INET_Addr::ACE_INET_Addr"); this->reset (); this->set (address); }

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 575 of file INET_Addr.cpp. References ACE_ERROR, ACE_LIB_TEXT, ACE_TRACE, LM_ERROR, reset(), and set(). : ACE_Addr (this->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_LIB_TEXT ("%p\n"), ACE_LIB_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 590 of file INET_Addr.cpp. References ACE_ERROR, ACE_LIB_TEXT, ACE_TRACE, LM_ERROR, reset(), and set(). : ACE_Addr (this->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_LIB_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 622 of file INET_Addr.cpp. References ACE_ERROR, ACE_LIB_TEXT, ACE_TRACE, LM_ERROR, reset(), and set(). : ACE_Addr (this->determine_type(), sizeof (inet_addr_)) { ACE_TRACE ("ACE_INET_Addr::ACE_INET_Addr"); this->reset (); if (this->set (port_name, htonl (inet_address), protocol) == -1) ACE_ERROR ((LM_ERROR, ACE_LIB_TEXT ("ACE_INET_Addr::ACE_INET_Addr"))); }

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

Definition at line 464 of file INET_Addr.cpp. References ACE_ERROR, ACE_LIB_TEXT, ACE_TEXT_WCHAR_TO_TCHAR, ACE_TEXT_WIDE, ACE_TRACE, LM_ERROR, ACE_OS::memset(), and set(). : ACE_Addr (this->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_LIB_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[]  )  [explicit]

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

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 605 of file INET_Addr.cpp. References ACE_ERROR, ACE_LIB_TEXT, ACE_TRACE, LM_ERROR, reset(), and set(). : ACE_Addr (this->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_LIB_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 637 of file INET_Addr.cpp. References ACE_ERROR, ACE_LIB_TEXT, ACE_TRACE, LM_ERROR, reset(), and set(). : ACE_Addr (this->determine_type(), sizeof (inet_addr_)) { ACE_TRACE ("ACE_INET_Addr::ACE_INET_Addr"); this->reset (); if (this->set (port_name, htonl (inet_address), protocol) == -1) ACE_ERROR ((LM_ERROR, ACE_LIB_TEXT ("ACE_INET_Addr::ACE_INET_Addr"))); }

ACE_INET_Addr::~ACE_INET_Addr (  void   )

Default dtor. Definition at line 652 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 of the is too small, else 0. Definition at line 32 of file INET_Addr.cpp. References ACE_LIB_TEXT, ACE_TCHAR, ACE_TEXT_CHAR_TO_TCHAR, ACE_TRACE, get_host_addr(), get_port_number(), ACE_OS::sprintf(), and ACE_OS::strlen(). Referenced by ACE_SDM_helpers::addr_to_string(), ACE_MEM_Addr::addr_to_string(), dump(), and ACE_Asynch_Connector< HANDLER >::parse_address(). { ACE_TRACE ("ACE_INET_Addr::addr_to_string"); // XXX Can we (should we) include the scope id for IPv6 addresses? size_t const total_len = (ipaddr_format == 0 ? ACE_OS::strlen (this->get_host_name ()) : ACE_OS::strlen (this->get_host_addr ())) + ACE_OS::strlen ("65536") // Assume the max port number. + sizeof (':') + sizeof ('\0'); // For trailing '\0'. if (size < total_len) return -1; else { ACE_OS::sprintf (s, ACE_LIB_TEXT ("%s:%d"), ACE_TEXT_CHAR_TO_TCHAR (ipaddr_format == 0 ? this->get_host_name () : this->get_host_addr ()), 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 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 63 of file INET_Addr.cpp. References ACE_BEGIN_DUMP, ACE_DEBUG, ACE_END_DUMP, ACE_LIB_TEXT, ACE_MAX_FULLY_QUALIFIED_NAME_LEN, ACE_TCHAR, ACE_TRACE, addr_to_string(), and LM_DEBUG. Referenced by ACE_TSS_Connection::dump(), and ACE_MEM_Addr::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_LIB_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 518 of file INET_Addr.cpp. References ACE_TRACE, and inet_addr_. Referenced by ACE::bind_port(), ACE_MEM_Addr::get_addr(), ACE_Multihomed_INET_Addr::get_addresses(), ACE_SOCK_Dgram::make_multicast_ifaddr6(), ACE_Asynch_Acceptor< HANDLER >::open(), ACE_Ping_Socket::send_echo_check(), 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 102 of file INET_Addr.inl. References ACE_TRACE, ACE_Addr::get_type(), and inet_addr_. { 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 (  char *  dst, int  size )  const

Definition at line 965 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_addr (  void   )  const

Return the "dotted decimal" Internet address. Definition at line 1039 of file INET_Addr.cpp. References ACE_TRACE, INET6_ADDRSTRLEN, and ACE_OS::inet_ntoa(). Referenced by addr_to_string(), and ACE_MEM_Addr::get_host_addr(). { 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_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). Definition at line 717 of file INET_Addr.cpp. References ACE_TRACE, MAXHOSTNAMELEN, and ACE_OS::strcpy(). Referenced by 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 691 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 657 of file INET_Addr.cpp. References ACE_TRACE, and get_host_name_i(). Referenced by ACE_MEM_Connector::connect(), ACE_MEM_Addr::get_host_name(), and 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 746 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(), inet_addr_, ip_addr_size(), ACE_OS::memcmp(), ACE_OS::memcpy(), 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 1063 of file INET_Addr.cpp. References ACE_ERROR, ACE_LIB_TEXT, ACE_NTOHL, ACE_TRACE, EAFNOSUPPORT, ACE_Addr::get_type(), ip_addr_pointer(), LM_ERROR, and ACE_OS::memcpy(). Referenced by ACE_MEM_Addr::get_ip_address(), hash(), 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_LIB_TEXT ("ACE_INET_Addr::get_ip_address: address is a IPv6 address not IPv4\n"))); errno = EAFNOSUPPORT; return 0; } #endif /* ACE_HAS_IPV6 */ return 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_TRACE, and ACE_Addr::get_type(). Referenced by ACE_MEM_Acceptor::accept(), addr_to_string(), ACE_MEM_Connector::connect(), ACE_MEM_Acceptor::get_local_addr(), ACE_MEM_Addr::get_port_number(), 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_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 103 of file INET_Addr.cpp. References get_ip_address(), get_port_number(), ACE_Addr::get_type(), and ip_addr_pointer(). Referenced by ACE_MEM_Addr::hash(). { #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(), and inet_addr_. Referenced by get_ip_address(), and hash(). { #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(), and inet_addr_. Referenced by get_host_name_i(). { // 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 166 of file INET_Addr.inl. References ACE_Addr::get_type(), 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); }

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 211 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 201 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 191 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 178 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 */ return (this->get_ip_address () == INADDR_LOOPBACK); }

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

Compare two addresses for inequality. Definition at line 80 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 116 of file INET_Addr.inl. References get_ip_address(), and get_port_number(). { 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 89 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 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[]  )

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

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 147 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 137 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 125 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 486 of file INET_Addr.cpp. References ACE_TRACE, 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[]  )

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 209 of file INET_Addr.cpp. References ACE_TRACE, and string_to_addr(). { ACE_TRACE ("ACE_INET_Addr::set"); return this->string_to_addr (address); }

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 426 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 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 399 of file INET_Addr.cpp. References ACE_LIB_TEXT, ACE_NOTSUP_RETURN, ACE_TEXT_CHAR_TO_TCHAR, ACE_TRACE, get_port_number_from_name(), 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_LIB_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 248 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 267 of file INET_Addr.cpp. References ACE_HOSTENT_DATA, ACE_TRACE, ACE_OS::gethostbyname(), ACE_OS::gethostbyname_r(), inet_addr_, ACE_OS::inet_aton(), 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, *res, *res0; int error; ACE_OS::memset (&hints, 0, sizeof (hints)); hints.ai_family = address_family; error = getaddrinfo (host_name, 0, &hints, &res0); if (error) return -1; int ret = -1; for (res = res0; res != 0; res = res->ai_next) { if (res->ai_family == AF_INET || res->ai_family == AF_INET6) { this->set_type (res->ai_family); this->set_addr (res->ai_addr, res->ai_addrlen); this->set_port_number (port_number, encode); ret = 0; break; } } freeaddrinfo (res0); return ret; #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 ? 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 ? 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 124 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_MEM_Addr::ACE_MEM_Addr(), ACE_Multihomed_INET_Addr::ACE_Multihomed_INET_Addr(), ACE::bind_port(), ACE::get_ip_interfaces(), ACE_Multihomed_INET_Addr::get_secondary_addresses(), ACE_Service_Manager::init(), ACE_MEM_Addr::initialize_local(), ACE_SOCK_Dgram::make_multicast_ifaddr(), ACE_Remote_Name_Space::open(), ACE_SOCK_Dgram_Mcast::open_i(), ACE_Asynch_Connector< HANDLER >::parse_address(), ACE_Asynch_Acceptor< HANDLER >::parse_address(), 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 532 of file INET_Addr.cpp. References ACE_TRACE, 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 525 of file INET_Addr.cpp. Referenced by ACE_SOCK_SEQPACK_Association::get_local_addrs(), ACE_SOCK_SEQPACK_Association::get_remote_addrs(), set(), and ACE_MEM_Addr::set_addr(). { 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 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 822 of file INET_Addr.cpp. References ACE_HTONL, ACE_TRACE, ACE_Addr::base_set(), EAFNOSUPPORT, ACE_Addr::get_type(), 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; } if (ip4 == INADDR_LOOPBACK) { 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 */ else { /* unknown or unsupported address length */ errno = EAFNOSUPPORT; return -1; } #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 939 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 728 of file INET_Addr.cpp. References ACE_TRACE, ACE_Addr::get_type(), and inet_addr_. Referenced by ACE_SOCK_Dgram_Mcast::join(), ACE_SOCK_Dgram_Mcast::open_i(), ACE_MEM_Addr::same_host(), ACE_SOCK_Dgram_Bcast::send(), set(), ACE_MEM_Addr::set_addr(), set_addr(), ACE_Multihomed_INET_Addr::set_port_number(), and ACE_MEM_Addr::set_port_number(). { ACE_TRACE ("ACE_INET_Addr::set_port_number"); if (encode) port_number = 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[]  )  [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 148 of file INET_Addr.cpp. References ACE_ALLOCATOR_RETURN, ACE_MALLOC_T, ACE_TRACE, ACE_OS::free(), 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; char *ip_addr; // 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); 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 335 of file INET_Addr.h.

sockaddr_in ACE_INET_Addr::in4_ [private]

Definition at line 355 of file INET_Addr.h.

sockaddr_in6 ACE_INET_Addr::in6_ [private]

Definition at line 357 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(), 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

---