grpc 1.74.0 → 1.75.0.pre1

data/third_party/cares/cares/src/lib/util/ares_iface_ips.h

@@ -0,0 +1,139 @@
+/* MIT License
+ *
+ * Copyright (c) 2023 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
+ */
+#ifndef __ARES__IFACE_IPS_H
+#define __ARES__IFACE_IPS_H
+
+/*! Flags for interface ip addresses. */
+typedef enum {
+  ARES_IFACE_IP_V4 = 1 << 0,        /*!< IPv4 address. During enumeration if
+                                     *   this flag is set ARES_IFACE_IP_V6
+                                     *   is not, will only enumerate v4
+                                     *   addresses. */
+  ARES_IFACE_IP_V6 = 1 << 1,        /*!< IPv6 address. During enumeration if
+                                     *   this flag is set ARES_IFACE_IP_V4
+                                     *   is not, will only enumerate v6
+                                     *   addresses. */
+  ARES_IFACE_IP_LOOPBACK  = 1 << 2, /*!< Loopback adapter */
+  ARES_IFACE_IP_OFFLINE   = 1 << 3, /*!< Adapter offline */
+  ARES_IFACE_IP_LINKLOCAL = 1 << 4, /*!< Link-local ip address */
+  /*! Default, enumerate all ips for online interfaces, including loopback */
+  ARES_IFACE_IP_DEFAULT = (ARES_IFACE_IP_V4 | ARES_IFACE_IP_V6 |
+                           ARES_IFACE_IP_LOOPBACK | ARES_IFACE_IP_LINKLOCAL)
+} ares_iface_ip_flags_t;
+
+struct ares_iface_ips;
+
+/*! Opaque pointer for holding enumerated interface ip addresses */
+typedef struct ares_iface_ips ares_iface_ips_t;
+
+/*! Destroy ip address enumeration created by ares_iface_ips().
+ *
+ *  \param[in]  ips   Initialized IP address enumeration structure
+ */
+void                          ares_iface_ips_destroy(ares_iface_ips_t *ips);
+
+/*! Enumerate ip addresses on interfaces
+ *
+ *  \param[out]  ips   Returns initialized ip address structure
+ *  \param[in]   flags Flags for enumeration
+ *  \param[in]   name  Interface name to enumerate, or NULL to enumerate all
+ *  \return ARES_ENOMEM on out of memory, ARES_ENOTIMP if not supported on
+ *          the system, ARES_SUCCESS on success
+ */
+ares_status_t                 ares_iface_ips(ares_iface_ips_t    **ips,
+                                             ares_iface_ip_flags_t flags, const char *name);
+
+/*! Count of ips enumerated
+ *
+ * \param[in]  ips   Initialized IP address enumeration structure
+ * \return count
+ */
+size_t                        ares_iface_ips_cnt(const ares_iface_ips_t *ips);
+
+/*! Retrieve interface name
+ *
+ * \param[in]  ips   Initialized IP address enumeration structure
+ * \param[in]  idx   Index of entry to pull
+ * \return interface name
+ */
+const char *ares_iface_ips_get_name(const ares_iface_ips_t *ips, size_t idx);
+
+/*! Retrieve interface address
+ *
+ * \param[in]  ips   Initialized IP address enumeration structure
+ * \param[in]  idx   Index of entry to pull
+ * \return interface address
+ */
+const struct ares_addr *ares_iface_ips_get_addr(const ares_iface_ips_t *ips,
+                                                size_t                  idx);
+
+/*! Retrieve interface address flags
+ *
+ * \param[in]  ips   Initialized IP address enumeration structure
+ * \param[in]  idx   Index of entry to pull
+ * \return interface address flags
+ */
+ares_iface_ip_flags_t   ares_iface_ips_get_flags(const ares_iface_ips_t *ips,
+                                                 size_t                  idx);
+
+/*! Retrieve interface address netmask
+ *
+ * \param[in]  ips   Initialized IP address enumeration structure
+ * \param[in]  idx   Index of entry to pull
+ * \return interface address netmask
+ */
+unsigned char           ares_iface_ips_get_netmask(const ares_iface_ips_t *ips,
+                                                   size_t                  idx);
+
+/*! Retrieve interface ipv6 link local scope
+ *
+ * \param[in]  ips   Initialized IP address enumeration structure
+ * \param[in]  idx   Index of entry to pull
+ * \return interface ipv6 link local scope
+ */
+unsigned int            ares_iface_ips_get_ll_scope(const ares_iface_ips_t *ips,
+                                                    size_t                  idx);
+
+
+/*! Retrieve the interface index (aka link local scope) from the interface
+ *  name.
+ *
+ * \param[in] name  Interface name
+ * \return 0 on failure, index otherwise
+ */
+unsigned int            ares_os_if_nametoindex(const char *name);
+
+/*! Retrieves the interface name from the index (aka link local scope)
+ *
+ * \param[in] index  Interface index (> 0)
+ * \param[in] name   Buffer to hold name
+ * \param[in] name_len Length of provided buffer, must be at least IF_NAMESIZE
+ * \return NULL on failure, or pointer to name on success
+ */
+const char             *ares_os_if_indextoname(unsigned int index, char *name,
+                                               size_t name_len);
+
+#endif

data/third_party/cares/cares/src/lib/util/ares_math.c

@@ -0,0 +1,158 @@
+/* MIT License
+ *
+ * Copyright (c) 2023 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
+ */
+
+#include "ares_private.h"
+
+/* Uses public domain code snippets from
+ * http://graphics.stanford.edu/~seander/bithacks.html */
+
+static unsigned int ares_round_up_pow2_u32(unsigned int n)
+{
+  /* NOTE: if already a power of 2, will return itself, not the next */
+  n--;
+  n |= n >> 1;
+  n |= n >> 2;
+  n |= n >> 4;
+  n |= n >> 8;
+  n |= n >> 16;
+  n++;
+  return n;
+}
+
+static ares_int64_t ares_round_up_pow2_u64(ares_int64_t n)
+{
+  /* NOTE: if already a power of 2, will return itself, not the next */
+  n--;
+  n |= n >> 1;
+  n |= n >> 2;
+  n |= n >> 4;
+  n |= n >> 8;
+  n |= n >> 16;
+  n |= n >> 32;
+  n++;
+  return n;
+}
+
+ares_bool_t ares_is_64bit(void)
+{
+#ifdef _MSC_VER
+#  pragma warning(push)
+#  pragma warning(disable : 4127)
+#endif
+
+  return (sizeof(size_t) == 4) ? ARES_FALSE : ARES_TRUE;
+
+#ifdef _MSC_VER
+#  pragma warning(pop)
+#endif
+}
+
+size_t ares_round_up_pow2(size_t n)
+{
+  if (ares_is_64bit()) {
+    return (size_t)ares_round_up_pow2_u64((ares_int64_t)n);
+  }
+
+  return (size_t)ares_round_up_pow2_u32((unsigned int)n);
+}
+
+size_t ares_log2(size_t n)
+{
+  static const unsigned char tab32[32] = { 0,  1,  28, 2,  29, 14, 24, 3,
+                                           30, 22, 20, 15, 25, 17, 4,  8,
+                                           31, 27, 13, 23, 21, 19, 16, 7,
+                                           26, 12, 18, 6,  11, 5,  10, 9 };
+  static const unsigned char tab64[64] = {
+    63, 0,  58, 1,  59, 47, 53, 2,  60, 39, 48, 27, 54, 33, 42, 3,
+    61, 51, 37, 40, 49, 18, 28, 20, 55, 30, 34, 11, 43, 14, 22, 4,
+    62, 57, 46, 52, 38, 26, 32, 41, 50, 36, 17, 19, 29, 10, 13, 21,
+    56, 45, 25, 31, 35, 16, 9,  12, 44, 24, 15, 8,  23, 7,  6,  5
+  };
+
+  if (!ares_is_64bit()) {
+    return tab32[(n * 0x077CB531) >> 27];
+  }
+
+  return tab64[(n * 0x07EDD5E59A4E28C2) >> 58];
+}
+
+/* x^y */
+size_t ares_pow(size_t x, size_t y)
+{
+  size_t res = 1;
+
+  while (y > 0) {
+    /* If y is odd, multiply x with result */
+    if (y & 1) {
+      res = res * x;
+    }
+
+    /* y must be even now */
+    y = y >> 1; /* y /= 2; */
+    x = x * x;  /* x^2 */
+  }
+
+  return res;
+}
+
+size_t ares_count_digits(size_t n)
+{
+  size_t digits;
+
+  for (digits = 0; n > 0; digits++) {
+    n /= 10;
+  }
+  if (digits == 0) {
+    digits = 1;
+  }
+
+  return digits;
+}
+
+size_t ares_count_hexdigits(size_t n)
+{
+  size_t digits;
+
+  for (digits = 0; n > 0; digits++) {
+    n /= 16;
+  }
+  if (digits == 0) {
+    digits = 1;
+  }
+
+  return digits;
+}
+
+unsigned char ares_count_bits_u8(unsigned char x)
+{
+  /* Implementation obtained from:
+   * http://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetTable */
+#define B2(n) n, n + 1, n + 1, n + 2
+#define B4(n) B2(n), B2(n + 1), B2(n + 1), B2(n + 2)
+#define B6(n) B4(n), B4(n + 1), B4(n + 1), B4(n + 2)
+  static const unsigned char lookup[256] = { B6(0), B6(1), B6(1), B6(2) };
+  return lookup[x];
+}

data/third_party/cares/cares/src/lib/util/ares_math.h

@@ -0,0 +1,45 @@
+/* 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
+ */
+#ifndef __ARES_MATH_H
+#define __ARES_MATH_H
+
+#ifdef _MSC_VER
+typedef __int64          ares_int64_t;
+typedef unsigned __int64 ares_uint64_t;
+#else
+typedef long long          ares_int64_t;
+typedef unsigned long long ares_uint64_t;
+#endif
+
+ares_bool_t   ares_is_64bit(void);
+size_t        ares_round_up_pow2(size_t n);
+size_t        ares_log2(size_t n);
+size_t        ares_pow(size_t x, size_t y);
+size_t        ares_count_digits(size_t n);
+size_t        ares_count_hexdigits(size_t n);
+unsigned char ares_count_bits_u8(unsigned char x);
+
+#endif