visaljs 0.0.9 → 0.0.11

package/node/third_party/c-ares/src/lib/ares_inet_net_pton.h

@@ -0,0 +1,31 @@
+/* MIT License
+ *
+ * Copyright (c) 2005 Daniel Stenberg
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * SPDX-License-Identifier: MIT
+ */
+#ifndef HEADER_CARES_INET_NET_PTON_H
+#define HEADER_CARES_INET_NET_PTON_H
+
+int ares_inet_net_pton(int af, const char *src, void *dst, size_t size);
+
+#endif /* HEADER_CARES_INET_NET_PTON_H */

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

@@ -0,0 +1,631 @@
+/* MIT License
+ *
+ * Copyright (c) 1998 Massachusetts Institute of Technology
+ * Copyright (c) 2007 Daniel Stenberg
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "ares_private.h"
+
+#ifdef HAVE_SYS_PARAM_H
+#  include <sys/param.h>
+#endif
+
+#ifdef HAVE_NETINET_IN_H
+#  include <netinet/in.h>
+#endif
+
+#ifdef HAVE_NETDB_H
+#  include <netdb.h>
+#endif
+
+#ifdef HAVE_ARPA_INET_H
+#  include <arpa/inet.h>
+#endif
+
+#include "ares_nameser.h"
+
+#if defined(ANDROID) || defined(__ANDROID__)
+#  include <sys/system_properties.h>
+#  include "ares_android.h"
+/* From the Bionic sources */
+#  define DNS_PROP_NAME_PREFIX "net.dns"
+#  define MAX_DNS_PROPERTIES   8
+#endif
+
+#if defined(CARES_USE_LIBRESOLV)
+#  include <resolv.h>
+#endif
+
+#if defined(USE_WINSOCK) && defined(HAVE_IPHLPAPI_H)
+#  include <iphlpapi.h>
+#endif
+
+#include "ares_inet_net_pton.h"
+#include "event/ares_event.h"
+
+int ares_init(ares_channel_t **channelptr)
+{
+  return ares_init_options(channelptr, NULL, 0);
+}
+
+static int ares_query_timeout_cmp_cb(const void *arg1, const void *arg2)
+{
+  const ares_query_t *q1 = arg1;
+  const ares_query_t *q2 = arg2;
+
+  if (q1->timeout.sec > q2->timeout.sec) {
+    return 1;
+  }
+  if (q1->timeout.sec < q2->timeout.sec) {
+    return -1;
+  }
+
+  if (q1->timeout.usec > q2->timeout.usec) {
+    return 1;
+  }
+  if (q1->timeout.usec < q2->timeout.usec) {
+    return -1;
+  }
+
+  return 0;
+}
+
+static int server_sort_cb(const void *data1, const void *data2)
+{
+  const ares_server_t *s1 = data1;
+  const ares_server_t *s2 = data2;
+
+  if (s1->consec_failures < s2->consec_failures) {
+    return -1;
+  }
+  if (s1->consec_failures > s2->consec_failures) {
+    return 1;
+  }
+
+  /* Among servers with the same failure count, prefer the one that failed
+   * least recently so that a server that went down long ago (and may have
+   * since recovered) is tried before one that just failed.  This also keeps
+   * retries rotating across servers once the failure counts saturate at
+   * SERVER_CONSEC_FAILURES_CAP.  Healthy servers all have a zeroed retry
+   * time and fall through to configuration order. */
+  if (s1->next_retry_time.sec != s2->next_retry_time.sec) {
+    return s1->next_retry_time.sec < s2->next_retry_time.sec ? -1 : 1;
+  }
+  if (s1->next_retry_time.usec != s2->next_retry_time.usec) {
+    return s1->next_retry_time.usec < s2->next_retry_time.usec ? -1 : 1;
+  }
+
+  if (s1->idx < s2->idx) {
+    return -1;
+  }
+  if (s1->idx > s2->idx) {
+    return 1;
+  }
+  return 0;
+}
+
+static void server_destroy_cb(void *data)
+{
+  if (data == NULL) {
+    return; /* LCOV_EXCL_LINE: DefensiveCoding */
+  }
+  ares_destroy_server(data);
+}
+
+static ares_status_t init_by_defaults(ares_channel_t *channel)
+{
+  char         *hostname = NULL;
+  ares_status_t rc       = ARES_SUCCESS;
+#ifdef HAVE_GETHOSTNAME
+  const char *dot;
+#endif
+  struct ares_addr addr;
+  ares_llist_t    *sconfig = NULL;
+
+  /* Enable EDNS by default */
+  if (!(channel->optmask & ARES_OPT_FLAGS)) {
+    channel->flags = ARES_FLAG_EDNS;
+  }
+  if (channel->ednspsz == 0) {
+    channel->ednspsz = EDNSPACKETSZ;
+  }
+
+  if (channel->timeout == 0) {
+    channel->timeout = DEFAULT_TIMEOUT;
+  }
+
+  if (channel->tries == 0) {
+    channel->tries = DEFAULT_TRIES;
+  }
+
+  if (ares_slist_len(channel->servers) == 0) {
+    /* Add a default local named server to the channel unless configured not
+     * to (in which case return an error).
+     */
+    if (channel->flags & ARES_FLAG_NO_DFLT_SVR) {
+      rc = ARES_ENOSERVER;
+      goto error;
+    }
+
+    addr.family            = AF_INET;
+    addr.addr.addr4.s_addr = htonl(INADDR_LOOPBACK);
+
+    rc = ares_sconfig_append(channel, &sconfig, &addr, 0, 0, NULL);
+    if (rc != ARES_SUCCESS) {
+      goto error; /* LCOV_EXCL_LINE: OutOfMemory */
+    }
+
+    rc = ares_servers_update(channel, sconfig, ARES_FALSE);
+    ares_llist_destroy(sconfig);
+
+    if (rc != ARES_SUCCESS) {
+      goto error;
+    }
+  }
+
+  if (channel->ndomains == 0) {
+    /* Derive a default domain search list from the kernel hostname,
+     * or set it to empty if the hostname isn't helpful.
+     */
+#ifndef HAVE_GETHOSTNAME
+    channel->ndomains = 0; /* default to none */
+#else
+    size_t len        = 256;
+    channel->ndomains = 0; /* default to none */
+
+    hostname = ares_malloc(len);
+    if (!hostname) {
+      rc = ARES_ENOMEM; /* LCOV_EXCL_LINE: OutOfMemory */
+      goto error;       /* LCOV_EXCL_LINE: OutOfMemory */
+    }
+
+    if (gethostname(hostname, (GETHOSTNAME_TYPE_ARG2)len) != 0) {
+      /* Lets not treat a gethostname failure as critical, since we
+       * are ok if gethostname doesn't even exist */
+      *hostname = '\0';
+    }
+
+    dot = strchr(hostname, '.');
+    if (dot) {
+      /* a dot was found */
+      channel->domains = ares_malloc(sizeof(char *));
+      if (!channel->domains) {
+        rc = ARES_ENOMEM; /* LCOV_EXCL_LINE: OutOfMemory */
+        goto error;       /* LCOV_EXCL_LINE: OutOfMemory */
+      }
+      channel->domains[0] = ares_strdup(dot + 1);
+      if (!channel->domains[0]) {
+        rc = ARES_ENOMEM; /* LCOV_EXCL_LINE: OutOfMemory */
+        goto error;       /* LCOV_EXCL_LINE: OutOfMemory */
+      }
+      channel->ndomains = 1;
+    }
+#endif
+  }
+
+  if (channel->nsort == 0) {
+    channel->sortlist = NULL;
+  }
+
+  if (!channel->lookups) {
+    channel->lookups = ares_strdup("fb");
+    if (!channel->lookups) {
+      rc = ARES_ENOMEM; /* LCOV_EXCL_LINE: OutOfMemory */
+    }
+  }
+
+  /* Set default fields for server failover behavior */
+  if (!(channel->optmask & ARES_OPT_SERVER_FAILOVER)) {
+    channel->server_retry_chance = DEFAULT_SERVER_RETRY_CHANCE;
+    channel->server_retry_delay  = DEFAULT_SERVER_RETRY_DELAY;
+  }
+
+error:
+  if (hostname) {
+    ares_free(hostname);
+  }
+
+  return rc;
+}
+
+int ares_init_options(ares_channel_t           **channelptr,
+                      const struct ares_options *options, int optmask)
+{
+  ares_channel_t *channel;
+  ares_status_t   status = ARES_SUCCESS;
+
+  if (ares_library_initialized() != ARES_SUCCESS) {
+    return ARES_ENOTINITIALIZED; /* LCOV_EXCL_LINE: n/a on non-WinSock */
+  }
+
+  channel = ares_malloc_zero(sizeof(*channel));
+  if (!channel) {
+    *channelptr = NULL;
+    return ARES_ENOMEM;
+  }
+
+  /* We are in a good state */
+  channel->sys_up = ARES_TRUE;
+
+  /* One option where zero is valid, so set default value here */
+  channel->ndots = 1;
+
+  status = ares_channel_threading_init(channel);
+  if (status != ARES_SUCCESS) {
+    goto done;
+  }
+
+  /* Generate random key */
+  channel->rand_state = ares_init_rand_state();
+  if (channel->rand_state == NULL) {
+    status = ARES_ENOMEM;
+    DEBUGF(fprintf(stderr, "Error: init_id_key failed: %s\n",
+                   ares_strerror(status)));
+    goto done;
+  }
+
+  ares_set_socket_functions_def(channel);
+
+  /* Initialize Server List */
+  channel->servers =
+    ares_slist_create(channel->rand_state, server_sort_cb, server_destroy_cb);
+  if (channel->servers == NULL) {
+    status = ARES_ENOMEM;
+    goto done;
+  }
+
+  /* Initialize our lists of queries */
+  channel->all_queries = ares_llist_create(NULL);
+  if (channel->all_queries == NULL) {
+    status = ARES_ENOMEM;
+    goto done;
+  }
+
+  channel->queries_by_qid = ares_htable_szvp_create(NULL);
+  if (channel->queries_by_qid == NULL) {
+    status = ARES_ENOMEM;
+    goto done;
+  }
+
+  channel->queries_by_timeout =
+    ares_slist_create(channel->rand_state, ares_query_timeout_cmp_cb, NULL);
+  if (channel->queries_by_timeout == NULL) {
+    status = ARES_ENOMEM;
+    goto done;
+  }
+
+  channel->connnode_by_socket = ares_htable_asvp_create(NULL);
+  if (channel->connnode_by_socket == NULL) {
+    status = ARES_ENOMEM;
+    goto done;
+  }
+
+  /* Initialize configuration by each of the four sources, from highest
+   * precedence to lowest.
+   */
+
+  status = ares_init_by_options(channel, options, optmask);
+  if (status != ARES_SUCCESS) {
+    DEBUGF(fprintf(stderr, "Error: init_by_options failed: %s\n",
+                   ares_strerror(status)));
+    /* If we fail to apply user-specified options, fail the whole init process
+     */
+    goto done;
+  }
+
+  /* Go ahead and let it initialize the query cache even if the ttl is 0 and
+   * completely unused.  This reduces the number of different code paths that
+   * might be followed even if there is a minor performance hit. */
+  status = ares_qcache_create(channel->rand_state, channel->qcache_max_ttl,
+                              &channel->qcache);
+  if (status != ARES_SUCCESS) {
+    goto done; /* LCOV_EXCL_LINE: OutOfMemory */
+  }
+
+  if (status == ARES_SUCCESS) {
+    status = ares_init_by_sysconfig(channel);
+    if (status != ARES_SUCCESS) {
+      DEBUGF(fprintf(stderr, "Error: init_by_sysconfig failed: %s\n",
+                     ares_strerror(status)));
+    }
+  }
+
+  /*
+   * No matter what failed or succeeded, seed defaults to provide
+   * useful behavior for things that we missed.
+   */
+  status = init_by_defaults(channel);
+  if (status != ARES_SUCCESS) {
+    DEBUGF(fprintf(stderr, "Error: init_by_defaults failed: %s\n",
+                   ares_strerror(status)));
+    goto done;
+  }
+
+  /* Initialize the event thread */
+  if (channel->optmask & ARES_OPT_EVENT_THREAD) {
+    ares_event_thread_t *e = NULL;
+
+    status = ares_event_thread_init(channel);
+    if (status != ARES_SUCCESS) {
+      goto done; /* LCOV_EXCL_LINE: UntestablePath */
+    }
+
+    /* Initialize monitor for configuration changes.  In some rare cases,
+     * ARES_ENOTIMP may occur (OpenWatcom), ignore this. */
+    e      = channel->sock_state_cb_data;
+    status = ares_event_configchg_init(&e->configchg, e);
+    if (status != ARES_SUCCESS && status != ARES_ENOTIMP) {
+      DEBUGF(fprintf(stderr, "Error: ares_event_configchg_init failed: %s\n",
+                     ares_strerror(status)));
+    }
+    status = ARES_SUCCESS;
+  }
+
+done:
+  if (status != ARES_SUCCESS) {
+    ares_destroy(channel);
+    return (int)status;
+  }
+
+  *channelptr = channel;
+  return ARES_SUCCESS;
+}
+
+static void *ares_reinit_thread(void *arg)
+{
+  ares_channel_t *channel = arg;
+  ares_status_t   status;
+
+  /* ares_init_by_sysconfig() will lock when applying the config, but not
+   * when retrieving. */
+  status = ares_init_by_sysconfig(channel);
+  if (status != ARES_SUCCESS) {
+    DEBUGF(fprintf(stderr, "Error: init_by_sysconfig failed: %s\n",
+                   ares_strerror(status)));
+  }
+
+  ares_channel_lock(channel);
+
+  /* Flush cached queries on reinit */
+  if (status == ARES_SUCCESS && channel->qcache) {
+    ares_qcache_flush(channel->qcache);
+  }
+
+  channel->reinit_pending = ARES_FALSE;
+  ares_channel_unlock(channel);
+
+  return NULL;
+}
+
+ares_status_t ares_reinit(ares_channel_t *channel)
+{
+  ares_status_t status = ARES_SUCCESS;
+
+  if (channel == NULL) {
+    return ARES_EFORMERR;
+  }
+
+  ares_channel_lock(channel);
+
+  /* If a reinit is already in process, lets not do it again. Or if we are
+   * shutting down, skip. */
+  if (!channel->sys_up || channel->reinit_pending) {
+    ares_channel_unlock(channel);
+    return ARES_SUCCESS;
+  }
+  channel->reinit_pending = ARES_TRUE;
+  ares_channel_unlock(channel);
+
+  if (ares_threadsafety()) {
+    /* clean up the prior reinit process's thread.  We know the thread isn't
+     * running since reinit_pending was false */
+    if (channel->reinit_thread != NULL) {
+      void *rv;
+      ares_thread_join(channel->reinit_thread, &rv);
+      channel->reinit_thread = NULL;
+    }
+
+    /* Spawn a new thread */
+    status =
+      ares_thread_create(&channel->reinit_thread, ares_reinit_thread, channel);
+    if (status != ARES_SUCCESS) {
+      /* LCOV_EXCL_START: UntestablePath */
+      ares_channel_lock(channel);
+      channel->reinit_pending = ARES_FALSE;
+      ares_channel_unlock(channel);
+      /* LCOV_EXCL_STOP */
+    }
+  } else {
+    /* Threading support not available, call directly */
+    ares_reinit_thread(channel);
+  }
+
+  return status;
+}
+
+/* ares_dup() duplicates a channel handle with all its options and returns a
+   new channel handle */
+int ares_dup(ares_channel_t **dest, const ares_channel_t *src)
+{
+  struct ares_options opts;
+  ares_status_t       rc;
+  int                 optmask;
+
+  if (dest == NULL || src == NULL) {
+    return ARES_EFORMERR;
+  }
+
+  *dest = NULL; /* in case of failure return NULL explicitly */
+
+  /* First get the options supported by the old ares_save_options() function,
+     which is most of them */
+  rc = (ares_status_t)ares_save_options(src, &opts, &optmask);
+  if (rc != ARES_SUCCESS) {
+    ares_destroy_options(&opts);
+    goto done;
+  }
+
+  /* Then create the new channel with those options */
+  rc = (ares_status_t)ares_init_options(dest, &opts, optmask);
+
+  /* destroy the options copy to not leak any memory */
+  ares_destroy_options(&opts);
+
+  if (rc != ARES_SUCCESS) {
+    goto done;
+  }
+
+  ares_channel_lock(src);
+  /* Now clone the options that ares_save_options() doesn't support, but are
+   * user-provided */
+  (*dest)->sock_create_cb               = src->sock_create_cb;
+  (*dest)->sock_create_cb_data          = src->sock_create_cb_data;
+  (*dest)->sock_config_cb               = src->sock_config_cb;
+  (*dest)->sock_config_cb_data          = src->sock_config_cb_data;
+  memcpy(&(*dest)->sock_funcs, &(src->sock_funcs), sizeof((*dest)->sock_funcs));
+  (*dest)->sock_func_cb_data            = src->sock_func_cb_data;
+  (*dest)->legacy_sock_funcs            = src->legacy_sock_funcs;
+  (*dest)->legacy_sock_funcs_cb_data    = src->legacy_sock_funcs_cb_data;
+  (*dest)->server_state_cb              = src->server_state_cb;
+  (*dest)->server_state_cb_data         = src->server_state_cb_data;
+  (*dest)->notify_pending_write_cb      = src->notify_pending_write_cb;
+  (*dest)->notify_pending_write_cb_data = src->notify_pending_write_cb_data;
+  (*dest)->query_enqueue_cb             = src->query_enqueue_cb;
+  (*dest)->query_enqueue_cb_data        = src->query_enqueue_cb_data;
+
+  ares_strcpy((*dest)->local_dev_name, src->local_dev_name,
+              sizeof((*dest)->local_dev_name));
+  (*dest)->local_ip4 = src->local_ip4;
+  memcpy((*dest)->local_ip6, src->local_ip6, sizeof(src->local_ip6));
+  ares_channel_unlock(src);
+
+  /* Servers are a bit unique as ares_init_options() only allows ipv4 servers
+   * and not a port per server, but there are other user specified ways, that
+   * too will toggle the optmask ARES_OPT_SERVERS to let us know.  If that's
+   * the case, pull them in.
+   *
+   * We don't want to clone system-configuration servers though.
+   *
+   * We must use the "csv" format to get things like link-local address support
+   */
+
+  if (optmask & ARES_OPT_SERVERS) {
+    char *csv = ares_get_servers_csv(src);
+    if (csv == NULL) {
+      /* LCOV_EXCL_START: OutOfMemory */
+      ares_destroy(*dest);
+      *dest = NULL;
+      rc    = ARES_ENOMEM;
+      goto done;
+      /* LCOV_EXCL_STOP */
+    }
+
+    rc = (ares_status_t)ares_set_servers_ports_csv(*dest, csv);
+    ares_free_string(csv);
+    if (rc != ARES_SUCCESS) {
+      /* LCOV_EXCL_START: OutOfMemory */
+      ares_destroy(*dest);
+      *dest = NULL;
+      goto done;
+      /* LCOV_EXCL_STOP */
+    }
+  }
+
+  rc = ARES_SUCCESS;
+done:
+  return (int)rc; /* everything went fine */
+}
+
+void ares_set_local_ip4(ares_channel_t *channel, unsigned int local_ip)
+{
+  if (channel == NULL) {
+    return;
+  }
+  ares_channel_lock(channel);
+  channel->local_ip4 = local_ip;
+  ares_channel_unlock(channel);
+}
+
+/* local_ip6 should be 16 bytes in length */
+void ares_set_local_ip6(ares_channel_t *channel, const unsigned char *local_ip6)
+{
+  if (channel == NULL) {
+    return;
+  }
+  ares_channel_lock(channel);
+  memcpy(&channel->local_ip6, local_ip6, sizeof(channel->local_ip6));
+  ares_channel_unlock(channel);
+}
+
+/* local_dev_name should be null terminated. */
+void ares_set_local_dev(ares_channel_t *channel, const char *local_dev_name)
+{
+  if (channel == NULL) {
+    return;
+  }
+
+  ares_channel_lock(channel);
+  ares_strcpy(channel->local_dev_name, local_dev_name,
+              sizeof(channel->local_dev_name));
+  channel->local_dev_name[sizeof(channel->local_dev_name) - 1] = 0;
+  ares_channel_unlock(channel);
+}
+
+int ares_set_sortlist(ares_channel_t *channel, const char *sortstr)
+{
+  size_t           nsort    = 0;
+  struct apattern *sortlist = NULL;
+  ares_status_t    status;
+
+  if (!channel) {
+    return ARES_ENODATA;
+  }
+  ares_channel_lock(channel);
+
+  status = ares_parse_sortlist(&sortlist, &nsort, sortstr);
+  if (status == ARES_SUCCESS && sortlist) {
+    if (channel->sortlist) {
+      ares_free(channel->sortlist);
+    }
+    channel->sortlist = sortlist;
+    channel->nsort    = nsort;
+
+    /* Save sortlist as if it was passed in as an option */
+    channel->optmask |= ARES_OPT_SORTLIST;
+  }
+  ares_channel_unlock(channel);
+  return (int)status;
+}
+
+void ares_set_query_enqueue_cb(ares_channel_t       *channel,
+                               ares_query_enqueue_cb callback,
+                               void                 *user_data)
+{
+  if (channel == NULL) {
+    return;
+  }
+
+  channel->query_enqueue_cb      = callback;
+  channel->query_enqueue_cb_data = user_data;
+}