grpc 1.74.1 → 1.75.0.pre1

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

@@ -0,0 +1,1362 @@
+/* MIT License
+ *
+ * Copyright (c) 1998 Massachusetts Institute of Technology
+ * Copyright (c) 2008 Daniel Stenberg
+ * Copyright (c) 2023 Brad House
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * SPDX-License-Identifier: MIT
+ */
+#include "ares_private.h"
+
+#ifdef HAVE_ARPA_INET_H
+#  include <arpa/inet.h>
+#endif
+#ifdef HAVE_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#  include <sys/socket.h>
+#endif
+#ifdef HAVE_NET_IF_H
+#  include <net/if.h>
+#endif
+#ifdef HAVE_STDINT_H
+#  include <stdint.h>
+#endif
+
+#if defined(USE_WINSOCK)
+#  if defined(HAVE_IPHLPAPI_H)
+#    include <iphlpapi.h>
+#  endif
+#  if defined(HAVE_NETIOAPI_H)
+#    include <netioapi.h>
+#  endif
+#endif
+
+#include "ares_data.h"
+#include "ares_inet_net_pton.h"
+
+typedef struct {
+  struct ares_addr addr;
+  unsigned short   tcp_port;
+  unsigned short   udp_port;
+
+  char             ll_iface[IF_NAMESIZE];
+  unsigned int     ll_scope;
+} ares_sconfig_t;
+
+static ares_bool_t ares_addr_match(const struct ares_addr *addr1,
+                                   const struct ares_addr *addr2)
+{
+  if (addr1 == NULL && addr2 == NULL) {
+    return ARES_TRUE; /* LCOV_EXCL_LINE: DefensiveCoding */
+  }
+
+  if (addr1 == NULL || addr2 == NULL) {
+    return ARES_FALSE; /* LCOV_EXCL_LINE: DefensiveCoding */
+  }
+
+  if (addr1->family != addr2->family) {
+    return ARES_FALSE;
+  }
+
+  if (addr1->family == AF_INET && memcmp(&addr1->addr.addr4, &addr2->addr.addr4,
+                                         sizeof(addr1->addr.addr4)) == 0) {
+    return ARES_TRUE;
+  }
+
+  if (addr1->family == AF_INET6 &&
+      memcmp(&addr1->addr.addr6._S6_un._S6_u8, &addr2->addr.addr6._S6_un._S6_u8,
+             sizeof(addr1->addr.addr6._S6_un._S6_u8)) == 0) {
+    return ARES_TRUE;
+  }
+
+  return ARES_FALSE;
+}
+
+ares_bool_t ares_subnet_match(const struct ares_addr *addr,
+                              const struct ares_addr *subnet,
+                              unsigned char           netmask)
+{
+  const unsigned char *addr_ptr;
+  const unsigned char *subnet_ptr;
+  size_t               len;
+  size_t               i;
+
+  if (addr == NULL || subnet == NULL) {
+    return ARES_FALSE; /* LCOV_EXCL_LINE: DefensiveCoding */
+  }
+
+  if (addr->family != subnet->family) {
+    return ARES_FALSE;
+  }
+
+  if (addr->family == AF_INET) {
+    addr_ptr   = (const unsigned char *)&addr->addr.addr4;
+    subnet_ptr = (const unsigned char *)&subnet->addr.addr4;
+    len        = 4;
+
+    if (netmask > 32) {
+      return ARES_FALSE; /* LCOV_EXCL_LINE: DefensiveCoding */
+    }
+  } else if (addr->family == AF_INET6) {
+    addr_ptr   = (const unsigned char *)&addr->addr.addr6;
+    subnet_ptr = (const unsigned char *)&subnet->addr.addr6;
+    len        = 16;
+
+    if (netmask > 128) {
+      return ARES_FALSE; /* LCOV_EXCL_LINE: DefensiveCoding */
+    }
+  } else {
+    return ARES_FALSE; /* LCOV_EXCL_LINE: DefensiveCoding */
+  }
+
+  for (i = 0; i < len && netmask > 0; i++) {
+    unsigned char mask = 0xff;
+    if (netmask < 8) {
+      mask    <<= (8 - netmask);
+      netmask   = 0;
+    } else {
+      netmask -= 8;
+    }
+
+    if ((addr_ptr[i] & mask) != (subnet_ptr[i] & mask)) {
+      return ARES_FALSE;
+    }
+  }
+
+  return ARES_TRUE;
+}
+
+ares_bool_t ares_addr_is_linklocal(const struct ares_addr *addr)
+{
+  struct ares_addr    subnet;
+  const unsigned char subnetaddr[16] = { 0xfe, 0x80, 0x00, 0x00, 0x00, 0x00,
+                                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                                         0x00, 0x00, 0x00, 0x00 };
+
+  /* fe80::/10 */
+  subnet.family = AF_INET6;
+  memcpy(&subnet.addr.addr6, subnetaddr, 16);
+
+  return ares_subnet_match(addr, &subnet, 10);
+}
+
+static ares_bool_t ares_server_blacklisted(const struct ares_addr *addr)
+{
+  /* A list of blacklisted IPv6 subnets. */
+  const struct {
+    const unsigned char netbase[16];
+    unsigned char       netmask;
+  } blacklist_v6[] = {
+    /* fec0::/10 was deprecated by [RFC3879] in September 2004. Formerly a
+     * Site-Local scoped address prefix.  These are never valid DNS servers,
+     * but are known to be returned at least sometimes on Windows and Android.
+     */
+    { { 0xfe, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00 },
+     10 }
+  };
+
+  size_t i;
+
+  if (addr->family != AF_INET6) {
+    return ARES_FALSE;
+  }
+
+  /* See if ipaddr matches any of the entries in the blacklist. */
+  for (i = 0; i < sizeof(blacklist_v6) / sizeof(*blacklist_v6); i++) {
+    struct ares_addr subnet;
+    subnet.family = AF_INET6;
+    memcpy(&subnet.addr.addr6, blacklist_v6[i].netbase, 16);
+    if (ares_subnet_match(addr, &subnet, blacklist_v6[i].netmask)) {
+      return ARES_TRUE;
+    }
+  }
+  return ARES_FALSE;
+}
+
+static ares_status_t parse_nameserver_uri(ares_buf_t     *buf,
+                                          ares_sconfig_t *sconfig)
+{
+  ares_uri_t   *uri    = NULL;
+  ares_status_t status = ARES_SUCCESS;
+  const char   *port;
+  char         *ll_scope;
+  char          hoststr[256];
+  size_t        addrlen;
+
+  status = ares_uri_parse_buf(&uri, buf);
+  if (status != ARES_SUCCESS) {
+    return status;
+  }
+
+  if (!ares_streq("dns", ares_uri_get_scheme(uri))) {
+    status = ARES_EBADSTR;
+    goto done;
+  }
+
+  ares_strcpy(hoststr, ares_uri_get_host(uri), sizeof(hoststr));
+  ll_scope = strchr(hoststr, '%');
+  if (ll_scope != NULL) {
+    *ll_scope = 0;
+    ll_scope++;
+    ares_strcpy(sconfig->ll_iface, ll_scope, sizeof(sconfig->ll_iface));
+  }
+
+  /* Convert ip address from string to network byte order */
+  sconfig->addr.family = AF_UNSPEC;
+  if (ares_dns_pton(hoststr, &sconfig->addr, &addrlen) == NULL) {
+    status = ARES_EBADSTR;
+    goto done;
+  }
+
+  sconfig->udp_port = ares_uri_get_port(uri);
+  sconfig->tcp_port = sconfig->udp_port;
+  port              = ares_uri_get_query_key(uri, "tcpport");
+  if (port != NULL) {
+    sconfig->tcp_port = (unsigned short)atoi(port);
+  }
+
+done:
+  ares_uri_destroy(uri);
+  return status;
+}
+
+/* Parse address and port in these formats, either ipv4 or ipv6 addresses
+ * are allowed:
+ *   ipaddr
+ *   ipv4addr:port
+ *   [ipaddr]
+ *   [ipaddr]:port
+ *
+ * Modifiers: %iface
+ *
+ * TODO: #domain modifier
+ *
+ * If a port is not specified, will set port to 0.
+ *
+ * Will fail if an IPv6 nameserver as detected by
+ * ares_ipv6_server_blacklisted()
+ *
+ * Returns an error code on failure, else ARES_SUCCESS
+ */
+
+static ares_status_t parse_nameserver(ares_buf_t *buf, ares_sconfig_t *sconfig)
+{
+  ares_status_t status;
+  char          ipaddr[INET6_ADDRSTRLEN] = "";
+  size_t        addrlen;
+
+  memset(sconfig, 0, sizeof(*sconfig));
+
+  /* Consume any leading whitespace */
+  ares_buf_consume_whitespace(buf, ARES_TRUE);
+
+  /* pop off IP address.  If it is in [ ] then it can be ipv4 or ipv6.  If
+   * not, ipv4 only */
+  if (ares_buf_begins_with(buf, (const unsigned char *)"[", 1)) {
+    /* Consume [ */
+    ares_buf_consume(buf, 1);
+
+    ares_buf_tag(buf);
+
+    /* Consume until ] */
+    if (ares_buf_consume_until_charset(buf, (const unsigned char *)"]", 1,
+                                       ARES_TRUE) == SIZE_MAX) {
+      return ARES_EBADSTR;
+    }
+
+    status = ares_buf_tag_fetch_string(buf, ipaddr, sizeof(ipaddr));
+    if (status != ARES_SUCCESS) {
+      return status;
+    }
+
+    /* Skip over ] */
+    ares_buf_consume(buf, 1);
+  } else {
+    size_t offset;
+
+    /* Not in [ ], see if '.' is in first 4 characters, if it is, then its ipv4,
+     * otherwise treat as ipv6 */
+    ares_buf_tag(buf);
+
+    offset = ares_buf_consume_until_charset(buf, (const unsigned char *)".", 1,
+                                            ARES_TRUE);
+    ares_buf_tag_rollback(buf);
+    ares_buf_tag(buf);
+
+    if (offset > 0 && offset < 4) {
+      /* IPv4 */
+      if (ares_buf_consume_charset(buf, (const unsigned char *)"0123456789.",
+                                   11) == 0) {
+        return ARES_EBADSTR;
+      }
+    } else {
+      /* IPv6 */
+      const unsigned char ipv6_charset[] = "ABCDEFabcdef0123456789.:";
+      if (ares_buf_consume_charset(buf, ipv6_charset,
+                                   sizeof(ipv6_charset) - 1) == 0) {
+        return ARES_EBADSTR;
+      }
+    }
+
+    status = ares_buf_tag_fetch_string(buf, ipaddr, sizeof(ipaddr));
+    if (status != ARES_SUCCESS) {
+      return status;
+    }
+  }
+
+  /* Convert ip address from string to network byte order */
+  sconfig->addr.family = AF_UNSPEC;
+  if (ares_dns_pton(ipaddr, &sconfig->addr, &addrlen) == NULL) {
+    return ARES_EBADSTR;
+  }
+
+  /* Pull off port */
+  if (ares_buf_begins_with(buf, (const unsigned char *)":", 1)) {
+    char portstr[6];
+
+    /* Consume : */
+    ares_buf_consume(buf, 1);
+
+    ares_buf_tag(buf);
+
+    /* Read numbers */
+    if (ares_buf_consume_charset(buf, (const unsigned char *)"0123456789",
+                                 10) == 0) {
+      return ARES_EBADSTR;
+    }
+
+    status = ares_buf_tag_fetch_string(buf, portstr, sizeof(portstr));
+    if (status != ARES_SUCCESS) {
+      return status;
+    }
+
+    sconfig->udp_port = (unsigned short)atoi(portstr);
+    sconfig->tcp_port = sconfig->udp_port;
+  }
+
+  /* Pull off interface modifier */
+  if (ares_buf_begins_with(buf, (const unsigned char *)"%", 1)) {
+    const unsigned char iface_charset[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+                                          "abcdefghijklmnopqrstuvwxyz"
+                                          "0123456789.-_\\:{}";
+    /* Consume % */
+    ares_buf_consume(buf, 1);
+
+    ares_buf_tag(buf);
+
+    if (ares_buf_consume_charset(buf, iface_charset,
+                                 sizeof(iface_charset) - 1) == 0) {
+      return ARES_EBADSTR;
+    }
+
+    status = ares_buf_tag_fetch_string(buf, sconfig->ll_iface,
+                                       sizeof(sconfig->ll_iface));
+    if (status != ARES_SUCCESS) {
+      return status;
+    }
+  }
+
+  /* Consume any trailing whitespace so we can bail out if there is something
+   * after we didn't read */
+  ares_buf_consume_whitespace(buf, ARES_TRUE);
+
+  if (ares_buf_len(buf) != 0) {
+    return ARES_EBADSTR;
+  }
+
+  return ARES_SUCCESS;
+}
+
+static ares_status_t ares_sconfig_linklocal(const ares_channel_t *channel,
+                                            ares_sconfig_t       *s,
+                                            const char           *ll_iface)
+{
+  unsigned int ll_scope = 0;
+
+
+  if (ares_str_isnum(ll_iface)) {
+    char ifname[IF_NAMESIZE] = "";
+    ll_scope                 = (unsigned int)atoi(ll_iface);
+    if (channel->sock_funcs.aif_indextoname == NULL ||
+        channel->sock_funcs.aif_indextoname(ll_scope, ifname, sizeof(ifname),
+                                            channel->sock_func_cb_data) ==
+          NULL) {
+      DEBUGF(fprintf(stderr, "Interface %s for ipv6 Link Local not found\n",
+                     ll_iface));
+      return ARES_ENOTFOUND;
+    }
+    ares_strcpy(s->ll_iface, ifname, sizeof(s->ll_iface));
+    s->ll_scope = ll_scope;
+    return ARES_SUCCESS;
+  }
+
+  if (channel->sock_funcs.aif_nametoindex != NULL) {
+    ll_scope =
+      channel->sock_funcs.aif_nametoindex(ll_iface, channel->sock_func_cb_data);
+  }
+  if (ll_scope == 0) {
+    DEBUGF(fprintf(stderr, "Interface %s for ipv6 Link Local not found\n",
+                   ll_iface));
+    return ARES_ENOTFOUND;
+  }
+  ares_strcpy(s->ll_iface, ll_iface, sizeof(s->ll_iface));
+  s->ll_scope = ll_scope;
+  return ARES_SUCCESS;
+}
+
+ares_status_t ares_sconfig_append(const ares_channel_t   *channel,
+                                  ares_llist_t          **sconfig,
+                                  const struct ares_addr *addr,
+                                  unsigned short          udp_port,
+                                  unsigned short tcp_port, const char *ll_iface)
+{
+  ares_sconfig_t *s;
+  ares_status_t   status;
+
+  if (sconfig == NULL || addr == NULL) {
+    return ARES_EFORMERR; /* LCOV_EXCL_LINE: DefensiveCoding */
+  }
+
+  /* Silently skip blacklisted IPv6 servers. */
+  if (ares_server_blacklisted(addr)) {
+    return ARES_SUCCESS;
+  }
+
+  s = ares_malloc_zero(sizeof(*s));
+  if (s == NULL) {
+    return ARES_ENOMEM; /* LCOV_EXCL_LINE: OutOfMemory */
+  }
+
+  if (*sconfig == NULL) {
+    *sconfig = ares_llist_create(ares_free);
+    if (*sconfig == NULL) {
+      status = ARES_ENOMEM; /* LCOV_EXCL_LINE: OutOfMemory */
+      goto fail;            /* LCOV_EXCL_LINE: OutOfMemory */
+    }
+  }
+
+  memcpy(&s->addr, addr, sizeof(s->addr));
+  s->udp_port = udp_port;
+  s->tcp_port = tcp_port;
+
+  /* Handle link-local enumeration. If an interface is specified on a
+   * non-link-local address, we'll simply end up ignoring that */
+  if (ares_addr_is_linklocal(&s->addr)) {
+    if (ares_strlen(ll_iface) == 0) {
+      /* Silently ignore this entry, we require an interface */
+      status = ARES_SUCCESS;
+      goto fail;
+    }
+    status = ares_sconfig_linklocal(channel, s, ll_iface);
+    /* Silently ignore this entry, we can't validate the interface */
+    if (status != ARES_SUCCESS) {
+      status = ARES_SUCCESS;
+      goto fail;
+    }
+  }
+
+  if (ares_llist_insert_last(*sconfig, s) == NULL) {
+    status = ARES_ENOMEM; /* LCOV_EXCL_LINE: OutOfMemory */
+    goto fail;            /* LCOV_EXCL_LINE: OutOfMemory */
+  }
+
+  return ARES_SUCCESS;
+
+fail:
+  ares_free(s);
+
+  return status;
+}
+
+/* Add the IPv4 or IPv6 nameservers in str (separated by commas or spaces) to
+ * the servers list, updating servers and nservers as required.
+ *
+ * If a nameserver is encapsulated in [ ] it may optionally include a port
+ * suffix, e.g.:
+ *    [127.0.0.1]:59591
+ *
+ * The extended format is required to support OpenBSD's resolv.conf format:
+ *   https://man.openbsd.org/OpenBSD-5.1/resolv.conf.5
+ * As well as MacOS libresolv that may include a non-default port number.
+ *
+ * This will silently ignore blacklisted IPv6 nameservers as detected by
+ * ares_ipv6_server_blacklisted().
+ *
+ * Returns an error code on failure, else ARES_SUCCESS.
+ */
+ares_status_t ares_sconfig_append_fromstr(const ares_channel_t *channel,
+                                          ares_llist_t        **sconfig,
+                                          const char           *str,
+                                          ares_bool_t           ignore_invalid)
+{
+  ares_status_t status = ARES_SUCCESS;
+  ares_buf_t   *buf    = NULL;
+  ares_array_t *list   = NULL;
+  size_t        num;
+  size_t        i;
+
+  /* On Windows, there may be more than one nameserver specified in the same
+   * registry key, so we parse input as a space or comma separated list.
+   */
+  buf = ares_buf_create_const((const unsigned char *)str, ares_strlen(str));
+  if (buf == NULL) {
+    status = ARES_ENOMEM;
+    goto done;
+  }
+
+  status = ares_buf_split(buf, (const unsigned char *)" ,", 2,
+                          ARES_BUF_SPLIT_NONE, 0, &list);
+  if (status != ARES_SUCCESS) {
+    goto done;
+  }
+
+  num = ares_array_len(list);
+  for (i = 0; i < num; i++) {
+    ares_buf_t   **bufptr = ares_array_at(list, i);
+    ares_buf_t    *entry  = *bufptr;
+    ares_sconfig_t s;
+
+    status = parse_nameserver_uri(entry, &s);
+    if (status != ARES_SUCCESS) {
+      status = parse_nameserver(entry, &s);
+    }
+
+    if (status != ARES_SUCCESS) {
+      if (ignore_invalid) {
+        continue;
+      } else {
+        goto done;
+      }
+    }
+
+    status = ares_sconfig_append(channel, sconfig, &s.addr, s.udp_port,
+                                 s.tcp_port, s.ll_iface);
+    if (status != ARES_SUCCESS) {
+      goto done; /* LCOV_EXCL_LINE: OutOfMemory */
+    }
+  }
+
+  status = ARES_SUCCESS;
+
+done:
+  ares_array_destroy(list);
+  ares_buf_destroy(buf);
+  return status;
+}
+
+static unsigned short ares_sconfig_get_port(const ares_channel_t *channel,
+                                            const ares_sconfig_t *s,
+                                            ares_bool_t           is_tcp)
+{
+  unsigned short port = is_tcp ? s->tcp_port : s->udp_port;
+
+  if (port == 0) {
+    port = is_tcp ? channel->tcp_port : channel->udp_port;
+  }
+
+  if (port == 0) {
+    port = 53;
+  }
+
+  return port;
+}
+
+static ares_slist_node_t *ares_server_find(const ares_channel_t *channel,
+                                           const ares_sconfig_t *s)
+{
+  ares_slist_node_t *node;
+
+  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);
+
+    if (!ares_addr_match(&server->addr, &s->addr)) {
+      continue;
+    }
+
+    if (server->tcp_port != ares_sconfig_get_port(channel, s, ARES_TRUE)) {
+      continue;
+    }
+
+    if (server->udp_port != ares_sconfig_get_port(channel, s, ARES_FALSE)) {
+      continue;
+    }
+
+    return node;
+  }
+  return NULL;
+}
+
+static ares_bool_t ares_server_isdup(const ares_channel_t *channel,
+                                     ares_llist_node_t    *s)
+{
+  /* Scan backwards to see if this is a duplicate */
+  ares_llist_node_t    *prev;
+  const ares_sconfig_t *server = ares_llist_node_val(s);
+
+  for (prev = ares_llist_node_prev(s); prev != NULL;
+       prev = ares_llist_node_prev(prev)) {
+    const ares_sconfig_t *p = ares_llist_node_val(prev);
+
+    if (!ares_addr_match(&server->addr, &p->addr)) {
+      continue;
+    }
+
+    if (ares_sconfig_get_port(channel, server, ARES_TRUE) !=
+        ares_sconfig_get_port(channel, p, ARES_TRUE)) {
+      continue;
+    }
+
+    if (ares_sconfig_get_port(channel, server, ARES_FALSE) !=
+        ares_sconfig_get_port(channel, p, ARES_FALSE)) {
+      continue;
+    }
+
+    return ARES_TRUE;
+  }
+
+  return ARES_FALSE;
+}
+
+static ares_status_t ares_server_create(ares_channel_t       *channel,
+                                        const ares_sconfig_t *sconfig,
+                                        size_t                idx)
+{
+  ares_status_t  status;
+  ares_server_t *server = ares_malloc_zero(sizeof(*server));
+
+  if (server == NULL) {
+    return ARES_ENOMEM; /* LCOV_EXCL_LINE: OutOfMemory */
+  }
+
+  server->idx         = idx;
+  server->channel     = channel;
+  server->udp_port    = ares_sconfig_get_port(channel, sconfig, ARES_FALSE);
+  server->tcp_port    = ares_sconfig_get_port(channel, sconfig, ARES_TRUE);
+  server->addr.family = sconfig->addr.family;
+  server->next_retry_time.sec  = 0;
+  server->next_retry_time.usec = 0;
+
+  if (sconfig->addr.family == AF_INET) {
+    memcpy(&server->addr.addr.addr4, &sconfig->addr.addr.addr4,
+           sizeof(server->addr.addr.addr4));
+  } else if (sconfig->addr.family == AF_INET6) {
+    memcpy(&server->addr.addr.addr6, &sconfig->addr.addr.addr6,
+           sizeof(server->addr.addr.addr6));
+  }
+
+  /* Copy over link-local settings */
+  if (ares_strlen(sconfig->ll_iface)) {
+    ares_strcpy(server->ll_iface, sconfig->ll_iface, sizeof(server->ll_iface));
+    server->ll_scope = sconfig->ll_scope;
+  }
+
+  server->connections = ares_llist_create(NULL);
+  if (server->connections == NULL) {
+    status = ARES_ENOMEM; /* LCOV_EXCL_LINE: OutOfMemory */
+    goto done;            /* LCOV_EXCL_LINE: OutOfMemory */
+  }
+
+  if (ares_slist_insert(channel->servers, server) == NULL) {
+    status = ARES_ENOMEM; /* LCOV_EXCL_LINE: OutOfMemory */
+    goto done;            /* LCOV_EXCL_LINE: OutOfMemory */
+  }
+
+  status = ARES_SUCCESS;
+
+done:
+  if (status != ARES_SUCCESS) {
+    ares_destroy_server(server); /* LCOV_EXCL_LINE: OutOfMemory */
+  }
+
+  return status;
+}
+
+static ares_bool_t ares_server_in_newconfig(const ares_server_t *server,
+                                            ares_llist_t        *srvlist)
+{
+  ares_llist_node_t    *node;
+  const ares_channel_t *channel = server->channel;
+
+  for (node = ares_llist_node_first(srvlist); node != NULL;
+       node = ares_llist_node_next(node)) {
+    const ares_sconfig_t *s = ares_llist_node_val(node);
+
+    if (!ares_addr_match(&server->addr, &s->addr)) {
+      continue;
+    }
+
+    if (server->tcp_port != ares_sconfig_get_port(channel, s, ARES_TRUE)) {
+      continue;
+    }
+
+    if (server->udp_port != ares_sconfig_get_port(channel, s, ARES_FALSE)) {
+      continue;
+    }
+
+    return ARES_TRUE;
+  }
+
+  return ARES_FALSE;
+}
+
+static ares_bool_t ares_servers_remove_stale(ares_channel_t *channel,
+                                             ares_llist_t   *srvlist)
+{
+  ares_bool_t        stale_removed = ARES_FALSE;
+  ares_slist_node_t *snode         = ares_slist_node_first(channel->servers);
+
+  while (snode != NULL) {
+    ares_slist_node_t   *snext  = ares_slist_node_next(snode);
+    const ares_server_t *server = ares_slist_node_val(snode);
+    if (!ares_server_in_newconfig(server, srvlist)) {
+      /* This will clean up all server state via the destruction callback and
+       * move any queries to new servers */
+      ares_slist_node_destroy(snode);
+      stale_removed = ARES_TRUE;
+    }
+    snode = snext;
+  }
+  return stale_removed;
+}
+
+static void ares_servers_trim_single(ares_channel_t *channel)
+{
+  while (ares_slist_len(channel->servers) > 1) {
+    ares_slist_node_destroy(ares_slist_node_last(channel->servers));
+  }
+}
+
+ares_status_t ares_servers_update(ares_channel_t *channel,
+                                  ares_llist_t   *server_list,
+                                  ares_bool_t     user_specified)
+{
+  ares_llist_node_t *node;
+  size_t             idx = 0;
+  ares_status_t      status;
+  ares_bool_t        list_changed = ARES_FALSE;
+
+  if (channel == NULL) {
+    return ARES_EFORMERR; /* LCOV_EXCL_LINE: DefensiveCoding */
+  }
+
+  /* NOTE: a NULL or zero entry server list is considered valid due to
+   *       real-world people needing support for this for their test harnesses
+   */
+
+  /* Add new entries */
+  for (node = ares_llist_node_first(server_list); node != NULL;
+       node = ares_llist_node_next(node)) {
+    const ares_sconfig_t *sconfig = ares_llist_node_val(node);
+    ares_slist_node_t    *snode;
+
+    /* If a server has already appeared in the list of new servers, skip it. */
+    if (ares_server_isdup(channel, node)) {
+      continue;
+    }
+
+    snode = ares_server_find(channel, sconfig);
+    if (snode != NULL) {
+      ares_server_t *server = ares_slist_node_val(snode);
+
+      /* Copy over link-local settings.  Its possible some of this data has
+       * changed, maybe ...  */
+      if (ares_strlen(sconfig->ll_iface)) {
+        ares_strcpy(server->ll_iface, sconfig->ll_iface,
+                    sizeof(server->ll_iface));
+        server->ll_scope = sconfig->ll_scope;
+      }
+
+      if (server->idx != idx) {
+        server->idx = idx;
+        /* Index changed, reinsert node, doesn't require any memory
+         * allocations so can't fail. */
+        ares_slist_node_reinsert(snode);
+      }
+    } else {
+      status = ares_server_create(channel, sconfig, idx);
+      if (status != ARES_SUCCESS) {
+        goto done;
+      }
+
+      list_changed = ARES_TRUE;
+    }
+
+    idx++;
+  }
+
+  /* Remove any servers that don't exist in the current configuration */
+  if (ares_servers_remove_stale(channel, server_list)) {
+    list_changed = ARES_TRUE;
+  }
+
+  /* Trim to one server if ARES_FLAG_PRIMARY is set. */
+  if (channel->flags & ARES_FLAG_PRIMARY) {
+    ares_servers_trim_single(channel);
+  }
+
+  if (user_specified) {
+    /* Save servers as if they were passed in as an option */
+    channel->optmask |= ARES_OPT_SERVERS;
+  }
+
+  /* Clear any cached query results only if the server list changed */
+  if (list_changed) {
+    ares_qcache_flush(channel->qcache);
+  }
+
+  status = ARES_SUCCESS;
+
+done:
+  return status;
+}
+
+static ares_status_t
+  ares_addr_node_to_sconfig_llist(const struct ares_addr_node *servers,
+                                  ares_llist_t               **llist)
+{
+  const struct ares_addr_node *node;
+  ares_llist_t                *s;
+
+  *llist = NULL;
+
+  s = ares_llist_create(ares_free);
+  if (s == NULL) {
+    goto fail; /* LCOV_EXCL_LINE: OutOfMemory */
+  }
+
+  for (node = servers; node != NULL; node = node->next) {
+    ares_sconfig_t *sconfig;
+
+    /* Invalid entry */
+    if (node->family != AF_INET && node->family != AF_INET6) {
+      continue;
+    }
+
+    sconfig = ares_malloc_zero(sizeof(*sconfig));
+    if (sconfig == NULL) {
+      goto fail; /* LCOV_EXCL_LINE: OutOfMemory */
+    }
+
+    sconfig->addr.family = node->family;
+    if (node->family == AF_INET) {
+      memcpy(&sconfig->addr.addr.addr4, &node->addr.addr4,
+             sizeof(sconfig->addr.addr.addr4));
+    } else if (sconfig->addr.family == AF_INET6) {
+      memcpy(&sconfig->addr.addr.addr6, &node->addr.addr6,
+             sizeof(sconfig->addr.addr.addr6));
+    }
+
+    if (ares_llist_insert_last(s, sconfig) == NULL) {
+      ares_free(sconfig); /* LCOV_EXCL_LINE: OutOfMemory */
+      goto fail;          /* LCOV_EXCL_LINE: OutOfMemory */
+    }
+  }
+
+  *llist = s;
+  return ARES_SUCCESS;
+
+/* LCOV_EXCL_START: OutOfMemory */
+fail:
+  ares_llist_destroy(s);
+  return ARES_ENOMEM;
+  /* LCOV_EXCL_STOP */
+}
+
+static ares_status_t
+  ares_addrpnode_to_sconfig_llist(const struct ares_addr_port_node *servers,
+                                  ares_llist_t                    **llist)
+{
+  const struct ares_addr_port_node *node;
+  ares_llist_t                     *s;
+
+  *llist = NULL;
+
+  s = ares_llist_create(ares_free);
+  if (s == NULL) {
+    goto fail; /* LCOV_EXCL_LINE: OutOfMemory */
+  }
+
+  for (node = servers; node != NULL; node = node->next) {
+    ares_sconfig_t *sconfig;
+
+    /* Invalid entry */
+    if (node->family != AF_INET && node->family != AF_INET6) {
+      continue;
+    }
+
+    sconfig = ares_malloc_zero(sizeof(*sconfig));
+    if (sconfig == NULL) {
+      goto fail; /* LCOV_EXCL_LINE: OutOfMemory */
+    }
+
+    sconfig->addr.family = node->family;
+    if (node->family == AF_INET) {
+      memcpy(&sconfig->addr.addr.addr4, &node->addr.addr4,
+             sizeof(sconfig->addr.addr.addr4));
+    } else if (sconfig->addr.family == AF_INET6) {
+      memcpy(&sconfig->addr.addr.addr6, &node->addr.addr6,
+             sizeof(sconfig->addr.addr.addr6));
+    }
+
+    sconfig->tcp_port = (unsigned short)node->tcp_port;
+    sconfig->udp_port = (unsigned short)node->udp_port;
+
+    if (ares_llist_insert_last(s, sconfig) == NULL) {
+      ares_free(sconfig); /* LCOV_EXCL_LINE: OutOfMemory */
+      goto fail;          /* LCOV_EXCL_LINE: OutOfMemory */
+    }
+  }
+
+  *llist = s;
+  return ARES_SUCCESS;
+
+/* LCOV_EXCL_START: OutOfMemory */
+fail:
+  ares_llist_destroy(s);
+  return ARES_ENOMEM;
+  /* LCOV_EXCL_STOP */
+}
+
+ares_status_t ares_in_addr_to_sconfig_llist(const struct in_addr *servers,
+                                            size_t                nservers,
+                                            ares_llist_t        **llist)
+{
+  size_t        i;
+  ares_llist_t *s;
+
+  *llist = NULL;
+
+  s = ares_llist_create(ares_free);
+  if (s == NULL) {
+    goto fail; /* LCOV_EXCL_LINE: OutOfMemory */
+  }
+
+  for (i = 0; servers != NULL && i < nservers; i++) {
+    ares_sconfig_t *sconfig;
+
+    sconfig = ares_malloc_zero(sizeof(*sconfig));
+    if (sconfig == NULL) {
+      goto fail; /* LCOV_EXCL_LINE: OutOfMemory */
+    }
+
+    sconfig->addr.family = AF_INET;
+    memcpy(&sconfig->addr.addr.addr4, &servers[i],
+           sizeof(sconfig->addr.addr.addr4));
+
+    if (ares_llist_insert_last(s, sconfig) == NULL) {
+      goto fail; /* LCOV_EXCL_LINE: OutOfMemory */
+    }
+  }
+
+  *llist = s;
+  return ARES_SUCCESS;
+
+/* LCOV_EXCL_START: OutOfMemory */
+fail:
+  ares_llist_destroy(s);
+  return ARES_ENOMEM;
+  /* LCOV_EXCL_STOP */
+}
+
+static ares_bool_t ares_server_use_uri(const ares_server_t *server)
+{
+  /* Currently only reason to use new format is if the ports for udp and tcp
+   * are different */
+  if (server->tcp_port != server->udp_port) {
+    return ARES_TRUE;
+  }
+  return ARES_FALSE;
+}
+
+static ares_status_t ares_get_server_addr_uri(const ares_server_t *server,
+                                              ares_buf_t          *buf)
+{
+  ares_uri_t   *uri = NULL;
+  ares_status_t status;
+  char          addr[INET6_ADDRSTRLEN];
+
+  uri = ares_uri_create();
+  if (uri == NULL) {
+    return ARES_ENOMEM;
+  }
+
+  status = ares_uri_set_scheme(uri, "dns");
+  if (status != ARES_SUCCESS) {
+    goto done;
+  }
+
+  ares_inet_ntop(server->addr.family, &server->addr.addr, addr, sizeof(addr));
+
+  if (ares_strlen(server->ll_iface)) {
+    char addr_iface[256];
+
+    snprintf(addr_iface, sizeof(addr_iface), "%s%%%s", addr, server->ll_iface);
+    status = ares_uri_set_host(uri, addr_iface);
+  } else {
+    status = ares_uri_set_host(uri, addr);
+  }
+
+  if (status != ARES_SUCCESS) {
+    goto done;
+  }
+
+  status = ares_uri_set_port(uri, server->udp_port);
+  if (status != ARES_SUCCESS) {
+    goto done;
+  }
+
+  if (server->udp_port != server->tcp_port) {
+    char port[6];
+    snprintf(port, sizeof(port), "%d", server->tcp_port);
+    status = ares_uri_set_query_key(uri, "tcpport", port);
+    if (status != ARES_SUCCESS) {
+      goto done;
+    }
+  }
+
+  status = ares_uri_write_buf(uri, buf);
+  if (status != ARES_SUCCESS) {
+    goto done;
+  }
+
+done:
+  ares_uri_destroy(uri);
+  return status;
+}
+
+/* Write out the details of a server to a buffer */
+ares_status_t ares_get_server_addr(const ares_server_t *server, ares_buf_t *buf)
+{
+  ares_status_t status;
+  char          addr[INET6_ADDRSTRLEN];
+
+  if (ares_server_use_uri(server)) {
+    return ares_get_server_addr_uri(server, buf);
+  }
+
+  /* ipv4addr or [ipv6addr] */
+  if (server->addr.family == AF_INET6) {
+    status = ares_buf_append_byte(buf, '[');
+    if (status != ARES_SUCCESS) {
+      return status; /* LCOV_EXCL_LINE: OutOfMemory */
+    }
+  }
+
+  ares_inet_ntop(server->addr.family, &server->addr.addr, addr, sizeof(addr));
+
+  status = ares_buf_append_str(buf, addr);
+  if (status != ARES_SUCCESS) {
+    return status; /* LCOV_EXCL_LINE: OutOfMemory */
+  }
+
+  if (server->addr.family == AF_INET6) {
+    status = ares_buf_append_byte(buf, ']');
+    if (status != ARES_SUCCESS) {
+      return status; /* LCOV_EXCL_LINE: OutOfMemory */
+    }
+  }
+
+  /* :port */
+  status = ares_buf_append_byte(buf, ':');
+  if (status != ARES_SUCCESS) {
+    return status; /* LCOV_EXCL_LINE: OutOfMemory */
+  }
+
+  status = ares_buf_append_num_dec(buf, server->udp_port, 0);
+  if (status != ARES_SUCCESS) {
+    return status; /* LCOV_EXCL_LINE: OutOfMemory */
+  }
+
+  /* %iface */
+  if (ares_strlen(server->ll_iface)) {
+    status = ares_buf_append_byte(buf, '%');
+    if (status != ARES_SUCCESS) {
+      return status; /* LCOV_EXCL_LINE: OutOfMemory */
+    }
+
+    status = ares_buf_append_str(buf, server->ll_iface);
+    if (status != ARES_SUCCESS) {
+      return status; /* LCOV_EXCL_LINE: OutOfMemory */
+    }
+  }
+
+  return ARES_SUCCESS;
+}
+
+int ares_get_servers(const ares_channel_t   *channel,
+                     struct ares_addr_node **servers)
+{
+  struct ares_addr_node *srvr_head = NULL;
+  struct ares_addr_node *srvr_last = NULL;
+  struct ares_addr_node *srvr_curr;
+  ares_status_t          status = ARES_SUCCESS;
+  ares_slist_node_t     *node;
+
+  if (channel == NULL) {
+    return ARES_ENODATA;
+  }
+
+  ares_channel_lock(channel);
+
+  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);
+
+    /* Allocate storage for this server node appending it to the list */
+    srvr_curr = ares_malloc_data(ARES_DATATYPE_ADDR_NODE);
+    if (!srvr_curr) {
+      status = ARES_ENOMEM;
+      break;
+    }
+    if (srvr_last) {
+      srvr_last->next = srvr_curr;
+    } else {
+      srvr_head = srvr_curr;
+    }
+    srvr_last = srvr_curr;
+
+    /* Fill this server node data */
+    srvr_curr->family = server->addr.family;
+    if (srvr_curr->family == AF_INET) {
+      memcpy(&srvr_curr->addr.addr4, &server->addr.addr.addr4,
+             sizeof(srvr_curr->addr.addr4));
+    } else {
+      memcpy(&srvr_curr->addr.addr6, &server->addr.addr.addr6,
+             sizeof(srvr_curr->addr.addr6));
+    }
+  }
+
+  if (status != ARES_SUCCESS) {
+    ares_free_data(srvr_head);
+    srvr_head = NULL;
+  }
+
+  *servers = srvr_head;
+
+  ares_channel_unlock(channel);
+
+  return (int)status;
+}
+
+int ares_get_servers_ports(const ares_channel_t        *channel,
+                           struct ares_addr_port_node **servers)
+{
+  struct ares_addr_port_node *srvr_head = NULL;
+  struct ares_addr_port_node *srvr_last = NULL;
+  struct ares_addr_port_node *srvr_curr;
+  ares_status_t               status = ARES_SUCCESS;
+  ares_slist_node_t          *node;
+
+  if (channel == NULL) {
+    return ARES_ENODATA;
+  }
+
+  ares_channel_lock(channel);
+
+  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);
+
+    /* Allocate storage for this server node appending it to the list */
+    srvr_curr = ares_malloc_data(ARES_DATATYPE_ADDR_PORT_NODE);
+    if (!srvr_curr) {
+      status = ARES_ENOMEM;
+      break;
+    }
+    if (srvr_last) {
+      srvr_last->next = srvr_curr;
+    } else {
+      srvr_head = srvr_curr;
+    }
+    srvr_last = srvr_curr;
+
+    /* Fill this server node data */
+    srvr_curr->family   = server->addr.family;
+    srvr_curr->udp_port = server->udp_port;
+    srvr_curr->tcp_port = server->tcp_port;
+
+    if (srvr_curr->family == AF_INET) {
+      memcpy(&srvr_curr->addr.addr4, &server->addr.addr.addr4,
+             sizeof(srvr_curr->addr.addr4));
+    } else {
+      memcpy(&srvr_curr->addr.addr6, &server->addr.addr.addr6,
+             sizeof(srvr_curr->addr.addr6));
+    }
+  }
+
+  if (status != ARES_SUCCESS) {
+    ares_free_data(srvr_head);
+    srvr_head = NULL;
+  }
+
+  *servers = srvr_head;
+
+  ares_channel_unlock(channel);
+  return (int)status;
+}
+
+int ares_set_servers(ares_channel_t              *channel,
+                     const struct ares_addr_node *servers)
+{
+  ares_llist_t *slist;
+  ares_status_t status;
+
+  if (channel == NULL) {
+    return ARES_ENODATA;
+  }
+
+  status = ares_addr_node_to_sconfig_llist(servers, &slist);
+  if (status != ARES_SUCCESS) {
+    return (int)status;
+  }
+
+  ares_channel_lock(channel);
+  status = ares_servers_update(channel, slist, ARES_TRUE);
+  ares_channel_unlock(channel);
+
+  ares_llist_destroy(slist);
+
+  return (int)status;
+}
+
+int ares_set_servers_ports(ares_channel_t                   *channel,
+                           const struct ares_addr_port_node *servers)
+{
+  ares_llist_t *slist;
+  ares_status_t status;
+
+  if (channel == NULL) {
+    return ARES_ENODATA;
+  }
+
+  status = ares_addrpnode_to_sconfig_llist(servers, &slist);
+  if (status != ARES_SUCCESS) {
+    return (int)status;
+  }
+
+  ares_channel_lock(channel);
+  status = ares_servers_update(channel, slist, ARES_TRUE);
+  ares_channel_unlock(channel);
+
+  ares_llist_destroy(slist);
+
+  return (int)status;
+}
+
+/* Incoming string format: host[:port][,host[:port]]... */
+/* IPv6 addresses with ports require square brackets [fe80::1]:53 */
+static ares_status_t set_servers_csv(ares_channel_t *channel, const char *_csv)
+{
+  ares_status_t status;
+  ares_llist_t *slist = NULL;
+
+  if (channel == NULL) {
+    return ARES_ENODATA;
+  }
+
+  if (ares_strlen(_csv) == 0) {
+    /* blank all servers */
+    ares_channel_lock(channel);
+    status = ares_servers_update(channel, NULL, ARES_TRUE);
+    ares_channel_unlock(channel);
+    return status;
+  }
+
+  status = ares_sconfig_append_fromstr(channel, &slist, _csv, ARES_FALSE);
+  if (status != ARES_SUCCESS) {
+    ares_llist_destroy(slist);
+    return status;
+  }
+
+  ares_channel_lock(channel);
+  status = ares_servers_update(channel, slist, ARES_TRUE);
+  ares_channel_unlock(channel);
+
+  ares_llist_destroy(slist);
+
+  return status;
+}
+
+/* We'll go ahead and honor ports anyhow */
+int ares_set_servers_csv(ares_channel_t *channel, const char *_csv)
+{
+  return (int)set_servers_csv(channel, _csv);
+}
+
+int ares_set_servers_ports_csv(ares_channel_t *channel, const char *_csv)
+{
+  return (int)set_servers_csv(channel, _csv);
+}
+
+char *ares_get_servers_csv(const ares_channel_t *channel)
+{
+  ares_buf_t        *buf = NULL;
+  char              *out = NULL;
+  ares_slist_node_t *node;
+
+  ares_channel_lock(channel);
+
+  buf = ares_buf_create();
+  if (buf == NULL) {
+    goto done; /* LCOV_EXCL_LINE: OutOfMemory */
+  }
+
+  for (node = ares_slist_node_first(channel->servers); node != NULL;
+       node = ares_slist_node_next(node)) {
+    ares_status_t        status;
+    const ares_server_t *server = ares_slist_node_val(node);
+
+    if (ares_buf_len(buf)) {
+      status = ares_buf_append_byte(buf, ',');
+      if (status != ARES_SUCCESS) {
+        goto done; /* LCOV_EXCL_LINE: OutOfMemory */
+      }
+    }
+
+    status = ares_get_server_addr(server, buf);
+    if (status != ARES_SUCCESS) {
+      goto done; /* LCOV_EXCL_LINE: OutOfMemory */
+    }
+  }
+
+  out = ares_buf_finish_str(buf, NULL);
+  buf = NULL;
+
+done:
+  ares_channel_unlock(channel);
+  ares_buf_destroy(buf);
+  return out;
+}
+
+void ares_set_server_state_callback(ares_channel_t            *channel,
+                                    ares_server_state_callback cb, void *data)
+{
+  if (channel == NULL) {
+    return; /* LCOV_EXCL_LINE: DefensiveCoding */
+  }
+  channel->server_state_cb      = cb;
+  channel->server_state_cb_data = data;
+}