grpc 1.74.1 → 1.75.0.pre1

data/third_party/cares/cares/src/lib/legacy/ares_getsock.c

@@ -0,0 +1,85 @@
+/* MIT License
+ *
+ * Copyright (c) 2005 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:
+ *
+ * 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"
+
+int ares_getsock(const ares_channel_t *channel, ares_socket_t *socks,
+                 int numsocks) /* size of the 'socks' array */
+{
+  ares_slist_node_t *snode;
+  size_t             sockindex = 0;
+  unsigned int       bitmap    = 0;
+  unsigned int       setbits   = 0xffffffff;
+
+  /* Are there any active queries? */
+  size_t             active_queries;
+
+  if (channel == NULL || numsocks <= 0) {
+    return 0;
+  }
+
+  ares_channel_lock(channel);
+
+  active_queries = ares_llist_len(channel->all_queries);
+
+  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);
+
+      if (sockindex >= (size_t)numsocks || sockindex >= ARES_GETSOCK_MAXNUM) {
+        break;
+      }
+
+      /* We only need to register interest in UDP sockets if we have
+       * outstanding queries.
+       */
+      if (!active_queries && !(conn->flags & ARES_CONN_FLAG_TCP)) {
+        continue;
+      }
+
+      socks[sockindex] = conn->fd;
+
+      if (active_queries || conn->flags & ARES_CONN_FLAG_TCP) {
+        bitmap |= ARES_GETSOCK_READABLE(setbits, sockindex);
+      }
+
+      if (conn->state_flags & ARES_CONN_STATE_WRITE) {
+        /* then the tcp socket is also writable! */
+        bitmap |= ARES_GETSOCK_WRITABLE(setbits, sockindex);
+      }
+
+      sockindex++;
+    }
+  }
+
+  ares_channel_unlock(channel);
+  return (int)bitmap;
+}

data/third_party/cares/cares/src/lib/legacy/ares_parse_a_reply.c

@@ -0,0 +1,107 @@
+/* MIT License
+ *
+ * Copyright (c) 1998 Massachusetts Institute of Technology
+ * Copyright (c) 2019 Andrew Selivanov
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "ares_private.h"
+
+#ifdef HAVE_NETINET_IN_H
+#  include <netinet/in.h>
+#endif
+#ifdef HAVE_NETDB_H
+#  include <netdb.h>
+#endif
+#ifdef HAVE_ARPA_INET_H
+#  include <arpa/inet.h>
+#endif
+
+#ifdef HAVE_STRINGS_H
+#  include <strings.h>
+#endif
+
+#ifdef HAVE_LIMITS_H
+#  include <limits.h>
+#endif
+
+int ares_parse_a_reply(const unsigned char *abuf, int alen,
+                       struct hostent **host, struct ares_addrttl *addrttls,
+                       int *naddrttls)
+{
+  struct ares_addrinfo ai;
+  char                *question_hostname = NULL;
+  ares_status_t        status;
+  size_t               req_naddrttls = 0;
+  ares_dns_record_t   *dnsrec        = NULL;
+
+  if (alen < 0) {
+    return ARES_EBADRESP;
+  }
+
+  if (naddrttls) {
+    req_naddrttls = (size_t)*naddrttls;
+    *naddrttls    = 0;
+  }
+
+  memset(&ai, 0, sizeof(ai));
+
+  status = ares_dns_parse(abuf, (size_t)alen, 0, &dnsrec);
+  if (status != ARES_SUCCESS) {
+    goto fail;
+  }
+
+  status = ares_parse_into_addrinfo(dnsrec, 0, 0, &ai);
+  if (status != ARES_SUCCESS && status != ARES_ENODATA) {
+    goto fail;
+  }
+
+  if (host != NULL) {
+    *host  = NULL;
+    status = ares_addrinfo2hostent(&ai, AF_INET, host);
+    if (status != ARES_SUCCESS && status != ARES_ENODATA) {
+      goto fail; /* LCOV_EXCL_LINE: DefensiveCoding */
+    }
+  }
+
+  if (addrttls != NULL && req_naddrttls) {
+    size_t temp_naddrttls = 0;
+    ares_addrinfo2addrttl(&ai, AF_INET, req_naddrttls, addrttls, NULL,
+                          &temp_naddrttls);
+    *naddrttls = (int)temp_naddrttls;
+  }
+
+
+fail:
+  ares_freeaddrinfo_cnames(ai.cnames);
+  ares_freeaddrinfo_nodes(ai.nodes);
+  ares_free(ai.name);
+  ares_free(question_hostname);
+  ares_dns_record_destroy(dnsrec);
+
+  if (status == ARES_EBADNAME) {
+    status = ARES_EBADRESP;
+  }
+
+  return (int)status;
+}

data/third_party/cares/cares/src/lib/legacy/ares_parse_aaaa_reply.c

@@ -0,0 +1,109 @@
+/* MIT License
+ *
+ * Copyright (c) 1998 Massachusetts Institute of Technology
+ * Copyright (c) 2005 Dominick Meglio
+ * Copyright (c) 2019 Andrew Selivanov
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "ares_private.h"
+
+#ifdef HAVE_NETINET_IN_H
+#  include <netinet/in.h>
+#endif
+#ifdef HAVE_NETDB_H
+#  include <netdb.h>
+#endif
+#ifdef HAVE_ARPA_INET_H
+#  include <arpa/inet.h>
+#endif
+
+#ifdef HAVE_STRINGS_H
+#  include <strings.h>
+#endif
+
+#ifdef HAVE_LIMITS_H
+#  include <limits.h>
+#endif
+
+#include "ares_inet_net_pton.h"
+
+int ares_parse_aaaa_reply(const unsigned char *abuf, int alen,
+                          struct hostent **host, struct ares_addr6ttl *addrttls,
+                          int *naddrttls)
+{
+  struct ares_addrinfo ai;
+  char                *question_hostname = NULL;
+  ares_status_t        status;
+  size_t               req_naddrttls = 0;
+  ares_dns_record_t   *dnsrec        = NULL;
+
+  if (alen < 0) {
+    return ARES_EBADRESP;
+  }
+
+  if (naddrttls) {
+    req_naddrttls = (size_t)*naddrttls;
+    *naddrttls    = 0;
+  }
+
+  memset(&ai, 0, sizeof(ai));
+
+  status = ares_dns_parse(abuf, (size_t)alen, 0, &dnsrec);
+  if (status != ARES_SUCCESS) {
+    goto fail;
+  }
+
+  status = ares_parse_into_addrinfo(dnsrec, 0, 0, &ai);
+  if (status != ARES_SUCCESS && status != ARES_ENODATA) {
+    goto fail;
+  }
+
+  if (host != NULL) {
+    *host  = NULL;
+    status = ares_addrinfo2hostent(&ai, AF_INET6, host);
+    if (status != ARES_SUCCESS && status != ARES_ENODATA) {
+      goto fail; /* LCOV_EXCL_LINE: DefensiveCoding */
+    }
+  }
+
+  if (addrttls != NULL && req_naddrttls) {
+    size_t temp_naddrttls = 0;
+    ares_addrinfo2addrttl(&ai, AF_INET6, req_naddrttls, NULL, addrttls,
+                          &temp_naddrttls);
+    *naddrttls = (int)temp_naddrttls;
+  }
+
+fail:
+  ares_freeaddrinfo_cnames(ai.cnames);
+  ares_freeaddrinfo_nodes(ai.nodes);
+  ares_free(question_hostname);
+  ares_free(ai.name);
+  ares_dns_record_destroy(dnsrec);
+
+  if (status == ARES_EBADNAME) {
+    status = ARES_EBADRESP;
+  }
+
+  return (int)status;
+}

data/third_party/cares/cares/src/lib/legacy/ares_parse_caa_reply.c

@@ -0,0 +1,137 @@
+/* MIT License
+ *
+ * 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"
+#include "ares_data.h"
+
+int ares_parse_caa_reply(const unsigned char *abuf, int alen_int,
+                         struct ares_caa_reply **caa_out)
+{
+  ares_status_t          status;
+  size_t                 alen;
+  struct ares_caa_reply *caa_head = NULL;
+  struct ares_caa_reply *caa_last = NULL;
+  struct ares_caa_reply *caa_curr;
+  ares_dns_record_t     *dnsrec = NULL;
+  size_t                 i;
+
+  *caa_out = NULL;
+
+  if (alen_int < 0) {
+    return ARES_EBADRESP;
+  }
+
+  alen = (size_t)alen_int;
+
+  status = ares_dns_parse(abuf, alen, 0, &dnsrec);
+  if (status != ARES_SUCCESS) {
+    goto done;
+  }
+
+  if (ares_dns_record_rr_cnt(dnsrec, ARES_SECTION_ANSWER) == 0) {
+    status = ARES_ENODATA;
+    goto done;
+  }
+
+  for (i = 0; i < ares_dns_record_rr_cnt(dnsrec, ARES_SECTION_ANSWER); i++) {
+    const unsigned char *ptr;
+    size_t               ptr_len;
+    const ares_dns_rr_t *rr =
+      ares_dns_record_rr_get(dnsrec, ARES_SECTION_ANSWER, i);
+
+    if (rr == NULL) {
+      /* Shouldn't be possible */
+      status = ARES_EBADRESP; /* LCOV_EXCL_LINE: DefensiveCoding */
+      goto done;              /* LCOV_EXCL_LINE: DefensiveCoding */
+    }
+
+    /* XXX: Why do we allow Chaos class? */
+    if (ares_dns_rr_get_class(rr) != ARES_CLASS_IN &&
+        ares_dns_rr_get_class(rr) != ARES_CLASS_CHAOS) {
+      continue;
+    }
+
+    /* Only looking for CAA records */
+    if (ares_dns_rr_get_type(rr) != ARES_REC_TYPE_CAA) {
+      continue;
+    }
+
+    /* Allocate storage for this CAA answer appending it to the list */
+    caa_curr = ares_malloc_data(ARES_DATATYPE_CAA_REPLY);
+    if (caa_curr == NULL) {
+      status = ARES_ENOMEM; /* LCOV_EXCL_LINE: OutOfMemory */
+      goto done;            /* LCOV_EXCL_LINE: OutOfMemory */
+    }
+
+    /* Link in the record */
+    if (caa_last) {
+      caa_last->next = caa_curr;
+    } else {
+      caa_head = caa_curr;
+    }
+    caa_last = caa_curr;
+
+    caa_curr->critical = ares_dns_rr_get_u8(rr, ARES_RR_CAA_CRITICAL);
+    caa_curr->property =
+      (unsigned char *)ares_strdup(ares_dns_rr_get_str(rr, ARES_RR_CAA_TAG));
+    if (caa_curr->property == NULL) {
+      status = ARES_ENOMEM; /* LCOV_EXCL_LINE: OutOfMemory */
+      break;                /* LCOV_EXCL_LINE: OutOfMemory */
+    }
+    /* RFC6844 says this can only be ascii, so not sure why we're recording a
+     * length */
+    caa_curr->plength = ares_strlen((const char *)caa_curr->property);
+
+    ptr = ares_dns_rr_get_bin(rr, ARES_RR_CAA_VALUE, &ptr_len);
+    if (ptr == NULL) {
+      status = ARES_EBADRESP; /* LCOV_EXCL_LINE: DefensiveCoding */
+      goto done;              /* LCOV_EXCL_LINE: DefensiveCoding */
+    }
+
+    /* Wants NULL termination for some reason */
+    caa_curr->value = ares_malloc(ptr_len + 1);
+    if (caa_curr->value == NULL) {
+      status = ARES_ENOMEM; /* LCOV_EXCL_LINE: OutOfMemory */
+      goto done;            /* LCOV_EXCL_LINE: OutOfMemory */
+    }
+    memcpy(caa_curr->value, ptr, ptr_len);
+    caa_curr->value[ptr_len] = 0;
+    caa_curr->length         = ptr_len;
+  }
+
+done:
+  /* clean up on error */
+  if (status != ARES_SUCCESS) {
+    if (caa_head) {
+      ares_free_data(caa_head);
+    }
+  } else {
+    /* everything looks fine, return the data */
+    *caa_out = caa_head;
+  }
+  ares_dns_record_destroy(dnsrec);
+  return (int)status;
+}

data/third_party/cares/cares/src/lib/legacy/ares_parse_mx_reply.c

@@ -0,0 +1,110 @@
+/* MIT License
+ *
+ * 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"
+#include "ares_data.h"
+
+int ares_parse_mx_reply(const unsigned char *abuf, int alen_int,
+                        struct ares_mx_reply **mx_out)
+{
+  ares_status_t         status;
+  size_t                alen;
+  struct ares_mx_reply *mx_head = NULL;
+  struct ares_mx_reply *mx_last = NULL;
+  struct ares_mx_reply *mx_curr;
+  ares_dns_record_t    *dnsrec = NULL;
+  size_t                i;
+
+  *mx_out = NULL;
+
+  if (alen_int < 0) {
+    return ARES_EBADRESP;
+  }
+
+  alen = (size_t)alen_int;
+
+  status = ares_dns_parse(abuf, alen, 0, &dnsrec);
+  if (status != ARES_SUCCESS) {
+    goto done;
+  }
+
+  if (ares_dns_record_rr_cnt(dnsrec, ARES_SECTION_ANSWER) == 0) {
+    status = ARES_ENODATA;
+    goto done;
+  }
+
+  for (i = 0; i < ares_dns_record_rr_cnt(dnsrec, ARES_SECTION_ANSWER); i++) {
+    const ares_dns_rr_t *rr =
+      ares_dns_record_rr_get(dnsrec, ARES_SECTION_ANSWER, i);
+
+    if (rr == NULL) {
+      /* Shouldn't be possible */
+      status = ARES_EBADRESP; /* LCOV_EXCL_LINE: DefensiveCoding */
+      goto done;              /* LCOV_EXCL_LINE: DefensiveCoding */
+    }
+
+    if (ares_dns_rr_get_class(rr) != ARES_CLASS_IN ||
+        ares_dns_rr_get_type(rr) != ARES_REC_TYPE_MX) {
+      continue;
+    }
+
+    /* Allocate storage for this MX answer appending it to the list */
+    mx_curr = ares_malloc_data(ARES_DATATYPE_MX_REPLY);
+    if (mx_curr == NULL) {
+      status = ARES_ENOMEM; /* LCOV_EXCL_LINE: OutOfMemory */
+      goto done;            /* LCOV_EXCL_LINE: OutOfMemory */
+    }
+
+    /* Link in the record */
+    if (mx_last) {
+      mx_last->next = mx_curr;
+    } else {
+      mx_head = mx_curr;
+    }
+    mx_last = mx_curr;
+
+    mx_curr->priority = ares_dns_rr_get_u16(rr, ARES_RR_MX_PREFERENCE);
+    mx_curr->host = ares_strdup(ares_dns_rr_get_str(rr, ARES_RR_MX_EXCHANGE));
+
+    if (mx_curr->host == NULL) {
+      status = ARES_ENOMEM; /* LCOV_EXCL_LINE: OutOfMemory */
+      goto done;            /* LCOV_EXCL_LINE: OutOfMemory */
+    }
+  }
+
+done:
+  /* clean up on error */
+  if (status != ARES_SUCCESS) {
+    if (mx_head) {
+      ares_free_data(mx_head);
+    }
+  } else {
+    /* everything looks fine, return the data */
+    *mx_out = mx_head;
+  }
+  ares_dns_record_destroy(dnsrec);
+  return (int)status;
+}

data/third_party/cares/cares/src/lib/legacy/ares_parse_naptr_reply.c

@@ -0,0 +1,132 @@
+/* MIT License
+ *
+ * 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"
+#include "ares_data.h"
+
+int ares_parse_naptr_reply(const unsigned char *abuf, int alen_int,
+                           struct ares_naptr_reply **naptr_out)
+{
+  ares_status_t            status;
+  size_t                   alen;
+  struct ares_naptr_reply *naptr_head = NULL;
+  struct ares_naptr_reply *naptr_last = NULL;
+  struct ares_naptr_reply *naptr_curr;
+  ares_dns_record_t       *dnsrec = NULL;
+  size_t                   i;
+
+  *naptr_out = NULL;
+
+  if (alen_int < 0) {
+    return ARES_EBADRESP;
+  }
+
+  alen = (size_t)alen_int;
+
+  status = ares_dns_parse(abuf, alen, 0, &dnsrec);
+  if (status != ARES_SUCCESS) {
+    goto done;
+  }
+
+  if (ares_dns_record_rr_cnt(dnsrec, ARES_SECTION_ANSWER) == 0) {
+    status = ARES_ENODATA;
+    goto done;
+  }
+
+  for (i = 0; i < ares_dns_record_rr_cnt(dnsrec, ARES_SECTION_ANSWER); i++) {
+    const ares_dns_rr_t *rr =
+      ares_dns_record_rr_get(dnsrec, ARES_SECTION_ANSWER, i);
+
+    if (rr == NULL) {
+      /* Shouldn't be possible */
+      status = ARES_EBADRESP; /* LCOV_EXCL_LINE: DefensiveCoding */
+      goto done;              /* LCOV_EXCL_LINE: DefensiveCoding */
+    }
+
+    if (ares_dns_rr_get_class(rr) != ARES_CLASS_IN ||
+        ares_dns_rr_get_type(rr) != ARES_REC_TYPE_NAPTR) {
+      continue;
+    }
+
+    /* Allocate storage for this NAPTR answer appending it to the list */
+    naptr_curr = ares_malloc_data(ARES_DATATYPE_NAPTR_REPLY);
+    if (naptr_curr == NULL) {
+      status = ARES_ENOMEM; /* LCOV_EXCL_LINE: OutOfMemory */
+      goto done;            /* LCOV_EXCL_LINE: OutOfMemory */
+    }
+
+    /* Link in the record */
+    if (naptr_last) {
+      naptr_last->next = naptr_curr;
+    } else {
+      naptr_head = naptr_curr;
+    }
+    naptr_last = naptr_curr;
+
+    naptr_curr->order      = ares_dns_rr_get_u16(rr, ARES_RR_NAPTR_ORDER);
+    naptr_curr->preference = ares_dns_rr_get_u16(rr, ARES_RR_NAPTR_PREFERENCE);
+
+    /* XXX: Why is this unsigned char * ? */
+    naptr_curr->flags = (unsigned char *)ares_strdup(
+      ares_dns_rr_get_str(rr, ARES_RR_NAPTR_FLAGS));
+    if (naptr_curr->flags == NULL) {
+      status = ARES_ENOMEM; /* LCOV_EXCL_LINE: OutOfMemory */
+      goto done;            /* LCOV_EXCL_LINE: OutOfMemory */
+    }
+    /* XXX: Why is this unsigned char * ? */
+    naptr_curr->service = (unsigned char *)ares_strdup(
+      ares_dns_rr_get_str(rr, ARES_RR_NAPTR_SERVICES));
+    if (naptr_curr->service == NULL) {
+      status = ARES_ENOMEM; /* LCOV_EXCL_LINE: OutOfMemory */
+      goto done;            /* LCOV_EXCL_LINE: OutOfMemory */
+    }
+    /* XXX: Why is this unsigned char * ? */
+    naptr_curr->regexp = (unsigned char *)ares_strdup(
+      ares_dns_rr_get_str(rr, ARES_RR_NAPTR_REGEXP));
+    if (naptr_curr->regexp == NULL) {
+      status = ARES_ENOMEM; /* LCOV_EXCL_LINE: OutOfMemory */
+      goto done;            /* LCOV_EXCL_LINE: OutOfMemory */
+    }
+    naptr_curr->replacement =
+      ares_strdup(ares_dns_rr_get_str(rr, ARES_RR_NAPTR_REPLACEMENT));
+    if (naptr_curr->replacement == NULL) {
+      status = ARES_ENOMEM; /* LCOV_EXCL_LINE: OutOfMemory */
+      goto done;            /* LCOV_EXCL_LINE: OutOfMemory */
+    }
+  }
+
+done:
+  /* clean up on error */
+  if (status != ARES_SUCCESS) {
+    if (naptr_head) {
+      ares_free_data(naptr_head);
+    }
+  } else {
+    /* everything looks fine, return the data */
+    *naptr_out = naptr_head;
+  }
+  ares_dns_record_destroy(dnsrec);
+  return (int)status;
+}