ACE/ace/Sock_Connect.cpp

   1 #include "ace/Sock_Connect.h"
   2 #include "ace/INET_Addr.h"
   3 #include "ace/Log_Category.h"
   4 #include "ace/Handle_Set.h"
   5 #include "ace/SString.h"
   6 #include "ace/OS_Memory.h"
   7 #include "ace/OS_NS_stdio.h"
   8 #include "ace/ACE.h"
   9 #include "ace/OS_NS_stdlib.h"
  10 #include "ace/OS_NS_string.h"
  11 #include "ace/OS_NS_sys_socket.h"
  12 #include "ace/OS_NS_netdb.h"
  13 #include "ace/OS_NS_unistd.h"
  14 #include "ace/os_include/net/os_if.h"
  15
  16 #if defined (ACE_HAS_IPV6)
  17 #  include "ace/Guard_T.h"
  18 #  include "ace/Recursive_Thread_Mutex.h"
  19 #endif /* ACE_HAS_IPV6 */
  20
  21 #if defined (ACE_HAS_GETIFADDRS)
  22 #  include "ace/os_include/os_ifaddrs.h"
  23 #endif /* ACE_HAS_GETIFADDRS */
  24
  25 #if defined (ACE_VXWORKS) && (ACE_VXWORKS <= 0x670) && defined (__RTP__) && defined (ACE_HAS_IPV6)
  26 const struct in6_addr in6addr_any = IN6ADDR_ANY_INIT;
  27 const struct in6_addr in6addr_nodelocal_allnodes = IN6ADDR_NODELOCAL_ALLNODES_INIT;
  28 const struct in6_addr in6addr_linklocal_allnodes = IN6ADDR_LINKLOCAL_ALLNODES_INIT;
  29 const struct in6_addr in6addr_linklocal_allrouters = IN6ADDR_LINKLOCAL_ALLROUTERS_INIT;
  30 #endif /* ACE_VXWORKS <= 0x670 && __RTP__ && ACE_HAS_IPV6 */
  31
  32 #if defined (ACE_WIN32)
  33 # include "ace/OS_NS_stdio.h"
  34 #endif
  35
  36 #if defined (ACE_HAS_IPV6)
  37
  38 // These defines support a generic usage based on
  39 // the various SIGCF*IF ioctl implementations
  40
  41 # if defined (SIOCGLIFCONF)
  42 #  define SIOCGIFCONF_CMD SIOCGLIFCONF
  43 #   define IFREQ lifreq
  44 #   define IFCONF lifconf
  45 #   define IFC_REQ lifc_req
  46 #   define IFC_LEN lifc_len
  47 #   define IFC_BUF lifc_buf
  48 #   define IFR_ADDR lifr_addr
  49 #   define IFR_NAME lifr_name
  50 #   define IFR_FLAGS lifr_flags
  51 #   define SETFAMILY
  52 #   define IFC_FAMILY lifc_family
  53 #   define IFC_FLAGS lifc_flags
  54 #   define SA_FAMILY ss_family
  55 # else
  56 #  define SIOCGIFCONF_CMD SIOCGIFCONF
  57 #  define IFREQ ifreq
  58 #  define IFCONF ifconf
  59 #  define IFC_REQ ifc_req
  60 #  define IFC_LEN ifc_len
  61 #  define IFC_BUF ifc_buf
  62 #  define IFR_ADDR ifr_addr
  63 #  define IFR_NAME ifr_name
  64 #  define IFR_FLAGS ifr_flags
  65 #  undef SETFAMILY
  66 #  define SA_FAMILY sa_family
  67 # endif /* SIOCGLIFCONF */
  68
  69 # if defined (ACE_HAS_THREADS)
  70 #  include "ace/Object_Manager.h"
  71 # endif /* ACE_HAS_THREADS */
  72
  73 namespace
  74 {
  75   // private:
  76   //  Used internally so not exported.
  77
  78   // Does this box have ipv4 turned on?
  79   int ace_ipv4_enabled = -1;
  80
  81   // Does this box have ipv6 turned on?
  82   int ace_ipv6_enabled = -1;
  83 }
  84 #else /* ACE_HAS_IPV6 */
  85 # define SIOCGIFCONF_CMD SIOCGIFCONF
  86 # define IFREQ ifreq
  87 # define IFCONF ifconf
  88 # define IFC_REQ ifc_req
  89 # define IFC_LEN ifc_len
  90 # define IFC_BUF ifc_buf
  91 # define IFR_ADDR ifr_addr
  92 # define IFR_NAME ifr_name
  93 # define IFR_FLAGS ifr_flags
  94 # undef SETFAMILY
  95 # define SA_FAMILY sa_family
  96 #endif /* ACE_HAS_IPV6 */
  97
  98 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  99
 100 // Bind socket to an unused port.
 101
 102 int
 103 ACE::bind_port (ACE_HANDLE handle, ACE_UINT32 ip_addr, int address_family)
 104 {
 105   ACE_TRACE ("ACE::bind_port");
 106
 107   ACE_INET_Addr addr;
 108
 109 #if defined (ACE_HAS_IPV6)
 110   if (address_family != PF_INET6)
 111     // What do we do if it is PF_"INET6?  Since it's 4 bytes, it must be an
 112     // IPV4 address. Is there a difference?  Why is this test done? dhinton
 113 #else /* ACE_HAS_IPV6 */
 114     ACE_UNUSED_ARG (address_family);
 115 #endif /* !ACE_HAS_IPV6 */
 116     addr = ACE_INET_Addr ((u_short)0, ip_addr);
 117 #if defined (ACE_HAS_IPV6)
 118  else if (ip_addr != INADDR_ANY)
 119  // address_family == PF_INET6 and a non default IP address means to bind
 120  // to the IPv4-mapped IPv6 address
 121    addr.set ((u_short)0, ip_addr, 1, 1);
 122 #endif /* ACE_HAS_IPV6 */
 123
 124   // The OS kernel should select a free port for us.
 125   return ACE_OS::bind (handle,
 126                        (sockaddr*)addr.get_addr(),
 127                        addr.get_size());
 128 }
 129
 130 int
 131 ACE::get_bcast_addr (ACE_UINT32 &bcast_addr,
 132                      const ACE_TCHAR *host_name,
 133                      ACE_UINT32 host_addr,
 134                      ACE_HANDLE handle)
 135 {
 136   ACE_TRACE ("ACE::get_bcast_addr");
 137
 138 #if defined (ACE_LACKS_GET_BCAST_ADDR)
 139   ACE_UNUSED_ARG (bcast_addr);
 140   ACE_UNUSED_ARG (host_name);
 141   ACE_UNUSED_ARG (host_addr);
 142   ACE_UNUSED_ARG (handle);
 143   ACE_NOTSUP_RETURN (-1);
 144 #elif !defined(ACE_WIN32)
 145   ACE_HANDLE s = handle;
 146
 147   if (s == ACE_INVALID_HANDLE)
 148     s = ACE_OS::socket (AF_INET, SOCK_STREAM, 0);
 149
 150   if (s == ACE_INVALID_HANDLE)
 151     ACELIB_ERROR_RETURN ((LM_ERROR,
 152                        ACE_TEXT ("%p\n"),
 153                        ACE_TEXT ("ACE_OS::socket")),
 154                       -1);
 155
 156   struct ifconf ifc;
 157   char buf[BUFSIZ];
 158
 159   ifc.ifc_len = sizeof buf;
 160   ifc.ifc_buf = buf;
 161
 162   // Get interface structure and initialize the addresses using UNIX
 163   // techniques
 164   if (ACE_OS::ioctl (s, SIOCGIFCONF_CMD, (char *) &ifc) == -1)
 165     ACELIB_ERROR_RETURN ((LM_ERROR,
 166                        ACE_TEXT ("%p\n"),
 167                        ACE_TEXT ("ACE::get_bcast_addr:")
 168                        ACE_TEXT ("ioctl (get interface configuration)")),
 169                       -1);
 170
 171   struct ifreq *ifr = ifc.ifc_req;
 172
 173   struct sockaddr_in ip_addr;
 174
 175   // Get host ip address if necessary.
 176   if (host_name)
 177     {
 178       hostent *hp = ACE_OS::gethostbyname (ACE_TEXT_ALWAYS_CHAR (host_name));
 179
 180       if (hp == 0)
 181         return -1;
 182       else
 183         ACE_OS::memcpy ((char *) &ip_addr.sin_addr.s_addr,
 184 # ifdef ACE_HOSTENT_H_ADDR
 185                         (char *) hp->ACE_HOSTENT_H_ADDR,
 186 # else
 187                         (char *) hp->h_addr,
 188 # endif
 189                         hp->h_length);
 190     }
 191   else
 192     {
 193       ACE_OS::memset ((void *) &ip_addr, 0, sizeof ip_addr);
 194       ACE_OS::memcpy ((void *) &ip_addr.sin_addr,
 195                       (void*) &host_addr,
 196                       sizeof ip_addr.sin_addr);
 197     }
 198
 199 #if !defined (__QNX__) && !defined (__FreeBSD__) && !defined(__NetBSD__) && !defined (__Lynx__)
 200   for (int n = ifc.ifc_len / sizeof (struct ifreq) ; n > 0;
 201        n--, ifr++)
 202 #else
 203   // see mk_broadcast@SOCK_Dgram_Bcast.cpp
 204   for (int nbytes = ifc.ifc_len; nbytes >= (int) sizeof (struct ifreq) &&
 205         ((ifr->ifr_addr.sa_len > sizeof (struct sockaddr)) ?
 206           (nbytes >= (int) sizeof (ifr->ifr_name) + ifr->ifr_addr.sa_len) : 1);
 207         ((ifr->ifr_addr.sa_len > sizeof (struct sockaddr)) ?
 208           (nbytes -= sizeof (ifr->ifr_name) + ifr->ifr_addr.sa_len,
 209             ifr = (struct ifreq *)
 210               ((caddr_t) &ifr->ifr_addr + ifr->ifr_addr.sa_len)) :
 211           (nbytes -= sizeof (struct ifreq), ifr++)))
 212 #endif /* !defined (__QNX__) && !defined (__FreeBSD__) && !defined(__NetBSD__) && !defined (__Lynx__) */
 213     {
 214       struct sockaddr_in if_addr;
 215
 216       // Compare host ip address with interface ip address.
 217       ACE_OS::memcpy (&if_addr,
 218                       &ifr->ifr_addr,
 219                       sizeof if_addr);
 220
 221       if (ip_addr.sin_addr.s_addr != if_addr.sin_addr.s_addr)
 222         continue;
 223
 224       if (ifr->ifr_addr.sa_family != AF_INET)
 225         {
 226           ACELIB_ERROR ((LM_ERROR,
 227                       ACE_TEXT ("%p\n"),
 228                       ACE_TEXT ("ACE::get_bcast_addr:")
 229                       ACE_TEXT ("Not AF_INET")));
 230           continue;
 231         }
 232
 233       struct ifreq flags = *ifr;
 234       struct ifreq if_req = *ifr;
 235
 236       if (ACE_OS::ioctl (s, SIOCGIFFLAGS, (char *) &flags) == -1)
 237         {
 238           ACELIB_ERROR ((LM_ERROR,
 239                       ACE_TEXT ("%p\n"),
 240                       ACE_TEXT ("ACE::get_bcast_addr:")
 241                       ACE_TEXT (" ioctl (get interface flags)")));
 242           continue;
 243         }
 244
 245       if (ACE_BIT_DISABLED (flags.ifr_flags, IFF_UP))
 246         {
 247           ACELIB_ERROR ((LM_ERROR,
 248                       ACE_TEXT ("%p\n"),
 249                       ACE_TEXT ("ACE::get_bcast_addr:")
 250                       ACE_TEXT ("Network interface is not up")));
 251           continue;
 252         }
 253
 254       if (ACE_BIT_ENABLED (flags.ifr_flags, IFF_LOOPBACK))
 255         continue;
 256
 257       if (ACE_BIT_ENABLED (flags.ifr_flags, IFF_BROADCAST))
 258         {
 259           if (ACE_OS::ioctl (s,
 260                              SIOCGIFBRDADDR,
 261                              (char *) &if_req) == -1)
 262             ACELIB_ERROR ((LM_ERROR,
 263                         ACE_TEXT ("%p\n"),
 264                         ACE_TEXT ("ACE::get_bcast_addr:")
 265                         ACE_TEXT ("ioctl (get broadaddr)")));
 266           else
 267             {
 268               ACE_OS::memcpy (&ip_addr,
 269                               &if_req.ifr_broadaddr,
 270                               sizeof if_req.ifr_broadaddr);
 271
 272               ACE_OS::memcpy ((void *) &host_addr,
 273                               (void *) &ip_addr.sin_addr,
 274                               sizeof host_addr);
 275
 276               if (handle == ACE_INVALID_HANDLE)
 277                 ACE_OS::close (s);
 278
 279               bcast_addr = host_addr;
 280               return 0;
 281             }
 282         }
 283       else
 284         ACELIB_ERROR ((LM_ERROR,
 285                     ACE_TEXT ("%p\n"),
 286                     ACE_TEXT ("ACE::get_bcast_addr:")
 287                     ACE_TEXT ("Broadcast is not enabled for this interface.")));
 288
 289       if (handle == ACE_INVALID_HANDLE)
 290         ACE_OS::close (s);
 291
 292       bcast_addr = host_addr;
 293       return 0;
 294     }
 295
 296   return 0;
 297 #else
 298   ACE_UNUSED_ARG (handle);
 299   ACE_UNUSED_ARG (host_addr);
 300   ACE_UNUSED_ARG (host_name);
 301   bcast_addr = (ACE_UINT32 (INADDR_BROADCAST));
 302   return 0;
 303 #endif /* !ACE_WIN32 */
 304 }
 305
 306 int
 307 ACE::get_fqdn (ACE_INET_Addr const & addr,
 308                char hostname[],
 309                size_t len)
 310 {
 311 #ifndef ACE_LACKS_GETNAMEINFO
 312
 313   const socklen_t addr_size =
 314 # ifdef ACE_HAS_IPV6
 315     (addr.get_type () == PF_INET6) ? sizeof (sockaddr_in6) :
 316 # endif
 317     sizeof (sockaddr_in);
 318
 319   if (ACE_OS::getnameinfo ((const sockaddr *) addr.get_addr (),
 320                            addr_size, hostname,
 321                            static_cast<ACE_SOCKET_LEN> (len),
 322                            0, 0, NI_NAMEREQD) != 0)
 323     return -1;
 324
 325   if (ACE::debug ())
 326     ACELIB_DEBUG ((LM_DEBUG,
 327                    ACE_TEXT ("(%P|%t) - ACE::get_fqdn, ")
 328                    ACE_TEXT ("canonical host name is %C\n"),
 329                    hostname));
 330
 331   return 0;
 332 #else // below, ACE_LACKS_GETNAMEINFO
 333   int h_error;  // Not the same as errno!
 334   hostent hentry;
 335   ACE_HOSTENT_DATA buf;
 336
 337   char * ip_addr = 0;
 338   int ip_addr_size = 0;
 339   if (addr.get_type () == AF_INET)
 340     {
 341       sockaddr_in * const sock_addr =
 342         reinterpret_cast<sockaddr_in *> (addr.get_addr ());
 343       ip_addr_size = sizeof sock_addr->sin_addr;
 344       ip_addr = (char*) &sock_addr->sin_addr;
 345     }
 346 # ifdef ACE_HAS_IPV6
 347   else
 348     {
 349       sockaddr_in6 * sock_addr =
 350         reinterpret_cast<sockaddr_in6 *> (addr.get_addr ());
 351
 352       ip_addr_size = sizeof sock_addr->sin6_addr;
 353       ip_addr = (char*) &sock_addr->sin6_addr;
 354     }
 355 # endif /* ACE_HAS_IPV6 */
 356
 357    // get the host entry for the address in question
 358    hostent * const hp = ACE_OS::gethostbyaddr_r (ip_addr,
 359                                                  ip_addr_size,
 360                                                  addr.get_type (),
 361                                                  &hentry,
 362                                                  buf,
 363                                                  &h_error);
 364
 365    // if it's not found in the host file or the DNS datase, there is nothing
 366    // much we can do. embed the IP address
 367    if (hp == 0 || hp->h_name == 0)
 368      return -1;
 369
 370    if (ACE::debug())
 371      ACELIB_DEBUG ((LM_DEBUG,
 372                  ACE_TEXT ("(%P|%t) - ACE::get_fqdn, ")
 373                  ACE_TEXT ("canonical host name is %C\n"),
 374                  hp->h_name));
 375
 376    // check if the canonical name is the FQDN
 377    if (!ACE_OS::strchr(hp->h_name, '.'))
 378      {
 379        // list of address
 380        char** p;
 381        // list of aliases
 382        char** q;
 383
 384        // for every address and for every alias within the address, check and
 385        // see if we can locate a FQDN
 386        for (p = hp->h_addr_list; *p != 0; ++p)
 387          {
 388            for (q = hp->h_aliases; *q != 0; ++q)
 389              {
 390                if (ACE_OS::strchr(*q, '.'))
 391                  {
 392                    // we got an FQDN from an alias. use this
 393                    if (ACE_OS::strlen (*q) >= len)
 394                      // the hostname is too huge to fit into a
 395                      // buffer of size MAXHOSTNAMELEN
 396                      // should we check other aliases as well
 397                      // before bailing out prematurely?
 398                      // for right now, let's do it. this (short name)
 399                      // is atleast better than embedding the IP
 400                      // address in the profile
 401                      continue;
 402
 403                    if (ACE::debug ())
 404                      ACELIB_DEBUG ((LM_DEBUG,
 405                                  ACE_TEXT ("(%P|%t) - ACE::get_fqdn, ")
 406                                  ACE_TEXT ("found fqdn within alias as %C\n"),
 407                                  *q));
 408                    ACE_OS::strcpy (hostname, *q);
 409
 410                    return 0;
 411                  }
 412              }
 413          }
 414      }
 415
 416    // The canonical name may be an FQDN when we reach here.
 417    // Alternatively, the canonical name (a non FQDN) may be the best
 418    // we can do.
 419    if (ACE_OS::strlen (hp->h_name) >= len)
 420      {
 421        // The hostname is too large to fit into a buffer of size
 422        // MAXHOSTNAMELEN.
 423        return -2;
 424      }
 425    else
 426      {
 427        ACE_OS::strcpy (hostname, hp->h_name);
 428      }
 429
 430    return 0;
 431 #endif /* ACE_LACKS_GETNAMEINFO */
 432 }
 433
 434 #if defined (ACE_WIN32)
 435
 436 static int
 437 get_ip_interfaces_win32 (size_t &count,
 438                          ACE_INET_Addr *&addrs)
 439 {
 440   int i, n_interfaces, status;
 441
 442   INTERFACE_INFO info[64];
 443   SOCKET sock;
 444
 445   // Get an (overlapped) DGRAM socket to test with
 446   sock = socket (AF_INET, SOCK_DGRAM, 0);
 447   if (sock == INVALID_SOCKET)
 448     return -1;
 449
 450   DWORD bytes;
 451   status = WSAIoctl(sock,
 452                     SIO_GET_INTERFACE_LIST,
 453                     0,
 454                     0,
 455                     info,
 456                     sizeof(info),
 457                     &bytes,
 458                     0,
 459                     0);
 460   closesocket (sock);
 461   if (status == SOCKET_ERROR)
 462     return -1;
 463
 464   n_interfaces = bytes / sizeof(INTERFACE_INFO);
 465
 466   // SIO_GET_INTERFACE_LIST does not work for IPv6
 467   // Instead recent versions of Winsock2 add the new opcode
 468   // SIO_ADDRESS_LIST_QUERY.
 469   // If this is not available forget about IPv6 local interfaces:-/
 470   int n_v6_interfaces = 0;
 471
 472 # if defined (ACE_HAS_IPV6) && defined (SIO_ADDRESS_LIST_QUERY)
 473
 474   LPSOCKET_ADDRESS_LIST v6info;
 475   char *buffer;
 476   DWORD buflen = sizeof (SOCKET_ADDRESS_LIST) + (63 * sizeof (SOCKET_ADDRESS));
 477   ACE_NEW_RETURN (buffer,
 478                   char[buflen],
 479                   -1);
 480   v6info = reinterpret_cast<LPSOCKET_ADDRESS_LIST> (buffer);
 481
 482   // Get an (overlapped) DGRAM socket to test with.
 483   // If it fails only return IPv4 interfaces.
 484   sock = socket (AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
 485   if (sock != INVALID_SOCKET)
 486     {
 487       status = WSAIoctl(sock,
 488                         SIO_ADDRESS_LIST_QUERY,
 489                         0,
 490                         0,
 491                         v6info,
 492                         buflen,
 493                         &bytes,
 494                         0,
 495                         0);
 496       closesocket (sock);
 497       if (status != SOCKET_ERROR)
 498         n_v6_interfaces = v6info->iAddressCount;
 499     }
 500 # endif /* ACE_HAS_IPV6 */
 501
 502   ACE_NEW_RETURN (addrs,
 503                   ACE_INET_Addr[n_interfaces + n_v6_interfaces],
 504                   -1);
 505
 506   // Now go through the list and transfer the good ones to the list of
 507   // because they're down or don't have an IP address.
 508   for (count = 0, i = 0; i < n_interfaces; ++i)
 509     {
 510       LPINTERFACE_INFO lpii;
 511       struct sockaddr_in *addrp = 0;
 512
 513       lpii = &info[i];
 514       if (!(lpii->iiFlags & IFF_UP))
 515         continue;
 516
 517       // We assume IPv4 addresses here
 518       addrp = reinterpret_cast<struct sockaddr_in *> (&lpii->iiAddress.AddressIn);
 519       if (addrp->sin_addr.s_addr == INADDR_ANY)
 520         continue;
 521
 522       // Set the address for the caller.
 523       addrs[count].set(addrp, sizeof(sockaddr_in));
 524       ++count;
 525     }
 526
 527 # if defined (ACE_HAS_IPV6) && defined (SIO_ADDRESS_LIST_QUERY)
 528   // Now go through the list and transfer the good ones to the list of
 529   // because they're down or don't have an IP address.
 530   for (i = 0; i < n_v6_interfaces; i++)
 531     {
 532       struct sockaddr_in6 *addr6p;
 533
 534       if (v6info->Address[i].lpSockaddr->sa_family != AF_INET6)
 535         continue;
 536
 537       addr6p = reinterpret_cast<struct sockaddr_in6 *> (v6info->Address[i].lpSockaddr);
 538       if (IN6_IS_ADDR_UNSPECIFIED(&addr6p->sin6_addr))  // IN6ADDR_ANY?
 539         continue;
 540
 541       // Set the address for the caller.
 542       addrs[count].set(reinterpret_cast<struct sockaddr_in *> (addr6p), sizeof(sockaddr_in6));
 543       ++count;
 544     }
 545
 546   delete [] buffer; // Clean up
 547 # endif /* ACE_HAS_IPV6 */
 548
 549   if (count == 0)
 550     {
 551       delete [] addrs;
 552       addrs = 0;
 553     }
 554
 555   return 0;
 556 }
 557
 558 #elif defined (ACE_HAS_GETIFADDRS)
 559 static int
 560 get_ip_interfaces_getifaddrs (size_t &count,
 561                               ACE_INET_Addr *&addrs)
 562 {
 563   // Take advantage of the BSD getifaddrs function that simplifies
 564   // access to connected interfaces.
 565   struct ifaddrs *ifap = 0;
 566   struct ifaddrs *p_if = 0;
 567
 568   if (::getifaddrs (&ifap) != 0)
 569     return -1;
 570
 571   // Count number of interfaces.
 572   size_t num_ifs = 0;
 573   for (p_if = ifap; p_if != 0; p_if = p_if->ifa_next)
 574     ++num_ifs;
 575
 576   // Now create and initialize output array.
 577   ACE_NEW_RETURN (addrs,
 578                   ACE_INET_Addr[num_ifs],
 579                   -1); // caller must free
 580
 581   // Pull the address out of each INET interface.  Not every interface
 582   // is for IP, so be careful to count properly.  When setting the
 583   // INET_Addr, note that the 3rd arg (0) says to leave the byte order
 584   // (already in net byte order from the interface structure) as is.
 585   count = 0;
 586
 587   for (p_if = ifap;
 588        p_if != 0;
 589        p_if = p_if->ifa_next)
 590     {
 591       if (p_if->ifa_addr == 0)
 592         continue;
 593
 594       // Check to see if it's up.
 595       if ((p_if->ifa_flags & IFF_UP) != IFF_UP)
 596         continue;
 597
 598       if (p_if->ifa_addr->sa_family == AF_INET)
 599         {
 600           struct sockaddr_in *addr =
 601             reinterpret_cast<sockaddr_in *> (p_if->ifa_addr);
 602
 603           // Sometimes the kernel returns 0.0.0.0 as the interface
 604           // address, skip those...
 605           if (addr->sin_addr.s_addr != INADDR_ANY)
 606             {
 607               addrs[count].set ((u_short) 0,
 608                                 addr->sin_addr.s_addr,
 609                                 0);
 610               ++count;
 611             }
 612         }
 613 # if defined (ACE_HAS_IPV6)
 614       else if (p_if->ifa_addr->sa_family == AF_INET6)
 615         {
 616           struct sockaddr_in6 *addr =
 617             reinterpret_cast<sockaddr_in6 *> (p_if->ifa_addr);
 618
 619           // Skip the ANY address
 620           if (!IN6_IS_ADDR_UNSPECIFIED(&addr->sin6_addr))
 621             {
 622               addrs[count].set(reinterpret_cast<struct sockaddr_in *> (addr),
 623                                sizeof(sockaddr_in6));
 624               ++count;
 625             }
 626         }
 627 # endif /* ACE_HAS_IPV6 */
 628     }
 629
 630   ::freeifaddrs (ifap);
 631
 632   return 0;
 633 }
 634 #endif // ACE_WIN32 || ACE_HAS_GETIFADDRS
 635
 636
 637 // return an array of all configured IP interfaces on this host, count
 638 // rc = 0 on success (count == number of interfaces else -1 caller is
 639 // responsible for calling delete [] on parray
 640
 641 int
 642 ACE::get_ip_interfaces (size_t &count, ACE_INET_Addr *&addrs)
 643 {
 644   ACE_TRACE ("ACE::get_ip_interfaces");
 645
 646   count = 0;
 647   addrs = 0;
 648
 649 #if defined (ACE_WIN32)
 650   return get_ip_interfaces_win32 (count, addrs);
 651 #elif defined (ACE_HAS_GETIFADDRS)
 652   return get_ip_interfaces_getifaddrs (count, addrs);
 653 #elif (defined (__unix) || defined (__unix__) || (defined (ACE_VXWORKS) && !defined (ACE_HAS_GETIFADDRS))) && !defined (ACE_LACKS_NETWORKING)
 654   // COMMON (SVR4 and BSD) UNIX CODE
 655
 656   // Call specific routine as necessary.
 657   ACE_HANDLE handle = ACE::get_handle();
 658
 659   if (handle == ACE_INVALID_HANDLE)
 660     ACELIB_ERROR_RETURN ((LM_ERROR,
 661                        ACE_TEXT ("%p\n"),
 662                        ACE_TEXT ("ACE::get_ip_interfaces:open")),
 663                       -1);
 664
 665   size_t num_ifs = 0;
 666
 667   if (ACE::count_interfaces (handle, num_ifs))
 668     {
 669       ACE_OS::close (handle);
 670       return -1;
 671     }
 672
 673   // ioctl likes to have an extra ifreq structure to mark the end of
 674   // what it returned, so increase the num_ifs by one.
 675   ++num_ifs;
 676
 677   struct IFREQ *ifs = 0;
 678   ACE_NEW_RETURN (ifs,
 679                   struct IFREQ[num_ifs],
 680                   -1);
 681   ACE_OS::memset (ifs, 0, num_ifs * sizeof (struct IFREQ));
 682
 683   std::unique_ptr<struct IFREQ[]> p_ifs (ifs);
 684
 685   if (p_ifs.get() == 0)
 686     {
 687       ACE_OS::close (handle);
 688       errno = ENOMEM;
 689       return -1;
 690     }
 691
 692   struct IFCONF ifcfg;
 693   ACE_OS::memset (&ifcfg, 0, sizeof (struct IFCONF));
 694
 695 # ifdef SETFAMILY
 696   ifcfg.IFC_FAMILY = AF_UNSPEC;  // request all families be returned
 697   ifcfg.IFC_FLAGS = 0;
 698 # endif
 699
 700   ifcfg.IFC_REQ = p_ifs.get ();
 701   ifcfg.IFC_LEN = num_ifs * sizeof (struct IFREQ);
 702
 703   if (ACE_OS::ioctl (handle,
 704                      SIOCGIFCONF_CMD,
 705                      (caddr_t) &ifcfg) == -1)
 706     {
 707       ACE_OS::close (handle);
 708       ACELIB_ERROR_RETURN ((LM_ERROR,
 709                          ACE_TEXT ("%p\n"),
 710                          ACE_TEXT ("ACE::get_ip_interfaces:")
 711                          ACE_TEXT ("ioctl - SIOCGIFCONF failed")),
 712                         -1);
 713     }
 714
 715   ACE_OS::close (handle);
 716
 717   // Now create and initialize output array.
 718
 719   ACE_NEW_RETURN (addrs,
 720                   ACE_INET_Addr[num_ifs],
 721                   -1); // caller must free
 722
 723   struct IFREQ *pcur = p_ifs.get ();
 724   size_t num_ifs_found = ifcfg.IFC_LEN / sizeof (struct IFREQ); // get the number of returned ifs
 725
 726   // Pull the address out of each INET interface.  Not every interface
 727   // is for IP, so be careful to count properly.  When setting the
 728   // INET_Addr, note that the 3rd arg (0) says to leave the byte order
 729   // (already in net byte order from the interface structure) as is.
 730   count = 0;
 731
 732   for (size_t i = 0;
 733        i < num_ifs_found;
 734        i++)
 735     {
 736       if (pcur->IFR_ADDR.SA_FAMILY == AF_INET
 737 #  if defined (ACE_HAS_IPV6)
 738           || pcur->IFR_ADDR.SA_FAMILY == AF_INET6
 739 #  endif
 740           )
 741
 742         {
 743           struct sockaddr_in *addr =
 744             reinterpret_cast<sockaddr_in *> (&pcur->IFR_ADDR);
 745
 746           // Sometimes the kernel returns 0.0.0.0 as an IPv4 interface
 747           // address; skip those...
 748           if (addr->sin_addr.s_addr != 0
 749 #  if defined (ACE_HAS_IPV6)
 750               || (addr->sin_family == AF_INET6 &&
 751                   !IN6_IS_ADDR_UNSPECIFIED(&reinterpret_cast<sockaddr_in6 *>(addr)->sin6_addr))
 752 #  endif
 753               )
 754             {
 755               int addrlen = static_cast<int> (sizeof (struct sockaddr_in));
 756 #  if defined (ACE_HAS_IPV6)
 757               if (addr->sin_family == AF_INET6)
 758                 addrlen = static_cast<int> (sizeof (struct sockaddr_in6));
 759 #  endif
 760               addrs[count].set (addr, addrlen);
 761               ++count;
 762             }
 763         }
 764
 765 #if !defined (__QNX__) && !defined (__FreeBSD__) && !defined(__NetBSD__) && !defined (__Lynx__)
 766       ++pcur;
 767 #else
 768       if (pcur->ifr_addr.sa_len <= sizeof (struct sockaddr))
 769         {
 770            ++pcur;
 771         }
 772       else
 773         {
 774            pcur = (struct ifreq *)
 775                (pcur->ifr_addr.sa_len + (caddr_t) &pcur->ifr_addr);
 776         }
 777 #endif /* !defined (__QNX__) && !defined (__FreeBSD__) && !defined(__NetBSD__) && !defined (__Lynx__) */
 778     }
 779
 780 # if defined (ACE_HAS_IPV6) && !defined (ACE_LACKS_FSCANF)
 781   // Retrieve IPv6 local interfaces by scanning /proc/net/if_inet6 if
 782   // it exists.  If we cannot open it then ignore possible IPv6
 783   // interfaces, we did our best;-)
 784   FILE* fp = 0;
 785   char addr_p[8][5];
 786   char s_ipaddr[64];
 787   int scopeid;
 788   struct addrinfo hints, *res0;
 789   int error;
 790
 791   ACE_OS::memset (&hints, 0, sizeof (hints));
 792   hints.ai_flags = AI_NUMERICHOST;
 793   hints.ai_family = AF_INET6;
 794
 795   if ((fp = ACE_OS::fopen (ACE_TEXT ("/proc/net/if_inet6"), ACE_TEXT ("r"))) != 0)
 796     {
 797       while (fscanf (fp,
 798                      "%4s%4s%4s%4s%4s%4s%4s%4s %02x %*02x %*02x %*02x %*8s\n",
 799                      addr_p[0], addr_p[1], addr_p[2], addr_p[3],
 800                      addr_p[4], addr_p[5], addr_p[6], addr_p[7], &scopeid) != EOF)
 801         {
 802           // Format the address intoa proper IPv6 decimal address specification and
 803           // resolve the resulting text using getaddrinfo().
 804
 805           const char* ip_fmt = "%s:%s:%s:%s:%s:%s:%s:%s%%%d";
 806           ACE_OS::snprintf (s_ipaddr, 64, ip_fmt,
 807                             addr_p[0], addr_p[1], addr_p[2], addr_p[3],
 808                             addr_p[4], addr_p[5], addr_p[6], addr_p[7],
 809                             scopeid);
 810
 811           error = ACE_OS::getaddrinfo (s_ipaddr, 0, &hints, &res0);
 812           if (error)
 813             continue;
 814
 815           if (res0->ai_family == AF_INET6 &&
 816                 !IN6_IS_ADDR_UNSPECIFIED (&reinterpret_cast<sockaddr_in6 *> (res0->ai_addr)->sin6_addr))
 817             {
 818               addrs[count].set(reinterpret_cast<sockaddr_in *> (res0->ai_addr), res0->ai_addrlen);
 819               ++count;
 820             }
 821           ACE_OS::freeaddrinfo (res0);
 822         }
 823       ACE_OS::fclose (fp);
 824     }
 825 # endif /* ACE_HAS_IPV6 && !ACE_LACKS_FSCANF */
 826
 827   return 0;
 828 #else
 829   ACE_UNUSED_ARG (count);
 830   ACE_UNUSED_ARG (addrs);
 831   ACE_NOTSUP_RETURN (-1);                      // no implementation
 832 #endif /* ACE_WIN32 */
 833 }
 834
 835 // Helper routine for get_ip_interfaces, differs by UNIX platform so
 836 // put into own subroutine.  perform some ioctls to retrieve ifconf
 837 // list of ifreq structs.
 838
 839 int
 840 ACE::count_interfaces (ACE_HANDLE handle, size_t &how_many)
 841 {
 842 #if defined (SIOCGIFNUM)
 843 # if defined (SIOCGLIFNUM)
 844   int cmd = SIOCGLIFNUM;
 845   struct lifnum if_num = {AF_UNSPEC,0,0};
 846 # else
 847   int cmd = SIOCGIFNUM;
 848   int if_num = 0;
 849 # endif /* SIOCGLIFNUM */
 850   if (ACE_OS::ioctl (handle, cmd, (caddr_t)&if_num) == -1)
 851     ACELIB_ERROR_RETURN ((LM_ERROR,
 852                        ACE_TEXT ("%p\n"),
 853                        ACE_TEXT ("ACE::count_interfaces:")
 854                        ACE_TEXT ("ioctl - SIOCGLIFNUM failed")),
 855                       -1);
 856 # if defined (SIOCGLIFNUM)
 857   how_many = if_num.lifn_count;
 858 # else
 859   how_many = if_num;
 860 # endif /* SIOCGLIFNUM */
 861 return 0;
 862
 863 #elif (defined (__unix) || defined (__unix__) || (defined (ACE_VXWORKS) && !defined (ACE_HAS_GETIFADDRS))) && !defined (ACE_LACKS_NETWORKING)
 864   // Note: DEC CXX doesn't define "unix".  BSD compatible OS: HP UX,
 865   // SunOS 4.x perform some ioctls to retrieve ifconf list of
 866   // ifreq structs no SIOCGIFNUM on SunOS 4.x, so use guess and scan
 867   // algorithm
 868
 869   // Probably hard to put this many ifs in a unix box..
 870   int const MAX_INTERFACES = 50;
 871
 872   // HACK - set to an unreasonable number
 873   int const num_ifs = MAX_INTERFACES;
 874
 875   struct ifconf ifcfg;
 876   size_t ifreq_size = num_ifs * sizeof (struct ifreq);
 877   struct ifreq *p_ifs;
 878
 879 #if defined (ACE_HAS_ALLOC_HOOKS)
 880   p_ifs = (struct IFREQ *)ACE_Allocator::instance()->malloc (ifreq_size);
 881 #else
 882   p_ifs = (struct ifreq *) ACE_OS::malloc (ifreq_size);
 883 #endif /* ACE_HAS_ALLOC_HOOKS */
 884
 885   if (!p_ifs)
 886     {
 887       errno = ENOMEM;
 888       return -1;
 889     }
 890
 891   ACE_OS::memset (p_ifs, 0, ifreq_size);
 892   ACE_OS::memset (&ifcfg, 0, sizeof (struct ifconf));
 893
 894   ifcfg.ifc_req = p_ifs;
 895   ifcfg.ifc_len = ifreq_size;
 896
 897   if (ACE_OS::ioctl (handle,
 898                      SIOCGIFCONF_CMD,
 899                      (caddr_t) &ifcfg) == -1)
 900     {
 901 #if defined (ACE_HAS_ALLOC_HOOKS)
 902       ACE_Allocator::instance()->free (ifcfg.ifc_req);
 903 #else
 904       ACE_OS::free (ifcfg.ifc_req);
 905 #endif /* ACE_HAS_ALLOC_HOOKS */
 906
 907       ACELIB_ERROR_RETURN ((LM_ERROR,
 908                          ACE_TEXT ("%p\n"),
 909                          ACE_TEXT ("ACE::count_interfaces:")
 910                          ACE_TEXT ("ioctl - SIOCGIFCONF failed")),
 911                         -1);
 912     }
 913
 914   int if_count = 0;
 915   int i = 0;
 916
 917   // get if address out of ifreq buffers.  ioctl puts a blank-named
 918   // interface to mark the end of the returned interfaces.
 919   for (i = 0;
 920        i < num_ifs;
 921        i++)
 922     {
 923       /* In OpenBSD, the length of the list is returned. */
 924       ifcfg.ifc_len -= sizeof (struct ifreq);
 925       if (ifcfg.ifc_len < 0)
 926         break;
 927
 928       ++if_count;
 929 # if !defined (__QNX__) && !defined (__FreeBSD__) && !defined(__NetBSD__) && !defined (__Lynx__)
 930       ++p_ifs;
 931 # else
 932      if (p_ifs->ifr_addr.sa_len <= sizeof (struct sockaddr))
 933        {
 934           ++p_ifs;
 935        }
 936        else
 937        {
 938           p_ifs = (struct ifreq *)
 939               (p_ifs->ifr_addr.sa_len + (caddr_t) &p_ifs->ifr_addr);
 940        }
 941 # endif /* !defined (__QNX__) && !defined (__FreeBSD__) && !defined(__NetBSD__) && !defined (__Lynx__) */
 942     }
 943
 944 #if defined (ACE_HAS_ALLOC_HOOKS)
 945       ACE_Allocator::instance()->free (ifcfg.ifc_req);
 946 #else
 947       ACE_OS::free (ifcfg.ifc_req);
 948 #endif /* ACE_HAS_ALLOC_HOOKS */
 949
 950 # if defined (ACE_HAS_IPV6)
 951   FILE* fp = 0;
 952
 953   if ((fp = ACE_OS::fopen (ACE_TEXT ("/proc/net/if_inet6"), ACE_TEXT ("r"))) != 0)
 954     {
 955       // Scan the lines according to the expected format but don't really read any input
 956       while (fscanf (fp, "%*32s %*02x %*02x %*02x %*02x %*8s\n") != EOF)
 957         {
 958           ++if_count;
 959         }
 960       ACE_OS::fclose (fp);
 961     }
 962 # endif /* ACE_HAS_IPV6  && !ACE_LACKS_FSCANF */
 963
 964   how_many = if_count;
 965   return 0;
 966 #else
 967   ACE_UNUSED_ARG (handle);
 968   ACE_UNUSED_ARG (how_many);
 969   ACE_NOTSUP_RETURN (-1); // no implementation
 970 #endif /* sparc && SIOCGIFNUM */
 971 }
 972
 973 // Routine to return a handle from which ioctl() requests can be made.
 974 ACE_HANDLE
 975 ACE::get_handle ()
 976 {
 977   ACE_HANDLE handle = ACE_INVALID_HANDLE;
 978 #if defined (__unix) || defined (__unix__) || (defined (ACE_VXWORKS) && (ACE_VXWORKS >= 0x600))
 979   // Note: DEC CXX doesn't define "unix" BSD compatible OS: SunOS 4.x
 980   handle = ACE_OS::socket (PF_INET, SOCK_DGRAM, 0);
 981 #endif /* __unux */
 982   return handle;
 983 }
 984
 985 #if defined (ACE_HAS_IPV6)
 986 static int
 987 ip_check (int &ipvn_enabled, int pf)
 988 {
 989   // We only get to this point if ipvn_enabled was -1 in the caller.
 990   // Perform Double-Checked Locking Optimization.
 991   ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
 992                             *ACE_Static_Object_Lock::instance (), 0));
 993
 994   if (ipvn_enabled == -1)
 995     {
 996 #if defined (ACE_WIN32)
 997       static bool recursing = false;
 998       if (recursing) return 1;
 999
1000       // as of the release of Windows 2008, even hosts that have IPv6 interfaces disabled
1001       // will still permit the creation of a PF_INET6 socket, thus rendering the socket
1002       // creation test inconsistent. The recommended solution is to get the list of
1003       // endpoint addresses and see if any match the desired family.
1004       ACE_INET_Addr *if_addrs = 0;
1005       size_t if_cnt = 0;
1006
1007       // assume enabled to avoid recursion during interface lookup.
1008       recursing = true;
1009       ACE::get_ip_interfaces (if_cnt, if_addrs);
1010       recursing = false;
1011
1012       bool found = false;
1013       for (size_t i = 0; !found && i < if_cnt; i++)
1014         {
1015           found = (if_addrs[i].get_type () == pf);
1016         }
1017       delete [] if_addrs;
1018
1019       // If the list of interfaces is empty, we've tried too quickly. Assume enabled, but don't cache the result
1020       if (!if_cnt) return 1;
1021
1022       ipvn_enabled = found ? 1 : 0;
1023 #else
1024       // Determine if the kernel has IPv6 support by attempting to
1025       // create a PF_INET6 socket and see if it fails.
1026       ACE_HANDLE const s = ACE_OS::socket (pf, SOCK_DGRAM, 0);
1027       if (s == ACE_INVALID_HANDLE)
1028         {
1029           ipvn_enabled = 0;
1030         }
1031       else
1032         {
1033           ipvn_enabled = 1;
1034           ACE_OS::closesocket (s);
1035         }
1036 #endif
1037     }
1038   return ipvn_enabled;
1039 }
1040 #endif /* ACE_HAS_IPV6 */
1041
1042 bool
1043 ACE::ipv4_enabled ()
1044 {
1045 #if defined (ACE_HAS_IPV6)
1046   return static_cast<bool> (ace_ipv4_enabled == -1 ?
1047                             ::ip_check (ace_ipv4_enabled, PF_INET) :
1048                             ace_ipv4_enabled);
1049 #else
1050  // Assume it's always enabled since ACE requires some version of
1051  // TCP/IP to exist.
1052   return true;
1053 #endif  /* ACE_HAS_IPV6*/
1054 }
1055
1056 int
1057 ACE::ipv6_enabled ()
1058 {
1059 #if defined (ACE_HAS_IPV6)
1060   return ace_ipv6_enabled == -1 ?
1061     ::ip_check (ace_ipv6_enabled, PF_INET6) :
1062     ace_ipv6_enabled;
1063 #else /* ACE_HAS_IPV6 */
1064   return 0;
1065 #endif /* !ACE_HAS_IPV6 */
1066 }
1067
1068 ACE_END_VERSIONED_NAMESPACE_DECL