grpc 1.55.3 → 1.56.0.pre3

data/third_party/cares/cares/include/ares.h

@@ -39,7 +39,7 @@
 #if defined(_AIX) || defined(__NOVELL_LIBC__) || defined(__NetBSD__) || \
     defined(__minix) || defined(__SYMBIAN32__) || defined(__INTEGRITY) || \
     defined(ANDROID) || defined(__ANDROID__) || defined(__OpenBSD__) || \
-    defined(__QNXNTO__) || defined(__MVS__)
+    defined(__QNXNTO__) || defined(__MVS__) || defined(__HAIKU__)
 #include <sys/select.h>
 #endif
 #if (defined(NETWARE) && !defined(__NOVELL_LIBC__))
@@ -63,6 +63,13 @@
 #  include <windows.h>
 #  include <winsock2.h>
 #  include <ws2tcpip.h>
+/* To aid with linking against a static c-ares build, lets tell the microsoft
+ * compiler to pull in needed dependencies */
+#  ifdef _MSC_VER
+#    pragma comment(lib, "ws2_32")
+#    pragma comment(lib, "advapi32")
+#    pragma comment(lib, "iphlpapi")
+#  endif
 #else
 #  include <sys/socket.h>
 #  include <netinet/in.h>
@@ -168,6 +175,7 @@ extern "C" {
 #define ARES_OPT_EDNSPSZ        (1 << 15)
 #define ARES_OPT_NOROTATE       (1 << 16)
 #define ARES_OPT_RESOLVCONF     (1 << 17)
+#define ARES_OPT_HOSTS_FILE     (1 << 18)
 
 /* Nameinfo flag values */
 #define ARES_NI_NOFQDN                  (1 << 0)
@@ -277,6 +285,7 @@ struct ares_options {
   int nsort;
   int ednspsz;
   char *resolvconf_path;
+  char *hosts_path;
 };
 
 struct hostent;
@@ -588,6 +597,14 @@ struct ares_soa_reply {
   unsigned int minttl;
 };
 
+struct ares_uri_reply {
+  struct ares_uri_reply  *next;
+  unsigned short          priority;
+  unsigned short          weight;
+  char                   *uri;
+  int                     ttl;
+};
+
 /*
  * Similar to addrinfo, but with extra ttl and missing canonname.
  */
@@ -617,6 +634,7 @@ struct ares_addrinfo_cname {
 struct ares_addrinfo {
   struct ares_addrinfo_cname *cnames;
   struct ares_addrinfo_node  *nodes;
+  char                       *name;
 };
 
 struct ares_addrinfo_hints {
@@ -685,6 +703,10 @@ CARES_EXTERN int ares_parse_soa_reply(const unsigned char* abuf,
 				      int alen,
 				      struct ares_soa_reply** soa_out);
 
+CARES_EXTERN int ares_parse_uri_reply(const unsigned char* abuf,
+                                      int alen,
+                                      struct ares_uri_reply** uri_out);
+
 CARES_EXTERN void ares_free_string(void *str);
 
 CARES_EXTERN void ares_free_hostent(struct hostent *host);

data/third_party/cares/cares/{src/lib → include}/ares_nameser.h

@@ -2,10 +2,12 @@
 #ifndef ARES_NAMESER_H
 #define ARES_NAMESER_H
 
-#ifdef HAVE_ARPA_NAMESER_H
+#include "ares_build.h"
+
+#ifdef CARES_HAVE_ARPA_NAMESER_H
 #  include <arpa/nameser.h>
 #endif
-#ifdef HAVE_ARPA_NAMESER_COMPAT_H
+#ifdef CARES_HAVE_ARPA_NAMESER_COMPAT_H
 #  include <arpa/nameser_compat.h>
 #endif
 
@@ -68,7 +70,7 @@
  * provide them
  * ============================================================================
  */
-#ifndef HAVE_ARPA_NAMESER_H
+#ifndef CARES_HAVE_ARPA_NAMESER_H
 
 typedef enum __ns_class {
     ns_c_invalid = 0,       /* Cookie. */
@@ -138,7 +140,7 @@ typedef enum __ns_type {
     ns_t_mailb = 253,       /* Transfer mailbox records. */
     ns_t_maila = 254,       /* Transfer mail agent records. */
     ns_t_any = 255,         /* Wildcard match. */
-    ns_t_zxfr = 256,        /* BIND-specific, nonstandard. */
+    ns_t_uri = 256,         /* Uniform Resource Identifier (RFC7553) */
     ns_t_caa = 257,         /* Certification Authority Authorization. */
     ns_t_max = 65536
 } ns_type;
@@ -173,7 +175,7 @@ typedef enum __ns_rcode {
     ns_r_badtime = 18
 } ns_rcode;
 
-#endif /* HAVE_ARPA_NAMESER_H */
+#endif /* CARES_HAVE_ARPA_NAMESER_H */
 
 
 /* ============================================================================
@@ -468,8 +470,8 @@ typedef enum __ns_rcode {
 #ifndef T_ANY
 #  define T_ANY           255 /* ns_t_any */
 #endif
-#ifndef T_ZXFR
-#  define T_ZXFR          256 /* ns_t_zxfr */
+#ifndef T_URI
+#  define T_URI          256 /* ns_t_uri */
 #endif
 #ifndef T_CAA
 #  define T_CAA           257 /* ns_t_caa */

data/third_party/cares/cares/include/ares_rules.h

@@ -2,7 +2,7 @@
 #define __CARES_RULES_H
 
 
-/* Copyright (C) 2009 by Daniel Stenberg et al
+/* Copyright (C) 2009 - 2021 by Daniel Stenberg et al
  *
  * Permission to use, copy, modify, and distribute this software and its
  * documentation for any purpose and without fee is hereby granted, provided
@@ -40,7 +40,7 @@
  * library is properly built and used.
  *
  * You can find further help on the c-ares development mailing list:
- * http://cool.haxx.se/mailman/listinfo/c-ares/
+ * http://lists.haxx.se/listinfo/c-ares/
  *
  * NOTE 2
  * ------

data/third_party/cares/cares/include/ares_version.h

@@ -3,15 +3,15 @@
 #define ARES__VERSION_H
 
 /* This is the global package copyright */
-#define ARES_COPYRIGHT "2004 - 2020 Daniel Stenberg, <daniel@haxx.se>."
+#define ARES_COPYRIGHT "2004 - 2021 Daniel Stenberg, <daniel@haxx.se>."
 
 #define ARES_VERSION_MAJOR 1
-#define ARES_VERSION_MINOR 17
+#define ARES_VERSION_MINOR 19
 #define ARES_VERSION_PATCH 0
 #define ARES_VERSION ((ARES_VERSION_MAJOR<<16)|\
                        (ARES_VERSION_MINOR<<8)|\
                        (ARES_VERSION_PATCH))
-#define ARES_VERSION_STR "1.17.0"
+#define ARES_VERSION_STR "1.19.0"
 
 #if (ARES_VERSION >= 0x010700)
 #  define CARES_HAVE_ARES_LIBRARY_INIT 1

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

@@ -0,0 +1,266 @@
+/* Copyright 1998 by the Massachusetts Institute of Technology.
+ * Copyright 2005 Dominick Meglio
+ * Copyright (C) 2019 by Andrew Selivanov
+ * Copyright (C) 2021 by Brad House
+ *
+ * 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.
+ */
+
+#include "ares_setup.h"
+
+#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"
+
+#ifdef HAVE_STRINGS_H
+#  include <strings.h>
+#endif
+
+#ifdef HAVE_LIMITS_H
+#  include <limits.h>
+#endif
+
+#include "ares.h"
+#include "ares_dns.h"
+#include "ares_inet_net_pton.h"
+#include "ares_private.h"
+
+int ares__addrinfo2hostent(const struct ares_addrinfo *ai, int family,
+                           struct hostent **host)
+{
+  struct ares_addrinfo_node *next;
+  struct ares_addrinfo_cname *next_cname;
+  char **aliases = NULL;
+  char *addrs = NULL;
+  int naliases = 0, naddrs = 0, alias = 0, i;
+
+  if (ai == NULL || host == NULL)
+    return ARES_EBADQUERY;
+
+  *host = ares_malloc(sizeof(**host));
+  if (!(*host))
+    {
+      goto enomem;
+    }
+  memset(*host, 0, sizeof(**host));
+
+  /* Use the first node of the response as the family, since hostent can only
+   * represent one family.  We assume getaddrinfo() returned a sorted list if
+   * the user requested AF_UNSPEC. */
+  if (family == AF_UNSPEC && ai->nodes)
+    family = ai->nodes->ai_family;
+
+  next = ai->nodes;
+  while (next)
+    {
+      if(next->ai_family == family)
+        {
+          ++naddrs;
+        }
+      next = next->ai_next;
+    }
+
+  next_cname = ai->cnames;
+  while (next_cname)
+    {
+      if(next_cname->alias)
+        ++naliases;
+      next_cname = next_cname->next;
+    }
+
+  aliases = ares_malloc((naliases + 1) * sizeof(char *));
+  if (!aliases)
+    {
+      goto enomem;
+    }
+  (*host)->h_aliases = aliases;
+  memset(aliases, 0, (naliases + 1) * sizeof(char *));
+
+  if (naliases)
+    {
+      next_cname = ai->cnames;
+      while (next_cname)
+        {
+          if(next_cname->alias) {
+            aliases[alias] = ares_strdup(next_cname->alias);
+            if (!aliases[alias]) {
+              goto enomem;
+            }
+            alias++;
+          }
+          next_cname = next_cname->next;
+        }
+    }
+
+
+  (*host)->h_addr_list = ares_malloc((naddrs + 1) * sizeof(char *));
+  if (!(*host)->h_addr_list)
+    {
+      goto enomem;
+    }
+
+  memset((*host)->h_addr_list, 0, (naddrs + 1) * sizeof(char *));
+
+  if (ai->cnames)
+    {
+      (*host)->h_name = ares_strdup(ai->cnames->name);
+      if ((*host)->h_name == NULL && ai->cnames->name)
+        {
+          goto enomem;
+        }
+    }
+  else
+    {
+      (*host)->h_name = ares_strdup(ai->name);
+      if ((*host)->h_name == NULL && ai->name)
+        {
+          goto enomem;
+        }
+    }
+
+  (*host)->h_addrtype = family;
+  (*host)->h_length = (family == AF_INET)?
+     sizeof(struct in_addr):sizeof(struct ares_in6_addr);
+
+  if (naddrs)
+    {
+      addrs = ares_malloc(naddrs * (*host)->h_length);
+      if (!addrs)
+        {
+          goto enomem;
+        }
+
+      i = 0;
+      next = ai->nodes;
+      while (next)
+        {
+          if(next->ai_family == family)
+            {
+              (*host)->h_addr_list[i] = addrs + (i * (*host)->h_length);
+              if (family == AF_INET6)
+                {
+                  memcpy((*host)->h_addr_list[i],
+                     &(CARES_INADDR_CAST(struct sockaddr_in6 *, next->ai_addr)->sin6_addr),
+                     (*host)->h_length);
+                }
+              else
+                {
+                  memcpy((*host)->h_addr_list[i],
+                     &(CARES_INADDR_CAST(struct sockaddr_in *, next->ai_addr)->sin_addr),
+                     (*host)->h_length);
+                }
+              ++i;
+            }
+          next = next->ai_next;
+        }
+
+      if (i == 0)
+        {
+          ares_free(addrs);
+        }
+    }
+
+  if (naddrs == 0 && naliases == 0)
+    {
+      ares_free_hostent(*host);
+      *host = NULL;
+      return ARES_ENODATA;
+    }
+
+  return ARES_SUCCESS;
+
+enomem:
+  ares_free_hostent(*host);
+  *host = NULL;
+  return ARES_ENOMEM;
+}
+
+
+int ares__addrinfo2addrttl(const struct ares_addrinfo *ai, int family,
+                           int req_naddrttls, struct ares_addrttl *addrttls,
+                           struct ares_addr6ttl *addr6ttls, int *naddrttls)
+{
+  struct ares_addrinfo_node *next;
+  struct ares_addrinfo_cname *next_cname;
+  int cname_ttl = INT_MAX;
+
+  if (family != AF_INET && family != AF_INET6)
+    return ARES_EBADQUERY;
+
+  if (ai == NULL || naddrttls == NULL)
+    return ARES_EBADQUERY;
+
+  if (family == AF_INET && addrttls == NULL)
+    return ARES_EBADQUERY;
+
+  if (family == AF_INET6 && addr6ttls == NULL)
+    return ARES_EBADQUERY;
+
+  if (req_naddrttls == 0)
+    return ARES_EBADQUERY;
+
+  *naddrttls = 0;
+
+  next_cname = ai->cnames;
+  while (next_cname)
+    {
+      if(next_cname->ttl < cname_ttl)
+        cname_ttl = next_cname->ttl;
+      next_cname = next_cname->next;
+    }
+
+  next = ai->nodes;
+  while (next)
+    {
+      if(next->ai_family == family)
+        {
+          if (*naddrttls < req_naddrttls)
+            {
+                if (family == AF_INET6)
+                  {
+                    if(next->ai_ttl > cname_ttl)
+                      addr6ttls[*naddrttls].ttl = cname_ttl;
+                    else
+                      addr6ttls[*naddrttls].ttl = next->ai_ttl;
+
+                    memcpy(&addr6ttls[*naddrttls].ip6addr,
+                           &(CARES_INADDR_CAST(struct sockaddr_in6 *, next->ai_addr)->sin6_addr),
+                           sizeof(struct ares_in6_addr));
+                  }
+                else
+                  {
+                    if(next->ai_ttl > cname_ttl)
+                      addrttls[*naddrttls].ttl = cname_ttl;
+                    else
+                      addrttls[*naddrttls].ttl = next->ai_ttl;
+                    memcpy(&addrttls[*naddrttls].ipaddr,
+                           &(CARES_INADDR_CAST(struct sockaddr_in *, next->ai_addr)->sin_addr),
+                           sizeof(struct in_addr));
+                  }
+                (*naddrttls)++;
+             }
+        }
+      next = next->ai_next;
+    }
+
+  return ARES_SUCCESS;
+}
+

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

@@ -0,0 +1,240 @@
+/* Copyright (C) 2021
+ *
+ * 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.
+ */
+
+#include "ares_setup.h"
+
+#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
+
+#if defined(_WIN32) && defined(_WIN32_WINNT) && _WIN32_WINNT >= 0x0600
+#include <ws2ipdef.h>
+#include <iphlpapi.h>
+#endif
+
+#include "ares.h"
+#include "ares_inet_net_pton.h"
+#include "ares_nowarn.h"
+#include "ares_private.h"
+
+int ares_append_ai_node(int aftype,
+                        unsigned short port,
+                        int ttl,
+                        const void *adata,
+                        struct ares_addrinfo_node **nodes)
+{
+  struct ares_addrinfo_node *node;
+
+  node = ares__append_addrinfo_node(nodes);
+  if (!node)
+    {
+      return ARES_ENOMEM;
+    }
+
+  memset(node, 0, sizeof(*node));
+
+  if (aftype == AF_INET)
+    {
+      struct sockaddr_in *sin = ares_malloc(sizeof(*sin));
+      if (!sin)
+        {
+          return ARES_ENOMEM;
+        }
+
+      memset(sin, 0, sizeof(*sin));
+      memcpy(&sin->sin_addr.s_addr, adata, sizeof(sin->sin_addr.s_addr));
+      sin->sin_family = AF_INET;
+      sin->sin_port = htons(port);
+
+      node->ai_addr = (struct sockaddr *)sin;
+      node->ai_family = AF_INET;
+      node->ai_addrlen = sizeof(*sin);
+      node->ai_addr = (struct sockaddr *)sin;
+      node->ai_ttl = ttl;
+    }
+
+  if (aftype == AF_INET6)
+    {
+      struct sockaddr_in6 *sin6 = ares_malloc(sizeof(*sin6));
+      if (!sin6)
+        {
+          return ARES_ENOMEM;
+        }
+
+      memset(sin6, 0, sizeof(*sin6));
+      memcpy(&sin6->sin6_addr.s6_addr, adata, sizeof(sin6->sin6_addr.s6_addr));
+      sin6->sin6_family = AF_INET6;
+      sin6->sin6_port = htons(port);
+
+      node->ai_addr = (struct sockaddr *)sin6;
+      node->ai_family = AF_INET6;
+      node->ai_addrlen = sizeof(*sin6);
+      node->ai_addr = (struct sockaddr *)sin6;
+      node->ai_ttl = ttl;
+    }
+
+  return ARES_SUCCESS;
+}
+
+
+static int ares__default_loopback_addrs(int aftype,
+                                        unsigned short port,
+                                        struct ares_addrinfo_node **nodes)
+{
+  int status = ARES_SUCCESS;
+
+  if (aftype == AF_UNSPEC || aftype == AF_INET6)
+    {
+      struct ares_in6_addr addr6;
+      ares_inet_pton(AF_INET6, "::1", &addr6);
+      status = ares_append_ai_node(AF_INET6, port, 0, &addr6, nodes);
+      if (status != ARES_SUCCESS)
+        {
+          return status;
+       }
+    }
+
+  if (aftype == AF_UNSPEC || aftype == AF_INET)
+    {
+      struct in_addr addr4;
+      ares_inet_pton(AF_INET, "127.0.0.1", &addr4);
+      status = ares_append_ai_node(AF_INET, port, 0, &addr4, nodes);
+      if (status != ARES_SUCCESS)
+        {
+          return status;
+       }
+    }
+
+  return status;
+}
+
+
+static int ares__system_loopback_addrs(int aftype,
+                                       unsigned short port,
+                                       struct ares_addrinfo_node **nodes)
+{
+#if defined(_WIN32) && defined(_WIN32_WINNT) && _WIN32_WINNT >= 0x0600 && !defined(__WATCOMC__)
+  PMIB_UNICASTIPADDRESS_TABLE table;
+  unsigned int i;
+  int status;
+
+  *nodes = NULL;
+
+  if (GetUnicastIpAddressTable(aftype, &table) != NO_ERROR)
+    return ARES_ENOTFOUND;
+
+  for (i=0; i<table->NumEntries; i++)
+    {
+      if (table->Table[i].InterfaceLuid.Info.IfType !=
+          IF_TYPE_SOFTWARE_LOOPBACK)
+        {
+          continue;
+        }
+
+      if (table->Table[i].Address.si_family == AF_INET)
+        {
+          status = ares_append_ai_node(table->Table[i].Address.si_family, port, 0,
+                                       &table->Table[i].Address.Ipv4.sin_addr,
+                                       nodes);
+        }
+      else if (table->Table[i].Address.si_family == AF_INET6)
+        {
+          status = ares_append_ai_node(table->Table[i].Address.si_family, port, 0,
+                                       &table->Table[i].Address.Ipv6.sin6_addr,
+                                       nodes);
+        }
+      else
+        {
+          /* Ignore any others */
+          continue;
+        }
+
+      if (status != ARES_SUCCESS)
+        {
+          goto fail;
+        }
+    }
+
+    if (*nodes == NULL)
+      status = ARES_ENOTFOUND;
+
+fail:
+  FreeMibTable(table);
+
+  if (status != ARES_SUCCESS)
+    {
+      ares__freeaddrinfo_nodes(*nodes);
+      *nodes = NULL;
+    }
+
+  return status;
+
+#else
+  (void)aftype;
+  (void)port;
+  (void)nodes;
+  /* Not supported on any other OS at this time */
+  return ARES_ENOTFOUND;
+#endif
+}
+
+
+int ares__addrinfo_localhost(const char *name,
+                             unsigned short port,
+                             const struct ares_addrinfo_hints *hints,
+                             struct ares_addrinfo *ai)
+{
+  struct ares_addrinfo_node *nodes = NULL;
+  int result;
+
+  /* Validate family */
+  switch (hints->ai_family) {
+    case AF_INET:
+    case AF_INET6:
+    case AF_UNSPEC:
+      break;
+    default:
+      return ARES_EBADFAMILY;
+  }
+
+  ai->name = ares_strdup(name);
+  if(!ai->name)
+    {
+      goto enomem;
+    }
+
+  result = ares__system_loopback_addrs(hints->ai_family, port, &nodes);
+
+  if (result == ARES_ENOTFOUND)
+    {
+      result = ares__default_loopback_addrs(hints->ai_family, port, &nodes);
+    }
+
+  ares__addrinfo_cat_nodes(&ai->nodes, nodes);
+
+  return result;
+
+enomem:
+  ares__freeaddrinfo_nodes(nodes);
+  ares_free(ai->name);
+  ai->name = NULL;
+  return ARES_ENOMEM;
+}