EIC code displayed by LXR master/​include/​boost/​asio/​detail/​impl/​socket_ops.ipp	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-01-18 09:28:35

 //
 // detail/impl/socket_ops.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
 // Copyright (c) 2003-2023 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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_SOCKET_OPS_IPP
 #define BOOST_ASIO_DETAIL_SOCKET_OPS_IPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
 #include <cctype>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <cerrno>
 #include <new>
 #include <boost/asio/detail/assert.hpp>
 #include <boost/asio/detail/socket_ops.hpp>
 #include <boost/asio/error.hpp>
 
 #if defined(BOOST_ASIO_WINDOWS_RUNTIME)
 # include <codecvt>
 # include <locale>
 # include <string>
 #endif // defined(BOOST_ASIO_WINDOWS_RUNTIME)
 
 #if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) \
   || defined(__MACH__) && defined(__APPLE__)
 # if defined(BOOST_ASIO_HAS_PTHREADS)
 #  include <pthread.h>
 # endif // defined(BOOST_ASIO_HAS_PTHREADS)
 #endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
        // || defined(__MACH__) && defined(__APPLE__)
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 namespace socket_ops {
 
 #if !defined(BOOST_ASIO_WINDOWS_RUNTIME)
 
 #if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 struct msghdr { int msg_namelen; };
 #endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 
 #if defined(__hpux)
 // HP-UX doesn't declare these functions extern "C", so they are declared again
 // here to avoid linker errors about undefined symbols.
 extern "C" char* if_indextoname(unsigned int, char*);
 extern "C" unsigned int if_nametoindex(const char*);
 #endif // defined(__hpux)
 
 #endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME)
 
 inline void clear_last_error()
 {
 #if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   WSASetLastError(0);
 #else
   errno = 0;
 #endif
 }
 
 #if !defined(BOOST_ASIO_WINDOWS_RUNTIME)
 
 inline void get_last_error(
     boost::system::error_code& ec, bool is_error_condition)
 {
   if (!is_error_condition)
   {
     boost::asio::error::clear(ec);
   }
   else
   {
 #if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
     ec = boost::system::error_code(WSAGetLastError(),
         boost::asio::error::get_system_category());
 #else
     ec = boost::system::error_code(errno,
         boost::asio::error::get_system_category());
 #endif
   }
 }
 
 template <typename SockLenType>
 inline socket_type call_accept(SockLenType msghdr::*,
     socket_type s, void* addr, std::size_t* addrlen)
 {
   SockLenType tmp_addrlen = addrlen ? (SockLenType)*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, void* addr,
     std::size_t* addrlen, boost::system::error_code& ec)
 {
   if (s == invalid_socket)
   {
     ec = boost::asio::error::bad_descriptor;
     return invalid_socket;
   }
 
   socket_type new_s = call_accept(&msghdr::msg_namelen, s, addr, addrlen);
   get_last_error(ec, new_s == invalid_socket);
   if (new_s == invalid_socket)
     return new_s;
 
 #if defined(__MACH__) && defined(__APPLE__) || defined(__FreeBSD__)
   int optval = 1;
   int result = ::setsockopt(new_s, SOL_SOCKET,
       SO_NOSIGPIPE, &optval, sizeof(optval));
   get_last_error(ec, result != 0);
   if (result != 0)
   {
     ::close(new_s);
     return invalid_socket;
   }
 #endif
 
   boost::asio::error::clear(ec);
   return new_s;
 }
 
 socket_type sync_accept(socket_type s, state_type state,
     void* addr, std::size_t* addrlen, boost::system::error_code& ec)
 {
   // Accept a socket.
   for (;;)
   {
     // Try to complete the operation without blocking.
     socket_type new_socket = socket_ops::accept(s, addr, addrlen, ec);
 
     // Check if operation succeeded.
     if (new_socket != invalid_socket)
       return new_socket;
 
     // Operation failed.
     if (ec == boost::asio::error::would_block
         || ec == boost::asio::error::try_again)
     {
       if (state & user_set_non_blocking)
         return invalid_socket;
       // Fall through to retry operation.
     }
     else if (ec == boost::asio::error::connection_aborted)
     {
       if (state & enable_connection_aborted)
         return invalid_socket;
       // Fall through to retry operation.
     }
 #if defined(EPROTO)
     else if (ec.value() == EPROTO)
     {
       if (state & enable_connection_aborted)
         return invalid_socket;
       // Fall through to retry operation.
     }
 #endif // defined(EPROTO)
     else
       return invalid_socket;
 
     // Wait for socket to become ready.
     if (socket_ops::poll_read(s, 0, -1, ec) < 0)
       return invalid_socket;
   }
 }
 
 #if defined(BOOST_ASIO_HAS_IOCP)
 
 void complete_iocp_accept(socket_type s, void* output_buffer,
     DWORD address_length, void* addr, std::size_t* addrlen,
     socket_type new_socket, boost::system::error_code& ec)
 {
   // Map non-portable errors to their portable counterparts.
   if (ec.value() == ERROR_NETNAME_DELETED)
     ec = boost::asio::error::connection_aborted;
 
   if (!ec)
   {
     // Get the address of the peer.
     if (addr && addrlen)
     {
       LPSOCKADDR local_addr = 0;
       int local_addr_length = 0;
       LPSOCKADDR remote_addr = 0;
       int remote_addr_length = 0;
       GetAcceptExSockaddrs(output_buffer, 0, address_length,
           address_length, &local_addr, &local_addr_length,
           &remote_addr, &remote_addr_length);
       if (static_cast<std::size_t>(remote_addr_length) > *addrlen)
       {
         ec = boost::asio::error::invalid_argument;
       }
       else
       {
         using namespace std; // For memcpy.
         memcpy(addr, remote_addr, remote_addr_length);
         *addrlen = static_cast<std::size_t>(remote_addr_length);
       }
     }
 
     // Need to set the SO_UPDATE_ACCEPT_CONTEXT option so that getsockname
     // and getpeername will work on the accepted socket.
     SOCKET update_ctx_param = s;
     socket_ops::state_type state = 0;
     socket_ops::setsockopt(new_socket, state,
           SOL_SOCKET, SO_UPDATE_ACCEPT_CONTEXT,
           &update_ctx_param, sizeof(SOCKET), ec);
   }
 }
 
 #else // defined(BOOST_ASIO_HAS_IOCP)
 
 bool non_blocking_accept(socket_type s,
     state_type state, void* addr, std::size_t* addrlen,
     boost::system::error_code& ec, socket_type& new_socket)
 {
   for (;;)
   {
     // Accept the waiting connection.
     new_socket = socket_ops::accept(s, addr, addrlen, ec);
 
     // Check if operation succeeded.
     if (new_socket != invalid_socket)
       return true;
 
     // Retry operation if interrupted by signal.
     if (ec == boost::asio::error::interrupted)
       continue;
 
     // Operation failed.
     if (ec == boost::asio::error::would_block
         || ec == boost::asio::error::try_again)
     {
       // Fall through to retry operation.
     }
     else if (ec == boost::asio::error::connection_aborted)
     {
       if (state & enable_connection_aborted)
         return true;
       // Fall through to retry operation.
     }
 #if defined(EPROTO)
     else if (ec.value() == EPROTO)
     {
       if (state & enable_connection_aborted)
         return true;
       // Fall through to retry operation.
     }
 #endif // defined(EPROTO)
     else
       return true;
 
     return false;
   }
 }
 
 #endif // defined(BOOST_ASIO_HAS_IOCP)
 
 template <typename SockLenType>
 inline int call_bind(SockLenType msghdr::*,
     socket_type s, const void* addr, std::size_t addrlen)
 {
   return ::bind(s, static_cast<const socket_addr_type*>(addr),
       (SockLenType)addrlen);
 }
 
 int bind(socket_type s, const void* addr,
     std::size_t addrlen, boost::system::error_code& ec)
 {
   if (s == invalid_socket)
   {
     ec = boost::asio::error::bad_descriptor;
     return socket_error_retval;
   }
 
   int result = call_bind(&msghdr::msg_namelen, s, addr, addrlen);
   get_last_error(ec, result != 0);
   return result;
 }
 
 int close(socket_type s, state_type& state,
     bool destruction, boost::system::error_code& ec)
 {
   int result = 0;
   if (s != invalid_socket)
   {
     // We don't want the destructor to block, so set the socket to linger in
     // the background. If the user doesn't like this behaviour then they need
     // to explicitly close the socket.
     if (destruction && (state & user_set_linger))
     {
       ::linger opt;
       opt.l_onoff = 0;
       opt.l_linger = 0;
       boost::system::error_code ignored_ec;
       socket_ops::setsockopt(s, state, SOL_SOCKET,
           SO_LINGER, &opt, sizeof(opt), ignored_ec);
     }
 
 #if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
     result = ::closesocket(s);
 #else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
     result = ::close(s);
 #endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
     get_last_error(ec, result != 0);
 
     if (result != 0
         && (ec == boost::asio::error::would_block
           || ec == boost::asio::error::try_again))
     {
       // According to UNIX Network Programming Vol. 1, it is possible for
       // close() to fail with EWOULDBLOCK under certain circumstances. What
       // isn't clear is the state of the descriptor after this error. The one
       // current OS where this behaviour is seen, Windows, says that the socket
       // remains open. Therefore we'll put the descriptor back into blocking
       // mode and have another attempt at closing it.
 #if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
       ioctl_arg_type arg = 0;
       ::ioctlsocket(s, FIONBIO, &arg);
 #else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 # if defined(__SYMBIAN32__) || defined(__EMSCRIPTEN__)
       int flags = ::fcntl(s, F_GETFL, 0);
       if (flags >= 0)
         ::fcntl(s, F_SETFL, flags & ~O_NONBLOCK);
 # else // defined(__SYMBIAN32__) || defined(__EMSCRIPTEN__)
       ioctl_arg_type arg = 0;
       ::ioctl(s, FIONBIO, &arg);
 # endif // defined(__SYMBIAN32__) || defined(__EMSCRIPTEN__)
 #endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
       state &= ~non_blocking;
 
 #if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
       result = ::closesocket(s);
 #else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
       result = ::close(s);
 #endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
       get_last_error(ec, result != 0);
     }
   }
 
   return result;
 }
 
 bool set_user_non_blocking(socket_type s,
     state_type& state, bool value, boost::system::error_code& ec)
 {
   if (s == invalid_socket)
   {
     ec = boost::asio::error::bad_descriptor;
     return false;
   }
 
 #if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   ioctl_arg_type arg = (value ? 1 : 0);
   int result = ::ioctlsocket(s, FIONBIO, &arg);
   get_last_error(ec, result < 0);
 #elif defined(__SYMBIAN32__) || defined(__EMSCRIPTEN__)
   int result = ::fcntl(s, F_GETFL, 0);
   get_last_error(ec, result < 0);
   if (result >= 0)
   {
     int flag = (value ? (result | O_NONBLOCK) : (result & ~O_NONBLOCK));
     result = ::fcntl(s, F_SETFL, flag);
     get_last_error(ec, result < 0);
   }
 #else
   ioctl_arg_type arg = (value ? 1 : 0);
   int result = ::ioctl(s, FIONBIO, &arg);
   get_last_error(ec, result < 0);
 #endif
 
   if (result >= 0)
   {
     if (value)
       state |= user_set_non_blocking;
     else
     {
       // Clearing the user-set non-blocking mode always overrides any
       // internally-set non-blocking flag. Any subsequent asynchronous
       // operations will need to re-enable non-blocking I/O.
       state &= ~(user_set_non_blocking | internal_non_blocking);
     }
     return true;
   }
 
   return false;
 }
 
 bool set_internal_non_blocking(socket_type s,
     state_type& state, bool value, boost::system::error_code& ec)
 {
   if (s == invalid_socket)
   {
     ec = boost::asio::error::bad_descriptor;
     return false;
   }
 
   if (!value && (state & user_set_non_blocking))
   {
     // It does not make sense to clear the internal non-blocking flag if the
     // user still wants non-blocking behaviour. Return an error and let the
     // caller figure out whether to update the user-set non-blocking flag.
     ec = boost::asio::error::invalid_argument;
     return false;
   }
 
 #if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   ioctl_arg_type arg = (value ? 1 : 0);
   int result = ::ioctlsocket(s, FIONBIO, &arg);
   get_last_error(ec, result < 0);
 #elif defined(__SYMBIAN32__) || defined(__EMSCRIPTEN__)
   int result = ::fcntl(s, F_GETFL, 0);
   get_last_error(ec, result < 0);
   if (result >= 0)
   {
     int flag = (value ? (result | O_NONBLOCK) : (result & ~O_NONBLOCK));
     result = ::fcntl(s, F_SETFL, flag);
     get_last_error(ec, result < 0);
   }
 #else
   ioctl_arg_type arg = (value ? 1 : 0);
   int result = ::ioctl(s, FIONBIO, &arg);
   get_last_error(ec, result < 0);
 #endif
 
   if (result >= 0)
   {
     if (value)
       state |= internal_non_blocking;
     else
       state &= ~internal_non_blocking;
     return true;
   }
 
   return false;
 }
 
 int shutdown(socket_type s, int what, boost::system::error_code& ec)
 {
   if (s == invalid_socket)
   {
     ec = boost::asio::error::bad_descriptor;
     return socket_error_retval;
   }
 
   int result = ::shutdown(s, what);
   get_last_error(ec, result != 0);
   return result;
 }
 
 template <typename SockLenType>
 inline int call_connect(SockLenType msghdr::*,
     socket_type s, const void* addr, std::size_t addrlen)
 {
   return ::connect(s, static_cast<const socket_addr_type*>(addr),
       (SockLenType)addrlen);
 }
 
 int connect(socket_type s, const void* addr,
     std::size_t addrlen, boost::system::error_code& ec)
 {
   if (s == invalid_socket)
   {
     ec = boost::asio::error::bad_descriptor;
     return socket_error_retval;
   }
 
   int result = call_connect(&msghdr::msg_namelen, s, addr, addrlen);
   get_last_error(ec, result != 0);
 #if defined(__linux__)
   if (result != 0 && ec == boost::asio::error::try_again)
   {
     if (static_cast<const socket_addr_type*>(addr)->sa_family == AF_UNIX)
       ec = boost::asio::error::in_progress;
     else
       ec = boost::asio::error::no_buffer_space;
   }
 #endif // defined(__linux__)
   return result;
 }
 
 void sync_connect(socket_type s, const void* addr,
     std::size_t addrlen, boost::system::error_code& ec)
 {
   // Perform the connect operation.
   socket_ops::connect(s, addr, addrlen, ec);
   if (ec != boost::asio::error::in_progress
       && ec != boost::asio::error::would_block)
   {
     // The connect operation finished immediately.
     return;
   }
 
   // Wait for socket to become ready.
   if (socket_ops::poll_connect(s, -1, ec) < 0)
     return;
 
   // Get the error code from the connect operation.
   int connect_error = 0;
   size_t connect_error_len = sizeof(connect_error);
   if (socket_ops::getsockopt(s, 0, SOL_SOCKET, SO_ERROR,
         &connect_error, &connect_error_len, ec) == socket_error_retval)
     return;
 
   // Return the result of the connect operation.
   ec = boost::system::error_code(connect_error,
       boost::asio::error::get_system_category());
 }
 
 #if defined(BOOST_ASIO_HAS_IOCP)
 
 void complete_iocp_connect(socket_type s, boost::system::error_code& ec)
 {
   // Map non-portable errors to their portable counterparts.
   switch (ec.value())
   {
   case ERROR_CONNECTION_REFUSED:
     ec = boost::asio::error::connection_refused;
     break;
   case ERROR_NETWORK_UNREACHABLE:
     ec = boost::asio::error::network_unreachable;
     break;
   case ERROR_HOST_UNREACHABLE:
     ec = boost::asio::error::host_unreachable;
     break;
   case ERROR_SEM_TIMEOUT:
     ec = boost::asio::error::timed_out;
     break;
   default:
     break;
   }
 
   if (!ec)
   {
     // Need to set the SO_UPDATE_CONNECT_CONTEXT option so that getsockname
     // and getpeername will work on the connected socket.
     socket_ops::state_type state = 0;
     const int so_update_connect_context = 0x7010;
     socket_ops::setsockopt(s, state, SOL_SOCKET,
         so_update_connect_context, 0, 0, ec);
   }
 }
 
 #endif // defined(BOOST_ASIO_HAS_IOCP)
 
 bool non_blocking_connect(socket_type s, boost::system::error_code& ec)
 {
   // Check if the connect operation has finished. This is required since we may
   // get spurious readiness notifications from the reactor.
 #if defined(BOOST_ASIO_WINDOWS) \
   || defined(__CYGWIN__) \
   || defined(__SYMBIAN32__)
   fd_set write_fds;
   FD_ZERO(&write_fds);
   FD_SET(s, &write_fds);
   fd_set except_fds;
   FD_ZERO(&except_fds);
   FD_SET(s, &except_fds);
   timeval zero_timeout;
   zero_timeout.tv_sec = 0;
   zero_timeout.tv_usec = 0;
   int ready = ::select(s + 1, 0, &write_fds, &except_fds, &zero_timeout);
 #else // defined(BOOST_ASIO_WINDOWS)
       // || defined(__CYGWIN__)
       // || defined(__SYMBIAN32__)
   pollfd fds;
   fds.fd = s;
   fds.events = POLLOUT;
   fds.revents = 0;
   int ready = ::poll(&fds, 1, 0);
 #endif // defined(BOOST_ASIO_WINDOWS)
        // || defined(__CYGWIN__)
        // || defined(__SYMBIAN32__)
   if (ready == 0)
   {
     // The asynchronous connect operation is still in progress.
     return false;
   }
 
   // Get the error code from the connect operation.
   int connect_error = 0;
   size_t connect_error_len = sizeof(connect_error);
   if (socket_ops::getsockopt(s, 0, SOL_SOCKET, SO_ERROR,
         &connect_error, &connect_error_len, ec) == 0)
   {
     if (connect_error)
     {
       ec = boost::system::error_code(connect_error,
           boost::asio::error::get_system_category());
     }
     else
       boost::asio::error::clear(ec);
   }
 
   return true;
 }
 
 int socketpair(int af, int type, int protocol,
     socket_type sv[2], boost::system::error_code& ec)
 {
 #if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   (void)(af);
   (void)(type);
   (void)(protocol);
   (void)(sv);
   ec = boost::asio::error::operation_not_supported;
   return socket_error_retval;
 #else
   int result = ::socketpair(af, type, protocol, sv);
   get_last_error(ec, result != 0);
   return result;
 #endif
 }
 
 bool sockatmark(socket_type s, boost::system::error_code& ec)
 {
   if (s == invalid_socket)
   {
     ec = boost::asio::error::bad_descriptor;
     return false;
   }
 
 #if defined(SIOCATMARK)
   ioctl_arg_type value = 0;
 # if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   int result = ::ioctlsocket(s, SIOCATMARK, &value);
 # else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   int result = ::ioctl(s, SIOCATMARK, &value);
 # endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   get_last_error(ec, result < 0);
 # if defined(ENOTTY)
   if (ec.value() == ENOTTY)
     ec = boost::asio::error::not_socket;
 # endif // defined(ENOTTY)
 #else // defined(SIOCATMARK)
   int value = ::sockatmark(s);
   get_last_error(ec, value < 0);
 #endif // defined(SIOCATMARK)
 
   return ec ? false : value != 0;
 }
 
 size_t available(socket_type s, boost::system::error_code& ec)
 {
   if (s == invalid_socket)
   {
     ec = boost::asio::error::bad_descriptor;
     return 0;
   }
 
   ioctl_arg_type value = 0;
 #if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   int result = ::ioctlsocket(s, FIONREAD, &value);
 #else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   int result = ::ioctl(s, FIONREAD, &value);
 #endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   get_last_error(ec, result < 0);
 #if defined(ENOTTY)
   if (ec.value() == ENOTTY)
     ec = boost::asio::error::not_socket;
 #endif // defined(ENOTTY)
 
   return ec ? static_cast<size_t>(0) : static_cast<size_t>(value);
 }
 
 int listen(socket_type s, int backlog, boost::system::error_code& ec)
 {
   if (s == invalid_socket)
   {
     ec = boost::asio::error::bad_descriptor;
     return socket_error_retval;
   }
 
   int result = ::listen(s, backlog);
   get_last_error(ec, result != 0);
   return result;
 }
 
 inline void init_buf_iov_base(void*& base, void* addr)
 {
   base = addr;
 }
 
 template <typename T>
 inline void init_buf_iov_base(T& base, void* addr)
 {
   base = static_cast<T>(addr);
 }
 
 #if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 typedef WSABUF buf;
 #else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 typedef iovec buf;
 #endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 
 void init_buf(buf& b, void* data, size_t size)
 {
 #if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   b.buf = static_cast<char*>(data);
   b.len = static_cast<u_long>(size);
 #else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   init_buf_iov_base(b.iov_base, data);
   b.iov_len = size;
 #endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 }
 
 void init_buf(buf& b, const void* data, size_t size)
 {
 #if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   b.buf = static_cast<char*>(const_cast<void*>(data));
   b.len = static_cast<u_long>(size);
 #else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   init_buf_iov_base(b.iov_base, const_cast<void*>(data));
   b.iov_len = size;
 #endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 }
 
 inline void init_msghdr_msg_name(void*& name, void* addr)
 {
   name = static_cast<socket_addr_type*>(addr);
 }
 
 inline void init_msghdr_msg_name(void*& name, const socket_addr_type* addr)
 {
   name = const_cast<socket_addr_type*>(addr);
 }
 
 template <typename T>
 inline void init_msghdr_msg_name(T& name, void* addr)
 {
   name = static_cast<T>(addr);
 }
 
 template <typename T>
 inline void init_msghdr_msg_name(T& name, const void* addr)
 {
   name = static_cast<T>(const_cast<void*>(addr));
 }
 
 signed_size_type recv(socket_type s, buf* bufs, size_t count,
     int flags, boost::system::error_code& ec)
 {
 #if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   // Receive some data.
   DWORD recv_buf_count = static_cast<DWORD>(count);
   DWORD bytes_transferred = 0;
   DWORD recv_flags = flags;
   int result = ::WSARecv(s, bufs, recv_buf_count,
       &bytes_transferred, &recv_flags, 0, 0);
   get_last_error(ec, true);
   if (ec.value() == ERROR_NETNAME_DELETED)
     ec = boost::asio::error::connection_reset;
   else if (ec.value() == ERROR_PORT_UNREACHABLE)
     ec = boost::asio::error::connection_refused;
   else if (ec.value() == WSAEMSGSIZE || ec.value() == ERROR_MORE_DATA)
     result = 0;
   if (result != 0)
     return socket_error_retval;
   boost::asio::error::clear(ec);
   return bytes_transferred;
 #else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   msghdr msg = msghdr();
   msg.msg_iov = bufs;
   msg.msg_iovlen = static_cast<int>(count);
   signed_size_type result = ::recvmsg(s, &msg, flags);
   get_last_error(ec, result < 0);
   return result;
 #endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 }
 
 signed_size_type recv1(socket_type s, void* data, size_t size,
     int flags, boost::system::error_code& ec)
 {
 #if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   // Receive some data.
   WSABUF buf;
   buf.buf = const_cast<char*>(static_cast<const char*>(data));
   buf.len = static_cast<ULONG>(size);
   DWORD bytes_transferred = 0;
   DWORD recv_flags = flags;
   int result = ::WSARecv(s, &buf, 1,
       &bytes_transferred, &recv_flags, 0, 0);
   get_last_error(ec, true);
   if (ec.value() == ERROR_NETNAME_DELETED)
     ec = boost::asio::error::connection_reset;
   else if (ec.value() == ERROR_PORT_UNREACHABLE)
     ec = boost::asio::error::connection_refused;
   else if (ec.value() == WSAEMSGSIZE || ec.value() == ERROR_MORE_DATA)
     result = 0;
   if (result != 0)
     return socket_error_retval;
   boost::asio::error::clear(ec);
   return bytes_transferred;
 #else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   signed_size_type result = ::recv(s, static_cast<char*>(data), size, flags);
   get_last_error(ec, result < 0);
   return result;
 #endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 }
 
 size_t sync_recv(socket_type s, state_type state, buf* bufs,
     size_t count, int flags, bool all_empty, boost::system::error_code& ec)
 {
   if (s == invalid_socket)
   {
     ec = boost::asio::error::bad_descriptor;
     return 0;
   }
 
   // A request to read 0 bytes on a stream is a no-op.
   if (all_empty && (state & stream_oriented))
   {
     boost::asio::error::clear(ec);
     return 0;
   }
 
   // Read some data.
   for (;;)
   {
     // Try to complete the operation without blocking.
     signed_size_type bytes = socket_ops::recv(s, bufs, count, flags, ec);
 
     // Check for EOF.
     if ((state & stream_oriented) && bytes == 0)
     {
       ec = boost::asio::error::eof;
       return 0;
     }
 
     // Check if operation succeeded.
     if (bytes >= 0)
       return bytes;
 
     // Operation failed.
     if ((state & user_set_non_blocking)
         || (ec != boost::asio::error::would_block
           && ec != boost::asio::error::try_again))
       return 0;
 
     // Wait for socket to become ready.
     if (socket_ops::poll_read(s, 0, -1, ec) < 0)
       return 0;
   }
 }
 
 size_t sync_recv1(socket_type s, state_type state, void* data,
     size_t size, int flags, boost::system::error_code& ec)
 {
   if (s == invalid_socket)
   {
     ec = boost::asio::error::bad_descriptor;
     return 0;
   }
 
   // A request to read 0 bytes on a stream is a no-op.
   if (size == 0 && (state & stream_oriented))
   {
     boost::asio::error::clear(ec);
     return 0;
   }
 
   // Read some data.
   for (;;)
   {
     // Try to complete the operation without blocking.
     signed_size_type bytes = socket_ops::recv1(s, data, size, flags, ec);
 
     // Check for EOF.
     if ((state & stream_oriented) && bytes == 0)
     {
       ec = boost::asio::error::eof;
       return 0;
     }
 
     // Check if operation succeeded.
     if (bytes >= 0)
       return bytes;
 
     // Operation failed.
     if ((state & user_set_non_blocking)
         || (ec != boost::asio::error::would_block
           && ec != boost::asio::error::try_again))
       return 0;
 
     // Wait for socket to become ready.
     if (socket_ops::poll_read(s, 0, -1, ec) < 0)
       return 0;
   }
 }
 
 #if defined(BOOST_ASIO_HAS_IOCP)
 
 void complete_iocp_recv(state_type state,
     const weak_cancel_token_type& cancel_token, bool all_empty,
     boost::system::error_code& ec, size_t bytes_transferred)
 {
   // Map non-portable errors to their portable counterparts.
   if (ec.value() == ERROR_NETNAME_DELETED)
   {
     if (cancel_token.expired())
       ec = boost::asio::error::operation_aborted;
     else
       ec = boost::asio::error::connection_reset;
   }
   else if (ec.value() == ERROR_PORT_UNREACHABLE)
   {
     ec = boost::asio::error::connection_refused;
   }
   else if (ec.value() == WSAEMSGSIZE || ec.value() == ERROR_MORE_DATA)
   {
     boost::asio::error::clear(ec);
   }
 
   // Check for connection closed.
   else if (!ec && bytes_transferred == 0
       && (state & stream_oriented) != 0
       && !all_empty)
   {
     ec = boost::asio::error::eof;
   }
 }
 
 #else // defined(BOOST_ASIO_HAS_IOCP)
 
 bool non_blocking_recv(socket_type s,
     buf* bufs, size_t count, int flags, bool is_stream,
     boost::system::error_code& ec, size_t& bytes_transferred)
 {
   for (;;)
   {
     // Read some data.
     signed_size_type bytes = socket_ops::recv(s, bufs, count, flags, ec);
 
     // Check for end of stream.
     if (is_stream && bytes == 0)
     {
       ec = boost::asio::error::eof;
       return true;
     }
 
     // Check if operation succeeded.
     if (bytes >= 0)
     {
       bytes_transferred = bytes;
       return true;
     }
 
     // Retry operation if interrupted by signal.
     if (ec == boost::asio::error::interrupted)
       continue;
 
     // Check if we need to run the operation again.
     if (ec == boost::asio::error::would_block
         || ec == boost::asio::error::try_again)
       return false;
 
     // Operation failed.
     bytes_transferred = 0;
     return true;
   }
 }
 
 bool non_blocking_recv1(socket_type s,
     void* data, size_t size, int flags, bool is_stream,
     boost::system::error_code& ec, size_t& bytes_transferred)
 {
   for (;;)
   {
     // Read some data.
     signed_size_type bytes = socket_ops::recv1(s, data, size, flags, ec);
 
     // Check for end of stream.
     if (is_stream && bytes == 0)
     {
       ec = boost::asio::error::eof;
       return true;
     }
 
     // Check if operation succeeded.
     if (bytes >= 0)
     {
       bytes_transferred = bytes;
       return true;
     }
 
     // Retry operation if interrupted by signal.
     if (ec == boost::asio::error::interrupted)
       continue;
 
     // Check if we need to run the operation again.
     if (ec == boost::asio::error::would_block
         || ec == boost::asio::error::try_again)
       return false;
 
     // Operation failed.
     bytes_transferred = 0;
     return true;
   }
 }
 
 #endif // defined(BOOST_ASIO_HAS_IOCP)
 
 signed_size_type recvfrom(socket_type s, buf* bufs, size_t count,
     int flags, void* addr, std::size_t* addrlen, boost::system::error_code& ec)
 {
 #if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   // Receive some data.
   DWORD recv_buf_count = static_cast<DWORD>(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, 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)
     ec = boost::asio::error::connection_reset;
   else if (ec.value() == ERROR_PORT_UNREACHABLE)
     ec = boost::asio::error::connection_refused;
   else if (ec.value() == WSAEMSGSIZE || ec.value() == ERROR_MORE_DATA)
     result = 0;
   if (result != 0)
     return socket_error_retval;
   boost::asio::error::clear(ec);
   return bytes_transferred;
 #else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   msghdr msg = msghdr();
   init_msghdr_msg_name(msg.msg_name, addr);
   msg.msg_namelen = static_cast<int>(*addrlen);
   msg.msg_iov = bufs;
   msg.msg_iovlen = static_cast<int>(count);
   signed_size_type result = ::recvmsg(s, &msg, flags);
   get_last_error(ec, result < 0);
   *addrlen = msg.msg_namelen;
   return result;
 #endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 }
 
 template <typename SockLenType>
 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, 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, void* addr, std::size_t* addrlen, boost::system::error_code& ec)
 {
 #if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   // Receive some data.
   WSABUF buf;
   buf.buf = static_cast<char*>(data);
   buf.len = static_cast<ULONG>(size);
   DWORD bytes_transferred = 0;
   DWORD recv_flags = flags;
   int tmp_addrlen = (int)*addrlen;
   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)
     ec = boost::asio::error::connection_reset;
   else if (ec.value() == ERROR_PORT_UNREACHABLE)
     ec = boost::asio::error::connection_refused;
   else if (ec.value() == WSAEMSGSIZE || ec.value() == ERROR_MORE_DATA)
     result = 0;
   if (result != 0)
     return socket_error_retval;
   boost::asio::error::clear(ec);
   return bytes_transferred;
 #else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   signed_size_type result = call_recvfrom(&msghdr::msg_namelen,
       s, data, size, flags, addr, addrlen);
   get_last_error(ec, result < 0);
   return result;
 #endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 }
 
 size_t sync_recvfrom(socket_type s, state_type state, buf* bufs, size_t count,
     int flags, void* addr, std::size_t* addrlen, boost::system::error_code& ec)
 {
   if (s == invalid_socket)
   {
     ec = boost::asio::error::bad_descriptor;
     return 0;
   }
 
   // Read some data.
   for (;;)
   {
     // Try to complete the operation without blocking.
     signed_size_type bytes = socket_ops::recvfrom(
         s, bufs, count, flags, addr, addrlen, ec);
 
     // Check if operation succeeded.
     if (bytes >= 0)
       return bytes;
 
     // Operation failed.
     if ((state & user_set_non_blocking)
         || (ec != boost::asio::error::would_block
           && ec != boost::asio::error::try_again))
       return 0;
 
     // Wait for socket to become ready.
     if (socket_ops::poll_read(s, 0, -1, ec) < 0)
       return 0;
   }
 }
 
 size_t sync_recvfrom1(socket_type s, state_type state, void* data, size_t size,
     int flags, void* addr, std::size_t* addrlen, boost::system::error_code& ec)
 {
   if (s == invalid_socket)
   {
     ec = boost::asio::error::bad_descriptor;
     return 0;
   }
 
   // Read some data.
   for (;;)
   {
     // Try to complete the operation without blocking.
     signed_size_type bytes = socket_ops::recvfrom1(
         s, data, size, flags, addr, addrlen, ec);
 
     // Check if operation succeeded.
     if (bytes >= 0)
       return bytes;
 
     // Operation failed.
     if ((state & user_set_non_blocking)
         || (ec != boost::asio::error::would_block
           && ec != boost::asio::error::try_again))
       return 0;
 
     // Wait for socket to become ready.
     if (socket_ops::poll_read(s, 0, -1, ec) < 0)
       return 0;
   }
 }
 
 #if defined(BOOST_ASIO_HAS_IOCP)
 
 void complete_iocp_recvfrom(
     const weak_cancel_token_type& cancel_token,
     boost::system::error_code& ec)
 {
   // Map non-portable errors to their portable counterparts.
   if (ec.value() == ERROR_NETNAME_DELETED)
   {
     if (cancel_token.expired())
       ec = boost::asio::error::operation_aborted;
     else
       ec = boost::asio::error::connection_reset;
   }
   else if (ec.value() == ERROR_PORT_UNREACHABLE)
   {
     ec = boost::asio::error::connection_refused;
   }
   else if (ec.value() == WSAEMSGSIZE || ec.value() == ERROR_MORE_DATA)
   {
     boost::asio::error::clear(ec);
   }
 }
 
 #else // defined(BOOST_ASIO_HAS_IOCP)
 
 bool non_blocking_recvfrom(socket_type s, buf* bufs,
     size_t count, int flags, void* addr, std::size_t* addrlen,
     boost::system::error_code& ec, size_t& bytes_transferred)
 {
   for (;;)
   {
     // Read some data.
     signed_size_type bytes = socket_ops::recvfrom(
         s, bufs, count, flags, addr, addrlen, ec);
 
     // Check if operation succeeded.
     if (bytes >= 0)
     {
       bytes_transferred = bytes;
       return true;
     }
 
     // Retry operation if interrupted by signal.
     if (ec == boost::asio::error::interrupted)
       continue;
 
     // Check if we need to run the operation again.
     if (ec == boost::asio::error::would_block
         || ec == boost::asio::error::try_again)
       return false;
 
     // Operation failed.
     bytes_transferred = 0;
     return true;
   }
 }
 
 bool non_blocking_recvfrom1(socket_type s, void* data,
     size_t size, int flags, void* addr, std::size_t* addrlen,
     boost::system::error_code& ec, size_t& bytes_transferred)
 {
   for (;;)
   {
     // Read some data.
     signed_size_type bytes = socket_ops::recvfrom1(
         s, data, size, flags, addr, addrlen, ec);
 
     // Check if operation succeeded.
     if (bytes >= 0)
     {
       bytes_transferred = bytes;
       return true;
     }
 
     // Retry operation if interrupted by signal.
     if (ec == boost::asio::error::interrupted)
       continue;
 
     // Check if we need to run the operation again.
     if (ec == boost::asio::error::would_block
         || ec == boost::asio::error::try_again)
       return false;
 
     // Operation failed.
     bytes_transferred = 0;
     return true;
   }
 }
 
 #endif // defined(BOOST_ASIO_HAS_IOCP)
 
 signed_size_type recvmsg(socket_type s, buf* bufs, size_t count,
     int in_flags, int& out_flags, boost::system::error_code& ec)
 {
 #if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   out_flags = 0;
   return socket_ops::recv(s, bufs, count, in_flags, ec);
 #else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   msghdr msg = msghdr();
   msg.msg_iov = bufs;
   msg.msg_iovlen = static_cast<int>(count);
   signed_size_type result = ::recvmsg(s, &msg, in_flags);
   get_last_error(ec, result < 0);
   if (result >= 0)
     out_flags = msg.msg_flags;
   else
     out_flags = 0;
   return result;
 #endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 }
 
 size_t sync_recvmsg(socket_type s, state_type state,
     buf* bufs, size_t count, int in_flags, int& out_flags,
     boost::system::error_code& ec)
 {
   if (s == invalid_socket)
   {
     ec = boost::asio::error::bad_descriptor;
     return 0;
   }
 
   // Read some data.
   for (;;)
   {
     // Try to complete the operation without blocking.
     signed_size_type bytes = socket_ops::recvmsg(
         s, bufs, count, in_flags, out_flags, ec);
 
     // Check if operation succeeded.
     if (bytes >= 0)
       return bytes;
 
     // Operation failed.
     if ((state & user_set_non_blocking)
         || (ec != boost::asio::error::would_block
           && ec != boost::asio::error::try_again))
       return 0;
 
     // Wait for socket to become ready.
     if (socket_ops::poll_read(s, 0, -1, ec) < 0)
       return 0;
   }
 }
 
 #if defined(BOOST_ASIO_HAS_IOCP)
 
 void complete_iocp_recvmsg(
     const weak_cancel_token_type& cancel_token,
     boost::system::error_code& ec)
 {
   // Map non-portable errors to their portable counterparts.
   if (ec.value() == ERROR_NETNAME_DELETED)
   {
     if (cancel_token.expired())
       ec = boost::asio::error::operation_aborted;
     else
       ec = boost::asio::error::connection_reset;
   }
   else if (ec.value() == ERROR_PORT_UNREACHABLE)
   {
     ec = boost::asio::error::connection_refused;
   }
   else if (ec.value() == WSAEMSGSIZE || ec.value() == ERROR_MORE_DATA)
   {
     boost::asio::error::clear(ec);
   }
 }
 
 #else // defined(BOOST_ASIO_HAS_IOCP)
 
 bool non_blocking_recvmsg(socket_type s,
     buf* bufs, size_t count, int in_flags, int& out_flags,
     boost::system::error_code& ec, size_t& bytes_transferred)
 {
   for (;;)
   {
     // Read some data.
     signed_size_type bytes = socket_ops::recvmsg(
         s, bufs, count, in_flags, out_flags, ec);
 
     // Check if operation succeeded.
     if (bytes >= 0)
     {
       bytes_transferred = bytes;
       return true;
     }
 
     // Retry operation if interrupted by signal.
     if (ec == boost::asio::error::interrupted)
       continue;
 
     // Check if we need to run the operation again.
     if (ec == boost::asio::error::would_block
         || ec == boost::asio::error::try_again)
       return false;
 
     // Operation failed.
     bytes_transferred = 0;
     return true;
   }
 }
 
 #endif // defined(BOOST_ASIO_HAS_IOCP)
 
 signed_size_type send(socket_type s, const buf* bufs, size_t count,
     int flags, boost::system::error_code& ec)
 {
 #if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   // Send the data.
   DWORD send_buf_count = static_cast<DWORD>(count);
   DWORD bytes_transferred = 0;
   DWORD send_flags = flags;
   int result = ::WSASend(s, const_cast<buf*>(bufs),
         send_buf_count, &bytes_transferred, send_flags, 0, 0);
   get_last_error(ec, true);
   if (ec.value() == ERROR_NETNAME_DELETED)
     ec = boost::asio::error::connection_reset;
   else if (ec.value() == ERROR_PORT_UNREACHABLE)
     ec = boost::asio::error::connection_refused;
   if (result != 0)
     return socket_error_retval;
   boost::asio::error::clear(ec);
   return bytes_transferred;
 #else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   msghdr msg = msghdr();
   msg.msg_iov = const_cast<buf*>(bufs);
   msg.msg_iovlen = static_cast<int>(count);
 #if defined(BOOST_ASIO_HAS_MSG_NOSIGNAL)
   flags |= MSG_NOSIGNAL;
 #endif // defined(BOOST_ASIO_HAS_MSG_NOSIGNAL)
   signed_size_type result = ::sendmsg(s, &msg, flags);
   get_last_error(ec, result < 0);
   return result;
 #endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 }
 
 signed_size_type send1(socket_type s, const void* data, size_t size,
     int flags, boost::system::error_code& ec)
 {
 #if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   // Send the data.
   WSABUF buf;
   buf.buf = const_cast<char*>(static_cast<const char*>(data));
   buf.len = static_cast<ULONG>(size);
   DWORD bytes_transferred = 0;
   DWORD send_flags = flags;
   int result = ::WSASend(s, &buf, 1,
         &bytes_transferred, send_flags, 0, 0);
   get_last_error(ec, true);
   if (ec.value() == ERROR_NETNAME_DELETED)
     ec = boost::asio::error::connection_reset;
   else if (ec.value() == ERROR_PORT_UNREACHABLE)
     ec = boost::asio::error::connection_refused;
   if (result != 0)
     return socket_error_retval;
   boost::asio::error::clear(ec);
   return bytes_transferred;
 #else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 #if defined(BOOST_ASIO_HAS_MSG_NOSIGNAL)
   flags |= MSG_NOSIGNAL;
 #endif // defined(BOOST_ASIO_HAS_MSG_NOSIGNAL)
   signed_size_type result = ::send(s,
       static_cast<const char*>(data), size, flags);
   get_last_error(ec, result < 0);
   return result;
 #endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 }
 
 size_t sync_send(socket_type s, state_type state, const buf* bufs,
     size_t count, int flags, bool all_empty, boost::system::error_code& ec)
 {
   if (s == invalid_socket)
   {
     ec = boost::asio::error::bad_descriptor;
     return 0;
   }
 
   // A request to write 0 bytes to a stream is a no-op.
   if (all_empty && (state & stream_oriented))
   {
     boost::asio::error::clear(ec);
     return 0;
   }
 
   // Read some data.
   for (;;)
   {
     // Try to complete the operation without blocking.
     signed_size_type bytes = socket_ops::send(s, bufs, count, flags, ec);
 
     // Check if operation succeeded.
     if (bytes >= 0)
       return bytes;
 
     // Operation failed.
     if ((state & user_set_non_blocking)
         || (ec != boost::asio::error::would_block
           && ec != boost::asio::error::try_again))
       return 0;
 
     // Wait for socket to become ready.
     if (socket_ops::poll_write(s, 0, -1, ec) < 0)
       return 0;
   }
 }
 
 size_t sync_send1(socket_type s, state_type state, const void* data,
     size_t size, int flags, boost::system::error_code& ec)
 {
   if (s == invalid_socket)
   {
     ec = boost::asio::error::bad_descriptor;
     return 0;
   }
 
   // A request to write 0 bytes to a stream is a no-op.
   if (size == 0 && (state & stream_oriented))
   {
     boost::asio::error::clear(ec);
     return 0;
   }
 
   // Read some data.
   for (;;)
   {
     // Try to complete the operation without blocking.
     signed_size_type bytes = socket_ops::send1(s, data, size, flags, ec);
 
     // Check if operation succeeded.
     if (bytes >= 0)
       return bytes;
 
     // Operation failed.
     if ((state & user_set_non_blocking)
         || (ec != boost::asio::error::would_block
           && ec != boost::asio::error::try_again))
       return 0;
 
     // Wait for socket to become ready.
     if (socket_ops::poll_write(s, 0, -1, ec) < 0)
       return 0;
   }
 }
 
 #if defined(BOOST_ASIO_HAS_IOCP)
 
 void complete_iocp_send(
     const weak_cancel_token_type& cancel_token,
     boost::system::error_code& ec)
 {
   // Map non-portable errors to their portable counterparts.
   if (ec.value() == ERROR_NETNAME_DELETED)
   {
     if (cancel_token.expired())
       ec = boost::asio::error::operation_aborted;
     else
       ec = boost::asio::error::connection_reset;
   }
   else if (ec.value() == ERROR_PORT_UNREACHABLE)
   {
     ec = boost::asio::error::connection_refused;
   }
 }
 
 #else // defined(BOOST_ASIO_HAS_IOCP)
 
 bool non_blocking_send(socket_type s,
     const buf* bufs, size_t count, int flags,
     boost::system::error_code& ec, size_t& bytes_transferred)
 {
   for (;;)
   {
     // Write some data.
     signed_size_type bytes = socket_ops::send(s, bufs, count, flags, ec);
 
     // Check if operation succeeded.
     if (bytes >= 0)
     {
       bytes_transferred = bytes;
       return true;
     }
 
     // Retry operation if interrupted by signal.
     if (ec == boost::asio::error::interrupted)
       continue;
 
     // Check if we need to run the operation again.
     if (ec == boost::asio::error::would_block
         || ec == boost::asio::error::try_again)
       return false;
 
     // Operation failed.
     bytes_transferred = 0;
     return true;
   }
 }
 
 bool non_blocking_send1(socket_type s,
     const void* data, size_t size, int flags,
     boost::system::error_code& ec, size_t& bytes_transferred)
 {
   for (;;)
   {
     // Write some data.
     signed_size_type bytes = socket_ops::send1(s, data, size, flags, ec);
 
     // Check if operation succeeded.
     if (bytes >= 0)
     {
       bytes_transferred = bytes;
       return true;
     }
 
     // Retry operation if interrupted by signal.
     if (ec == boost::asio::error::interrupted)
       continue;
 
     // Check if we need to run the operation again.
     if (ec == boost::asio::error::would_block
         || ec == boost::asio::error::try_again)
       return false;
 
     // Operation failed.
     bytes_transferred = 0;
     return true;
   }
 }
 
 #endif // defined(BOOST_ASIO_HAS_IOCP)
 
 signed_size_type sendto(socket_type s, const buf* bufs,
     size_t count, int flags, const void* addr,
     std::size_t addrlen, boost::system::error_code& ec)
 {
 #if defined(BOOST_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,
         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 = boost::asio::error::connection_reset;
   else if (ec.value() == ERROR_PORT_UNREACHABLE)
     ec = boost::asio::error::connection_refused;
   if (result != 0)
     return socket_error_retval;
   boost::asio::error::clear(ec);
   return bytes_transferred;
 #else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   msghdr msg = msghdr();
   init_msghdr_msg_name(msg.msg_name, addr);
   msg.msg_namelen = static_cast<int>(addrlen);
   msg.msg_iov = const_cast<buf*>(bufs);
   msg.msg_iovlen = static_cast<int>(count);
 #if defined(BOOST_ASIO_HAS_MSG_NOSIGNAL)
   flags |= MSG_NOSIGNAL;
 #endif // defined(BOOST_ASIO_HAS_MSG_NOSIGNAL)
   signed_size_type result = ::sendmsg(s, &msg, flags);
   get_last_error(ec, result < 0);
   return result;
 #endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 }
 
 template <typename SockLenType>
 inline signed_size_type call_sendto(SockLenType msghdr::*,
     socket_type s, const void* data, size_t size, int flags,
     const void* addr, std::size_t 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 void* addr,
     std::size_t addrlen, boost::system::error_code& ec)
 {
 #if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   // Send the data.
   WSABUF buf;
   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,
       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 = boost::asio::error::connection_reset;
   else if (ec.value() == ERROR_PORT_UNREACHABLE)
     ec = boost::asio::error::connection_refused;
   if (result != 0)
     return socket_error_retval;
   boost::asio::error::clear(ec);
   return bytes_transferred;
 #else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 #if defined(BOOST_ASIO_HAS_MSG_NOSIGNAL)
   flags |= MSG_NOSIGNAL;
 #endif // defined(BOOST_ASIO_HAS_MSG_NOSIGNAL)
   signed_size_type result = call_sendto(&msghdr::msg_namelen,
       s, data, size, flags, addr, addrlen);
   get_last_error(ec, result < 0);
   return result;
 #endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 }
 
 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, boost::system::error_code& ec)
 {
   if (s == invalid_socket)
   {
     ec = boost::asio::error::bad_descriptor;
     return 0;
   }
 
   // Write some data.
   for (;;)
   {
     // Try to complete the operation without blocking.
     signed_size_type bytes = socket_ops::sendto(
         s, bufs, count, flags, addr, addrlen, ec);
 
     // Check if operation succeeded.
     if (bytes >= 0)
       return bytes;
 
     // Operation failed.
     if ((state & user_set_non_blocking)
         || (ec != boost::asio::error::would_block
           && ec != boost::asio::error::try_again))
       return 0;
 
     // Wait for socket to become ready.
     if (socket_ops::poll_write(s, 0, -1, ec) < 0)
       return 0;
   }
 }
 
 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, boost::system::error_code& ec)
 {
   if (s == invalid_socket)
   {
     ec = boost::asio::error::bad_descriptor;
     return 0;
   }
 
   // Write some data.
   for (;;)
   {
     // Try to complete the operation without blocking.
     signed_size_type bytes = socket_ops::sendto1(
         s, data, size, flags, addr, addrlen, ec);
 
     // Check if operation succeeded.
     if (bytes >= 0)
       return bytes;
 
     // Operation failed.
     if ((state & user_set_non_blocking)
         || (ec != boost::asio::error::would_block
           && ec != boost::asio::error::try_again))
       return 0;
 
     // Wait for socket to become ready.
     if (socket_ops::poll_write(s, 0, -1, ec) < 0)
       return 0;
   }
 }
 
 #if !defined(BOOST_ASIO_HAS_IOCP)
 
 bool non_blocking_sendto(socket_type s,
     const buf* bufs, size_t count, int flags,
     const void* addr, std::size_t addrlen,
     boost::system::error_code& ec, size_t& bytes_transferred)
 {
   for (;;)
   {
     // Write some data.
     signed_size_type bytes = socket_ops::sendto(
         s, bufs, count, flags, addr, addrlen, ec);
 
     // Check if operation succeeded.
     if (bytes >= 0)
     {
       bytes_transferred = bytes;
       return true;
     }
 
     // Retry operation if interrupted by signal.
     if (ec == boost::asio::error::interrupted)
       continue;
 
     // Check if we need to run the operation again.
     if (ec == boost::asio::error::would_block
         || ec == boost::asio::error::try_again)
       return false;
 
     // Operation failed.
     bytes_transferred = 0;
     return true;
   }
 }
 
 bool non_blocking_sendto1(socket_type s,
     const void* data, size_t size, int flags,
     const void* addr, std::size_t addrlen,
     boost::system::error_code& ec, size_t& bytes_transferred)
 {
   for (;;)
   {
     // Write some data.
     signed_size_type bytes = socket_ops::sendto1(
         s, data, size, flags, addr, addrlen, ec);
 
     // Check if operation succeeded.
     if (bytes >= 0)
     {
       bytes_transferred = bytes;
       return true;
     }
 
     // Retry operation if interrupted by signal.
     if (ec == boost::asio::error::interrupted)
       continue;
 
     // Check if we need to run the operation again.
     if (ec == boost::asio::error::would_block
         || ec == boost::asio::error::try_again)
       return false;
 
     // Operation failed.
     bytes_transferred = 0;
     return true;
   }
 }
 
 #endif // !defined(BOOST_ASIO_HAS_IOCP)
 
 socket_type socket(int af, int type, int protocol,
     boost::system::error_code& ec)
 {
 #if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   socket_type s = ::WSASocketW(af, type, protocol, 0, 0, WSA_FLAG_OVERLAPPED);
   get_last_error(ec, s == invalid_socket);
   if (s == invalid_socket)
     return s;
 
   if (af == BOOST_ASIO_OS_DEF(AF_INET6))
   {
     // Try to enable the POSIX default behaviour of having IPV6_V6ONLY set to
     // false. This will only succeed on Windows Vista and later versions of
     // Windows, where a dual-stack IPv4/v6 implementation is available.
     DWORD optval = 0;
     ::setsockopt(s, IPPROTO_IPV6, IPV6_V6ONLY,
         reinterpret_cast<const char*>(&optval), sizeof(optval));
   }
 
   return s;
 #elif defined(__MACH__) && defined(__APPLE__) || defined(__FreeBSD__)
   socket_type s = ::socket(af, type, protocol);
   get_last_error(ec, s == invalid_socket);
   if (s == invalid_socket)
     return s;
 
   int optval = 1;
   int result = ::setsockopt(s, SOL_SOCKET,
       SO_NOSIGPIPE, &optval, sizeof(optval));
   get_last_error(ec, result != 0);
   if (result != 0)
   {
     ::close(s);
     return invalid_socket;
   }
 
   return s;
 #else
   int s = ::socket(af, type, protocol);
   get_last_error(ec, s < 0);
   return s;
 #endif
 }
 
 template <typename SockLenType>
 inline int call_setsockopt(SockLenType msghdr::*,
     socket_type s, int level, int optname,
     const void* optval, std::size_t optlen)
 {
   return ::setsockopt(s, level, optname,
       (const char*)optval, (SockLenType)optlen);
 }
 
 int setsockopt(socket_type s, state_type& state, int level, int optname,
     const void* optval, std::size_t optlen, boost::system::error_code& ec)
 {
   if (s == invalid_socket)
   {
     ec = boost::asio::error::bad_descriptor;
     return socket_error_retval;
   }
 
   if (level == custom_socket_option_level && optname == always_fail_option)
   {
     ec = boost::asio::error::invalid_argument;
     return socket_error_retval;
   }
 
   if (level == custom_socket_option_level
       && optname == enable_connection_aborted_option)
   {
     if (optlen != sizeof(int))
     {
       ec = boost::asio::error::invalid_argument;
       return socket_error_retval;
     }
 
     if (*static_cast<const int*>(optval))
       state |= enable_connection_aborted;
     else
       state &= ~enable_connection_aborted;
     boost::asio::error::clear(ec);
     return 0;
   }
 
   if (level == SOL_SOCKET && optname == SO_LINGER)
     state |= user_set_linger;
 
 #if defined(__BORLANDC__)
   // Mysteriously, using the getsockopt and setsockopt functions directly with
   // Borland C++ results in incorrect values being set and read. The bug can be
   // worked around by using function addresses resolved with GetProcAddress.
   if (HMODULE winsock_module = ::GetModuleHandleA("ws2_32"))
   {
     typedef int (WSAAPI *sso_t)(SOCKET, int, int, const char*, int);
     if (sso_t sso = (sso_t)::GetProcAddress(winsock_module, "setsockopt"))
     {
       int result = sso(s, level, optname,
             reinterpret_cast<const char*>(optval),
             static_cast<int>(optlen));
       get_last_error(ec, result != 0);
       return result;
     }
   }
   ec = boost::asio::error::fault;
   return socket_error_retval;
 #else // defined(__BORLANDC__)
   int result = call_setsockopt(&msghdr::msg_namelen,
         s, level, optname, optval, optlen);
   get_last_error(ec, result != 0);
   if (result == 0)
   {
 #if defined(__MACH__) && defined(__APPLE__) \
   || defined(__NetBSD__) || defined(__FreeBSD__) \
   || defined(__OpenBSD__) || defined(__QNX__)
     // To implement portable behaviour for SO_REUSEADDR with UDP sockets we
     // need to also set SO_REUSEPORT on BSD-based platforms.
     if ((state & datagram_oriented)
         && level == SOL_SOCKET && optname == SO_REUSEADDR)
     {
       call_setsockopt(&msghdr::msg_namelen, s,
           SOL_SOCKET, SO_REUSEPORT, optval, optlen);
     }
 #endif
   }
 
   return result;
 #endif // defined(__BORLANDC__)
 }
 
 template <typename SockLenType>
 inline int call_getsockopt(SockLenType msghdr::*,
     socket_type s, int level, int optname,
     void* optval, std::size_t* optlen)
 {
   SockLenType tmp_optlen = (SockLenType)*optlen;
   int result = ::getsockopt(s, level, optname, (char*)optval, &tmp_optlen);
   *optlen = (std::size_t)tmp_optlen;
   return result;
 }
 
 int getsockopt(socket_type s, state_type state, int level, int optname,
     void* optval, size_t* optlen, boost::system::error_code& ec)
 {
   if (s == invalid_socket)
   {
     ec = boost::asio::error::bad_descriptor;
     return socket_error_retval;
   }
 
   if (level == custom_socket_option_level && optname == always_fail_option)
   {
     ec = boost::asio::error::invalid_argument;
     return socket_error_retval;
   }
 
   if (level == custom_socket_option_level
       && optname == enable_connection_aborted_option)
   {
     if (*optlen != sizeof(int))
     {
       ec = boost::asio::error::invalid_argument;
       return socket_error_retval;
     }
 
     *static_cast<int*>(optval) = (state & enable_connection_aborted) ? 1 : 0;
     boost::asio::error::clear(ec);
     return 0;
   }
 
 #if defined(__BORLANDC__)
   // Mysteriously, using the getsockopt and setsockopt functions directly with
   // Borland C++ results in incorrect values being set and read. The bug can be
   // worked around by using function addresses resolved with GetProcAddress.
   if (HMODULE winsock_module = ::GetModuleHandleA("ws2_32"))
   {
     typedef int (WSAAPI *gso_t)(SOCKET, int, int, char*, int*);
     if (gso_t gso = (gso_t)::GetProcAddress(winsock_module, "getsockopt"))
     {
       int tmp_optlen = static_cast<int>(*optlen);
       int result = gso(s, level, optname,
             reinterpret_cast<char*>(optval), &tmp_optlen);
       get_last_error(ec, result != 0);
       *optlen = static_cast<size_t>(tmp_optlen);
       if (result != 0 && level == IPPROTO_IPV6 && optname == IPV6_V6ONLY
           && ec.value() == WSAENOPROTOOPT && *optlen == sizeof(DWORD))
       {
         // Dual-stack IPv4/v6 sockets, and the IPV6_V6ONLY socket option, are
         // only supported on Windows Vista and later. To simplify program logic
         // we will fake success of getting this option and specify that the
         // 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;
         boost::asio::error::clear(ec);
       }
       return result;
     }
   }
   ec = boost::asio::error::fault;
   return socket_error_retval;
 #elif defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   int result = call_getsockopt(&msghdr::msg_namelen,
         s, level, optname, optval, optlen);
   get_last_error(ec, result != 0);
   if (result != 0 && level == IPPROTO_IPV6 && optname == IPV6_V6ONLY
       && ec.value() == WSAENOPROTOOPT && *optlen == sizeof(DWORD))
   {
     // Dual-stack IPv4/v6 sockets, and the IPV6_V6ONLY socket option, are only
     // supported on Windows Vista and later. To simplify program logic we will
     // fake success of getting this option and specify that the 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;
     boost::asio::error::clear(ec);
   }
   return result;
 #else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   int result = call_getsockopt(&msghdr::msg_namelen,
         s, level, optname, optval, optlen);
   get_last_error(ec, result != 0);
 #if defined(__linux__)
   if (result == 0 && level == SOL_SOCKET && *optlen == sizeof(int)
       && (optname == SO_SNDBUF || optname == SO_RCVBUF))
   {
     // On Linux, setting SO_SNDBUF or SO_RCVBUF to N actually causes the kernel
     // to set the buffer size to N*2. Linux puts additional stuff into the
     // buffers so that only about half is actually available to the application.
     // The retrieved value is divided by 2 here to make it appear as though the
     // correct value has been set.
     *static_cast<int*>(optval) /= 2;
   }
 #endif // defined(__linux__)
   return result;
 #endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 }
 
 template <typename SockLenType>
 inline int call_getpeername(SockLenType msghdr::*,
     socket_type s, void* addr, std::size_t* addrlen)
 {
   SockLenType tmp_addrlen = (SockLenType)*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, void* addr, std::size_t* addrlen,
     bool cached, boost::system::error_code& ec)
 {
   if (s == invalid_socket)
   {
     ec = boost::asio::error::bad_descriptor;
     return socket_error_retval;
   }
 
 #if defined(BOOST_ASIO_WINDOWS) && !defined(BOOST_ASIO_WINDOWS_APP) \
   || defined(__CYGWIN__)
   if (cached)
   {
     // Check if socket is still connected.
     DWORD connect_time = 0;
     size_t connect_time_len = sizeof(connect_time);
     if (socket_ops::getsockopt(s, 0, SOL_SOCKET, SO_CONNECT_TIME,
           &connect_time, &connect_time_len, ec) == socket_error_retval)
     {
       return socket_error_retval;
     }
     if (connect_time == 0xFFFFFFFF)
     {
       ec = boost::asio::error::not_connected;
       return socket_error_retval;
     }
 
     // The cached value is still valid.
     boost::asio::error::clear(ec);
     return 0;
   }
 #else // defined(BOOST_ASIO_WINDOWS) && !defined(BOOST_ASIO_WINDOWS_APP)
       // || defined(__CYGWIN__)
   (void)cached;
 #endif // defined(BOOST_ASIO_WINDOWS) && !defined(BOOST_ASIO_WINDOWS_APP)
        // || defined(__CYGWIN__)
 
   int result = call_getpeername(&msghdr::msg_namelen, s, addr, addrlen);
   get_last_error(ec, result != 0);
   return result;
 }
 
 template <typename SockLenType>
 inline int call_getsockname(SockLenType msghdr::*,
     socket_type s, void* addr, std::size_t* addrlen)
 {
   SockLenType tmp_addrlen = (SockLenType)*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, void* addr,
     std::size_t* addrlen, boost::system::error_code& ec)
 {
   if (s == invalid_socket)
   {
     ec = boost::asio::error::bad_descriptor;
     return socket_error_retval;
   }
 
   int result = call_getsockname(&msghdr::msg_namelen, s, addr, addrlen);
   get_last_error(ec, result != 0);
   return result;
 }
 
 int ioctl(socket_type s, state_type& state, int cmd,
     ioctl_arg_type* arg, boost::system::error_code& ec)
 {
   if (s == invalid_socket)
   {
     ec = boost::asio::error::bad_descriptor;
     return socket_error_retval;
   }
 
 #if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   int result = ::ioctlsocket(s, cmd, arg);
 #elif defined(__MACH__) && defined(__APPLE__) \
   || defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__)
   int result = ::ioctl(s, static_cast<unsigned int>(cmd), arg);
 #else
   int result = ::ioctl(s, cmd, arg);
 #endif
   get_last_error(ec, result < 0);
   if (result >= 0)
   {
     // When updating the non-blocking mode we always perform the ioctl syscall,
     // even if the flags would otherwise indicate that the socket is already in
     // the correct state. This ensures that the underlying socket is put into
     // the state that has been requested by the user. If the ioctl syscall was
     // successful then we need to update the flags to match.
     if (cmd == static_cast<int>(FIONBIO))
     {
       if (*arg)
       {
         state |= user_set_non_blocking;
       }
       else
       {
         // Clearing the non-blocking mode always overrides any internally-set
         // non-blocking flag. Any subsequent asynchronous operations will need
         // to re-enable non-blocking I/O.
         state &= ~(user_set_non_blocking | internal_non_blocking);
       }
     }
   }
 
   return result;
 }
 
 int select(int nfds, fd_set* readfds, fd_set* writefds,
     fd_set* exceptfds, timeval* timeout, boost::system::error_code& ec)
 {
 #if defined(__EMSCRIPTEN__)
   exceptfds = 0;
 #endif // defined(__EMSCRIPTEN__)
 #if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   if (!readfds && !writefds && !exceptfds && timeout)
   {
     DWORD milliseconds = timeout->tv_sec * 1000 + timeout->tv_usec / 1000;
     if (milliseconds == 0)
       milliseconds = 1; // Force context switch.
     ::Sleep(milliseconds);
     boost::asio::error::clear(ec);
     return 0;
   }
 
   // The select() call allows timeout values measured in microseconds, but the
   // system clock (as wrapped by boost::posix_time::microsec_clock) typically
   // has a resolution of 10 milliseconds. This can lead to a spinning select
   // reactor, meaning increased CPU usage, when waiting for the earliest
   // scheduled timeout if it's less than 10 milliseconds away. To avoid a tight
   // spin we'll use a minimum timeout of 1 millisecond.
   if (timeout && timeout->tv_sec == 0
       && timeout->tv_usec > 0 && timeout->tv_usec < 1000)
     timeout->tv_usec = 1000;
 #endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 
 #if defined(__hpux) && defined(__SELECT)
   timespec ts;
   ts.tv_sec = timeout ? timeout->tv_sec : 0;
   ts.tv_nsec = timeout ? timeout->tv_usec * 1000 : 0;
   int result = ::pselect(nfds, readfds,
         writefds, exceptfds, timeout ? &ts : 0, 0);
 #else
   int result = ::select(nfds, readfds, writefds, exceptfds, timeout);
 #endif
   get_last_error(ec, result < 0);
   return result;
 }
 
 int poll_read(socket_type s, state_type state,
     int msec, boost::system::error_code& ec)
 {
   if (s == invalid_socket)
   {
     ec = boost::asio::error::bad_descriptor;
     return socket_error_retval;
   }
 
 #if defined(BOOST_ASIO_WINDOWS) \
   || defined(__CYGWIN__) \
   || defined(__SYMBIAN32__)
   fd_set fds;
   FD_ZERO(&fds);
   FD_SET(s, &fds);
   timeval timeout_obj;
   timeval* timeout;
   if (state & user_set_non_blocking)
   {
     timeout_obj.tv_sec = 0;
     timeout_obj.tv_usec = 0;
     timeout = &timeout_obj;
   }
   else if (msec >= 0)
   {
     timeout_obj.tv_sec = msec / 1000;
     timeout_obj.tv_usec = (msec % 1000) * 1000;
     timeout = &timeout_obj;
   }
   else
     timeout = 0;
   int result = ::select(s + 1, &fds, 0, 0, timeout);
   get_last_error(ec, result < 0);
 #else // defined(BOOST_ASIO_WINDOWS)
       // || defined(__CYGWIN__)
       // || defined(__SYMBIAN32__)
   pollfd fds;
   fds.fd = s;
   fds.events = POLLIN;
   fds.revents = 0;
   int timeout = (state & user_set_non_blocking) ? 0 : msec;
   int result = ::poll(&fds, 1, timeout);
   get_last_error(ec, result < 0);
 #endif // defined(BOOST_ASIO_WINDOWS)
        // || defined(__CYGWIN__)
        // || defined(__SYMBIAN32__)
   if (result == 0)
     if (state & user_set_non_blocking)
       ec = boost::asio::error::would_block;
   return result;
 }
 
 int poll_write(socket_type s, state_type state,
     int msec, boost::system::error_code& ec)
 {
   if (s == invalid_socket)
   {
     ec = boost::asio::error::bad_descriptor;
     return socket_error_retval;
   }
 
 #if defined(BOOST_ASIO_WINDOWS) \
   || defined(__CYGWIN__) \
   || defined(__SYMBIAN32__)
   fd_set fds;
   FD_ZERO(&fds);
   FD_SET(s, &fds);
   timeval timeout_obj;
   timeval* timeout;
   if (state & user_set_non_blocking)
   {
     timeout_obj.tv_sec = 0;
     timeout_obj.tv_usec = 0;
     timeout = &timeout_obj;
   }
   else if (msec >= 0)
   {
     timeout_obj.tv_sec = msec / 1000;
     timeout_obj.tv_usec = (msec % 1000) * 1000;
     timeout = &timeout_obj;
   }
   else
     timeout = 0;
   int result = ::select(s + 1, 0, &fds, 0, timeout);
   get_last_error(ec, result < 0);
 #else // defined(BOOST_ASIO_WINDOWS)
       // || defined(__CYGWIN__)
       // || defined(__SYMBIAN32__)
   pollfd fds;
   fds.fd = s;
   fds.events = POLLOUT;
   fds.revents = 0;
   int timeout = (state & user_set_non_blocking) ? 0 : msec;
   int result = ::poll(&fds, 1, timeout);
   get_last_error(ec, result < 0);
 #endif // defined(BOOST_ASIO_WINDOWS)
        // || defined(__CYGWIN__)
        // || defined(__SYMBIAN32__)
   if (result == 0)
     if (state & user_set_non_blocking)
       ec = boost::asio::error::would_block;
   return result;
 }
 
 int poll_error(socket_type s, state_type state,
     int msec, boost::system::error_code& ec)
 {
   if (s == invalid_socket)
   {
     ec = boost::asio::error::bad_descriptor;
     return socket_error_retval;
   }
 
 #if defined(BOOST_ASIO_WINDOWS) \
   || defined(__CYGWIN__) \
   || defined(__SYMBIAN32__)
   fd_set fds;
   FD_ZERO(&fds);
   FD_SET(s, &fds);
   timeval timeout_obj;
   timeval* timeout;
   if (state & user_set_non_blocking)
   {
     timeout_obj.tv_sec = 0;
     timeout_obj.tv_usec = 0;
     timeout = &timeout_obj;
   }
   else if (msec >= 0)
   {
     timeout_obj.tv_sec = msec / 1000;
     timeout_obj.tv_usec = (msec % 1000) * 1000;
     timeout = &timeout_obj;
   }
   else
     timeout = 0;
   int result = ::select(s + 1, 0, 0, &fds, timeout);
   get_last_error(ec, result < 0);
 #else // defined(BOOST_ASIO_WINDOWS)
       // || defined(__CYGWIN__)
       // || defined(__SYMBIAN32__)
   pollfd fds;
   fds.fd = s;
   fds.events = POLLPRI | POLLERR | POLLHUP;
   fds.revents = 0;
   int timeout = (state & user_set_non_blocking) ? 0 : msec;
   int result = ::poll(&fds, 1, timeout);
   get_last_error(ec, result < 0);
 #endif // defined(BOOST_ASIO_WINDOWS)
        // || defined(__CYGWIN__)
        // || defined(__SYMBIAN32__)
   if (result == 0)
     if (state & user_set_non_blocking)
       ec = boost::asio::error::would_block;
   return result;
 }
 
 int poll_connect(socket_type s, int msec, boost::system::error_code& ec)
 {
   if (s == invalid_socket)
   {
     ec = boost::asio::error::bad_descriptor;
     return socket_error_retval;
   }
 
 #if defined(BOOST_ASIO_WINDOWS) \
   || defined(__CYGWIN__) \
   || defined(__SYMBIAN32__)
   fd_set write_fds;
   FD_ZERO(&write_fds);
   FD_SET(s, &write_fds);
   fd_set except_fds;
   FD_ZERO(&except_fds);
   FD_SET(s, &except_fds);
   timeval timeout_obj;
   timeval* timeout;
   if (msec >= 0)
   {
     timeout_obj.tv_sec = msec / 1000;
     timeout_obj.tv_usec = (msec % 1000) * 1000;
     timeout = &timeout_obj;
   }
   else
     timeout = 0;
   int result = ::select(s + 1, 0, &write_fds, &except_fds, timeout);
   get_last_error(ec, result < 0);
   return result;
 #else // defined(BOOST_ASIO_WINDOWS)
       // || defined(__CYGWIN__)
       // || defined(__SYMBIAN32__)
   pollfd fds;
   fds.fd = s;
   fds.events = POLLOUT;
   fds.revents = 0;
   int result = ::poll(&fds, 1, msec);
   get_last_error(ec, result < 0);
   return result;
 #endif // defined(BOOST_ASIO_WINDOWS)
        // || defined(__CYGWIN__)
        // || defined(__SYMBIAN32__)
 }
 
 #endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME)
 
 const char* inet_ntop(int af, const void* src, char* dest, size_t length,
     unsigned long scope_id, boost::system::error_code& ec)
 {
   clear_last_error();
 #if defined(BOOST_ASIO_WINDOWS_RUNTIME)
   using namespace std; // For sprintf.
   const unsigned char* bytes = static_cast<const unsigned char*>(src);
   if (af == BOOST_ASIO_OS_DEF(AF_INET))
   {
     sprintf_s(dest, length, "%u.%u.%u.%u",
         bytes[0], bytes[1], bytes[2], bytes[3]);
     return dest;
   }
   else if (af == BOOST_ASIO_OS_DEF(AF_INET6))
   {
     size_t n = 0, b = 0, z = 0;
     while (n < length && b < 16)
     {
       if (bytes[b] == 0 && bytes[b + 1] == 0 && z == 0)
       {
         do b += 2; while (b < 16 && bytes[b] == 0 && bytes[b + 1] == 0);
         n += sprintf_s(dest + n, length - n, ":%s", b < 16 ? "" : ":"), ++z;
       }
       else
       {
         n += sprintf_s(dest + n, length - n, "%s%x", b ? ":" : "",
             (static_cast<u_long_type>(bytes[b]) << 8) | bytes[b + 1]);
         b += 2;
       }
     }
     if (scope_id)
       n += sprintf_s(dest + n, length - n, "%%%lu", scope_id);
     return dest;
   }
   else
   {
     ec = boost::asio::error::address_family_not_supported;
     return 0;
   }
 #elif defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   using namespace std; // For memcpy.
 
   if (af != BOOST_ASIO_OS_DEF(AF_INET) && af != BOOST_ASIO_OS_DEF(AF_INET6))
   {
     ec = boost::asio::error::address_family_not_supported;
     return 0;
   }
 
   union
   {
     socket_addr_type base;
     sockaddr_storage_type storage;
     sockaddr_in4_type v4;
     sockaddr_in6_type v6;
   } address;
   DWORD address_length;
   if (af == BOOST_ASIO_OS_DEF(AF_INET))
   {
     address_length = sizeof(sockaddr_in4_type);
     address.v4.sin_family = BOOST_ASIO_OS_DEF(AF_INET);
     address.v4.sin_port = 0;
     memcpy(&address.v4.sin_addr, src, sizeof(in4_addr_type));
   }
   else // AF_INET6
   {
     address_length = sizeof(sockaddr_in6_type);
     address.v6.sin6_family = BOOST_ASIO_OS_DEF(AF_INET6);
     address.v6.sin6_port = 0;
     address.v6.sin6_flowinfo = 0;
     address.v6.sin6_scope_id = scope_id;
     memcpy(&address.v6.sin6_addr, src, sizeof(in6_addr_type));
   }
 
   DWORD string_length = static_cast<DWORD>(length);
 #if defined(BOOST_NO_ANSI_APIS) || (defined(_MSC_VER) && (_MSC_VER >= 1800))
   LPWSTR string_buffer = (LPWSTR)_alloca(length * sizeof(WCHAR));
   int result = ::WSAAddressToStringW(&address.base,
         address_length, 0, string_buffer, &string_length);
   get_last_error(ec, true);
   ::WideCharToMultiByte(CP_ACP, 0, string_buffer, -1,
       dest, static_cast<int>(length), 0, 0);
 #else
   int result = ::WSAAddressToStringA(&address.base,
       address_length, 0, dest, &string_length);
   get_last_error(ec, true);
 #endif
 
   // Windows may set error code on success.
   if (result != socket_error_retval)
     boost::asio::error::clear(ec);
 
   // Windows may not set an error code on failure.
   else if (result == socket_error_retval && !ec)
     ec = boost::asio::error::invalid_argument;
 
   return result == socket_error_retval ? 0 : dest;
 #else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   const char* result = ::inet_ntop(af, src, dest, static_cast<int>(length));
   get_last_error(ec, true);
   if (result == 0 && !ec)
     ec = boost::asio::error::invalid_argument;
   if (result != 0 && af == BOOST_ASIO_OS_DEF(AF_INET6) && scope_id != 0)
   {
     using namespace std; // For strcat and sprintf.
     char if_name[(IF_NAMESIZE > 21 ? IF_NAMESIZE : 21) + 1] = "%";
     const in6_addr_type* ipv6_address = static_cast<const in6_addr_type*>(src);
     bool is_link_local = ((ipv6_address->s6_addr[0] == 0xfe)
         && ((ipv6_address->s6_addr[1] & 0xc0) == 0x80));
     bool is_multicast_link_local = ((ipv6_address->s6_addr[0] == 0xff)
         && ((ipv6_address->s6_addr[1] & 0x0f) == 0x02));
     if ((!is_link_local && !is_multicast_link_local)
         || if_indextoname(static_cast<unsigned>(scope_id), if_name + 1) == 0)
 #if defined(BOOST_ASIO_HAS_SNPRINTF)
       snprintf(if_name + 1, sizeof(if_name) - 1, "%lu", scope_id);
 #else // defined(BOOST_ASIO_HAS_SNPRINTF)
       sprintf(if_name + 1, "%lu", scope_id);
 #endif // defined(BOOST_ASIO_HAS_SNPRINTF)
     strcat(dest, if_name);
   }
   return result;
 #endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 }
 
 int inet_pton(int af, const char* src, void* dest,
     unsigned long* scope_id, boost::system::error_code& ec)
 {
   clear_last_error();
 #if defined(BOOST_ASIO_WINDOWS_RUNTIME)
   using namespace std; // For sscanf.
   unsigned char* bytes = static_cast<unsigned char*>(dest);
   if (af == BOOST_ASIO_OS_DEF(AF_INET))
   {
     unsigned int b0, b1, b2, b3;
     if (sscanf_s(src, "%u.%u.%u.%u", &b0, &b1, &b2, &b3) != 4)
     {
       ec = boost::asio::error::invalid_argument;
       return -1;
     }
     if (b0 > 255 || b1 > 255 || b2 > 255 || b3 > 255)
     {
       ec = boost::asio::error::invalid_argument;
       return -1;
     }
     bytes[0] = static_cast<unsigned char>(b0);
     bytes[1] = static_cast<unsigned char>(b1);
     bytes[2] = static_cast<unsigned char>(b2);
     bytes[3] = static_cast<unsigned char>(b3);
     boost::asio::error::clear(ec);
     return 1;
   }
   else if (af == BOOST_ASIO_OS_DEF(AF_INET6))
   {
     unsigned char* bytes = static_cast<unsigned char*>(dest);
     std::memset(bytes, 0, 16);
     unsigned char back_bytes[16] = { 0 };
     int num_front_bytes = 0, num_back_bytes = 0;
     const char* p = src;
 
     enum { fword, fcolon, bword, scope, done } state = fword;
     unsigned long current_word = 0;
     while (state != done)
     {
       if (current_word > 0xFFFF)
       {
         ec = boost::asio::error::invalid_argument;
         return -1;
       }
 
       switch (state)
       {
       case fword:
         if (*p >= '0' && *p <= '9')
           current_word = current_word * 16 + *p++ - '0';
         else if (*p >= 'a' && *p <= 'f')
           current_word = current_word * 16 + *p++ - 'a' + 10;
         else if (*p >= 'A' && *p <= 'F')
           current_word = current_word * 16 + *p++ - 'A' + 10;
         else
         {
           if (num_front_bytes == 16)
           {
             ec = boost::asio::error::invalid_argument;
             return -1;
           }
 
           bytes[num_front_bytes++] = (current_word >> 8) & 0xFF;
           bytes[num_front_bytes++] = current_word & 0xFF;
           current_word = 0;
 
           if (*p == ':')
             state = fcolon, ++p;
           else if (*p == '%')
             state = scope, ++p;
           else if (*p == 0)
             state = done;
           else
           {
             ec = boost::asio::error::invalid_argument;
             return -1;
           }
         }
         break;
 
       case fcolon:
         if (*p == ':')
           state = bword, ++p;
         else
           state = fword;
         break;
 
       case bword:
         if (*p >= '0' && *p <= '9')
           current_word = current_word * 16 + *p++ - '0';
         else if (*p >= 'a' && *p <= 'f')
           current_word = current_word * 16 + *p++ - 'a' + 10;
         else if (*p >= 'A' && *p <= 'F')
           current_word = current_word * 16 + *p++ - 'A' + 10;
         else
         {
           if (num_front_bytes + num_back_bytes == 16)
           {
             ec = boost::asio::error::invalid_argument;
             return -1;
           }
 
           back_bytes[num_back_bytes++] = (current_word >> 8) & 0xFF;
           back_bytes[num_back_bytes++] = current_word & 0xFF;
           current_word = 0;
 
           if (*p == ':')
             state = bword, ++p;
           else if (*p == '%')
             state = scope, ++p;
           else if (*p == 0)
             state = done;
           else
           {
             ec = boost::asio::error::invalid_argument;
             return -1;
           }
         }
         break;
 
       case scope:
         if (*p >= '0' && *p <= '9')
           current_word = current_word * 10 + *p++ - '0';
         else if (*p == 0)
           *scope_id = current_word, state = done;
         else
         {
           ec = boost::asio::error::invalid_argument;
           return -1;
         }
         break;
 
       default:
         break;
       }
     }
 
     for (int i = 0; i < num_back_bytes; ++i)
       bytes[16 - num_back_bytes + i] = back_bytes[i];
 
     boost::asio::error::clear(ec);
     return 1;
   }
   else
   {
     ec = boost::asio::error::address_family_not_supported;
     return -1;
   }
 #elif defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   using namespace std; // For memcpy and strcmp.
 
   if (af != BOOST_ASIO_OS_DEF(AF_INET) && af != BOOST_ASIO_OS_DEF(AF_INET6))
   {
     ec = boost::asio::error::address_family_not_supported;
     return -1;
   }
 
   union
   {
     socket_addr_type base;
     sockaddr_storage_type storage;
     sockaddr_in4_type v4;
     sockaddr_in6_type v6;
   } address;
   int address_length = sizeof(sockaddr_storage_type);
 #if defined(BOOST_NO_ANSI_APIS) || (defined(_MSC_VER) && (_MSC_VER >= 1800))
   int num_wide_chars = static_cast<int>(strlen(src)) + 1;
   LPWSTR wide_buffer = (LPWSTR)_alloca(num_wide_chars * sizeof(WCHAR));
   ::MultiByteToWideChar(CP_ACP, 0, src, -1, wide_buffer, num_wide_chars);
   int result = ::WSAStringToAddressW(wide_buffer,
       af, 0, &address.base, &address_length);
   get_last_error(ec, true);
 #else
   int result = ::WSAStringToAddressA(const_cast<char*>(src),
       af, 0, &address.base, &address_length);
   get_last_error(ec, true);
 #endif
 
   if (af == BOOST_ASIO_OS_DEF(AF_INET))
   {
     if (result != socket_error_retval)
     {
       memcpy(dest, &address.v4.sin_addr, sizeof(in4_addr_type));
       boost::asio::error::clear(ec);
     }
     else if (strcmp(src, "255.255.255.255") == 0)
     {
       static_cast<in4_addr_type*>(dest)->s_addr = INADDR_NONE;
       boost::asio::error::clear(ec);
     }
   }
   else // AF_INET6
   {
     if (result != socket_error_retval)
     {
       memcpy(dest, &address.v6.sin6_addr, sizeof(in6_addr_type));
       if (scope_id)
         *scope_id = address.v6.sin6_scope_id;
       boost::asio::error::clear(ec);
     }
   }
 
   // Windows may not set an error code on failure.
   if (result == socket_error_retval && !ec)
     ec = boost::asio::error::invalid_argument;
 
   if (result != socket_error_retval)
     boost::asio::error::clear(ec);
 
   return result == socket_error_retval ? -1 : 1;
 #else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   using namespace std; // For strchr, memcpy and atoi.
 
   // On some platforms, inet_pton fails if an address string contains a scope
   // id. Detect and remove the scope id before passing the string to inet_pton.
   const bool is_v6 = (af == BOOST_ASIO_OS_DEF(AF_INET6));
   const char* if_name = is_v6 ? strchr(src, '%') : 0;
   char src_buf[max_addr_v6_str_len + 1];
   const char* src_ptr = src;
   if (if_name != 0)
   {
     if (if_name - src > max_addr_v6_str_len)
     {
       ec = boost::asio::error::invalid_argument;
       return 0;
     }
     memcpy(src_buf, src, if_name - src);
     src_buf[if_name - src] = 0;
     src_ptr = src_buf;
   }
 
   int result = ::inet_pton(af, src_ptr, dest);
   get_last_error(ec, true);
   if (result <= 0 && !ec)
     ec = boost::asio::error::invalid_argument;
   if (result > 0 && is_v6 && scope_id)
   {
     using namespace std; // For strchr and atoi.
     *scope_id = 0;
     if (if_name != 0)
     {
       in6_addr_type* ipv6_address = static_cast<in6_addr_type*>(dest);
       bool is_link_local = ((ipv6_address->s6_addr[0] == 0xfe)
           && ((ipv6_address->s6_addr[1] & 0xc0) == 0x80));
       bool is_multicast_link_local = ((ipv6_address->s6_addr[0] == 0xff)
           && ((ipv6_address->s6_addr[1] & 0x0f) == 0x02));
       if (is_link_local || is_multicast_link_local)
         *scope_id = if_nametoindex(if_name + 1);
       if (*scope_id == 0)
         *scope_id = atoi(if_name + 1);
     }
   }
   return result;
 #endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 }
 
 int gethostname(char* name, int namelen, boost::system::error_code& ec)
 {
 #if defined(BOOST_ASIO_WINDOWS_RUNTIME)
   try
   {
     using namespace Windows::Foundation::Collections;
     using namespace Windows::Networking;
     using namespace Windows::Networking::Connectivity;
     IVectorView<HostName^>^ hostnames = NetworkInformation::GetHostNames();
     for (unsigned i = 0; i < hostnames->Size; ++i)
     {
       HostName^ hostname = hostnames->GetAt(i);
       if (hostname->Type == HostNameType::DomainName)
       {
         std::wstring_convert<std::codecvt_utf8<wchar_t>> converter;
         std::string raw_name = converter.to_bytes(hostname->RawName->Data());
         if (namelen > 0 && raw_name.size() < static_cast<std::size_t>(namelen))
         {
           strcpy_s(name, namelen, raw_name.c_str());
           return 0;
         }
       }
     }
     return -1;
   }
   catch (Platform::Exception^ e)
   {
     ec = boost::system::error_code(e->HResult,
         boost::system::system_category());
     return -1;
   }
 #else // defined(BOOST_ASIO_WINDOWS_RUNTIME)
   int result = ::gethostname(name, namelen);
   get_last_error(ec, result != 0);
   return result;
 #endif // defined(BOOST_ASIO_WINDOWS_RUNTIME)
 }
 
 #if !defined(BOOST_ASIO_WINDOWS_RUNTIME)
 
 #if !defined(BOOST_ASIO_HAS_GETADDRINFO)
 
 // The following functions are only needed for emulation of getaddrinfo and
 // getnameinfo.
 
 inline boost::system::error_code translate_netdb_error(int error)
 {
   switch (error)
   {
   case 0:
     return boost::system::error_code();
   case HOST_NOT_FOUND:
     return boost::asio::error::host_not_found;
   case TRY_AGAIN:
     return boost::asio::error::host_not_found_try_again;
   case NO_RECOVERY:
     return boost::asio::error::no_recovery;
   case NO_DATA:
     return boost::asio::error::no_data;
   default:
     BOOST_ASIO_ASSERT(false);
     return boost::asio::error::invalid_argument;
   }
 }
 
 inline hostent* gethostbyaddr(const char* addr, int length, int af,
     hostent* result, char* buffer, int buflength, boost::system::error_code& ec)
 {
 #if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   (void)(buffer);
   (void)(buflength);
   hostent* retval = ::gethostbyaddr(addr, length, af);
   get_last_error(ec, !retval);
   if (!retval)
     return 0;
   *result = *retval;
   return retval;
 #elif defined(__sun) || defined(__QNX__)
   int error = 0;
   hostent* retval = ::gethostbyaddr_r(addr, length,
       af, result, buffer, buflength, &error);
   get_last_error(ec, !retval);
   if (error)
     ec = translate_netdb_error(error);
   return retval;
 #elif defined(__MACH__) && defined(__APPLE__)
   (void)(buffer);
   (void)(buflength);
   int error = 0;
   hostent* retval = ::getipnodebyaddr(addr, length, af, &error);
   get_last_error(ec, !retval);
   if (error)
     ec = translate_netdb_error(error);
   if (!retval)
     return 0;
   *result = *retval;
   return retval;
 #else
   hostent* retval = 0;
   int error = 0;
   clear_last_error();
   ::gethostbyaddr_r(addr, length, af, result,
       buffer, buflength, &retval, &error);
   get_last_error(ec, true);
   if (error)
     ec = translate_netdb_error(error);
   return retval;
 #endif
 }
 
 inline hostent* gethostbyname(const char* name, int af, struct hostent* result,
     char* buffer, int buflength, int ai_flags, boost::system::error_code& ec)
 {
 #if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   (void)(buffer);
   (void)(buflength);
   (void)(ai_flags);
   if (af != BOOST_ASIO_OS_DEF(AF_INET))
   {
     ec = boost::asio::error::address_family_not_supported;
     return 0;
   }
   hostent* retval = ::gethostbyname(name);
   get_last_error(ec, !retval);
   if (!retval)
     return 0;
   *result = *retval;
   return result;
 #elif defined(__sun) || defined(__QNX__)
   (void)(ai_flags);
   if (af != BOOST_ASIO_OS_DEF(AF_INET))
   {
     ec = boost::asio::error::address_family_not_supported;
     return 0;
   }
   int error = 0;
   hostent* retval = ::gethostbyname_r(name, result, buffer, buflength, &error);
   get_last_error(ec, !retval);
   if (error)
     ec = translate_netdb_error(error);
   return retval;
 #elif defined(__MACH__) && defined(__APPLE__)
   (void)(buffer);
   (void)(buflength);
   int error = 0;
   hostent* retval = ::getipnodebyname(name, af, ai_flags, &error);
   get_last_error(ec, !retval);
   if (error)
     ec = translate_netdb_error(error);
   if (!retval)
     return 0;
   *result = *retval;
   return retval;
 #else
   (void)(ai_flags);
   if (af != BOOST_ASIO_OS_DEF(AF_INET))
   {
     ec = boost::asio::error::address_family_not_supported;
     return 0;
   }
   hostent* retval = 0;
   int error = 0;
   clear_last_error();
   ::gethostbyname_r(name, result, buffer, buflength, &retval, &error);
   get_last_error(ec, true);
   if (error)
     ec = translate_netdb_error(error);
   return retval;
 #endif
 }
 
 inline void freehostent(hostent* h)
 {
 #if defined(__MACH__) && defined(__APPLE__)
   if (h)
     ::freehostent(h);
 #else
   (void)(h);
 #endif
 }
 
 // Emulation of getaddrinfo based on implementation in:
 // Stevens, W. R., UNIX Network Programming Vol. 1, 2nd Ed., Prentice-Hall 1998.
 
 struct gai_search
 {
   const char* host;
   int family;
 };
 
 inline int gai_nsearch(const char* host,
     const addrinfo_type* hints, gai_search (&search)[2])
 {
   int search_count = 0;
   if (host == 0 || host[0] == '\0')
   {
     if (hints->ai_flags & AI_PASSIVE)
     {
       // No host and AI_PASSIVE implies wildcard bind.
       switch (hints->ai_family)
       {
       case BOOST_ASIO_OS_DEF(AF_INET):
         search[search_count].host = "0.0.0.0";
         search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET);
         ++search_count;
         break;
       case BOOST_ASIO_OS_DEF(AF_INET6):
         search[search_count].host = "0::0";
         search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET6);
         ++search_count;
         break;
       case BOOST_ASIO_OS_DEF(AF_UNSPEC):
         search[search_count].host = "0::0";
         search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET6);
         ++search_count;
         search[search_count].host = "0.0.0.0";
         search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET);
         ++search_count;
         break;
       default:
         break;
       }
     }
     else
     {
       // No host and not AI_PASSIVE means connect to local host.
       switch (hints->ai_family)
       {
       case BOOST_ASIO_OS_DEF(AF_INET):
         search[search_count].host = "localhost";
         search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET);
         ++search_count;
         break;
       case BOOST_ASIO_OS_DEF(AF_INET6):
         search[search_count].host = "localhost";
         search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET6);
         ++search_count;
         break;
       case BOOST_ASIO_OS_DEF(AF_UNSPEC):
         search[search_count].host = "localhost";
         search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET6);
         ++search_count;
         search[search_count].host = "localhost";
         search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET);
         ++search_count;
         break;
       default:
         break;
       }
     }
   }
   else
   {
     // Host is specified.
     switch (hints->ai_family)
     {
     case BOOST_ASIO_OS_DEF(AF_INET):
       search[search_count].host = host;
       search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET);
       ++search_count;
       break;
     case BOOST_ASIO_OS_DEF(AF_INET6):
       search[search_count].host = host;
       search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET6);
       ++search_count;
       break;
     case BOOST_ASIO_OS_DEF(AF_UNSPEC):
       search[search_count].host = host;
       search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET6);
       ++search_count;
       search[search_count].host = host;
       search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET);
       ++search_count;
       break;
     default:
       break;
     }
   }
   return search_count;
 }
 
 template <typename T>
 inline T* gai_alloc(std::size_t size = sizeof(T))
 {
   using namespace std;
   T* p = static_cast<T*>(::operator new(size, std::nothrow));
   if (p)
     memset(p, 0, size);
   return p;
 }
 
 inline void gai_free(void* p)
 {
   ::operator delete(p);
 }
 
 inline void gai_strcpy(char* target, const char* source, std::size_t max_size)
 {
   using namespace std;
 #if defined(BOOST_ASIO_HAS_SECURE_RTL)
   strcpy_s(target, max_size, source);
 #else // defined(BOOST_ASIO_HAS_SECURE_RTL)
   *target = 0;
   if (max_size > 0)
     strncat(target, source, max_size - 1);
 #endif // defined(BOOST_ASIO_HAS_SECURE_RTL)
 }
 
 enum { gai_clone_flag = 1 << 30 };
 
 inline int gai_aistruct(addrinfo_type*** next, const addrinfo_type* hints,
     const void* addr, int family)
 {
   using namespace std;
 
   addrinfo_type* ai = gai_alloc<addrinfo_type>();
   if (ai == 0)
     return EAI_MEMORY;
 
   ai->ai_next = 0;
   **next = ai;
   *next = &ai->ai_next;
 
   ai->ai_canonname = 0;
   ai->ai_socktype = hints->ai_socktype;
   if (ai->ai_socktype == 0)
     ai->ai_flags |= gai_clone_flag;
   ai->ai_protocol = hints->ai_protocol;
   ai->ai_family = family;
 
   switch (ai->ai_family)
   {
   case BOOST_ASIO_OS_DEF(AF_INET):
     {
       sockaddr_in4_type* sinptr = gai_alloc<sockaddr_in4_type>();
       if (sinptr == 0)
         return EAI_MEMORY;
       sinptr->sin_family = BOOST_ASIO_OS_DEF(AF_INET);
       memcpy(&sinptr->sin_addr, addr, sizeof(in4_addr_type));
       ai->ai_addr = reinterpret_cast<sockaddr*>(sinptr);
       ai->ai_addrlen = sizeof(sockaddr_in4_type);
       break;
     }
   case BOOST_ASIO_OS_DEF(AF_INET6):
     {
       sockaddr_in6_type* sin6ptr = gai_alloc<sockaddr_in6_type>();
       if (sin6ptr == 0)
         return EAI_MEMORY;
       sin6ptr->sin6_family = BOOST_ASIO_OS_DEF(AF_INET6);
       memcpy(&sin6ptr->sin6_addr, addr, sizeof(in6_addr_type));
       ai->ai_addr = reinterpret_cast<sockaddr*>(sin6ptr);
       ai->ai_addrlen = sizeof(sockaddr_in6_type);
       break;
     }
   default:
     break;
   }
 
   return 0;
 }
 
 inline addrinfo_type* gai_clone(addrinfo_type* ai)
 {
   using namespace std;
 
   addrinfo_type* new_ai = gai_alloc<addrinfo_type>();
   if (new_ai == 0)
     return new_ai;
 
   new_ai->ai_next = ai->ai_next;
   ai->ai_next = new_ai;
 
   new_ai->ai_flags = 0;
   new_ai->ai_family = ai->ai_family;
   new_ai->ai_socktype = ai->ai_socktype;
   new_ai->ai_protocol = ai->ai_protocol;
   new_ai->ai_canonname = 0;
   new_ai->ai_addrlen = ai->ai_addrlen;
   new_ai->ai_addr = gai_alloc<sockaddr>(ai->ai_addrlen);
   memcpy(new_ai->ai_addr, ai->ai_addr, ai->ai_addrlen);
 
   return new_ai;
 }
 
 inline int gai_port(addrinfo_type* aihead, int port, int socktype)
 {
   int num_found = 0;
 
   for (addrinfo_type* ai = aihead; ai; ai = ai->ai_next)
   {
     if (ai->ai_flags & gai_clone_flag)
     {
       if (ai->ai_socktype != 0)
       {
         ai = gai_clone(ai);
         if (ai == 0)
           return -1;
         // ai now points to newly cloned entry.
       }
     }
     else if (ai->ai_socktype != socktype)
     {
       // Ignore if mismatch on socket type.
       continue;
     }
 
     ai->ai_socktype = socktype;
 
     switch (ai->ai_family)
     {
     case BOOST_ASIO_OS_DEF(AF_INET):
       {
         sockaddr_in4_type* sinptr =
           reinterpret_cast<sockaddr_in4_type*>(ai->ai_addr);
         sinptr->sin_port = port;
         ++num_found;
         break;
       }
     case BOOST_ASIO_OS_DEF(AF_INET6):
       {
         sockaddr_in6_type* sin6ptr =
           reinterpret_cast<sockaddr_in6_type*>(ai->ai_addr);
         sin6ptr->sin6_port = port;
         ++num_found;
         break;
       }
     default:
       break;
     }
   }
 
   return num_found;
 }
 
 inline int gai_serv(addrinfo_type* aihead,
     const addrinfo_type* hints, const char* serv)
 {
   using namespace std;
 
   int num_found = 0;
 
   if (
 #if defined(AI_NUMERICSERV)
       (hints->ai_flags & AI_NUMERICSERV) ||
 #endif
       isdigit(static_cast<unsigned char>(serv[0])))
   {
     int port = htons(atoi(serv));
     if (hints->ai_socktype)
     {
       // Caller specifies socket type.
       int rc = gai_port(aihead, port, hints->ai_socktype);
       if (rc < 0)
         return EAI_MEMORY;
       num_found += rc;
     }
     else
     {
       // Caller does not specify socket type.
       int rc = gai_port(aihead, port, SOCK_STREAM);
       if (rc < 0)
         return EAI_MEMORY;
       num_found += rc;
       rc = gai_port(aihead, port, SOCK_DGRAM);
       if (rc < 0)
         return EAI_MEMORY;
       num_found += rc;
     }
   }
   else
   {
     // Try service name with TCP first, then UDP.
     if (hints->ai_socktype == 0 || hints->ai_socktype == SOCK_STREAM)
     {
       servent* sptr = getservbyname(serv, "tcp");
       if (sptr != 0)
       {
         int rc = gai_port(aihead, sptr->s_port, SOCK_STREAM);
         if (rc < 0)
           return EAI_MEMORY;
         num_found += rc;
       }
     }
     if (hints->ai_socktype == 0 || hints->ai_socktype == SOCK_DGRAM)
     {
       servent* sptr = getservbyname(serv, "udp");
       if (sptr != 0)
       {
         int rc = gai_port(aihead, sptr->s_port, SOCK_DGRAM);
         if (rc < 0)
           return EAI_MEMORY;
         num_found += rc;
       }
     }
   }
 
   if (num_found == 0)
   {
     if (hints->ai_socktype == 0)
     {
       // All calls to getservbyname() failed.
       return EAI_NONAME;
     }
     else
     {
       // Service not supported for socket type.
       return EAI_SERVICE;
     }
   }
 
   return 0;
 }
 
 inline int gai_echeck(const char* host, const char* service,
     int flags, int family, int socktype, int protocol)
 {
   (void)(flags);
   (void)(protocol);
 
   // Host or service must be specified.
   if (host == 0 || host[0] == '\0')
     if (service == 0 || service[0] == '\0')
       return EAI_NONAME;
 
   // Check combination of family and socket type.
   switch (family)
   {
   case BOOST_ASIO_OS_DEF(AF_UNSPEC):
     break;
   case BOOST_ASIO_OS_DEF(AF_INET):
   case BOOST_ASIO_OS_DEF(AF_INET6):
     if (service != 0 && service[0] != '\0')
       if (socktype != 0 && socktype != SOCK_STREAM && socktype != SOCK_DGRAM)
         return EAI_SOCKTYPE;
     break;
   default:
     return EAI_FAMILY;
   }
 
   return 0;
 }
 
 inline void freeaddrinfo_emulation(addrinfo_type* aihead)
 {
   addrinfo_type* ai = aihead;
   while (ai)
   {
     gai_free(ai->ai_addr);
     gai_free(ai->ai_canonname);
     addrinfo_type* ainext = ai->ai_next;
     gai_free(ai);
     ai = ainext;
   }
 }
 
 inline int getaddrinfo_emulation(const char* host, const char* service,
     const addrinfo_type* hintsp, addrinfo_type** result)
 {
   // Set up linked list of addrinfo structures.
   addrinfo_type* aihead = 0;
   addrinfo_type** ainext = &aihead;
   char* canon = 0;
 
   // Supply default hints if not specified by caller.
   addrinfo_type hints = addrinfo_type();
   hints.ai_family = BOOST_ASIO_OS_DEF(AF_UNSPEC);
   if (hintsp)
     hints = *hintsp;
 
   // If the resolution is not specifically for AF_INET6, remove the AI_V4MAPPED
   // and AI_ALL flags.
 #if defined(AI_V4MAPPED)
   if (hints.ai_family != BOOST_ASIO_OS_DEF(AF_INET6))
     hints.ai_flags &= ~AI_V4MAPPED;
 #endif
 #if defined(AI_ALL)
   if (hints.ai_family != BOOST_ASIO_OS_DEF(AF_INET6))
     hints.ai_flags &= ~AI_ALL;
 #endif
 
   // Basic error checking.
   int rc = gai_echeck(host, service, hints.ai_flags, hints.ai_family,
       hints.ai_socktype, hints.ai_protocol);
   if (rc != 0)
   {
     freeaddrinfo_emulation(aihead);
     return rc;
   }
 
   gai_search search[2];
   int search_count = gai_nsearch(host, &hints, search);
   for (gai_search* sptr = search; sptr < search + search_count; ++sptr)
   {
     // Check for IPv4 dotted decimal string.
     in4_addr_type inaddr;
     boost::system::error_code ec;
     if (socket_ops::inet_pton(BOOST_ASIO_OS_DEF(AF_INET),
           sptr->host, &inaddr, 0, ec) == 1)
     {
       if (hints.ai_family != BOOST_ASIO_OS_DEF(AF_UNSPEC)
           && hints.ai_family != BOOST_ASIO_OS_DEF(AF_INET))
       {
         freeaddrinfo_emulation(aihead);
         gai_free(canon);
         return EAI_FAMILY;
       }
       if (sptr->family == BOOST_ASIO_OS_DEF(AF_INET))
       {
         rc = gai_aistruct(&ainext, &hints, &inaddr, BOOST_ASIO_OS_DEF(AF_INET));
         if (rc != 0)
         {
           freeaddrinfo_emulation(aihead);
           gai_free(canon);
           return rc;
         }
       }
       continue;
     }
 
     // Check for IPv6 hex string.
     in6_addr_type in6addr;
     if (socket_ops::inet_pton(BOOST_ASIO_OS_DEF(AF_INET6),
           sptr->host, &in6addr, 0, ec) == 1)
     {
       if (hints.ai_family != BOOST_ASIO_OS_DEF(AF_UNSPEC)
           && hints.ai_family != BOOST_ASIO_OS_DEF(AF_INET6))
       {
         freeaddrinfo_emulation(aihead);
         gai_free(canon);
         return EAI_FAMILY;
       }
       if (sptr->family == BOOST_ASIO_OS_DEF(AF_INET6))
       {
         rc = gai_aistruct(&ainext, &hints, &in6addr,
             BOOST_ASIO_OS_DEF(AF_INET6));
         if (rc != 0)
         {
           freeaddrinfo_emulation(aihead);
           gai_free(canon);
           return rc;
         }
       }
       continue;
     }
 
     // Look up hostname.
     hostent hent;
     char hbuf[8192] = "";
     hostent* hptr = socket_ops::gethostbyname(sptr->host,
         sptr->family, &hent, hbuf, sizeof(hbuf), hints.ai_flags, ec);
     if (hptr == 0)
     {
       if (search_count == 2)
       {
         // Failure is OK if there are multiple searches.
         continue;
       }
       freeaddrinfo_emulation(aihead);
       gai_free(canon);
       if (ec == boost::asio::error::host_not_found)
         return EAI_NONAME;
       if (ec == boost::asio::error::host_not_found_try_again)
         return EAI_AGAIN;
       if (ec == boost::asio::error::no_recovery)
         return EAI_FAIL;
       if (ec == boost::asio::error::no_data)
         return EAI_NONAME;
       return EAI_NONAME;
     }
 
     // Check for address family mismatch if one was specified.
     if (hints.ai_family != BOOST_ASIO_OS_DEF(AF_UNSPEC)
         && hints.ai_family != hptr->h_addrtype)
     {
       freeaddrinfo_emulation(aihead);
       gai_free(canon);
       socket_ops::freehostent(hptr);
       return EAI_FAMILY;
     }
 
     // Save canonical name first time.
     if (host != 0 && host[0] != '\0' && hptr->h_name && hptr->h_name[0]
         && (hints.ai_flags & AI_CANONNAME) && canon == 0)
     {
       std::size_t canon_len = strlen(hptr->h_name) + 1;
       canon = gai_alloc<char>(canon_len);
       if (canon == 0)
       {
         freeaddrinfo_emulation(aihead);
         socket_ops::freehostent(hptr);
         return EAI_MEMORY;
       }
       gai_strcpy(canon, hptr->h_name, canon_len);
     }
 
     // Create an addrinfo structure for each returned address.
     for (char** ap = hptr->h_addr_list; *ap; ++ap)
     {
       rc = gai_aistruct(&ainext, &hints, *ap, hptr->h_addrtype);
       if (rc != 0)
       {
         freeaddrinfo_emulation(aihead);
         gai_free(canon);
         socket_ops::freehostent(hptr);
         return EAI_FAMILY;
       }
     }
 
     socket_ops::freehostent(hptr);
   }
 
   // Check if we found anything.
   if (aihead == 0)
   {
     gai_free(canon);
     return EAI_NONAME;
   }
 
   // Return canonical name in first entry.
   if (host != 0 && host[0] != '\0' && (hints.ai_flags & AI_CANONNAME))
   {
     if (canon)
     {
       aihead->ai_canonname = canon;
       canon = 0;
     }
     else
     {
       std::size_t canonname_len = strlen(search[0].host) + 1;
       aihead->ai_canonname = gai_alloc<char>(canonname_len);
       if (aihead->ai_canonname == 0)
       {
         freeaddrinfo_emulation(aihead);
         return EAI_MEMORY;
       }
       gai_strcpy(aihead->ai_canonname, search[0].host, canonname_len);
     }
   }
   gai_free(canon);
 
   // Process the service name.
   if (service != 0 && service[0] != '\0')
   {
     rc = gai_serv(aihead, &hints, service);
     if (rc != 0)
     {
       freeaddrinfo_emulation(aihead);
       return rc;
     }
   }
 
   // Return result to caller.
   *result = aihead;
   return 0;
 }
 
 inline boost::system::error_code getnameinfo_emulation(
     const socket_addr_type* sa, std::size_t salen, char* host,
     std::size_t hostlen, char* serv, std::size_t servlen, int flags,
     boost::system::error_code& ec)
 {
   using namespace std;
 
   const char* addr;
   size_t addr_len;
   unsigned short port;
   switch (sa->sa_family)
   {
   case BOOST_ASIO_OS_DEF(AF_INET):
     if (salen != sizeof(sockaddr_in4_type))
     {
       return ec = boost::asio::error::invalid_argument;
     }
     addr = reinterpret_cast<const char*>(
         &reinterpret_cast<const sockaddr_in4_type*>(sa)->sin_addr);
     addr_len = sizeof(in4_addr_type);
     port = reinterpret_cast<const sockaddr_in4_type*>(sa)->sin_port;
     break;
   case BOOST_ASIO_OS_DEF(AF_INET6):
     if (salen != sizeof(sockaddr_in6_type))
     {
       return ec = boost::asio::error::invalid_argument;
     }
     addr = reinterpret_cast<const char*>(
         &reinterpret_cast<const sockaddr_in6_type*>(sa)->sin6_addr);
     addr_len = sizeof(in6_addr_type);
     port = reinterpret_cast<const sockaddr_in6_type*>(sa)->sin6_port;
     break;
   default:
     return ec = boost::asio::error::address_family_not_supported;
   }
 
   if (host && hostlen > 0)
   {
     if (flags & NI_NUMERICHOST)
     {
       if (socket_ops::inet_ntop(sa->sa_family, addr, host, hostlen, 0, ec) == 0)
       {
         return ec;
       }
     }
     else
     {
       hostent hent;
       char hbuf[8192] = "";
       hostent* hptr = socket_ops::gethostbyaddr(addr,
           static_cast<int>(addr_len), sa->sa_family,
           &hent, hbuf, sizeof(hbuf), ec);
       if (hptr && hptr->h_name && hptr->h_name[0] != '\0')
       {
         if (flags & NI_NOFQDN)
         {
           char* dot = strchr(hptr->h_name, '.');
           if (dot)
           {
             *dot = 0;
           }
         }
         gai_strcpy(host, hptr->h_name, hostlen);
         socket_ops::freehostent(hptr);
       }
       else
       {
         socket_ops::freehostent(hptr);
         if (flags & NI_NAMEREQD)
         {
           return ec = boost::asio::error::host_not_found;
         }
         if (socket_ops::inet_ntop(sa->sa_family,
               addr, host, hostlen, 0, ec) == 0)
         {
           return ec;
         }
       }
     }
   }
 
   if (serv && servlen > 0)
   {
     if (flags & NI_NUMERICSERV)
     {
       if (servlen < 6)
       {
         return ec = boost::asio::error::no_buffer_space;
       }
 #if defined(BOOST_ASIO_HAS_SNPRINTF)
       snprintf(serv, servlen, "%u", ntohs(port));
 #elif defined(BOOST_ASIO_HAS_SECURE_RTL)
       sprintf_s(serv, servlen, "%u", ntohs(port));
 #else // defined(BOOST_ASIO_HAS_SECURE_RTL)
       sprintf(serv, "%u", ntohs(port));
 #endif // defined(BOOST_ASIO_HAS_SECURE_RTL)
     }
     else
     {
 #if defined(BOOST_ASIO_HAS_PTHREADS)
       static ::pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
       ::pthread_mutex_lock(&mutex);
 #endif // defined(BOOST_ASIO_HAS_PTHREADS)
       servent* sptr = ::getservbyport(port, (flags & NI_DGRAM) ? "udp" : 0);
       if (sptr && sptr->s_name && sptr->s_name[0] != '\0')
       {
         gai_strcpy(serv, sptr->s_name, servlen);
       }
       else
       {
         if (servlen < 6)
         {
           return ec = boost::asio::error::no_buffer_space;
         }
 #if defined(BOOST_ASIO_HAS_SNPRINTF)
         snprintf(serv, servlen, "%u", ntohs(port));
 #elif defined(BOOST_ASIO_HAS_SECURE_RTL)
         sprintf_s(serv, servlen, "%u", ntohs(port));
 #else // defined(BOOST_ASIO_HAS_SECURE_RTL)
         sprintf(serv, "%u", ntohs(port));
 #endif // defined(BOOST_ASIO_HAS_SECURE_RTL)
       }
 #if defined(BOOST_ASIO_HAS_PTHREADS)
       ::pthread_mutex_unlock(&mutex);
 #endif // defined(BOOST_ASIO_HAS_PTHREADS)
     }
   }
 
   boost::asio::error::clear(ec);
   return ec;
 }
 
 #endif // !defined(BOOST_ASIO_HAS_GETADDRINFO)
 
 inline boost::system::error_code translate_addrinfo_error(int error)
 {
   switch (error)
   {
   case 0:
     return boost::system::error_code();
   case EAI_AGAIN:
     return boost::asio::error::host_not_found_try_again;
   case EAI_BADFLAGS:
     return boost::asio::error::invalid_argument;
   case EAI_FAIL:
     return boost::asio::error::no_recovery;
   case EAI_FAMILY:
     return boost::asio::error::address_family_not_supported;
   case EAI_MEMORY:
     return boost::asio::error::no_memory;
   case EAI_NONAME:
 #if defined(EAI_ADDRFAMILY)
   case EAI_ADDRFAMILY:
 #endif
 #if defined(EAI_NODATA) && (EAI_NODATA != EAI_NONAME)
   case EAI_NODATA:
 #endif
     return boost::asio::error::host_not_found;
   case EAI_SERVICE:
     return boost::asio::error::service_not_found;
   case EAI_SOCKTYPE:
     return boost::asio::error::socket_type_not_supported;
   default: // Possibly the non-portable EAI_SYSTEM.
 #if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
     return boost::system::error_code(
         WSAGetLastError(), boost::asio::error::get_system_category());
 #else
     return boost::system::error_code(
         errno, boost::asio::error::get_system_category());
 #endif
   }
 }
 
 boost::system::error_code getaddrinfo(const char* host,
     const char* service, const addrinfo_type& hints,
     addrinfo_type** result, boost::system::error_code& ec)
 {
   host = (host && *host) ? host : 0;
   service = (service && *service) ? service : 0;
   clear_last_error();
 #if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 # if defined(BOOST_ASIO_HAS_GETADDRINFO)
   // Building for Windows XP, Windows Server 2003, or later.
   int error = ::getaddrinfo(host, service, &hints, result);
   return ec = translate_addrinfo_error(error);
 # else
   // Building for Windows 2000 or earlier.
   typedef int (WSAAPI *gai_t)(const char*,
       const char*, const addrinfo_type*, addrinfo_type**);
   if (HMODULE winsock_module = ::GetModuleHandleA("ws2_32"))
   {
     if (gai_t gai = (gai_t)::GetProcAddress(winsock_module, "getaddrinfo"))
     {
       int error = gai(host, service, &hints, result);
       return ec = translate_addrinfo_error(error);
     }
   }
   int error = getaddrinfo_emulation(host, service, &hints, result);
   return ec = translate_addrinfo_error(error);
 # endif
 #elif !defined(BOOST_ASIO_HAS_GETADDRINFO)
   int error = getaddrinfo_emulation(host, service, &hints, result);
   return ec = translate_addrinfo_error(error);
 #else
   int error = ::getaddrinfo(host, service, &hints, result);
 #if defined(__MACH__) && defined(__APPLE__)
   using namespace std; // For isdigit and atoi.
   if (error == 0 && service && isdigit(static_cast<unsigned char>(service[0])))
   {
     u_short_type port = host_to_network_short(atoi(service));
     for (addrinfo_type* ai = *result; ai; ai = ai->ai_next)
     {
       switch (ai->ai_family)
       {
       case BOOST_ASIO_OS_DEF(AF_INET):
         {
           sockaddr_in4_type* sinptr =
             reinterpret_cast<sockaddr_in4_type*>(ai->ai_addr);
           if (sinptr->sin_port == 0)
             sinptr->sin_port = port;
           break;
         }
       case BOOST_ASIO_OS_DEF(AF_INET6):
         {
           sockaddr_in6_type* sin6ptr =
             reinterpret_cast<sockaddr_in6_type*>(ai->ai_addr);
           if (sin6ptr->sin6_port == 0)
             sin6ptr->sin6_port = port;
           break;
         }
       default:
         break;
       }
     }
   }
 #endif
   return ec = translate_addrinfo_error(error);
 #endif
 }
 
 boost::system::error_code background_getaddrinfo(
     const weak_cancel_token_type& cancel_token, const char* host,
     const char* service, const addrinfo_type& hints,
     addrinfo_type** result, boost::system::error_code& ec)
 {
   if (cancel_token.expired())
     ec = boost::asio::error::operation_aborted;
   else
     socket_ops::getaddrinfo(host, service, hints, result, ec);
   return ec;
 }
 
 void freeaddrinfo(addrinfo_type* ai)
 {
 #if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 # if defined(BOOST_ASIO_HAS_GETADDRINFO)
   // Building for Windows XP, Windows Server 2003, or later.
   ::freeaddrinfo(ai);
 # else
   // Building for Windows 2000 or earlier.
   typedef int (WSAAPI *fai_t)(addrinfo_type*);
   if (HMODULE winsock_module = ::GetModuleHandleA("ws2_32"))
   {
     if (fai_t fai = (fai_t)::GetProcAddress(winsock_module, "freeaddrinfo"))
     {
       fai(ai);
       return;
     }
   }
   freeaddrinfo_emulation(ai);
 # endif
 #elif !defined(BOOST_ASIO_HAS_GETADDRINFO)
   freeaddrinfo_emulation(ai);
 #else
   ::freeaddrinfo(ai);
 #endif
 }
 
 boost::system::error_code getnameinfo(const void* addr,
     std::size_t addrlen, char* host, std::size_t hostlen,
     char* serv, std::size_t servlen, int flags, boost::system::error_code& ec)
 {
 #if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 # if defined(BOOST_ASIO_HAS_GETADDRINFO)
   // Building for Windows XP, Windows Server 2003, or later.
   clear_last_error();
   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
   // Building for Windows 2000 or earlier.
   typedef int (WSAAPI *gni_t)(const socket_addr_type*,
       int, char*, DWORD, char*, DWORD, int);
   if (HMODULE winsock_module = ::GetModuleHandleA("ws2_32"))
   {
     if (gni_t gni = (gni_t)::GetProcAddress(winsock_module, "getnameinfo"))
     {
       clear_last_error();
       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(static_cast<const socket_addr_type*>(addr),
       addrlen, host, hostlen, serv, servlen, flags, ec);
 # endif
 #elif !defined(BOOST_ASIO_HAS_GETADDRINFO)
   using namespace std; // For memcpy.
   sockaddr_storage_type tmp_addr;
   memcpy(&tmp_addr, addr, addrlen);
   addr = &tmp_addr;
   clear_last_error();
   return getnameinfo_emulation(static_cast<const socket_addr_type*>(addr),
       addrlen, host, hostlen, serv, servlen, flags, ec);
 #else
   clear_last_error();
   int error = ::getnameinfo(static_cast<const socket_addr_type*>(addr),
       addrlen, host, hostlen, serv, servlen, flags);
   return ec = translate_addrinfo_error(error);
 #endif
 }
 
 boost::system::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, boost::system::error_code& ec)
 {
   // First try resolving with the service name. If that fails try resolving
   // but allow the service to be returned as a number.
   int flags = (sock_type == SOCK_DGRAM) ? NI_DGRAM : 0;
   socket_ops::getnameinfo(addr, addrlen, host,
       hostlen, serv, servlen, flags, ec);
   if (ec)
   {
     socket_ops::getnameinfo(addr, addrlen, host, hostlen,
         serv, servlen, flags | NI_NUMERICSERV, ec);
   }
 
   return ec;
 }
 
 boost::system::error_code background_getnameinfo(
     const weak_cancel_token_type& cancel_token,
     const void* addr, std::size_t addrlen,
     char* host, std::size_t hostlen, char* serv,
     std::size_t servlen, int sock_type, boost::system::error_code& ec)
 {
   if (cancel_token.expired())
   {
     ec = boost::asio::error::operation_aborted;
   }
   else
   {
     // First try resolving with the service name. If that fails try resolving
     // but allow the service to be returned as a number.
     int flags = (sock_type == SOCK_DGRAM) ? NI_DGRAM : 0;
     socket_ops::getnameinfo(addr, addrlen, host,
         hostlen, serv, servlen, flags, ec);
     if (ec)
     {
       socket_ops::getnameinfo(addr, addrlen, host, hostlen,
           serv, servlen, flags | NI_NUMERICSERV, ec);
     }
   }
 
   return ec;
 }
 
 #endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME)
 
 u_long_type network_to_host_long(u_long_type value)
 {
 #if defined(BOOST_ASIO_WINDOWS_RUNTIME)
   unsigned char* value_p = reinterpret_cast<unsigned char*>(&value);
   u_long_type result = (static_cast<u_long_type>(value_p[0]) << 24)
     | (static_cast<u_long_type>(value_p[1]) << 16)
     | (static_cast<u_long_type>(value_p[2]) << 8)
     | static_cast<u_long_type>(value_p[3]);
   return result;
 #else // defined(BOOST_ASIO_WINDOWS_RUNTIME)
   return ntohl(value);
 #endif // defined(BOOST_ASIO_WINDOWS_RUNTIME)
 }
 
 u_long_type host_to_network_long(u_long_type value)
 {
 #if defined(BOOST_ASIO_WINDOWS_RUNTIME)
   u_long_type result;
   unsigned char* result_p = reinterpret_cast<unsigned char*>(&result);
   result_p[0] = static_cast<unsigned char>((value >> 24) & 0xFF);
   result_p[1] = static_cast<unsigned char>((value >> 16) & 0xFF);
   result_p[2] = static_cast<unsigned char>((value >> 8) & 0xFF);
   result_p[3] = static_cast<unsigned char>(value & 0xFF);
   return result;
 #else // defined(BOOST_ASIO_WINDOWS_RUNTIME)
   return htonl(value);
 #endif // defined(BOOST_ASIO_WINDOWS_RUNTIME)
 }
 
 u_short_type network_to_host_short(u_short_type value)
 {
 #if defined(BOOST_ASIO_WINDOWS_RUNTIME)
   unsigned char* value_p = reinterpret_cast<unsigned char*>(&value);
   u_short_type result = (static_cast<u_short_type>(value_p[0]) << 8)
     | static_cast<u_short_type>(value_p[1]);
   return result;
 #else // defined(BOOST_ASIO_WINDOWS_RUNTIME)
   return ntohs(value);
 #endif // defined(BOOST_ASIO_WINDOWS_RUNTIME)
 }
 
 u_short_type host_to_network_short(u_short_type value)
 {
 #if defined(BOOST_ASIO_WINDOWS_RUNTIME)
   u_short_type result;
   unsigned char* result_p = reinterpret_cast<unsigned char*>(&result);
   result_p[0] = static_cast<unsigned char>((value >> 8) & 0xFF);
   result_p[1] = static_cast<unsigned char>(value & 0xFF);
   return result;
 #else // defined(BOOST_ASIO_WINDOWS_RUNTIME)
   return htons(value);
 #endif // defined(BOOST_ASIO_WINDOWS_RUNTIME)
 }
 
 } // namespace socket_ops
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // BOOST_ASIO_DETAIL_SOCKET_OPS_IPP