grpc 1.74.1 → 1.75.0.pre1

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

@@ -0,0 +1,425 @@
+/* MIT License
+ *
+ * Copyright (c) Massachusetts Institute of Technology
+ * Copyright (c) The c-ares project and its contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * SPDX-License-Identifier: MIT
+ */
+#include "ares_private.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
+
+#ifdef HAVE_STRINGS_H
+#  include <strings.h>
+#endif
+#ifdef HAVE_SYS_IOCTL_H
+#  include <sys/ioctl.h>
+#endif
+#ifdef NETWARE
+#  include <sys/filio.h>
+#endif
+
+#include <assert.h>
+#include <fcntl.h>
+#include <limits.h>
+
+static ares_conn_err_t ares_socket_deref_error(int err)
+{
+  switch (err) {
+#if defined(EWOULDBLOCK)
+    case EWOULDBLOCK:
+      return ARES_CONN_ERR_WOULDBLOCK;
+#endif
+#if defined(EAGAIN) && (!defined(EWOULDBLOCK) || EAGAIN != EWOULDBLOCK)
+    case EAGAIN:
+      return ARES_CONN_ERR_WOULDBLOCK;
+#endif
+    case EINPROGRESS:
+      return ARES_CONN_ERR_WOULDBLOCK;
+    case ENETDOWN:
+      return ARES_CONN_ERR_NETDOWN;
+    case ENETUNREACH:
+      return ARES_CONN_ERR_NETUNREACH;
+    case ECONNABORTED:
+      return ARES_CONN_ERR_CONNABORTED;
+    case ECONNRESET:
+      return ARES_CONN_ERR_CONNRESET;
+    case ECONNREFUSED:
+      return ARES_CONN_ERR_CONNREFUSED;
+    case ETIMEDOUT:
+      return ARES_CONN_ERR_CONNTIMEDOUT;
+    case EHOSTDOWN:
+      return ARES_CONN_ERR_HOSTDOWN;
+    case EHOSTUNREACH:
+      return ARES_CONN_ERR_HOSTUNREACH;
+    case EINTR:
+      return ARES_CONN_ERR_INTERRUPT;
+    case EAFNOSUPPORT:
+      return ARES_CONN_ERR_AFNOSUPPORT;
+    case EADDRNOTAVAIL:
+      return ARES_CONN_ERR_BADADDR;
+    default:
+      break;
+  }
+
+  return ARES_CONN_ERR_FAILURE;
+}
+
+ares_bool_t ares_sockaddr_addr_eq(const struct sockaddr  *sa,
+                                  const struct ares_addr *aa)
+{
+  const void *addr1;
+  const void *addr2;
+
+  if (sa->sa_family == aa->family) {
+    switch (aa->family) {
+      case AF_INET:
+        addr1 = &aa->addr.addr4;
+        addr2 = &(CARES_INADDR_CAST(const struct sockaddr_in *, sa))->sin_addr;
+        if (memcmp(addr1, addr2, sizeof(aa->addr.addr4)) == 0) {
+          return ARES_TRUE; /* match */
+        }
+        break;
+      case AF_INET6:
+        addr1 = &aa->addr.addr6;
+        addr2 =
+          &(CARES_INADDR_CAST(const struct sockaddr_in6 *, sa))->sin6_addr;
+        if (memcmp(addr1, addr2, sizeof(aa->addr.addr6)) == 0) {
+          return ARES_TRUE; /* match */
+        }
+        break;
+      default:
+        break; /* LCOV_EXCL_LINE */
+    }
+  }
+  return ARES_FALSE; /* different */
+}
+
+ares_conn_err_t ares_socket_write(ares_channel_t *channel, ares_socket_t fd,
+                                  const void *data, size_t len, size_t *written,
+                                  const struct sockaddr *sa,
+                                  ares_socklen_t         salen)
+{
+  int             flags = 0;
+  ares_ssize_t    rv;
+  ares_conn_err_t err = ARES_CONN_ERR_SUCCESS;
+
+#ifdef HAVE_MSG_NOSIGNAL
+  flags |= MSG_NOSIGNAL;
+#endif
+
+  rv = channel->sock_funcs.asendto(fd, data, len, flags, sa, salen,
+                                   channel->sock_func_cb_data);
+  if (rv <= 0) {
+    err = ares_socket_deref_error(SOCKERRNO);
+  } else {
+    *written = (size_t)rv;
+  }
+  return err;
+}
+
+ares_conn_err_t ares_socket_recv(ares_channel_t *channel, ares_socket_t s,
+                                 ares_bool_t is_tcp, void *data,
+                                 size_t data_len, size_t *read_bytes)
+{
+  ares_ssize_t rv;
+
+  *read_bytes = 0;
+
+  rv = channel->sock_funcs.arecvfrom(s, data, data_len, 0, NULL, 0,
+                                     channel->sock_func_cb_data);
+
+  if (rv > 0) {
+    *read_bytes = (size_t)rv;
+    return ARES_CONN_ERR_SUCCESS;
+  }
+
+  if (rv == 0) {
+    /* UDP allows 0-byte packets and is connectionless, so this is success */
+    if (!is_tcp) {
+      return ARES_CONN_ERR_SUCCESS;
+    } else {
+      return ARES_CONN_ERR_CONNCLOSED;
+    }
+  }
+
+  /* If we're here, rv<0 */
+  return ares_socket_deref_error(SOCKERRNO);
+}
+
+ares_conn_err_t ares_socket_recvfrom(ares_channel_t *channel, ares_socket_t s,
+                                     ares_bool_t is_tcp, void *data,
+                                     size_t data_len, int flags,
+                                     struct sockaddr *from,
+                                     ares_socklen_t  *from_len,
+                                     size_t          *read_bytes)
+{
+  ares_ssize_t rv;
+
+  rv = channel->sock_funcs.arecvfrom(s, data, data_len, flags, from, from_len,
+                                     channel->sock_func_cb_data);
+
+  if (rv > 0) {
+    *read_bytes = (size_t)rv;
+    return ARES_CONN_ERR_SUCCESS;
+  }
+
+  if (rv == 0) {
+    /* UDP allows 0-byte packets and is connectionless, so this is success */
+    if (!is_tcp) {
+      return ARES_CONN_ERR_SUCCESS;
+    } else {
+      return ARES_CONN_ERR_CONNCLOSED;
+    }
+  }
+
+  /* If we're here, rv<0 */
+  return ares_socket_deref_error(SOCKERRNO);
+}
+
+ares_conn_err_t ares_socket_enable_tfo(const ares_channel_t *channel,
+                                       ares_socket_t         fd)
+{
+  ares_bool_t opt = ARES_TRUE;
+
+  if (channel->sock_funcs.asetsockopt(fd, ARES_SOCKET_OPT_TCP_FASTOPEN,
+                                      (void *)&opt, sizeof(opt),
+                                      channel->sock_func_cb_data) != 0) {
+    return ARES_CONN_ERR_NOTIMP;
+  }
+
+  return ARES_CONN_ERR_SUCCESS;
+}
+
+ares_status_t ares_socket_configure(ares_channel_t *channel, int family,
+                                    ares_bool_t is_tcp, ares_socket_t fd)
+{
+  union {
+    struct sockaddr     sa;
+    struct sockaddr_in  sa4;
+    struct sockaddr_in6 sa6;
+  } local;
+
+  ares_socklen_t bindlen = 0;
+  int            rv;
+  unsigned int   bind_flags = 0;
+
+  /* Set the socket's send and receive buffer sizes. */
+  if (channel->socket_send_buffer_size > 0) {
+    rv = channel->sock_funcs.asetsockopt(
+      fd, ARES_SOCKET_OPT_SENDBUF_SIZE,
+      (void *)&channel->socket_send_buffer_size,
+      sizeof(channel->socket_send_buffer_size), channel->sock_func_cb_data);
+    if (rv != 0 && SOCKERRNO != ENOSYS) {
+      return ARES_ECONNREFUSED; /* LCOV_EXCL_LINE: UntestablePath */
+    }
+  }
+
+  if (channel->socket_receive_buffer_size > 0) {
+    rv = channel->sock_funcs.asetsockopt(
+      fd, ARES_SOCKET_OPT_RECVBUF_SIZE,
+      (void *)&channel->socket_receive_buffer_size,
+      sizeof(channel->socket_receive_buffer_size), channel->sock_func_cb_data);
+    if (rv != 0 && SOCKERRNO != ENOSYS) {
+      return ARES_ECONNREFUSED; /* LCOV_EXCL_LINE: UntestablePath */
+    }
+  }
+
+  /* Bind to network interface if configured */
+  if (ares_strlen(channel->local_dev_name)) {
+    /* Prior versions silently ignored failure, so we need to maintain that
+     * compatibility */
+    (void)channel->sock_funcs.asetsockopt(
+      fd, ARES_SOCKET_OPT_BIND_DEVICE, channel->local_dev_name,
+      (ares_socklen_t)ares_strlen(channel->local_dev_name),
+      channel->sock_func_cb_data);
+  }
+
+  /* Bind to ip address if configured */
+  if (family == AF_INET && 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);
+    bindlen                   = sizeof(local.sa4);
+  } else if (family == AF_INET6 &&
+             memcmp(channel->local_ip6, ares_in6addr_any._S6_un._S6_u8,
+                    sizeof(channel->local_ip6)) != 0) {
+    /* Only if not link-local and an ip other than "::" is specified */
+    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));
+    bindlen = sizeof(local.sa6);
+  }
+
+
+  if (bindlen && channel->sock_funcs.abind != NULL) {
+    bind_flags |= ARES_SOCKET_BIND_CLIENT;
+    if (is_tcp) {
+      bind_flags |= ARES_SOCKET_BIND_TCP;
+    }
+    if (channel->sock_funcs.abind(fd, bind_flags, &local.sa, bindlen,
+                                  channel->sock_func_cb_data) != 0) {
+      return ARES_ECONNREFUSED;
+    }
+  }
+
+  return ARES_SUCCESS;
+}
+
+ares_bool_t ares_sockaddr_to_ares_addr(struct ares_addr      *ares_addr,
+                                       unsigned short        *port,
+                                       const struct sockaddr *sockaddr)
+{
+  if (sockaddr->sa_family == AF_INET) {
+    /* NOTE: memcpy sockaddr_in due to alignment issues found by UBSAN due to
+     *       dnsinfo packing on MacOS */
+    struct sockaddr_in sockaddr_in;
+    memcpy(&sockaddr_in, sockaddr, sizeof(sockaddr_in));
+
+    ares_addr->family = AF_INET;
+    memcpy(&ares_addr->addr.addr4, &(sockaddr_in.sin_addr),
+           sizeof(ares_addr->addr.addr4));
+
+    if (port) {
+      *port = ntohs(sockaddr_in.sin_port);
+    }
+    return ARES_TRUE;
+  }
+
+  if (sockaddr->sa_family == AF_INET6) {
+    /* NOTE: memcpy sockaddr_in6 due to alignment issues found by UBSAN due to
+     *       dnsinfo packing on MacOS */
+    struct sockaddr_in6 sockaddr_in6;
+    memcpy(&sockaddr_in6, sockaddr, sizeof(sockaddr_in6));
+
+    ares_addr->family = AF_INET6;
+    memcpy(&ares_addr->addr.addr6, &(sockaddr_in6.sin6_addr),
+           sizeof(ares_addr->addr.addr6));
+    if (port) {
+      *port = ntohs(sockaddr_in6.sin6_port);
+    }
+    return ARES_TRUE;
+  }
+
+  return ARES_FALSE;
+}
+
+ares_conn_err_t ares_socket_open(ares_socket_t *sock, ares_channel_t *channel,
+                                 int af, int type, int protocol)
+{
+  ares_socket_t s;
+
+  *sock = ARES_SOCKET_BAD;
+
+  s =
+    channel->sock_funcs.asocket(af, type, protocol, channel->sock_func_cb_data);
+
+  if (s == ARES_SOCKET_BAD) {
+    return ares_socket_deref_error(SOCKERRNO);
+  }
+
+  *sock = s;
+
+  return ARES_CONN_ERR_SUCCESS;
+}
+
+ares_conn_err_t ares_socket_connect(ares_channel_t *channel,
+                                    ares_socket_t sockfd, ares_bool_t is_tfo,
+                                    const struct sockaddr *addr,
+                                    ares_socklen_t         addrlen)
+{
+  ares_conn_err_t err   = ARES_CONN_ERR_SUCCESS;
+  unsigned int    flags = 0;
+
+  if (is_tfo) {
+    flags |= ARES_SOCKET_CONN_TCP_FASTOPEN;
+  }
+
+  do {
+    int rv;
+
+    rv = channel->sock_funcs.aconnect(sockfd, addr, addrlen, flags,
+                                      channel->sock_func_cb_data);
+
+    if (rv < 0) {
+      err = ares_socket_deref_error(SOCKERRNO);
+    } else {
+      err = ARES_CONN_ERR_SUCCESS;
+    }
+  } while (err == ARES_CONN_ERR_INTERRUPT);
+
+  return err;
+}
+
+void ares_socket_close(ares_channel_t *channel, ares_socket_t s)
+{
+  if (channel == NULL || s == ARES_SOCKET_BAD) {
+    return;
+  }
+
+  channel->sock_funcs.aclose(s, channel->sock_func_cb_data);
+}
+
+void ares_set_socket_callback(ares_channel_t           *channel,
+                              ares_sock_create_callback cb, void *data)
+{
+  if (channel == NULL) {
+    return;
+  }
+  channel->sock_create_cb      = cb;
+  channel->sock_create_cb_data = data;
+}
+
+void ares_set_socket_configure_callback(ares_channel_t           *channel,
+                                        ares_sock_config_callback cb,
+                                        void                     *data)
+{
+  if (channel == NULL || channel->optmask & ARES_OPT_EVENT_THREAD) {
+    return;
+  }
+  channel->sock_config_cb      = cb;
+  channel->sock_config_cb_data = data;
+}
+
+void ares_set_pending_write_cb(ares_channel_t       *channel,
+                               ares_pending_write_cb callback, void *user_data)
+{
+  if (channel == NULL || channel->optmask & ARES_OPT_EVENT_THREAD) {
+    return;
+  }
+  channel->notify_pending_write_cb      = callback;
+  channel->notify_pending_write_cb_data = user_data;
+}

data/third_party/cares/cares/src/lib/ares_socket.h

@@ -0,0 +1,163 @@
+/* MIT License
+ *
+ * Copyright (c) 2024 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
+ */
+
+#ifndef __ARES_SOCKET_H
+#define __ARES_SOCKET_H
+
+/* Macro SOCKERRNO / SET_SOCKERRNO() returns / sets the *socket-related* errno
+ * (or equivalent) on this platform to hide platform details to code using it.
+ */
+#ifdef USE_WINSOCK
+#  define SOCKERRNO        ((int)WSAGetLastError())
+#  define SET_SOCKERRNO(x) (WSASetLastError((int)(x)))
+#else
+#  define SOCKERRNO        (errno)
+#  define SET_SOCKERRNO(x) (errno = (x))
+#endif
+
+/* Portable error number symbolic names defined to Winsock error codes. */
+#ifdef USE_WINSOCK
+#  undef EBADF           /* override definition in errno.h */
+#  define EBADF WSAEBADF
+#  undef EINTR           /* override definition in errno.h */
+#  define EINTR WSAEINTR
+#  undef EINVAL          /* override definition in errno.h */
+#  define EINVAL WSAEINVAL
+#  undef EWOULDBLOCK     /* override definition in errno.h */
+#  define EWOULDBLOCK WSAEWOULDBLOCK
+#  undef EINPROGRESS     /* override definition in errno.h */
+#  define EINPROGRESS WSAEINPROGRESS
+#  undef EALREADY        /* override definition in errno.h */
+#  define EALREADY WSAEALREADY
+#  undef ENOTSOCK        /* override definition in errno.h */
+#  define ENOTSOCK WSAENOTSOCK
+#  undef EDESTADDRREQ    /* override definition in errno.h */
+#  define EDESTADDRREQ WSAEDESTADDRREQ
+#  undef EMSGSIZE        /* override definition in errno.h */
+#  define EMSGSIZE WSAEMSGSIZE
+#  undef EPROTOTYPE      /* override definition in errno.h */
+#  define EPROTOTYPE WSAEPROTOTYPE
+#  undef ENOPROTOOPT     /* override definition in errno.h */
+#  define ENOPROTOOPT WSAENOPROTOOPT
+#  undef EPROTONOSUPPORT /* override definition in errno.h */
+#  define EPROTONOSUPPORT WSAEPROTONOSUPPORT
+#  define ESOCKTNOSUPPORT WSAESOCKTNOSUPPORT
+#  undef EOPNOTSUPP /* override definition in errno.h */
+#  define EOPNOTSUPP WSAEOPNOTSUPP
+#  undef ENOSYS     /* override definition in errno.h */
+#  define ENOSYS       WSAEOPNOTSUPP
+#  define EPFNOSUPPORT WSAEPFNOSUPPORT
+#  undef EAFNOSUPPORT  /* override definition in errno.h */
+#  define EAFNOSUPPORT WSAEAFNOSUPPORT
+#  undef EADDRINUSE    /* override definition in errno.h */
+#  define EADDRINUSE WSAEADDRINUSE
+#  undef EADDRNOTAVAIL /* override definition in errno.h */
+#  define EADDRNOTAVAIL WSAEADDRNOTAVAIL
+#  undef ENETDOWN      /* override definition in errno.h */
+#  define ENETDOWN WSAENETDOWN
+#  undef ENETUNREACH   /* override definition in errno.h */
+#  define ENETUNREACH WSAENETUNREACH
+#  undef ENETRESET     /* override definition in errno.h */
+#  define ENETRESET WSAENETRESET
+#  undef ECONNABORTED  /* override definition in errno.h */
+#  define ECONNABORTED WSAECONNABORTED
+#  undef ECONNRESET    /* override definition in errno.h */
+#  define ECONNRESET WSAECONNRESET
+#  undef ENOBUFS       /* override definition in errno.h */
+#  define ENOBUFS WSAENOBUFS
+#  undef EISCONN       /* override definition in errno.h */
+#  define EISCONN WSAEISCONN
+#  undef ENOTCONN      /* override definition in errno.h */
+#  define ENOTCONN     WSAENOTCONN
+#  define ESHUTDOWN    WSAESHUTDOWN
+#  define ETOOMANYREFS WSAETOOMANYREFS
+#  undef ETIMEDOUT     /* override definition in errno.h */
+#  define ETIMEDOUT WSAETIMEDOUT
+#  undef ECONNREFUSED  /* override definition in errno.h */
+#  define ECONNREFUSED WSAECONNREFUSED
+#  undef ELOOP         /* override definition in errno.h */
+#  define ELOOP WSAELOOP
+#  ifndef ENAMETOOLONG /* possible previous definition in errno.h */
+#    define ENAMETOOLONG WSAENAMETOOLONG
+#  endif
+#  define EHOSTDOWN WSAEHOSTDOWN
+#  undef EHOSTUNREACH /* override definition in errno.h */
+#  define EHOSTUNREACH WSAEHOSTUNREACH
+#  ifndef ENOTEMPTY   /* possible previous definition in errno.h */
+#    define ENOTEMPTY WSAENOTEMPTY
+#  endif
+#  define EPROCLIM WSAEPROCLIM
+#  define EUSERS   WSAEUSERS
+#  define EDQUOT   WSAEDQUOT
+#  define ESTALE   WSAESTALE
+#  define EREMOTE  WSAEREMOTE
+#endif
+
+/*! Socket errors */
+typedef enum {
+  ARES_CONN_ERR_SUCCESS      = 0,  /*!< Success */
+  ARES_CONN_ERR_WOULDBLOCK   = 1,  /*!< Operation would block */
+  ARES_CONN_ERR_CONNCLOSED   = 2,  /*!< Connection closed (gracefully) */
+  ARES_CONN_ERR_CONNABORTED  = 3,  /*!< Connection Aborted */
+  ARES_CONN_ERR_CONNRESET    = 4,  /*!< Connection Reset */
+  ARES_CONN_ERR_CONNREFUSED  = 5,  /*!< Connection Refused */
+  ARES_CONN_ERR_CONNTIMEDOUT = 6,  /*!< Connection Timed Out */
+  ARES_CONN_ERR_HOSTDOWN     = 7,  /*!< Host Down */
+  ARES_CONN_ERR_HOSTUNREACH  = 8,  /*!< Host Unreachable */
+  ARES_CONN_ERR_NETDOWN      = 9,  /*!< Network Down */
+  ARES_CONN_ERR_NETUNREACH   = 10, /*!< Network Unreachable */
+  ARES_CONN_ERR_INTERRUPT    = 11, /*!< Call interrupted by signal, repeat */
+  ARES_CONN_ERR_AFNOSUPPORT  = 12, /*!< Address family not supported */
+  ARES_CONN_ERR_BADADDR      = 13, /*!< Bad Address / Unavailable */
+  ARES_CONN_ERR_NOMEM        = 14, /*!< Out of memory */
+  ARES_CONN_ERR_INVALID      = 15, /*!< Invalid Usage */
+  ARES_CONN_ERR_TOOLARGE     = 16, /*!< Request size too large */
+  ARES_CONN_ERR_NOTIMP       = 17, /*!< Not implemented */
+  ARES_CONN_ERR_FAILURE      = 99  /*!< Generic failure */
+} ares_conn_err_t;
+
+ares_bool_t     ares_sockaddr_addr_eq(const struct sockaddr  *sa,
+                                      const struct ares_addr *aa);
+ares_status_t   ares_socket_configure(ares_channel_t *channel, int family,
+                                      ares_bool_t is_tcp, ares_socket_t fd);
+ares_conn_err_t ares_socket_enable_tfo(const ares_channel_t *channel,
+                                       ares_socket_t         fd);
+ares_conn_err_t ares_socket_open(ares_socket_t *sock, ares_channel_t *channel,
+                                 int af, int type, int protocol);
+ares_bool_t     ares_socket_try_again(int errnum);
+void            ares_socket_close(ares_channel_t *channel, ares_socket_t s);
+ares_conn_err_t ares_socket_connect(ares_channel_t *channel,
+                                    ares_socket_t sockfd, ares_bool_t is_tfo,
+                                    const struct sockaddr *addr,
+                                    ares_socklen_t         addrlen);
+ares_bool_t     ares_sockaddr_to_ares_addr(struct ares_addr      *ares_addr,
+                                           unsigned short        *port,
+                                           const struct sockaddr *sockaddr);
+ares_conn_err_t ares_socket_write(ares_channel_t *channel, ares_socket_t fd,
+                                  const void *data, size_t len, size_t *written,
+                                  const struct sockaddr *sa,
+                                  ares_socklen_t         salen);
+#endif