ACE: ACE_INET_Addr Class Reference

ACE_INET_Addr::ACE_INET_Addr ( void )

Default constructor.

Definition at line 160 of file INET_Addr.cpp.

References reset().

00161   : ACE_Addr (determine_type (), sizeof (inet_addr_))
00162 {
00163   // ACE_TRACE ("ACE_INET_Addr::ACE_INET_Addr");
00164   this->reset ();
00165 }

ACE_INET_Addr::ACE_INET_Addr ( const ACE_INET_Addr & )

Copy constructor.

Definition at line 291 of file INET_Addr.cpp.

References ACE_TRACE, reset(), and set().

00292   : ACE_Addr (sa.get_type (), sa.get_size())
00293 {
00294   ACE_TRACE ("ACE_INET_Addr::ACE_INET_Addr");
00295   this->reset ();
00296   this->set (sa);
00297 }

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 642 of file INET_Addr.cpp.

References ACE_TRACE, reset(), and set().

00643   : ACE_Addr (determine_type (), sizeof (inet_addr_))
00644 {
00645   ACE_TRACE ("ACE_INET_Addr::ACE_INET_Addr");
00646   this->reset ();
00647   this->set (addr, len);
00648 }

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 port_number and the remote host_name. 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 523 of file INET_Addr.cpp.

References ACE_ERROR, ACE_TEXT, ACE_TEXT_CHAR_TO_TCHAR, ACE_TRACE, LM_ERROR, and ACE_OS::memset().

00526   : ACE_Addr (determine_type (), sizeof (inet_addr_))
00527 {
00528   ACE_TRACE ("ACE_INET_Addr::ACE_INET_Addr");
00529   ACE_OS::memset (&this->inet_addr_, 0, sizeof (this->inet_addr_));
00530   if (this->set (port_number,
00531                  host_name,
00532                  1,
00533                  address_family) == -1)
00534     ACE_ERROR ((LM_ERROR,
00535                 ACE_TEXT ("ACE_INET_Addr::ACE_INET_Addr: %p\n"),
00536                 ACE_TEXT_CHAR_TO_TCHAR ((host_name == 0) ?
00537                                         "<unknown>" : host_name)));
00538 }

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

Initializes an ACE_INET_Addr from the address, 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 address it is assumed to be a port number, with the IP address being INADDR_ANY.

Definition at line 270 of file INET_Addr.cpp.

References ACE_TRACE, reset(), and set().

00271   : ACE_Addr (determine_type (), sizeof (inet_addr_))
00272 {
00273   ACE_TRACE ("ACE_INET_Addr::ACE_INET_Addr");
00274   this->reset ();
00275   this->set (address, address_family);
00276 }

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

Creates an ACE_INET_Addr from a port_number and an Internet <ip_addr>. This method assumes that port_number and <ip_addr> are in host byte order. If you have addressing information in network byte order,

See also:: set().

Definition at line 652 of file INET_Addr.cpp.

References ACE_ERROR, ACE_TEXT, ACE_TRACE, and reset().

00654   : ACE_Addr (determine_type (), sizeof (inet_addr_))
00655 {
00656   ACE_TRACE ("ACE_INET_Addr::ACE_INET_Addr");
00657   this->reset ();
00658   if (this->set (port_number, inet_address) == -1)
00659     ACE_ERROR ((LM_ERROR,
00660                 ACE_TEXT ("%p\n"),
00661                 ACE_TEXT ("ACE_INET_Addr::ACE_INET_Addr")));
00662 }

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

Uses <getservbyname> to create an ACE_INET_Addr from a <port_name>, the remote host_name, and the protocol.

Definition at line 667 of file INET_Addr.cpp.

References ACE_ERROR, ACE_TEXT, ACE_TRACE, and reset().

00670   : ACE_Addr (determine_type (), sizeof (inet_addr_))
00671 {
00672   ACE_TRACE ("ACE_INET_Addr::ACE_INET_Addr");
00673   this->reset ();
00674   if (this->set (port_name,
00675                  host_name,
00676                  protocol) == -1)
00677     ACE_ERROR ((LM_ERROR,
00678                 ACE_TEXT ("ACE_INET_Addr::ACE_INET_Addr")));
00679 }

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

Uses <getservbyname> to create an ACE_INET_Addr from a <port_name>, an Internet <ip_addr>, and the protocol. This method assumes that <ip_addr> is in host byte order.

Definition at line 699 of file INET_Addr.cpp.

References ACE_ERROR, ACE_TEXT, ACE_TRACE, and reset().

00702   : ACE_Addr (determine_type (), sizeof (inet_addr_))
00703 {
00704   ACE_TRACE ("ACE_INET_Addr::ACE_INET_Addr");
00705 #if !defined (ACE_LACKS_HTONL)
00706   this->reset ();
00707   if (this->set (port_name,
00708                  htonl (inet_address),
00709                  protocol) == -1)
00710     ACE_ERROR ((LM_ERROR,
00711                 ACE_TEXT ("ACE_INET_Addr::ACE_INET_Addr")));
00712 #else
00713   ACE_UNUSED_ARG (port_name);
00714   ACE_UNUSED_ARG (inet_address);
00715   ACE_UNUSED_ARG (protocol);
00716 #endif
00717 }

ACE_INET_Addr::~ACE_INET_Addr ( void )

Default dtor.

Definition at line 741 of file INET_Addr.cpp.

00742 {
00743 }

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 <ipaddr_format> is non-0 this produces "ip-number:port-number" (e.g., "128.252.166.57:1234"), whereas if <ipaddr_format> is 0 this produces "ip-name:port-number" (e.g., "tango.cs.wustl.edu:1234"). Returns -1 if the size of the <buffer> is too small, else 0.

Definition at line 32 of file INET_Addr.cpp.

References ACE_TEXT, ACE_TEXT_CHAR_TO_TCHAR, ACE_TRACE, MAXHOSTNAMELEN, ACE_OS::sprintf(), ACE_OS::strchr(), and ACE_OS::strlen().

Referenced by ACE_SDM_helpers::addr_to_string(), and dump().

00035 {
00036   ACE_TRACE ("ACE_INET_Addr::addr_to_string");
00037 
00038   // XXX Can we (should we) include the scope id for IPv6 addresses?
00039   char  hoststr[MAXHOSTNAMELEN+1];
00040 
00041   bool result = false;
00042   if (ipaddr_format == 0)
00043     result = (this->get_host_name (hoststr, MAXHOSTNAMELEN+1) == 0);
00044   else
00045     result = (this->get_host_addr (hoststr, MAXHOSTNAMELEN+1) != 0);
00046 
00047   if (!result)
00048     return -1;
00049 
00050   size_t total_len =
00051     ACE_OS::strlen (hoststr)
00052     + 5 // ACE_OS::strlen ("65535"), Assuming the max port number.
00053     + 1 // sizeof (':'), addr/port sep
00054     + 1; // sizeof ('\0'), terminating NUL
00055 #if !defined (ACE_WIN32) && defined (ACE_USES_WCHAR)
00056   ACE_TCHAR const *format = ACE_TEXT("%ls:%d");
00057 #else
00058   ACE_TCHAR const *format = ACE_TEXT("%s:%d");
00059 #endif /* !ACE_WIN32 && ACE_USES_WCHAR */
00060 #if defined (ACE_HAS_IPV6)
00061   if (ACE_OS::strchr (hoststr, ACE_TEXT (':')) != 0)
00062     {
00063       total_len += 2; // ACE_OS::strlen ("[]") IPv6 addr frames
00064 #  if !defined (ACE_WIN32) && defined (ACE_USES_WCHAR)
00065       format = ACE_TEXT("[%ls]:%d");
00066 #  else
00067       format = ACE_TEXT("[%s]:%d");
00068 #  endif /* !ACE_WIN32 && ACE_USES_WCHAR */
00069     }
00070 #endif // ACE_HAS_IPV6
00071 
00072   if (size < total_len)
00073     return -1;
00074   else
00075       ACE_OS::sprintf (s, format,
00076                        ACE_TEXT_CHAR_TO_TCHAR (hoststr),
00077                        this->get_port_number ());
00078   return 0;
00079 }

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().

00036 {
00037 #if defined (ACE_HAS_IPV6)
00038 #  if defined (ACE_USES_IPV4_IPV6_MIGRATION)
00039   return ACE::ipv6_enabled () ? AF_INET6 : AF_INET;
00040 #  else
00041   return AF_INET6;
00042 #  endif /* ACE_USES_IPV4_IPV6_MIGRATION */
00043 #else
00044   return AF_INET;
00045 #endif /* ACE_HAS_IPV6 */
00046 }

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_TEXT, ACE_TRACE, addr_to_string(), and LM_DEBUG.

00083 {
00084 #if defined (ACE_HAS_DUMP)
00085   ACE_TRACE ("ACE_INET_Addr::dump");
00086 
00087   ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
00088 
00089   ACE_TCHAR s[ACE_MAX_FULLY_QUALIFIED_NAME_LEN + 16];
00090   this->addr_to_string(s, ACE_MAX_FULLY_QUALIFIED_NAME_LEN + 16);
00091   ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("%s"), s));
00092   ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
00093 #endif /* ACE_HAS_DUMP */
00094 }

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

Return a pointer to the underlying network address.

Reimplemented from ACE_Addr.

Definition at line 595 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(), and ACE_SOCK_SEQPACK_Acceptor::shared_open().

00596 {
00597   ACE_TRACE ("ACE_INET_Addr::get_addr");
00598   return (void*)&this->inet_addr_;
00599 }

ACE_INLINE int ACE_INET_Addr::get_addr_size ( void ) const

Definition at line 104 of file INET_Addr.inl.

References ACE_TRACE, and PF_INET.

00105 {
00106   ACE_TRACE ("ACE_INET_Addr::get_addr_size");
00107 #if defined (ACE_HAS_IPV6)
00108   if (this->get_type () == PF_INET)
00109     return sizeof this->inet_addr_.in4_;
00110   else
00111     return sizeof this->inet_addr_.in6_;
00112 #else
00113   return sizeof this->inet_addr_.in4_;
00114 #endif /* ACE_HAS_IPV6 */
00115 }

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 1134 of file INET_Addr.cpp.

References ACE_TRACE, INET6_ADDRSTRLEN, and ACE_OS::inet_ntoa().

01135 {
01136   ACE_TRACE ("ACE_INET_Addr::get_host_addr");
01137 #if defined (ACE_HAS_IPV6)
01138   static char buf[INET6_ADDRSTRLEN];
01139   return this->get_host_addr (buf, INET6_ADDRSTRLEN);
01140 #else /* ACE_HAS_IPV6 */
01141 #  if defined (ACE_VXWORKS)
01142   // It would be nice to be able to encapsulate this into
01143   // ACE_OS::inet_ntoa(), but that would lead to either inefficiencies
01144   // on vxworks or lack of thread safety.
01145   //
01146   // So, we use the way that vxworks suggests.
01147   ACE_INET_Addr *ncthis = const_cast<ACE_INET_Addr *> (this);
01148   inet_ntoa_b (this->inet_addr_.in4_.sin_addr, ncthis->buf_);
01149   return &buf_[0];
01150 #  else /* ACE_VXWORKS */
01151   return ACE_OS::inet_ntoa (this->inet_addr_.in4_.sin_addr);
01152 #  endif /* !ACE_VXWORKS */
01153 #endif /* !ACE_HAS_IPV6 */
01154 }

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 addr_size bytes long). This version is reentrant.

Definition at line 1060 of file INET_Addr.cpp.

References 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().

01061 {
01062 #if defined (ACE_HAS_IPV6)
01063   if (this->get_type () == AF_INET6)
01064     {
01065       // mcorino@remedy.nl - Aug-26, 2005
01066       // I don't think this should be done because it results in a decimal address
01067       // representation which is not distinguishable from the IPv4 form which makes
01068       // it impossible to resolve back to an IPv6 INET_Addr without prior knowledge
01069       // that this was such an address to begin with.
01070 
01071       //if (IN6_IS_ADDR_V4MAPPED (&this->inet_addr_.in6_.sin6_addr))
01072       //{
01073       //  ACE_UINT32 addr;
01074       //  addr = this->get_ip_address();
01075       //  addr = ACE_HTONL (addr);
01076       //  return ACE_OS::inet_ntop (AF_INET, &addr, dst, size);
01077       //}
01078 
01079 #  if defined (ACE_WIN32)
01080       if (0 == ::getnameinfo (reinterpret_cast<const sockaddr*> (&this->inet_addr_.in6_),
01081                               this->get_size (),
01082                               dst,
01083                               size,
01084                               0, 0,    // Don't want service name
01085                               NI_NUMERICHOST))
01086         return dst;
01087       ACE_OS::set_errno_to_wsa_last_error ();
01088       return 0;
01089 #  else
01090       const char *ch = ACE_OS::inet_ntop (AF_INET6,
01091                                           &this->inet_addr_.in6_.sin6_addr,
01092                                           dst,
01093                                           size);
01094 #if defined (__linux__)
01095       if ((IN6_IS_ADDR_LINKLOCAL (&this->inet_addr_.in6_.sin6_addr) ||
01096            IN6_IS_ADDR_MC_LINKLOCAL (&this->inet_addr_.in6_.sin6_addr)) &&
01097           this->inet_addr_.in6_.sin6_scope_id != 0)
01098         {
01099           char scope_buf[32];
01100           ACE_OS::sprintf (scope_buf, "%%%u", this->inet_addr_.in6_.sin6_scope_id);
01101           if ((ACE_OS::strlen (ch)+ACE_OS::strlen (scope_buf)) < (size_t)size)
01102             {
01103               ACE_OS::strcat (dst, scope_buf);
01104             }
01105         }
01106 #endif
01107       return ch;
01108 #  endif /* ACE_WIN32 */
01109     }
01110 #endif /* ACE_HAS_IPV6 */
01111 
01112 #if defined (ACE_VXWORKS)
01113   ACE_UNUSED_ARG (dst);
01114   ACE_UNUSED_ARG (size);
01115 
01116   // It would be nice to be able to encapsulate this into
01117   // ACE_OS::inet_ntoa(), but that would lead to either inefficiencies
01118   // on vxworks or lack of thread safety.
01119   //
01120   // So, we use the way that vxworks suggests.
01121   ACE_INET_Addr *ncthis = const_cast<ACE_INET_Addr *> (this);
01122   inet_ntoa_b(this->inet_addr_.in4_.sin_addr, ncthis->buf_);
01123   ACE_OS::strsncpy (dst, &buf_[0], size);
01124   return &buf_[0];
01125 #else /* ACE_VXWORKS */
01126   char *ch = ACE_OS::inet_ntoa (this->inet_addr_.in4_.sin_addr);
01127   ACE_OS::strsncpy (dst, ch, size);
01128   return ch;
01129 #endif
01130 }

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 806 of file INET_Addr.cpp.

References ACE_TRACE, MAXHOSTNAMELEN, and ACE_OS::strcpy().

00807 {
00808   ACE_TRACE ("ACE_INET_Addr::get_host_name");
00809 
00810   static char name[MAXHOSTNAMELEN + 1];
00811   if (this->get_host_name (name, MAXHOSTNAMELEN + 1) == -1)
00812     ACE_OS::strcpy (name, "<unknown>");
00813   return name;
00814 }

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 <hostname> (which is assumed to be <hostnamelen> bytes long). This version is reentrant. If <hostnamelen> is greater than 0 then <hostname> will be NUL-terminated even if -1 is returned.

Definition at line 746 of file INET_Addr.cpp.

References ACE_TRACE, and get_host_name_i().

Referenced by ACE_Service_Manager::handle_input().

00748 {
00749   ACE_TRACE ("ACE_INET_Addr::get_host_name");
00750 
00751   int result;
00752   if (len > 1)
00753     {
00754       result = this->get_host_name_i (hostname,len);
00755       if (result < 0)
00756         {
00757           if (result == -2)
00758             // We know that hostname is nul-terminated
00759             result = -1;
00760           else
00761             {
00762               //result == -1;
00763               // This could be worse than hostname[len -1] = '\0'?
00764               hostname[0] = '\0';
00765             }
00766         }
00767     }
00768   else
00769     {
00770       if (len == 1)
00771         hostname[0] = '\0';
00772       result = -1;
00773     }
00774 
00775   return result;
00776 }

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 835 of file INET_Addr.cpp.

References ACE_TRACE, ACE_Addr::get_type(), ACE_OS::gethostbyaddr(), ACE_OS::gethostbyaddr_r(), ACE_OS::hostname(), INADDR_ANY, inet_addr_, ip_addr_pointer(), ip_addr_size(), ACE_OS::memcmp(), ACE_OS::memcpy(), PF_INET, ACE_OS::strcpy(), and ACE_OS::strlen().

Referenced by get_host_name().

00836 {
00837   ACE_TRACE ("ACE_INET_Addr::get_host_name_i");
00838 
00839 #if defined (ACE_HAS_IPV6)
00840   if ((this->get_type () == PF_INET6 &&
00841        0 == ACE_OS::memcmp (&this->inet_addr_.in6_.sin6_addr,
00842                             &in6addr_any,
00843                             sizeof (this->inet_addr_.in6_.sin6_addr)))
00844       ||
00845       (this->get_type () == PF_INET &&
00846        this->inet_addr_.in4_.sin_addr.s_addr == INADDR_ANY))
00847 #else
00848   if (this->inet_addr_.in4_.sin_addr.s_addr == INADDR_ANY)
00849 #endif /* ACE_HAS_IPV6 */
00850     {
00851       if (ACE_OS::hostname (hostname, len) == -1)
00852         return -1;
00853       else
00854         return 0;
00855     }
00856   else
00857     {
00858 #if defined (ACE_VXWORKS) && defined (ACE_LACKS_GETHOSTBYADDR)
00859       ACE_UNUSED_ARG (len);
00860       int error =
00861         ::hostGetByAddr ((int) this->inet_addr_.in4_.sin_addr.s_addr,
00862                          hostname);
00863       if (error == OK)
00864         return 0;
00865       else
00866         {
00867           errno = error;
00868           return -1;
00869         }
00870 #else
00871       void* addr = this->ip_addr_pointer ();
00872       int   size = this->ip_addr_size ();
00873       int   type = this->get_type ();
00874 
00875 #  if defined (ACE_HAS_IPV6) && defined (ACE_HAS_BROKEN_GETHOSTBYADDR_V4MAPPED)
00876       // Most OS can not handle IPv6-mapped-IPv4 addresses (even
00877       // though they are meant to) so map them back to IPv4 addresses
00878       // before trying to resolve them
00879       in_addr demapped_addr;
00880       if (type == PF_INET6 &&
00881           (this->is_ipv4_mapped_ipv6 () || this->is_ipv4_compat_ipv6 ()))
00882         {
00883           ACE_OS::memcpy (&demapped_addr.s_addr, &this->inet_addr_.in6_.sin6_addr.s6_addr[12], 4);
00884           addr = &demapped_addr;
00885           size = sizeof(demapped_addr);
00886           type = PF_INET;
00887         }
00888 #  endif /* ACE_HAS_IPV6 */
00889 
00890 #  if defined (DIGITAL_UNIX) && defined (__GNUC__)
00891       hostent * const hp =
00892         ACE_OS::gethostbyaddr (static_cast <char *> (addr), size, type);
00893 #  else
00894       int h_error;  // Not the same as errno!
00895       hostent hentry;
00896       ACE_HOSTENT_DATA buf;
00897       hostent * const hp =
00898         ACE_OS::gethostbyaddr_r (static_cast <char *> (addr),
00899                                  size,
00900                                  type,
00901                                  &hentry,
00902                                  buf,
00903                                  &h_error);
00904 #  endif /* DIGITAL_UNIX */
00905 
00906       if (hp == 0 || hp->h_name == 0)
00907         return -1;
00908 
00909       if (ACE_OS::strlen (hp->h_name) >= len)
00910         {
00911           // We know the length, so use memcpy
00912           if (len > 0)
00913             {
00914               ACE_OS::memcpy (hostname, hp->h_name, len - 1);
00915               hostname[len-1]= '\0';
00916             }
00917           errno = ENOSPC;
00918           return -2;  // -2 Means that we have a good string
00919           // Using errno looks ok, but ENOSPC could be set on
00920           // other places.
00921         }
00922 
00923       ACE_OS::strcpy (hostname, hp->h_name);
00924       return 0;
00925 #endif /* ACE_VXWORKS */
00926     }
00927 }

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 1158 of file INET_Addr.cpp.

References ACE_ERROR, ACE_NTOHL, ACE_TEXT, ACE_TRACE, and ACE_OS::memcpy().

Referenced by hash(), is_ip_equal(), ACE_SOCK_Dgram::make_multicast_ifaddr(), and operator<().

01159 {
01160   ACE_TRACE ("ACE_INET_Addr::get_ip_address");
01161 #if defined (ACE_HAS_IPV6)
01162   if (this->get_type () == AF_INET6)
01163     {
01164       if (IN6_IS_ADDR_V4MAPPED (&this->inet_addr_.in6_.sin6_addr) ||
01165           IN6_IS_ADDR_V4COMPAT (&this->inet_addr_.in6_.sin6_addr)    )
01166         {
01167           ACE_UINT32 addr;
01168           // Return the last 32 bits of the address
01169           char *thisaddrptr = (char*)this->ip_addr_pointer ();
01170           thisaddrptr += 128/8 - 32/8;
01171           ACE_OS::memcpy (&addr, thisaddrptr, sizeof (addr));
01172           return ACE_NTOHL (addr);
01173         }
01174 
01175       ACE_ERROR ((LM_ERROR,
01176                   ACE_TEXT ("ACE_INET_Addr::get_ip_address: address is a IPv6 address not IPv4\n")));
01177       errno = EAFNOSUPPORT;
01178       return 0;
01179     }
01180 #endif /* ACE_HAS_IPV6 */
01181   return ACE_NTOHL (ACE_UINT32 (this->inet_addr_.in4_.sin_addr.s_addr));
01182 }

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, 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<().

00089 {
00090   ACE_TRACE ("ACE_INET_Addr::get_port_number");
00091 #if defined (ACE_LACKS_NTOHS)
00092   ACE_NOTSUP_RETURN (0);
00093 #elif defined (ACE_HAS_IPV6)
00094   if (this->get_type () == PF_INET)
00095     return ntohs (this->inet_addr_.in4_.sin_port);
00096   else
00097     return ntohs (this->inet_addr_.in6_.sin6_port);
00098 #else
00099   return ntohs (this->inet_addr_.in4_.sin_port);
00100 #endif /* ACE_HAS_IPV6 */
00101 }

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(), and ip_addr_pointer().

00148 {
00149 #if defined (ACE_HAS_IPV6)
00150   if (this->get_type () == PF_INET6)
00151     {
00152       const unsigned int *addr = (const unsigned int*)this->ip_addr_pointer();
00153       return addr[0] + addr[1] + addr[2] + addr[3] + this->get_port_number();
00154     }
00155   else
00156 #endif /* ACE_HAS_IPV6 */
00157   return this->get_ip_address () + this->get_port_number ();
00158 }

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

Definition at line 49 of file INET_Addr.inl.

References inet_addr_, and PF_INET.

Referenced by get_host_name_i(), hash(), is_ip_equal(), and operator<().

00050 {
00051 #if defined (ACE_HAS_IPV6)
00052   if (this->get_type () == PF_INET)
00053     return (void*)&this->inet_addr_.in4_.sin_addr;
00054   else
00055     return (void*)&this->inet_addr_.in6_.sin6_addr;
00056 #else
00057   return (void*)&this->inet_addr_.in4_.sin_addr;
00058 #endif
00059 }

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

Definition at line 62 of file INET_Addr.inl.

References inet_addr_, and PF_INET.

Referenced by get_host_name_i(), and operator<().

00063 {
00064   // Since this size value is used to pass to other host db-type
00065   // functions (gethostbyaddr, etc.) the length is of int type.
00066   // Thus, cast all these sizes back to int. They're all well
00067   // within the range of an int anyway.
00068 #if defined (ACE_HAS_IPV6)
00069   if (this->get_type () == PF_INET)
00070     return static_cast<int> (sizeof this->inet_addr_.in4_.sin_addr);
00071   else
00072     return static_cast<int> (sizeof this->inet_addr_.in6_.sin6_addr);
00073 #else
00074   // These _UNICOS changes were picked up from pre-IPv6 code in
00075   // get_host_name_i... the IPv6 section above may need something
00076   // similar, so keep an eye out for it.
00077 #  if !defined(_UNICOS)
00078   return static_cast<int> (sizeof this->inet_addr_.in4_.sin_addr.s_addr);
00079 #  else /* _UNICOS */
00080   return static_cast<int> (sizeof this->inet_addr_.in4_.sin_addr);
00081 #  endif /* ! _UNICOS */
00082 #endif /* ACE_HAS_IPV6 */
00083 }

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 INADDR_ANY.

00190 {
00191 #if defined (ACE_HAS_IPV6)
00192   if (this->get_type () == AF_INET6)
00193       return IN6_IS_ADDR_UNSPECIFIED (&this->inet_addr_.in6_.sin6_addr);
00194 #endif /* ACE_HAS_IPV6 */
00195 
00196   return (this->inet_addr_.in4_.sin_addr.s_addr == INADDR_ANY);
00197 }

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().

00123 {
00124     if (this->get_type () != sap.get_type ()
00125       || this->get_size () != sap.get_size ())
00126     return false;
00127 
00128 #if defined (ACE_HAS_IPV6)
00129   if (this->get_type () == PF_INET6)
00130     {
00131       const unsigned int *addr =
00132         reinterpret_cast<const unsigned int*>(this->ip_addr_pointer());
00133       const unsigned int *saddr =
00134         reinterpret_cast<const unsigned int*>(sap.ip_addr_pointer());
00135       return (addr[0] == saddr[0] &&
00136               addr[1] == saddr[1] &&
00137               addr[2] == saddr[2] &&
00138               addr[3] == saddr[3]);
00139     }
00140   else
00141 #endif /* ACE_HAS_IPV6 */
00142   return this->get_ip_address () == sap.get_ip_address();
00143 }

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 INADDR_LOOPBACK.

00202 {
00203 #if defined (ACE_HAS_IPV6)
00204   if (this->get_type () == AF_INET6)
00205       return IN6_IS_ADDR_LOOPBACK (&this->inet_addr_.in6_.sin6_addr);
00206 #endif /* ACE_HAS_IPV6 */
00207 
00208   // RFC 3330 defines loopback as any address with 127.x.x.x
00209   return ((this->get_ip_address () & 0XFF000000) == (INADDR_LOOPBACK & 0XFF000000));
00210 }

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.

00215 {
00216 #if defined (ACE_HAS_IPV6)
00217   if (this->get_type() == AF_INET6)
00218     return this->inet_addr_.in6_.sin6_addr.s6_addr[0] == 0xFF;
00219 #endif /* ACE_HAS_IPV6 */
00220   return
00221     this->inet_addr_.in4_.sin_addr.s_addr >= 0xE0000000 &&  // 224.0.0.0
00222     this->inet_addr_.in4_.sin_addr.s_addr <= 0xEFFFFFFF; // 239.255.255.255
00223 }

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.

00100 {
00101   ACE_TRACE ("ACE_INET_Addr::operator !=");
00102   return !((*this) == sap);
00103 }

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().

00119 {
00120 #if defined (ACE_HAS_IPV6)
00121   if (this->get_type() != rhs.get_type())
00122   {
00123     return this->get_type() < rhs.get_type();
00124   }
00125 
00126   if (this->get_type() == PF_INET6)
00127   {
00128     int memval = ACE_OS::memcmp (this->ip_addr_pointer(),
00129                                  rhs.ip_addr_pointer(),
00130                                  this->ip_addr_size());
00131 
00132     return memval < 0
00133             || (memval == 0
00134                 && (this->get_port_number() < rhs.get_port_number()
00135                     || (this->get_port_number() == rhs.get_port_number()
00136                         && this->inet_addr_.in6_.sin6_scope_id <
00137                             rhs.inet_addr_.in6_.sin6_scope_id)));
00138   }
00139 #endif
00140 
00141   return this->get_ip_address () < rhs.get_ip_address ()
00142     || (this->get_ip_address () == rhs.get_ip_address ()
00143         && this->get_port_number () < rhs.get_port_number ());
00144 }

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().

00109 {
00110   ACE_TRACE ("ACE_INET_Addr::operator ==");
00111 
00112   if (this->get_type () != sap.get_type ()
00113       || this->get_size () != sap.get_size ())
00114     return false;
00115 
00116   return (ACE_OS::memcmp (&this->inet_addr_,
00117                           &sap.inet_addr_,
00118                           this->get_size ()) == 0);
00119 }

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, inet_addr_, and ACE_OS::memset().

Referenced by ACE_INET_Addr().

00014 {
00015   ACE_OS::memset (&this->inet_addr_, 0, sizeof (this->inet_addr_));
00016   if (this->get_type() == AF_INET)
00017     {
00018 #ifdef ACE_HAS_SOCKADDR_IN_SIN_LEN
00019       this->inet_addr_.in4_.sin_len = sizeof (this->inet_addr_.in4_);
00020 #endif
00021       this->inet_addr_.in4_.sin_family = AF_INET;
00022     }
00023 #if defined (ACE_HAS_IPV6)
00024   else if (this->get_type() == AF_INET6)
00025     {
00026 #ifdef ACE_HAS_SOCKADDR_IN6_SIN6_LEN
00027       this->inet_addr_.in6_.sin6_len = sizeof (this->inet_addr_.in6_);
00028 #endif
00029       this->inet_addr_.in6_.sin6_family = AF_INET6;
00030     }
00031 #endif  /* ACE_HAS_IPV6 */
00032 }

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

Creates an ACE_INET_Addr from a sockaddr_in structure.

Definition at line 563 of file INET_Addr.cpp.

References ACE_TRACE, AF_INET, ACE_Addr::base_set(), inet_addr_, and ACE_OS::memcpy().

00564 {
00565   ACE_TRACE ("ACE_INET_Addr::set");
00566 
00567   if (addr->sin_family == AF_INET)
00568     {
00569       int maxlen = static_cast<int> (sizeof (this->inet_addr_.in4_));
00570       if (len > maxlen)
00571         len = maxlen;
00572       ACE_OS::memcpy (&this->inet_addr_.in4_, addr, len);
00573       this->base_set (AF_INET, len);
00574       return 0;
00575     }
00576 #if defined (ACE_HAS_IPV6)
00577   else if (addr->sin_family == AF_INET6)
00578     {
00579       int maxlen = static_cast<int> (sizeof (this->inet_addr_.in6_));
00580       if (len > maxlen)
00581         len = maxlen;
00582       ACE_OS::memcpy (&this->inet_addr_.in6_, addr, len);
00583       this->base_set (AF_INET6, len);
00584       return 0;
00585     }
00586 #endif /* ACE_HAS_IPV6 */
00587 
00588   errno = EAFNOSUPPORT;
00589   return -1;
00590 }

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 address it is assumed to be a port number, with the IP address being INADDR_ANY.

Definition at line 264 of file INET_Addr.cpp.

References ACE_TRACE, and string_to_addr().

00265 {
00266   ACE_TRACE ("ACE_INET_Addr::set");
00267   return this->string_to_addr (address, address_family);
00268 }

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

Uses <getservbyname> to initialize an ACE_INET_Addr from a <port_name>, an <ip_addr>, and the protocol. This assumes that <ip_addr> is already in network byte order.

Definition at line 504 of file INET_Addr.cpp.

References ACE_NOTSUP_RETURN, ACE_TRACE, get_port_number_from_name(), and set().

00507 {
00508   ACE_TRACE ("ACE_INET_Addr::set");
00509 
00510   int const port_number = get_port_number_from_name (port_name, protocol);
00511   if (port_number == -1)
00512     {
00513       ACE_NOTSUP_RETURN (-1);
00514     }
00515 
00516   return this->set (static_cast<u_short> (port_number),
00517                     inet_address, 0);
00518 }

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

Uses <getservbyname> to initialize an ACE_INET_Addr from a <port_name>, the remote host_name, and the protocol.

Definition at line 478 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().

00481 {
00482   ACE_TRACE ("ACE_INET_Addr::set");
00483 
00484   int const port_number = get_port_number_from_name (port_name, protocol);
00485   if (port_number == -1)
00486     {
00487       ACE_NOTSUP_RETURN (-1);
00488     }
00489 
00490   int address_family = PF_UNSPEC;
00491 #  if defined (ACE_HAS_IPV6)
00492   if (ACE_OS::strcmp (ACE_TEXT_CHAR_TO_TCHAR(protocol), ACE_TEXT ("tcp6")) == 0)
00493     address_family = AF_INET6;
00494 #  endif /* ACE_HAS_IPV6 */
00495 
00496   return this->set (static_cast<u_short> (port_number),
00497                     host_name, 0, address_family);
00498 }

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 <map> 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 303 of file INET_Addr.cpp.

References ACE_TRACE, set_address(), and set_port_number().

00307 {
00308   ACE_TRACE ("ACE_INET_Addr::set");
00309   this->set_address (reinterpret_cast<const char *> (&inet_address),
00310                      sizeof inet_address,
00311                      encode, map);
00312   this->set_port_number (port_number, encode);
00313 
00314   return 0;
00315 }

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 port_number and the remote host_name. If encode is non-zero then port_number 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 322 of file INET_Addr.cpp.

References 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().

00326 {
00327   ACE_TRACE ("ACE_INET_Addr::set");
00328 
00329   // Yow, someone gave us a NULL host_name!
00330   if (host_name == 0)
00331     {
00332       errno = EINVAL;
00333       return -1;
00334     }
00335 
00336   ACE_OS::memset ((void *) &this->inet_addr_,
00337                   0,
00338                   sizeof this->inet_addr_);
00339 
00340 #if defined (ACE_HAS_IPV6)
00341   struct addrinfo hints;
00342   struct addrinfo *res = 0;
00343   int error = 0;
00344   ACE_OS::memset (&hints, 0, sizeof (hints));
00345 # if defined (ACE_USES_IPV4_IPV6_MIGRATION)
00346   if (address_family == AF_UNSPEC && !ACE::ipv6_enabled())
00347     address_family = AF_INET;
00348 # endif /* ACE_USES_IPV4_IPV6_MIGRATION */
00349   if (address_family == AF_UNSPEC || address_family == AF_INET6)
00350     {
00351       hints.ai_family = AF_INET6;
00352       error = ::getaddrinfo (host_name, 0, &hints, &res);
00353       if (error)
00354         {
00355           if (address_family == AF_INET6)
00356             {
00357               if (res)
00358                 ::freeaddrinfo(res);
00359               errno = error;
00360               return -1;
00361             }
00362           address_family = AF_INET;
00363         }
00364     }
00365   if (address_family == AF_INET)
00366     {
00367       hints.ai_family = AF_INET;
00368       error = ::getaddrinfo (host_name, 0, &hints, &res);
00369       if (error)
00370         {
00371           if (res)
00372             ::freeaddrinfo(res);
00373           errno = error;
00374           return -1;
00375         }
00376     }
00377   this->set_type (res->ai_family);
00378   this->set_addr (res->ai_addr, res->ai_addrlen);
00379   this->set_port_number (port_number, encode);
00380   ::freeaddrinfo (res);
00381   return 0;
00382 #else /* ACE_HAS_IPV6 */
00383 
00384   // IPv6 not supported... insure the family is set to IPv4
00385   address_family = AF_INET;
00386   this->set_type (address_family);
00387   this->inet_addr_.in4_.sin_family = static_cast<short> (address_family);
00388 #ifdef ACE_HAS_SOCKADDR_IN_SIN_LEN
00389   this->inet_addr_.in4_.sin_len = sizeof (this->inet_addr_.in4_);
00390 #endif
00391   struct in_addr addrv4;
00392   if (ACE_OS::inet_aton (host_name,
00393                          &addrv4) == 1)
00394     return this->set (port_number,
00395                       encode ? ACE_NTOHL (addrv4.s_addr) : addrv4.s_addr,
00396                       encode);
00397   else
00398     {
00399 #  if defined (ACE_VXWORKS) && defined (ACE_LACKS_GETHOSTBYNAME)
00400       hostent *hp = ACE_OS::gethostbyname (host_name);
00401 #  else
00402       hostent hentry;
00403       ACE_HOSTENT_DATA buf;
00404       int h_error = 0;  // Not the same as errno!
00405 
00406       hostent *hp = ACE_OS::gethostbyname_r (host_name, &hentry,
00407                                              buf, &h_error);
00408       if (hp == 0)
00409         errno = h_error;
00410 #  endif /* ACE_VXWORKS */
00411 
00412       if (hp == 0)
00413         {
00414           return -1;
00415         }
00416       else
00417         {
00418           (void) ACE_OS::memcpy ((void *) &addrv4.s_addr,
00419                                  hp->h_addr,
00420                                  hp->h_length);
00421           return this->set (port_number,
00422                             encode ? ACE_NTOHL (addrv4.s_addr) : addrv4.s_addr,
00423                             encode);
00424         }
00425     }
00426 #endif /* ACE_HAS_IPV6 */
00427 }

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(), 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().

00169 {
00170   ACE_TRACE ("ACE_INET_Addr::set");
00171 
00172   if (sa.get_type () == AF_ANY)
00173     // Ugh, this is really a base class, so don't copy it.
00174     ACE_OS::memset (&this->inet_addr_, 0, sizeof (this->inet_addr_));
00175   else
00176     {
00177       // It's ok to make the copy.
00178       ACE_OS::memcpy (&this->inet_addr_,
00179                       &sa.inet_addr_,
00180                       sa.get_size ());
00181 
00182       this->set_type (sa.get_type());
00183       this->set_size (sa.get_size());
00184     }
00185 
00186   return 0;
00187 }

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

Set a pointer to the address.

Definition at line 609 of file INET_Addr.cpp.

References ACE_TRACE, AF_INET, inet_addr_, set_address(), set_port_number(), and ACE_Addr::set_type().

00610 {
00611   ACE_TRACE ("ACE_INET_Addr::set_addr");
00612   struct sockaddr_in *getfamily = static_cast<struct sockaddr_in *> (addr);
00613 
00614   if (getfamily->sin_family == AF_INET)
00615     {
00616 #if defined (ACE_HAS_IPV6)
00617       if (map)
00618         this->set_type (AF_INET6);
00619       else
00620 #endif /* ACE_HAS_IPV6 */
00621         this->set_type (AF_INET);
00622       this->set_port_number (getfamily->sin_port, 0);
00623       this->set_address (reinterpret_cast<const char*> (&getfamily->sin_addr),
00624                          sizeof (getfamily->sin_addr),
00625                          0, map);
00626     }
00627 #if defined (ACE_HAS_IPV6)
00628   else if (getfamily->sin_family == AF_INET6)
00629     {
00630       struct sockaddr_in6 *in6 = static_cast<struct sockaddr_in6*> (addr);
00631       this->set_port_number (in6->sin6_port, 0);
00632       this->set_address (reinterpret_cast<const char*> (&in6->sin6_addr),
00633                          sizeof (in6->sin6_addr),
00634                          0);
00635       this->inet_addr_.in6_.sin6_scope_id = in6->sin6_scope_id;
00636     }
00637 #endif // ACE_HAS_IPV6
00638 }

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

Set a pointer to the address.

Reimplemented from ACE_Addr.

Definition at line 602 of file INET_Addr.cpp.

Referenced by ACE_SOCK_SEQPACK_Association::get_local_addrs(), ACE_SOCK_SEQPACK_Association::get_remote_addrs(), and set().

00603 {
00604   this->set_addr (addr, len, 0);
00605 }

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 encode is enabled then <ip_addr> 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 <map> is non-zero, IPv6 support has been compiled in, and <ip_addr> is an IPv4 address, then this address is set to the IPv4-mapped IPv6 address of it.

Definition at line 929 of file INET_Addr.cpp.

References ACE_HTONL, ACE_TRACE, AF_INET, ACE_Addr::base_set(), INADDR_ANY, inet_addr_, ACE_OS::memcpy(), ACE_OS::memset(), and ACE_Addr::set_size().

Referenced by set(), and set_addr().

00933 {
00934   ACE_TRACE ("ACE_INET_Addr::set_address");
00935   // This is really intended for IPv4. If the object is IPv4, or the type
00936   // hasn't been set but it's a 4-byte address, go ahead. If this is an
00937   // IPv6 object and <encode> is requested, refuse.
00938   if (encode && len != 4)
00939     {
00940       errno = EAFNOSUPPORT;
00941       return -1;
00942     }
00943 
00944   if (len == 4)
00945     {
00946       ACE_UINT32 ip4 = *reinterpret_cast<const ACE_UINT32 *> (ip_addr);
00947       if (encode)
00948         ip4 = ACE_HTONL (ip4);
00949 
00950 
00951       if (this->get_type () == AF_INET && map == 0) {
00952         this->base_set (AF_INET, sizeof (this->inet_addr_.in4_));
00953 #ifdef ACE_HAS_SOCKADDR_IN_SIN_LEN
00954         this->inet_addr_.in4_.sin_len = sizeof (this->inet_addr_.in4_);
00955 #endif
00956         this->inet_addr_.in4_.sin_family = AF_INET;
00957         this->set_size (sizeof (this->inet_addr_.in4_));
00958         ACE_OS::memcpy (&this->inet_addr_.in4_.sin_addr,
00959                         &ip4,
00960                         len);
00961       }
00962 #if defined (ACE_HAS_IPV6)
00963       else if (map == 0)
00964         {
00965           // this->set_type (AF_INET);
00966           this->base_set (AF_INET, sizeof (this->inet_addr_.in4_));
00967 #ifdef ACE_HAS_SOCKADDR_IN_SIN_LEN
00968           this->inet_addr_.in4_.sin_len = sizeof (this->inet_addr_.in4_);
00969 #endif
00970           this->inet_addr_.in4_.sin_family = AF_INET;
00971           this->set_size (sizeof (this->inet_addr_.in4_));
00972           ACE_OS::memcpy (&this->inet_addr_.in4_.sin_addr,
00973                           &ip4, len);
00974         }
00975       // If given an IPv4 address to copy to an IPv6 object, map it to
00976       // an IPv4-mapped IPv6 address.
00977       else
00978         {
00979           this->base_set (AF_INET6, sizeof (this->inet_addr_.in6_));
00980 #ifdef ACE_HAS_SOCKADDR_IN6_SIN6_LEN
00981           this->inet_addr_.in6_.sin6_len = sizeof (this->inet_addr_.in6_);
00982 #endif
00983           this->inet_addr_.in6_.sin6_family = AF_INET6;
00984           this->set_size (sizeof (this->inet_addr_.in6_));
00985           if (ip4 == ACE_HTONL (INADDR_ANY))
00986             {
00987               in6_addr const ip6 = in6addr_any;
00988               ACE_OS::memcpy (&this->inet_addr_.in6_.sin6_addr,
00989                               &ip6,
00990                               sizeof (ip6));
00991               return 0;
00992             }
00993 
00994           // Build up a 128 bit address.  An IPv4-mapped IPv6 address
00995           // is defined as 0:0:0:0:0:ffff:IPv4_address.  This is defined
00996           // in RFC 1884 */
00997           ACE_OS::memset (&this->inet_addr_.in6_.sin6_addr, 0, 16);
00998           this->inet_addr_.in6_.sin6_addr.s6_addr[10] =
00999             this->inet_addr_.in6_.sin6_addr.s6_addr[11] = 0xff;
01000           ACE_OS::memcpy
01001             (&this->inet_addr_.in6_.sin6_addr.s6_addr[12], &ip4, 4);
01002         }
01003 #endif /* ACE_HAS_IPV6 */
01004       return 0;
01005     }   /* end if (len == 4) */
01006 #if defined (ACE_HAS_IPV6)
01007   else if (len == 16)
01008     {
01009       if (this->get_type () != PF_INET6)
01010         {
01011           errno = EAFNOSUPPORT;
01012           return -1;
01013         }
01014       // We protect ourselves up above so IPv6 must be possible here.
01015       this->base_set (AF_INET6, sizeof (this->inet_addr_.in6_));
01016       this->inet_addr_.in6_.sin6_family = AF_INET6;
01017 #ifdef ACE_HAS_SOCKADDR_IN6_SIN6_LEN
01018       this->inet_addr_.in6_.sin6_len = sizeof (this->inet_addr_.in6_);
01019 #endif
01020       ACE_OS::memcpy (&this->inet_addr_.in6_.sin6_addr, ip_addr, len);
01021 
01022       return 0;
01023     } /* end len == 16 */
01024 #endif /* ACE_HAS_IPV6 */
01025 
01026   // Here with an unrecognized length.
01027   errno = EAFNOSUPPORT;
01028   return -1;
01029 
01030 }

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

Sets the port number without affecting the host name. If encode is enabled then port_number 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 817 of file INET_Addr.cpp.

References ACE_HTONS, and ACE_TRACE.

Referenced by ACE_SOCK_Dgram_Mcast::join(), ACE_SOCK_Dgram_Mcast::open_i(), set(), set_addr(), and ACE_Multihomed_INET_Addr::set_port_number().

00819 {
00820   ACE_TRACE ("ACE_INET_Addr::set_port_number");
00821 
00822   if (encode)
00823     port_number = ACE_HTONS (port_number);
00824 
00825 #if defined (ACE_HAS_IPV6)
00826   if (this->get_type () == AF_INET6)
00827     this->inet_addr_.in6_.sin6_port = port_number;
00828   else
00829 #endif /* ACE_HAS_IPV6 */
00830   this->inet_addr_.in4_.sin_port = port_number;
00831 }

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 address 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_MAX_DEFAULT_PORT, ACE_TRACE, ACE_OS::free(), INADDR_ANY, set(), ACE_OS::strchr(), ACE_OS::strdup(), ACE_OS::strrchr(), and ACE_OS::strtol().

Referenced by set().

00193 {
00194   ACE_TRACE ("ACE_INET_Addr::string_to_addr");
00195   int result;
00196   char *ip_buf = 0;
00197   char *ip_addr = 0;
00198 
00199   // Need to make a duplicate since we'll be overwriting the string.
00200   ACE_ALLOCATOR_RETURN (ip_buf,
00201                         ACE_OS::strdup (s),
00202                         -1);
00203   ip_addr = ip_buf;
00204   // We use strrchr because of IPv6 addresses.
00205   char *port_p = ACE_OS::strrchr (ip_addr, ':');
00206 #if defined (ACE_HAS_IPV6)
00207   // Check for extended IPv6 format : '[' <ipv6 address> ']' ':' <port>
00208   if (ip_addr[0] == '[')
00209     {
00210       // find closing bracket
00211       char *cp_pos = ACE_OS::strchr (ip_addr, ']');
00212       // check for port separator after closing bracket
00213       // if not found leave it, error will come later
00214       if (cp_pos)
00215         {
00216           *cp_pos = '\0'; // blank out ']'
00217           ++ip_addr; // skip over '['
00218           if (cp_pos[1] == ':')
00219             port_p = cp_pos + 1;
00220           else
00221             port_p = cp_pos; // leads to error on missing port
00222         }
00223     }
00224 #endif /* ACE_HAS_IPV6 */
00225 
00226   if (port_p == 0) // Assume it's a port number.
00227     {
00228       char *endp = 0;
00229       long port = ACE_OS::strtol (ip_addr, &endp, 10);
00230 
00231       if (*endp == '\0')    // strtol scanned the entire string - all digits
00232         {
00233           if (port < 0 || port > ACE_MAX_DEFAULT_PORT)
00234             result = -1;
00235           else
00236             result = this->set (u_short (port), ACE_UINT32 (INADDR_ANY));
00237         }
00238       else // port name
00239         result = this->set (ip_addr, ACE_UINT32 (INADDR_ANY));
00240     }
00241   else
00242     {
00243       *port_p = '\0'; ++port_p; // skip over ':'
00244 
00245       char *endp = 0;
00246       long port = ACE_OS::strtol (port_p, &endp, 10);
00247 
00248       if (*endp == '\0')    // strtol scanned the entire string - all digits
00249         {
00250           if (port < 0 || port > ACE_MAX_DEFAULT_PORT)
00251             result = -1;
00252           else
00253             result = this->set (u_short (port), ip_addr, 1, address_family);
00254         }
00255       else
00256         result = this->set (port_p, ip_addr);
00257     }
00258 
00259   ACE_OS::free (ACE_MALLOC_T (ip_buf));
00260   return result;
00261 }

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.

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_host_name_i(), ip_addr_pointer(), ip_addr_size(), operator<(), operator==(), reset(), set(), set_addr(), and set_address().


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 (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.
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)
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
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	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_
}	inet_addr_

ACE_INET_Addr Class Reference

Public Member Functions

Public Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation