grpc 1.73.0 → 1.75.0

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

@@ -1,121 +1,159 @@
-
-/* Copyright 1998 by the Massachusetts Institute of Technology.
- * Copyright (C) 2004-2011 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:
  *
- * 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 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_setup.h"
-
-#include <assert.h>
-
-#include "ares.h"
 #include "ares_private.h"
+#include "event/ares_event.h"
+#include <assert.h>
 
-void ares_destroy_options(struct ares_options *options)
-{
-  int i;
-
-  if(options->servers)
-    ares_free(options->servers);
-  for (i = 0; i < options->ndomains; i++)
-    ares_free(options->domains[i]);
-  if(options->domains)
-    ares_free(options->domains);
-  if(options->sortlist)
-    ares_free(options->sortlist);
-  if(options->lookups)
-    ares_free(options->lookups);
-  if(options->resolvconf_path)
-    ares_free(options->resolvconf_path);
-  if(options->hosts_path)
-    ares_free(options->hosts_path);
-}
-
-void ares_destroy(ares_channel channel)
+void ares_destroy(ares_channel_t *channel)
 {
-  int i;
-  struct query *query;
-  struct list_node* list_head;
-  struct list_node* list_node;
+  size_t             i;
+  ares_llist_node_t *node = NULL;
 
-  if (!channel)
+  if (channel == NULL) {
     return;
+  }
 
-  list_head = &(channel->all_queries);
-  for (list_node = list_head->next; list_node != list_head; )
-    {
-      query = list_node->data;
-      list_node = list_node->next;  /* since we're deleting the query */
-      query->callback(query->arg, ARES_EDESTRUCTION, 0, NULL, 0);
-      ares__free_query(query);
+  /* Mark as being shutdown */
+  ares_channel_lock(channel);
+  channel->sys_up = ARES_FALSE;
+  ares_channel_unlock(channel);
+
+  /* Disable configuration change monitoring.  We can't hold a lock because
+   * some cleanup routines, such as on Windows, are synchronous operations.
+   * What we've observed is a system config change event was triggered right
+   * at shutdown time and it tries to take the channel lock and the destruction
+   * waits for that event to complete before it continues so we get a channel
+   * lock deadlock at shutdown if we hold a lock during this process. */
+  if (channel->optmask & ARES_OPT_EVENT_THREAD) {
+    ares_event_thread_t *e = channel->sock_state_cb_data;
+    if (e && e->configchg) {
+      ares_event_configchg_destroy(e->configchg);
+      e->configchg = NULL;
     }
+  }
+
+  /* Wait for reinit thread to exit if there was one pending, can't be
+   * holding a lock as the thread may take locks. */
+  if (channel->reinit_thread != NULL) {
+    void *rv;
+    ares_thread_join(channel->reinit_thread, &rv);
+    channel->reinit_thread = NULL;
+  }
+
+  /* Lock because callbacks will be triggered, and any system-generated
+   * callbacks need to hold a channel lock. */
+  ares_channel_lock(channel);
+
+  /* Destroy all queries */
+  node = ares_llist_node_first(channel->all_queries);
+  while (node != NULL) {
+    ares_llist_node_t *next  = ares_llist_node_next(node);
+    ares_query_t      *query = ares_llist_node_claim(node);
+
+    query->node_all_queries = NULL;
+    query->callback(query->arg, ARES_EDESTRUCTION, 0, NULL);
+    ares_free_query(query);
+
+    node = next;
+  }
+
+  ares_queue_notify_empty(channel);
+
 #ifndef NDEBUG
   /* Freeing the query should remove it from all the lists in which it sits,
    * so all query lists should be empty now.
    */
-  assert(ares__is_list_empty(&(channel->all_queries)));
-  for (i = 0; i < ARES_QID_TABLE_SIZE; i++)
-    {
-      assert(ares__is_list_empty(&(channel->queries_by_qid[i])));
-    }
-  for (i = 0; i < ARES_TIMEOUT_TABLE_SIZE; i++)
-    {
-      assert(ares__is_list_empty(&(channel->queries_by_timeout[i])));
-    }
+  assert(ares_llist_len(channel->all_queries) == 0);
+  assert(ares_htable_szvp_num_keys(channel->queries_by_qid) == 0);
+  assert(ares_slist_len(channel->queries_by_timeout) == 0);
+#endif
+
+  ares_destroy_servers_state(channel);
+
+#ifndef NDEBUG
+  assert(ares_htable_asvp_num_keys(channel->connnode_by_socket) == 0);
 #endif
 
-  ares__destroy_servers_state(channel);
+  /* No more callbacks will be triggered after this point, unlock */
+  ares_channel_unlock(channel);
+
+  /* Shut down the event thread */
+  if (channel->optmask & ARES_OPT_EVENT_THREAD) {
+    ares_event_thread_destroy(channel);
+  }
 
   if (channel->domains) {
-    for (i = 0; i < channel->ndomains; i++)
+    for (i = 0; i < channel->ndomains; i++) {
       ares_free(channel->domains[i]);
+    }
     ares_free(channel->domains);
   }
 
-  if(channel->sortlist)
-    ares_free(channel->sortlist);
+  ares_llist_destroy(channel->all_queries);
+  ares_slist_destroy(channel->queries_by_timeout);
+  ares_htable_szvp_destroy(channel->queries_by_qid);
+  ares_htable_asvp_destroy(channel->connnode_by_socket);
 
-  if (channel->lookups)
-    ares_free(channel->lookups);
+  ares_free(channel->sortlist);
+  ares_free(channel->lookups);
+  ares_free(channel->resolvconf_path);
+  ares_free(channel->hosts_path);
+  ares_destroy_rand_state(channel->rand_state);
 
-  if (channel->resolvconf_path)
-    ares_free(channel->resolvconf_path);
+  ares_hosts_file_destroy(channel->hf);
 
-  if (channel->hosts_path)
-    ares_free(channel->hosts_path);
+  ares_qcache_destroy(channel->qcache);
 
-  if (channel->rand_state)
-    ares__destroy_rand_state(channel->rand_state);
+  ares_channel_threading_destroy(channel);
 
   ares_free(channel);
 }
 
-void ares__destroy_servers_state(ares_channel channel)
+void ares_destroy_server(ares_server_t *server)
 {
-  struct server_state *server;
-  int i;
-
-  if (channel->servers)
-    {
-      for (i = 0; i < channel->nservers; i++)
-        {
-          server = &channel->servers[i];
-          ares__close_sockets(channel, server);
-          assert(ares__is_list_empty(&server->queries_to_server));
-        }
-      ares_free(channel->servers);
-      channel->servers = NULL;
-    }
-  channel->nservers = -1;
+  if (server == NULL) {
+    return; /* LCOV_EXCL_LINE: DefensiveCoding */
+  }
+
+  ares_close_sockets(server);
+  ares_llist_destroy(server->connections);
+  ares_free(server);
+}
+
+void ares_destroy_servers_state(ares_channel_t *channel)
+{
+  ares_slist_node_t *node;
+
+  while ((node = ares_slist_node_first(channel->servers)) != NULL) {
+    ares_server_t *server = ares_slist_node_claim(node);
+    ares_destroy_server(server);
+  }
+
+  ares_slist_destroy(channel->servers);
+  channel->servers = NULL;
 }

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

@@ -1,42 +1,53 @@
-
-/* Copyright 1998 by the Massachusetts Institute of Technology.
+/* 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.
  *
- * 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_private.h"
 
 #ifdef HAVE_NETDB_H
-#include <netdb.h>
+#  include <netdb.h>
 #endif
 
-#include "ares.h"
-#include "ares_private.h" /* for memdebug */
-
 void ares_free_hostent(struct hostent *host)
 {
   char **p;
 
-  if (!host)
+  if (!host) {
     return;
+  }
 
-  ares_free((char *)(host->h_name));
-  for (p = host->h_aliases; p && *p; p++)
+  ares_free(host->h_name);
+  for (p = host->h_aliases; p && *p; p++) {
     ares_free(*p);
+  }
   ares_free(host->h_aliases);
   if (host->h_addr_list) {
-    ares_free(host->h_addr_list[0]); /* no matter if there is one or many entries,
-                                   there is only one malloc for all of them */
+    size_t i;
+    for (i=0; host->h_addr_list[i] != NULL; i++) {
+      ares_free(host->h_addr_list[i]);
+    }
     ares_free(host->h_addr_list);
   }
   ares_free(host);

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

@@ -1,22 +1,30 @@
-
-/* Copyright 2000 by the Massachusetts Institute of Technology.
+/* MIT License
+ *
+ * Copyright (c) 2000 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:
  *
- * 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 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_setup.h"
-
-#include "ares.h"
 #include "ares_private.h"
 
 void ares_free_string(void *str)

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

@@ -1,60 +1,67 @@
-
-/* Copyright 1998 by the Massachusetts Institute of Technology.
- * Copyright (C) 2019 by Andrew Selivanov
+/* MIT License
+ *
+ * Copyright (c) 1998 Massachusetts Institute of Technology
+ * Copyright (c) 2019 Andrew Selivanov
+ *
+ * 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_private.h"
 
 #ifdef HAVE_NETDB_H
 #  include <netdb.h>
 #endif
 
-#include "ares.h"
-#include "ares_private.h"
-
-void ares__freeaddrinfo_cnames(struct ares_addrinfo_cname *head)
+void ares_freeaddrinfo_cnames(struct ares_addrinfo_cname *head)
 {
   struct ares_addrinfo_cname *current;
-  while (head)
-    {
-      current = head;
-      head = head->next;
-      ares_free(current->alias);
-      ares_free(current->name);
-      ares_free(current);
-    }
+  while (head) {
+    current = head;
+    head    = head->next;
+    ares_free(current->alias);
+    ares_free(current->name);
+    ares_free(current);
+  }
 }
 
-void ares__freeaddrinfo_nodes(struct ares_addrinfo_node *head)
+void ares_freeaddrinfo_nodes(struct ares_addrinfo_node *head)
 {
   struct ares_addrinfo_node *current;
-  while (head)
-    {
-      current = head;
-      head = head->ai_next;
-      ares_free(current->ai_addr);
-      ares_free(current);
-    }
+  while (head) {
+    current = head;
+    head    = head->ai_next;
+    ares_free(current->ai_addr);
+    ares_free(current);
+  }
 }
 
 void ares_freeaddrinfo(struct ares_addrinfo *ai)
 {
-  if (ai == NULL)
+  if (ai == NULL) {
     return;
-  ares__freeaddrinfo_cnames(ai->cnames);
-  ares__freeaddrinfo_nodes(ai->nodes);
+  }
+  ares_freeaddrinfo_cnames(ai->cnames);
+  ares_freeaddrinfo_nodes(ai->nodes);
+
   ares_free(ai->name);
   ares_free(ai);
 }