Merge branch 'rightlib' into mergelibs-241019-1758

1 files changed, 33 insertions, 35 deletions

diff --git a/contrib/libs/c-ares/src/lib/ares_destroy.c b/contrib/libs/c-ares/src/lib/ares_destroy.c
index d75b5e227c..1e5706e0e0 100644
--- a/contrib/libs/c-ares/src/lib/ares_destroy.c
+++ b/contrib/libs/c-ares/src/lib/ares_destroy.c
@@ -31,17 +31,17 @@
 
 void ares_destroy(ares_channel_t *channel)
 {
-  size_t              i;
-  ares__llist_node_t *node = NULL;
+  size_t             i;
+  ares_llist_node_t *node = NULL;
 
   if (channel == NULL) {
     return;
   }
 
   /* Mark as being shutdown */
-  ares__channel_lock(channel);
+  ares_channel_lock(channel);
   channel->sys_up = ARES_FALSE;
-  ares__channel_unlock(channel);
+  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.
@@ -61,23 +61,23 @@ void ares_destroy(ares_channel_t *channel)
    * holding a lock as the thread may take locks. */
   if (channel->reinit_thread != NULL) {
     void *rv;
-    ares__thread_join(channel->reinit_thread, &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);
+  ares_channel_lock(channel);
 
   /* Destroy all queries */
-  node = ares__llist_node_first(channel->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);
+    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);
+    ares_free_query(query);
 
     node = next;
   }
@@ -88,19 +88,19 @@ void ares_destroy(ares_channel_t *channel)
   /* Freeing the query should remove it from all the lists in which it sits,
    * so all query lists should be empty now.
    */
-  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);
+  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);
+  ares_destroy_servers_state(channel);
 
 #ifndef NDEBUG
-  assert(ares__htable_asvp_num_keys(channel->connnode_by_socket) == 0);
+  assert(ares_htable_asvp_num_keys(channel->connnode_by_socket) == 0);
 #endif
 
   /* No more callbacks will be triggered after this point, unlock */
-  ares__channel_unlock(channel);
+  ares_channel_unlock(channel);
 
   /* Shut down the event thread */
   if (channel->optmask & ARES_OPT_EVENT_THREAD) {
@@ -114,48 +114,46 @@ void ares_destroy(ares_channel_t *channel)
     ares_free(channel->domains);
   }
 
-  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);
+  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);
 
   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);
+  ares_destroy_rand_state(channel->rand_state);
 
-  ares__hosts_file_destroy(channel->hf);
+  ares_hosts_file_destroy(channel->hf);
 
-  ares__qcache_destroy(channel->qcache);
+  ares_qcache_destroy(channel->qcache);
 
-  ares__channel_threading_destroy(channel);
+  ares_channel_threading_destroy(channel);
 
   ares_free(channel);
 }
 
-void ares__destroy_server(ares_server_t *server)
+void ares_destroy_server(ares_server_t *server)
 {
   if (server == NULL) {
     return; /* LCOV_EXCL_LINE: DefensiveCoding */
   }
 
-  ares__close_sockets(server);
-  ares__llist_destroy(server->connections);
-  ares__buf_destroy(server->tcp_parser);
-  ares__buf_destroy(server->tcp_send);
+  ares_close_sockets(server);
+  ares_llist_destroy(server->connections);
   ares_free(server);
 }
 
-void ares__destroy_servers_state(ares_channel_t *channel)
+void ares_destroy_servers_state(ares_channel_t *channel)
 {
-  ares__slist_node_t *node;
+  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);
+  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);
+  ares_slist_destroy(channel->servers);
   channel->servers = NULL;
 }