visaljs 0.0.10 → 0.0.11

package/node/third_party/c-ares/src/lib/inet_net_pton.c

@@ -0,0 +1,451 @@
+/*
+ * Copyright (c) 2012 by Gilles Chehade <gilles@openbsd.org>
+ * Copyright (c) 1996,1999 by Internet Software Consortium.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS
+ * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
+ * CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
+ * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+ * SOFTWARE.
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "ares_private.h"
+
+#ifdef HAVE_NETINET_IN_H
+#  include <netinet/in.h>
+#endif
+#ifdef HAVE_ARPA_INET_H
+#  include <arpa/inet.h>
+#endif
+
+#include "ares_nameser.h"
+
+#include "ares_ipv6.h"
+#include "ares_inet_net_pton.h"
+
+#ifdef USE_WINSOCK
+#  define SOCKERRNO        ((int)WSAGetLastError())
+#  define SET_SOCKERRNO(x) (WSASetLastError((int)(x)))
+#  undef EMSGSIZE
+#  define EMSGSIZE WSAEMSGSIZE
+#  undef ENOENT
+#  define ENOENT WSA_INVALID_PARAMETER
+#  undef EAFNOSUPPORT
+#  define EAFNOSUPPORT WSAEAFNOSUPPORT
+#else
+#  define SOCKERRNO        (errno)
+#  define SET_SOCKERRNO(x) (errno = (x))
+#endif
+
+const struct ares_in6_addr ares_in6addr_any = { { { 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                                                    0, 0, 0, 0, 0, 0, 0 } } };
+
+/*
+ * static int
+ * inet_net_pton_ipv4(src, dst, size)
+ *      convert IPv4 network number from presentation to network format.
+ *      accepts hex octets, hex strings, decimal octets, and /CIDR.
+ *      "size" is in bytes and describes "dst".
+ * return:
+ *      number of bits, either imputed classfully or specified with /CIDR,
+ *      or -1 if some failure occurred (check errno).  ENOENT means it was
+ *      not an IPv4 network specification.
+ * note:
+ *      network byte order assumed.  this means 192.5.5.240/28 has
+ *      0b11110000 in its fourth octet.
+ * note:
+ *      On Windows we store the error in the thread errno, not
+ *      in the winsock error code. This is to avoid losing the
+ *      actual last winsock error. So use macro ERRNO to fetch the
+ *      errno this function sets when returning (-1), not SOCKERRNO.
+ * author:
+ *      Paul Vixie (ISC), June 1996
+ */
+static int ares_inet_net_pton_ipv4(const char *src, unsigned char *dst,
+                                   size_t size)
+{
+  static const char    xdigits[] = "0123456789abcdef";
+  static const char    digits[]  = "0123456789";
+  int                  n;
+  int                  ch;
+  int                  tmp = 0;
+  int                  dirty;
+  int                  bits;
+  const unsigned char *odst = dst;
+
+  ch = *src++;
+  if (ch == '0' && (src[0] == 'x' || src[0] == 'X') && ares_isascii(src[1]) &&
+      ares_isxdigit(src[1])) {
+    /* Hexadecimal: Eat nybble string. */
+    if (!size) {
+      goto emsgsize;
+    }
+    dirty = 0;
+    src++; /* skip x or X. */
+    while ((ch = *src++) != '\0' && ares_isascii(ch) && ares_isxdigit(ch)) {
+      if (ares_isupper(ch)) {
+        ch = ares_tolower((unsigned char)ch);
+      }
+      n = (int)(strchr(xdigits, ch) - xdigits);
+      if (dirty == 0) {
+        tmp = n;
+      } else {
+        tmp = (tmp << 4) | n;
+      }
+      if (++dirty == 2) {
+        if (!size--) {
+          goto emsgsize;
+        }
+        *dst++ = (unsigned char)tmp;
+        dirty  = 0;
+      }
+    }
+    if (dirty) { /* Odd trailing nybble? */
+      if (!size--) {
+        goto emsgsize;
+      }
+      *dst++ = (unsigned char)(tmp << 4);
+    }
+  } else if (ares_isascii(ch) && ares_isdigit(ch)) {
+    /* Decimal: eat dotted digit string. */
+    for (;;) {
+      tmp = 0;
+      do {
+        n    = (int)(strchr(digits, ch) - digits);
+        tmp *= 10;
+        tmp += n;
+        if (tmp > 255) {
+          goto enoent;
+        }
+      } while ((ch = *src++) != '\0' && ares_isascii(ch) && ares_isdigit(ch));
+      if (!size--) {
+        goto emsgsize;
+      }
+      *dst++ = (unsigned char)tmp;
+      if (ch == '\0' || ch == '/') {
+        break;
+      }
+      if (ch != '.') {
+        goto enoent;
+      }
+      ch = *src++;
+      if (!ares_isascii(ch) || !ares_isdigit(ch)) {
+        goto enoent;
+      }
+    }
+  } else {
+    goto enoent;
+  }
+
+  bits = -1;
+  if (ch == '/' && ares_isascii(src[0]) && ares_isdigit(src[0]) && dst > odst) {
+    /* CIDR width specifier.  Nothing can follow it. */
+    ch   = *src++; /* Skip over the /. */
+    bits = 0;
+    do {
+      n     = (int)(strchr(digits, ch) - digits);
+      bits *= 10;
+      bits += n;
+      if (bits > 32) {
+        goto enoent;
+      }
+    } while ((ch = *src++) != '\0' && ares_isascii(ch) && ares_isdigit(ch));
+    if (ch != '\0') {
+      goto enoent;
+    }
+  }
+
+  /* Firey death and destruction unless we prefetched EOS. */
+  if (ch != '\0') {
+    goto enoent;
+  }
+
+  /* If nothing was written to the destination, we found no address. */
+  if (dst == odst) {
+    goto enoent; /* LCOV_EXCL_LINE: all valid paths above increment dst */
+  }
+  /* If no CIDR spec was given, infer width from net class. */
+  if (bits == -1) {
+    if (*odst >= 240) {        /* Class E */
+      bits = 32;
+    } else if (*odst >= 224) { /* Class D */
+      bits = 8;
+    } else if (*odst >= 192) { /* Class C */
+      bits = 24;
+    } else if (*odst >= 128) { /* Class B */
+      bits = 16;
+    } else {                   /* Class A */
+      bits = 8;
+    }
+    /* If imputed mask is narrower than specified octets, widen. */
+    if (bits < ((dst - odst) * 8)) {
+      bits = (int)(dst - odst) * 8;
+    }
+    /*
+     * If there are no additional bits specified for a class D
+     * address adjust bits to 4.
+     */
+    if (bits == 8 && *odst == 224) {
+      bits = 4;
+    }
+  }
+  /* Extend network to cover the actual mask. */
+  while (bits > ((dst - odst) * 8)) {
+    if (!size--) {
+      goto emsgsize;
+    }
+    *dst++ = '\0';
+  }
+  return bits;
+
+enoent:
+  SET_SOCKERRNO(ENOENT);
+  return -1;
+
+emsgsize:
+  SET_SOCKERRNO(EMSGSIZE);
+  return -1;
+}
+
+static int getbits(const char *src, size_t *bitsp)
+{
+  static const char digits[] = "0123456789";
+  size_t            n;
+  size_t            val;
+  char              ch;
+
+  val = 0;
+  n   = 0;
+  while ((ch = *src++) != '\0') {
+    const char *pch;
+
+    pch = strchr(digits, ch);
+    if (pch != NULL) {
+      if (n++ != 0 && val == 0) { /* no leading zeros */
+        return 0;
+      }
+      val *= 10;
+      val += (size_t)(pch - digits);
+      if (val > 128) { /* range */
+        return 0;
+      }
+      continue;
+    }
+    return 0;
+  }
+  if (n == 0) {
+    return 0;
+  }
+  *bitsp = val;
+  return 1;
+}
+
+static int ares_inet_pton6(const char *src, unsigned char *dst)
+{
+  static const char xdigits_l[] = "0123456789abcdef";
+  static const char xdigits_u[] = "0123456789ABCDEF";
+  unsigned char     tmp[NS_IN6ADDRSZ];
+  unsigned char    *tp;
+  unsigned char    *endp;
+  unsigned char    *colonp;
+  const char       *xdigits;
+  const char       *curtok;
+  int               ch;
+  int               saw_xdigit;
+  int               count_xdigit;
+  unsigned int      val;
+
+  memset((tp = tmp), '\0', NS_IN6ADDRSZ);
+  endp   = tp + NS_IN6ADDRSZ;
+  colonp = NULL;
+  /* Leading :: requires some special handling. */
+  if (*src == ':') {
+    if (*++src != ':') {
+      goto enoent;
+    }
+  }
+  curtok     = src;
+  saw_xdigit = count_xdigit = 0;
+  val                       = 0;
+  while ((ch = *src++) != '\0') {
+    const char *pch;
+
+    if ((pch = strchr((xdigits = xdigits_l), ch)) == NULL) {
+      pch = strchr((xdigits = xdigits_u), ch);
+    }
+    if (pch != NULL) {
+      if (count_xdigit >= 4) {
+        goto enoent;
+      }
+      val <<= 4;
+      val  |= (unsigned int)(pch - xdigits);
+      if (val > 0xffff) {
+        goto enoent;
+      }
+      saw_xdigit = 1;
+      count_xdigit++;
+      continue;
+    }
+    if (ch == ':') {
+      curtok = src;
+      if (!saw_xdigit) {
+        if (colonp) {
+          goto enoent;
+        }
+        colonp = tp;
+        continue;
+      } else if (*src == '\0') {
+        goto enoent;
+      }
+      if (tp + NS_INT16SZ > endp) {
+        goto enoent;
+      }
+      *tp++        = (unsigned char)(val >> 8) & 0xff;
+      *tp++        = (unsigned char)val & 0xff;
+      saw_xdigit   = 0;
+      count_xdigit = 0;
+      val          = 0;
+      continue;
+    }
+    if (ch == '.' && ((tp + NS_INADDRSZ) <= endp) &&
+        ares_inet_net_pton_ipv4(curtok, tp, NS_INADDRSZ) > 0) {
+      tp         += NS_INADDRSZ;
+      saw_xdigit  = 0;
+      break; /* '\0' was seen by inet_pton4(). */
+    }
+    goto enoent;
+  }
+  if (saw_xdigit) {
+    if (tp + NS_INT16SZ > endp) {
+      goto enoent;
+    }
+    *tp++ = (unsigned char)(val >> 8) & 0xff;
+    *tp++ = (unsigned char)val & 0xff;
+  }
+  if (colonp != NULL) {
+    /*
+     * Since some memmove()'s erroneously fail to handle
+     * overlapping regions, we'll do the shift by hand.
+     */
+    const int n = (int)(tp - colonp);
+    int       i;
+
+    if (tp == endp) {
+      goto enoent;
+    }
+    for (i = 1; i <= n; i++) {
+      endp[-i]      = colonp[n - i];
+      colonp[n - i] = 0;
+    }
+    tp = endp;
+  }
+  if (tp != endp) {
+    goto enoent;
+  }
+
+  memcpy(dst, tmp, NS_IN6ADDRSZ);
+  return 1;
+
+enoent:
+  SET_SOCKERRNO(ENOENT);
+  return -1;
+}
+
+static int ares_inet_net_pton_ipv6(const char *src, unsigned char *dst,
+                                   size_t size)
+{
+  struct ares_in6_addr in6;
+  int                  ret;
+  size_t               bits;
+  size_t               bytes;
+  char                 buf[INET6_ADDRSTRLEN + sizeof("/128")];
+  char                *sep;
+
+  if (ares_strlen(src) >= sizeof buf) {
+    SET_SOCKERRNO(EMSGSIZE);
+    return -1;
+  }
+  ares_strcpy(buf, src, sizeof buf);
+
+  sep = strchr(buf, '/');
+  if (sep != NULL) {
+    *sep++ = '\0';
+  }
+
+  ret = ares_inet_pton6(buf, (unsigned char *)&in6);
+  if (ret != 1) {
+    return -1;
+  }
+
+  if (sep == NULL) {
+    bits = 128;
+  } else {
+    if (!getbits(sep, &bits)) {
+      SET_SOCKERRNO(ENOENT);
+      return -1;
+    }
+  }
+
+  bytes = (bits + 7) / 8;
+  if (bytes > size) {
+    SET_SOCKERRNO(EMSGSIZE);
+    return -1;
+  }
+  memcpy(dst, &in6, bytes);
+  return (int)bits;
+}
+
+/*
+ * int
+ * inet_net_pton(af, src, dst, size)
+ *      convert network number from presentation to network format.
+ *      accepts hex octets, hex strings, decimal octets, and /CIDR.
+ *      "size" is in bytes and describes "dst".
+ * return:
+ *      number of bits, either imputed classfully or specified with /CIDR,
+ *      or -1 if some failure occurred (check errno).  ENOENT means it was
+ *      not a valid network specification.
+ * author:
+ *      Paul Vixie (ISC), June 1996
+ *
+ */
+int ares_inet_net_pton(int af, const char *src, void *dst, size_t size)
+{
+  switch (af) {
+    case AF_INET:
+      return ares_inet_net_pton_ipv4(src, dst, size);
+    case AF_INET6:
+      return ares_inet_net_pton_ipv6(src, dst, size);
+    default:
+      return -1;
+  }
+}
+
+int ares_inet_pton(int af, const char *src, void *dst)
+{
+  int    result;
+  size_t size;
+
+  if (af == AF_INET) {
+    size = sizeof(struct in_addr);
+  } else if (af == AF_INET6) {
+    size = sizeof(struct ares_in6_addr);
+  } else {
+    SET_SOCKERRNO(EAFNOSUPPORT);
+    return -1;
+  }
+  result = ares_inet_net_pton(af, src, dst, size);
+  if (result == -1 && SOCKERRNO == ENOENT) {
+    return 0;
+  }
+  return (result > -1) ? 1 : -1;
+}

package/node/third_party/c-ares/src/lib/inet_ntop.c

@@ -0,0 +1,219 @@
+/*
+ * Copyright (c) 2004 by Internet Systems Consortium, Inc. ("ISC")
+ * Copyright (c) 1996-1999 by Internet Software Consortium.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
+ * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "ares_private.h"
+
+#ifdef HAVE_NETINET_IN_H
+#  include <netinet/in.h>
+#endif
+#ifdef HAVE_ARPA_INET_H
+#  include <arpa/inet.h>
+#endif
+
+#include "ares_nameser.h"
+#include "ares_ipv6.h"
+
+#ifdef USE_WINSOCK
+#  define SOCKERRNO        ((int)WSAGetLastError())
+#  define SET_SOCKERRNO(x) (WSASetLastError((int)(x)))
+#  undef EMSGSIZE
+#  define EMSGSIZE WSAEMSGSIZE
+#  undef ENOENT
+#  define ENOENT WSA_INVALID_PARAMETER
+#  undef EAFNOSUPPORT
+#  define EAFNOSUPPORT WSAEAFNOSUPPORT
+#  undef ENOSPC
+#  define ENOSPC WSA_INVALID_PARAMETER
+#else
+#  define SOCKERRNO        (errno)
+#  define SET_SOCKERRNO(x) (errno = (x))
+#endif
+
+/*
+ * WARNING: Don't even consider trying to compile this on a system where
+ * sizeof(int) < 4.  sizeof(int) > 4 is fine; all the world's not a VAX.
+ */
+
+static const char *inet_ntop4(const unsigned char *src, char *dst, size_t size);
+static const char *inet_ntop6(const unsigned char *src, char *dst, size_t size);
+
+/* char *
+ * inet_ntop(af, src, dst, size)
+ *     convert a network format address to presentation format.
+ * return:
+ *     pointer to presentation format address (`dst'), or NULL (see errno).
+ * author:
+ *     Paul Vixie, 1996.
+ */
+const char        *ares_inet_ntop(int af, const void *src, char *dst,
+                                  ares_socklen_t size)
+{
+  switch (af) {
+    case AF_INET:
+      return inet_ntop4(src, dst, (size_t)size);
+    case AF_INET6:
+      return inet_ntop6(src, dst, (size_t)size);
+    default:
+      break;
+  }
+  SET_SOCKERRNO(EAFNOSUPPORT);
+  return NULL;
+}
+
+/* const char *
+ * inet_ntop4(src, dst, size)
+ *     format an IPv4 address
+ * return:
+ *     `dst' (as a const)
+ * notes:
+ *     (1) uses no statics
+ *     (2) takes a unsigned char* not an in_addr as input
+ * author:
+ *     Paul Vixie, 1996.
+ */
+static const char *inet_ntop4(const unsigned char *src, char *dst, size_t size)
+{
+  static const char fmt[] = "%u.%u.%u.%u";
+  char              tmp[sizeof("255.255.255.255")];
+
+  if (size < sizeof(tmp)) {
+    SET_SOCKERRNO(ENOSPC);
+    return NULL;
+  }
+
+  if ((size_t)snprintf(tmp, sizeof(tmp), fmt, src[0], src[1], src[2], src[3]) >=
+      size) {
+    SET_SOCKERRNO(ENOSPC);
+    return NULL;
+  }
+  ares_strcpy(dst, tmp, size);
+  return dst;
+}
+
+/* const char *
+ * inet_ntop6(src, dst, size)
+ *     convert IPv6 binary address into presentation (printable) format
+ * author:
+ *     Paul Vixie, 1996.
+ */
+static const char *inet_ntop6(const unsigned char *src, char *dst, size_t size)
+{
+  /*
+   * Note that int32_t and int16_t need only be "at least" large enough
+   * to contain a value of the specified size.  On some systems, like
+   * Crays, there is no such thing as an integer variable with 16 bits.
+   * Keep this in mind if you think this function should have been coded
+   * to use pointer overlays.  All the world's not a VAX.
+   */
+  char  tmp[sizeof("ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255")];
+  char *tp;
+
+  struct {
+    ares_ssize_t base;
+    size_t       len;
+  } best, cur;
+
+  unsigned int words[NS_IN6ADDRSZ / NS_INT16SZ];
+  size_t       i;
+
+  /*
+   * Preprocess:
+   *  Copy the input (bytewise) array into a wordwise array.
+   *  Find the longest run of 0x00's in src[] for :: shorthanding.
+   */
+  memset(words, '\0', sizeof(words));
+  for (i = 0; i < NS_IN6ADDRSZ; i++) {
+    words[i / 2] |= (unsigned int)(src[i] << ((1 - (i % 2)) << 3));
+  }
+  best.base = -1;
+  best.len  = 0;
+  cur.base  = -1;
+  cur.len   = 0;
+  for (i = 0; i < (NS_IN6ADDRSZ / NS_INT16SZ); i++) {
+    if (words[i] == 0) {
+      if (cur.base == -1) {
+        cur.base = (ares_ssize_t)i;
+        cur.len  = 1;
+      } else {
+        cur.len++;
+      }
+    } else {
+      if (cur.base != -1) {
+        if (best.base == -1 || cur.len > best.len) {
+          best = cur;
+        }
+        cur.base = -1;
+      }
+    }
+  }
+  if (cur.base != -1) {
+    if (best.base == -1 || cur.len > best.len) {
+      best = cur;
+    }
+  }
+  if (best.base != -1 && best.len < 2) {
+    best.base = -1;
+  }
+
+  /*
+   * Format the result.
+   */
+  tp = tmp;
+  for (i = 0; i < (NS_IN6ADDRSZ / NS_INT16SZ); i++) {
+    /* Are we inside the best run of 0x00's? */
+    if (best.base != -1 && i >= (size_t)best.base &&
+        i < ((size_t)best.base + best.len)) {
+      if (i == (size_t)best.base) {
+        *tp++ = ':';
+      }
+      continue;
+    }
+    /* Are we following an initial run of 0x00s or any real hex? */
+    if (i != 0) {
+      *tp++ = ':';
+    }
+    /* Is this address an encapsulated IPv4? */
+    if (i == 6 && best.base == 0 &&
+        (best.len == 6 || (best.len == 7 && words[7] != 0x0001) ||
+         (best.len == 5 && words[5] == 0xffff))) {
+      if (!inet_ntop4(src + 12, tp, sizeof(tmp) - (size_t)(tp - tmp))) {
+        return (NULL);
+      }
+      tp += ares_strlen(tp);
+      break;
+    }
+    tp += snprintf(tp, sizeof(tmp) - (size_t)(tp - tmp), "%x", words[i]);
+  }
+  /* Was it a trailing run of 0x00's? */
+  if (best.base != -1 &&
+      ((size_t)best.base + best.len) == (NS_IN6ADDRSZ / NS_INT16SZ)) {
+    *tp++ = ':';
+  }
+  *tp++ = '\0';
+
+  /*
+   * Check for overflow, copy, and we're done.
+   */
+  if ((size_t)(tp - tmp) > size) {
+    SET_SOCKERRNO(ENOSPC);
+    return NULL;
+  }
+  ares_strcpy(dst, tmp, size);
+  return dst;
+}