../../../../pr/src/misc/prnetdb.c

Bug Summary

File:	pr/Linux4.19_x86_64_gcc_glibc_PTH_64_DBG.OBJ/pr/src/misc/../../../../pr/src/misc/prnetdb.c
Warning:	line 2235, column 18 Access to field 'ai_next' results in a dereference of a null pointer (loaded from variable 'ai')
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name prnetdb.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=all -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/var/lib/jenkins/workspace/nss-scan-build/nspr/Linux4.19_x86_64_gcc_glibc_PTH_64_DBG.OBJ/pr/src/misc -fcoverage-compilation-dir=/var/lib/jenkins/workspace/nss-scan-build/nspr/Linux4.19_x86_64_gcc_glibc_PTH_64_DBG.OBJ/pr/src/misc -resource-dir /usr/lib/llvm-18/lib/clang/18 -U NDEBUG -D DEBUG_jenkins -D PACKAGE_NAME="" -D PACKAGE_TARNAME="" -D PACKAGE_VERSION="" -D PACKAGE_STRING="" -D PACKAGE_BUGREPORT="" -D PACKAGE_URL="" -D DEBUG=1 -D HAVE_VISIBILITY_HIDDEN_ATTRIBUTE=1 -D HAVE_VISIBILITY_PRAGMA=1 -D XP_UNIX=1 -D _GNU_SOURCE=1 -D HAVE_FCNTL_FILE_LOCKING=1 -D HAVE_POINTER_LOCALTIME_R=1 -D LINUX=1 -D HAVE_DLADDR=1 -D HAVE_GETTID=1 -D HAVE_LCHOWN=1 -D HAVE_SETPRIORITY=1 -D HAVE_STRERROR=1 -D HAVE_SYSCALL=1 -D HAVE_SECURE_GETENV=1 -D _REENTRANT=1 -D FORCE_PR_LOG -D _PR_PTHREADS -U HAVE_CVAR_BUILT_ON_SEM -D _NSPR_BUILD_ -I /var/lib/jenkins/workspace/nss-scan-build/nss/../dist/Linux4.19_x86_64_gcc_glibc_PTH_64_DBG.OBJ/include -I ../../../../pr/include -I ../../../../pr/include/private -internal-isystem /usr/lib/llvm-18/lib/clang/18/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -ferror-limit 19 -fvisibility=hidden -fgnuc-version=4.2.1 -fno-inline -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2024-05-18-082241-28900-1 -x c ../../../../pr/src/misc/prnetdb.c
1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */

6#include "primpl.h"

8#include <string.h>

10#if defined(LINUX1)
11#include <sys/un.h>
12#endif

14/*
* On Unix, the error code for gethostbyname() and gethostbyaddr()
* is returned in the global variable h_errno, instead of the usual
* errno.
*/
19#if defined(XP_UNIX1)
20#if defined(_PR_NEED_H_ERRNO)
21extern int h_errno(*__h_errno_location ());
22#endif
23#define _MD_GETHOST_ERRNO()(*__h_errno_location ()) h_errno(*__h_errno_location ())
24#else
25#define _MD_GETHOST_ERRNO()(*__h_errno_location ()) _MD_ERRNO()((*__errno_location ()))
26#endif

28/*
* The meaning of the macros related to gethostbyname, gethostbyaddr,
* and gethostbyname2 is defined below.
* - _PR_HAVE_THREADSAFE_GETHOST: the gethostbyXXX functions return
*   the result in thread specific storage.  For example, AIX, HP-UX.
* -  _PR_HAVE_GETHOST_R: have the gethostbyXXX_r functions. See next
*   two macros.
* - _PR_HAVE_GETHOST_R_INT: the gethostbyXXX_r functions return an
*   int.  For example, Linux glibc.
* - _PR_HAVE_GETHOST_R_POINTER: the gethostbyXXX_r functions return
*   a struct hostent* pointer.  For example, Solaris.
*/
40#if defined(_PR_NO_PREEMPT) || defined(_PR_HAVE_GETHOST_R) \
  || defined(_PR_HAVE_THREADSAFE_GETHOST)
42#define _PR_NO_DNS_LOCK
43#endif

45#if defined(_PR_NO_DNS_LOCK)
46#define LOCK_DNS()
47#define UNLOCK_DNS()
48#else
49PRLock *_pr_dnsLock = NULL((void*)0);
50#define LOCK_DNS() PR_Lock(_pr_dnsLock)
51#define UNLOCK_DNS() PR_Unlock(_pr_dnsLock)
52#endif  /* defined(_PR_NO_DNS_LOCK) */

54/*
* Some platforms have the reentrant getprotobyname_r() and
* getprotobynumber_r().  However, they come in three flavors.
* Some return a pointer to struct protoent, others return
* an int, and glibc's flavor takes five arguments.
*/

61#if defined(SOLARIS) || (defined(BSDI) && defined(_REENTRANT1)) \
  || (defined(LINUX1) && defined(_REENTRANT1) \
      && defined(__GLIBC__2) && __GLIBC__2 < 2)
64#define _PR_HAVE_GETPROTO_R
65#define _PR_HAVE_GETPROTO_R_POINTER
66#endif

68#if defined(AIX4_3_PLUS) || (defined(AIX) && defined(_THREAD_SAFE)) \
  || (defined(HPUX10_10) && defined(_REENTRANT1)) \
      || (defined(HPUX10_20) && defined(_REENTRANT1)) \
      || defined(OPENBSD)
72#define _PR_HAVE_GETPROTO_R
73#define _PR_HAVE_GETPROTO_R_INT
74#endif

76#if __FreeBSD_version >= 602000
77#define _PR_HAVE_GETPROTO_R
78#define _PR_HAVE_5_ARG_GETPROTO_R
79#endif

81/* BeOS has glibc but not the glibc-style getprotobyxxx_r functions. */
82#if (defined(__GLIBC__2) && __GLIBC__2 >= 2)
83#define _PR_HAVE_GETPROTO_R
84#define _PR_HAVE_5_ARG_GETPROTO_R
85#endif

87#if !defined(_PR_HAVE_GETPROTO_R)
88PRLock* _getproto_lock = NULL((void*)0);
89#endif

91#if defined(_PR_INET6_PROBE)
92extern PRBool _pr_ipv6_is_present(void);
93#endif

95#define _PR_IN6_IS_ADDR_UNSPECIFIED(a)(((a)->_S6_un._S6_u32[0] == 0) && ((a)->_S6_un.
_S6_u32[1] == 0) && ((a)->_S6_un._S6_u32[2] == 0) &&
 ((a)->_S6_un._S6_u32[3] == 0))              \
              (((a)->pr_s6_addr32_S6_un._S6_u32[0] == 0) && \
              ((a)->pr_s6_addr32_S6_un._S6_u32[1] == 0) &&      \
              ((a)->pr_s6_addr32_S6_un._S6_u32[2] == 0) &&      \
              ((a)->pr_s6_addr32_S6_un._S6_u32[3] == 0))

101#define _PR_IN6_IS_ADDR_LOOPBACK(a)(((a)->_S6_un._S6_u32[0] == 0) && ((a)->_S6_un.
_S6_u32[1] == 0) && ((a)->_S6_un._S6_u32[2] == 0) &&
 ((a)->_S6_un._S6_u8[12] == 0) && ((a)->_S6_un.
_S6_u8[13] == 0) && ((a)->_S6_un._S6_u8[14] == 0) &&
 ((a)->_S6_un._S6_u8[15] == 0x1U))                 \
             (((a)->pr_s6_addr32_S6_un._S6_u32[0] == 0) &&  \
             ((a)->pr_s6_addr32_S6_un._S6_u32[1] == 0)      &&  \
             ((a)->pr_s6_addr32_S6_un._S6_u32[2] == 0)      &&  \
             ((a)->pr_s6_addr_S6_un._S6_u8[12] == 0)       &&  \
             ((a)->pr_s6_addr_S6_un._S6_u8[13] == 0)       &&  \
             ((a)->pr_s6_addr_S6_un._S6_u8[14] == 0)       &&  \
             ((a)->pr_s6_addr_S6_un._S6_u8[15] == 0x1U))

110const PRIPv6Addr _pr_in6addr_any =  {{{
          0, 0, 0, 0,
          0, 0, 0, 0,
          0, 0, 0, 0,
          0, 0, 0, 0
      }
  }
117};

119const PRIPv6Addr _pr_in6addr_loopback = {{{
          0, 0, 0, 0,
          0, 0, 0, 0,
          0, 0, 0, 0,
          0, 0, 0, 0x1U
      }
  }
126};
127/*
* The values at bytes 10 and 11 are compared using pointers to
* 8-bit fields, and not 32-bit fields, to make the comparison work on
* both big-endian and little-endian systems
*/

133#define _PR_IN6_IS_ADDR_V4MAPPED(a)(((a)->_S6_un._S6_u32[0] == 0) && ((a)->_S6_un.
_S6_u32[1] == 0) && ((a)->_S6_un._S6_u8[8] == 0) &&
 ((a)->_S6_un._S6_u8[9] == 0) && ((a)->_S6_un._S6_u8
[10] == 0xff) && ((a)->_S6_un._S6_u8[11] == 0xff))         \
      (((a)->pr_s6_addr32_S6_un._S6_u32[0] == 0)    &&  \
      ((a)->pr_s6_addr32_S6_un._S6_u32[1] == 0) &&  \
      ((a)->pr_s6_addr_S6_un._S6_u8[8] == 0)       &&  \
      ((a)->pr_s6_addr_S6_un._S6_u8[9] == 0)       &&  \
      ((a)->pr_s6_addr_S6_un._S6_u8[10] == 0xff)   &&  \
      ((a)->pr_s6_addr_S6_un._S6_u8[11] == 0xff))

141#define _PR_IN6_IS_ADDR_V4COMPAT(a)(((a)->_S6_un._S6_u32[0] == 0) && ((a)->_S6_un.
_S6_u32[1] == 0) && ((a)->_S6_un._S6_u32[2] == 0))         \
      (((a)->pr_s6_addr32_S6_un._S6_u32[0] == 0) && \
      ((a)->pr_s6_addr32_S6_un._S6_u32[1] == 0) &&      \
      ((a)->pr_s6_addr32_S6_un._S6_u32[2] == 0))

146#define _PR_IN6_V4MAPPED_TO_IPADDR(a)((a)->_S6_un._S6_u32[3]) ((a)->pr_s6_addr32_S6_un._S6_u32[3])

148#if defined(_PR_INET6) && defined(_PR_HAVE_GETHOSTBYNAME2)

150/*
* The _pr_QueryNetIfs() function finds out if the system has
* IPv4 or IPv6 source addresses configured and sets _pr_have_inet_if
* and _pr_have_inet6_if accordingly.
*
* We have an implementation using SIOCGIFCONF ioctl and a
* default implementation that simply sets _pr_have_inet_if
* and _pr_have_inet6_if to true.  A better implementation
* would be to use the routing sockets (see Chapter 17 of
* W. Richard Stevens' Unix Network Programming, Vol. 1, 2nd. Ed.)
*/

162static PRLock *_pr_query_ifs_lock = NULL((void*)0);
163static PRBool _pr_have_inet_if = PR_FALSE0;
164static PRBool _pr_have_inet6_if = PR_FALSE0;

166#undef DEBUG_QUERY_IFS

168#if defined(AIX) \
  || (defined(DARWIN) && !defined(HAVE_GETIFADDRS))

171/*
* Use SIOCGIFCONF ioctl on platforms that don't have routing
* sockets.  Warning: whether SIOCGIFCONF ioctl returns AF_INET6
* network interfaces is not portable.
*
* The _pr_QueryNetIfs() function is derived from the code in
* src/lib/libc/net/getifaddrs.c in BSD Unix and the code in
* Section 16.6 of W. Richard Stevens' Unix Network Programming,
* Vol. 1, 2nd. Ed.
*/

182#include <sys/ioctl.h>
183#include <sys/socket.h>
184#include <netinet/in.h>
185#include <net/if.h>

187#ifdef DEBUG_QUERY_IFS
188static void
189_pr_PrintIfreq(struct ifreq *ifr)
190{
  PRNetAddr addr;
  struct sockaddr *sa;
  const char* family;
  char addrstr[64];

  sa = &ifr->ifr_addr;
  if (sa->sa_family == AF_INET2) {
      struct sockaddr_in *sin = (struct sockaddr_in *)sa;
      family = "inet";
      memcpy(&addr.inet.ip, &sin->sin_addr, sizeof(sin->sin_addr));
  } else if (sa->sa_family == AF_INET610) {
      struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sa;
      family = "inet6";
      memcpy(&addr.ipv6.ip, &sin6->sin6_addr, sizeof(sin6->sin6_addr));
  } else {
      return;  /* skip if not AF_INET or AF_INET6 */
  }
  addr.raw.family = sa->sa_family;
  PR_NetAddrToString(&addr, addrstr, sizeof(addrstr));
  printf("%s: %s %s\n", ifr->ifr_name, family, addrstr);
211}
212#endif

214static void
215_pr_QueryNetIfs(void)
216{
  int sock;
  int rv;
  struct ifconf ifc;
  struct ifreq *ifr;
  struct ifreq *lifr;
  PRUint32 len, lastlen;
  char *buf;

  if ((sock = socket(AF_INET2, SOCK_STREAMSOCK_STREAM, 0)) == -1) {
      return;
  }

  /* Issue SIOCGIFCONF request in a loop. */
  lastlen = 0;
  len = 100 * sizeof(struct ifreq);  /* initial buffer size guess */
  for (;;) {
      buf = (char *)PR_Malloc(len);
      if (NULL((void*)0) == buf) {
          close(sock);
          return;
      }
      ifc.ifc_buf = buf;
      ifc.ifc_len = len;
      rv = ioctl(sock, SIOCGIFCONF, &ifc);
      if (rv < 0) {
          if (errno(*__errno_location ()) != EINVAL22 || lastlen != 0) {
              close(sock);
              PR_Free(buf);
              return;
          }
      } else {
          if (ifc.ifc_len == lastlen) {
              break;    /* success, len has not changed */
          }
          lastlen = ifc.ifc_len;
      }
      len += 10 * sizeof(struct ifreq);  /* increment */
      PR_Free(buf);
  }
  close(sock);

  ifr = ifc.ifc_req;
  lifr = (struct ifreq *)&ifc.ifc_buf[ifc.ifc_len];

  while (ifr < lifr) {
      struct sockaddr *sa;
      int sa_len;

265#ifdef DEBUG_QUERY_IFS
      _pr_PrintIfreq(ifr);
267#endif
      sa = &ifr->ifr_addr;
      if (sa->sa_family == AF_INET2) {
          struct sockaddr_in *sin = (struct sockaddr_in *) sa;
          if (sin->sin_addr.s_addr != htonl(INADDR_LOOPBACK((in_addr_t) 0x7f000001))) {
              _pr_have_inet_if = PR_TRUE1;
          }
      } else if (sa->sa_family == AF_INET610) {
          struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *) sa;
          if (!IN6_IS_ADDR_LOOPBACK(&sin6->sin6_addr)(__extension__ ({ const struct in6_addr *__a = (const struct in6_addr
 *) (&sin6->sin6_addr); __a->__in6_u.__u6_addr32[0]
 == 0 && __a->__in6_u.__u6_addr32[1] == 0 &&
 __a->__in6_u.__u6_addr32[2] == 0 && __a->__in6_u
.__u6_addr32[3] == htonl (1); }))
              && !IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr)(__extension__ ({ const struct in6_addr *__a = (const struct in6_addr
 *) (&sin6->sin6_addr); (__a->__in6_u.__u6_addr32[0
] & htonl (0xffc00000)) == htonl (0xfe800000); }))) {
              _pr_have_inet6_if = PR_TRUE1;
          }
      }

282#ifdef _PR_HAVE_SOCKADDR_LEN
      sa_len = PR_MAX(sa->sa_len, sizeof(struct sockaddr))((sa->sa_len)>(sizeof(struct sockaddr))?(sa->sa_len)
:(sizeof(struct sockaddr)));
284#else
      switch (sa->sa_family) {
286#ifdef AF_LINK
          case AF_LINK:
              sa_len = sizeof(struct sockaddr_dl);
              break;
290#endif
          case AF_INET610:
              sa_len = sizeof(struct sockaddr_in6);
              break;
          default:
              sa_len = sizeof(struct sockaddr);
              break;
      }
298#endif
      ifr = (struct ifreq *)(((char *)sa) + sa_len);
  }
  PR_Free(buf);
302}

304#elif (defined(DARWIN) && defined(HAVE_GETIFADDRS)) || defined(FREEBSD) \
  || defined(NETBSD) || defined(OPENBSD)

307/*
* Use the BSD getifaddrs function.
*/

311#include <sys/types.h>
312#include <sys/socket.h>
313#include <ifaddrs.h>
314#include <netinet/in.h>

316#ifdef DEBUG_QUERY_IFS
317static void
318_pr_PrintIfaddrs(struct ifaddrs *ifa)
319{
  struct sockaddr *sa;
  const char* family;
  void *addrp;
  char addrstr[64];

  sa = ifa->ifa_addr;
  if (sa->sa_family == AF_INET2) {
      struct sockaddr_in *sin = (struct sockaddr_in *)sa;
      family = "inet";
      addrp = &sin->sin_addr;
  } else if (sa->sa_family == AF_INET610) {
      struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sa;
      family = "inet6";
      addrp = &sin6->sin6_addr;
  } else {
      return;  /* skip if not AF_INET or AF_INET6 */
  }
  inet_ntop(sa->sa_family, addrp, addrstr, sizeof(addrstr));
  printf("%s: %s %s\n", ifa->ifa_name, family, addrstr);
339}
340#endif

342static void
343_pr_QueryNetIfs(void)
344{
  struct ifaddrs *ifp;
  struct ifaddrs *ifa;

  if (getifaddrs(&ifp) == -1) {
      return;
  }
  for (ifa = ifp; ifa; ifa = ifa->ifa_next) {
      struct sockaddr *sa;

354#ifdef DEBUG_QUERY_IFS
      _pr_PrintIfaddrs(ifa);
356#endif
      sa = ifa->ifa_addr;
      if (sa->sa_family == AF_INET2) {
          struct sockaddr_in *sin = (struct sockaddr_in *) sa;
          if (sin->sin_addr.s_addr != htonl(INADDR_LOOPBACK((in_addr_t) 0x7f000001))) {
              _pr_have_inet_if = 1;
          }
      } else if (sa->sa_family == AF_INET610) {
          struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *) sa;
          if (!IN6_IS_ADDR_LOOPBACK(&sin6->sin6_addr)(__extension__ ({ const struct in6_addr *__a = (const struct in6_addr
 *) (&sin6->sin6_addr); __a->__in6_u.__u6_addr32[0]
 == 0 && __a->__in6_u.__u6_addr32[1] == 0 &&
 __a->__in6_u.__u6_addr32[2] == 0 && __a->__in6_u
.__u6_addr32[3] == htonl (1); }))
              && !IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr)(__extension__ ({ const struct in6_addr *__a = (const struct in6_addr
 *) (&sin6->sin6_addr); (__a->__in6_u.__u6_addr32[0
] & htonl (0xffc00000)) == htonl (0xfe800000); }))) {
              _pr_have_inet6_if = 1;
          }
      }
  }
  freeifaddrs(ifp);
372}

374#else  /* default */

376/*
* Emulate the code in NSPR 4.2 or older.  PR_GetIPNodeByName behaves
* as if the system had both IPv4 and IPv6 source addresses configured.
*/
380static void
381_pr_QueryNetIfs(void)
382{
  _pr_have_inet_if = PR_TRUE1;
  _pr_have_inet6_if = PR_TRUE1;
385}

387#endif

389#endif  /* _PR_INET6 && _PR_HAVE_GETHOSTBYNAME2 */

391void _PR_InitNet(void)
392{
393#if defined(XP_UNIX1)
394#ifdef HAVE_NETCONFIG
  /*
   * This one-liner prevents the endless re-open's and re-read's of
   * /etc/netconfig on EACH and EVERY call to accept(), connect(), etc.
   */
  (void)setnetconfig();
400#endif
401#endif
402#if !defined(_PR_NO_DNS_LOCK)
  _pr_dnsLock = PR_NewLock();
404#endif
405#if !defined(_PR_HAVE_GETPROTO_R)
  _getproto_lock = PR_NewLock();
407#endif
408#if defined(_PR_INET6) && defined(_PR_HAVE_GETHOSTBYNAME2)
  _pr_query_ifs_lock = PR_NewLock();
410#endif
411}

413void _PR_CleanupNet(void)
414{
415#if !defined(_PR_NO_DNS_LOCK)
  if (_pr_dnsLock) {
      PR_DestroyLock(_pr_dnsLock);
      _pr_dnsLock = NULL((void*)0);
  }
420#endif
421#if !defined(_PR_HAVE_GETPROTO_R)
  if (_getproto_lock) {
      PR_DestroyLock(_getproto_lock);
      _getproto_lock = NULL((void*)0);
  }
426#endif
427#if defined(_PR_INET6) && defined(_PR_HAVE_GETHOSTBYNAME2)
  if (_pr_query_ifs_lock) {
      PR_DestroyLock(_pr_query_ifs_lock);
      _pr_query_ifs_lock = NULL((void*)0);
  }
432#endif
433}

435/*
436** Allocate space from the buffer, aligning it to "align" before doing
437** the allocation. "align" must be a power of 2.
438*/
439static char *Alloc(PRIntn amount, char **bufp, PRIntn *buflenp, PRIntn align)
440{
  char *buf = *bufp;
  PRIntn buflen = *buflenp;

  if (align && ((long)buf & (align - 1))) {
      PRIntn skip = align - ((ptrdiff_t)buf & (align - 1));
      if (buflen < skip) {
          return 0;
      }
      buf += skip;
      buflen -= skip;
  }
  if (buflen < amount) {
      return 0;
  }
  *bufp = buf + amount;
  *buflenp = buflen - amount;
  return buf;
458}

460typedef enum _PRIPAddrConversion {
  _PRIPAddrNoConversion,
  _PRIPAddrIPv4Mapped,
  _PRIPAddrIPv4Compat
464} _PRIPAddrConversion;

466/*
467** Convert an IPv4 address (v4) to an IPv4-mapped IPv6 address (v6).
468*/
469static void MakeIPv4MappedAddr(const char *v4, char *v6)
470{
  memset(v6, 0, 10);
  memset(v6 + 10, 0xff, 2);
  memcpy(v6 + 12, v4, 4);
474}

476/*
477** Convert an IPv4 address (v4) to an IPv4-compatible IPv6 address (v6).
478*/
479static void MakeIPv4CompatAddr(const char *v4, char *v6)
480{
  memset(v6, 0, 12);
  memcpy(v6 + 12, v4, 4);
483}

485/*
486** Copy a hostent, and all of the memory that it refers to into
487** (hopefully) stacked buffers.
488*/
489static PRStatus CopyHostent(
  struct hostent *from,
  char **buf,
  PRIntn *bufsize,
  _PRIPAddrConversion conversion,
  PRHostEnt *to)
495{
  PRIntn len, na;
  char **ap;

  if (conversion != _PRIPAddrNoConversion
      && from->h_addrtype == AF_INET2) {
      PR_ASSERT(from->h_length == 4)((from->h_length == 4)?((void)0):PR_Assert("from->h_length == 4"
,"../../../../pr/src/misc/prnetdb.c",501));
      to->h_addrtype = PR_AF_INET610;
      to->h_length = 16;
  } else {
505#if defined(_PR_INET6) || defined(_PR_INET6_PROBE)
      if (AF_INET610 == from->h_addrtype) {
          to->h_addrtype = PR_AF_INET610;
      }
      else
510#endif
          to->h_addrtype = from->h_addrtype;
      to->h_length = from->h_length;
  }

  /* Copy the official name */
  if (!from->h_name) {
      return PR_FAILURE;
  }
  len = strlen(from->h_name) + 1;
  to->h_name = Alloc(len, buf, bufsize, 0);
  if (!to->h_name) {
      return PR_FAILURE;
  }
  memcpy(to->h_name, from->h_name, len);

  /* Count the aliases, then allocate storage for the pointers */
  if (!from->h_aliases) {
      na = 1;
  } else {
      for (na = 1, ap = from->h_aliases; *ap != 0; na++, ap++) {;} /* nothing to execute */
  }
  to->h_aliases = (char**)Alloc(
                      na * sizeof(char*), buf, bufsize, sizeof(char**));
  if (!to->h_aliases) {
      return PR_FAILURE;
  }

  /* Copy the aliases, one at a time */
  if (!from->h_aliases) {
      to->h_aliases[0] = 0;
  } else {
      for (na = 0, ap = from->h_aliases; *ap != 0; na++, ap++) {
          len = strlen(*ap) + 1;
          to->h_aliases[na] = Alloc(len, buf, bufsize, 0);
          if (!to->h_aliases[na]) {
              return PR_FAILURE;
          }
          memcpy(to->h_aliases[na], *ap, len);
      }
      to->h_aliases[na] = 0;
  }

  /* Count the addresses, then allocate storage for the pointers */
  for (na = 1, ap = from->h_addr_list; *ap != 0; na++, ap++) {;} /* nothing to execute */
  to->h_addr_list = (char**)Alloc(
                        na * sizeof(char*), buf, bufsize, sizeof(char**));
  if (!to->h_addr_list) {
      return PR_FAILURE;
  }

  /* Copy the addresses, one at a time */
  for (na = 0, ap = from->h_addr_list; *ap != 0; na++, ap++) {
      to->h_addr_list[na] = Alloc(to->h_length, buf, bufsize, 0);
      if (!to->h_addr_list[na]) {
          return PR_FAILURE;
      }
      if (conversion != _PRIPAddrNoConversion
          && from->h_addrtype == AF_INET2) {
          if (conversion == _PRIPAddrIPv4Mapped) {
              MakeIPv4MappedAddr(*ap, to->h_addr_list[na]);
          } else {
              PR_ASSERT(conversion == _PRIPAddrIPv4Compat)((conversion == _PRIPAddrIPv4Compat)?((void)0):PR_Assert("conversion == _PRIPAddrIPv4Compat"
,"../../../../pr/src/misc/prnetdb.c",572));
              MakeIPv4CompatAddr(*ap, to->h_addr_list[na]);
          }
      } else {
          memcpy(to->h_addr_list[na], *ap, to->h_length);
      }
  }
  to->h_addr_list[na] = 0;
  return PR_SUCCESS;
581}

583#if !defined(_PR_HAVE_GETPROTO_R)
584/*
585** Copy a protoent, and all of the memory that it refers to into
586** (hopefully) stacked buffers.
587*/
588static PRStatus CopyProtoent(
  struct protoent *from, char *buf, PRIntn bufsize, PRProtoEnt *to)
590{
  PRIntn len, na;
  char **ap;

  /* Do the easy stuff */
  to->p_num = from->p_proto;

  /* Copy the official name */
  if (!from->p_name) {
      return PR_FAILURE;
  }
  len = strlen(from->p_name) + 1;
  to->p_name = Alloc(len, &buf, &bufsize, 0);
  if (!to->p_name) {
      return PR_FAILURE;
  }
  memcpy(to->p_name, from->p_name, len);

  /* Count the aliases, then allocate storage for the pointers */
  for (na = 1, ap = from->p_aliases; *ap != 0; na++, ap++) {;} /* nothing to execute */
  to->p_aliases = (char**)Alloc(
                      na * sizeof(char*), &buf, &bufsize, sizeof(char**));
  if (!to->p_aliases) {
      return PR_FAILURE;
  }

  /* Copy the aliases, one at a time */
  for (na = 0, ap = from->p_aliases; *ap != 0; na++, ap++) {
      len = strlen(*ap) + 1;
      to->p_aliases[na] = Alloc(len, &buf, &bufsize, 0);
      if (!to->p_aliases[na]) {
          return PR_FAILURE;
      }
      memcpy(to->p_aliases[na], *ap, len);
  }
  to->p_aliases[na] = 0;

  return PR_SUCCESS;
628}
629#endif /* !defined(_PR_HAVE_GETPROTO_R) */

631/*
* #################################################################
* NOTE: tmphe, tmpbuf, bufsize, h, and h_err are local variables
* or arguments of PR_GetHostByName, PR_GetIPNodeByName, and
* PR_GetHostByAddr.  DO NOT CHANGE THE NAMES OF THESE LOCAL
* VARIABLES OR ARGUMENTS.
* #################################################################
*/
639#if defined(_PR_HAVE_GETHOST_R_INT)

641#define GETHOSTBYNAME(name)(gethostbyname_r(name, &tmphe, tmpbuf, bufsize, &h, &
h_err), h) \
  (gethostbyname_r(name, &tmphe, tmpbuf, bufsize, &h, &h_err), h)
643#define GETHOSTBYNAME2(name, af)(gethostbyname2_r(name, af, &tmphe, tmpbuf, bufsize, &
h, &h_err), h) \
  (gethostbyname2_r(name, af, &tmphe, tmpbuf, bufsize, &h, &h_err), h)
645#define GETHOSTBYADDR(addr, addrlen, af)(gethostbyaddr_r(addr, addrlen, af, &tmphe, tmpbuf, bufsize
, &h, &h_err), h) \
  (gethostbyaddr_r(addr, addrlen, af, \
  &tmphe, tmpbuf, bufsize, &h, &h_err), h)

649#elif defined(_PR_HAVE_GETHOST_R_POINTER)

651#define GETHOSTBYNAME(name)(gethostbyname_r(name, &tmphe, tmpbuf, bufsize, &h, &
h_err), h) \
  gethostbyname_r(name, &tmphe, tmpbuf, bufsize, &h_err)
653#define GETHOSTBYNAME2(name, af)(gethostbyname2_r(name, af, &tmphe, tmpbuf, bufsize, &
h, &h_err), h) \
  gethostbyname2_r(name, af, &tmphe, tmpbuf, bufsize, &h_err)
655#define GETHOSTBYADDR(addr, addrlen, af)(gethostbyaddr_r(addr, addrlen, af, &tmphe, tmpbuf, bufsize
, &h, &h_err), h) \
  gethostbyaddr_r(addr, addrlen, af, &tmphe, tmpbuf, bufsize, &h_err)

658#else

660#define GETHOSTBYNAME(name)(gethostbyname_r(name, &tmphe, tmpbuf, bufsize, &h, &
h_err), h) gethostbyname(name)
661#define GETHOSTBYNAME2(name, af)(gethostbyname2_r(name, af, &tmphe, tmpbuf, bufsize, &
h, &h_err), h) gethostbyname2(name, af)
662#define GETHOSTBYADDR(addr, addrlen, af)(gethostbyaddr_r(addr, addrlen, af, &tmphe, tmpbuf, bufsize
, &h, &h_err), h) gethostbyaddr(addr, addrlen, af)

664#endif  /* definition of GETHOSTBYXXX */

666PR_IMPLEMENT(PRStatus)__attribute__((visibility("default"))) PRStatus PR_GetHostByName(
  const char *name, char *buf, PRIntn bufsize, PRHostEnt *hp)
668{
  struct hostent *h;
  PRStatus rv = PR_FAILURE;
671#if defined(_PR_HAVE_GETHOST_R)
  char localbuf[PR_NETDB_BUF_SIZE2048];
  char *tmpbuf;
  struct hostent tmphe;
  int h_err;
676#endif

  if (!_pr_initialized) {
      _PR_ImplicitInitialization();
  }

682#if defined(_PR_HAVE_GETHOST_R)
  tmpbuf = localbuf;
  if (bufsize > sizeof(localbuf))
  {
      tmpbuf = (char *)PR_Malloc(bufsize);
      if (NULL((void*)0) == tmpbuf)
      {
          PR_SetError(PR_OUT_OF_MEMORY_ERROR(-6000L), 0);
          return rv;
      }
  }
693#endif

  LOCK_DNS();

  h = GETHOSTBYNAME(name)(gethostbyname_r(name, &tmphe, tmpbuf, bufsize, &h, &
h_err), h);

  if (NULL((void*)0) == h)
  {
      PR_SetError(PR_DIRECTORY_LOOKUP_ERROR(-5973L), _MD_GETHOST_ERRNO()(*__h_errno_location ()));
  }
  else
  {
      _PRIPAddrConversion conversion = _PRIPAddrNoConversion;
      rv = CopyHostent(h, &buf, &bufsize, conversion, hp);
      if (PR_SUCCESS != rv) {
          PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR(-5974L), 0);
      }
  }
  UNLOCK_DNS();
712#if defined(_PR_HAVE_GETHOST_R)
  if (tmpbuf != localbuf) {
      PR_Free(tmpbuf);
  }
716#endif
  return rv;
718}

720#if !defined(_PR_INET6) && \
      defined(_PR_INET6_PROBE) && defined(_PR_HAVE_GETIPNODEBYNAME)
722typedef struct hostent  * (*_pr_getipnodebyname_t)(const char *, int,
      int, int *);
724typedef struct hostent  * (*_pr_getipnodebyaddr_t)(const void *, size_t,
      int, int *);
726typedef void (*_pr_freehostent_t)(struct hostent *);
727static void * _pr_getipnodebyname_fp;
728static void * _pr_getipnodebyaddr_fp;
729static void * _pr_freehostent_fp;

731/*
* Look up the addresses of getipnodebyname, getipnodebyaddr,
* and freehostent.
*/
735PRStatus
736_pr_find_getipnodebyname(void)
737{
  PRLibrary *lib;
  PRStatus rv;
740#define GETIPNODEBYNAME "getipnodebyname"
741#define GETIPNODEBYADDR "getipnodebyaddr"
742#define FREEHOSTENT     "freehostent"

  _pr_getipnodebyname_fp = PR_FindSymbolAndLibrary(GETIPNODEBYNAME, &lib);
  if (NULL((void*)0) != _pr_getipnodebyname_fp) {
      _pr_freehostent_fp = PR_FindSymbol(lib, FREEHOSTENT);
      if (NULL((void*)0) != _pr_freehostent_fp) {
          _pr_getipnodebyaddr_fp = PR_FindSymbol(lib, GETIPNODEBYADDR);
          if (NULL((void*)0) != _pr_getipnodebyaddr_fp) {
              rv = PR_SUCCESS;
          }
          else {
              rv = PR_FAILURE;
          }
      } else {
          rv = PR_FAILURE;
      }
      (void)PR_UnloadLibrary(lib);
  } else {
      rv = PR_FAILURE;
  }
  return rv;
763}
764#endif

766#if defined(_PR_INET6) && defined(_PR_HAVE_GETHOSTBYNAME2)
767/*
768** Append the V4 addresses to the end of the list
769*/
770static PRStatus AppendV4AddrsToHostent(
  struct hostent *from,
  char **buf,
  PRIntn *bufsize,
  PRHostEnt *to)
775{
  PRIntn na, na_old;
  char **ap;
  char **new_addr_list;

  /* Count the addresses, then grow storage for the pointers */
  for (na_old = 0, ap = to->h_addr_list; *ap != 0; na_old++, ap++)
  {;} /* nothing to execute */
  for (na = na_old + 1, ap = from->h_addr_list; *ap != 0; na++, ap++)
  {;} /* nothing to execute */
  new_addr_list = (char**)Alloc(
                      na * sizeof(char*), buf, bufsize, sizeof(char**));
  if (!new_addr_list) {
      return PR_FAILURE;
  }

  /* Copy the V6 addresses, one at a time */
  for (na = 0, ap = to->h_addr_list; *ap != 0; na++, ap++) {
      new_addr_list[na] = to->h_addr_list[na];
  }
  to->h_addr_list = new_addr_list;

  /* Copy the V4 addresses, one at a time */
  for (ap = from->h_addr_list; *ap != 0; na++, ap++) {
      to->h_addr_list[na] = Alloc(to->h_length, buf, bufsize, 0);
      if (!to->h_addr_list[na]) {
          return PR_FAILURE;
      }
      MakeIPv4MappedAddr(*ap, to->h_addr_list[na]);
  }
  to->h_addr_list[na] = 0;
  return PR_SUCCESS;
807}
808#endif

810PR_IMPLEMENT(PRStatus)__attribute__((visibility("default"))) PRStatus PR_GetIPNodeByName(
  const char *name, PRUint16 af, PRIntn flags,
  char *buf, PRIntn bufsize, PRHostEnt *hp)
813{
  struct hostent *h = 0;
  PRStatus rv = PR_FAILURE;
816#if defined(_PR_HAVE_GETHOST_R)
  char localbuf[PR_NETDB_BUF_SIZE2048];
  char *tmpbuf;
  struct hostent tmphe;
  int h_err;
821#endif
822#if defined(_PR_HAVE_GETIPNODEBYNAME)
  PRUint16 md_af = af;
  int error_num;
  int tmp_flags = 0;
826#endif
827#if defined(_PR_HAVE_GETHOSTBYNAME2)
  PRBool did_af_inet = PR_FALSE0;
829#endif

  if (!_pr_initialized) {
      _PR_ImplicitInitialization();
  }

  if (af != PR_AF_INET2 && af != PR_AF_INET610) {
      PR_SetError(PR_INVALID_ARGUMENT_ERROR(-5987L), 0);
      return PR_FAILURE;
  }

840#if defined(_PR_INET6) && defined(_PR_HAVE_GETHOSTBYNAME2)
  PR_Lock(_pr_query_ifs_lock);
  /*
   * Keep querying the presence of IPv4 and IPv6 interfaces until
   * at least one is up.  This allows us to detect the local
   * machine going from offline to online.
   */
  if (!_pr_have_inet_if && !_pr_have_inet6_if) {
      _pr_QueryNetIfs();
849#ifdef DEBUG_QUERY_IFS
      if (_pr_have_inet_if) {
          printf("Have IPv4 source address\n");
      }
      if (_pr_have_inet6_if) {
          printf("Have IPv6 source address\n");
      }
856#endif
  }
  PR_Unlock(_pr_query_ifs_lock);
859#endif

861#if defined(_PR_HAVE_GETIPNODEBYNAME)
  if (flags & PR_AI_V4MAPPED0x10) {
      tmp_flags |= AI_V4MAPPED0x0008;
  }
  if (flags & PR_AI_ADDRCONFIG0x20) {
      tmp_flags |= AI_ADDRCONFIG0x0020;
  }
  if (flags & PR_AI_ALL0x08) {
      tmp_flags |= AI_ALL0x0010;
  }
  if (af == PR_AF_INET610) {
      md_af = AF_INET610;
  }
  else {
      md_af = af;
  }
877#endif

879#if defined(_PR_HAVE_GETHOST_R)
  tmpbuf = localbuf;
  if (bufsize > sizeof(localbuf))
  {
      tmpbuf = (char *)PR_Malloc(bufsize);
      if (NULL((void*)0) == tmpbuf)
      {
          PR_SetError(PR_OUT_OF_MEMORY_ERROR(-6000L), 0);
          return rv;
      }
  }
890#endif

  /* Do not need to lock the DNS lock if getipnodebyname() is called */
893#ifdef _PR_INET6
894#ifdef _PR_HAVE_GETHOSTBYNAME2
  LOCK_DNS();
  if (af == PR_AF_INET610)
  {
      if ((flags & PR_AI_ADDRCONFIG0x20) == 0 || _pr_have_inet6_if)
      {
900#ifdef _PR_INET6_PROBE
          if (_pr_ipv6_is_present())
902#endif
              h = GETHOSTBYNAME2(name, AF_INET6)(gethostbyname2_r(name, 10, &tmphe, tmpbuf, bufsize, &
h, &h_err), h);
      }
      if ((NULL((void*)0) == h) && (flags & PR_AI_V4MAPPED0x10)
          && ((flags & PR_AI_ADDRCONFIG0x20) == 0 || _pr_have_inet_if))
      {
          did_af_inet = PR_TRUE1;
          h = GETHOSTBYNAME2(name, AF_INET)(gethostbyname2_r(name, 2, &tmphe, tmpbuf, bufsize, &
h, &h_err), h);
      }
  }
  else
  {
      if ((flags & PR_AI_ADDRCONFIG0x20) == 0 || _pr_have_inet_if)
      {
          did_af_inet = PR_TRUE1;
          h = GETHOSTBYNAME2(name, af)(gethostbyname2_r(name, af, &tmphe, tmpbuf, bufsize, &
h, &h_err), h);
      }
  }
920#elif defined(_PR_HAVE_GETIPNODEBYNAME)
  h = getipnodebyname(name, md_af, tmp_flags, &error_num);
922#else
923#error "Unknown name-to-address translation function"
924#endif  /* _PR_HAVE_GETHOSTBYNAME2 */
925#elif defined(_PR_INET6_PROBE) && defined(_PR_HAVE_GETIPNODEBYNAME)
  if (_pr_ipv6_is_present())
  {
928#ifdef PR_GETIPNODE_NOT_THREADSAFE
      LOCK_DNS();
930#endif
      h = (*((_pr_getipnodebyname_t)_pr_getipnodebyname_fp))(name, md_af, tmp_flags, &error_num);
  }
  else
  {
      LOCK_DNS();
      h = GETHOSTBYNAME(name)(gethostbyname_r(name, &tmphe, tmpbuf, bufsize, &h, &
h_err), h);
  }
938#else /* _PR_INET6 */
  LOCK_DNS();
  h = GETHOSTBYNAME(name)(gethostbyname_r(name, &tmphe, tmpbuf, bufsize, &h, &
h_err), h);
941#endif /* _PR_INET6 */

  if (NULL((void*)0) == h)
  {
945#if defined(_PR_INET6) && defined(_PR_HAVE_GETIPNODEBYNAME)
      PR_SetError(PR_DIRECTORY_LOOKUP_ERROR(-5973L), error_num);
947#elif defined(_PR_INET6_PROBE) && defined(_PR_HAVE_GETIPNODEBYNAME)
      if (_pr_ipv6_is_present()) {
          PR_SetError(PR_DIRECTORY_LOOKUP_ERROR(-5973L), error_num);
      }
      else {
          PR_SetError(PR_DIRECTORY_LOOKUP_ERROR(-5973L), _MD_GETHOST_ERRNO()(*__h_errno_location ()));
      }
954#else
      PR_SetError(PR_DIRECTORY_LOOKUP_ERROR(-5973L), _MD_GETHOST_ERRNO()(*__h_errno_location ()));
956#endif
  }
  else
  {
      _PRIPAddrConversion conversion = _PRIPAddrNoConversion;

      if (af == PR_AF_INET610) {
          conversion = _PRIPAddrIPv4Mapped;
      }
      rv = CopyHostent(h, &buf, &bufsize, conversion, hp);
      if (PR_SUCCESS != rv) {
          PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR(-5974L), 0);
      }
969#if defined(_PR_INET6) && defined(_PR_HAVE_GETIPNODEBYNAME)
      freehostent(h);
971#elif defined(_PR_INET6_PROBE) && defined(_PR_HAVE_GETIPNODEBYNAME)
      if (_pr_ipv6_is_present()) {
          (*((_pr_freehostent_t)_pr_freehostent_fp))(h);
      }
975#endif
976#if defined(_PR_INET6) && defined(_PR_HAVE_GETHOSTBYNAME2)
      if ((PR_SUCCESS == rv) && (flags & PR_AI_V4MAPPED0x10)
          && ((flags & PR_AI_ALL0x08)
              || ((flags & PR_AI_ADDRCONFIG0x20) && _pr_have_inet_if))
          && !did_af_inet && (h = GETHOSTBYNAME2(name, AF_INET)(gethostbyname2_r(name, 2, &tmphe, tmpbuf, bufsize, &
h, &h_err), h)) != 0) {
          rv = AppendV4AddrsToHostent(h, &buf, &bufsize, hp);
          if (PR_SUCCESS != rv) {
              PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR(-5974L), 0);
          }
      }
986#endif
  }

  /* Must match the convoluted logic above for LOCK_DNS() */
990#ifdef _PR_INET6
991#ifdef _PR_HAVE_GETHOSTBYNAME2
  UNLOCK_DNS();
993#endif  /* _PR_HAVE_GETHOSTBYNAME2 */
994#elif defined(_PR_INET6_PROBE) && defined(_PR_HAVE_GETIPNODEBYNAME)
995#ifdef PR_GETIPNODE_NOT_THREADSAFE
  UNLOCK_DNS();
997#else
  if (!_pr_ipv6_is_present()) {
      UNLOCK_DNS();
  }
1001#endif
1002#else /* _PR_INET6 */
  UNLOCK_DNS();
1004#endif /* _PR_INET6 */

1006#if defined(_PR_HAVE_GETHOST_R)
  if (tmpbuf != localbuf) {
      PR_Free(tmpbuf);
  }
1010#endif

  return rv;
1013}

1015PR_IMPLEMENT(PRStatus)__attribute__((visibility("default"))) PRStatus PR_GetHostByAddr(
  const PRNetAddr *hostaddr, char *buf, PRIntn bufsize, PRHostEnt *hostentry)
1017{
  struct hostent *h;
  PRStatus rv = PR_FAILURE;
  const void *addr;
  PRUint32 tmp_ip;
  int addrlen;
  PRInt32 af;
1024#if defined(_PR_HAVE_GETHOST_R)
  char localbuf[PR_NETDB_BUF_SIZE2048];
  char *tmpbuf;
  struct hostent tmphe;
  int h_err;
1029#endif
1030#if defined(_PR_HAVE_GETIPNODEBYADDR)
  int error_num;
1032#endif

  if (!_pr_initialized) {
      _PR_ImplicitInitialization();
  }

  if (hostaddr->raw.family == PR_AF_INET610)
  {
1040#if defined(_PR_INET6_PROBE)
      af = _pr_ipv6_is_present() ? AF_INET610 : AF_INET2;
1042#elif defined(_PR_INET6)
      af = AF_INET610;
1044#else
      af = AF_INET2;
1046#endif
1047#if defined(_PR_GHBA_DISALLOW_V4MAPPED)
      if (_PR_IN6_IS_ADDR_V4MAPPED(&hostaddr->ipv6.ip)(((&hostaddr->ipv6.ip)->_S6_un._S6_u32[0] == 0) &&
 ((&hostaddr->ipv6.ip)->_S6_un._S6_u32[1] == 0) &&
 ((&hostaddr->ipv6.ip)->_S6_un._S6_u8[8] == 0) &&
 ((&hostaddr->ipv6.ip)->_S6_un._S6_u8[9] == 0) &&
 ((&hostaddr->ipv6.ip)->_S6_un._S6_u8[10] == 0xff) &&
 ((&hostaddr->ipv6.ip)->_S6_un._S6_u8[11] == 0xff))) {
          af = AF_INET2;
      }
1051#endif
  }
  else
  {
      PR_ASSERT(hostaddr->raw.family == AF_INET)((hostaddr->raw.family == 2)?((void)0):PR_Assert("hostaddr->raw.family == AF_INET"
,"../../../../pr/src/misc/prnetdb.c",1055));
      af = AF_INET2;
  }
  if (hostaddr->raw.family == PR_AF_INET610) {
1059#if defined(_PR_INET6) || defined(_PR_INET6_PROBE)
      if (af == AF_INET610) {
          addr = &hostaddr->ipv6.ip;
          addrlen = sizeof(hostaddr->ipv6.ip);
      }
      else
1065#endif
      {
          PR_ASSERT(af == AF_INET)((af == 2)?((void)0):PR_Assert("af == AF_INET","../../../../pr/src/misc/prnetdb.c"
,1067));
          if (!_PR_IN6_IS_ADDR_V4MAPPED(&hostaddr->ipv6.ip)(((&hostaddr->ipv6.ip)->_S6_un._S6_u32[0] == 0) &&
 ((&hostaddr->ipv6.ip)->_S6_un._S6_u32[1] == 0) &&
 ((&hostaddr->ipv6.ip)->_S6_un._S6_u8[8] == 0) &&
 ((&hostaddr->ipv6.ip)->_S6_un._S6_u8[9] == 0) &&
 ((&hostaddr->ipv6.ip)->_S6_un._S6_u8[10] == 0xff) &&
 ((&hostaddr->ipv6.ip)->_S6_un._S6_u8[11] == 0xff))) {
              PR_SetError(PR_INVALID_ARGUMENT_ERROR(-5987L), 0);
              return rv;
          }
          tmp_ip = _PR_IN6_V4MAPPED_TO_IPADDR((PRIPv6Addr *)(((PRIPv6Addr *) &hostaddr->ipv6.ip)->_S6_un._S6_u32
[3])
                                              &hostaddr->ipv6.ip)(((PRIPv6Addr *) &hostaddr->ipv6.ip)->_S6_un._S6_u32
[3]);
          addr = &tmp_ip;
          addrlen = sizeof(tmp_ip);
      }
  } else {
      PR_ASSERT(hostaddr->raw.family == AF_INET)((hostaddr->raw.family == 2)?((void)0):PR_Assert("hostaddr->raw.family == AF_INET"
,"../../../../pr/src/misc/prnetdb.c",1078));
      PR_ASSERT(af == AF_INET)((af == 2)?((void)0):PR_Assert("af == AF_INET","../../../../pr/src/misc/prnetdb.c"
,1079));
      addr = &hostaddr->inet.ip;
      addrlen = sizeof(hostaddr->inet.ip);
  }

1084#if defined(_PR_HAVE_GETHOST_R)
  tmpbuf = localbuf;
  if (bufsize > sizeof(localbuf))
  {
      tmpbuf = (char *)PR_Malloc(bufsize);
      if (NULL((void*)0) == tmpbuf)
      {
          PR_SetError(PR_OUT_OF_MEMORY_ERROR(-6000L), 0);
          return rv;
      }
  }
1095#endif

  /* Do not need to lock the DNS lock if getipnodebyaddr() is called */
1098#if defined(_PR_HAVE_GETIPNODEBYADDR) && defined(_PR_INET6)
  h = getipnodebyaddr(addr, addrlen, af, &error_num);
1100#elif defined(_PR_HAVE_GETIPNODEBYADDR) && defined(_PR_INET6_PROBE)
  if (_pr_ipv6_is_present())
  {
1103#ifdef PR_GETIPNODE_NOT_THREADSAFE
      LOCK_DNS();
1105#endif
      h = (*((_pr_getipnodebyaddr_t)_pr_getipnodebyaddr_fp))(addr, addrlen,
              af, &error_num);
  }
  else
  {
      LOCK_DNS();
      h = GETHOSTBYADDR(addr, addrlen, af)(gethostbyaddr_r(addr, addrlen, af, &tmphe, tmpbuf, bufsize
, &h, &h_err), h);
  }
1114#else   /* _PR_HAVE_GETIPNODEBYADDR */
  LOCK_DNS();
  h = GETHOSTBYADDR(addr, addrlen, af)(gethostbyaddr_r(addr, addrlen, af, &tmphe, tmpbuf, bufsize
, &h, &h_err), h);
1117#endif /* _PR_HAVE_GETIPNODEBYADDR */
  if (NULL((void*)0) == h)
  {
1120#if defined(_PR_INET6) && defined(_PR_HAVE_GETIPNODEBYADDR)
      PR_SetError(PR_DIRECTORY_LOOKUP_ERROR(-5973L), error_num);
1122#elif defined(_PR_INET6_PROBE) && defined(_PR_HAVE_GETIPNODEBYADDR)
      if (_pr_ipv6_is_present()) {
          PR_SetError(PR_DIRECTORY_LOOKUP_ERROR(-5973L), error_num);
      }
      else {
          PR_SetError(PR_DIRECTORY_LOOKUP_ERROR(-5973L), _MD_GETHOST_ERRNO()(*__h_errno_location ()));
      }
1129#else
      PR_SetError(PR_DIRECTORY_LOOKUP_ERROR(-5973L), _MD_GETHOST_ERRNO()(*__h_errno_location ()));
1131#endif
  }
  else
  {
      _PRIPAddrConversion conversion = _PRIPAddrNoConversion;
      if (hostaddr->raw.family == PR_AF_INET610) {
          if (af == AF_INET2) {
              if (_PR_IN6_IS_ADDR_V4MAPPED((PRIPv6Addr*)((((PRIPv6Addr*) &hostaddr->ipv6.ip)->_S6_un._S6_u32
[0] == 0) && (((PRIPv6Addr*) &hostaddr->ipv6.ip
)->_S6_un._S6_u32[1] == 0) && (((PRIPv6Addr*) &
hostaddr->ipv6.ip)->_S6_un._S6_u8[8] == 0) && (
((PRIPv6Addr*) &hostaddr->ipv6.ip)->_S6_un._S6_u8[9
] == 0) && (((PRIPv6Addr*) &hostaddr->ipv6.ip)
->_S6_un._S6_u8[10] == 0xff) && (((PRIPv6Addr*) &
hostaddr->ipv6.ip)->_S6_un._S6_u8[11] == 0xff))
                                           &hostaddr->ipv6.ip)((((PRIPv6Addr*) &hostaddr->ipv6.ip)->_S6_un._S6_u32
[0] == 0) && (((PRIPv6Addr*) &hostaddr->ipv6.ip
)->_S6_un._S6_u32[1] == 0) && (((PRIPv6Addr*) &
hostaddr->ipv6.ip)->_S6_un._S6_u8[8] == 0) && (
((PRIPv6Addr*) &hostaddr->ipv6.ip)->_S6_un._S6_u8[9
] == 0) && (((PRIPv6Addr*) &hostaddr->ipv6.ip)
->_S6_un._S6_u8[10] == 0xff) && (((PRIPv6Addr*) &
hostaddr->ipv6.ip)->_S6_un._S6_u8[11] == 0xff))) {
                  conversion = _PRIPAddrIPv4Mapped;
              } else if (_PR_IN6_IS_ADDR_V4COMPAT((PRIPv6Addr *)((((PRIPv6Addr *) &hostaddr->ipv6.ip)->_S6_un._S6_u32
[0] == 0) && (((PRIPv6Addr *) &hostaddr->ipv6.
ip)->_S6_un._S6_u32[1] == 0) && (((PRIPv6Addr *) &
hostaddr->ipv6.ip)->_S6_un._S6_u32[2] == 0))
                                                  &hostaddr->ipv6.ip)((((PRIPv6Addr *) &hostaddr->ipv6.ip)->_S6_un._S6_u32
[0] == 0) && (((PRIPv6Addr *) &hostaddr->ipv6.
ip)->_S6_un._S6_u32[1] == 0) && (((PRIPv6Addr *) &
hostaddr->ipv6.ip)->_S6_un._S6_u32[2] == 0))) {
                  conversion = _PRIPAddrIPv4Compat;
              }
          }
      }
      rv = CopyHostent(h, &buf, &bufsize, conversion, hostentry);
      if (PR_SUCCESS != rv) {
          PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR(-5974L), 0);
      }
1151#if defined(_PR_INET6) && defined(_PR_HAVE_GETIPNODEBYADDR)
      freehostent(h);
1153#elif defined(_PR_INET6_PROBE) && defined(_PR_HAVE_GETIPNODEBYADDR)
      if (_pr_ipv6_is_present()) {
          (*((_pr_freehostent_t)_pr_freehostent_fp))(h);
      }
1157#endif
  }

  /* Must match the convoluted logic above for LOCK_DNS() */
1161#if defined(_PR_HAVE_GETIPNODEBYADDR) && defined(_PR_INET6)
1162#elif defined(_PR_HAVE_GETIPNODEBYADDR) && defined(_PR_INET6_PROBE)
1163#ifdef PR_GETIPNODE_NOT_THREADSAFE
  UNLOCK_DNS();
1165#else
  if (!_pr_ipv6_is_present()) {
      UNLOCK_DNS();
  }
1169#endif
1170#else   /* _PR_HAVE_GETIPNODEBYADDR */
  UNLOCK_DNS();
1172#endif /* _PR_HAVE_GETIPNODEBYADDR */

1174#if defined(_PR_HAVE_GETHOST_R)
  if (tmpbuf != localbuf) {
      PR_Free(tmpbuf);
  }
1178#endif

  return rv;
1181}

1183/******************************************************************************/
1184/*
* Some systems define a reentrant version of getprotobyname(). Too bad
* the signature isn't always the same. But hey, they tried. If there
* is such a definition, use it. Otherwise, grab a lock and do it here.
*/
1189/******************************************************************************/

1191#if !defined(_PR_HAVE_GETPROTO_R)
1192/*
* This may seem like a silly thing to do, but the compiler SHOULD
* complain if getprotobyname_r() is implemented on some system and
* we're not using it. For sure these signatures are different than
* any usable implementation.
*/

1199#if defined(ANDROID)
1200/* Android's Bionic libc system includes prototypes for these in netdb.h,
* but doesn't actually include implementations.  It uses the 5-arg form,
* so these functions end up not matching the prototype.  So just rename
* them if not found.
*/
1205#define getprotobyname_r _pr_getprotobyname_r
1206#define getprotobynumber_r _pr_getprotobynumber_r
1207#endif

1209static struct protoent *getprotobyname_r(const char* name)
1210{
  return getprotobyname(name);
1212} /* getprotobyname_r */

1214static struct protoent *getprotobynumber_r(PRInt32 number)
1215{
  return getprotobynumber(number);
1217} /* getprotobynumber_r */

1219#endif /* !defined(_PR_HAVE_GETPROTO_R) */

1221PR_IMPLEMENT(PRStatus)__attribute__((visibility("default"))) PRStatus PR_GetProtoByName(
  const char* name, char* buffer, PRInt32 buflen, PRProtoEnt* result)
1223{
  PRStatus rv = PR_SUCCESS;
1225#if defined(_PR_HAVE_GETPROTO_R)
  struct protoent* res = (struct protoent*)result;
1227#endif

  if (!_pr_initialized) {
      _PR_ImplicitInitialization();
  }

1233#if defined(_PR_HAVE_GETPROTO_R_INT)
  {
      /*
      ** The protoent_data has a pointer as the first field.
      ** That implies the buffer better be aligned, and char*
      ** doesn't promise much.
      */
      PRUptrdiff aligned = (PRUptrdiff)buffer;
      if (0 != (aligned & (sizeof(struct protoent_data*) - 1)))
      {
          aligned += sizeof(struct protoent_data*) - 1;
          aligned &= ~(sizeof(struct protoent_data*) - 1);
          buflen -= (aligned - (PRUptrdiff)buffer);
          buffer = (char*)aligned;
      }
  }
1249#endif  /* defined(_PR_HAVE_GETPROTO_R_INT) */

  if (PR_MIN_NETDB_BUF_SIZE1024 > buflen)
  {
      PR_SetError(PR_INVALID_ARGUMENT_ERROR(-5987L), 0);
      return PR_FAILURE;
  }

1257#if defined(_PR_HAVE_GETPROTO_R_POINTER)
  if (NULL((void*)0) == getprotobyname_r(name, res, buffer, buflen))
  {
      PR_SetError(PR_DIRECTORY_LOOKUP_ERROR(-5973L), _MD_ERRNO()((*__errno_location ())));
      return PR_FAILURE;
  }
1263#elif defined(_PR_HAVE_GETPROTO_R_INT)
  /*
  ** The buffer needs to be zero'd, and it should be
  ** at least the size of a struct protoent_data.
  */
  memset(buffer, 0, buflen);
  if (-1 == getprotobyname_r(name, res, (struct protoent_data*)buffer))
  {
      PR_SetError(PR_DIRECTORY_LOOKUP_ERROR(-5973L), _MD_ERRNO()((*__errno_location ())));
      return PR_FAILURE;
  }
1274#elif defined(_PR_HAVE_5_ARG_GETPROTO_R)
  /* The 5th argument for getprotobyname_r() cannot be NULL */
  if (-1 == getprotobyname_r(name, res, buffer, buflen, &res))
  {
      PR_SetError(PR_DIRECTORY_LOOKUP_ERROR(-5973L), _MD_ERRNO()((*__errno_location ())));
      return PR_FAILURE;
  }
1281#else  /* do it the hard way */
  {
      struct protoent *staticBuf;
      PR_Lock(_getproto_lock);
      staticBuf = getprotobyname_r(name);
      if (NULL((void*)0) == staticBuf)
      {
          rv = PR_FAILURE;
          PR_SetError(PR_DIRECTORY_LOOKUP_ERROR(-5973L), _MD_ERRNO()((*__errno_location ())));
      }
      else
      {
          rv = CopyProtoent(staticBuf, buffer, buflen, result);
          if (PR_FAILURE == rv) {
              PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR(-5974L), 0);
          }
      }
      PR_Unlock(_getproto_lock);
  }
1300#endif  /* all that */
  return rv;
1302}

1304PR_IMPLEMENT(PRStatus)__attribute__((visibility("default"))) PRStatus PR_GetProtoByNumber(
  PRInt32 number, char* buffer, PRInt32 buflen, PRProtoEnt* result)
1306{
  PRStatus rv = PR_SUCCESS;
1308#if defined(_PR_HAVE_GETPROTO_R)
  struct protoent* res = (struct protoent*)result;
1310#endif

  if (!_pr_initialized) {
      _PR_ImplicitInitialization();
  }

1316#if defined(_PR_HAVE_GETPROTO_R_INT)
  {
      /*
      ** The protoent_data has a pointer as the first field.
      ** That implies the buffer better be aligned, and char*
      ** doesn't promise much.
      */
      PRUptrdiff aligned = (PRUptrdiff)buffer;
      if (0 != (aligned & (sizeof(struct protoent_data*) - 1)))
      {
          aligned += sizeof(struct protoent_data*) - 1;
          aligned &= ~(sizeof(struct protoent_data*) - 1);
          buflen -= (aligned - (PRUptrdiff)buffer);
          buffer = (char*)aligned;
      }
  }
1332#endif /* defined(_PR_HAVE_GETPROTO_R_INT) */

  if (PR_MIN_NETDB_BUF_SIZE1024 > buflen)
  {
      PR_SetError(PR_INVALID_ARGUMENT_ERROR(-5987L), 0);
      return PR_FAILURE;
  }

1340#if defined(_PR_HAVE_GETPROTO_R_POINTER)
  if (NULL((void*)0) == getprotobynumber_r(number, res, buffer, buflen))
  {
      PR_SetError(PR_DIRECTORY_LOOKUP_ERROR(-5973L), _MD_ERRNO()((*__errno_location ())));
      return PR_FAILURE;
  }

1347#elif defined(_PR_HAVE_GETPROTO_R_INT)
  /*
  ** The buffer needs to be zero'd for these OS's.
  */
  memset(buffer, 0, buflen);
  if (-1 == getprotobynumber_r(number, res, (struct protoent_data*)buffer))
  {
      PR_SetError(PR_DIRECTORY_LOOKUP_ERROR(-5973L), _MD_ERRNO()((*__errno_location ())));
      return PR_FAILURE;
  }
1357#elif defined(_PR_HAVE_5_ARG_GETPROTO_R)
  /* The 5th argument for getprotobynumber_r() cannot be NULL */
  if (-1 == getprotobynumber_r(number, res, buffer, buflen, &res))
  {
      PR_SetError(PR_DIRECTORY_LOOKUP_ERROR(-5973L), _MD_ERRNO()((*__errno_location ())));
      return PR_FAILURE;
  }
1364#else  /* do it the hard way */
  {
      struct protoent *staticBuf;
      PR_Lock(_getproto_lock);
      staticBuf = getprotobynumber_r(number);
      if (NULL((void*)0) == staticBuf)
      {
          rv = PR_FAILURE;
          PR_SetError(PR_DIRECTORY_LOOKUP_ERROR(-5973L), _MD_ERRNO()((*__errno_location ())));
      }
      else
      {
          rv = CopyProtoent(staticBuf, buffer, buflen, result);
          if (PR_FAILURE == rv) {
              PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR(-5974L), 0);
          }
      }
      PR_Unlock(_getproto_lock);
  }
1383#endif  /* all that crap */
  return rv;

1386}

1388PRUintn _PR_NetAddrSize(const PRNetAddr* addr)
1389{
  PRUintn addrsize;

  /*
   * RFC 2553 added a new field (sin6_scope_id) to
   * struct sockaddr_in6.  PRNetAddr's ipv6 member has a
   * scope_id field to match the new field.  In order to
   * work with older implementations supporting RFC 2133,
   * we take the size of struct sockaddr_in6 instead of
   * addr->ipv6.
   */
  if (AF_INET2 == addr->raw.family) {
      addrsize = sizeof(addr->inet);
  }
  else if (PR_AF_INET610 == addr->raw.family)
1404#if defined(_PR_INET6)
      addrsize = sizeof(struct sockaddr_in6);
1406#else
      addrsize = sizeof(addr->ipv6);
1408#endif
1409#if defined(XP_UNIX1) || defined(XP_OS2)
  else if (AF_UNIX1 == addr->raw.family)
  {
1412#if defined(LINUX1)
      if (addr->local.path[0] == 0)
          /* abstract socket address is supported on Linux only */
          addrsize = strnlen(addr->local.path + 1,
                             sizeof(addr->local.path)) +
                     offsetof(struct sockaddr_un, sun_path)__builtin_offsetof(struct sockaddr_un, sun_path) + 1;
      else
1419#endif
          addrsize = sizeof(addr->local);
  }
1422#endif
  else {
      addrsize = 0;
  }

  return addrsize;
1428}  /* _PR_NetAddrSize */

1430PR_IMPLEMENT(PRIntn)__attribute__((visibility("default"))) PRIntn PR_EnumerateHostEnt(
  PRIntn enumIndex, const PRHostEnt *hostEnt, PRUint16 port, PRNetAddr *address)
1432{
  void *addr = hostEnt->h_addr_list[enumIndex++];
  memset(address, 0, sizeof(PRNetAddr));
  if (NULL((void*)0) == addr) {
      enumIndex = 0;
  }
  else
  {
      address->raw.family = hostEnt->h_addrtype;
      if (PR_AF_INET610 == hostEnt->h_addrtype)
      {
          address->ipv6.port = htons(port);
          address->ipv6.flowinfo = 0;
          address->ipv6.scope_id = 0;
          memcpy(&address->ipv6.ip, addr, hostEnt->h_length);
      }
      else
      {
          PR_ASSERT(AF_INET == hostEnt->h_addrtype)((2 == hostEnt->h_addrtype)?((void)0):PR_Assert("AF_INET == hostEnt->h_addrtype"
,"../../../../pr/src/misc/prnetdb.c",1450));
          address->inet.port = htons(port);
          memcpy(&address->inet.ip, addr, hostEnt->h_length);
      }
  }
  return enumIndex;
1456}  /* PR_EnumerateHostEnt */

1458PR_IMPLEMENT(PRStatus)__attribute__((visibility("default"))) PRStatus PR_InitializeNetAddr(
  PRNetAddrValue val, PRUint16 port, PRNetAddr *addr)
1460{
  PRStatus rv = PR_SUCCESS;
  if (!_pr_initialized) {
      _PR_ImplicitInitialization();
  }

  if (val != PR_IpAddrNull) {
      memset(addr, 0, sizeof(*addr));
  }
  addr->inet.family = AF_INET2;
  addr->inet.port = htons(port);
  switch (val)
  {
      case PR_IpAddrNull:
          break;  /* don't overwrite the address */
      case PR_IpAddrAny:
          addr->inet.ip = htonl(INADDR_ANY((in_addr_t) 0x00000000));
          break;
      case PR_IpAddrLoopback:
          addr->inet.ip = htonl(INADDR_LOOPBACK((in_addr_t) 0x7f000001));
          break;
      default:
          PR_SetError(PR_INVALID_ARGUMENT_ERROR(-5987L), 0);
          rv = PR_FAILURE;
  }
  return rv;
1486}  /* PR_InitializeNetAddr */

1488PR_IMPLEMENT(PRStatus)__attribute__((visibility("default"))) PRStatus PR_SetNetAddr(
  PRNetAddrValue val, PRUint16 af, PRUint16 port, PRNetAddr *addr)
1490{
  PRStatus rv = PR_SUCCESS;
  if (!_pr_initialized) {
      _PR_ImplicitInitialization();
  }

  if (af == PR_AF_INET610)
  {
      if (val != PR_IpAddrNull) {
          memset(addr, 0, sizeof(addr->ipv6));
      }
      addr->ipv6.family = af;
      addr->ipv6.port = htons(port);
      addr->ipv6.flowinfo = 0;
      addr->ipv6.scope_id = 0;
      switch (val)
      {
          case PR_IpAddrNull:
              break;  /* don't overwrite the address */
          case PR_IpAddrAny:
              addr->ipv6.ip = _pr_in6addr_any;
              break;
          case PR_IpAddrLoopback:
              addr->ipv6.ip = _pr_in6addr_loopback;
              break;
          default:
              PR_SetError(PR_INVALID_ARGUMENT_ERROR(-5987L), 0);
              rv = PR_FAILURE;
      }
  }
  else
  {
      if (val != PR_IpAddrNull) {
          memset(addr, 0, sizeof(addr->inet));
      }
      addr->inet.family = af;
      addr->inet.port = htons(port);
      switch (val)
      {
          case PR_IpAddrNull:
              break;  /* don't overwrite the address */
          case PR_IpAddrAny:
              addr->inet.ip = htonl(INADDR_ANY((in_addr_t) 0x00000000));
              break;
          case PR_IpAddrLoopback:
              addr->inet.ip = htonl(INADDR_LOOPBACK((in_addr_t) 0x7f000001));
              break;
          default:
              PR_SetError(PR_INVALID_ARGUMENT_ERROR(-5987L), 0);
              rv = PR_FAILURE;
      }
  }
  return rv;
1543}  /* PR_SetNetAddr */

1545PR_IMPLEMENT(PRBool)__attribute__((visibility("default"))) PRBool
1546PR_IsNetAddrType(const PRNetAddr *addr, PRNetAddrValue val)
1547{
  if (addr->raw.family == PR_AF_INET610) {
      if (val == PR_IpAddrAny) {
          if (_PR_IN6_IS_ADDR_UNSPECIFIED((PRIPv6Addr *)&addr->ipv6.ip)((((PRIPv6Addr *)&addr->ipv6.ip)->_S6_un._S6_u32[0]
 == 0) && (((PRIPv6Addr *)&addr->ipv6.ip)->
_S6_un._S6_u32[1] == 0) && (((PRIPv6Addr *)&addr->
ipv6.ip)->_S6_un._S6_u32[2] == 0) && (((PRIPv6Addr
 *)&addr->ipv6.ip)->_S6_un._S6_u32[3] == 0))) {
              return PR_TRUE1;
          }
          if (_PR_IN6_IS_ADDR_V4MAPPED((PRIPv6Addr *)&addr->ipv6.ip)((((PRIPv6Addr *)&addr->ipv6.ip)->_S6_un._S6_u32[0]
 == 0) && (((PRIPv6Addr *)&addr->ipv6.ip)->
_S6_un._S6_u32[1] == 0) && (((PRIPv6Addr *)&addr->
ipv6.ip)->_S6_un._S6_u8[8] == 0) && (((PRIPv6Addr *
)&addr->ipv6.ip)->_S6_un._S6_u8[9] == 0) &&
 (((PRIPv6Addr *)&addr->ipv6.ip)->_S6_un._S6_u8[10]
 == 0xff) && (((PRIPv6Addr *)&addr->ipv6.ip)->
_S6_un._S6_u8[11] == 0xff))
              && _PR_IN6_V4MAPPED_TO_IPADDR((PRIPv6Addr *)&addr->ipv6.ip)(((PRIPv6Addr *)&addr->ipv6.ip)->_S6_un._S6_u32[3])
              == htonl(INADDR_ANY((in_addr_t) 0x00000000))) {
              return PR_TRUE1;
          }
      } else if (val == PR_IpAddrLoopback) {
          if (_PR_IN6_IS_ADDR_LOOPBACK((PRIPv6Addr *)&addr->ipv6.ip)((((PRIPv6Addr *)&addr->ipv6.ip)->_S6_un._S6_u32[0]
 == 0) && (((PRIPv6Addr *)&addr->ipv6.ip)->
_S6_un._S6_u32[1] == 0) && (((PRIPv6Addr *)&addr->
ipv6.ip)->_S6_un._S6_u32[2] == 0) && (((PRIPv6Addr
 *)&addr->ipv6.ip)->_S6_un._S6_u8[12] == 0) &&
 (((PRIPv6Addr *)&addr->ipv6.ip)->_S6_un._S6_u8[13]
 == 0) && (((PRIPv6Addr *)&addr->ipv6.ip)->
_S6_un._S6_u8[14] == 0) && (((PRIPv6Addr *)&addr->
ipv6.ip)->_S6_un._S6_u8[15] == 0x1U))) {
              return PR_TRUE1;
          }
          if (_PR_IN6_IS_ADDR_V4MAPPED((PRIPv6Addr *)&addr->ipv6.ip)((((PRIPv6Addr *)&addr->ipv6.ip)->_S6_un._S6_u32[0]
 == 0) && (((PRIPv6Addr *)&addr->ipv6.ip)->
_S6_un._S6_u32[1] == 0) && (((PRIPv6Addr *)&addr->
ipv6.ip)->_S6_un._S6_u8[8] == 0) && (((PRIPv6Addr *
)&addr->ipv6.ip)->_S6_un._S6_u8[9] == 0) &&
 (((PRIPv6Addr *)&addr->ipv6.ip)->_S6_un._S6_u8[10]
 == 0xff) && (((PRIPv6Addr *)&addr->ipv6.ip)->
_S6_un._S6_u8[11] == 0xff))
              && _PR_IN6_V4MAPPED_TO_IPADDR((PRIPv6Addr *)&addr->ipv6.ip)(((PRIPv6Addr *)&addr->ipv6.ip)->_S6_un._S6_u32[3])
              == htonl(INADDR_LOOPBACK((in_addr_t) 0x7f000001))) {
              return PR_TRUE1;
          }
      } else if (val == PR_IpAddrV4Mapped
                 && _PR_IN6_IS_ADDR_V4MAPPED((PRIPv6Addr *)&addr->ipv6.ip)((((PRIPv6Addr *)&addr->ipv6.ip)->_S6_un._S6_u32[0]
 == 0) && (((PRIPv6Addr *)&addr->ipv6.ip)->
_S6_un._S6_u32[1] == 0) && (((PRIPv6Addr *)&addr->
ipv6.ip)->_S6_un._S6_u8[8] == 0) && (((PRIPv6Addr *
)&addr->ipv6.ip)->_S6_un._S6_u8[9] == 0) &&
 (((PRIPv6Addr *)&addr->ipv6.ip)->_S6_un._S6_u8[10]
 == 0xff) && (((PRIPv6Addr *)&addr->ipv6.ip)->
_S6_un._S6_u8[11] == 0xff))) {
          return PR_TRUE1;
      }
  } else {
      if (addr->raw.family == AF_INET2) {
          if (val == PR_IpAddrAny && addr->inet.ip == htonl(INADDR_ANY((in_addr_t) 0x00000000))) {
              return PR_TRUE1;
          }
          if (val == PR_IpAddrLoopback
              && addr->inet.ip == htonl(INADDR_LOOPBACK((in_addr_t) 0x7f000001))) {
              return PR_TRUE1;
          }
      }
  }
  return PR_FALSE0;
1583}

1585extern int pr_inet_aton(const char *cp, PRUint32 *addr);

1587#define XX 127
1588static const unsigned char index_hex[256] = {
  XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
  XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
  XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
  0, 1, 2, 3,  4, 5, 6, 7,  8, 9,XX,XX, XX,XX,XX,XX,
  XX,10,11,12, 13,14,15,XX, XX,XX,XX,XX, XX,XX,XX,XX,
  XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
  XX,10,11,12, 13,14,15,XX, XX,XX,XX,XX, XX,XX,XX,XX,
  XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
  XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
  XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
  XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
  XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
  XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
  XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
  XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
  XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
1605};

1607/*
* StringToV6Addr() returns 1 if the conversion succeeds,
* or 0 if the input is not a valid IPv6 address string.
* (Same as inet_pton(AF_INET6, string, addr).)
*/
1612static int StringToV6Addr(const char *string, PRIPv6Addr *addr)
1613{
  const unsigned char *s = (const unsigned char *)string;
  int section = 0;        /* index of the current section (a 16-bit
                           * piece of the address */
  int double_colon = -1;  /* index of the section after the first
                           * 16-bit group of zeros represented by
                           * the double colon */
  unsigned int val;
  int len;

  /* Handle initial (double) colon */
  if (*s == ':') {
      if (s[1] != ':') {
          return 0;
      }
      s += 2;
      addr->pr_s6_addr16_S6_un._S6_u16[0] = 0;
      section = double_colon = 1;
  }

  while (*s) {
      if (section == 8) {
          return 0;    /* too long */
      }
      if (*s == ':') {
          if (double_colon != -1) {
              return 0;    /* two double colons */
          }
          addr->pr_s6_addr16_S6_un._S6_u16[section++] = 0;
          double_colon = section;
          s++;
          continue;
      }
      for (len = val = 0; len < 4 && index_hex[*s] != XX; len++) {
          val = (val << 4) + index_hex[*s++];
      }
      if (*s == '.') {
          if (len == 0) {
              return 0;    /* nothing between : and . */
          }
          break;
      }
      if (*s == ':') {
          s++;
          if (!*s) {
              return 0;    /* cannot end with single colon */
          }
      } else if (*s) {
          return 0; /* bad character */
      }
      addr->pr_s6_addr16_S6_un._S6_u16[section++] = htons((unsigned short)val);
  }

  if (*s == '.') {
      /* Have a trailing v4 format address */
      if (section > 6) {
          return 0;    /* not enough room */
      }

      /*
       * The number before the '.' is decimal, but we parsed it
       * as hex.  That means it is in BCD.  Check it for validity
       * and convert it to binary.
       */
      if (val > 0x0255 || (val & 0xf0) > 0x90 || (val & 0xf) > 9) {
          return 0;
      }
      val = (val >> 8) * 100 + ((val >> 4) & 0xf) * 10 + (val & 0xf);
      addr->pr_s6_addr_S6_un._S6_u8[2 * section] = val;

      s++;
      val = index_hex[*s++];
      if (val > 9) {
          return 0;
      }
      while (*s >= '0' && *s <= '9') {
          val = val * 10 + *s++ - '0';
          if (val > 255) {
              return 0;
          }
      }
      if (*s != '.') {
          return 0;    /* must have exactly 4 decimal numbers */
      }
      addr->pr_s6_addr_S6_un._S6_u8[2 * section + 1] = val;
      section++;

      s++;
      val = index_hex[*s++];
      if (val > 9) {
          return 0;
      }
      while (*s >= '0' && *s <= '9') {
          val = val * 10 + *s++ - '0';
          if (val > 255) {
              return 0;
          }
      }
      if (*s != '.') {
          return 0;    /* must have exactly 4 decimal numbers */
      }
      addr->pr_s6_addr_S6_un._S6_u8[2 * section] = val;

      s++;
      val = index_hex[*s++];
      if (val > 9) {
          return 0;
      }
      while (*s >= '0' && *s <= '9') {
          val = val * 10 + *s++ - '0';
          if (val > 255) {
              return 0;
          }
      }
      if (*s) {
          return 0;    /* must have exactly 4 decimal numbers */
      }
      addr->pr_s6_addr_S6_un._S6_u8[2 * section + 1] = val;
      section++;
  }

  if (double_colon != -1) {
      /* Stretch the double colon */
      int tosection;
      int ncopy = section - double_colon;
      for (tosection = 7; ncopy--; tosection--) {
          addr->pr_s6_addr16_S6_un._S6_u16[tosection] =
              addr->pr_s6_addr16_S6_un._S6_u16[double_colon + ncopy];
      }
      while (tosection >= double_colon) {
          addr->pr_s6_addr16_S6_un._S6_u16[tosection--] = 0;
      }
  } else if (section != 8) {
      return 0; /* too short */
  }
  return 1;
1749}
1750#undef XX

1752#ifndef _PR_HAVE_INET_NTOP
1753static const char *basis_hex = "0123456789abcdef";

1755/*
* V6AddrToString() returns a pointer to the buffer containing
* the text string if the conversion succeeds, and NULL otherwise.
* (Same as inet_ntop(AF_INET6, addr, buf, size), except that errno
* is not set on failure.)
*/
1761static const char *V6AddrToString(
  const PRIPv6Addr *addr, char *buf, PRUint32 size)
1763{
1764#define STUFF(c) do { \
  if (!size--) return NULL((void*)0); \
  *buf++ = (c); \
1767} while (0)

  int double_colon = -1;          /* index of the first 16-bit
                                   * group of zeros represented
                                   * by the double colon */
  int double_colon_length = 1;    /* use double colon only if
                                   * there are two or more 16-bit
                                   * groups of zeros */
  int zero_length;
  int section;
  unsigned int val;
  const char *bufcopy = buf;

  /* Scan to find the placement of the double colon */
  for (section = 0; section < 8; section++) {
      if (addr->pr_s6_addr16_S6_un._S6_u16[section] == 0) {
          zero_length = 1;
          section++;
          while (section < 8 && addr->pr_s6_addr16_S6_un._S6_u16[section] == 0) {
              zero_length++;
              section++;
          }
          /* Select the longest sequence of zeros */
          if (zero_length > double_colon_length) {
              double_colon = section - zero_length;
              double_colon_length = zero_length;
          }
      }
  }

  /* Now start converting to a string */
  section = 0;

  if (double_colon == 0) {
      if (double_colon_length == 6 ||
          (double_colon_length == 5 && addr->pr_s6_addr16_S6_un._S6_u16[5] == 0xffff)) {
          /* ipv4 format address */
          STUFF(':');
          STUFF(':');
          if (double_colon_length == 5) {
              STUFF('f');
              STUFF('f');
              STUFF('f');
              STUFF('f');
              STUFF(':');
          }
          if (addr->pr_s6_addr_S6_un._S6_u8[12] > 99) {
              STUFF(addr->pr_s6_addr_S6_un._S6_u8[12]/100 + '0');
          }
          if (addr->pr_s6_addr_S6_un._S6_u8[12] > 9) {
              STUFF((addr->pr_s6_addr_S6_un._S6_u8[12]%100)/10 + '0');
          }
          STUFF(addr->pr_s6_addr_S6_un._S6_u8[12]%10 + '0');
          STUFF('.');
          if (addr->pr_s6_addr_S6_un._S6_u8[13] > 99) {
              STUFF(addr->pr_s6_addr_S6_un._S6_u8[13]/100 + '0');
          }
          if (addr->pr_s6_addr_S6_un._S6_u8[13] > 9) {
              STUFF((addr->pr_s6_addr_S6_un._S6_u8[13]%100)/10 + '0');
          }
          STUFF(addr->pr_s6_addr_S6_un._S6_u8[13]%10 + '0');
          STUFF('.');
          if (addr->pr_s6_addr_S6_un._S6_u8[14] > 99) {
              STUFF(addr->pr_s6_addr_S6_un._S6_u8[14]/100 + '0');
          }
          if (addr->pr_s6_addr_S6_un._S6_u8[14] > 9) {
              STUFF((addr->pr_s6_addr_S6_un._S6_u8[14]%100)/10 + '0');
          }
          STUFF(addr->pr_s6_addr_S6_un._S6_u8[14]%10 + '0');
          STUFF('.');
          if (addr->pr_s6_addr_S6_un._S6_u8[15] > 99) {
              STUFF(addr->pr_s6_addr_S6_un._S6_u8[15]/100 + '0');
          }
          if (addr->pr_s6_addr_S6_un._S6_u8[15] > 9) {
              STUFF((addr->pr_s6_addr_S6_un._S6_u8[15]%100)/10 + '0');
          }
          STUFF(addr->pr_s6_addr_S6_un._S6_u8[15]%10 + '0');
          STUFF('\0');
          return bufcopy;
      }
  }

  while (section < 8) {
      if (section == double_colon) {
          STUFF(':');
          STUFF(':');
          section += double_colon_length;
          continue;
      }
      val = ntohs(addr->pr_s6_addr16_S6_un._S6_u16[section]);
      if (val > 0xfff) {
          STUFF(basis_hex[val >> 12]);
      }
      if (val > 0xff) {
          STUFF(basis_hex[(val >> 8) & 0xf]);
      }
      if (val > 0xf) {
          STUFF(basis_hex[(val >> 4) & 0xf]);
      }
      STUFF(basis_hex[val & 0xf]);
      section++;
      if (section < 8 && section != double_colon) {
          STUFF(':');
      }
  }
  STUFF('\0');
  return bufcopy;
1874#undef STUFF
1875}
1876#endif /* !_PR_HAVE_INET_NTOP */

1878/*
* Convert an IPv4 addr to an (IPv4-mapped) IPv6 addr
*/
1881PR_IMPLEMENT(void)__attribute__((visibility("default"))) void PR_ConvertIPv4AddrToIPv6(PRUint32 v4addr, PRIPv6Addr *v6addr)
1882{
  PRUint8 *dstp;
  dstp = v6addr->pr_s6_addr_S6_un._S6_u8;
  memset(dstp, 0, 10);
  memset(dstp + 10, 0xff, 2);
  memcpy(dstp + 12,(char *) &v4addr, 4);
1888}

1890PR_IMPLEMENT(PRUint16)__attribute__((visibility("default"))) PRUint16 PR_ntohs(PRUint16 n) {
  return ntohs(n);
1892}
1893PR_IMPLEMENT(PRUint32)__attribute__((visibility("default"))) PRUint32 PR_ntohl(PRUint32 n) {
  return ntohl(n);
1895}
1896PR_IMPLEMENT(PRUint16)__attribute__((visibility("default"))) PRUint16 PR_htons(PRUint16 n) {
  return htons(n);
1898}
1899PR_IMPLEMENT(PRUint32)__attribute__((visibility("default"))) PRUint32 PR_htonl(PRUint32 n) {
  return htonl(n);
1901}
1902PR_IMPLEMENT(PRUint64)__attribute__((visibility("default"))) PRUint64 PR_ntohll(PRUint64 n)
1903{
1904#ifdef IS_BIG_ENDIAN
  return n;
1906#else
  PRUint32 hi, lo;
  lo = (PRUint32)n;
  hi = (PRUint32)(n >> 32);
  hi = PR_ntohl(hi);
  lo = PR_ntohl(lo);
  return ((PRUint64)lo << 32) + (PRUint64)hi;
1913#endif
1914}  /* ntohll */

1916PR_IMPLEMENT(PRUint64)__attribute__((visibility("default"))) PRUint64 PR_htonll(PRUint64 n)
1917{
1918#ifdef IS_BIG_ENDIAN
  return n;
1920#else
  PRUint32 hi, lo;
  lo = (PRUint32)n;
  hi = (PRUint32)(n >> 32);
  hi = htonl(hi);
  lo = htonl(lo);
  return ((PRUint64)lo << 32) + (PRUint64)hi;
1927#endif
1928}  /* htonll */


1931/*
* Implementation of PR_GetAddrInfoByName and friends
*
* Compile-time options:
*
*  _PR_HAVE_GETADDRINFO  Define this macro if the target system provides
*                        getaddrinfo. With this defined, NSPR will require
*                        getaddrinfo at run time. If this if not defined,
*                        then NSPR will attempt to dynamically resolve
*                        getaddrinfo, falling back to PR_GetHostByName if
*                        getaddrinfo does not exist on the target system.
*
* Since getaddrinfo is a relatively new system call on many systems,
* we are forced to dynamically resolve it at run time in most cases.
* The exception includes any system (such as Mac OS X) that is known to
* provide getaddrinfo in all versions that NSPR cares to support.
*/

1949#if defined(_PR_HAVE_GETADDRINFO)

1951#if defined(_PR_INET6)

1953typedef struct addrinfo PRADDRINFO;
1954#define GETADDRINFOgetaddrinfo getaddrinfo
1955#define FREEADDRINFOfreeaddrinfo freeaddrinfo
1956#define GETNAMEINFOgetnameinfo getnameinfo

1958#elif defined(_PR_INET6_PROBE)

1960typedef struct addrinfo PRADDRINFO;

1962/* getaddrinfo/freeaddrinfo/getnameinfo prototypes */
1963#if defined(WIN32)
1964#define FUNC_MODIFIER __stdcall
1965#else
1966#define FUNC_MODIFIER
1967#endif
1968typedef int (FUNC_MODIFIER * FN_GETADDRINFO)
1969(const char *nodename,
const char *servname,
const PRADDRINFO *hints,
PRADDRINFO **res);
1973typedef int (FUNC_MODIFIER * FN_FREEADDRINFO)
1974(PRADDRINFO *ai);
1975typedef int (FUNC_MODIFIER * FN_GETNAMEINFO)
1976(const struct sockaddr *addr, int addrlen,
char *host, int hostlen,
char *serv, int servlen, int flags);

1980/* global state */
1981static FN_GETADDRINFO   _pr_getaddrinfo   = NULL((void*)0);
1982static FN_FREEADDRINFO  _pr_freeaddrinfo  = NULL((void*)0);
1983static FN_GETNAMEINFO   _pr_getnameinfo   = NULL((void*)0);

1985#define GETADDRINFO_SYMBOL "getaddrinfo"
1986#define FREEADDRINFO_SYMBOL "freeaddrinfo"
1987#define GETNAMEINFO_SYMBOL "getnameinfo"

1989PRStatus
1990_pr_find_getaddrinfo(void)
1991{
  PRLibrary *lib;
1993#ifdef WIN32
  /*
   * On windows, we need to search ws2_32.dll or wship6.dll
   * (Microsoft IPv6 Technology Preview for Windows 2000) for
   * getaddrinfo and freeaddrinfo.  These libraries might not
   * be loaded yet.
   */
  const char *libname[] = { "ws2_32.dll", "wship6.dll" };
  int i;

  for (i = 0; i < sizeof(libname)/sizeof(libname[0]); i++) {
      lib = PR_LoadLibrary(libname[i]);
      if (!lib) {
          continue;
      }
      _pr_getaddrinfo = (FN_GETADDRINFO)
                        PR_FindFunctionSymbol(lib, GETADDRINFO_SYMBOL);
      if (!_pr_getaddrinfo) {
          PR_UnloadLibrary(lib);
          continue;
      }
      _pr_freeaddrinfo = (FN_FREEADDRINFO)
                         PR_FindFunctionSymbol(lib, FREEADDRINFO_SYMBOL);
      _pr_getnameinfo = (FN_GETNAMEINFO)
                        PR_FindFunctionSymbol(lib, GETNAMEINFO_SYMBOL);
      if (!_pr_freeaddrinfo || !_pr_getnameinfo) {
          PR_UnloadLibrary(lib);
          continue;
      }
      /* Keep the library loaded. */
      return PR_SUCCESS;
  }
  return PR_FAILURE;
2026#else
  /*
   * Resolve getaddrinfo by searching all loaded libraries.  Then
   * search library containing getaddrinfo for freeaddrinfo.
   */
  _pr_getaddrinfo = (FN_GETADDRINFO)
                    PR_FindFunctionSymbolAndLibrary(GETADDRINFO_SYMBOL, &lib);
  if (!_pr_getaddrinfo) {
      return PR_FAILURE;
  }
  _pr_freeaddrinfo = (FN_FREEADDRINFO)
                     PR_FindFunctionSymbol(lib, FREEADDRINFO_SYMBOL);
  _pr_getnameinfo = (FN_GETNAMEINFO)
                    PR_FindFunctionSymbol(lib, GETNAMEINFO_SYMBOL);
  PR_UnloadLibrary(lib);
  if (!_pr_freeaddrinfo || !_pr_getnameinfo) {
      return PR_FAILURE;
  }
  return PR_SUCCESS;
2045#endif
2046}

2048#define GETADDRINFOgetaddrinfo (*_pr_getaddrinfo)
2049#define FREEADDRINFOfreeaddrinfo (*_pr_freeaddrinfo)
2050#define GETNAMEINFOgetnameinfo (*_pr_getnameinfo)

2052#endif /* _PR_INET6 */

2054#endif /* _PR_HAVE_GETADDRINFO */

2056#if !defined(_PR_HAVE_GETADDRINFO) || defined(_PR_INET6_PROBE)
2057/*
* If getaddrinfo does not exist, then we will fall back on
* PR_GetHostByName, which requires that we allocate a buffer for the
* PRHostEnt data structure and its members.
*/
2062typedef struct PRAddrInfoFB {
  char      buf[PR_NETDB_BUF_SIZE2048];
  PRHostEnt hostent;
  PRBool    has_cname;
2066} PRAddrInfoFB;

2068static PRAddrInfo *
2069pr_GetAddrInfoByNameFB(const char  *hostname,
                     PRUint16     af,
                     PRIntn       flags)
2072{
  PRStatus rv;
  PRAddrInfoFB *ai;
  /* fallback on PR_GetHostByName */
  ai = PR_NEW(PRAddrInfoFB)((PRAddrInfoFB *) (PR_Malloc((sizeof(PRAddrInfoFB)))));
  if (!ai) {
      PR_SetError(PR_OUT_OF_MEMORY_ERROR(-6000L), 0);
      return NULL((void*)0);
  }
  rv = PR_GetHostByName(hostname, ai->buf, sizeof ai->buf, &ai->hostent);
  if (rv == PR_FAILURE) {
      PR_Free(ai);
      return NULL((void*)0);
  }
  ai->has_cname = !(flags & PR_AI_NOCANONNAME0x8000);

  return (PRAddrInfo *) ai;
2089}
2090#endif /* !_PR_HAVE_GETADDRINFO || _PR_INET6_PROBE */

2092PR_IMPLEMENT(PRAddrInfo *)__attribute__((visibility("default"))) PRAddrInfo * PR_GetAddrInfoByName(const char  *hostname,
      PRUint16     af,
      PRIntn       flags)
2095{
  /* restrict input to supported values */
  if ((af != PR_AF_INET2 && af != PR_AF_UNSPEC0) ||
      (flags & ~ PR_AI_NOCANONNAME0x8000) != PR_AI_ADDRCONFIG0x20) {
      PR_SetError(PR_INVALID_ARGUMENT_ERROR(-5987L), 0);
      return NULL((void*)0);
  }

  if (!_pr_initialized) {
      _PR_ImplicitInitialization();
  }

2107#if !defined(_PR_HAVE_GETADDRINFO)
  return pr_GetAddrInfoByNameFB(hostname, af, flags);
2109#else
2110#if defined(_PR_INET6_PROBE)
  if (!_pr_ipv6_is_present()) {
      return pr_GetAddrInfoByNameFB(hostname, af, flags);
  }
2114#endif
  {
      PRADDRINFO *res, hints;
      int rv;

      /*
       * we assume a RFC 2553 compliant getaddrinfo.  this may at some
       * point need to be customized as platforms begin to adopt the
       * RFC 3493.
       */

      memset(&hints, 0, sizeof(hints));
      if (!(flags & PR_AI_NOCANONNAME0x8000)) {
          hints.ai_flags |= AI_CANONNAME0x0002;
      }
2129#ifdef AI_ADDRCONFIG0x0020
      /*
       * Propagate AI_ADDRCONFIG to the GETADDRINFO call if PR_AI_ADDRCONFIG
       * is set.
       *
       * Need a workaround for loopback host addresses:
       * The problem is that in glibc and Windows, AI_ADDRCONFIG applies the
       * existence of an outgoing network interface to IP addresses of the
       * loopback interface, due to a strict interpretation of the
       * specification.  For example, if a computer does not have any
       * outgoing IPv6 network interface, but its loopback network interface
       * supports IPv6, a getaddrinfo call on "localhost" with AI_ADDRCONFIG
       * won't return the IPv6 loopback address "::1", because getaddrinfo
       * thinks the computer cannot connect to any IPv6 destination,
       * ignoring the remote vs. local/loopback distinction.
       */
      if ((flags & PR_AI_ADDRCONFIG0x20) &&
          strcmp(hostname, "localhost") != 0 &&
          strcmp(hostname, "localhost.localdomain") != 0 &&
          strcmp(hostname, "localhost6") != 0 &&
          strcmp(hostname, "localhost6.localdomain6") != 0) {
          hints.ai_flags |= AI_ADDRCONFIG0x0020;
      }
2152#endif
      hints.ai_family = (af == PR_AF_INET2) ? AF_INET2 : AF_UNSPEC0;

      /*
       * it is important to select a socket type in the hints, otherwise we
       * will get back repetitive entries: one for each socket type.  since
       * we do not expose ai_socktype through our API, it is okay to do this
       * here.  the application may still choose to create a socket of some
       * other type.
       */
      hints.ai_socktype = SOCK_STREAMSOCK_STREAM;

      rv = GETADDRINFOgetaddrinfo(hostname, NULL((void*)0), &hints, &res);
2165#ifdef AI_ADDRCONFIG0x0020
      if (rv == EAI_BADFLAGS-1 && (hints.ai_flags & AI_ADDRCONFIG0x0020)) {
          hints.ai_flags &= ~AI_ADDRCONFIG0x0020;
          rv = GETADDRINFOgetaddrinfo(hostname, NULL((void*)0), &hints, &res);
      }
2170#endif
      if (rv == 0) {
          return (PRAddrInfo *) res;
      }

      PR_SetError(PR_DIRECTORY_LOOKUP_ERROR(-5973L), rv);
  }
  return NULL((void*)0);
2178#endif
2179}

2181PR_IMPLEMENT(PRStatus)__attribute__((visibility("default"))) PRStatus
2182PR_GetPrefLoopbackAddrInfo(PRNetAddr *result,
                         PRUint16 port)
2184{
  char          tmpBuf[ 40 ];
  const int     tmpBufSize = sizeof( tmpBuf );

  if (!result) {
1
Assuming 'result' is non-null→
2
←
Taking false branch→
      PR_SetError(PR_INVALID_ARGUMENT_ERROR(-5987L), 0);
      return PR_FAILURE;
  }

  if (!_pr_initialized) _PR_ImplicitInitialization();
3
←
Assuming '_pr_initialized' is not equal to 0→
4
←
Taking false branch→

  PR_snprintf(tmpBuf, tmpBufSize, "%u", port );

2197#if !defined(_PR_HAVE_GETADDRINFO) || !defined(AI_PASSIVE0x0001)
  PR_SetError(PR_NOT_IMPLEMENTED_ERROR(-5992L), 0);
  return PR_FAILURE;
2200#else

  PRADDRINFO *res, hints;
  PRStatus rv;

  memset(&hints, 0, sizeof(hints));

  rv = GETADDRINFOgetaddrinfo(NULL((void*)0), tmpBuf, &hints, &res);
5
←
Value assigned to 'res'→
  if (rv == 0) {
6
←
Assuming 'rv' is equal to 0→
7
←
Taking true branch→
      PRBool result_still_empty = PR_TRUE1;
      PRADDRINFO *ai = res;
8
←
'ai' initialized to the value of 'res'→
      do {
          PRNetAddr aNetAddr;

          while (ai && ai->ai_addrlen > sizeof(PRNetAddr))
9
←
Assuming 'ai' is null→
              ai = ai->ai_next;

          if (ai9.1
'ai' is null
) {
              /* copy sockaddr to PRNetAddr */
              memcpy(&aNetAddr, ai->ai_addr, ai->ai_addrlen);
              aNetAddr.raw.family = ai->ai_addr->sa_family;
2221#ifdef _PR_INET6
              if (AF_INET610 == aNetAddr.raw.family)
                  aNetAddr.raw.family = PR_AF_INET610;
2224#endif
              if (ai->ai_addrlen < sizeof(PRNetAddr))
                  memset(((char*)result)+ai->ai_addrlen, 0,
                         sizeof(PRNetAddr) - ai->ai_addrlen);
          }

          /* If we obtain more than one result, prefer IPv6. */
          if (result_still_empty9.2
'result_still_empty' is 1
 || aNetAddr.raw.family == PR_AF_INET610) {
              memcpy(result, &aNetAddr, sizeof(PRNetAddr));
          }
          result_still_empty = PR_FALSE0;
          ai = ai->ai_next;
10
←
Access to field 'ai_next' results in a dereference of a null pointer (loaded from variable 'ai')
      }
      while (ai);

      FREEADDRINFOfreeaddrinfo(res);
      return PR_SUCCESS;
  }

  PR_SetError(PR_DIRECTORY_LOOKUP_ERROR(-5973L), rv);
  return PR_FAILURE;
2245#endif
2246}

2248PR_IMPLEMENT(void)__attribute__((visibility("default"))) void PR_FreeAddrInfo(PRAddrInfo *ai)
2249{
2250#if defined(_PR_HAVE_GETADDRINFO)
2251#if defined(_PR_INET6_PROBE)
  if (!_pr_ipv6_is_present()) {
      PR_Free((PRAddrInfoFB *) ai);
  }
  else
2256#endif
      FREEADDRINFOfreeaddrinfo((PRADDRINFO *) ai);
2258#else
  PR_Free((PRAddrInfoFB *) ai);
2260#endif
2261}

2263PR_IMPLEMENT(void *)__attribute__((visibility("default"))) void * PR_EnumerateAddrInfo(void             *iterPtr,
      const PRAddrInfo *base,
      PRUint16          port,
      PRNetAddr        *result)
2267{
2268#if defined(_PR_HAVE_GETADDRINFO)
  PRADDRINFO *ai;
2270#if defined(_PR_INET6_PROBE)
  if (!_pr_ipv6_is_present()) {
      /* using PRAddrInfoFB */
      PRIntn iter = (PRIntn)(PRPtrdiff) iterPtr;
      iter = PR_EnumerateHostEnt(iter, &((PRAddrInfoFB *) base)->hostent, port, result);
      if (iter < 0) {
          iter = 0;
      }
      return (void *)(PRPtrdiff) iter;
  }
2280#endif

  if (iterPtr) {
      ai = ((PRADDRINFO *) iterPtr)->ai_next;
  }
  else {
      ai = (PRADDRINFO *) base;
  }

  while (ai && ai->ai_addrlen > sizeof(PRNetAddr)) {
      ai = ai->ai_next;
  }

  if (ai) {
      /* copy sockaddr to PRNetAddr */
      memcpy(result, ai->ai_addr, ai->ai_addrlen);
      result->raw.family = ai->ai_addr->sa_family;
2297#ifdef _PR_INET6
      if (AF_INET610 == result->raw.family) {
          result->raw.family = PR_AF_INET610;
      }
2301#endif
      if (ai->ai_addrlen < sizeof(PRNetAddr)) {
          memset(((char*)result)+ai->ai_addrlen, 0, sizeof(PRNetAddr) - ai->ai_addrlen);
      }

      if (result->raw.family == PR_AF_INET2) {
          result->inet.port = htons(port);
      }
      else {
          result->ipv6.port = htons(port);
      }
  }

  return ai;
2315#else
  /* using PRAddrInfoFB */
  PRIntn iter = (PRIntn) iterPtr;
  iter = PR_EnumerateHostEnt(iter, &((PRAddrInfoFB *) base)->hostent, port, result);
  if (iter < 0) {
      iter = 0;
  }
  return (void *) iter;
2323#endif
2324}

2326PR_IMPLEMENT(const char *)__attribute__((visibility("default"))) const char * PR_GetCanonNameFromAddrInfo(const PRAddrInfo *ai)
2327{
2328#if defined(_PR_HAVE_GETADDRINFO)
2329#if defined(_PR_INET6_PROBE)
  if (!_pr_ipv6_is_present()) {
      const PRAddrInfoFB *fb = (const PRAddrInfoFB *) ai;
      return fb->has_cname ? fb->hostent.h_name : NULL((void*)0);
  }
2334#endif
  return ((const PRADDRINFO *) ai)->ai_canonname;
2336#else
  const PRAddrInfoFB *fb = (const PRAddrInfoFB *) ai;
  return fb->has_cname ? fb->hostent.h_name : NULL((void*)0);
2339#endif
2340}

2342#if defined(_PR_HAVE_GETADDRINFO)
2343static PRStatus pr_StringToNetAddrGAI(const char *string, PRNetAddr *addr)
2344{
  PRADDRINFO *res, hints;
  int rv;  /* 0 for success, or the error code EAI_xxx */
  PRNetAddr laddr;
  PRStatus status = PR_SUCCESS;

  memset(&hints, 0, sizeof(hints));
  hints.ai_flags = AI_NUMERICHOST0x0004;
  hints.ai_family = AF_UNSPEC0;
  hints.ai_socktype = SOCK_STREAMSOCK_STREAM;

  rv = GETADDRINFOgetaddrinfo(string, NULL((void*)0), &hints, &res);
  if (rv != 0)
  {
      PR_SetError(PR_INVALID_ARGUMENT_ERROR(-5987L), rv);
      return PR_FAILURE;
  }

  /* pick up the first addr */
  memcpy(&laddr, res->ai_addr, res->ai_addrlen);
  if (AF_INET610 == res->ai_addr->sa_family)
  {
      addr->ipv6.family = PR_AF_INET610;
      addr->ipv6.ip = laddr.ipv6.ip;
      addr->ipv6.scope_id = laddr.ipv6.scope_id;
  }
  else if (AF_INET2 == res->ai_addr->sa_family)
  {
      addr->inet.family = PR_AF_INET2;
      addr->inet.ip = laddr.inet.ip;
  }
  else
  {
      PR_SetError(PR_INVALID_ARGUMENT_ERROR(-5987L), 0);
      status = PR_FAILURE;
  }

  FREEADDRINFOfreeaddrinfo(res);
  return status;
2383}
2384#endif  /* _PR_HAVE_GETADDRINFO */

2386static PRStatus pr_StringToNetAddrFB(const char *string, PRNetAddr *addr)
2387{
  PRIntn rv;

  rv = pr_inet_aton(string, &addr->inet.ip);
  if (1 == rv)
  {
      addr->raw.family = AF_INET2;
      return PR_SUCCESS;
  }

  PR_ASSERT(0 == rv)((0 == rv)?((void)0):PR_Assert("0 == rv","../../../../pr/src/misc/prnetdb.c"
,2397));
  /* clean up after the failed call */
  memset(&addr->inet.ip, 0, sizeof(addr->inet.ip));

  rv = StringToV6Addr(string, &addr->ipv6.ip);
  if (1 == rv)
  {
      addr->raw.family = PR_AF_INET610;
      return PR_SUCCESS;
  }

  PR_ASSERT(0 == rv)((0 == rv)?((void)0):PR_Assert("0 == rv","../../../../pr/src/misc/prnetdb.c"
,2408));
  PR_SetError(PR_INVALID_ARGUMENT_ERROR(-5987L), 0);
  return PR_FAILURE;
2411}

2413PR_IMPLEMENT(PRStatus)__attribute__((visibility("default"))) PRStatus PR_StringToNetAddr(const char *string, PRNetAddr *addr)
2414{
  if (!_pr_initialized) {
      _PR_ImplicitInitialization();
  }

  if (!addr || !string || !*string)
  {
      PR_SetError(PR_INVALID_ARGUMENT_ERROR(-5987L), 0);
      return PR_FAILURE;
  }

2425#if !defined(_PR_HAVE_GETADDRINFO)
  return pr_StringToNetAddrFB(string, addr);
2427#else
  /*
   * getaddrinfo with AI_NUMERICHOST is much slower than pr_inet_aton on some
   * platforms, such as Mac OS X (bug 404399), Linux glibc 2.10 (bug 344809),
   * and most likely others. So we only use it to convert literal IP addresses
   * that contain IPv6 scope IDs, which pr_inet_aton cannot convert.
   */
  if (!strchr(string, '%')) {
      return pr_StringToNetAddrFB(string, addr);
  }

2438#if defined(_PR_INET6_PROBE)
  if (!_pr_ipv6_is_present()) {
      return pr_StringToNetAddrFB(string, addr);
  }
2442#endif

  return pr_StringToNetAddrGAI(string, addr);
2445#endif
2446}

2448#if defined(_PR_HAVE_GETADDRINFO)
2449static PRStatus pr_NetAddrToStringGNI(
  const PRNetAddr *addr, char *string, PRUint32 size)
2451{
  int addrlen;
  const PRNetAddr *addrp = addr;
2454#if defined(_PR_HAVE_SOCKADDR_LEN) || defined(_PR_INET6)
  PRUint16 md_af = addr->raw.family;
  PRNetAddr addrcopy;
2457#endif
  int rv;  /* 0 for success, or the error code EAI_xxx */

2460#ifdef _PR_INET6
  if (addr->raw.family == PR_AF_INET610)
  {
      md_af = AF_INET610;
2464#ifndef _PR_HAVE_SOCKADDR_LEN
      addrcopy = *addr;
      addrcopy.raw.family = md_af;
      addrp = &addrcopy;
2468#endif
  }
2470#endif

  addrlen = PR_NETADDR_SIZE(addr)_PR_NetAddrSize(addr);
2473#ifdef _PR_HAVE_SOCKADDR_LEN
  addrcopy = *addr;
  ((struct sockaddr*)&addrcopy)->sa_len = addrlen;
  ((struct sockaddr*)&addrcopy)->sa_family = md_af;
  addrp = &addrcopy;
2478#endif
  rv = GETNAMEINFOgetnameinfo((const struct sockaddr *)addrp, addrlen,
                   string, size, NULL((void*)0), 0, NI_NUMERICHOST1);
  if (rv != 0)
  {
      PR_SetError(PR_INVALID_ARGUMENT_ERROR(-5987L), rv);
      return PR_FAILURE;
  }
  return PR_SUCCESS;
2487}
2488#endif  /* _PR_HAVE_GETADDRINFO */

2490#if !defined(_PR_HAVE_GETADDRINFO) || defined(_PR_INET6_PROBE)
2491static PRStatus pr_NetAddrToStringFB(
  const PRNetAddr *addr, char *string, PRUint32 size)
2493{
  if (PR_AF_INET610 == addr->raw.family)
  {
2496#if defined(_PR_HAVE_INET_NTOP)
      if (NULL((void*)0) == inet_ntop(AF_INET610, &addr->ipv6.ip, string, size))
2498#else
      if (NULL((void*)0) == V6AddrToString(&addr->ipv6.ip, string, size))
2500#endif
      {
          /* the size of the result buffer is inadequate */
          PR_SetError(PR_BUFFER_OVERFLOW_ERROR(-5962L), 0);
          return PR_FAILURE;
      }
  }
  else
  {
      if (size < 16) {
          goto failed;
      }
      if (AF_INET2 != addr->raw.family) {
          goto failed;
      }
      else
      {
          unsigned char *byte = (unsigned char*)&addr->inet.ip;
          PR_snprintf(string, size, "%u.%u.%u.%u",
                      byte[0], byte[1], byte[2], byte[3]);
      }
  }

  return PR_SUCCESS;

2525failed:
  PR_SetError(PR_INVALID_ARGUMENT_ERROR(-5987L), 0);
  return PR_FAILURE;

2529}  /* pr_NetAddrToStringFB */
2530#endif  /* !_PR_HAVE_GETADDRINFO || _PR_INET6_PROBE */

2532PR_IMPLEMENT(PRStatus)__attribute__((visibility("default"))) PRStatus PR_NetAddrToString(
  const PRNetAddr *addr, char *string, PRUint32 size)
2534{
  if (!_pr_initialized) {
      _PR_ImplicitInitialization();
  }

2539#if !defined(_PR_HAVE_GETADDRINFO)
  return pr_NetAddrToStringFB(addr, string, size);
2541#else
2542#if defined(_PR_INET6_PROBE)
  if (!_pr_ipv6_is_present()) {
      return pr_NetAddrToStringFB(addr, string, size);
  }
2546#endif
  return pr_NetAddrToStringGNI(addr, string, size);
2548#endif
2549}  /* PR_NetAddrToString */