visaljs 0.0.9 → 0.0.11

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

@@ -0,0 +1,168 @@
+/* MIT License
+ *
+ * Copyright (c) 2009 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"
+#include <stddef.h>
+#include <assert.h>
+#include "ares_data.h"
+
+/*
+** ares_free_data() - c-ares external API function.
+**
+** This function must be used by the application to free data memory that
+** has been internally allocated by some c-ares function and for which a
+** pointer has already been returned to the calling application. The list
+** of c-ares functions returning pointers that must be free'ed using this
+** function is:
+**
+**   ares_get_servers()
+**   ares_parse_srv_reply()
+**   ares_parse_txt_reply()
+*/
+
+void ares_free_data(void *dataptr)
+{
+  while (dataptr != NULL) {
+    struct ares_data *ptr;
+    void             *next_data = NULL;
+
+#ifdef __INTEL_COMPILER
+#  pragma warning(push)
+#  pragma warning(disable : 1684)
+    /* 1684: conversion from pointer to same-sized integral type */
+#endif
+
+    ptr = (void *)((char *)dataptr - offsetof(struct ares_data, data));
+
+#ifdef __INTEL_COMPILER
+#  pragma warning(pop)
+#endif
+
+    if (ptr->mark != ARES_DATATYPE_MARK) {
+      return;
+    }
+
+    switch (ptr->type) {
+      case ARES_DATATYPE_MX_REPLY:
+        next_data = ptr->data.mx_reply.next;
+        ares_free(ptr->data.mx_reply.host);
+        break;
+
+      case ARES_DATATYPE_SRV_REPLY:
+        next_data = ptr->data.srv_reply.next;
+        ares_free(ptr->data.srv_reply.host);
+        break;
+
+      case ARES_DATATYPE_URI_REPLY:
+        next_data = ptr->data.uri_reply.next;
+        ares_free(ptr->data.uri_reply.uri);
+        break;
+
+      case ARES_DATATYPE_TXT_REPLY:
+      case ARES_DATATYPE_TXT_EXT:
+        next_data = ptr->data.txt_reply.next;
+        ares_free(ptr->data.txt_reply.txt);
+        break;
+
+      case ARES_DATATYPE_ADDR_NODE:
+        next_data = ptr->data.addr_node.next;
+        break;
+
+      case ARES_DATATYPE_ADDR_PORT_NODE:
+        next_data = ptr->data.addr_port_node.next;
+        break;
+
+      case ARES_DATATYPE_NAPTR_REPLY:
+        next_data = ptr->data.naptr_reply.next;
+        ares_free(ptr->data.naptr_reply.flags);
+        ares_free(ptr->data.naptr_reply.service);
+        ares_free(ptr->data.naptr_reply.regexp);
+        ares_free(ptr->data.naptr_reply.replacement);
+        break;
+
+      case ARES_DATATYPE_SOA_REPLY:
+        ares_free(ptr->data.soa_reply.nsname);
+        ares_free(ptr->data.soa_reply.hostmaster);
+        break;
+
+      case ARES_DATATYPE_CAA_REPLY:
+        next_data = ptr->data.caa_reply.next;
+        ares_free(ptr->data.caa_reply.property);
+        ares_free(ptr->data.caa_reply.value);
+        break;
+
+      default:
+        return;
+    }
+
+    ares_free(ptr);
+    dataptr = next_data;
+  }
+}
+
+/*
+** ares_malloc_data() - c-ares internal helper function.
+**
+** This function allocates memory for a c-ares private ares_data struct
+** for the specified ares_datatype, initializes c-ares private fields
+** and zero initializes those which later might be used from the public
+** API. It returns an interior pointer which can be passed by c-ares
+** functions to the calling application, and that must be free'ed using
+** c-ares external API function ares_free_data().
+*/
+
+void *ares_malloc_data(ares_datatype type)
+{
+  struct ares_data *ptr;
+
+  ptr = ares_malloc_zero(sizeof(*ptr));
+  if (!ptr) {
+    return NULL;
+  }
+
+  switch (type) {
+    case ARES_DATATYPE_MX_REPLY:
+    case ARES_DATATYPE_SRV_REPLY:
+    case ARES_DATATYPE_URI_REPLY:
+    case ARES_DATATYPE_TXT_EXT:
+    case ARES_DATATYPE_TXT_REPLY:
+    case ARES_DATATYPE_CAA_REPLY:
+    case ARES_DATATYPE_ADDR_NODE:
+    case ARES_DATATYPE_ADDR_PORT_NODE:
+    case ARES_DATATYPE_NAPTR_REPLY:
+    case ARES_DATATYPE_SOA_REPLY:
+      break;
+
+    default:
+      ares_free(ptr);
+      return NULL;
+  }
+
+  ptr->mark = ARES_DATATYPE_MARK;
+  ptr->type = type;
+
+  return &ptr->data;
+}

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

@@ -0,0 +1,92 @@
+/* MIT License
+ *
+ * Copyright (c) 2009 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 __ARES_DATA_H
+#define __ARES_DATA_H
+
+typedef enum {
+  ARES_DATATYPE_UNKNOWN = 1, /* unknown data type     - introduced in 1.7.0 */
+  ARES_DATATYPE_SRV_REPLY,   /* struct ares_srv_reply - introduced in 1.7.0 */
+  ARES_DATATYPE_TXT_REPLY,   /* struct ares_txt_reply - introduced in 1.7.0 */
+  ARES_DATATYPE_TXT_EXT,     /* struct ares_txt_ext   - introduced in 1.11.0 */
+  ARES_DATATYPE_ADDR_NODE,   /* struct ares_addr_node - introduced in 1.7.1 */
+  ARES_DATATYPE_MX_REPLY,    /* struct ares_mx_reply   - introduced in 1.7.2 */
+  ARES_DATATYPE_NAPTR_REPLY, /* struct ares_naptr_reply - introduced in 1.7.6 */
+  ARES_DATATYPE_SOA_REPLY,   /* struct ares_soa_reply - introduced in 1.9.0 */
+  ARES_DATATYPE_URI_REPLY,   /* struct ares_uri_reply */
+#if 0
+  ARES_DATATYPE_ADDR6TTL,     /* struct ares_addrttl   */
+  ARES_DATATYPE_ADDRTTL,      /* struct ares_addr6ttl  */
+  ARES_DATATYPE_HOSTENT,      /* struct hostent        */
+  ARES_DATATYPE_OPTIONS,      /* struct ares_options   */
+#endif
+  ARES_DATATYPE_ADDR_PORT_NODE, /* struct ares_addr_port_node - introduced
+                                   in 1.11.0 */
+  ARES_DATATYPE_CAA_REPLY, /* struct ares_caa_reply   - introduced in 1.17 */
+  ARES_DATATYPE_LAST       /* not used              - introduced in 1.7.0 */
+} ares_datatype;
+
+#define ARES_DATATYPE_MARK 0xbead
+
+/*
+ * ares_data struct definition is internal to c-ares and shall not
+ * be exposed by the public API in order to allow future changes
+ * and extensions to it without breaking ABI.  This will be used
+ * internally by c-ares as the container of multiple types of data
+ * dynamically allocated for which a reference will be returned
+ * to the calling application.
+ *
+ * c-ares API functions returning a pointer to c-ares internally
+ * allocated data will actually be returning an interior pointer
+ * into this ares_data struct.
+ *
+ * All this is 'invisible' to the calling application, the only
+ * requirement is that this kind of data must be free'ed by the
+ * calling application using ares_free_data() with the pointer
+ * it has received from a previous c-ares function call.
+ */
+
+struct ares_data {
+  ares_datatype type; /* Actual data type identifier. */
+  unsigned int  mark; /* Private ares_data signature. */
+
+  union {
+    struct ares_txt_reply      txt_reply;
+    struct ares_txt_ext        txt_ext;
+    struct ares_srv_reply      srv_reply;
+    struct ares_addr_node      addr_node;
+    struct ares_addr_port_node addr_port_node;
+    struct ares_mx_reply       mx_reply;
+    struct ares_naptr_reply    naptr_reply;
+    struct ares_soa_reply      soa_reply;
+    struct ares_caa_reply      caa_reply;
+    struct ares_uri_reply      uri_reply;
+  } data;
+};
+
+void *ares_malloc_data(ares_datatype type);
+
+
+#endif /* __ARES_DATA_H */

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

@@ -0,0 +1,159 @@
+/* MIT License
+ *
+ * Copyright (c) 1998 Massachusetts Institute of Technology
+ * Copyright (c) 2004 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"
+#include "event/ares_event.h"
+#include <assert.h>
+
+void ares_destroy(ares_channel_t *channel)
+{
+  size_t             i;
+  ares_llist_node_t *node = NULL;
+
+  if (channel == NULL) {
+    return;
+  }
+
+  /* Mark as being shutdown */
+  ares_channel_lock(channel);
+  channel->sys_up = ARES_FALSE;
+  ares_channel_unlock(channel);
+
+  /* Disable configuration change monitoring.  We can't hold a lock because
+   * some cleanup routines, such as on Windows, are synchronous operations.
+   * What we've observed is a system config change event was triggered right
+   * at shutdown time and it tries to take the channel lock and the destruction
+   * waits for that event to complete before it continues so we get a channel
+   * lock deadlock at shutdown if we hold a lock during this process. */
+  if (channel->optmask & ARES_OPT_EVENT_THREAD) {
+    ares_event_thread_t *e = channel->sock_state_cb_data;
+    if (e && e->configchg) {
+      ares_event_configchg_destroy(e->configchg);
+      e->configchg = NULL;
+    }
+  }
+
+  /* Wait for reinit thread to exit if there was one pending, can't be
+   * holding a lock as the thread may take locks. */
+  if (channel->reinit_thread != NULL) {
+    void *rv;
+    ares_thread_join(channel->reinit_thread, &rv);
+    channel->reinit_thread = NULL;
+  }
+
+  /* Lock because callbacks will be triggered, and any system-generated
+   * callbacks need to hold a channel lock. */
+  ares_channel_lock(channel);
+
+  /* Destroy all queries */
+  node = ares_llist_node_first(channel->all_queries);
+  while (node != NULL) {
+    ares_llist_node_t *next  = ares_llist_node_next(node);
+    ares_query_t      *query = ares_llist_node_claim(node);
+
+    query->node_all_queries = NULL;
+    query->callback(query->arg, ARES_EDESTRUCTION, 0, NULL);
+    ares_free_query(query);
+
+    node = next;
+  }
+
+  ares_queue_notify_empty(channel);
+
+#ifndef NDEBUG
+  /* Freeing the query should remove it from all the lists in which it sits,
+   * so all query lists should be empty now.
+   */
+  assert(ares_llist_len(channel->all_queries) == 0);
+  assert(ares_htable_szvp_num_keys(channel->queries_by_qid) == 0);
+  assert(ares_slist_len(channel->queries_by_timeout) == 0);
+#endif
+
+  ares_destroy_servers_state(channel);
+
+#ifndef NDEBUG
+  assert(ares_htable_asvp_num_keys(channel->connnode_by_socket) == 0);
+#endif
+
+  /* No more callbacks will be triggered after this point, unlock */
+  ares_channel_unlock(channel);
+
+  /* Shut down the event thread */
+  if (channel->optmask & ARES_OPT_EVENT_THREAD) {
+    ares_event_thread_destroy(channel);
+  }
+
+  if (channel->domains) {
+    for (i = 0; i < channel->ndomains; i++) {
+      ares_free(channel->domains[i]);
+    }
+    ares_free(channel->domains);
+  }
+
+  ares_llist_destroy(channel->all_queries);
+  ares_slist_destroy(channel->queries_by_timeout);
+  ares_htable_szvp_destroy(channel->queries_by_qid);
+  ares_htable_asvp_destroy(channel->connnode_by_socket);
+
+  ares_free(channel->sortlist);
+  ares_free(channel->lookups);
+  ares_free(channel->resolvconf_path);
+  ares_free(channel->hosts_path);
+  ares_destroy_rand_state(channel->rand_state);
+
+  ares_hosts_file_destroy(channel->hf);
+
+  ares_qcache_destroy(channel->qcache);
+
+  ares_channel_threading_destroy(channel);
+
+  ares_free(channel);
+}
+
+void ares_destroy_server(ares_server_t *server)
+{
+  if (server == NULL) {
+    return; /* LCOV_EXCL_LINE: DefensiveCoding */
+  }
+
+  ares_close_sockets(server);
+  ares_llist_destroy(server->connections);
+  ares_free(server);
+}
+
+void ares_destroy_servers_state(ares_channel_t *channel)
+{
+  ares_slist_node_t *node;
+
+  while ((node = ares_slist_node_first(channel->servers)) != NULL) {
+    ares_server_t *server = ares_slist_node_claim(node);
+    ares_destroy_server(server);
+  }
+
+  ares_slist_destroy(channel->servers);
+  channel->servers = NULL;
+}

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

@@ -0,0 +1,54 @@
+/* MIT License
+ *
+ * Copyright (c) 1998 Massachusetts Institute of Technology
+ * Copyright (c) The c-ares project and its contributors
+ *
+ * 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_NETDB_H
+#  include <netdb.h>
+#endif
+
+void ares_free_hostent(struct hostent *host)
+{
+  char **p;
+
+  if (!host) {
+    return;
+  }
+
+  ares_free(host->h_name);
+  for (p = host->h_aliases; p && *p; p++) {
+    ares_free(*p);
+  }
+  ares_free(host->h_aliases);
+  if (host->h_addr_list) {
+    size_t i;
+    for (i=0; host->h_addr_list[i] != NULL; i++) {
+      ares_free(host->h_addr_list[i]);
+    }
+    ares_free(host->h_addr_list);
+  }
+  ares_free(host);
+}

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

@@ -0,0 +1,33 @@
+/* MIT License
+ *
+ * Copyright (c) 2000 Massachusetts Institute of Technology
+ * Copyright (c) The c-ares project and its contributors
+ *
+ * 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"
+
+void ares_free_string(void *str)
+{
+  ares_free(str);
+}

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

@@ -0,0 +1,67 @@
+/* MIT License
+ *
+ * Copyright (c) 1998 Massachusetts Institute of Technology
+ * Copyright (c) 2019 Andrew Selivanov
+ *
+ * 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_NETDB_H
+#  include <netdb.h>
+#endif
+
+void ares_freeaddrinfo_cnames(struct ares_addrinfo_cname *head)
+{
+  struct ares_addrinfo_cname *current;
+  while (head) {
+    current = head;
+    head    = head->next;
+    ares_free(current->alias);
+    ares_free(current->name);
+    ares_free(current);
+  }
+}
+
+void ares_freeaddrinfo_nodes(struct ares_addrinfo_node *head)
+{
+  struct ares_addrinfo_node *current;
+  while (head) {
+    current = head;
+    head    = head->ai_next;
+    ares_free(current->ai_addr);
+    ares_free(current);
+  }
+}
+
+void ares_freeaddrinfo(struct ares_addrinfo *ai)
+{
+  if (ai == NULL) {
+    return;
+  }
+  ares_freeaddrinfo_cnames(ai->cnames);
+  ares_freeaddrinfo_nodes(ai->nodes);
+
+  ares_free(ai->name);
+  ares_free(ai);
+}