grpc 1.74.1 → 1.75.0.pre1

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

@@ -1,39 +1,31 @@
-
-/* Copyright 1998 by the Massachusetts Institute of Technology.
- * Copyright (C) 2004-2017 by Daniel Stenberg
+/* MIT License
+ *
+ * Copyright (c) 1998 Massachusetts Institute of Technology
+ * Copyright (c) 2010 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"
-
-#ifdef HAVE_SYS_UIO_H
-#  include <sys/uio.h>
-#endif
-#ifdef HAVE_NETINET_IN_H
-#  include <netinet/in.h>
-#endif
-#ifdef HAVE_NETINET_TCP_H
-#  include <netinet/tcp.h>
-#endif
-#ifdef HAVE_NETDB_H
-#  include <netdb.h>
-#endif
-#ifdef HAVE_ARPA_INET_H
-#  include <arpa/inet.h>
-#endif
-
-#include "ares_nameser.h"
+#include "ares_private.h"
 
 #ifdef HAVE_STRINGS_H
 #  include <strings.h>
@@ -44,1544 +36,1407 @@
 #ifdef NETWARE
 #  include <sys/filio.h>
 #endif
+#ifdef HAVE_STDINT_H
+#  include <stdint.h>
+#endif
 
 #include <assert.h>
 #include <fcntl.h>
 #include <limits.h>
 
-#include "ares.h"
-#include "ares_dns.h"
-#include "ares_nowarn.h"
-#include "ares_private.h"
-
 
-static int try_again(int errnum);
-static void write_tcp_data(ares_channel channel, fd_set *write_fds,
-                           ares_socket_t write_fd, struct timeval *now);
-static void read_tcp_data(ares_channel channel, fd_set *read_fds,
-                          ares_socket_t read_fd, struct timeval *now);
-static void read_udp_packets(ares_channel channel, fd_set *read_fds,
-                             ares_socket_t read_fd, struct timeval *now);
-static void advance_tcp_send_queue(ares_channel channel, int whichserver,
-                                   ares_ssize_t num_bytes);
-static void process_timeouts(ares_channel channel, struct timeval *now);
-static void process_broken_connections(ares_channel channel,
-                                       struct timeval *now);
-static void process_answer(ares_channel channel, unsigned char *abuf,
-                           int alen, int whichserver, int tcp,
-                           struct timeval *now);
-static void handle_error(ares_channel channel, int whichserver,
-                         struct timeval *now);
-static void skip_server(ares_channel channel, struct query *query,
-                        int whichserver);
-static void next_server(ares_channel channel, struct query *query,
-                        struct timeval *now);
-static int open_tcp_socket(ares_channel channel, struct server_state *server);
-static int open_udp_socket(ares_channel channel, struct server_state *server);
-static int same_questions(const unsigned char *qbuf, int qlen,
-                          const unsigned char *abuf, int alen);
-static int same_address(struct sockaddr *sa, struct ares_addr *aa);
-static int has_opt_rr(const unsigned char *abuf, int alen);
-static void end_query(ares_channel channel, struct query *query, int status,
-                      unsigned char *abuf, int alen);
+static void          timeadd(ares_timeval_t *now, size_t millisecs);
+static ares_status_t process_write(ares_channel_t *channel,
+                                   ares_socket_t   write_fd);
+static ares_status_t process_read(ares_channel_t       *channel,
+                                  ares_socket_t         read_fd,
+                                  const ares_timeval_t *now);
+static ares_status_t process_timeouts(ares_channel_t       *channel,
+                                      const ares_timeval_t *now);
+static ares_status_t process_answer(ares_channel_t      *channel,
+                                    const unsigned char *abuf, size_t alen,
+                                    ares_conn_t          *conn,
+                                    const ares_timeval_t *now,
+                                    ares_array_t        **requeue);
+static void handle_conn_error(ares_conn_t *conn, ares_bool_t critical_failure,
+                              ares_status_t failure_status);
+static ares_bool_t same_questions(const ares_query_t      *query,
+                                  const ares_dns_record_t *arec);
+static void        end_query(ares_channel_t *channel, ares_server_t *server,
+                             ares_query_t *query, ares_status_t status,
+                             const ares_dns_record_t *dnsrec);
+
+static void        ares_query_remove_from_conn(ares_query_t *query)
+{
+  /* If its not part of a connection, it can't be tracked for timeouts either */
+  ares_slist_node_destroy(query->node_queries_by_timeout);
+  ares_llist_node_destroy(query->node_queries_to_conn);
+  query->node_queries_by_timeout = NULL;
+  query->node_queries_to_conn    = NULL;
+  query->conn                    = NULL;
+}
 
-/* return true if now is exactly check time or later */
-int ares__timedout(struct timeval *now,
-                   struct timeval *check)
+/* Invoke the server state callback after a success or failure */
+static void invoke_server_state_cb(const ares_server_t *server,
+                                   ares_bool_t success, int flags)
 {
-  long secs = (now->tv_sec - check->tv_sec);
+  const ares_channel_t *channel = server->channel;
+  ares_buf_t           *buf;
+  ares_status_t         status;
+  char                 *server_string;
+
+  if (channel->server_state_cb == NULL) {
+    return;
+  }
 
-  if(secs > 0)
-    return 1; /* yes, timed out */
-  if(secs < 0)
-    return 0; /* nope, not timed out */
+  buf = ares_buf_create();
+  if (buf == NULL) {
+    return; /* LCOV_EXCL_LINE: OutOfMemory */
+  }
 
-  /* if the full seconds were identical, check the sub second parts */
-  return (now->tv_usec - check->tv_usec >= 0);
+  status = ares_get_server_addr(server, buf);
+  if (status != ARES_SUCCESS) {
+    ares_buf_destroy(buf); /* LCOV_EXCL_LINE: OutOfMemory */
+    return;                /* LCOV_EXCL_LINE: OutOfMemory */
+  }
+
+  server_string = ares_buf_finish_str(buf, NULL);
+  buf           = NULL;
+  if (server_string == NULL) {
+    return; /* LCOV_EXCL_LINE: OutOfMemory */
+  }
+
+  channel->server_state_cb(server_string, success, flags,
+                           channel->server_state_cb_data);
+  ares_free(server_string);
 }
 
-/* add the specific number of milliseconds to the time in the first argument */
-static void timeadd(struct timeval *now, int millisecs)
+static void server_increment_failures(ares_server_t *server,
+                                      ares_bool_t    used_tcp)
 {
-  now->tv_sec += millisecs/1000;
-  now->tv_usec += (millisecs%1000)*1000;
+  ares_slist_node_t    *node;
+  const ares_channel_t *channel = server->channel;
+  ares_timeval_t        next_retry_time;
 
-  if(now->tv_usec >= 1000000) {
-    ++(now->tv_sec);
-    now->tv_usec -= 1000000;
+  node = ares_slist_node_find(channel->servers, server);
+  if (node == NULL) {
+    return; /* LCOV_EXCL_LINE: DefensiveCoding */
   }
+
+  server->consec_failures++;
+  ares_slist_node_reinsert(node);
+
+  ares_tvnow(&next_retry_time);
+  timeadd(&next_retry_time, channel->server_retry_delay);
+  server->next_retry_time = next_retry_time;
+
+  invoke_server_state_cb(server, ARES_FALSE,
+                         used_tcp == ARES_TRUE ? ARES_SERV_STATE_TCP
+                                               : ARES_SERV_STATE_UDP);
 }
 
-/*
- * generic process function
- */
-static void processfds(ares_channel channel,
-                       fd_set *read_fds, ares_socket_t read_fd,
-                       fd_set *write_fds, ares_socket_t write_fd)
+static void server_set_good(ares_server_t *server, ares_bool_t used_tcp)
 {
-  struct timeval now = ares__tvnow();
+  ares_slist_node_t    *node;
+  const ares_channel_t *channel = server->channel;
+
+  node = ares_slist_node_find(channel->servers, server);
+  if (node == NULL) {
+    return; /* LCOV_EXCL_LINE: DefensiveCoding */
+  }
+
+  if (server->consec_failures > 0) {
+    server->consec_failures = 0;
+    ares_slist_node_reinsert(node);
+  }
+
+  server->next_retry_time.sec  = 0;
+  server->next_retry_time.usec = 0;
 
-  write_tcp_data(channel, write_fds, write_fd, &now);
-  read_tcp_data(channel, read_fds, read_fd, &now);
-  read_udp_packets(channel, read_fds, read_fd, &now);
-  process_timeouts(channel, &now);
-  process_broken_connections(channel, &now);
+  invoke_server_state_cb(server, ARES_TRUE,
+                         used_tcp == ARES_TRUE ? ARES_SERV_STATE_TCP
+                                               : ARES_SERV_STATE_UDP);
 }
 
-/* Something interesting happened on the wire, or there was a timeout.
- * See what's up and respond accordingly.
- */
-void ares_process(ares_channel channel, fd_set *read_fds, fd_set *write_fds)
+/* return true if now is exactly check time or later */
+ares_bool_t ares_timedout(const ares_timeval_t *now,
+                          const ares_timeval_t *check)
 {
-  processfds(channel, read_fds, ARES_SOCKET_BAD, write_fds, ARES_SOCKET_BAD);
+  ares_int64_t secs = (now->sec - check->sec);
+
+  if (secs > 0) {
+    return ARES_TRUE; /* yes, timed out */
+  }
+  if (secs < 0) {
+    return ARES_FALSE; /* nope, not timed out */
+  }
+
+  /* if the full seconds were identical, check the sub second parts */
+  return ((ares_int64_t)now->usec - (ares_int64_t)check->usec) >= 0
+           ? ARES_TRUE
+           : ARES_FALSE;
 }
 
-/* Something interesting happened on the wire, or there was a timeout.
- * See what's up and respond accordingly.
- */
-void ares_process_fd(ares_channel channel,
-                     ares_socket_t read_fd, /* use ARES_SOCKET_BAD or valid
-                                               file descriptors */
-                     ares_socket_t write_fd)
+/* add the specific number of milliseconds to the time in the first argument */
+static void timeadd(ares_timeval_t *now, size_t millisecs)
 {
-  processfds(channel, NULL, read_fd, NULL, write_fd);
-}
+  now->sec  += (ares_int64_t)millisecs / 1000;
+  now->usec += (unsigned int)((millisecs % 1000) * 1000);
 
+  if (now->usec >= 1000000) {
+    now->sec  += now->usec / 1000000;
+    now->usec %= 1000000;
+  }
+}
 
-/* Return 1 if the specified error number describes a readiness error, or 0
- * otherwise. This is mostly for HP-UX, which could return EAGAIN or
- * EWOULDBLOCK. See this man page
- *
- * http://devrsrc1.external.hp.com/STKS/cgi-bin/man2html?
- *     manpage=/usr/share/man/man2.Z/send.2
- */
-static int try_again(int errnum)
+static ares_status_t ares_process_fds_nolock(ares_channel_t         *channel,
+                                             const ares_fd_events_t *events,
+                                             size_t nevents, unsigned int flags)
 {
-#if !defined EWOULDBLOCK && !defined EAGAIN
-#error "Neither EWOULDBLOCK nor EAGAIN defined"
-#endif
-  switch (errnum)
-    {
-#ifdef EWOULDBLOCK
-    case EWOULDBLOCK:
-      return 1;
-#endif
-#if defined EAGAIN && EAGAIN != EWOULDBLOCK
-    case EAGAIN:
-      return 1;
-#endif
+  ares_timeval_t now;
+  size_t         i;
+  ares_status_t  status = ARES_SUCCESS;
+
+  if (channel == NULL || (events == NULL && nevents != 0)) {
+    return ARES_EFORMERR; /* LCOV_EXCL_LINE: DefensiveCoding */
+  }
+
+  ares_tvnow(&now);
+
+  /* Process write events */
+  for (i = 0; i < nevents; i++) {
+    if (events[i].fd == ARES_SOCKET_BAD ||
+        !(events[i].events & ARES_FD_EVENT_WRITE)) {
+      continue;
+    }
+    status = process_write(channel, events[i].fd);
+    /* We only care about ENOMEM, anything else is handled via connection
+     * retries, etc */
+    if (status == ARES_ENOMEM) {
+      goto done;
+    }
+  }
+
+  /* Process read events */
+  for (i = 0; i < nevents; i++) {
+    if (events[i].fd == ARES_SOCKET_BAD ||
+        !(events[i].events & ARES_FD_EVENT_READ)) {
+      continue;
+    }
+    status = process_read(channel, events[i].fd, &now);
+    if (status == ARES_ENOMEM) {
+      goto done;
+    }
+  }
+
+  if (!(flags & ARES_PROCESS_FLAG_SKIP_NON_FD)) {
+    ares_check_cleanup_conns(channel);
+    status = process_timeouts(channel, &now);
+    if (status == ARES_ENOMEM) {
+      goto done;
     }
-  return 0;
+  }
+
+done:
+  if (status == ARES_ENOMEM) {
+    return ARES_ENOMEM;
+  }
+  return ARES_SUCCESS;
 }
 
-static ares_ssize_t socket_writev(ares_channel channel, ares_socket_t s, const struct iovec * vec, int len)
+ares_status_t ares_process_fds(ares_channel_t         *channel,
+                               const ares_fd_events_t *events, size_t nevents,
+                               unsigned int flags)
 {
-  if (channel->sock_funcs)
-    return channel->sock_funcs->asendv(s, vec, len, channel->sock_func_cb_data);
+  ares_status_t status;
 
-  return writev(s, vec, len);
+  if (channel == NULL) {
+    return ARES_EFORMERR;
+  }
+
+  ares_channel_lock(channel);
+  status = ares_process_fds_nolock(channel, events, nevents, flags);
+  ares_channel_unlock(channel);
+  return status;
 }
 
-static ares_ssize_t socket_write(ares_channel channel, ares_socket_t s, const void * data, size_t len)
+void ares_process_fd(ares_channel_t *channel, ares_socket_t read_fd,
+                     ares_socket_t write_fd)
 {
-  if (channel->sock_funcs)
-    {
-      struct iovec vec;
-      vec.iov_base = (void*)data;
-      vec.iov_len = len;
-      return channel->sock_funcs->asendv(s, &vec, 1, channel->sock_func_cb_data);
+  ares_fd_events_t events[2];
+  size_t           nevents = 0;
+
+  memset(events, 0, sizeof(events));
+
+  if (read_fd != ARES_SOCKET_BAD) {
+    nevents++;
+    events[nevents - 1].fd      = read_fd;
+    events[nevents - 1].events |= ARES_FD_EVENT_READ;
+  }
+
+  if (write_fd != ARES_SOCKET_BAD) {
+    if (write_fd != read_fd) {
+      nevents++;
     }
-  return swrite(s, data, len);
+    events[nevents - 1].fd      = write_fd;
+    events[nevents - 1].events |= ARES_FD_EVENT_WRITE;
+  }
+
+  ares_process_fds(channel, events, nevents, ARES_PROCESS_FLAG_NONE);
 }
 
-/* If any TCP sockets select true for writing, write out queued data
- * we have for them.
- */
-static void write_tcp_data(ares_channel channel,
-                           fd_set *write_fds,
-                           ares_socket_t write_fd,
-                           struct timeval *now)
+static ares_socket_t *channel_socket_list(const ares_channel_t *channel,
+                                          size_t               *num)
 {
-  struct server_state *server;
-  struct send_request *sendreq;
-  struct iovec *vec;
-  int i;
-  ares_ssize_t scount;
-  ares_ssize_t wcount;
-  size_t n;
-  /* From writev manpage: An implementation can advertise its limit by defining
-     IOV_MAX in <limits.h> or at run time via the return value from
-     sysconf(_SC_IOV_MAX). On modern Linux systems, the limit is 1024. Back in
-     Linux 2.0 days, this limit was 16. */
-#if defined(IOV_MAX)
-  const size_t maxn = IOV_MAX;   /* FreeBSD */
-#elif defined(_SC_IOV_MAX)
-  const size_t maxn = sysconf(_SC_IOV_MAX);   /* Linux */
-#else
-  const size_t maxn = 16;   /* Safe default */
-#endif
+  ares_slist_node_t *snode;
+  ares_array_t      *arr = ares_array_create(sizeof(ares_socket_t), NULL);
 
-  if(!write_fds && (write_fd == ARES_SOCKET_BAD))
-    /* no possible action */
-    return;
+  *num = 0;
 
-  for (i = 0; i < channel->nservers; i++)
-    {
-      /* Make sure server has data to send and is selected in write_fds or
-         write_fd. */
-      server = &channel->servers[i];
-      if (!server->qhead || server->tcp_socket == ARES_SOCKET_BAD ||
-          server->is_broken)
-        continue;
+  if (arr == NULL) {
+    return NULL; /* LCOV_EXCL_LINE: OutOfMemory */
+  }
 
-      if(write_fds) {
-        if(!FD_ISSET(server->tcp_socket, write_fds))
-          continue;
-      }
-      else {
-        if(server->tcp_socket != write_fd)
-          continue;
+  for (snode = ares_slist_node_first(channel->servers); snode != NULL;
+       snode = ares_slist_node_next(snode)) {
+    ares_server_t     *server = ares_slist_node_val(snode);
+    ares_llist_node_t *node;
+
+    for (node = ares_llist_node_first(server->connections); node != NULL;
+         node = ares_llist_node_next(node)) {
+      const ares_conn_t *conn = ares_llist_node_val(node);
+      ares_socket_t     *sptr;
+      ares_status_t      status;
+
+      if (conn->fd == ARES_SOCKET_BAD) {
+        continue;
       }
 
-      if(write_fds)
-        /* If there's an error and we close this socket, then open
-         * another with the same fd to talk to another server, then we
-         * don't want to think that it was the new socket that was
-         * ready. This is not disastrous, but is likely to result in
-         * extra system calls and confusion. */
-        FD_CLR(server->tcp_socket, write_fds);
-
-      /* Count the number of send queue items. */
-      n = 0;
-      for (sendreq = server->qhead; sendreq; sendreq = sendreq->next)
-        n++;
-
-      /* Allocate iovecs so we can send all our data at once. */
-      vec = ares_malloc(n * sizeof(struct iovec));
-      if (vec)
-        {
-          /* Fill in the iovecs and send. */
-          n = 0;
-          for (sendreq = server->qhead; sendreq; sendreq = sendreq->next)
-            {
-              vec[n].iov_base = (char *) sendreq->data;
-              vec[n].iov_len = sendreq->len;
-              n++;
-              if(n >= maxn)
-                break;
-            }
-          wcount = socket_writev(channel, server->tcp_socket, vec, (int)n);
-          ares_free(vec);
-          if (wcount < 0)
-            {
-              if (!try_again(SOCKERRNO))
-                handle_error(channel, i, now);
-              continue;
-            }
-
-          /* Advance the send queue by as many bytes as we sent. */
-          advance_tcp_send_queue(channel, i, wcount);
-        }
-      else
-        {
-          /* Can't allocate iovecs; just send the first request. */
-          sendreq = server->qhead;
-
-          scount = socket_write(channel, server->tcp_socket, sendreq->data, sendreq->len);
-          if (scount < 0)
-            {
-              if (!try_again(SOCKERRNO))
-                handle_error(channel, i, now);
-              continue;
-            }
-
-          /* Advance the send queue by as many bytes as we sent. */
-          advance_tcp_send_queue(channel, i, scount);
-        }
+      status = ares_array_insert_last((void **)&sptr, arr);
+      if (status != ARES_SUCCESS) {
+        ares_array_destroy(arr); /* LCOV_EXCL_LINE: OutOfMemory */
+        return NULL;             /* LCOV_EXCL_LINE: OutOfMemory */
+      }
+      *sptr = conn->fd;
     }
+  }
+
+  return ares_array_finish(arr, num);
 }
 
-/* Consume the given number of bytes from the head of the TCP send queue. */
-static void advance_tcp_send_queue(ares_channel channel, int whichserver,
-                                   ares_ssize_t num_bytes)
+/* Something interesting happened on the wire, or there was a timeout.
+ * See what's up and respond accordingly.
+ */
+void ares_process(ares_channel_t *channel, fd_set *read_fds, fd_set *write_fds)
 {
-  struct send_request *sendreq;
-  struct server_state *server = &channel->servers[whichserver];
-  while (num_bytes > 0) {
-    sendreq = server->qhead;
-    if ((size_t)num_bytes >= sendreq->len) {
-      num_bytes -= sendreq->len;
-      server->qhead = sendreq->next;
-      if (sendreq->data_storage)
-        ares_free(sendreq->data_storage);
-      ares_free(sendreq);
-      if (server->qhead == NULL) {
-        SOCK_STATE_CALLBACK(channel, server->tcp_socket, 1, 0);
-        server->qtail = NULL;
-
-        /* qhead is NULL so we cannot continue this loop */
-        break;
-      }
+  size_t            i;
+  size_t            num_sockets;
+  ares_socket_t    *socketlist;
+  ares_fd_events_t *events  = NULL;
+  size_t            nevents = 0;
+
+  if (channel == NULL) {
+    return;
+  }
+
+  ares_channel_lock(channel);
+
+  /* There is no good way to iterate across an fd_set, instead we must pull a
+   * list of all known fds, and iterate across that checking against the fd_set.
+   */
+  socketlist = channel_socket_list(channel, &num_sockets);
+
+  /* Lets create an events array, maximum number is the number of sockets in
+   * the list, so we'll use that and just track entries with nevents */
+  if (num_sockets) {
+    events = ares_malloc_zero(sizeof(*events) * num_sockets);
+    if (events == NULL) {
+      goto done;
+    }
+  }
+
+  for (i = 0; i < num_sockets; i++) {
+    ares_bool_t had_read = ARES_FALSE;
+    if (read_fds && FD_ISSET(socketlist[i], read_fds)) {
+      nevents++;
+      events[nevents - 1].fd      = socketlist[i];
+      events[nevents - 1].events |= ARES_FD_EVENT_READ;
+      had_read                    = ARES_TRUE;
     }
-    else {
-      sendreq->data += num_bytes;
-      sendreq->len -= num_bytes;
-      num_bytes = 0;
+    if (write_fds && FD_ISSET(socketlist[i], write_fds)) {
+      if (!had_read) {
+        nevents++;
+      }
+      events[nevents - 1].fd      = socketlist[i];
+      events[nevents - 1].events |= ARES_FD_EVENT_WRITE;
     }
   }
-}
 
-static ares_ssize_t socket_recvfrom(ares_channel channel,
-   ares_socket_t s,
-   void * data,
-   size_t data_len,
-   int flags,
-   struct sockaddr *from,
-   ares_socklen_t *from_len)
-{
-   if (channel->sock_funcs)
-      return channel->sock_funcs->arecvfrom(s, data, data_len,
-	 flags, from, from_len,
-	 channel->sock_func_cb_data);
-
-#ifdef HAVE_RECVFROM
-   return recvfrom(s, data, data_len, flags, from, from_len);
-#else
-   return sread(s, data, data_len);
-#endif
+done:
+  ares_process_fds_nolock(channel, events, nevents, ARES_PROCESS_FLAG_NONE);
+  ares_free(events);
+  ares_free(socketlist);
+  ares_channel_unlock(channel);
 }
 
-static ares_ssize_t socket_recv(ares_channel channel,
-   ares_socket_t s,
-   void * data,
-   size_t data_len)
+static ares_status_t process_write(ares_channel_t *channel,
+                                   ares_socket_t   write_fd)
 {
-   if (channel->sock_funcs)
-      return channel->sock_funcs->arecvfrom(s, data, data_len, 0, 0, 0,
-	 channel->sock_func_cb_data);
+  ares_conn_t  *conn = ares_conn_from_fd(channel, write_fd);
+  ares_status_t status;
 
-   return sread(s, data, data_len);
+  if (conn == NULL) {
+    return ARES_SUCCESS;
+  }
+
+  /* Mark as connected if we got here and TFO Initial not set */
+  if (!(conn->flags & ARES_CONN_FLAG_TFO_INITIAL)) {
+    conn->state_flags |= ARES_CONN_STATE_CONNECTED;
+  }
+
+  status = ares_conn_flush(conn);
+  if (status != ARES_SUCCESS) {
+    handle_conn_error(conn, ARES_TRUE, status);
+  }
+  return status;
 }
 
-/* If any TCP socket selects true for reading, read some data,
- * allocate a buffer if we finish reading the length word, and process
- * a packet if we finish reading one.
- */
-static void read_tcp_data(ares_channel channel, fd_set *read_fds,
-                          ares_socket_t read_fd, struct timeval *now)
+void ares_process_pending_write(ares_channel_t *channel)
 {
-  struct server_state *server;
-  int i;
-  ares_ssize_t count;
+  ares_slist_node_t *node;
 
-  if(!read_fds && (read_fd == ARES_SOCKET_BAD))
-    /* no possible action */
+  if (channel == NULL) {
     return;
+  }
 
-  for (i = 0; i < channel->nservers; i++)
-    {
-      /* Make sure the server has a socket and is selected in read_fds. */
-      server = &channel->servers[i];
-      if (server->tcp_socket == ARES_SOCKET_BAD || server->is_broken)
-        continue;
+  ares_channel_lock(channel);
+  if (!channel->notify_pending_write) {
+    ares_channel_unlock(channel);
+    return;
+  }
 
-      if(read_fds) {
-        if(!FD_ISSET(server->tcp_socket, read_fds))
-          continue;
-      }
-      else {
-        if(server->tcp_socket != read_fd)
-          continue;
-      }
+  /* Set as untriggerd before calling into ares_conn_flush(), this is
+   * because its possible ares_conn_flush() might cause additional data to
+   * be enqueued if there is some form of exception so it will need to recurse.
+   */
+  channel->notify_pending_write = ARES_FALSE;
+
+  for (node = ares_slist_node_first(channel->servers); node != NULL;
+       node = ares_slist_node_next(node)) {
+    ares_server_t *server = ares_slist_node_val(node);
+    ares_conn_t   *conn   = server->tcp_conn;
+    ares_status_t  status;
+
+    if (conn == NULL) {
+      continue;
+    }
 
-      if(read_fds)
-        /* If there's an error and we close this socket, then open another
-         * with the same fd to talk to another server, then we don't want to
-         * think that it was the new socket that was ready. This is not
-         * disastrous, but is likely to result in extra system calls and
-         * confusion. */
-        FD_CLR(server->tcp_socket, read_fds);
-
-      if (server->tcp_lenbuf_pos != 2)
-        {
-          /* We haven't yet read a length word, so read that (or
-           * what's left to read of it).
-           */
-          count = socket_recv(channel, server->tcp_socket,
-			      server->tcp_lenbuf + server->tcp_lenbuf_pos,
-			      2 - server->tcp_lenbuf_pos);
-          if (count <= 0)
-            {
-              if (!(count == -1 && try_again(SOCKERRNO)))
-                handle_error(channel, i, now);
-              continue;
-            }
-
-          server->tcp_lenbuf_pos += (int)count;
-          if (server->tcp_lenbuf_pos == 2)
-            {
-              /* We finished reading the length word.  Decode the
-               * length and allocate a buffer for the data.
-               */
-              server->tcp_length = server->tcp_lenbuf[0] << 8
-                | server->tcp_lenbuf[1];
-              server->tcp_buffer = ares_malloc(server->tcp_length);
-              if (!server->tcp_buffer) {
-                handle_error(channel, i, now);
-                return; /* bail out on malloc failure. TODO: make this
-                           function return error codes */
-              }
-              server->tcp_buffer_pos = 0;
-            }
-        }
-      else
-        {
-          /* Read data into the allocated buffer. */
-          count = socket_recv(channel, server->tcp_socket,
-			      server->tcp_buffer + server->tcp_buffer_pos,
-			      server->tcp_length - server->tcp_buffer_pos);
-          if (count <= 0)
-            {
-              if (!(count == -1 && try_again(SOCKERRNO)))
-                handle_error(channel, i, now);
-              continue;
-            }
-
-          server->tcp_buffer_pos += (int)count;
-          if (server->tcp_buffer_pos == server->tcp_length)
-            {
-              /* We finished reading this answer; process it and
-               * prepare to read another length word.
-               */
-              process_answer(channel, server->tcp_buffer, server->tcp_length,
-                             i, 1, now);
-              ares_free(server->tcp_buffer);
-              server->tcp_buffer = NULL;
-              server->tcp_lenbuf_pos = 0;
-              server->tcp_buffer_pos = 0;
-            }
-        }
+    /* Enqueue any pending data if there is any */
+    status = ares_conn_flush(conn);
+    if (status != ARES_SUCCESS) {
+      handle_conn_error(conn, ARES_TRUE, status);
     }
+  }
+
+  ares_channel_unlock(channel);
 }
 
-/* If any UDP sockets select true for reading, process them. */
-static void read_udp_packets(ares_channel channel, fd_set *read_fds,
-                             ares_socket_t read_fd, struct timeval *now)
+static ares_status_t read_conn_packets(ares_conn_t *conn)
 {
-  struct server_state *server;
-  int i;
-  ares_ssize_t read_len;
-  unsigned char buf[MAXENDSSZ + 1];
-#ifdef HAVE_RECVFROM
-  ares_socklen_t fromlen;
-  union {
-    struct sockaddr     sa;
-    struct sockaddr_in  sa4;
-    struct sockaddr_in6 sa6;
-  } from;
-#endif
+  ares_bool_t           read_again;
+  ares_conn_err_t       err;
+  const ares_channel_t *channel = conn->server->channel;
+
+  do {
+    size_t         count;
+    size_t         len = 65535;
+    unsigned char *ptr;
+    size_t         start_len = ares_buf_len(conn->in_buf);
+
+    /* If UDP, lets write out a placeholder for the length indicator */
+    if (!(conn->flags & ARES_CONN_FLAG_TCP) &&
+        ares_buf_append_be16(conn->in_buf, 0) != ARES_SUCCESS) {
+      handle_conn_error(conn, ARES_FALSE /* not critical to connection */,
+                        ARES_SUCCESS);
+      return ARES_ENOMEM;
+    }
 
-  if(!read_fds && (read_fd == ARES_SOCKET_BAD))
-    /* no possible action */
-    return;
+    /* Get a buffer of sufficient size */
+    ptr = ares_buf_append_start(conn->in_buf, &len);
 
-  for (i = 0; i < channel->nservers; i++)
-    {
-      /* Make sure the server has a socket and is selected in read_fds. */
-      server = &channel->servers[i];
+    if (ptr == NULL) {
+      handle_conn_error(conn, ARES_FALSE /* not critical to connection */,
+                        ARES_SUCCESS);
+      return ARES_ENOMEM;
+    }
 
-      if (server->udp_socket == ARES_SOCKET_BAD || server->is_broken)
-        continue;
+    /* Read from socket */
+    err = ares_conn_read(conn, ptr, len, &count);
 
-      if(read_fds) {
-        if(!FD_ISSET(server->udp_socket, read_fds))
-          continue;
-      }
-      else {
-        if(server->udp_socket != read_fd)
-          continue;
+    if (err != ARES_CONN_ERR_SUCCESS) {
+      ares_buf_append_finish(conn->in_buf, 0);
+      if (!(conn->flags & ARES_CONN_FLAG_TCP)) {
+        ares_buf_set_length(conn->in_buf, start_len);
       }
+      break;
+    }
 
-      if(read_fds)
-        /* If there's an error and we close this socket, then open
-         * another with the same fd to talk to another server, then we
-         * don't want to think that it was the new socket that was
-         * ready. This is not disastrous, but is likely to result in
-         * extra system calls and confusion. */
-        FD_CLR(server->udp_socket, read_fds);
-
-      /* To reduce event loop overhead, read and process as many
-       * packets as we can. */
-      do {
-        if (server->udp_socket == ARES_SOCKET_BAD) {
-          read_len = -1;
-        } else {
-          if (server->addr.family == AF_INET) {
-            fromlen = sizeof(from.sa4);
-          } else {
-            fromlen = sizeof(from.sa6);
-          }
-          read_len = socket_recvfrom(channel, server->udp_socket, (void *)buf,
-                                     sizeof(buf), 0, &from.sa, &fromlen);
-        }
-
-        if (read_len == 0) {
-          /* UDP is connectionless, so result code of 0 is a 0-length UDP
-           * packet, and not an indication the connection is closed like on
-           * tcp */
-          continue;
-        } else if (read_len < 0) {
-          if (try_again(SOCKERRNO))
-            continue;
-
-          handle_error(channel, i, now);
-
-#ifdef HAVE_RECVFROM
-        } else if (!same_address(&from.sa, &server->addr)) {
-          /* The address the response comes from does not match the address we
-           * sent the request to. Someone may be attempting to perform a cache
-           * poisoning attack. */
-          continue;
-#endif
+    /* Record amount of data read */
+    ares_buf_append_finish(conn->in_buf, count);
+
+    /* Only loop if sockets support non-blocking operation, and are using UDP
+     * or are using TCP and read the maximum buffer size */
+    read_again = ARES_FALSE;
+    if (channel->sock_funcs.flags & ARES_SOCKFUNC_FLAG_NONBLOCKING &&
+        (!(conn->flags & ARES_CONN_FLAG_TCP) || count == len)) {
+      read_again = ARES_TRUE;
+    }
 
-        } else {
-          process_answer(channel, buf, (int)read_len, i, 0, now);
-        }
-      } while (read_len >= 0);
+    /* If UDP, overwrite length */
+    if (!(conn->flags & ARES_CONN_FLAG_TCP)) {
+      len = ares_buf_len(conn->in_buf);
+      ares_buf_set_length(conn->in_buf, start_len);
+      ares_buf_append_be16(conn->in_buf, (unsigned short)count);
+      ares_buf_set_length(conn->in_buf, len);
     }
+    /* Try to read again only if *we* set up the socket, otherwise it may be
+     * a blocking socket and would cause recvfrom to hang. */
+  } while (read_again);
+
+  if (err != ARES_CONN_ERR_SUCCESS && err != ARES_CONN_ERR_WOULDBLOCK) {
+    handle_conn_error(conn, ARES_TRUE, ARES_ECONNREFUSED);
+    return ARES_ECONNREFUSED;
+  }
+
+  return ARES_SUCCESS;
 }
 
-/* If any queries have timed out, note the timeout and move them on. */
-static void process_timeouts(ares_channel channel, struct timeval *now)
+/* Simple data structure to store a query that needs to be requeued with
+ * optional server */
+typedef struct {
+  unsigned short qid;
+  ares_server_t *server; /* optional */
+} ares_requeue_t;
+
+static ares_status_t ares_append_requeue(ares_array_t **requeue,
+                                         ares_query_t *query,
+                                         ares_server_t *server)
 {
-  time_t t;  /* the time of the timeouts we're processing */
-  struct query *query;
-  struct list_node* list_head;
-  struct list_node* list_node;
-
-  /* Process all the timeouts that have fired since the last time we processed
-   * timeouts. If things are going well, then we'll have hundreds/thousands of
-   * queries that fall into future buckets, and only a handful of requests
-   * that fall into the "now" bucket, so this should be quite quick.
-   */
-  for (t = channel->last_timeout_processed; t <= now->tv_sec; t++)
-    {
-      list_head = &(channel->queries_by_timeout[t % ARES_TIMEOUT_TABLE_SIZE]);
-      for (list_node = list_head->next; list_node != list_head; )
-        {
-          query = list_node->data;
-          list_node = list_node->next;  /* in case the query gets deleted */
-          if (query->timeout.tv_sec && ares__timedout(now, &query->timeout))
-            {
-              query->error_status = ARES_ETIMEOUT;
-              ++query->timeouts;
-              next_server(channel, query, now);
-            }
-        }
-     }
-  channel->last_timeout_processed = now->tv_sec;
+  ares_requeue_t entry;
+
+  if (*requeue == NULL) {
+    *requeue = ares_array_create(sizeof(ares_requeue_t), NULL);
+    if (*requeue == NULL) {
+      return ARES_ENOMEM;
+    }
+  }
+
+  ares_query_remove_from_conn(query);
+
+  entry.qid    = query->qid;
+  entry.server = server;
+  return ares_array_insertdata_last(*requeue, &entry);
 }
 
-/* Handle an answer from a server. */
-static void process_answer(ares_channel channel, unsigned char *abuf,
-                           int alen, int whichserver, int tcp,
-                           struct timeval *now)
+static ares_status_t read_answers(ares_conn_t *conn, const ares_timeval_t *now)
 {
-  int tc, rcode, packetsz;
-  unsigned short id;
-  struct query *query;
-  struct list_node* list_head;
-  struct list_node* list_node;
-
-  /* If there's no room in the answer for a header, we can't do much
-   * with it. */
-  if (alen < HFIXEDSZ)
-    return;
+  ares_status_t   status;
+  ares_channel_t *channel = conn->server->channel;
+  ares_array_t   *requeue = NULL;
+
+  /* Process all queued answers */
+  while (1) {
+    unsigned short       dns_len  = 0;
+    const unsigned char *data     = NULL;
+    size_t               data_len = 0;
+
+    /* Tag so we can roll back */
+    ares_buf_tag(conn->in_buf);
+
+    /* Read length indicator */
+    status = ares_buf_fetch_be16(conn->in_buf, &dns_len);
+    if (status != ARES_SUCCESS) {
+      ares_buf_tag_rollback(conn->in_buf);
+      break;
+    }
 
-  /* Grab the query ID, truncate bit, and response code from the packet. */
-  id = DNS_HEADER_QID(abuf);
-  tc = DNS_HEADER_TC(abuf);
-  rcode = DNS_HEADER_RCODE(abuf);
+    /* Not enough data for a full response yet */
+    status = ares_buf_consume(conn->in_buf, dns_len);
+    if (status != ARES_SUCCESS) {
+      ares_buf_tag_rollback(conn->in_buf);
+      break;
+    }
 
-  /* Find the query corresponding to this packet. The queries are
-   * hashed/bucketed by query id, so this lookup should be quick.  Note that
-   * both the query id and the questions must be the same; when the query id
-   * wraps around we can have multiple outstanding queries with the same query
-   * id, so we need to check both the id and question.
-   */
-  query = NULL;
-  list_head = &(channel->queries_by_qid[id % ARES_QID_TABLE_SIZE]);
-  for (list_node = list_head->next; list_node != list_head;
-       list_node = list_node->next)
-    {
-      struct query *q = list_node->data;
-      if ((q->qid == id) && same_questions(q->qbuf, q->qlen, abuf, alen))
-        {
-          query = q;
-          break;
-        }
+    /* Can't fail except for misuse */
+    data = ares_buf_tag_fetch(conn->in_buf, &data_len);
+    if (data == NULL || data_len < 2) {
+      ares_buf_tag_clear(conn->in_buf);
+      break;
     }
-  if (!query)
-    return;
 
-  packetsz = PACKETSZ;
-  /* If we use EDNS and server answers with FORMERR without an OPT RR, the protocol
-   * extension is not understood by the responder. We must retry the query
-   * without EDNS enabled. */
-  if (channel->flags & ARES_FLAG_EDNS)
-  {
-      packetsz = channel->ednspsz;
-      if (rcode == FORMERR && has_opt_rr(abuf, alen) != 1)
-      {
-          int qlen = (query->tcplen - 2) - EDNSFIXEDSZ;
-          channel->flags ^= ARES_FLAG_EDNS;
-          query->tcplen -= EDNSFIXEDSZ;
-          query->qlen -= EDNSFIXEDSZ;
-          query->tcpbuf[0] = (unsigned char)((qlen >> 8) & 0xff);
-          query->tcpbuf[1] = (unsigned char)(qlen & 0xff);
-          DNS_HEADER_SET_ARCOUNT(query->tcpbuf + 2, 0);
-          query->tcpbuf = ares_realloc(query->tcpbuf, query->tcplen);
-          query->qbuf = query->tcpbuf + 2;
-          ares__send_query(channel, query, now);
-          return;
-      }
-  }
+    /* Strip off 2 bytes length */
+    data     += 2;
+    data_len -= 2;
 
-  /* If we got a truncated UDP packet and are not ignoring truncation,
-   * don't accept the packet, and switch the query to TCP if we hadn't
-   * done so already.
-   */
-  if ((tc || alen > packetsz) && !tcp && !(channel->flags & ARES_FLAG_IGNTC))
-    {
-      if (!query->using_tcp)
-        {
-          query->using_tcp = 1;
-          ares__send_query(channel, query, now);
-        }
-      return;
+    /* We finished reading this answer; process it */
+    status = process_answer(channel, data, data_len, conn, now, &requeue);
+    if (status != ARES_SUCCESS) {
+      handle_conn_error(conn, ARES_TRUE, status);
+      goto cleanup;
     }
 
-  /* Limit alen to PACKETSZ if we aren't using TCP (only relevant if we
-   * are ignoring truncation.
-   */
-  if (alen > packetsz && !tcp)
-      alen = packetsz;
+    /* Since we processed the answer, clear the tag so space can be reclaimed */
+    ares_buf_tag_clear(conn->in_buf);
+  }
 
-  /* If we aren't passing through all error packets, discard packets
-   * with SERVFAIL, NOTIMP, or REFUSED response codes.
-   */
-  if (!(channel->flags & ARES_FLAG_NOCHECKRESP))
-    {
-      if (rcode == SERVFAIL || rcode == NOTIMP || rcode == REFUSED)
-        {
-          skip_server(channel, query, whichserver);
-          if (query->server == whichserver)
-            next_server(channel, query, now);
-          return;
-        }
+cleanup:
+
+  /* Flush requeue */
+  while (ares_array_len(requeue) > 0) {
+    ares_query_t  *query;
+    ares_requeue_t entry;
+    ares_status_t  internal_status;
+
+    internal_status = ares_array_claim_at(&entry, sizeof(entry), requeue, 0);
+    if (internal_status != ARES_SUCCESS) {
+      break;
     }
 
-  end_query(channel, query, ARES_SUCCESS, abuf, alen);
-}
+    /* Query disappeared */
+    query = ares_htable_szvp_get_direct(channel->queries_by_qid, entry.qid);
+    if (query == NULL) {
+      continue;
+    }
 
-/* Close all the connections that are no longer usable. */
-static void process_broken_connections(ares_channel channel,
-                                       struct timeval *now)
-{
-  int i;
-  for (i = 0; i < channel->nservers; i++)
-    {
-      struct server_state *server = &channel->servers[i];
-      if (server->is_broken)
-        {
-          handle_error(channel, i, now);
-        }
+    internal_status = ares_send_query(entry.server, query, now);
+    /* We only care about ARES_ENOMEM */
+    if (internal_status == ARES_ENOMEM) {
+      status = ARES_ENOMEM;
     }
+  }
+  ares_array_destroy(requeue);
+
+  return status;
 }
 
-/* Swap the contents of two lists */
-static void swap_lists(struct list_node* head_a,
-                       struct list_node* head_b)
+static ares_status_t process_read(ares_channel_t       *channel,
+                                  ares_socket_t         read_fd,
+                                  const ares_timeval_t *now)
 {
-  int is_a_empty = ares__is_list_empty(head_a);
-  int is_b_empty = ares__is_list_empty(head_b);
-  struct list_node old_a = *head_a;
-  struct list_node old_b = *head_b;
+  ares_conn_t  *conn = ares_conn_from_fd(channel, read_fd);
+  ares_status_t status;
 
-  if (is_a_empty) {
-    ares__init_list_head(head_b);
-  } else {
-    *head_b = old_a;
-    old_a.next->prev = head_b;
-    old_a.prev->next = head_b;
+  if (conn == NULL) {
+    return ARES_SUCCESS;
   }
-  if (is_b_empty) {
-    ares__init_list_head(head_a);
-  } else {
-    *head_a = old_b;
-    old_b.next->prev = head_a;
-    old_b.prev->next = head_a;
+
+  /* TODO: There might be a potential issue here where there was a read that
+   *       read some data, then looped and read again and got a disconnect.
+   *       Right now, that would cause a resend instead of processing the data
+   *       we have.  This is fairly unlikely to occur due to only looping if
+   *       a full buffer of 65535 bytes was read. */
+  status = read_conn_packets(conn);
+
+  if (status != ARES_SUCCESS) {
+    return status;
   }
+
+  return read_answers(conn, now);
 }
 
-static void handle_error(ares_channel channel, int whichserver,
-                         struct timeval *now)
+/* If any queries have timed out, note the timeout and move them on. */
+static ares_status_t process_timeouts(ares_channel_t       *channel,
+                                      const ares_timeval_t *now)
 {
-  struct server_state *server;
-  struct query *query;
-  struct list_node list_head;
-  struct list_node* list_node;
-
-  server = &channel->servers[whichserver];
+  ares_slist_node_t *node;
+  ares_status_t      status = ARES_SUCCESS;
+
+  /* Just keep popping off the first as this list will re-sort as things come
+   * and go.  We don't want to try to rely on 'next' as some operation might
+   * cause a cleanup of that pointer and would become invalid */
+  while ((node = ares_slist_node_first(channel->queries_by_timeout)) != NULL) {
+    ares_query_t *query = ares_slist_node_val(node);
+    ares_conn_t  *conn;
+
+    /* Since this is sorted, as soon as we hit a query that isn't timed out,
+     * break */
+    if (!ares_timedout(now, &query->timeout)) {
+      break;
+    }
 
-  /* Reset communications with this server. */
-  ares__close_sockets(channel, server);
+    query->timeouts++;
 
-  /* Tell all queries talking to this server to move on and not try this
-   * server again. We steal the current list of queries that were in-flight to
-   * this server, since when we call next_server this can cause the queries to
-   * be re-sent to this server, which will re-insert these queries in that
-   * same server->queries_to_server list.
-   */
-  ares__init_list_head(&list_head);
-  swap_lists(&list_head, &(server->queries_to_server));
-  for (list_node = list_head.next; list_node != &list_head; )
-    {
-      query = list_node->data;
-      list_node = list_node->next;  /* in case the query gets deleted */
-      assert(query->server == whichserver);
-      skip_server(channel, query, whichserver);
-      next_server(channel, query, now);
+    conn = query->conn;
+    server_increment_failures(conn->server, query->using_tcp);
+    status = ares_requeue_query(query, now, ARES_ETIMEOUT, ARES_TRUE, NULL,
+                                NULL);
+    if (status == ARES_ENOMEM) {
+      goto done;
     }
-  /* Each query should have removed itself from our temporary list as
-   * it re-sent itself or finished up...
-   */
-  assert(ares__is_list_empty(&list_head));
+  }
+done:
+  if (status == ARES_ENOMEM) {
+    return ARES_ENOMEM;
+  }
+  return ARES_SUCCESS;
 }
 
-static void skip_server(ares_channel channel, struct query *query,
-                        int whichserver)
+static ares_status_t rewrite_without_edns(ares_query_t *query)
 {
-  /* The given server gave us problems with this query, so if we have the
-   * luxury of using other servers, then let's skip the potentially broken
-   * server and just use the others. If we only have one server and we need to
-   * retry then we should just go ahead and re-use that server, since it's our
-   * only hope; perhaps we just got unlucky, and retrying will work (eg, the
-   * server timed out our TCP connection just as we were sending another
-   * request).
-   */
-  if (channel->nservers > 1)
-    {
-      query->server_info[whichserver].skip_server = 1;
+  ares_status_t status = ARES_SUCCESS;
+  size_t        i;
+  ares_bool_t   found_opt_rr = ARES_FALSE;
+
+  /* Find and remove the OPT RR record */
+  for (i = 0; i < ares_dns_record_rr_cnt(query->query, ARES_SECTION_ADDITIONAL);
+       i++) {
+    const ares_dns_rr_t *rr;
+    rr = ares_dns_record_rr_get(query->query, ARES_SECTION_ADDITIONAL, i);
+    if (ares_dns_rr_get_type(rr) == ARES_REC_TYPE_OPT) {
+      ares_dns_record_rr_del(query->query, ARES_SECTION_ADDITIONAL, i);
+      found_opt_rr = ARES_TRUE;
+      break;
     }
-}
+  }
 
-static void next_server(ares_channel channel, struct query *query,
-                        struct timeval *now)
-{
-  /* We need to try each server channel->tries times. We have channel->nservers
-   * servers to try. In total, we need to do channel->nservers * channel->tries
-   * attempts. Use query->try to remember how many times we already attempted
-   * this query. Use modular arithmetic to find the next server to try. */
-  while (++(query->try_count) < (channel->nservers * channel->tries))
-    {
-      struct server_state *server;
-
-      /* Move on to the next server. */
-      query->server = (query->server + 1) % channel->nservers;
-      server = &channel->servers[query->server];
-
-      /* We don't want to use this server if (1) we decided this connection is
-       * broken, and thus about to be closed, (2) we've decided to skip this
-       * server because of earlier errors we encountered, or (3) we already
-       * sent this query over this exact connection.
-       */
-      if (!server->is_broken &&
-           !query->server_info[query->server].skip_server &&
-           !(query->using_tcp &&
-             (query->server_info[query->server].tcp_connection_generation ==
-              server->tcp_connection_generation)))
-        {
-           ares__send_query(channel, query, now);
-           return;
-        }
-
-      /* You might think that with TCP we only need one try. However, even
-       * when using TCP, servers can time-out our connection just as we're
-       * sending a request, or close our connection because they die, or never
-       * send us a reply because they get wedged or tickle a bug that drops
-       * our request.
-       */
-    }
+  if (!found_opt_rr) {
+    status = ARES_EFORMERR;
+    goto done;
+  }
 
-  /* If we are here, all attempts to perform query failed. */
-  end_query(channel, query, query->error_status, NULL, 0);
+done:
+  return status;
 }
 
-void ares__send_query(ares_channel channel, struct query *query,
-                      struct timeval *now)
+static ares_bool_t issue_might_be_edns(const ares_dns_record_t *req,
+                                       const ares_dns_record_t *rsp)
 {
-  struct send_request *sendreq;
-  struct server_state *server;
-  int timeplus;
-
-  server = &channel->servers[query->server];
-  if (query->using_tcp)
-    {
-      /* Make sure the TCP socket for this server is set up and queue
-       * a send request.
-       */
-      if (server->tcp_socket == ARES_SOCKET_BAD)
-        {
-          if (open_tcp_socket(channel, server) == -1)
-            {
-              skip_server(channel, query, query->server);
-              next_server(channel, query, now);
-              return;
-            }
-        }
-      sendreq = ares_malloc(sizeof(struct send_request));
-      if (!sendreq)
-        {
-        end_query(channel, query, ARES_ENOMEM, NULL, 0);
-          return;
-        }
-      memset(sendreq, 0, sizeof(struct send_request));
-      /* To make the common case fast, we avoid copies by using the query's
-       * tcpbuf for as long as the query is alive. In the rare case where the
-       * query ends while it's queued for transmission, then we give the
-       * sendreq its own copy of the request packet and put it in
-       * sendreq->data_storage.
-       */
-      sendreq->data_storage = NULL;
-      sendreq->data = query->tcpbuf;
-      sendreq->len = query->tcplen;
-      sendreq->owner_query = query;
-      sendreq->next = NULL;
-      if (server->qtail)
-        server->qtail->next = sendreq;
-      else
-        {
-          SOCK_STATE_CALLBACK(channel, server->tcp_socket, 1, 1);
-          server->qhead = sendreq;
-        }
-      server->qtail = sendreq;
-      query->server_info[query->server].tcp_connection_generation =
-        server->tcp_connection_generation;
-    }
-  else
-    {
-      if (server->udp_socket == ARES_SOCKET_BAD)
-        {
-          if (open_udp_socket(channel, server) == -1)
-            {
-              skip_server(channel, query, query->server);
-              next_server(channel, query, now);
-              return;
-            }
-        }
-      if (socket_write(channel, server->udp_socket, query->qbuf, query->qlen) == -1)
-        {
-          /* FIXME: Handle EAGAIN here since it likely can happen. */
-          skip_server(channel, query, query->server);
-          next_server(channel, query, now);
-          return;
-        }
-    }
+  const ares_dns_rr_t *rr;
 
-    /* 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;
-      }
-    }
+  /* If we use EDNS and server answers with FORMERR without an OPT RR, the
+   * protocol extension is not understood by the responder. We must retry the
+   * query without EDNS enabled. */
+  if (ares_dns_record_get_rcode(rsp) != ARES_RCODE_FORMERR) {
+    return ARES_FALSE;
+  }
+
+  rr = ares_dns_get_opt_rr_const(req);
+  if (rr == NULL) {
+    /* We didn't send EDNS */
+    return ARES_FALSE;
+  }
+
+  if (ares_dns_get_opt_rr_const(rsp) == NULL) {
+    /* Spec says EDNS won't be echo'd back on non-supporting servers, so
+     * retry without EDNS */
+    return ARES_TRUE;
+  }
+
+  /* As per issue #911 some non-compliant servers that do indeed support EDNS
+   * but don't support unrecognized option codes exist.  At this point we
+   * expect them to have also returned an EDNS opt record, but we may remove
+   * that check in the future. Lets detect this situation if we're sending
+   * option codes */
+  if (ares_dns_rr_get_opt_cnt(rr, ARES_RR_OPT_OPTIONS) == 0) {
+    /* We didn't send any option codes */
+    return ARES_FALSE;
+  }
+
+  if (ares_dns_get_opt_rr_const(rsp) != NULL) {
+    /* At this time we're requiring the server to respond with EDNS opt
+     * records since that's what has been observed in the field.  We might
+     * find in the future we have to remove this, who knows. Lets go
+     * ahead and force a retry without EDNS*/
+    return ARES_TRUE;
+  }
 
-    query->timeout = *now;
-    timeadd(&query->timeout, timeplus);
-    /* Keep track of queries bucketed by timeout, so we can process
-     * timeout events quickly.
-     */
-    ares__remove_from_list(&(query->queries_by_timeout));
-    ares__insert_in_list(
-        &(query->queries_by_timeout),
-        &(channel->queries_by_timeout[query->timeout.tv_sec %
-                                      ARES_TIMEOUT_TABLE_SIZE]));
-
-    /* Keep track of queries bucketed by server, so we can process server
-     * errors quickly.
-     */
-    ares__remove_from_list(&(query->queries_to_server));
-    ares__insert_in_list(&(query->queries_to_server),
-                         &(server->queries_to_server));
+  return ARES_FALSE;
 }
 
-/*
- * setsocknonblock sets the given socket to either blocking or non-blocking
- * mode based on the 'nonblock' boolean argument. This function is highly
- * portable.
- */
-static int setsocknonblock(ares_socket_t sockfd,    /* operate on this */
-                           int nonblock   /* TRUE or FALSE */)
+/* Handle an answer from a server. This must NEVER cleanup the
+ * server connection! Return something other than ARES_SUCCESS to cause
+ * the connection to be terminated after this call. */
+static ares_status_t process_answer(ares_channel_t      *channel,
+                                    const unsigned char *abuf, size_t alen,
+                                    ares_conn_t          *conn,
+                                    const ares_timeval_t *now,
+                                    ares_array_t        **requeue)
 {
-#if defined(USE_BLOCKING_SOCKETS)
+  ares_query_t      *query;
+  /* Cache these as once ares_send_query() gets called, it may end up
+   * invalidating the connection all-together */
+  ares_server_t     *server  = conn->server;
+  ares_dns_record_t *rdnsrec = NULL;
+  ares_status_t      status;
+  ares_bool_t        is_cached = ARES_FALSE;
+
+  /* UDP can have 0-byte messages, drop them to the ground */
+  if (alen == 0) {
+    return ARES_SUCCESS;
+  }
 
-  return 0; /* returns success */
+  /* Parse the response */
+  status = ares_dns_parse(abuf, alen, 0, &rdnsrec);
+  if (status != ARES_SUCCESS) {
+    /* Malformations are never accepted */
+    status = ARES_EBADRESP;
+    goto cleanup;
+  }
 
-#elif defined(HAVE_FCNTL_O_NONBLOCK)
+  /* Find the query corresponding to this packet. The queries are
+   * hashed/bucketed by query id, so this lookup should be quick.
+   */
+  query = ares_htable_szvp_get_direct(channel->queries_by_qid,
+                                      ares_dns_record_get_id(rdnsrec));
+  if (!query) {
+    /* We may have stopped listening for this query, that's ok */
+    status = ARES_SUCCESS;
+    goto cleanup;
+  }
 
-  /* most recent unix versions */
-  int flags;
-  flags = fcntl(sockfd, F_GETFL, 0);
-  if (FALSE != nonblock)
-    return fcntl(sockfd, F_SETFL, flags | O_NONBLOCK);
-  else
-    return fcntl(sockfd, F_SETFL, flags & (~O_NONBLOCK));  /* LCOV_EXCL_LINE */
+  /* Both the query id and the questions must be the same. We will drop any
+   * replies that aren't for the same query as this is considered invalid. */
+  if (!same_questions(query, rdnsrec)) {
+    /* Possible qid conflict due to delayed response, that's ok */
+    status = ARES_SUCCESS;
+    goto cleanup;
+  }
 
-#elif defined(HAVE_IOCTL_FIONBIO)
+  /* Validate DNS cookie in response. This function may need to requeue the
+   * query. */
+  if (ares_cookie_validate(query, rdnsrec, conn, now, requeue)
+      != ARES_SUCCESS) {
+    /* Drop response and return */
+    status = ARES_SUCCESS;
+    goto cleanup;
+  }
 
-  /* older unix versions */
-  int flags = nonblock ? 1 : 0;
-  return ioctl(sockfd, FIONBIO, &flags);
+  /* At this point we know we've received an answer for this query, so we should
+   * remove it from the connection's queue so we can possibly invalidate the
+   * connection. Delay cleaning up the connection though as we may enqueue
+   * something new.  */
+  ares_llist_node_destroy(query->node_queries_to_conn);
+  query->node_queries_to_conn = NULL;
+
+  /* There are old servers that don't understand EDNS at all, then some servers
+   * that have non-compliant implementations.  Lets try to detect this sort
+   * of thing. */
+  if (issue_might_be_edns(query->query, rdnsrec)) {
+    status = rewrite_without_edns(query);
+    if (status != ARES_SUCCESS) {
+      end_query(channel, server, query, status, NULL);
+      goto cleanup;
+    }
 
-#elif defined(HAVE_IOCTLSOCKET_FIONBIO)
+    /* Requeue to same server */
+    status = ares_append_requeue(requeue, query, server);
+    goto cleanup;
+  }
 
-#ifdef WATT32
-  char flags = nonblock ? 1 : 0;
-#else
-  /* Windows */
-  unsigned long flags = nonblock ? 1UL : 0UL;
-#endif
-  return ioctlsocket(sockfd, FIONBIO, &flags);
+  /* If we got a truncated UDP packet and are not ignoring truncation,
+   * don't accept the packet, and switch the query to TCP if we hadn't
+   * done so already.
+   */
+  if (ares_dns_record_get_flags(rdnsrec) & ARES_FLAG_TC &&
+      !(conn->flags & ARES_CONN_FLAG_TCP) &&
+      !(channel->flags & ARES_FLAG_IGNTC)) {
+    query->using_tcp = ARES_TRUE;
+    status = ares_append_requeue(requeue, query, NULL);
+    /* Status will reflect success except on memory error, which is good since
+     * requeuing to TCP is ok */
+    goto cleanup;
+  }
 
-#elif defined(HAVE_IOCTLSOCKET_CAMEL_FIONBIO)
+  /* If we aren't passing through all error packets, discard packets
+   * with SERVFAIL, NOTIMP, or REFUSED response codes.
+   */
+  if (!(channel->flags & ARES_FLAG_NOCHECKRESP)) {
+    ares_dns_rcode_t rcode = ares_dns_record_get_rcode(rdnsrec);
+    if (rcode == ARES_RCODE_SERVFAIL || rcode == ARES_RCODE_NOTIMP ||
+        rcode == ARES_RCODE_REFUSED) {
+      switch (rcode) {
+        case ARES_RCODE_SERVFAIL:
+          status = ARES_ESERVFAIL;
+          break;
+        case ARES_RCODE_NOTIMP:
+          status = ARES_ENOTIMP;
+          break;
+        case ARES_RCODE_REFUSED:
+          status = ARES_EREFUSED;
+          break;
+        default:
+          break;
+      }
 
-  /* Amiga */
-  long flags = nonblock ? 1L : 0L;
-  return IoctlSocket(sockfd, FIONBIO, flags);
+      server_increment_failures(server, query->using_tcp);
+      status = ares_requeue_query(query, now, status, ARES_TRUE, rdnsrec, requeue);
 
-#elif defined(HAVE_SETSOCKOPT_SO_NONBLOCK)
+      if (status != ARES_ENOMEM) {
+        /* Should any of these cause a connection termination?
+         * Maybe SERVER_FAILURE? */
+        status = ARES_SUCCESS;
+      }
+      goto cleanup;
+    }
+  }
 
-  /* BeOS */
-  long b = nonblock ? 1L : 0L;
-  return setsockopt(sockfd, SOL_SOCKET, SO_NONBLOCK, &b, sizeof(b));
+  /* If cache insertion was successful, it took ownership.  We ignore
+   * other cache insertion failures. */
+  if (ares_qcache_insert(channel, now, query, rdnsrec) == ARES_SUCCESS) {
+    is_cached = ARES_TRUE;
+  }
 
-#else
-#  error "no non-blocking method was found/used/set"
-#endif
+  server_set_good(server, query->using_tcp);
+  end_query(channel, server, query, ARES_SUCCESS, rdnsrec);
+
+  status = ARES_SUCCESS;
+
+cleanup:
+  /* Don't cleanup the cached pointer to the dns response */
+  if (!is_cached) {
+    ares_dns_record_destroy(rdnsrec);
+  }
+
+  return status;
 }
 
-#if defined(IPV6_V6ONLY) && defined(WIN32)
-/* It makes support for IPv4-mapped IPv6 addresses.
- * Linux kernel, NetBSD, FreeBSD and Darwin: default is off;
- * Windows Vista and later: default is on;
- * DragonFly BSD: acts like off, and dummy setting;
- * OpenBSD and earlier Windows: unsupported.
- * Linux: controlled by /proc/sys/net/ipv6/bindv6only.
- */
-static void set_ipv6_v6only(ares_socket_t sockfd, int on)
+static void handle_conn_error(ares_conn_t *conn, ares_bool_t critical_failure,
+                              ares_status_t failure_status)
 {
-  (void)setsockopt(sockfd, IPPROTO_IPV6, IPV6_V6ONLY, (void *)&on, sizeof(on));
+  ares_server_t *server = conn->server;
+
+  /* Increment failures first before requeue so it is unlikely to requeue
+   * to the same server */
+  if (critical_failure) {
+    server_increment_failures(
+      server, (conn->flags & ARES_CONN_FLAG_TCP) ? ARES_TRUE : ARES_FALSE);
+  }
+
+  /* This will requeue any connections automatically */
+  ares_close_connection(conn, failure_status);
 }
-#else
-#define set_ipv6_v6only(s,v)
-#endif
 
-static int configure_socket(ares_socket_t s, int family, ares_channel channel)
+/* Requeue query will normally call ares_send_query() but in some circumstances
+ * this needs to be delayed, so if requeue is not NULL, it will add the query
+ * to the queue instead */
+ares_status_t ares_requeue_query(ares_query_t *query, const ares_timeval_t *now,
+                                 ares_status_t            status,
+                                 ares_bool_t              inc_try_count,
+                                 const ares_dns_record_t *dnsrec,
+                                 ares_array_t           **requeue)
 {
-  union {
-    struct sockaddr     sa;
-    struct sockaddr_in  sa4;
-    struct sockaddr_in6 sa6;
-  } local;
-
-  /* do not set options for user-managed sockets */
-  if (channel->sock_funcs)
-    return 0;
-
-  (void)setsocknonblock(s, TRUE);
-
-#if defined(FD_CLOEXEC) && !defined(MSDOS)
-  /* Configure the socket fd as close-on-exec. */
-  if (fcntl(s, F_SETFD, FD_CLOEXEC) == -1)
-    return -1;  /* LCOV_EXCL_LINE */
-#endif
+  ares_channel_t *channel   = query->channel;
+  size_t          max_tries = ares_slist_len(channel->servers) * channel->tries;
 
-  /* Set the socket's send and receive buffer sizes. */
-  if ((channel->socket_send_buffer_size > 0) &&
-      setsockopt(s, SOL_SOCKET, SO_SNDBUF,
-                 (void *)&channel->socket_send_buffer_size,
-                 sizeof(channel->socket_send_buffer_size)) == -1)
-    return -1;
-
-  if ((channel->socket_receive_buffer_size > 0) &&
-      setsockopt(s, SOL_SOCKET, SO_RCVBUF,
-                 (void *)&channel->socket_receive_buffer_size,
-                 sizeof(channel->socket_receive_buffer_size)) == -1)
-    return -1;
-
-#ifdef SO_BINDTODEVICE
-  if (channel->local_dev_name[0]) {
-    if (setsockopt(s, SOL_SOCKET, SO_BINDTODEVICE,
-                   channel->local_dev_name, sizeof(channel->local_dev_name))) {
-      /* Only root can do this, and usually not fatal if it doesn't work, so */
-      /* just continue on. */
-    }
+  ares_query_remove_from_conn(query);
+
+  if (status != ARES_SUCCESS) {
+    query->error_status = status;
   }
-#endif
 
-  if (family == AF_INET) {
-    if (channel->local_ip4) {
-      memset(&local.sa4, 0, sizeof(local.sa4));
-      local.sa4.sin_family = AF_INET;
-      local.sa4.sin_addr.s_addr = htonl(channel->local_ip4);
-      if (bind(s, &local.sa, sizeof(local.sa4)) < 0)
-        return -1;
-    }
+  if (inc_try_count) {
+    query->try_count++;
   }
-  else if (family == AF_INET6) {
-    if (memcmp(channel->local_ip6, &ares_in6addr_any,
-               sizeof(channel->local_ip6)) != 0) {
-      memset(&local.sa6, 0, sizeof(local.sa6));
-      local.sa6.sin6_family = AF_INET6;
-      memcpy(&local.sa6.sin6_addr, channel->local_ip6,
-             sizeof(channel->local_ip6));
-      if (bind(s, &local.sa, sizeof(local.sa6)) < 0)
-        return -1;
+
+  if (query->try_count < max_tries && !query->no_retries) {
+    if (requeue != NULL) {
+      return ares_append_requeue(requeue, query, NULL);
     }
-    set_ipv6_v6only(s, 0);
+    return ares_send_query(NULL, query, now);
+  }
+
+  /* If we are here, all attempts to perform query failed. */
+  if (query->error_status == ARES_SUCCESS) {
+    query->error_status = ARES_ETIMEOUT;
   }
 
-  return 0;
+  end_query(channel, NULL, query, query->error_status, dnsrec);
+  return ARES_ETIMEOUT;
 }
 
-static int open_tcp_socket(ares_channel channel, struct server_state *server)
+/*! Count the number of servers that share the same highest priority (lowest
+ *  consecutive failures).  Since they are sorted in priority order, we just
+ *  stop when the consecutive failure count changes. Used for random selection
+ *  of good servers. */
+static size_t count_highest_prio_servers(const ares_channel_t *channel)
 {
-  ares_socket_t s;
-  int opt;
-  ares_socklen_t salen;
-  union {
-    struct sockaddr_in  sa4;
-    struct sockaddr_in6 sa6;
-  } saddr;
-  struct sockaddr *sa;
-
-  switch (server->addr.family)
-    {
-      case AF_INET:
-        sa = (void *)&saddr.sa4;
-        salen = sizeof(saddr.sa4);
-        memset(sa, 0, salen);
-        saddr.sa4.sin_family = AF_INET;
-        if (server->addr.tcp_port) {
-          saddr.sa4.sin_port = aresx_sitous(server->addr.tcp_port);
-        } else {
-          saddr.sa4.sin_port = aresx_sitous(channel->tcp_port);
-        }
-        memcpy(&saddr.sa4.sin_addr, &server->addr.addrV4,
-               sizeof(server->addr.addrV4));
-        break;
-      case AF_INET6:
-        sa = (void *)&saddr.sa6;
-        salen = sizeof(saddr.sa6);
-        memset(sa, 0, salen);
-        saddr.sa6.sin6_family = AF_INET6;
-        if (server->addr.tcp_port) {
-          saddr.sa6.sin6_port = aresx_sitous(server->addr.tcp_port);
-        } else {
-          saddr.sa6.sin6_port = aresx_sitous(channel->tcp_port);
-        }
-        memcpy(&saddr.sa6.sin6_addr, &server->addr.addrV6,
-               sizeof(server->addr.addrV6));
-        break;
-      default:
-        return -1;  /* LCOV_EXCL_LINE */
-    }
+  ares_slist_node_t *node;
+  size_t             cnt                  = 0;
+  size_t             last_consec_failures = SIZE_MAX;
 
-  /* Acquire a socket. */
-  s = ares__open_socket(channel, server->addr.family, SOCK_STREAM, 0);
-  if (s == ARES_SOCKET_BAD)
-    return -1;
+  for (node = ares_slist_node_first(channel->servers); node != NULL;
+       node = ares_slist_node_next(node)) {
+    const ares_server_t *server = ares_slist_node_val(node);
 
-  /* Configure it. */
-  if (configure_socket(s, server->addr.family, channel) < 0)
-    {
-       ares__close_socket(channel, s);
-       return -1;
+    if (last_consec_failures != SIZE_MAX &&
+        last_consec_failures < server->consec_failures) {
+      break;
     }
 
-#ifdef TCP_NODELAY
-  /*
-   * Disable the Nagle algorithm (only relevant for TCP sockets, and thus not
-   * in configure_socket). In general, in DNS lookups we're pretty much
-   * interested in firing off a single request and then waiting for a reply,
-   * so batching isn't very interesting.
-   */
-  opt = 1;
-  if (channel->sock_funcs == 0
-     &&
-     setsockopt(s, IPPROTO_TCP, TCP_NODELAY,
-                (void *)&opt, sizeof(opt)) == -1)
-    {
-       ares__close_socket(channel, s);
-       return -1;
-    }
-#endif
+    last_consec_failures = server->consec_failures;
+    cnt++;
+  }
 
-  if (channel->sock_config_cb)
-    {
-      int err = channel->sock_config_cb(s, SOCK_STREAM,
-                                        channel->sock_config_cb_data);
-      if (err < 0)
-        {
-          ares__close_socket(channel, s);
-          return err;
-        }
-    }
+  return cnt;
+}
 
-  /* Connect to the server. */
-  if (ares__connect_socket(channel, s, sa, salen) == -1)
-    {
-      int err = SOCKERRNO;
+/* Pick a random *best* server from the list, we first get a random number in
+ * the range of the number of *best* servers, then scan until we find that
+ * server in the list */
+static ares_server_t *ares_random_server(ares_channel_t *channel)
+{
+  unsigned char      c;
+  size_t             cnt;
+  size_t             idx;
+  ares_slist_node_t *node;
+  size_t             num_servers = count_highest_prio_servers(channel);
+
+  /* Silence coverity, not possible */
+  if (num_servers == 0) {
+    return NULL;
+  }
 
-      if (err != EINPROGRESS && err != EWOULDBLOCK)
-        {
-          ares__close_socket(channel, s);
-          return -1;
-        }
-    }
+  ares_rand_bytes(channel->rand_state, &c, 1);
 
-  if (channel->sock_create_cb)
-    {
-      int err = channel->sock_create_cb(s, SOCK_STREAM,
-                                        channel->sock_create_cb_data);
-      if (err < 0)
-        {
-          ares__close_socket(channel, s);
-          return err;
-        }
+  cnt = c;
+  idx = cnt % num_servers;
+
+  cnt = 0;
+  for (node = ares_slist_node_first(channel->servers); node != NULL;
+       node = ares_slist_node_next(node)) {
+    if (cnt == idx) {
+      return ares_slist_node_val(node);
     }
 
-  SOCK_STATE_CALLBACK(channel, s, 1, 0);
-  server->tcp_buffer_pos = 0;
-  server->tcp_socket = s;
-  server->tcp_connection_generation = ++channel->tcp_connection_generation;
-  return 0;
+    cnt++;
+  }
+
+  return NULL;
 }
 
-static int open_udp_socket(ares_channel channel, struct server_state *server)
+static void server_probe_cb(void *arg, ares_status_t status, size_t timeouts,
+                            const ares_dns_record_t *dnsrec)
 {
-  ares_socket_t s;
-  ares_socklen_t salen;
-  union {
-    struct sockaddr_in  sa4;
-    struct sockaddr_in6 sa6;
-  } saddr;
-  struct sockaddr *sa;
-
-  switch (server->addr.family)
-    {
-      case AF_INET:
-        sa = (void *)&saddr.sa4;
-        salen = sizeof(saddr.sa4);
-        memset(sa, 0, salen);
-        saddr.sa4.sin_family = AF_INET;
-        if (server->addr.udp_port) {
-          saddr.sa4.sin_port = aresx_sitous(server->addr.udp_port);
-        } else {
-          saddr.sa4.sin_port = aresx_sitous(channel->udp_port);
-        }
-        memcpy(&saddr.sa4.sin_addr, &server->addr.addrV4,
-               sizeof(server->addr.addrV4));
-        break;
-      case AF_INET6:
-        sa = (void *)&saddr.sa6;
-        salen = sizeof(saddr.sa6);
-        memset(sa, 0, salen);
-        saddr.sa6.sin6_family = AF_INET6;
-        if (server->addr.udp_port) {
-          saddr.sa6.sin6_port = aresx_sitous(server->addr.udp_port);
-        } else {
-          saddr.sa6.sin6_port = aresx_sitous(channel->udp_port);
-        }
-        memcpy(&saddr.sa6.sin6_addr, &server->addr.addrV6,
-               sizeof(server->addr.addrV6));
-        break;
-      default:
-        return -1;  /* LCOV_EXCL_LINE */
-    }
+  (void)arg;
+  (void)status;
+  (void)timeouts;
+  (void)dnsrec;
+  /* Nothing to do, the logic internally will handle success/fail of this */
+}
+
+/* Determine if we should probe a downed server */
+static void ares_probe_failed_server(ares_channel_t      *channel,
+                                     const ares_server_t *server,
+                                     const ares_query_t  *query)
+{
+  const ares_server_t *last_server = ares_slist_last_val(channel->servers);
+  unsigned short       r;
+  ares_timeval_t       now;
+  ares_slist_node_t   *node;
+  ares_server_t       *probe_server = NULL;
+
+  /* If no servers have failures, or we're not configured with a server retry
+   * chance, then nothing to probe */
+  if ((last_server != NULL && last_server->consec_failures == 0) ||
+      channel->server_retry_chance == 0) {
+    return;
+  }
 
-  /* Acquire a socket. */
-  s = ares__open_socket(channel, server->addr.family, SOCK_DGRAM, 0);
-  if (s == ARES_SOCKET_BAD)
-    return -1;
+  /* Generate a random value to decide whether to retry a failed server. The
+   * probability to use is 1/channel->server_retry_chance, rounded up to a
+   * precision of 1/2^B where B is the number of bits in the random value.
+   * We use an unsigned short for the random value for increased precision.
+   */
+  ares_rand_bytes(channel->rand_state, (unsigned char *)&r, sizeof(r));
+  if (r % channel->server_retry_chance != 0) {
+    return;
+  }
 
-  /* Set the socket non-blocking. */
-  if (configure_socket(s, server->addr.family, channel) < 0)
-    {
-       ares__close_socket(channel, s);
-       return -1;
+  /* Select the first server with failures to retry that has passed the retry
+   * timeout and doesn't already have a pending probe */
+  ares_tvnow(&now);
+  for (node = ares_slist_node_first(channel->servers); node != NULL;
+       node = ares_slist_node_next(node)) {
+    ares_server_t *node_val = ares_slist_node_val(node);
+    if (node_val != NULL && node_val->consec_failures > 0 &&
+        !node_val->probe_pending &&
+        ares_timedout(&now, &node_val->next_retry_time)) {
+      probe_server = node_val;
+      break;
     }
+  }
 
-  if (channel->sock_config_cb)
-    {
-      int err = channel->sock_config_cb(s, SOCK_DGRAM,
-                                        channel->sock_config_cb_data);
-      if (err < 0)
-        {
-          ares__close_socket(channel, s);
-          return err;
-        }
-    }
+  /* Either nothing to probe or the query was enqueud to the same server
+   * we were going to probe. Do nothing. */
+  if (probe_server == NULL || server == probe_server) {
+    return;
+  }
 
-  /* Connect to the server. */
-  if (ares__connect_socket(channel, s, sa, salen) == -1)
-    {
-      int err = SOCKERRNO;
+  /* Enqueue an identical query onto the specified server without honoring
+   * the cache or allowing retries.  We want to make sure it only attempts to
+   * use the server in question */
+  probe_server->probe_pending = ARES_TRUE;
+  ares_send_nolock(channel, probe_server,
+                   ARES_SEND_FLAG_NOCACHE | ARES_SEND_FLAG_NORETRY,
+                   query->query, server_probe_cb, NULL, NULL);
+}
 
-      if (err != EINPROGRESS && err != EWOULDBLOCK)
-        {
-          ares__close_socket(channel, s);
-          return -1;
-        }
-    }
+static size_t ares_calc_query_timeout(const ares_query_t   *query,
+                                      const ares_server_t  *server,
+                                      const ares_timeval_t *now)
+{
+  const ares_channel_t *channel  = query->channel;
+  size_t                timeout  = ares_metrics_server_timeout(server, now);
+  size_t                timeplus = timeout;
+  size_t                rounds;
+  size_t                num_servers = ares_slist_len(channel->servers);
+
+  if (num_servers == 0) {
+    return 0; /* LCOV_EXCL_LINE: DefensiveCoding */
+  }
 
-  if (channel->sock_create_cb)
-    {
-      int err = channel->sock_create_cb(s, SOCK_DGRAM,
-                                        channel->sock_create_cb_data);
-      if (err < 0)
-        {
-          ares__close_socket(channel, s);
-          return err;
-        }
-    }
+  /* For each trip through the entire server list, we want to double the
+   * retry from the last retry */
+  rounds = (query->try_count / num_servers);
+  if (rounds > 0) {
+    timeplus <<= rounds;
+  }
+
+  if (channel->maxtimeout && timeplus > channel->maxtimeout) {
+    timeplus = channel->maxtimeout;
+  }
+
+  /* Add some jitter to the retry timeout.
+   *
+   * Jitter is needed in situation when resolve requests are performed
+   * simultaneously from multiple hosts and DNS server throttle these requests.
+   * Adding randomness allows to avoid synchronisation of retries.
+   *
+   * Value of timeplus adjusted randomly to the range [0.5 * timeplus,
+   * timeplus].
+   */
+  if (rounds > 0) {
+    unsigned short r;
+    float          delta_multiplier;
 
-  SOCK_STATE_CALLBACK(channel, s, 1, 0);
+    ares_rand_bytes(channel->rand_state, (unsigned char *)&r, sizeof(r));
+    delta_multiplier  = ((float)r / USHRT_MAX) * 0.5f;
+    timeplus         -= (size_t)((float)timeplus * delta_multiplier);
+  }
+
+  /* We want explicitly guarantee that timeplus is greater or equal to timeout
+   * specified in channel options. */
+  if (timeplus < timeout) {
+    timeplus = timeout;
+  }
 
-  server->udp_socket = s;
-  return 0;
+  return timeplus;
 }
 
-static int same_questions(const unsigned char *qbuf, int qlen,
-                          const unsigned char *abuf, int alen)
+static ares_conn_t *ares_fetch_connection(const ares_channel_t *channel,
+                                          ares_server_t        *server,
+                                          const ares_query_t   *query)
 {
-  struct {
-    const unsigned char *p;
-    int qdcount;
-    char *name;
-    long namelen;
-    int type;
-    int dnsclass;
-  } q, a;
-  int i, j;
-
-  if (qlen < HFIXEDSZ || alen < HFIXEDSZ)
-    return 0;
-
-  /* Extract qdcount from the request and reply buffers and compare them. */
-  q.qdcount = DNS_HEADER_QDCOUNT(qbuf);
-  a.qdcount = DNS_HEADER_QDCOUNT(abuf);
-  if (q.qdcount != a.qdcount)
-    return 0;
-
-  /* For each question in qbuf, find it in abuf. */
-  q.p = qbuf + HFIXEDSZ;
-  for (i = 0; i < q.qdcount; i++)
-    {
-      /* Decode the question in the query. */
-      if (ares_expand_name(q.p, qbuf, qlen, &q.name, &q.namelen)
-          != ARES_SUCCESS)
-        return 0;
-      q.p += q.namelen;
-      if (q.p + QFIXEDSZ > qbuf + qlen)
-        {
-          ares_free(q.name);
-          return 0;
-        }
-      q.type = DNS_QUESTION_TYPE(q.p);
-      q.dnsclass = DNS_QUESTION_CLASS(q.p);
-      q.p += QFIXEDSZ;
-
-      /* Search for this question in the answer. */
-      a.p = abuf + HFIXEDSZ;
-      for (j = 0; j < a.qdcount; j++)
-        {
-          /* Decode the question in the answer. */
-          if (ares_expand_name(a.p, abuf, alen, &a.name, &a.namelen)
-              != ARES_SUCCESS)
-            {
-              ares_free(q.name);
-              return 0;
-            }
-          a.p += a.namelen;
-          if (a.p + QFIXEDSZ > abuf + alen)
-            {
-              ares_free(q.name);
-              ares_free(a.name);
-              return 0;
-            }
-          a.type = DNS_QUESTION_TYPE(a.p);
-          a.dnsclass = DNS_QUESTION_CLASS(a.p);
-          a.p += QFIXEDSZ;
-
-          /* Compare the decoded questions. */
-          if (strcasecmp(q.name, a.name) == 0 && q.type == a.type
-              && q.dnsclass == a.dnsclass)
-            {
-              ares_free(a.name);
-              break;
-            }
-          ares_free(a.name);
-        }
-
-      ares_free(q.name);
-      if (j == a.qdcount)
-        return 0;
-    }
-  return 1;
+  ares_llist_node_t *node;
+  ares_conn_t       *conn;
+
+  if (query->using_tcp) {
+    return server->tcp_conn;
+  }
+
+  /* Fetch existing UDP connection */
+  node = ares_llist_node_first(server->connections);
+  if (node == NULL) {
+    return NULL;
+  }
+
+  conn = ares_llist_node_val(node);
+  /* Not UDP, skip */
+  if (conn->flags & ARES_CONN_FLAG_TCP) {
+    return NULL;
+  }
+
+  /* Used too many times */
+  if (channel->udp_max_queries > 0 &&
+      conn->total_queries >= channel->udp_max_queries) {
+    return NULL;
+  }
+
+  return conn;
 }
 
-static int same_address(struct sockaddr *sa, struct ares_addr *aa)
+static ares_status_t ares_conn_query_write(ares_conn_t          *conn,
+                                           ares_query_t         *query,
+                                           const ares_timeval_t *now)
 {
-  void *addr1;
-  void *addr2;
-
-  if (sa->sa_family == aa->family)
-    {
-      switch (aa->family)
-        {
-          case AF_INET:
-            addr1 = &aa->addrV4;
-            addr2 = &(CARES_INADDR_CAST(struct sockaddr_in *, sa))->sin_addr;
-            if (memcmp(addr1, addr2, sizeof(aa->addrV4)) == 0)
-              return 1; /* match */
-            break;
-          case AF_INET6:
-            addr1 = &aa->addrV6;
-            addr2 = &(CARES_INADDR_CAST(struct sockaddr_in6 *, sa))->sin6_addr;
-            if (memcmp(addr1, addr2, sizeof(aa->addrV6)) == 0)
-              return 1; /* match */
-            break;
-          default:
-            break;  /* LCOV_EXCL_LINE */
-        }
-    }
-  return 0; /* different */
+  ares_server_t  *server  = conn->server;
+  ares_channel_t *channel = server->channel;
+  ares_status_t   status;
+
+  status = ares_cookie_apply(query->query, conn, now);
+  if (status != ARES_SUCCESS) {
+    return status;
+  }
+
+  /* We write using the TCP format even for UDP, we just strip the length
+   * before putting on the wire */
+  status = ares_dns_write_buf_tcp(query->query, conn->out_buf);
+  if (status != ARES_SUCCESS) {
+    return status;
+  }
+
+  /* Not pending a TFO write and not connected, so we can't even try to
+   * write until we get a signal */
+  if (conn->flags & ARES_CONN_FLAG_TCP &&
+      !(conn->state_flags & ARES_CONN_STATE_CONNECTED) &&
+      !(conn->flags & ARES_CONN_FLAG_TFO_INITIAL)) {
+    return ARES_SUCCESS;
+  }
+
+  /* Delay actual write if possible (TCP only, and only if callback
+   * configured) */
+  if (channel->notify_pending_write_cb && !channel->notify_pending_write &&
+      conn->flags & ARES_CONN_FLAG_TCP) {
+    channel->notify_pending_write = ARES_TRUE;
+    channel->notify_pending_write_cb(channel->notify_pending_write_cb_data);
+    return ARES_SUCCESS;
+  }
+
+  /* Unfortunately we need to write right away and can't aggregate multiple
+   * queries into a single write. */
+  return ares_conn_flush(conn);
 }
 
-/* search for an OPT RR in the response */
-static int has_opt_rr(const unsigned char *abuf, int alen)
+ares_status_t ares_send_query(ares_server_t *requested_server,
+                              ares_query_t *query, const ares_timeval_t *now)
 {
-  unsigned int qdcount, ancount, nscount, arcount, i;
-  const unsigned char *aptr;
-  int status;
-
-  if (alen < HFIXEDSZ)
-    return -1;
-
-  /* Parse the answer header. */
-  qdcount = DNS_HEADER_QDCOUNT(abuf);
-  ancount = DNS_HEADER_ANCOUNT(abuf);
-  nscount = DNS_HEADER_NSCOUNT(abuf);
-  arcount = DNS_HEADER_ARCOUNT(abuf);
-
-  aptr = abuf + HFIXEDSZ;
-
-  /* skip the questions */
-  for (i = 0; i < qdcount; i++)
-    {
-      char* name;
-      long len;
-      status = ares_expand_name(aptr, abuf, alen, &name, &len);
-      if (status != ARES_SUCCESS)
-        return -1;
-      ares_free_string(name);
-      if (aptr + len + QFIXEDSZ > abuf + alen)
-        return -1;
-      aptr += len + QFIXEDSZ;
-    }
+  ares_channel_t *channel = query->channel;
+  ares_server_t  *server;
+  ares_conn_t    *conn;
+  size_t          timeplus;
+  ares_status_t   status;
+  ares_bool_t     probe_downed_server = ARES_TRUE;
 
-  /* skip the ancount and nscount */
-  for (i = 0; i < ancount + nscount; i++)
-    {
-      char* name;
-      long len;
-      int dlen;
-      status = ares_expand_name(aptr, abuf, alen, &name, &len);
-      if (status != ARES_SUCCESS)
-        return -1;
-      ares_free_string(name);
-      if (aptr + len + RRFIXEDSZ > abuf + alen)
-        return -1;
-      aptr += len;
-      dlen = DNS_RR_LEN(aptr);
-      aptr += RRFIXEDSZ;
-      if (aptr + dlen > abuf + alen)
-        return -1;
-      aptr += dlen;
+
+  /* Choose the server to send the query to */
+  if (requested_server != NULL) {
+    server = requested_server;
+  } else {
+    /* If rotate is turned on, do a random selection */
+    if (channel->rotate) {
+      server = ares_random_server(channel);
+    } else {
+      /* First server in list */
+      server = ares_slist_first_val(channel->servers);
     }
+  }
 
-  /* search for rr type (41) - opt */
-  for (i = 0; i < arcount; i++)
-    {
-      char* name;
-      long len;
-      int dlen;
-      status = ares_expand_name(aptr, abuf, alen, &name, &len);
-      if (status != ARES_SUCCESS)
-        return -1;
-      ares_free_string(name);
-      if (aptr + len + RRFIXEDSZ > abuf + alen)
-        return -1;
-      aptr += len;
-
-      if (DNS_RR_TYPE(aptr) == T_OPT)
-        return 1;
-
-      dlen = DNS_RR_LEN(aptr);
-      aptr += RRFIXEDSZ;
-      if (aptr + dlen > abuf + alen)
-        return -1;
-      aptr += dlen;
+  if (server == NULL) {
+    end_query(channel, server, query, ARES_ENOSERVER /* ? */, NULL);
+    return ARES_ENOSERVER;
+  }
+
+  /* If a query is directed to a specific query, or the server chosen has
+   * failures, or the query is being retried, don't probe for downed servers */
+  if (requested_server != NULL || server->consec_failures > 0 ||
+      query->try_count != 0) {
+    probe_downed_server = ARES_FALSE;
+  }
+
+  conn = ares_fetch_connection(channel, server, query);
+  if (conn == NULL) {
+    status = ares_open_connection(&conn, channel, server, query->using_tcp);
+    switch (status) {
+      /* Good result, continue on */
+      case ARES_SUCCESS:
+        break;
+
+      /* These conditions are retryable as they are server-specific
+       * error codes */
+      case ARES_ECONNREFUSED:
+      case ARES_EBADFAMILY:
+        server_increment_failures(server, query->using_tcp);
+        return ares_requeue_query(query, now, status, ARES_TRUE, NULL, NULL);
+
+      /* Anything else is not retryable, likely ENOMEM */
+      default:
+        end_query(channel, server, query, status, NULL);
+        return status;
     }
+  }
+
+  /* Write the query */
+  status = ares_conn_query_write(conn, query, now);
+  switch (status) {
+    /* Good result, continue on */
+    case ARES_SUCCESS:
+      break;
+
+    case ARES_ENOMEM:
+      /* Not retryable */
+      end_query(channel, server, query, status, NULL);
+      return status;
+
+    /* These conditions are retryable as they are server-specific
+     * error codes */
+    case ARES_ECONNREFUSED:
+    case ARES_EBADFAMILY:
+      handle_conn_error(conn, ARES_TRUE, status);
+      status = ares_requeue_query(query, now, status, ARES_TRUE, NULL, NULL);
+      if (status == ARES_ETIMEOUT) {
+        status = ARES_ECONNREFUSED;
+      }
+      return status;
+
+    default:
+      server_increment_failures(server, query->using_tcp);
+      status = ares_requeue_query(query, now, status, ARES_TRUE, NULL, NULL);
+      return status;
+  }
+
+  timeplus = ares_calc_query_timeout(query, server, now);
+  /* Keep track of queries bucketed by timeout, so we can process
+   * timeout events quickly.
+   */
+  ares_slist_node_destroy(query->node_queries_by_timeout);
+  query->ts      = *now;
+  query->timeout = *now;
+  timeadd(&query->timeout, timeplus);
+  query->node_queries_by_timeout =
+    ares_slist_insert(channel->queries_by_timeout, query);
+  if (!query->node_queries_by_timeout) {
+    /* LCOV_EXCL_START: OutOfMemory */
+    end_query(channel, server, query, ARES_ENOMEM, NULL);
+    return ARES_ENOMEM;
+    /* LCOV_EXCL_STOP */
+  }
+
+  /* Keep track of queries bucketed by connection, so we can process errors
+   * quickly. */
+  ares_llist_node_destroy(query->node_queries_to_conn);
+  query->node_queries_to_conn =
+    ares_llist_insert_last(conn->queries_to_conn, query);
+
+  if (query->node_queries_to_conn == NULL) {
+    /* LCOV_EXCL_START: OutOfMemory */
+    end_query(channel, server, query, ARES_ENOMEM, NULL);
+    return ARES_ENOMEM;
+    /* LCOV_EXCL_STOP */
+  }
+
+  query->conn = conn;
+  conn->total_queries++;
+
+  /* We just successfully enqueud a query, see if we should probe downed
+   * servers. */
+  if (probe_downed_server) {
+    ares_probe_failed_server(channel, server, query);
+  }
 
-  return 0;
+  return ARES_SUCCESS;
 }
 
-static void end_query (ares_channel channel, struct query *query, int status,
-                       unsigned char *abuf, int alen)
+static ares_bool_t same_questions(const ares_query_t      *query,
+                                  const ares_dns_record_t *arec)
 {
-  int i;
+  size_t                   i;
+  ares_bool_t              rv      = ARES_FALSE;
+  const ares_dns_record_t *qrec    = query->query;
+  const ares_channel_t    *channel = query->channel;
 
-  /* First we check to see if this query ended while one of our send
-   * queues still has pointers to it.
-   */
-  for (i = 0; i < channel->nservers; i++)
-    {
-      struct server_state *server = &channel->servers[i];
-      struct send_request *sendreq;
-      for (sendreq = server->qhead; sendreq; sendreq = sendreq->next)
-        if (sendreq->owner_query == query)
-          {
-            sendreq->owner_query = NULL;
-            assert(sendreq->data_storage == NULL);
-            if (status == ARES_SUCCESS)
-              {
-                /* We got a reply for this query, but this queued sendreq
-                 * points into this soon-to-be-gone query's tcpbuf. Probably
-                 * this means we timed out and queued the query for
-                 * retransmission, then received a response before actually
-                 * retransmitting. This is perfectly fine, so we want to keep
-                 * the connection running smoothly if we can. But in the worst
-                 * case we may have sent only some prefix of the query, with
-                 * some suffix of the query left to send. Also, the buffer may
-                 * be queued on multiple queues. To prevent dangling pointers
-                 * to the query's tcpbuf and handle these cases, we just give
-                 * such sendreqs their own copy of the query packet.
-                 */
-               sendreq->data_storage = ares_malloc(sendreq->len);
-               if (sendreq->data_storage != NULL)
-                 {
-                   memcpy(sendreq->data_storage, sendreq->data, sendreq->len);
-                   sendreq->data = sendreq->data_storage;
-                 }
-              }
-            if ((status != ARES_SUCCESS) || (sendreq->data_storage == NULL))
-              {
-                /* We encountered an error (probably a timeout, suggesting the
-                 * DNS server we're talking to is probably unreachable,
-                 * wedged, or severely overloaded) or we couldn't copy the
-                 * request, so mark the connection as broken. When we get to
-                 * process_broken_connections() we'll close the connection and
-                 * try to re-send requests to another server.
-                 */
-               server->is_broken = 1;
-               /* Just to be paranoid, zero out this sendreq... */
-               sendreq->data = NULL;
-               sendreq->len = 0;
-             }
-          }
+
+  if (ares_dns_record_query_cnt(qrec) != ares_dns_record_query_cnt(arec)) {
+    goto done;
+  }
+
+  for (i = 0; i < ares_dns_record_query_cnt(qrec); i++) {
+    const char         *qname = NULL;
+    const char         *aname = NULL;
+    ares_dns_rec_type_t qtype;
+    ares_dns_rec_type_t atype;
+    ares_dns_class_t    qclass;
+    ares_dns_class_t    aclass;
+
+    if (ares_dns_record_query_get(qrec, i, &qname, &qtype, &qclass) !=
+          ARES_SUCCESS ||
+        qname == NULL) {
+      goto done;
     }
 
-  /* Invoke the callback */
-  query->callback(query->arg, status, query->timeouts, abuf, alen);
-  ares__free_query(query);
+    if (ares_dns_record_query_get(arec, i, &aname, &atype, &aclass) !=
+          ARES_SUCCESS ||
+        aname == NULL) {
+      goto done;
+    }
 
-  /* Simple cleanup policy: if no queries are remaining, close all network
-   * sockets unless STAYOPEN is set.
-   */
-  if (!(channel->flags & ARES_FLAG_STAYOPEN) &&
-      ares__is_list_empty(&(channel->all_queries)))
-    {
-      for (i = 0; i < channel->nservers; i++)
-        ares__close_sockets(channel, &channel->servers[i]);
+    if (qtype != atype || qclass != aclass) {
+      goto done;
     }
+
+    if (channel->flags & ARES_FLAG_DNS0x20 && !query->using_tcp) {
+      /* NOTE: for DNS 0x20, part of the protection is to use a case-sensitive
+       *       comparison of the DNS query name.  This expects the upstream DNS
+       *       server to preserve the case of the name in the response packet.
+       *       https://datatracker.ietf.org/doc/html/draft-vixie-dnsext-dns0x20-00
+       */
+      if (!ares_streq(qname, aname)) {
+        goto done;
+      }
+    } else {
+      /* without DNS0x20 use case-insensitive matching */
+      if (!ares_strcaseeq(qname, aname)) {
+        goto done;
+      }
+    }
+  }
+
+  rv = ARES_TRUE;
+
+done:
+  return rv;
 }
 
-void ares__free_query(struct query *query)
+static void ares_detach_query(ares_query_t *query)
 {
   /* Remove the query from all the lists in which it is linked */
-  ares__remove_from_list(&(query->queries_by_qid));
-  ares__remove_from_list(&(query->queries_by_timeout));
-  ares__remove_from_list(&(query->queries_to_server));
-  ares__remove_from_list(&(query->all_queries));
-  /* Zero out some important stuff, to help catch bugs */
-  query->callback = NULL;
-  query->arg = NULL;
-  /* Deallocate the memory associated with the query */
-  ares_free(query->tcpbuf);
-  ares_free(query->server_info);
-  ares_free(query);
+  ares_query_remove_from_conn(query);
+  ares_htable_szvp_remove(query->channel->queries_by_qid, query->qid);
+  ares_llist_node_destroy(query->node_all_queries);
+  query->node_all_queries = NULL;
 }
 
-ares_socket_t ares__open_socket(ares_channel channel,
-                                int af, int type, int protocol)
+static void end_query(ares_channel_t *channel, ares_server_t *server,
+                      ares_query_t *query, ares_status_t status,
+                      const ares_dns_record_t *dnsrec)
 {
-  if (channel->sock_funcs)
-    return channel->sock_funcs->asocket(af,
-                                        type,
-                                        protocol,
-                                        channel->sock_func_cb_data);
-  else
-    return socket(af, type, protocol);
-}
+  /* If we were probing for the server to come back online, lets mark it as
+   * no longer being probed */
+  if (server != NULL) {
+    server->probe_pending = ARES_FALSE;
+  }
 
-int ares__connect_socket(ares_channel channel,
-                         ares_socket_t sockfd,
-                         const struct sockaddr *addr,
-                         ares_socklen_t addrlen)
-{
-  if (channel->sock_funcs)
-    return channel->sock_funcs->aconnect(sockfd,
-                                         addr,
-                                         addrlen,
-                                         channel->sock_func_cb_data);
-  else
-    return connect(sockfd, addr, addrlen);
+  ares_metrics_record(query, server, status, dnsrec);
+
+  /* Invoke the callback. */
+  query->callback(query->arg, status, query->timeouts, dnsrec);
+  ares_free_query(query);
+
+  /* Check and notify if no other queries are enqueued on the channel.  This
+   * must come after the callback and freeing the query for 2 reasons.
+   *  1) The callback itself may enqueue a new query
+   *  2) Technically the current query isn't detached until it is free()'d.
+   */
+  ares_queue_notify_empty(channel);
 }
 
-void ares__close_socket(ares_channel channel, ares_socket_t s)
+void ares_free_query(ares_query_t *query)
 {
-  if (channel->sock_funcs)
-    channel->sock_funcs->aclose(s, channel->sock_func_cb_data);
-  else
-    sclose(s);
+  ares_detach_query(query);
+  /* Zero out some important stuff, to help catch bugs */
+  query->callback = NULL;
+  query->arg      = NULL;
+  /* Deallocate the memory associated with the query */
+  ares_dns_record_destroy(query->query);
+
+  ares_free(query);
 }