visaljs 0.0.9 → 0.0.11

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

@@ -0,0 +1,300 @@
+/* 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_NETINET_IN_H
+#  include <netinet/in.h>
+#endif
+#include "ares_nameser.h"
+
+static unsigned short generate_unique_qid(ares_channel_t *channel)
+{
+  unsigned short id;
+
+  do {
+    id = ares_generate_new_id(channel->rand_state);
+  } while (ares_htable_szvp_get(channel->queries_by_qid, id, NULL));
+
+  return id;
+}
+
+/* https://datatracker.ietf.org/doc/html/draft-vixie-dnsext-dns0x20-00 */
+static ares_status_t ares_apply_dns0x20(ares_channel_t    *channel,
+                                        ares_dns_record_t *dnsrec)
+{
+  ares_status_t status = ARES_SUCCESS;
+  const char   *name   = NULL;
+  char          dns0x20name[256];
+  unsigned char randdata[256 / 8];
+  size_t        len;
+  size_t        remaining_bits;
+  size_t        total_bits;
+  size_t        i;
+
+  status = ares_dns_record_query_get(dnsrec, 0, &name, NULL, NULL);
+  if (status != ARES_SUCCESS) {
+    goto done;
+  }
+
+  len = ares_strlen(name);
+  if (len == 0) {
+    return ARES_SUCCESS;
+  }
+
+  if (len >= sizeof(dns0x20name)) {
+    status = ARES_EBADNAME;
+    goto done;
+  }
+
+  memset(dns0x20name, 0, sizeof(dns0x20name));
+
+  /* Fetch the minimum amount of random data we'd need for the string, which
+   * is 1 bit per byte */
+  total_bits     = ((len + 7) / 8) * 8;
+  remaining_bits = total_bits;
+  ares_rand_bytes(channel->rand_state, randdata, total_bits / 8);
+
+  /* Randomly apply 0x20 to name */
+  for (i = 0; i < len; i++) {
+    size_t bit;
+
+    /* Only apply 0x20 to alpha characters */
+    if (!ares_isalpha(name[i])) {
+      dns0x20name[i] = name[i];
+      continue;
+    }
+
+    /* coin flip */
+    bit = total_bits - remaining_bits;
+    if (randdata[bit / 8] & (1 << (bit % 8))) {
+      dns0x20name[i] = name[i] | 0x20;                          /* Set 0x20 */
+    } else {
+      dns0x20name[i] = (char)(((unsigned char)name[i]) & 0xDF); /* Unset 0x20 */
+    }
+    remaining_bits--;
+  }
+
+  status = ares_dns_record_query_set_name(dnsrec, 0, dns0x20name);
+
+done:
+  return status;
+}
+
+ares_status_t ares_send_nolock(ares_channel_t *channel, ares_server_t *server,
+                               ares_send_flags_t        flags,
+                               const ares_dns_record_t *dnsrec,
+                               ares_callback_dnsrec callback, void *arg,
+                               unsigned short *qid)
+{
+  ares_query_t            *query;
+  ares_timeval_t           now;
+  ares_status_t            status;
+  unsigned short           id          = generate_unique_qid(channel);
+  const ares_dns_record_t *dnsrec_resp = NULL;
+
+  ares_tvnow(&now);
+
+  if (ares_slist_len(channel->servers) == 0) {
+    callback(arg, ARES_ENOSERVER, 0, NULL);
+    return ARES_ENOSERVER;
+  }
+
+  if (!(flags & ARES_SEND_FLAG_NOCACHE)) {
+    /* Check query cache */
+    status = ares_qcache_fetch(channel, &now, dnsrec, &dnsrec_resp);
+    if (status != ARES_ENOTFOUND) {
+      /* ARES_SUCCESS means we retrieved the cache, anything else is a critical
+       * failure, all result in termination */
+      callback(arg, status, 0, dnsrec_resp);
+      return status;
+    }
+  }
+
+  /* Allocate space for query and allocated fields. */
+  query = ares_malloc(sizeof(ares_query_t));
+  if (!query) {
+    callback(arg, ARES_ENOMEM, 0, NULL); /* LCOV_EXCL_LINE: OutOfMemory */
+    return ARES_ENOMEM;                  /* LCOV_EXCL_LINE: OutOfMemory */
+  }
+  memset(query, 0, sizeof(*query));
+
+  query->channel      = channel;
+  query->qid          = id;
+  query->timeout.sec  = 0;
+  query->timeout.usec = 0;
+  query->using_tcp =
+    (channel->flags & ARES_FLAG_USEVC) ? ARES_TRUE : ARES_FALSE;
+
+  /* Duplicate Query */
+  status = ares_dns_record_duplicate_ex(&query->query, dnsrec);
+  if (status != ARES_SUCCESS) {
+    /* Sometimes we might get a EBADRESP response from duplicate due to
+     * the way it works (write and parse), rewrite it to EBADQUERY. */
+    if (status == ARES_EBADRESP) {
+      status = ARES_EBADQUERY;
+    }
+    ares_free(query);
+    callback(arg, status, 0, NULL);
+    return status;
+  }
+
+  ares_dns_record_set_id(query->query, id);
+
+  if (channel->flags & ARES_FLAG_DNS0x20 && !query->using_tcp) {
+    status = ares_apply_dns0x20(channel, query->query);
+    if (status != ARES_SUCCESS) {
+      /* LCOV_EXCL_START: OutOfMemory */
+      callback(arg, status, 0, NULL);
+      ares_free_query(query);
+      return status;
+      /* LCOV_EXCL_STOP */
+    }
+  }
+
+  /* Fill in query arguments. */
+  query->callback = callback;
+  query->arg      = arg;
+
+  /* Initialize query status. */
+  query->try_count = 0;
+
+  if (flags & ARES_SEND_FLAG_NORETRY) {
+    query->no_retries = ARES_TRUE;
+  }
+
+  query->error_status = ARES_SUCCESS;
+  query->timeouts     = 0;
+
+  /* Initialize our list nodes. */
+  query->node_queries_by_timeout = NULL;
+  query->node_queries_to_conn    = NULL;
+
+  /* Chain the query into the list of all queries. */
+  query->node_all_queries = ares_llist_insert_last(channel->all_queries, query);
+  if (query->node_all_queries == NULL) {
+    /* LCOV_EXCL_START: OutOfMemory */
+    callback(arg, ARES_ENOMEM, 0, NULL);
+    ares_free_query(query);
+    return ARES_ENOMEM;
+    /* LCOV_EXCL_STOP */
+  }
+
+  /* Keep track of queries bucketed by qid, so we can process DNS
+   * responses quickly.
+   */
+  if (!ares_htable_szvp_insert(channel->queries_by_qid, query->qid, query)) {
+    /* LCOV_EXCL_START: OutOfMemory */
+    callback(arg, ARES_ENOMEM, 0, NULL);
+    ares_free_query(query);
+    return ARES_ENOMEM;
+    /* LCOV_EXCL_STOP */
+  }
+
+  /* Perform the first query action. */
+
+  status = ares_send_query(server, query, &now);
+  if (status == ARES_SUCCESS && qid) {
+    *qid = id;
+  }
+  return status;
+}
+
+ares_status_t ares_send_dnsrec(ares_channel_t          *channel,
+                               const ares_dns_record_t *dnsrec,
+                               ares_callback_dnsrec callback, void *arg,
+                               unsigned short *qid)
+{
+  ares_status_t status;
+
+  if (channel == NULL) {
+    return ARES_EFORMERR; /* LCOV_EXCL_LINE: DefensiveCoding */
+  }
+
+  ares_channel_lock(channel);
+
+  status = ares_send_nolock(channel, NULL, 0, dnsrec, callback, arg, qid);
+
+  ares_channel_unlock(channel);
+
+  return status;
+}
+
+void ares_send(ares_channel_t *channel, const unsigned char *qbuf, int qlen,
+               ares_callback callback, void *arg)
+{
+  ares_dns_record_t *dnsrec = NULL;
+  ares_status_t      status;
+  void              *carg = NULL;
+
+  if (channel == NULL) {
+    return;
+  }
+
+  /* Verify that the query is at least long enough to hold the header. */
+  if (qlen < HFIXEDSZ || qlen >= (1 << 16)) {
+    callback(arg, ARES_EBADQUERY, 0, NULL, 0);
+    return;
+  }
+
+  status = ares_dns_parse(qbuf, (size_t)qlen, 0, &dnsrec);
+  if (status != ARES_SUCCESS) {
+    callback(arg, (int)status, 0, NULL, 0);
+    return;
+  }
+
+  carg = ares_dnsrec_convert_arg(callback, arg);
+  if (carg == NULL) {
+    /* LCOV_EXCL_START: OutOfMemory */
+    status = ARES_ENOMEM;
+    ares_dns_record_destroy(dnsrec);
+    callback(arg, (int)status, 0, NULL, 0);
+    return;
+    /* LCOV_EXCL_STOP */
+  }
+
+  ares_send_dnsrec(channel, dnsrec, ares_dnsrec_convert_cb, carg, NULL);
+
+  ares_dns_record_destroy(dnsrec);
+}
+
+size_t ares_queue_active_queries(const ares_channel_t *channel)
+{
+  size_t len;
+
+  if (channel == NULL) {
+    return 0;
+  }
+
+  ares_channel_lock(channel);
+
+  len = ares_llist_len(channel->all_queries);
+
+  ares_channel_unlock(channel);
+
+  return len;
+}