grpc 1.74.1 → 1.75.0.pre1

data/third_party/cares/cares/src/lib/ares_ipv6.h

@@ -1,29 +1,51 @@
-
-/* Copyright (C) 2005 by Dominick Meglio
+/* MIT License
+ *
+ * Copyright (c) 2005 Dominick Meglio
+ *
+ * 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.
  *
- * Permission to use, copy, modify, and distribute this
- * software and its documentation for any purpose and without
- * fee is hereby granted, provided that the above copyright
- * notice appear in all copies and that both that copyright
- * notice and this permission notice appear in supporting
- * documentation, and that the name of M.I.T. not be used in
- * advertising or publicity pertaining to distribution of the
- * software without specific, written prior permission.
- * M.I.T. makes no representations about the suitability of
- * this software for any purpose.  It is provided "as is"
- * without express or implied warranty.
+ * 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_IPV6_H
 #define ARES_IPV6_H
 
+#ifdef HAVE_NETINET6_IN6_H
+#  include <netinet6/in6.h>
+#endif
+
+#if defined(USE_WINSOCK)
+#  if defined(HAVE_IPHLPAPI_H)
+#    include <iphlpapi.h>
+#  endif
+#  if defined(HAVE_NETIOAPI_H)
+#    include <netioapi.h>
+#  endif
+#endif
+
 #ifndef HAVE_PF_INET6
-#define PF_INET6 AF_INET6
+#  define PF_INET6 AF_INET6
 #endif
 
 #ifndef HAVE_STRUCT_SOCKADDR_IN6
-struct sockaddr_in6
-{
+struct sockaddr_in6 {
   unsigned short       sin6_family;
   unsigned short       sin6_port;
   unsigned long        sin6_flowinfo;
@@ -32,21 +54,19 @@ struct sockaddr_in6
 };
 #endif
 
-typedef union
-{
+typedef union {
   struct sockaddr     sa;
   struct sockaddr_in  sa4;
   struct sockaddr_in6 sa6;
 } ares_sockaddr;
 
 #ifndef HAVE_STRUCT_ADDRINFO
-struct addrinfo
-{
+struct addrinfo {
   int              ai_flags;
   int              ai_family;
   int              ai_socktype;
   int              ai_protocol;
-  ares_socklen_t   ai_addrlen;   /* Follow rfc3493 struct addrinfo */
+  ares_socklen_t   ai_addrlen; /* Follow rfc3493 struct addrinfo */
   char            *ai_canonname;
   struct sockaddr *ai_addr;
   struct addrinfo *ai_next;
@@ -54,28 +74,38 @@ struct addrinfo
 #endif
 
 #ifndef NS_IN6ADDRSZ
-#ifndef HAVE_STRUCT_IN6_ADDR
+#  ifndef HAVE_STRUCT_IN6_ADDR
 /* We cannot have it set to zero, so we pick a fixed value here */
-#define NS_IN6ADDRSZ 16
-#else
-#define NS_IN6ADDRSZ sizeof(struct in6_addr)
-#endif
+#    define NS_IN6ADDRSZ 16
+#  else
+#    define NS_IN6ADDRSZ sizeof(struct in6_addr)
+#  endif
 #endif
 
 #ifndef NS_INADDRSZ
-#define NS_INADDRSZ sizeof(struct in_addr)
+#  define NS_INADDRSZ sizeof(struct in_addr)
 #endif
 
 #ifndef NS_INT16SZ
-#define NS_INT16SZ 2
+#  define NS_INT16SZ 2
 #endif
 
-#ifndef IF_NAMESIZE
-#ifdef IFNAMSIZ
-#define IF_NAMESIZE IFNAMSIZ
-#else
-#define IF_NAMESIZE 256
+/* Windows XP Compatibility with later MSVC/Mingw versions */
+#if defined(_WIN32)
+#  if !defined(IF_MAX_STRING_SIZE)
+#    define IF_MAX_STRING_SIZE 256 /* =256 in <ifdef.h> */
+#  endif
+#  if !defined(NDIS_IF_MAX_STRING_SIZE)
+#    define NDIS_IF_MAX_STRING_SIZE IF_MAX_STRING_SIZE   /* =256 in <ifdef.h> */
+#  endif
 #endif
+
+#ifndef IF_NAMESIZE
+#  ifdef IFNAMSIZ
+#    define IF_NAMESIZE IFNAMSIZ
+#  else
+#    define IF_NAMESIZE 32
+#  endif
 #endif
 
 /* Defined in inet_net_pton.c for no particular reason. */

data/third_party/cares/cares/src/lib/ares_library_init.c

@@ -1,29 +1,36 @@
-
-/* Copyright 1998 by the Massachusetts Institute of Technology.
- * Copyright (C) 2004-2009 by Daniel Stenberg
+/* 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.
  *
- * Permission to use, copy, modify, and distribute this
- * software and its documentation for any purpose and without
- * fee is hereby granted, provided that the above copyright
- * notice appear in all copies and that both that copyright
- * notice and this permission notice appear in supporting
- * documentation, and that the name of M.I.T. not be used in
- * advertising or publicity pertaining to distribution of the
- * software without specific, written prior permission.
- * M.I.T. makes no representations about the suitability of
- * this software for any purpose.  It is provided "as is"
- * without express or implied warranty.
+ * SPDX-License-Identifier: MIT
  */
 
-#include "ares_setup.h"
-
-#include "ares.h"
 #include "ares_private.h"
 
 /* library-private global and unique instance vars */
 
 #if defined(ANDROID) || defined(__ANDROID__)
-#include "ares_android.h"
+#  include "ares_android.h"
 #endif
 
 /* library-private global vars with source visibility restricted to this file */
@@ -33,31 +40,77 @@ static int          ares_init_flags;
 
 /* library-private global vars with visibility across the whole library */
 
-/* Some systems may return either NULL or a valid pointer on malloc(0).  c-ares should
- * never call malloc(0) so lets return NULL so we're more likely to find an issue if it
- * were to occur. */
+/* Some systems may return either NULL or a valid pointer on malloc(0).  c-ares
+ * should never call malloc(0) so lets return NULL so we're more likely to find
+ * an issue if it were to occur. */
 
-static void *default_malloc(size_t size) { if (size == 0) { return NULL; } return malloc(size); }
+static void        *default_malloc(size_t size)
+{
+  if (size == 0) {
+    return NULL;
+  }
+  return malloc(size);
+}
 
-#if defined(WIN32)
-/* We need indirections to handle Windows DLL rules. */
-static void *default_realloc(void *p, size_t size) { return realloc(p, size); }
-static void default_free(void *p) { free(p); }
-#else
-# define default_realloc realloc
-# define default_free free
-#endif
-void *(*ares_malloc)(size_t size) = default_malloc;
-void *(*ares_realloc)(void *ptr, size_t size) = default_realloc;
-void (*ares_free)(void *ptr) = default_free;
+static void *default_realloc(void *p, size_t size)
+{
+  return realloc(p, size);
+}
+
+static void default_free(void *p)
+{
+  free(p);
+}
+
+static void *(*__ares_malloc)(size_t size)             = default_malloc;
+static void *(*__ares_realloc)(void *ptr, size_t size) = default_realloc;
+static void (*__ares_free)(void *ptr)                  = default_free;
+
+void *ares_malloc(size_t size)
+{
+  return __ares_malloc(size);
+}
+
+void *ares_realloc(void *ptr, size_t size)
+{
+  return __ares_realloc(ptr, size);
+}
+
+void ares_free(void *ptr)
+{
+  __ares_free(ptr);
+}
+
+void *ares_malloc_zero(size_t size)
+{
+  void *ptr = ares_malloc(size);
+  if (ptr != NULL) {
+    memset(ptr, 0, size);
+  }
+
+  return ptr;
+}
+
+void *ares_realloc_zero(void *ptr, size_t orig_size, size_t new_size)
+{
+  void *p = ares_realloc(ptr, new_size);
+  if (p == NULL) {
+    return NULL;
+  }
+
+  if (new_size > orig_size) {
+    memset((unsigned char *)p + orig_size, 0, new_size - orig_size);
+  }
+
+  return p;
+}
 
 int ares_library_init(int flags)
 {
-  if (ares_initialized)
-    {
-      ares_initialized++;
-      return ARES_SUCCESS;
-    }
+  if (ares_initialized) {
+    ares_initialized++;
+    return ARES_SUCCESS;
+  }
   ares_initialized++;
 
   /* NOTE: ARES_LIB_INIT_WIN32 flag no longer used */
@@ -67,28 +120,31 @@ int ares_library_init(int flags)
   return ARES_SUCCESS;
 }
 
-int ares_library_init_mem(int flags,
-                          void *(*amalloc)(size_t size),
+int ares_library_init_mem(int flags, void *(*amalloc)(size_t size),
                           void (*afree)(void *ptr),
                           void *(*arealloc)(void *ptr, size_t size))
 {
-  if (amalloc)
-    ares_malloc = amalloc;
-  if (arealloc)
-    ares_realloc = arealloc;
-  if (afree)
-    ares_free = afree;
+  if (amalloc) {
+    __ares_malloc = amalloc;
+  }
+  if (arealloc) {
+    __ares_realloc = arealloc;
+  }
+  if (afree) {
+    __ares_free = afree;
+  }
   return ares_library_init(flags);
 }
 
-
 void ares_library_cleanup(void)
 {
-  if (!ares_initialized)
+  if (!ares_initialized) {
     return;
+  }
   ares_initialized--;
-  if (ares_initialized)
+  if (ares_initialized) {
     return;
+  }
 
   /* NOTE: ARES_LIB_INIT_WIN32 flag no longer used */
 
@@ -97,17 +153,17 @@ void ares_library_cleanup(void)
 #endif
 
   ares_init_flags = ARES_LIB_INIT_NONE;
-  ares_malloc = malloc;
-  ares_realloc = realloc;
-  ares_free = free;
+  __ares_malloc   = default_malloc;
+  __ares_realloc  = default_realloc;
+  __ares_free     = default_free;
 }
 
-
 int ares_library_initialized(void)
 {
 #ifdef USE_WINSOCK
-  if (!ares_initialized)
+  if (!ares_initialized) {
     return ARES_ENOTINITIALIZED;
+  }
 #endif
   return ARES_SUCCESS;
 }

data/third_party/cares/cares/src/lib/ares_metrics.c

@@ -0,0 +1,261 @@
+/* MIT License
+ *
+ * Copyright (c) 2024 Brad House
+ *
+ * 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
+ */
+
+
+/* IMPLEMENTATION NOTES
+ * ====================
+ *
+ * With very little effort we should be able to determine fairly proper timeouts
+ * we can use based on prior query history.  We track in order to be able to
+ * auto-scale when network conditions change (e.g. maybe there is a provider
+ * failover and timings change due to that).  Apple appears to do this within
+ * their system resolver in MacOS.  Obviously we should have a minimum, maximum,
+ * and initial value to make sure the algorithm doesn't somehow go off the
+ * rails.
+ *
+ * Values:
+ * - Minimum Timeout: 250ms (approximate RTT half-way around the globe)
+ * - Maximum Timeout: 5000ms (Recommended timeout in RFC 1123), can be reduced
+ *   by ARES_OPT_MAXTIMEOUTMS, but otherwise the bound specified by the option
+ *   caps the retry timeout.
+ * - Initial Timeout: User-specified via configuration or ARES_OPT_TIMEOUTMS
+ * - Average latency multiplier: 5x (a local DNS server returning a cached value
+ *   will be quicker than if it needs to recurse so we need to account for this)
+ * - Minimum Count for Average: 3.  This is the minimum number of queries we
+ *   need to form an average for the bucket.
+ *
+ * Per-server buckets for tracking latency over time (these are ephemeral
+ * meaning they don't persist once a channel is destroyed).  We record both the
+ * current timespan for the bucket and the immediate preceding timespan in case
+ * of roll-overs we can still maintain recent metrics for calculations:
+ * - 1 minute
+ * - 15 minutes
+ * - 1 hr
+ * - 1 day
+ * - since inception
+ *
+ * Each bucket would contain:
+ * - timestamp (divided by interval)
+ * - minimum latency
+ * - maximum latency
+ * - total time
+ * - count
+ * NOTE: average latency is (total time / count), we will calculate this
+ *       dynamically when needed
+ *
+ * Basic algorithm for calculating timeout to use would be:
+ * - Scan from most recent bucket to least recent
+ * - Check timestamp of bucket, if doesn't match current time, continue to next
+ *   bucket
+ * - Check count of bucket, if its not at least the "Minimum Count for Average",
+ *   check the previous bucket, otherwise continue to next bucket
+ * - If we reached the end with no bucket match, use "Initial Timeout"
+ * - If bucket is selected, take ("total time" / count) as Average latency,
+ *   multiply by "Average Latency Multiplier", bound by "Minimum Timeout" and
+ *   "Maximum Timeout"
+ * NOTE: The timeout calculated may not be the timeout used.  If we are retrying
+ * the query on the same server another time, then it will use a larger value
+ *
+ * On each query reply where the response is legitimate (proper response or
+ * NXDOMAIN) and not something like a server error:
+ * - Cycle through each bucket in order
+ * - Check timestamp of bucket against current timestamp, if out of date
+ *   overwrite previous entry with values, clear current values
+ * - Compare current minimum and maximum recorded latency against query time and
+ *   adjust if necessary
+ * - Increment "count" by 1 and "total time" by the query time
+ *
+ * Other Notes:
+ * - This is always-on, the only user-configurable value is the initial
+ *   timeout which will simply re-uses the current option.
+ * - Minimum and Maximum latencies for a bucket are currently unused but are
+ *   there in case we find a need for them in the future.
+ */
+
+#include "ares_private.h"
+
+/*! Minimum timeout value. Chosen due to it being approximately RTT half-way
+ *  around the world */
+#define MIN_TIMEOUT_MS 250
+
+/*! Multiplier to apply to average latency to come up with an initial timeout */
+#define AVG_TIMEOUT_MULTIPLIER 5
+
+/*! Upper timeout bounds, only used if channel->maxtimeout not set */
+#define MAX_TIMEOUT_MS 5000
+
+/*! Minimum queries required to form an average */
+#define MIN_COUNT_FOR_AVERAGE 3
+
+static time_t ares_metric_timestamp(ares_server_bucket_t  bucket,
+                                    const ares_timeval_t *now,
+                                    ares_bool_t           is_previous)
+{
+  time_t divisor = 1; /* Silence bogus MSVC warning by setting default value */
+
+  switch (bucket) {
+    case ARES_METRIC_1MINUTE:
+      divisor = 60;
+      break;
+    case ARES_METRIC_15MINUTES:
+      divisor = 15 * 60;
+      break;
+    case ARES_METRIC_1HOUR:
+      divisor = 60 * 60;
+      break;
+    case ARES_METRIC_1DAY:
+      divisor = 24 * 60 * 60;
+      break;
+    case ARES_METRIC_INCEPTION:
+      return is_previous ? 0 : 1;
+    case ARES_METRIC_COUNT:
+      return 0; /* Invalid! */
+  }
+
+  if (is_previous) {
+    if (divisor >= now->sec) {
+      return 0;
+    }
+    return (time_t)((now->sec - divisor) / divisor);
+  }
+
+  return (time_t)(now->sec / divisor);
+}
+
+void ares_metrics_record(const ares_query_t *query, ares_server_t *server,
+                         ares_status_t status, const ares_dns_record_t *dnsrec)
+{
+  ares_timeval_t       now;
+  ares_timeval_t       tvdiff;
+  unsigned int         query_ms;
+  ares_dns_rcode_t     rcode;
+  ares_server_bucket_t i;
+
+  if (status != ARES_SUCCESS) {
+    return;
+  }
+
+  if (server == NULL) {
+    return;
+  }
+
+  ares_tvnow(&now);
+
+  rcode = ares_dns_record_get_rcode(dnsrec);
+  if (rcode != ARES_RCODE_NOERROR && rcode != ARES_RCODE_NXDOMAIN) {
+    return;
+  }
+
+  ares_timeval_diff(&tvdiff, &query->ts, &now);
+  query_ms = (unsigned int)((tvdiff.sec * 1000) + (tvdiff.usec / 1000));
+  if (query_ms == 0) {
+    query_ms = 1;
+  }
+
+  /* Place in each bucket */
+  for (i = 0; i < ARES_METRIC_COUNT; i++) {
+    time_t ts = ares_metric_timestamp(i, &now, ARES_FALSE);
+
+    /* Copy metrics to prev and clear */
+    if (ts != server->metrics[i].ts) {
+      server->metrics[i].prev_ts          = server->metrics[i].ts;
+      server->metrics[i].prev_total_ms    = server->metrics[i].total_ms;
+      server->metrics[i].prev_total_count = server->metrics[i].total_count;
+      server->metrics[i].ts               = ts;
+      server->metrics[i].latency_min_ms   = 0;
+      server->metrics[i].latency_max_ms   = 0;
+      server->metrics[i].total_ms         = 0;
+      server->metrics[i].total_count      = 0;
+    }
+
+    if (server->metrics[i].latency_min_ms == 0 ||
+        server->metrics[i].latency_min_ms > query_ms) {
+      server->metrics[i].latency_min_ms = query_ms;
+    }
+
+    if (query_ms > server->metrics[i].latency_max_ms) {
+      server->metrics[i].latency_max_ms = query_ms;
+    }
+
+    server->metrics[i].total_count++;
+    server->metrics[i].total_ms += (ares_uint64_t)query_ms;
+  }
+}
+
+size_t ares_metrics_server_timeout(const ares_server_t  *server,
+                                   const ares_timeval_t *now)
+{
+  const ares_channel_t *channel = server->channel;
+  ares_server_bucket_t  i;
+  size_t                timeout_ms = 0;
+  size_t                max_timeout_ms;
+
+  for (i = 0; i < ARES_METRIC_COUNT; i++) {
+    time_t ts = ares_metric_timestamp(i, now, ARES_FALSE);
+
+    /* This ts has been invalidated, see if we should use the previous
+     * time period */
+    if (ts != server->metrics[i].ts ||
+        server->metrics[i].total_count < MIN_COUNT_FOR_AVERAGE) {
+      time_t prev_ts = ares_metric_timestamp(i, now, ARES_TRUE);
+      if (prev_ts != server->metrics[i].prev_ts ||
+          server->metrics[i].prev_total_count < MIN_COUNT_FOR_AVERAGE) {
+        /* Move onto next bucket */
+        continue;
+      }
+      /* Calculate average time for previous bucket */
+      timeout_ms = (size_t)(server->metrics[i].prev_total_ms /
+                            server->metrics[i].prev_total_count);
+    } else {
+      /* Calculate average time for current bucket*/
+      timeout_ms =
+        (size_t)(server->metrics[i].total_ms / server->metrics[i].total_count);
+    }
+
+    /* Multiply average by constant to get timeout value */
+    timeout_ms *= AVG_TIMEOUT_MULTIPLIER;
+    break;
+  }
+
+  /* If we're here, that means its the first query for the server, so we just
+   * use the initial default timeout */
+  if (timeout_ms == 0) {
+    timeout_ms = channel->timeout;
+  }
+
+  /* don't go below lower bounds */
+  if (timeout_ms < MIN_TIMEOUT_MS) {
+    timeout_ms = MIN_TIMEOUT_MS;
+  }
+
+  /* don't go above upper bounds */
+  max_timeout_ms = channel->maxtimeout ? channel->maxtimeout : MAX_TIMEOUT_MS;
+  if (timeout_ms > max_timeout_ms) {
+    timeout_ms = max_timeout_ms;
+  }
+
+  return timeout_ms;
+}