couchbase 3.3.0 → 3.4.0

data/ext/couchbase/third_party/asio/asio/include/asio/detail/impl/socket_ops.ipp

@@ -2,7 +2,7 @@
 // detail/impl/socket_ops.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -78,7 +78,7 @@ inline void get_last_error(
 {
   if (!is_error_condition)
   {
-    ec.assign(0, ec.category());
+    asio::error::clear(ec);
   }
   else
   {
@@ -94,16 +94,18 @@ inline void get_last_error(
 
 template <typename SockLenType>
 inline socket_type call_accept(SockLenType msghdr::*,
-    socket_type s, socket_addr_type* addr, std::size_t* addrlen)
+    socket_type s, void* addr, std::size_t* addrlen)
 {
   SockLenType tmp_addrlen = addrlen ? (SockLenType)*addrlen : 0;
-  socket_type result = ::accept(s, addr, addrlen ? &tmp_addrlen : 0);
+  socket_type result = ::accept(s,
+      static_cast<socket_addr_type*>(addr),
+      addrlen ? &tmp_addrlen : 0);
   if (addrlen)
     *addrlen = (std::size_t)tmp_addrlen;
   return result;
 }
 
-socket_type accept(socket_type s, socket_addr_type* addr,
+socket_type accept(socket_type s, void* addr,
     std::size_t* addrlen, asio::error_code& ec)
 {
   if (s == invalid_socket)
@@ -129,12 +131,12 @@ socket_type accept(socket_type s, socket_addr_type* addr,
   }
 #endif
 
-  ec.assign(0, ec.category());
+  asio::error::clear(ec);
   return new_s;
 }
 
 socket_type sync_accept(socket_type s, state_type state,
-    socket_addr_type* addr, std::size_t* addrlen, asio::error_code& ec)
+    void* addr, std::size_t* addrlen, asio::error_code& ec)
 {
   // Accept a socket.
   for (;;)
@@ -179,9 +181,8 @@ socket_type sync_accept(socket_type s, state_type state,
 
 #if defined(ASIO_HAS_IOCP)
 
-void complete_iocp_accept(socket_type s,
-    void* output_buffer, DWORD address_length,
-    socket_addr_type* addr, std::size_t* addrlen,
+void complete_iocp_accept(socket_type s, void* output_buffer,
+    DWORD address_length, void* addr, std::size_t* addrlen,
     socket_type new_socket, asio::error_code& ec)
 {
   // Map non-portable errors to their portable counterparts.
@@ -225,7 +226,7 @@ void complete_iocp_accept(socket_type s,
 #else // defined(ASIO_HAS_IOCP)
 
 bool non_blocking_accept(socket_type s,
-    state_type state, socket_addr_type* addr, std::size_t* addrlen,
+    state_type state, void* addr, std::size_t* addrlen,
     asio::error_code& ec, socket_type& new_socket)
 {
   for (;;)
@@ -272,12 +273,13 @@ bool non_blocking_accept(socket_type s,
 
 template <typename SockLenType>
 inline int call_bind(SockLenType msghdr::*,
-    socket_type s, const socket_addr_type* addr, std::size_t addrlen)
+    socket_type s, const void* addr, std::size_t addrlen)
 {
-  return ::bind(s, addr, (SockLenType)addrlen);
+  return ::bind(s, static_cast<const socket_addr_type*>(addr),
+      (SockLenType)addrlen);
 }
 
-int bind(socket_type s, const socket_addr_type* addr,
+int bind(socket_type s, const void* addr,
     std::size_t addrlen, asio::error_code& ec)
 {
   if (s == invalid_socket)
@@ -463,12 +465,13 @@ int shutdown(socket_type s, int what, asio::error_code& ec)
 
 template <typename SockLenType>
 inline int call_connect(SockLenType msghdr::*,
-    socket_type s, const socket_addr_type* addr, std::size_t addrlen)
+    socket_type s, const void* addr, std::size_t addrlen)
 {
-  return ::connect(s, addr, (SockLenType)addrlen);
+  return ::connect(s, static_cast<const socket_addr_type*>(addr),
+      (SockLenType)addrlen);
 }
 
-int connect(socket_type s, const socket_addr_type* addr,
+int connect(socket_type s, const void* addr,
     std::size_t addrlen, asio::error_code& ec)
 {
   if (s == invalid_socket)
@@ -481,12 +484,17 @@ int connect(socket_type s, const socket_addr_type* addr,
   get_last_error(ec, result != 0);
 #if defined(__linux__)
   if (result != 0 && ec == asio::error::try_again)
-    ec = asio::error::no_buffer_space;
+  {
+    if (static_cast<const socket_addr_type*>(addr)->sa_family == AF_UNIX)
+      ec = asio::error::in_progress;
+    else
+      ec = asio::error::no_buffer_space;
+  }
 #endif // defined(__linux__)
   return result;
 }
 
-void sync_connect(socket_type s, const socket_addr_type* addr,
+void sync_connect(socket_type s, const void* addr,
     std::size_t addrlen, asio::error_code& ec)
 {
   // Perform the connect operation.
@@ -596,7 +604,7 @@ bool non_blocking_connect(socket_type s, asio::error_code& ec)
           asio::error::get_system_category());
     }
     else
-      ec.assign(0, ec.category());
+      asio::error::clear(ec);
   }
 
   return true;
@@ -641,7 +649,7 @@ bool sockatmark(socket_type s, asio::error_code& ec)
 # endif // defined(ENOTTY)
 #else // defined(SIOCATMARK)
   int value = ::sockatmark(s);
-  get_last_error(ec, result < 0);
+  get_last_error(ec, value < 0);
 #endif // defined(SIOCATMARK)
 
   return ec ? false : value != 0;
@@ -722,9 +730,9 @@ void init_buf(buf& b, const void* data, size_t size)
 #endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
 }
 
-inline void init_msghdr_msg_name(void*& name, socket_addr_type* addr)
+inline void init_msghdr_msg_name(void*& name, void* addr)
 {
-  name = addr;
+  name = static_cast<socket_addr_type*>(addr);
 }
 
 inline void init_msghdr_msg_name(void*& name, const socket_addr_type* addr)
@@ -733,15 +741,15 @@ inline void init_msghdr_msg_name(void*& name, const socket_addr_type* addr)
 }
 
 template <typename T>
-inline void init_msghdr_msg_name(T& name, socket_addr_type* addr)
+inline void init_msghdr_msg_name(T& name, void* addr)
 {
-  name = reinterpret_cast<T>(addr);
+  name = static_cast<T>(addr);
 }
 
 template <typename T>
-inline void init_msghdr_msg_name(T& name, const socket_addr_type* addr)
+inline void init_msghdr_msg_name(T& name, const void* addr)
 {
-  name = reinterpret_cast<T>(const_cast<socket_addr_type*>(addr));
+  name = static_cast<T>(const_cast<void*>(addr));
 }
 
 signed_size_type recv(socket_type s, buf* bufs, size_t count,
@@ -763,7 +771,7 @@ signed_size_type recv(socket_type s, buf* bufs, size_t count,
     result = 0;
   if (result != 0)
     return socket_error_retval;
-  ec.assign(0, ec.category());
+  asio::error::clear(ec);
   return bytes_transferred;
 #else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
   msghdr msg = msghdr();
@@ -796,7 +804,7 @@ signed_size_type recv1(socket_type s, void* data, size_t size,
     result = 0;
   if (result != 0)
     return socket_error_retval;
-  ec.assign(0, ec.category());
+  asio::error::clear(ec);
   return bytes_transferred;
 #else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
   signed_size_type result = ::recv(s, static_cast<char*>(data), size, flags);
@@ -817,7 +825,7 @@ size_t sync_recv(socket_type s, state_type state, buf* bufs,
   // A request to read 0 bytes on a stream is a no-op.
   if (all_empty && (state & stream_oriented))
   {
-    ec.assign(0, ec.category());
+    asio::error::clear(ec);
     return 0;
   }
 
@@ -862,7 +870,7 @@ size_t sync_recv1(socket_type s, state_type state, void* data,
   // A request to read 0 bytes on a stream is a no-op.
   if (size == 0 && (state & stream_oriented))
   {
-    ec.assign(0, ec.category());
+    asio::error::clear(ec);
     return 0;
   }
 
@@ -915,7 +923,7 @@ void complete_iocp_recv(state_type state,
   }
   else if (ec.value() == WSAEMSGSIZE || ec.value() == ERROR_MORE_DATA)
   {
-    ec.assign(0, ec.category());
+    asio::error::clear(ec);
   }
 
   // Check for connection closed.
@@ -1008,8 +1016,7 @@ bool non_blocking_recv1(socket_type s,
 #endif // defined(ASIO_HAS_IOCP)
 
 signed_size_type recvfrom(socket_type s, buf* bufs, size_t count,
-    int flags, socket_addr_type* addr, std::size_t* addrlen,
-    asio::error_code& ec)
+    int flags, void* addr, std::size_t* addrlen, asio::error_code& ec)
 {
 #if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
   // Receive some data.
@@ -1017,8 +1024,8 @@ signed_size_type recvfrom(socket_type s, buf* bufs, size_t count,
   DWORD bytes_transferred = 0;
   DWORD recv_flags = flags;
   int tmp_addrlen = (int)*addrlen;
-  int result = ::WSARecvFrom(s, bufs, recv_buf_count,
-        &bytes_transferred, &recv_flags, addr, &tmp_addrlen, 0, 0);
+  int result = ::WSARecvFrom(s, bufs, recv_buf_count, &bytes_transferred,
+      &recv_flags, static_cast<socket_addr_type*>(addr), &tmp_addrlen, 0, 0);
   get_last_error(ec, true);
   *addrlen = (std::size_t)tmp_addrlen;
   if (ec.value() == ERROR_NETNAME_DELETED)
@@ -1029,7 +1036,7 @@ signed_size_type recvfrom(socket_type s, buf* bufs, size_t count,
     result = 0;
   if (result != 0)
     return socket_error_retval;
-  ec.assign(0, ec.category());
+  asio::error::clear(ec);
   return bytes_transferred;
 #else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
   msghdr msg = msghdr();
@@ -1045,21 +1052,19 @@ signed_size_type recvfrom(socket_type s, buf* bufs, size_t count,
 }
 
 template <typename SockLenType>
-inline signed_size_type call_recvfrom(SockLenType msghdr::*,
-    socket_type s, void* data, size_t size, int flags,
-    socket_addr_type* addr, std::size_t* addrlen)
+inline signed_size_type call_recvfrom(SockLenType msghdr::*, socket_type s,
+    void* data, size_t size, int flags, void* addr, std::size_t* addrlen)
 {
   SockLenType tmp_addrlen = addrlen ? (SockLenType)*addrlen : 0;
-  signed_size_type result = ::recvfrom(s, static_cast<char*>(data),
-      size, flags, addr, addrlen ? &tmp_addrlen : 0);
+  signed_size_type result = ::recvfrom(s, static_cast<char*>(data), size,
+      flags, static_cast<socket_addr_type*>(addr), addrlen ? &tmp_addrlen : 0);
   if (addrlen)
     *addrlen = (std::size_t)tmp_addrlen;
   return result;
 }
 
 signed_size_type recvfrom1(socket_type s, void* data, size_t size,
-    int flags, socket_addr_type* addr, std::size_t* addrlen,
-    asio::error_code& ec)
+    int flags, void* addr, std::size_t* addrlen, asio::error_code& ec)
 {
 #if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
   // Receive some data.
@@ -1069,8 +1074,8 @@ signed_size_type recvfrom1(socket_type s, void* data, size_t size,
   DWORD bytes_transferred = 0;
   DWORD recv_flags = flags;
   int tmp_addrlen = (int)*addrlen;
-  int result = ::WSARecvFrom(s, &buf, 1, &bytes_transferred,
-      &recv_flags, addr, &tmp_addrlen, 0, 0);
+  int result = ::WSARecvFrom(s, &buf, 1, &bytes_transferred, &recv_flags,
+      static_cast<socket_addr_type*>(addr), &tmp_addrlen, 0, 0);
   get_last_error(ec, true);
   *addrlen = (std::size_t)tmp_addrlen;
   if (ec.value() == ERROR_NETNAME_DELETED)
@@ -1081,7 +1086,7 @@ signed_size_type recvfrom1(socket_type s, void* data, size_t size,
     result = 0;
   if (result != 0)
     return socket_error_retval;
-  ec.assign(0, ec.category());
+  asio::error::clear(ec);
   return bytes_transferred;
 #else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
   signed_size_type result = call_recvfrom(&msghdr::msg_namelen,
@@ -1091,9 +1096,8 @@ signed_size_type recvfrom1(socket_type s, void* data, size_t size,
 #endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
 }
 
-size_t sync_recvfrom(socket_type s, state_type state, buf* bufs,
-    size_t count, int flags, socket_addr_type* addr,
-    std::size_t* addrlen, asio::error_code& ec)
+size_t sync_recvfrom(socket_type s, state_type state, buf* bufs, size_t count,
+    int flags, void* addr, std::size_t* addrlen, asio::error_code& ec)
 {
   if (s == invalid_socket)
   {
@@ -1124,9 +1128,8 @@ size_t sync_recvfrom(socket_type s, state_type state, buf* bufs,
   }
 }
 
-size_t sync_recvfrom1(socket_type s, state_type state, void* data,
-    size_t size, int flags, socket_addr_type* addr,
-    std::size_t* addrlen, asio::error_code& ec)
+size_t sync_recvfrom1(socket_type s, state_type state, void* data, size_t size,
+    int flags, void* addr, std::size_t* addrlen, asio::error_code& ec)
 {
   if (s == invalid_socket)
   {
@@ -1177,15 +1180,14 @@ void complete_iocp_recvfrom(
   }
   else if (ec.value() == WSAEMSGSIZE || ec.value() == ERROR_MORE_DATA)
   {
-    ec.assign(0, ec.category());
+    asio::error::clear(ec);
   }
 }
 
 #else // defined(ASIO_HAS_IOCP)
 
-bool non_blocking_recvfrom(socket_type s,
-    buf* bufs, size_t count, int flags,
-    socket_addr_type* addr, std::size_t* addrlen,
+bool non_blocking_recvfrom(socket_type s, buf* bufs,
+    size_t count, int flags, void* addr, std::size_t* addrlen,
     asio::error_code& ec, size_t& bytes_transferred)
 {
   for (;;)
@@ -1216,9 +1218,8 @@ bool non_blocking_recvfrom(socket_type s,
   }
 }
 
-bool non_blocking_recvfrom1(socket_type s,
-    void* data, size_t size, int flags,
-    socket_addr_type* addr, std::size_t* addrlen,
+bool non_blocking_recvfrom1(socket_type s, void* data,
+    size_t size, int flags, void* addr, std::size_t* addrlen,
     asio::error_code& ec, size_t& bytes_transferred)
 {
   for (;;)
@@ -1324,7 +1325,7 @@ void complete_iocp_recvmsg(
   }
   else if (ec.value() == WSAEMSGSIZE || ec.value() == ERROR_MORE_DATA)
   {
-    ec.assign(0, ec.category());
+    asio::error::clear(ec);
   }
 }
 
@@ -1381,7 +1382,7 @@ signed_size_type send(socket_type s, const buf* bufs, size_t count,
     ec = asio::error::connection_refused;
   if (result != 0)
     return socket_error_retval;
-  ec.assign(0, ec.category());
+  asio::error::clear(ec);
   return bytes_transferred;
 #else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
   msghdr msg = msghdr();
@@ -1415,7 +1416,7 @@ signed_size_type send1(socket_type s, const void* data, size_t size,
     ec = asio::error::connection_refused;
   if (result != 0)
     return socket_error_retval;
-  ec.assign(0, ec.category());
+  asio::error::clear(ec);
   return bytes_transferred;
 #else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
 #if defined(ASIO_HAS_MSG_NOSIGNAL)
@@ -1440,7 +1441,7 @@ size_t sync_send(socket_type s, state_type state, const buf* bufs,
   // A request to write 0 bytes to a stream is a no-op.
   if (all_empty && (state & stream_oriented))
   {
-    ec.assign(0, ec.category());
+    asio::error::clear(ec);
     return 0;
   }
 
@@ -1478,7 +1479,7 @@ size_t sync_send1(socket_type s, state_type state, const void* data,
   // A request to write 0 bytes to a stream is a no-op.
   if (size == 0 && (state & stream_oriented))
   {
-    ec.assign(0, ec.category());
+    asio::error::clear(ec);
     return 0;
   }
 
@@ -1590,16 +1591,17 @@ bool non_blocking_send1(socket_type s,
 
 #endif // defined(ASIO_HAS_IOCP)
 
-signed_size_type sendto(socket_type s, const buf* bufs, size_t count,
-    int flags, const socket_addr_type* addr, std::size_t addrlen,
-    asio::error_code& ec)
+signed_size_type sendto(socket_type s, const buf* bufs,
+    size_t count, int flags, const void* addr,
+    std::size_t addrlen, asio::error_code& ec)
 {
 #if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
   // Send the data.
   DWORD send_buf_count = static_cast<DWORD>(count);
   DWORD bytes_transferred = 0;
   int result = ::WSASendTo(s, const_cast<buf*>(bufs),
-        send_buf_count, &bytes_transferred, flags, addr,
+        send_buf_count, &bytes_transferred, flags,
+        static_cast<const socket_addr_type*>(addr),
         static_cast<int>(addrlen), 0, 0);
   get_last_error(ec, true);
   if (ec.value() == ERROR_NETNAME_DELETED)
@@ -1608,7 +1610,7 @@ signed_size_type sendto(socket_type s, const buf* bufs, size_t count,
     ec = asio::error::connection_refused;
   if (result != 0)
     return socket_error_retval;
-  ec.assign(0, ec.category());
+  asio::error::clear(ec);
   return bytes_transferred;
 #else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
   msghdr msg = msghdr();
@@ -1628,15 +1630,15 @@ signed_size_type sendto(socket_type s, const buf* bufs, size_t count,
 template <typename SockLenType>
 inline signed_size_type call_sendto(SockLenType msghdr::*,
     socket_type s, const void* data, size_t size, int flags,
-    const socket_addr_type* addr, std::size_t addrlen)
+    const void* addr, std::size_t addrlen)
 {
-  return ::sendto(s, static_cast<char*>(const_cast<void*>(data)),
-      size, flags, addr, (SockLenType)addrlen);
+  return ::sendto(s, static_cast<char*>(const_cast<void*>(data)), size, flags,
+      static_cast<const socket_addr_type*>(addr), (SockLenType)addrlen);
 }
 
-signed_size_type sendto1(socket_type s, const void* data, size_t size,
-    int flags, const socket_addr_type* addr, std::size_t addrlen,
-    asio::error_code& ec)
+signed_size_type sendto1(socket_type s, const void* data,
+    size_t size, int flags, const void* addr,
+    std::size_t addrlen, asio::error_code& ec)
 {
 #if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
   // Send the data.
@@ -1644,8 +1646,9 @@ signed_size_type sendto1(socket_type s, const void* data, size_t size,
   buf.buf = const_cast<char*>(static_cast<const char*>(data));
   buf.len = static_cast<ULONG>(size);
   DWORD bytes_transferred = 0;
-  int result = ::WSASendTo(s, &buf, 1, &bytes_transferred,
-      flags, addr, static_cast<int>(addrlen), 0, 0);
+  int result = ::WSASendTo(s, &buf, 1, &bytes_transferred, flags,
+      static_cast<const socket_addr_type*>(addr),
+      static_cast<int>(addrlen), 0, 0);
   get_last_error(ec, true);
   if (ec.value() == ERROR_NETNAME_DELETED)
     ec = asio::error::connection_reset;
@@ -1653,7 +1656,7 @@ signed_size_type sendto1(socket_type s, const void* data, size_t size,
     ec = asio::error::connection_refused;
   if (result != 0)
     return socket_error_retval;
-  ec.assign(0, ec.category());
+  asio::error::clear(ec);
   return bytes_transferred;
 #else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
 #if defined(ASIO_HAS_MSG_NOSIGNAL)
@@ -1666,8 +1669,8 @@ signed_size_type sendto1(socket_type s, const void* data, size_t size,
 #endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
 }
 
-size_t sync_sendto(socket_type s, state_type state, const buf* bufs,
-    size_t count, int flags, const socket_addr_type* addr,
+size_t sync_sendto(socket_type s, state_type state,
+    const buf* bufs, size_t count, int flags, const void* addr,
     std::size_t addrlen, asio::error_code& ec)
 {
   if (s == invalid_socket)
@@ -1699,8 +1702,8 @@ size_t sync_sendto(socket_type s, state_type state, const buf* bufs,
   }
 }
 
-size_t sync_sendto1(socket_type s, state_type state, const void* data,
-    size_t size, int flags, const socket_addr_type* addr,
+size_t sync_sendto1(socket_type s, state_type state,
+    const void* data, size_t size, int flags, const void* addr,
     std::size_t addrlen, asio::error_code& ec)
 {
   if (s == invalid_socket)
@@ -1736,7 +1739,7 @@ size_t sync_sendto1(socket_type s, state_type state, const void* data,
 
 bool non_blocking_sendto(socket_type s,
     const buf* bufs, size_t count, int flags,
-    const socket_addr_type* addr, std::size_t addrlen,
+    const void* addr, std::size_t addrlen,
     asio::error_code& ec, size_t& bytes_transferred)
 {
   for (;;)
@@ -1769,7 +1772,7 @@ bool non_blocking_sendto(socket_type s,
 
 bool non_blocking_sendto1(socket_type s,
     const void* data, size_t size, int flags,
-    const socket_addr_type* addr, std::size_t addrlen,
+    const void* addr, std::size_t addrlen,
     asio::error_code& ec, size_t& bytes_transferred)
 {
   for (;;)
@@ -1883,7 +1886,7 @@ int setsockopt(socket_type s, state_type& state, int level, int optname,
       state |= enable_connection_aborted;
     else
       state &= ~enable_connection_aborted;
-    ec.assign(0, ec.category());
+    asio::error::clear(ec);
     return 0;
   }
 
@@ -1968,7 +1971,7 @@ int getsockopt(socket_type s, state_type state, int level, int optname,
     }
 
     *static_cast<int*>(optval) = (state & enable_connection_aborted) ? 1 : 0;
-    ec.assign(0, ec.category());
+    asio::error::clear(ec);
     return 0;
   }
 
@@ -1995,7 +1998,7 @@ int getsockopt(socket_type s, state_type state, int level, int optname,
         // value is non-zero (i.e. true). This corresponds to the behavior of
         // IPv6 sockets on Windows platforms pre-Vista.
         *static_cast<DWORD*>(optval) = 1;
-        ec.assign(0, ec.category());
+        asio::error::clear(ec);
       }
       return result;
     }
@@ -2015,7 +2018,7 @@ int getsockopt(socket_type s, state_type state, int level, int optname,
     // non-zero (i.e. true). This corresponds to the behavior of IPv6 sockets
     // on Windows platforms pre-Vista.
     *static_cast<DWORD*>(optval) = 1;
-    ec.assign(0, ec.category());
+    asio::error::clear(ec);
   }
   return result;
 #else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
@@ -2040,16 +2043,17 @@ int getsockopt(socket_type s, state_type state, int level, int optname,
 
 template <typename SockLenType>
 inline int call_getpeername(SockLenType msghdr::*,
-    socket_type s, socket_addr_type* addr, std::size_t* addrlen)
+    socket_type s, void* addr, std::size_t* addrlen)
 {
   SockLenType tmp_addrlen = (SockLenType)*addrlen;
-  int result = ::getpeername(s, addr, &tmp_addrlen);
+  int result = ::getpeername(s,
+      static_cast<socket_addr_type*>(addr), &tmp_addrlen);
   *addrlen = (std::size_t)tmp_addrlen;
   return result;
 }
 
-int getpeername(socket_type s, socket_addr_type* addr,
-    std::size_t* addrlen, bool cached, asio::error_code& ec)
+int getpeername(socket_type s, void* addr, std::size_t* addrlen,
+    bool cached, asio::error_code& ec)
 {
   if (s == invalid_socket)
   {
@@ -2076,7 +2080,7 @@ int getpeername(socket_type s, socket_addr_type* addr,
     }
 
     // The cached value is still valid.
-    ec.assign(0, ec.category());
+    asio::error::clear(ec);
     return 0;
   }
 #else // defined(ASIO_WINDOWS) && !defined(ASIO_WINDOWS_APP)
@@ -2092,15 +2096,16 @@ int getpeername(socket_type s, socket_addr_type* addr,
 
 template <typename SockLenType>
 inline int call_getsockname(SockLenType msghdr::*,
-    socket_type s, socket_addr_type* addr, std::size_t* addrlen)
+    socket_type s, void* addr, std::size_t* addrlen)
 {
   SockLenType tmp_addrlen = (SockLenType)*addrlen;
-  int result = ::getsockname(s, addr, &tmp_addrlen);
+  int result = ::getsockname(s,
+      static_cast<socket_addr_type*>(addr), &tmp_addrlen);
   *addrlen = (std::size_t)tmp_addrlen;
   return result;
 }
 
-int getsockname(socket_type s, socket_addr_type* addr,
+int getsockname(socket_type s, void* addr,
     std::size_t* addrlen, asio::error_code& ec)
 {
   if (s == invalid_socket)
@@ -2171,7 +2176,7 @@ int select(int nfds, fd_set* readfds, fd_set* writefds,
     if (milliseconds == 0)
       milliseconds = 1; // Force context switch.
     ::Sleep(milliseconds);
-    ec.assign(0, ec.category());
+    asio::error::clear(ec);
     return 0;
   }
 
@@ -2491,7 +2496,7 @@ const char* inet_ntop(int af, const void* src, char* dest, size_t length,
 
   // Windows may set error code on success.
   if (result != socket_error_retval)
-    ec.assign(0, ec.category());
+    asio::error::clear(ec);
 
   // Windows may not set an error code on failure.
   else if (result == socket_error_retval && !ec)
@@ -2545,7 +2550,7 @@ int inet_pton(int af, const char* src, void* dest,
     bytes[1] = static_cast<unsigned char>(b1);
     bytes[2] = static_cast<unsigned char>(b2);
     bytes[3] = static_cast<unsigned char>(b3);
-    ec.assign(0, ec.category());
+    asio::error::clear(ec);
     return 1;
   }
   else if (af == ASIO_OS_DEF(AF_INET6))
@@ -2661,7 +2666,7 @@ int inet_pton(int af, const char* src, void* dest,
     for (int i = 0; i < num_back_bytes; ++i)
       bytes[16 - num_back_bytes + i] = back_bytes[i];
 
-    ec.assign(0, ec.category());
+    asio::error::clear(ec);
     return 1;
   }
   else
@@ -2704,12 +2709,12 @@ int inet_pton(int af, const char* src, void* dest,
     if (result != socket_error_retval)
     {
       memcpy(dest, &address.v4.sin_addr, sizeof(in4_addr_type));
-      ec.assign(0, ec.category());
+      asio::error::clear(ec);
     }
     else if (strcmp(src, "255.255.255.255") == 0)
     {
       static_cast<in4_addr_type*>(dest)->s_addr = INADDR_NONE;
-      ec.assign(0, ec.category());
+      asio::error::clear(ec);
     }
   }
   else // AF_INET6
@@ -2719,7 +2724,7 @@ int inet_pton(int af, const char* src, void* dest,
       memcpy(dest, &address.v6.sin6_addr, sizeof(in6_addr_type));
       if (scope_id)
         *scope_id = address.v6.sin6_scope_id;
-      ec.assign(0, ec.category());
+      asio::error::clear(ec);
     }
   }
 
@@ -2728,7 +2733,7 @@ int inet_pton(int af, const char* src, void* dest,
     ec = asio::error::invalid_argument;
 
   if (result != socket_error_retval)
-    ec.assign(0, ec.category());
+    asio::error::clear(ec);
 
   return result == socket_error_retval ? -1 : 1;
 #else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
@@ -3657,7 +3662,7 @@ inline asio::error_code getnameinfo_emulation(
     }
   }
 
-  ec.assign(0, ec.category());
+  asio::error::clear(ec);
   return ec;
 }
 
@@ -3807,7 +3812,7 @@ void freeaddrinfo(addrinfo_type* ai)
 #endif
 }
 
-asio::error_code getnameinfo(const socket_addr_type* addr,
+asio::error_code getnameinfo(const void* addr,
     std::size_t addrlen, char* host, std::size_t hostlen,
     char* serv, std::size_t servlen, int flags, asio::error_code& ec)
 {
@@ -3815,8 +3820,8 @@ asio::error_code getnameinfo(const socket_addr_type* addr,
 # if defined(ASIO_HAS_GETADDRINFO)
   // Building for Windows XP, Windows Server 2003, or later.
   clear_last_error();
-  int error = ::getnameinfo(addr, static_cast<socklen_t>(addrlen),
-      host, static_cast<DWORD>(hostlen),
+  int error = ::getnameinfo(static_cast<const socket_addr_type*>(addr),
+      static_cast<socklen_t>(addrlen), host, static_cast<DWORD>(hostlen),
       serv, static_cast<DWORD>(servlen), flags);
   return ec = translate_addrinfo_error(error);
 # else
@@ -3828,34 +3833,34 @@ asio::error_code getnameinfo(const socket_addr_type* addr,
     if (gni_t gni = (gni_t)::GetProcAddress(winsock_module, "getnameinfo"))
     {
       clear_last_error();
-      int error = gni(addr, static_cast<int>(addrlen),
-          host, static_cast<DWORD>(hostlen),
+      int error = gni(static_cast<const socket_addr_type*>(addr),
+          static_cast<int>(addrlen), host, static_cast<DWORD>(hostlen),
           serv, static_cast<DWORD>(servlen), flags);
       return ec = translate_addrinfo_error(error);
     }
   }
   clear_last_error();
-  return getnameinfo_emulation(addr, addrlen,
-      host, hostlen, serv, servlen, flags, ec);
+  return getnameinfo_emulation(static_cast<const socket_addr_type*>(addr),
+      addrlen, host, hostlen, serv, servlen, flags, ec);
 # endif
 #elif !defined(ASIO_HAS_GETADDRINFO)
   using namespace std; // For memcpy.
   sockaddr_storage_type tmp_addr;
   memcpy(&tmp_addr, addr, addrlen);
-  addr = reinterpret_cast<socket_addr_type*>(&tmp_addr);
+  addr = &tmp_addr;
   clear_last_error();
-  return getnameinfo_emulation(addr, addrlen,
-      host, hostlen, serv, servlen, flags, ec);
+  return getnameinfo_emulation(static_cast<const socket_addr_type*>(addr),
+      addrlen, host, hostlen, serv, servlen, flags, ec);
 #else
   clear_last_error();
-  int error = ::getnameinfo(addr, addrlen, host, hostlen, serv, servlen, flags);
+  int error = ::getnameinfo(static_cast<const socket_addr_type*>(addr),
+      addrlen, host, hostlen, serv, servlen, flags);
   return ec = translate_addrinfo_error(error);
 #endif
 }
 
-asio::error_code sync_getnameinfo(
-    const socket_addr_type* addr, std::size_t addrlen,
-    char* host, std::size_t hostlen, char* serv,
+asio::error_code sync_getnameinfo(const void* addr,
+    std::size_t addrlen, char* host, std::size_t hostlen, char* serv,
     std::size_t servlen, int sock_type, asio::error_code& ec)
 {
   // First try resolving with the service name. If that fails try resolving
@@ -3874,7 +3879,7 @@ asio::error_code sync_getnameinfo(
 
 asio::error_code background_getnameinfo(
     const weak_cancel_token_type& cancel_token,
-    const socket_addr_type* addr, std::size_t addrlen,
+    const void* addr, std::size_t addrlen,
     char* host, std::size_t hostlen, char* serv,
     std::size_t servlen, int sock_type, asio::error_code& ec)
 {