grpc 1.19.0 → 1.20.0.pre1

data/third_party/cares/cares/ares_library_init.c

@@ -30,15 +30,29 @@ fpGetAdaptersAddresses_t ares_fpGetAdaptersAddresses = ZERO_NULL;
 fpGetBestRoute2_t ares_fpGetBestRoute2 = ZERO_NULL;
 #endif
 
+#if defined(ANDROID) || defined(__ANDROID__)
+#include "ares_android.h"
+#endif
+
 /* library-private global vars with source visibility restricted to this file */
 
 static unsigned int ares_initialized;
 static int          ares_init_flags;
 
 /* library-private global vars with visibility across the whole library */
-void *(*ares_malloc)(size_t size) = malloc;
-void *(*ares_realloc)(void *ptr, size_t size) = realloc;
-void (*ares_free)(void *ptr) = free;
+#if defined(WIN32)
+/* We need indirections to handle Windows DLL rules. */
+static void *default_malloc(size_t size) { return malloc(size); }
+static void *default_realloc(void *p, size_t size) { return realloc(p, size); }
+static void default_free(void *p) { free(p); }
+#else
+# define default_malloc malloc
+# 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;
 
 #ifdef USE_WINSOCK
 static HMODULE hnd_iphlpapi;
@@ -160,6 +174,10 @@ void ares_library_cleanup(void)
   if (ares_init_flags & ARES_LIB_INIT_WIN32)
     ares_win32_cleanup();
 
+#if defined(ANDROID) || defined(__ANDROID__)
+  ares_library_cleanup_android();
+#endif
+
   ares_init_flags = ARES_LIB_INIT_NONE;
   ares_malloc = malloc;
   ares_realloc = realloc;

data/third_party/cares/cares/ares_options.c

@@ -153,6 +153,9 @@ int ares_set_servers(ares_channel channel,
   if (!channel)
     return ARES_ENODATA;
 
+  if (!ares__is_list_empty(&channel->all_queries))
+    return ARES_ENOTIMP;
+
   ares__destroy_servers_state(channel);
 
   for (srvr = servers; srvr; srvr = srvr->next)
@@ -202,6 +205,9 @@ int ares_set_servers_ports(ares_channel channel,
   if (!channel)
     return ARES_ENODATA;
 
+  if (!ares__is_list_empty(&channel->all_queries))
+    return ARES_ENOTIMP;
+
   ares__destroy_servers_state(channel);
 
   for (srvr = servers; srvr; srvr = srvr->next)
@@ -258,8 +264,6 @@ static int set_servers_csv(ares_channel channel,
   if (!channel)
     return ARES_ENODATA;
 
-  ares__destroy_servers_state(channel);
-
   i = strlen(_csv);
   if (i == 0)
      return ARES_SUCCESS; /* blank all servers */

data/third_party/cares/cares/ares_parse_naptr_reply.c

@@ -110,18 +110,19 @@ ares_parse_naptr_reply (const unsigned char *abuf, int alen,
           status = ARES_EBADRESP;
           break;
         }
-      /* RR must contain at least 7 bytes = 2 x int16 + 3 x name */
-      if (rr_len < 7)
-        {
-          status = ARES_EBADRESP;
-          break;
-        }
 
       /* Check if we are really looking at a NAPTR record */
       if (rr_class == C_IN && rr_type == T_NAPTR)
         {
           /* parse the NAPTR record itself */
 
+          /* RR must contain at least 7 bytes = 2 x int16 + 3 x name */
+          if (rr_len < 7)
+            {
+              status = ARES_EBADRESP;
+              break;
+            }
+
           /* Allocate storage for this NAPTR answer appending it to the list */
           naptr_curr = ares_malloc_data(ARES_DATATYPE_NAPTR_REPLY);
           if (!naptr_curr)

data/third_party/cares/cares/ares_parse_ptr_reply.c

@@ -52,6 +52,7 @@ int ares_parse_ptr_reply(const unsigned char *abuf, int alen, const void *addr,
   int aliascnt = 0;
   int alias_alloc = 8;
   char ** aliases;
+  size_t rr_data_len;
 
   /* Set *host to NULL for all failure cases. */
   *host = NULL;
@@ -124,14 +125,15 @@ int ares_parse_ptr_reply(const unsigned char *abuf, int alen, const void *addr,
           if (hostname)
             ares_free(hostname);
           hostname = rr_data;
-          aliases[aliascnt] = ares_malloc((strlen(rr_data)+1) * sizeof(char));
+          rr_data_len = strlen(rr_data)+1;
+          aliases[aliascnt] = ares_malloc(rr_data_len * sizeof(char));
           if (!aliases[aliascnt])
             {
               ares_free(rr_name);
               status = ARES_ENOMEM;
               break;
             }
-          strncpy(aliases[aliascnt], rr_data, strlen(rr_data)+1);
+          strncpy(aliases[aliascnt], rr_data, rr_data_len);
           aliascnt++;
           if (aliascnt >= alias_alloc) {
             char **ptr;

data/third_party/cares/cares/ares_platform.c

@@ -36,6 +36,10 @@ win_platform ares__getplatform(void)
 
   memset(&OsvEx, 0, sizeof(OsvEx));
   OsvEx.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4996) /* warning C4996: 'GetVersionExW': was declared deprecated */
+#endif
   if (!GetVersionEx((void *)&OsvEx))
     {
       memset(&OsvEx, 0, sizeof(OsvEx));
@@ -43,6 +47,9 @@ win_platform ares__getplatform(void)
       if (!GetVersionEx((void *)&OsvEx))
         return WIN_UNKNOWN;
     }
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
 
   switch(OsvEx.dwPlatformId)
     {

data/third_party/cares/cares/ares_private.h

@@ -52,18 +52,19 @@
 
 #if defined(WIN32) && !defined(WATT32)
 
-#define WIN_NS_9X      "System\\CurrentControlSet\\Services\\VxD\\MSTCP"
-#define WIN_NS_NT_KEY  "System\\CurrentControlSet\\Services\\Tcpip\\Parameters"
-#define WIN_DNSCLIENT  "Software\\Policies\\Microsoft\\System\\DNSClient"
-#define NAMESERVER     "NameServer"
-#define DHCPNAMESERVER "DhcpNameServer"
-#define DATABASEPATH   "DatabasePath"
-#define WIN_PATH_HOSTS  "\\hosts"
-#define SEARCHLIST_KEY "SearchList"
+#define WIN_NS_9X            "System\\CurrentControlSet\\Services\\VxD\\MSTCP"
+#define WIN_NS_NT_KEY        "System\\CurrentControlSet\\Services\\Tcpip\\Parameters"
+#define WIN_DNSCLIENT        "Software\\Policies\\Microsoft\\System\\DNSClient"
+#define WIN_NT_DNSCLIENT     "Software\\Policies\\Microsoft\\Windows NT\\DNSClient"
+#define NAMESERVER           "NameServer"
+#define DHCPNAMESERVER       "DhcpNameServer"
+#define DATABASEPATH         "DatabasePath"
+#define WIN_PATH_HOSTS       "\\hosts"
+#define SEARCHLIST_KEY       "SearchList"
 #define PRIMARYDNSSUFFIX_KEY "PrimaryDNSSuffix"
-#define INTERFACES_KEY "Interfaces"
-#define DOMAIN_KEY     "Domain"
-#define DHCPDOMAIN_KEY "DhcpDomain"
+#define INTERFACES_KEY       "Interfaces"
+#define DOMAIN_KEY           "Domain"
+#define DHCPDOMAIN_KEY       "DhcpDomain"
 
 #elif defined(WATT32)
 
@@ -100,6 +101,7 @@
 #endif
 
 #include "ares_strdup.h"
+#include "ares_strsplit.h"
 
 #ifndef HAVE_STRCASECMP
 #  include "ares_strcasecmp.h"
@@ -323,8 +325,14 @@ struct ares_channeldata {
 
   const struct ares_socket_functions * sock_funcs;
   void *sock_func_cb_data;
+
+  /* Path for resolv.conf file, configurable via ares_options */
+  char *resolvconf_path;
 };
 
+/* Does the domain end in ".onion" or ".onion."? Case-insensitive. */
+int ares__is_onion_domain(const char *name);
+
 /* Memory management functions */
 extern void *(*ares_malloc)(size_t size);
 extern void *(*ares_realloc)(void *ptr, size_t size);

data/third_party/cares/cares/ares_process.c

@@ -53,6 +53,7 @@
 
 #include <assert.h>
 #include <fcntl.h>
+#include <limits.h>
 
 #include "ares.h"
 #include "ares_dns.h"
@@ -871,8 +872,32 @@ void ares__send_query(ares_channel channel, struct query *query,
           return;
         }
     }
-    timeplus = channel->timeout << (query->try_count / channel->nservers);
-    timeplus = (timeplus * (9 + (rand () & 7))) / 16;
+
+    /* For each trip through the entire server list, double the channel's
+     * assigned timeout, avoiding overflow.  If channel->timeout is negative,
+     * leave it as-is, even though that should be impossible here.
+     */
+    timeplus = channel->timeout;
+    {
+      /* How many times do we want to double it?  Presume sane values here. */
+      const int shift = query->try_count / channel->nservers;
+
+      /* Is there enough room to shift timeplus left that many times?
+       *
+       * To find out, confirm that all of the bits we'll shift away are zero.
+       * Stop considering a shift if we get to the point where we could shift
+       * a 1 into the sign bit (i.e. when shift is within two of the bit
+       * count).
+       *
+       * This has the side benefit of leaving negative numbers unchanged.
+       */
+      if(shift <= (int)(sizeof(int) * CHAR_BIT - 1)
+         && (timeplus >> (sizeof(int) * CHAR_BIT - 1 - shift)) == 0)
+      {
+        timeplus <<= shift;
+      }
+    }
+
     query->timeout = *now;
     timeadd(&query->timeout, timeplus);
     /* Keep track of queries bucketed by timeout, so we can process

data/third_party/cares/cares/ares_rules.h

@@ -83,7 +83,7 @@
 
 /*
  * Verify that the size previously defined and expected for
- * ares_socklen_t is actually the the same as the one reported
+ * ares_socklen_t is actually the same as the one reported
  * by sizeof() at compile time.
  */
 

data/third_party/cares/cares/ares_search.c

@@ -54,6 +54,13 @@ void ares_search(ares_channel channel, const char *name, int dnsclass,
   const char *p;
   int status, ndots;
 
+  /* Per RFC 7686, reject queries for ".onion" domain names with NXDOMAIN. */
+  if (ares__is_onion_domain(name))
+    {
+      callback(arg, ARES_ENOTFOUND, 0, NULL, 0);
+      return;
+    }
+
   /* If name only yields one domain to search, then we don't have
    * to keep extra state, so just do an ares_query().
    */

data/third_party/cares/cares/ares_send.c

@@ -60,6 +60,12 @@ void ares_send(ares_channel channel, const unsigned char *qbuf, int qlen,
       callback(arg, ARES_ENOMEM, 0, NULL, 0);
       return;
     }
+  if (channel->nservers < 1)
+    {
+      ares_free(query);
+      callback(arg, ARES_ESERVFAIL, 0, NULL, 0);
+      return;
+    }
   query->server_info = ares_malloc(channel->nservers *
                                    sizeof(query->server_info[0]));
   if (!query->server_info)

data/third_party/cares/cares/ares_strsplit.c

@@ -0,0 +1,174 @@
+/* Copyright (C) 2018 by John Schember <john@nachtimwald.com>
+ *
+ * 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"
+#include "ares_strsplit.h"
+#include "ares.h"
+#include "ares_private.h"
+
+static int list_contains(char * const *list, size_t num_elem, const char *str, int insensitive)
+{
+  size_t len;
+  size_t i;
+
+  len = strlen(str);
+  for (i=0; i<num_elem; i++)
+  {
+    if (insensitive)
+    {
+#ifdef WIN32
+      if (strnicmp(list[i], str, len) == 0)
+#else
+      if (strncasecmp(list[i], str, len) == 0)
+#endif
+        return 1;
+    }
+    else
+    {
+      if (strncmp(list[i], str, len) == 0)
+        return 1;
+    }
+  }
+
+  return 0;
+}
+
+static int is_delim(char c, const char *delims, size_t num_delims)
+{
+  size_t i;
+
+  for (i=0; i<num_delims; i++)
+  {
+    if (c == delims[i])
+      return 1;
+  }
+  return 0;
+}
+
+
+void ares_strsplit_free(char **elms, size_t num_elm)
+{
+  size_t i;
+
+  if (elms == NULL)
+    return;
+
+  for (i=0; i<num_elm; i++)
+    ares_free(elms[i]);
+  ares_free(elms);
+}
+
+
+char **ares_strsplit(const char *in, const char *delms, int make_set, size_t *num_elm)
+{
+  char *parsestr;
+  char **temp;
+  char **out;
+  size_t cnt;
+  size_t nelms;
+  size_t in_len;
+  size_t num_delims;
+  size_t i;
+
+  if (in == NULL || delms == NULL || num_elm == NULL)
+    return NULL;
+
+  *num_elm = 0;
+
+  in_len = strlen(in);
+  num_delims = strlen(delms);
+
+  /* Figure out how many elements. */
+  nelms = 1;
+  for (i=0; i<in_len; i++)
+  {
+    if (is_delim(in[i], delms, num_delims))
+    {
+      nelms++;
+    }
+  }
+
+  /* Copy of input so we can cut it up. */
+  parsestr = ares_strdup(in);
+  if (parsestr == NULL)
+    return NULL;
+
+  /* Temporary array to store locations of start of each element
+   * within parsestr. */
+  temp = ares_malloc(nelms * sizeof(*temp));
+  if (temp == NULL)
+  {
+    ares_free(parsestr);
+    return NULL;
+  }
+  temp[0] = parsestr;
+  cnt = 1;
+  for (i=0; i<in_len && cnt<nelms; i++)
+  {
+    if (!is_delim(parsestr[i], delms, num_delims))
+      continue;
+
+    /* Replace sep with NULL. */
+    parsestr[i] = '\0';
+    /* Add the pointer to the array of elements */
+    temp[cnt] = parsestr+i+1;
+    cnt++;
+  }
+
+  /* Copy each element to our output array. */
+  out = ares_malloc(nelms * sizeof(*out));
+  if (out == NULL)
+  {
+    ares_free(parsestr);
+    ares_free(temp);
+    return NULL;
+  }
+
+  nelms = 0;
+  for (i=0; i<cnt; i++)
+  {
+    if (temp[i][0] == '\0')
+      continue;
+
+    if (make_set && list_contains(out, nelms, temp[i], 1))
+      continue;
+
+    out[nelms] = ares_strdup(temp[i]);
+    if (out[nelms] == NULL)
+    {
+      ares_strsplit_free(out, nelms);
+      ares_free(parsestr);
+      ares_free(temp);
+      return NULL;
+    }
+    nelms++;
+  }
+
+
+  /* If there are no elements don't return an empty allocated
+   * array. */
+  if (nelms == 0)
+  {
+    ares_strsplit_free(out, nelms);
+    out = NULL;
+  }
+
+  /* Get the true number of elements (recalculated because of make_set) */
+  *num_elm = nelms;
+
+  ares_free(parsestr);
+  ares_free(temp);
+  return out;
+}