hadoop-common-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From whe...@apache.org
Subject [29/56] [abbrv] hadoop git commit: HDFS-8724. Import third_party libraries into the repository. Contributed by Haohui Mai.
Date Wed, 07 Oct 2015 07:19:55 GMT
http://git-wip-us.apache.org/repos/asf/hadoop/blob/c3e6c61e/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/detail/impl/socket_ops.ipp
----------------------------------------------------------------------
diff --git a/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/detail/impl/socket_ops.ipp b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/detail/impl/socket_ops.ipp
new file mode 100644
index 0000000..c601210
--- /dev/null
+++ b/hadoop-hdfs-project/hadoop-hdfs-client/src/main/native/libhdfspp/third_party/asio-1.10.2/include/asio/detail/impl/socket_ops.ipp
@@ -0,0 +1,3394 @@
+//
+// detail/impl/socket_ops.ipp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2014 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 ASIO_DETAIL_SOCKET_OPS_IPP
+#define ASIO_DETAIL_SOCKET_OPS_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+
+#include <cctype>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <cerrno>
+#include <new>
+#include "asio/detail/assert.hpp"
+#include "asio/detail/socket_ops.hpp"
+#include "asio/error.hpp"
+
+#if defined(ASIO_WINDOWS_RUNTIME)
+# include <codecvt>
+# include <locale>
+# include <string>
+#endif // defined(ASIO_WINDOWS_RUNTIME)
+
+#if defined(ASIO_WINDOWS) || defined(__CYGWIN__) \
+  || defined(__MACH__) && defined(__APPLE__)
+# if defined(ASIO_HAS_PTHREADS)
+#  include <pthread.h>
+# endif // defined(ASIO_HAS_PTHREADS)
+#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+       // || defined(__MACH__) && defined(__APPLE__)
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace detail {
+namespace socket_ops {
+
+#if !defined(ASIO_WINDOWS_RUNTIME)
+
+#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+struct msghdr { int msg_namelen; };
+#endif // defined(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(ASIO_WINDOWS_RUNTIME)
+
+inline void clear_last_error()
+{
+#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+  WSASetLastError(0);
+#else
+  errno = 0;
+#endif
+}
+
+#if !defined(ASIO_WINDOWS_RUNTIME)
+
+template <typename ReturnType>
+inline ReturnType error_wrapper(ReturnType return_value,
+    asio::error_code& ec)
+{
+#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+  ec = asio::error_code(WSAGetLastError(),
+      asio::error::get_system_category());
+#else
+  ec = asio::error_code(errno,
+      asio::error::get_system_category());
+#endif
+  return return_value;
+}
+
+template <typename SockLenType>
+inline socket_type call_accept(SockLenType msghdr::*,
+    socket_type s, socket_addr_type* addr, std::size_t* addrlen)
+{
+  SockLenType tmp_addrlen = addrlen ? (SockLenType)*addrlen : 0;
+  socket_type result = ::accept(s, addr, addrlen ? &tmp_addrlen : 0);
+  if (addrlen)
+    *addrlen = (std::size_t)tmp_addrlen;
+  return result;
+}
+
+socket_type accept(socket_type s, socket_addr_type* addr,
+    std::size_t* addrlen, asio::error_code& ec)
+{
+  if (s == invalid_socket)
+  {
+    ec = asio::error::bad_descriptor;
+    return invalid_socket;
+  }
+
+  clear_last_error();
+
+  socket_type new_s = error_wrapper(call_accept(
+        &msghdr::msg_namelen, s, addr, addrlen), ec);
+  if (new_s == invalid_socket)
+    return new_s;
+
+#if defined(__MACH__) && defined(__APPLE__) || defined(__FreeBSD__)
+  int optval = 1;
+  int result = error_wrapper(::setsockopt(new_s,
+        SOL_SOCKET, SO_NOSIGPIPE, &optval, sizeof(optval)), ec);
+  if (result != 0)
+  {
+    ::close(new_s);
+    return invalid_socket;
+  }
+#endif
+
+  ec = asio::error_code();
+  return new_s;
+}
+
+socket_type sync_accept(socket_type s, state_type state,
+    socket_addr_type* addr, std::size_t* addrlen, asio::error_code& ec)
+{
+  // 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 == asio::error::would_block
+        || ec == asio::error::try_again)
+    {
+      if (state & user_set_non_blocking)
+        return invalid_socket;
+      // Fall through to retry operation.
+    }
+    else if (ec == 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, ec) < 0)
+      return invalid_socket;
+  }
+}
+
+#if defined(ASIO_HAS_IOCP)
+
+void complete_iocp_accept(socket_type s,
+    void* output_buffer, DWORD address_length,
+    socket_addr_type* addr, std::size_t* addrlen,
+    socket_type new_socket, asio::error_code& ec)
+{
+  // Map non-portable errors to their portable counterparts.
+  if (ec.value() == ERROR_NETNAME_DELETED)
+    ec = 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 = 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(ASIO_HAS_IOCP)
+
+bool non_blocking_accept(socket_type s,
+    state_type state, socket_addr_type* addr, std::size_t* addrlen,
+    asio::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 == asio::error::interrupted)
+      continue;
+
+    // Operation failed.
+    if (ec == asio::error::would_block
+        || ec == asio::error::try_again)
+    {
+      if (state & user_set_non_blocking)
+        return true;
+      // Fall through to retry operation.
+    }
+    else if (ec == 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(ASIO_HAS_IOCP)
+
+template <typename SockLenType>
+inline int call_bind(SockLenType msghdr::*,
+    socket_type s, const socket_addr_type* addr, std::size_t addrlen)
+{
+  return ::bind(s, addr, (SockLenType)addrlen);
+}
+
+int bind(socket_type s, const socket_addr_type* addr,
+    std::size_t addrlen, asio::error_code& ec)
+{
+  if (s == invalid_socket)
+  {
+    ec = asio::error::bad_descriptor;
+    return socket_error_retval;
+  }
+
+  clear_last_error();
+  int result = error_wrapper(call_bind(
+        &msghdr::msg_namelen, s, addr, addrlen), ec);
+  if (result == 0)
+    ec = asio::error_code();
+  return result;
+}
+
+int close(socket_type s, state_type& state,
+    bool destruction, asio::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;
+      asio::error_code ignored_ec;
+      socket_ops::setsockopt(s, state, SOL_SOCKET,
+          SO_LINGER, &opt, sizeof(opt), ignored_ec);
+    }
+
+    clear_last_error();
+#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+    result = error_wrapper(::closesocket(s), ec);
+#else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+    result = error_wrapper(::close(s), ec);
+#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+
+    if (result != 0
+        && (ec == asio::error::would_block
+          || ec == 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(ASIO_WINDOWS) || defined(__CYGWIN__)
+      ioctl_arg_type arg = 0;
+      ::ioctlsocket(s, FIONBIO, &arg);
+#else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+# if defined(__SYMBIAN32__)
+      int flags = ::fcntl(s, F_GETFL, 0);
+      if (flags >= 0)
+        ::fcntl(s, F_SETFL, flags & ~O_NONBLOCK);
+# else // defined(__SYMBIAN32__)
+      ioctl_arg_type arg = 0;
+      ::ioctl(s, FIONBIO, &arg);
+# endif // defined(__SYMBIAN32__)
+#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+      state &= ~non_blocking;
+
+      clear_last_error();
+#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+      result = error_wrapper(::closesocket(s), ec);
+#else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+      result = error_wrapper(::close(s), ec);
+#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+    }
+  }
+
+  if (result == 0)
+    ec = asio::error_code();
+  return result;
+}
+
+bool set_user_non_blocking(socket_type s,
+    state_type& state, bool value, asio::error_code& ec)
+{
+  if (s == invalid_socket)
+  {
+    ec = asio::error::bad_descriptor;
+    return false;
+  }
+
+  clear_last_error();
+#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+  ioctl_arg_type arg = (value ? 1 : 0);
+  int result = error_wrapper(::ioctlsocket(s, FIONBIO, &arg), ec);
+#elif defined(__SYMBIAN32__)
+  int result = error_wrapper(::fcntl(s, F_GETFL, 0), ec);
+  if (result >= 0)
+  {
+    clear_last_error();
+    int flag = (value ? (result | O_NONBLOCK) : (result & ~O_NONBLOCK));
+    result = error_wrapper(::fcntl(s, F_SETFL, flag), ec);
+  }
+#else
+  ioctl_arg_type arg = (value ? 1 : 0);
+  int result = error_wrapper(::ioctl(s, FIONBIO, &arg), ec);
+#endif
+
+  if (result >= 0)
+  {
+    ec = asio::error_code();
+    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, asio::error_code& ec)
+{
+  if (s == invalid_socket)
+  {
+    ec = 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 = asio::error::invalid_argument;
+    return false;
+  }
+
+  clear_last_error();
+#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+  ioctl_arg_type arg = (value ? 1 : 0);
+  int result = error_wrapper(::ioctlsocket(s, FIONBIO, &arg), ec);
+#elif defined(__SYMBIAN32__)
+  int result = error_wrapper(::fcntl(s, F_GETFL, 0), ec);
+  if (result >= 0)
+  {
+    clear_last_error();
+    int flag = (value ? (result | O_NONBLOCK) : (result & ~O_NONBLOCK));
+    result = error_wrapper(::fcntl(s, F_SETFL, flag), ec);
+  }
+#else
+  ioctl_arg_type arg = (value ? 1 : 0);
+  int result = error_wrapper(::ioctl(s, FIONBIO, &arg), ec);
+#endif
+
+  if (result >= 0)
+  {
+    ec = asio::error_code();
+    if (value)
+      state |= internal_non_blocking;
+    else
+      state &= ~internal_non_blocking;
+    return true;
+  }
+
+  return false;
+}
+
+int shutdown(socket_type s, int what, asio::error_code& ec)
+{
+  if (s == invalid_socket)
+  {
+    ec = asio::error::bad_descriptor;
+    return socket_error_retval;
+  }
+
+  clear_last_error();
+  int result = error_wrapper(::shutdown(s, what), ec);
+  if (result == 0)
+    ec = asio::error_code();
+  return result;
+}
+
+template <typename SockLenType>
+inline int call_connect(SockLenType msghdr::*,
+    socket_type s, const socket_addr_type* addr, std::size_t addrlen)
+{
+  return ::connect(s, addr, (SockLenType)addrlen);
+}
+
+int connect(socket_type s, const socket_addr_type* addr,
+    std::size_t addrlen, asio::error_code& ec)
+{
+  if (s == invalid_socket)
+  {
+    ec = asio::error::bad_descriptor;
+    return socket_error_retval;
+  }
+
+  clear_last_error();
+  int result = error_wrapper(call_connect(
+        &msghdr::msg_namelen, s, addr, addrlen), ec);
+  if (result == 0)
+    ec = asio::error_code();
+#if defined(__linux__)
+  else if (ec == asio::error::try_again)
+    ec = asio::error::no_buffer_space;
+#endif // defined(__linux__)
+  return result;
+}
+
+void sync_connect(socket_type s, const socket_addr_type* addr,
+    std::size_t addrlen, asio::error_code& ec)
+{
+  // Perform the connect operation.
+  socket_ops::connect(s, addr, addrlen, ec);
+  if (ec != asio::error::in_progress
+      && ec != asio::error::would_block)
+  {
+    // The connect operation finished immediately.
+    return;
+  }
+
+  // Wait for socket to become ready.
+  if (socket_ops::poll_connect(s, 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 = asio::error_code(connect_error,
+      asio::error::get_system_category());
+}
+
+#if defined(ASIO_HAS_IOCP)
+
+void complete_iocp_connect(socket_type s, asio::error_code& ec)
+{
+  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;
+    socket_ops::setsockopt(s, state, SOL_SOCKET,
+        SO_UPDATE_CONNECT_CONTEXT, 0, 0, ec);
+  }
+}
+
+#endif // defined(ASIO_HAS_IOCP)
+
+bool non_blocking_connect(socket_type s, asio::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(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(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(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 = asio::error_code(connect_error,
+          asio::error::get_system_category());
+    }
+    else
+      ec = asio::error_code();
+  }
+
+  return true;
+}
+
+int socketpair(int af, int type, int protocol,
+    socket_type sv[2], asio::error_code& ec)
+{
+#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+  (void)(af);
+  (void)(type);
+  (void)(protocol);
+  (void)(sv);
+  ec = asio::error::operation_not_supported;
+  return socket_error_retval;
+#else
+  clear_last_error();
+  int result = error_wrapper(::socketpair(af, type, protocol, sv), ec);
+  if (result == 0)
+    ec = asio::error_code();
+  return result;
+#endif
+}
+
+bool sockatmark(socket_type s, asio::error_code& ec)
+{
+  if (s == invalid_socket)
+  {
+    ec = asio::error::bad_descriptor;
+    return false;
+  }
+
+#if defined(SIOCATMARK)
+  ioctl_arg_type value = 0;
+# if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+  int result = error_wrapper(::ioctlsocket(s, SIOCATMARK, &value), ec);
+# else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+  int result = error_wrapper(::ioctl(s, SIOCATMARK, &value), ec);
+# endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+  if (result == 0)
+    ec = asio::error_code();
+# if defined(ENOTTY)
+  if (ec.value() == ENOTTY)
+    ec = asio::error::not_socket;
+# endif // defined(ENOTTY)
+#else // defined(SIOCATMARK)
+  int value = error_wrapper(::sockatmark(s), ec);
+  if (value != -1)
+    ec = asio::error_code();
+#endif // defined(SIOCATMARK)
+
+  return ec ? false : value != 0;
+}
+
+size_t available(socket_type s, asio::error_code& ec)
+{
+  if (s == invalid_socket)
+  {
+    ec = asio::error::bad_descriptor;
+    return 0;
+  }
+
+  ioctl_arg_type value = 0;
+#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+  int result = error_wrapper(::ioctlsocket(s, FIONREAD, &value), ec);
+#else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+  int result = error_wrapper(::ioctl(s, FIONREAD, &value), ec);
+#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+  if (result == 0)
+    ec = asio::error_code();
+#if defined(ENOTTY)
+  if (ec.value() == ENOTTY)
+    ec = 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, asio::error_code& ec)
+{
+  if (s == invalid_socket)
+  {
+    ec = asio::error::bad_descriptor;
+    return socket_error_retval;
+  }
+
+  clear_last_error();
+  int result = error_wrapper(::listen(s, backlog), ec);
+  if (result == 0)
+    ec = asio::error_code();
+  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(ASIO_WINDOWS) || defined(__CYGWIN__)
+typedef WSABUF buf;
+#else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+typedef iovec buf;
+#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+
+void init_buf(buf& b, void* data, size_t size)
+{
+#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+  b.buf = static_cast<char*>(data);
+  b.len = static_cast<u_long>(size);
+#else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+  init_buf_iov_base(b.iov_base, data);
+  b.iov_len = size;
+#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+}
+
+void init_buf(buf& b, const void* data, size_t size)
+{
+#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+  b.buf = static_cast<char*>(const_cast<void*>(data));
+  b.len = static_cast<u_long>(size);
+#else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+  init_buf_iov_base(b.iov_base, const_cast<void*>(data));
+  b.iov_len = size;
+#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+}
+
+inline void init_msghdr_msg_name(void*& name, socket_addr_type* addr)
+{
+  name = 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, socket_addr_type* addr)
+{
+  name = reinterpret_cast<T>(addr);
+}
+
+template <typename T>
+inline void init_msghdr_msg_name(T& name, const socket_addr_type* addr)
+{
+  name = reinterpret_cast<T>(const_cast<socket_addr_type*>(addr));
+}
+
+signed_size_type recv(socket_type s, buf* bufs, size_t count,
+    int flags, asio::error_code& ec)
+{
+  clear_last_error();
+#if defined(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 = error_wrapper(::WSARecv(s, bufs,
+        recv_buf_count, &bytes_transferred, &recv_flags, 0, 0), ec);
+  if (ec.value() == ERROR_NETNAME_DELETED)
+    ec = asio::error::connection_reset;
+  else if (ec.value() == ERROR_PORT_UNREACHABLE)
+    ec = asio::error::connection_refused;
+  if (result != 0)
+    return socket_error_retval;
+  ec = asio::error_code();
+  return bytes_transferred;
+#else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+  msghdr msg = msghdr();
+  msg.msg_iov = bufs;
+  msg.msg_iovlen = static_cast<int>(count);
+  signed_size_type result = error_wrapper(::recvmsg(s, &msg, flags), ec);
+  if (result >= 0)
+    ec = asio::error_code();
+  return result;
+#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+}
+
+size_t sync_recv(socket_type s, state_type state, buf* bufs,
+    size_t count, int flags, bool all_empty, asio::error_code& ec)
+{
+  if (s == invalid_socket)
+  {
+    ec = 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))
+  {
+    ec = asio::error_code();
+    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 if operation succeeded.
+    if (bytes > 0)
+      return bytes;
+
+    // Check for EOF.
+    if ((state & stream_oriented) && bytes == 0)
+    {
+      ec = asio::error::eof;
+      return 0;
+    }
+
+    // Operation failed.
+    if ((state & user_set_non_blocking)
+        || (ec != asio::error::would_block
+          && ec != asio::error::try_again))
+      return 0;
+
+    // Wait for socket to become ready.
+    if (socket_ops::poll_read(s, 0, ec) < 0)
+      return 0;
+  }
+}
+
+#if defined(ASIO_HAS_IOCP)
+
+void complete_iocp_recv(state_type state,
+    const weak_cancel_token_type& cancel_token, bool all_empty,
+    asio::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 = asio::error::operation_aborted;
+    else
+      ec = asio::error::connection_reset;
+  }
+  else if (ec.value() == ERROR_PORT_UNREACHABLE)
+  {
+    ec = asio::error::connection_refused;
+  }
+
+  // Check for connection closed.
+  else if (!ec && bytes_transferred == 0
+      && (state & stream_oriented) != 0
+      && !all_empty)
+  {
+    ec = asio::error::eof;
+  }
+}
+
+#else // defined(ASIO_HAS_IOCP)
+
+bool non_blocking_recv(socket_type s,
+    buf* bufs, size_t count, int flags, bool is_stream,
+    asio::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 = asio::error::eof;
+      return true;
+    }
+
+    // Retry operation if interrupted by signal.
+    if (ec == asio::error::interrupted)
+      continue;
+
+    // Check if we need to run the operation again.
+    if (ec == asio::error::would_block
+        || ec == asio::error::try_again)
+      return false;
+
+    // Operation is complete.
+    if (bytes >= 0)
+    {
+      ec = asio::error_code();
+      bytes_transferred = bytes;
+    }
+    else
+      bytes_transferred = 0;
+
+    return true;
+  }
+}
+
+#endif // defined(ASIO_HAS_IOCP)
+
+signed_size_type recvfrom(socket_type s, buf* bufs, size_t count,
+    int flags, socket_addr_type* addr, std::size_t* addrlen,
+    asio::error_code& ec)
+{
+  clear_last_error();
+#if defined(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 = error_wrapper(::WSARecvFrom(s, bufs, recv_buf_count,
+        &bytes_transferred, &recv_flags, addr, &tmp_addrlen, 0, 0), ec);
+  *addrlen = (std::size_t)tmp_addrlen;
+  if (ec.value() == ERROR_NETNAME_DELETED)
+    ec = asio::error::connection_reset;
+  else if (ec.value() == ERROR_PORT_UNREACHABLE)
+    ec = asio::error::connection_refused;
+  if (result != 0)
+    return socket_error_retval;
+  ec = asio::error_code();
+  return bytes_transferred;
+#else // defined(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 = error_wrapper(::recvmsg(s, &msg, flags), ec);
+  *addrlen = msg.msg_namelen;
+  if (result >= 0)
+    ec = asio::error_code();
+  return result;
+#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+}
+
+size_t sync_recvfrom(socket_type s, state_type state, buf* bufs,
+    size_t count, int flags, socket_addr_type* addr,
+    std::size_t* addrlen, asio::error_code& ec)
+{
+  if (s == invalid_socket)
+  {
+    ec = 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 != asio::error::would_block
+          && ec != asio::error::try_again))
+      return 0;
+
+    // Wait for socket to become ready.
+    if (socket_ops::poll_read(s, 0, ec) < 0)
+      return 0;
+  }
+}
+
+#if defined(ASIO_HAS_IOCP)
+
+void complete_iocp_recvfrom(
+    const weak_cancel_token_type& cancel_token,
+    asio::error_code& ec)
+{
+  // Map non-portable errors to their portable counterparts.
+  if (ec.value() == ERROR_NETNAME_DELETED)
+  {
+    if (cancel_token.expired())
+      ec = asio::error::operation_aborted;
+    else
+      ec = asio::error::connection_reset;
+  }
+  else if (ec.value() == ERROR_PORT_UNREACHABLE)
+  {
+    ec = asio::error::connection_refused;
+  }
+}
+
+#else // defined(ASIO_HAS_IOCP)
+
+bool non_blocking_recvfrom(socket_type s,
+    buf* bufs, size_t count, int flags,
+    socket_addr_type* addr, std::size_t* addrlen,
+    asio::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);
+
+    // Retry operation if interrupted by signal.
+    if (ec == asio::error::interrupted)
+      continue;
+
+    // Check if we need to run the operation again.
+    if (ec == asio::error::would_block
+        || ec == asio::error::try_again)
+      return false;
+
+    // Operation is complete.
+    if (bytes >= 0)
+    {
+      ec = asio::error_code();
+      bytes_transferred = bytes;
+    }
+    else
+      bytes_transferred = 0;
+
+    return true;
+  }
+}
+
+#endif // defined(ASIO_HAS_IOCP)
+
+signed_size_type recvmsg(socket_type s, buf* bufs, size_t count,
+    int in_flags, int& out_flags, asio::error_code& ec)
+{
+  clear_last_error();
+#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+  out_flags = 0;
+  return socket_ops::recv(s, bufs, count, in_flags, ec);
+#else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+  msghdr msg = msghdr();
+  msg.msg_iov = bufs;
+  msg.msg_iovlen = static_cast<int>(count);
+  signed_size_type result = error_wrapper(::recvmsg(s, &msg, in_flags), ec);
+  if (result >= 0)
+  {
+    ec = asio::error_code();
+    out_flags = msg.msg_flags;
+  }
+  else
+    out_flags = 0;
+  return result;
+#endif // defined(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,
+    asio::error_code& ec)
+{
+  if (s == invalid_socket)
+  {
+    ec = 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 != asio::error::would_block
+          && ec != asio::error::try_again))
+      return 0;
+
+    // Wait for socket to become ready.
+    if (socket_ops::poll_read(s, 0, ec) < 0)
+      return 0;
+  }
+}
+
+#if defined(ASIO_HAS_IOCP)
+
+void complete_iocp_recvmsg(
+    const weak_cancel_token_type& cancel_token,
+    asio::error_code& ec)
+{
+  // Map non-portable errors to their portable counterparts.
+  if (ec.value() == ERROR_NETNAME_DELETED)
+  {
+    if (cancel_token.expired())
+      ec = asio::error::operation_aborted;
+    else
+      ec = asio::error::connection_reset;
+  }
+  else if (ec.value() == ERROR_PORT_UNREACHABLE)
+  {
+    ec = asio::error::connection_refused;
+  }
+}
+
+#else // defined(ASIO_HAS_IOCP)
+
+bool non_blocking_recvmsg(socket_type s,
+    buf* bufs, size_t count, int in_flags, int& out_flags,
+    asio::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);
+
+    // Retry operation if interrupted by signal.
+    if (ec == asio::error::interrupted)
+      continue;
+
+    // Check if we need to run the operation again.
+    if (ec == asio::error::would_block
+        || ec == asio::error::try_again)
+      return false;
+
+    // Operation is complete.
+    if (bytes >= 0)
+    {
+      ec = asio::error_code();
+      bytes_transferred = bytes;
+    }
+    else
+      bytes_transferred = 0;
+
+    return true;
+  }
+}
+
+#endif // defined(ASIO_HAS_IOCP)
+
+signed_size_type send(socket_type s, const buf* bufs, size_t count,
+    int flags, asio::error_code& ec)
+{
+  clear_last_error();
+#if defined(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 = error_wrapper(::WSASend(s, const_cast<buf*>(bufs),
+        send_buf_count, &bytes_transferred, send_flags, 0, 0), ec);
+  if (ec.value() == ERROR_NETNAME_DELETED)
+    ec = asio::error::connection_reset;
+  else if (ec.value() == ERROR_PORT_UNREACHABLE)
+    ec = asio::error::connection_refused;
+  if (result != 0)
+    return socket_error_retval;
+  ec = asio::error_code();
+  return bytes_transferred;
+#else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+  msghdr msg = msghdr();
+  msg.msg_iov = const_cast<buf*>(bufs);
+  msg.msg_iovlen = static_cast<int>(count);
+#if defined(__linux__)
+  flags |= MSG_NOSIGNAL;
+#endif // defined(__linux__)
+  signed_size_type result = error_wrapper(::sendmsg(s, &msg, flags), ec);
+  if (result >= 0)
+    ec = asio::error_code();
+  return result;
+#endif // defined(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, asio::error_code& ec)
+{
+  if (s == invalid_socket)
+  {
+    ec = 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))
+  {
+    ec = asio::error_code();
+    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 != asio::error::would_block
+          && ec != asio::error::try_again))
+      return 0;
+
+    // Wait for socket to become ready.
+    if (socket_ops::poll_write(s, 0, ec) < 0)
+      return 0;
+  }
+}
+
+#if defined(ASIO_HAS_IOCP)
+
+void complete_iocp_send(
+    const weak_cancel_token_type& cancel_token,
+    asio::error_code& ec)
+{
+  // Map non-portable errors to their portable counterparts.
+  if (ec.value() == ERROR_NETNAME_DELETED)
+  {
+    if (cancel_token.expired())
+      ec = asio::error::operation_aborted;
+    else
+      ec = asio::error::connection_reset;
+  }
+  else if (ec.value() == ERROR_PORT_UNREACHABLE)
+  {
+    ec = asio::error::connection_refused;
+  }
+}
+
+#else // defined(ASIO_HAS_IOCP)
+
+bool non_blocking_send(socket_type s,
+    const buf* bufs, size_t count, int flags,
+    asio::error_code& ec, size_t& bytes_transferred)
+{
+  for (;;)
+  {
+    // Write some data.
+    signed_size_type bytes = socket_ops::send(s, bufs, count, flags, ec);
+
+    // Retry operation if interrupted by signal.
+    if (ec == asio::error::interrupted)
+      continue;
+
+    // Check if we need to run the operation again.
+    if (ec == asio::error::would_block
+        || ec == asio::error::try_again)
+      return false;
+
+    // Operation is complete.
+    if (bytes >= 0)
+    {
+      ec = asio::error_code();
+      bytes_transferred = bytes;
+    }
+    else
+      bytes_transferred = 0;
+
+    return true;
+  }
+}
+
+#endif // defined(ASIO_HAS_IOCP)
+
+signed_size_type sendto(socket_type s, const buf* bufs, size_t count,
+    int flags, const socket_addr_type* addr, std::size_t addrlen,
+    asio::error_code& ec)
+{
+  clear_last_error();
+#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+  // Send the data.
+  DWORD send_buf_count = static_cast<DWORD>(count);
+  DWORD bytes_transferred = 0;
+  int result = error_wrapper(::WSASendTo(s, const_cast<buf*>(bufs),
+        send_buf_count, &bytes_transferred, flags, addr,
+        static_cast<int>(addrlen), 0, 0), ec);
+  if (ec.value() == ERROR_NETNAME_DELETED)
+    ec = asio::error::connection_reset;
+  else if (ec.value() == ERROR_PORT_UNREACHABLE)
+    ec = asio::error::connection_refused;
+  if (result != 0)
+    return socket_error_retval;
+  ec = asio::error_code();
+  return bytes_transferred;
+#else // defined(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(__linux__)
+  flags |= MSG_NOSIGNAL;
+#endif // defined(__linux__)
+  signed_size_type result = error_wrapper(::sendmsg(s, &msg, flags), ec);
+  if (result >= 0)
+    ec = asio::error_code();
+  return result;
+#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+}
+
+size_t sync_sendto(socket_type s, state_type state, const buf* bufs,
+    size_t count, int flags, const socket_addr_type* addr,
+    std::size_t addrlen, asio::error_code& ec)
+{
+  if (s == invalid_socket)
+  {
+    ec = 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 != asio::error::would_block
+          && ec != asio::error::try_again))
+      return 0;
+
+    // Wait for socket to become ready.
+    if (socket_ops::poll_write(s, 0, ec) < 0)
+      return 0;
+  }
+}
+
+#if !defined(ASIO_HAS_IOCP)
+
+bool non_blocking_sendto(socket_type s,
+    const buf* bufs, size_t count, int flags,
+    const socket_addr_type* addr, std::size_t addrlen,
+    asio::error_code& ec, size_t& bytes_transferred)
+{
+  for (;;)
+  {
+    // Write some data.
+    signed_size_type bytes = socket_ops::sendto(
+        s, bufs, count, flags, addr, addrlen, ec);
+
+    // Retry operation if interrupted by signal.
+    if (ec == asio::error::interrupted)
+      continue;
+
+    // Check if we need to run the operation again.
+    if (ec == asio::error::would_block
+        || ec == asio::error::try_again)
+      return false;
+
+    // Operation is complete.
+    if (bytes >= 0)
+    {
+      ec = asio::error_code();
+      bytes_transferred = bytes;
+    }
+    else
+      bytes_transferred = 0;
+
+    return true;
+  }
+}
+
+#endif // !defined(ASIO_HAS_IOCP)
+
+socket_type socket(int af, int type, int protocol,
+    asio::error_code& ec)
+{
+  clear_last_error();
+#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+  socket_type s = error_wrapper(::WSASocket(af, type, protocol, 0, 0,
+        WSA_FLAG_OVERLAPPED), ec);
+  if (s == invalid_socket)
+    return s;
+
+  if (af == 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));
+  }
+
+  ec = asio::error_code();
+
+  return s;
+#elif defined(__MACH__) && defined(__APPLE__) || defined(__FreeBSD__)
+  socket_type s = error_wrapper(::socket(af, type, protocol), ec);
+  if (s == invalid_socket)
+    return s;
+
+  int optval = 1;
+  int result = error_wrapper(::setsockopt(s,
+        SOL_SOCKET, SO_NOSIGPIPE, &optval, sizeof(optval)), ec);
+  if (result != 0)
+  {
+    ::close(s);
+    return invalid_socket;
+  }
+
+  return s;
+#else
+  int s = error_wrapper(::socket(af, type, protocol), ec);
+  if (s >= 0)
+    ec = asio::error_code();
+  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, asio::error_code& ec)
+{
+  if (s == invalid_socket)
+  {
+    ec = asio::error::bad_descriptor;
+    return socket_error_retval;
+  }
+
+  if (level == custom_socket_option_level && optname == always_fail_option)
+  {
+    ec = asio::error::invalid_argument;
+    return socket_error_retval;
+  }
+
+  if (level == custom_socket_option_level
+      && optname == enable_connection_aborted_option)
+  {
+    if (optlen != sizeof(int))
+    {
+      ec = asio::error::invalid_argument;
+      return socket_error_retval;
+    }
+
+    if (*static_cast<const int*>(optval))
+      state |= enable_connection_aborted;
+    else
+      state &= ~enable_connection_aborted;
+    ec = asio::error_code();
+    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"))
+    {
+      clear_last_error();
+      return error_wrapper(sso(s, level, optname,
+            reinterpret_cast<const char*>(optval),
+            static_cast<int>(optlen)), ec);
+    }
+  }
+  ec = asio::error::fault;
+  return socket_error_retval;
+#else // defined(__BORLANDC__)
+  clear_last_error();
+  int result = error_wrapper(call_setsockopt(&msghdr::msg_namelen,
+        s, level, optname, optval, optlen), ec);
+  if (result == 0)
+  {
+    ec = asio::error_code();
+
+#if defined(__MACH__) && defined(__APPLE__) \
+  || defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__)
+    // 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, asio::error_code& ec)
+{
+  if (s == invalid_socket)
+  {
+    ec = asio::error::bad_descriptor;
+    return socket_error_retval;
+  }
+
+  if (level == custom_socket_option_level && optname == always_fail_option)
+  {
+    ec = asio::error::invalid_argument;
+    return socket_error_retval;
+  }
+
+  if (level == custom_socket_option_level
+      && optname == enable_connection_aborted_option)
+  {
+    if (*optlen != sizeof(int))
+    {
+      ec = asio::error::invalid_argument;
+      return socket_error_retval;
+    }
+
+    *static_cast<int*>(optval) = (state & enable_connection_aborted) ? 1 : 0;
+    ec = asio::error_code();
+    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"))
+    {
+      clear_last_error();
+      int tmp_optlen = static_cast<int>(*optlen);
+      int result = error_wrapper(gso(s, level, optname,
+            reinterpret_cast<char*>(optval), &tmp_optlen), ec);
+      *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;
+        ec = asio::error_code();
+      }
+      return result;
+    }
+  }
+  ec = asio::error::fault;
+  return socket_error_retval;
+#elif defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+  clear_last_error();
+  int result = error_wrapper(call_getsockopt(&msghdr::msg_namelen,
+        s, level, optname, optval, optlen), ec);
+  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;
+    ec = asio::error_code();
+  }
+  if (result == 0)
+    ec = asio::error_code();
+  return result;
+#else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+  clear_last_error();
+  int result = error_wrapper(call_getsockopt(&msghdr::msg_namelen,
+        s, level, optname, optval, optlen), ec);
+#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__)
+  if (result == 0)
+    ec = asio::error_code();
+  return result;
+#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+}
+
+template <typename SockLenType>
+inline int call_getpeername(SockLenType msghdr::*,
+    socket_type s, socket_addr_type* addr, std::size_t* addrlen)
+{
+  SockLenType tmp_addrlen = (SockLenType)*addrlen;
+  int result = ::getpeername(s, addr, &tmp_addrlen);
+  *addrlen = (std::size_t)tmp_addrlen;
+  return result;
+}
+
+int getpeername(socket_type s, socket_addr_type* addr,
+    std::size_t* addrlen, bool cached, asio::error_code& ec)
+{
+  if (s == invalid_socket)
+  {
+    ec = asio::error::bad_descriptor;
+    return socket_error_retval;
+  }
+
+#if defined(ASIO_WINDOWS) || 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 = asio::error::not_connected;
+      return socket_error_retval;
+    }
+
+    // The cached value is still valid.
+    ec = asio::error_code();
+    return 0;
+  }
+#else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+  (void)cached;
+#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+
+  clear_last_error();
+  int result = error_wrapper(call_getpeername(
+        &msghdr::msg_namelen, s, addr, addrlen), ec);
+  if (result == 0)
+    ec = asio::error_code();
+  return result;
+}
+
+template <typename SockLenType>
+inline int call_getsockname(SockLenType msghdr::*,
+    socket_type s, socket_addr_type* addr, std::size_t* addrlen)
+{
+  SockLenType tmp_addrlen = (SockLenType)*addrlen;
+  int result = ::getsockname(s, addr, &tmp_addrlen);
+  *addrlen = (std::size_t)tmp_addrlen;
+  return result;
+}
+
+int getsockname(socket_type s, socket_addr_type* addr,
+    std::size_t* addrlen, asio::error_code& ec)
+{
+  if (s == invalid_socket)
+  {
+    ec = asio::error::bad_descriptor;
+    return socket_error_retval;
+  }
+
+  clear_last_error();
+  int result = error_wrapper(call_getsockname(
+        &msghdr::msg_namelen, s, addr, addrlen), ec);
+  if (result == 0)
+    ec = asio::error_code();
+  return result;
+}
+
+int ioctl(socket_type s, state_type& state, int cmd,
+    ioctl_arg_type* arg, asio::error_code& ec)
+{
+  if (s == invalid_socket)
+  {
+    ec = asio::error::bad_descriptor;
+    return socket_error_retval;
+  }
+
+  clear_last_error();
+#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+  int result = error_wrapper(::ioctlsocket(s, cmd, arg), ec);
+#elif defined(__MACH__) && defined(__APPLE__) \
+  || defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__)
+  int result = error_wrapper(::ioctl(s,
+        static_cast<unsigned int>(cmd), arg), ec);
+#else
+  int result = error_wrapper(::ioctl(s, cmd, arg), ec);
+#endif
+  if (result >= 0)
+  {
+    ec = asio::error_code();
+
+    // 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, asio::error_code& ec)
+{
+  clear_last_error();
+#if defined(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);
+    ec = asio::error_code();
+    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(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;
+  return error_wrapper(::pselect(nfds, readfds,
+        writefds, exceptfds, timeout ? &ts : 0, 0), ec);
+#else
+  int result = error_wrapper(::select(nfds, readfds,
+        writefds, exceptfds, timeout), ec);
+  if (result >= 0)
+    ec = asio::error_code();
+  return result;
+#endif
+}
+
+int poll_read(socket_type s, state_type state, asio::error_code& ec)
+{
+  if (s == invalid_socket)
+  {
+    ec = asio::error::bad_descriptor;
+    return socket_error_retval;
+  }
+
+#if defined(ASIO_WINDOWS) \
+  || defined(__CYGWIN__) \
+  || defined(__SYMBIAN32__)
+  fd_set fds;
+  FD_ZERO(&fds);
+  FD_SET(s, &fds);
+  timeval zero_timeout;
+  zero_timeout.tv_sec = 0;
+  zero_timeout.tv_usec = 0;
+  timeval* timeout = (state & user_set_non_blocking) ? &zero_timeout : 0;
+  clear_last_error();
+  int result = error_wrapper(::select(s + 1, &fds, 0, 0, timeout), ec);
+#else // defined(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 : -1;
+  clear_last_error();
+  int result = error_wrapper(::poll(&fds, 1, timeout), ec);
+#endif // defined(ASIO_WINDOWS)
+       // || defined(__CYGWIN__)
+       // || defined(__SYMBIAN32__)
+  if (result == 0)
+    ec = (state & user_set_non_blocking)
+      ? asio::error::would_block : asio::error_code();
+  else if (result > 0)
+    ec = asio::error_code();
+  return result;
+}
+
+int poll_write(socket_type s, state_type state, asio::error_code& ec)
+{
+  if (s == invalid_socket)
+  {
+    ec = asio::error::bad_descriptor;
+    return socket_error_retval;
+  }
+
+#if defined(ASIO_WINDOWS) \
+  || defined(__CYGWIN__) \
+  || defined(__SYMBIAN32__)
+  fd_set fds;
+  FD_ZERO(&fds);
+  FD_SET(s, &fds);
+  timeval zero_timeout;
+  zero_timeout.tv_sec = 0;
+  zero_timeout.tv_usec = 0;
+  timeval* timeout = (state & user_set_non_blocking) ? &zero_timeout : 0;
+  clear_last_error();
+  int result = error_wrapper(::select(s + 1, 0, &fds, 0, timeout), ec);
+#else // defined(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 : -1;
+  clear_last_error();
+  int result = error_wrapper(::poll(&fds, 1, timeout), ec);
+#endif // defined(ASIO_WINDOWS)
+       // || defined(__CYGWIN__)
+       // || defined(__SYMBIAN32__)
+  if (result == 0)
+    ec = (state & user_set_non_blocking)
+      ? asio::error::would_block : asio::error_code();
+  else if (result > 0)
+    ec = asio::error_code();
+  return result;
+}
+
+int poll_connect(socket_type s, asio::error_code& ec)
+{
+  if (s == invalid_socket)
+  {
+    ec = asio::error::bad_descriptor;
+    return socket_error_retval;
+  }
+
+#if defined(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);
+  clear_last_error();
+  int result = error_wrapper(::select(
+        s + 1, 0, &write_fds, &except_fds, 0), ec);
+  if (result >= 0)
+    ec = asio::error_code();
+  return result;
+#else // defined(ASIO_WINDOWS)
+      // || defined(__CYGWIN__)
+      // || defined(__SYMBIAN32__)
+  pollfd fds;
+  fds.fd = s;
+  fds.events = POLLOUT;
+  fds.revents = 0;
+  clear_last_error();
+  int result = error_wrapper(::poll(&fds, 1, -1), ec);
+  if (result >= 0)
+    ec = asio::error_code();
+  return result;
+#endif // defined(ASIO_WINDOWS)
+       // || defined(__CYGWIN__)
+       // || defined(__SYMBIAN32__)
+}
+
+#endif // !defined(ASIO_WINDOWS_RUNTIME)
+
+const char* inet_ntop(int af, const void* src, char* dest, size_t length,
+    unsigned long scope_id, asio::error_code& ec)
+{
+  clear_last_error();
+#if defined(ASIO_WINDOWS_RUNTIME)
+  using namespace std; // For sprintf.
+  const unsigned char* bytes = static_cast<const unsigned char*>(src);
+  if (af == 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 == 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 = asio::error::address_family_not_supported;
+    return 0;
+  }
+#elif defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+  using namespace std; // For memcpy.
+
+  if (af != ASIO_OS_DEF(AF_INET) && af != ASIO_OS_DEF(AF_INET6))
+  {
+    ec = 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 == ASIO_OS_DEF(AF_INET))
+  {
+    address_length = sizeof(sockaddr_in4_type);
+    address.v4.sin_family = 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 = 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)
+  LPWSTR string_buffer = (LPWSTR)_alloca(length * sizeof(WCHAR));
+  int result = error_wrapper(::WSAAddressToStringW(&address.base,
+        address_length, 0, string_buffer, &string_length), ec);
+  ::WideCharToMultiByte(CP_ACP, 0, string_buffer, -1, dest, length, 0, 0);
+#else
+  int result = error_wrapper(::WSAAddressToStringA(
+        &address.base, address_length, 0, dest, &string_length), ec);
+#endif
+
+  // Windows may set error code on success.
+  if (result != socket_error_retval)
+    ec = asio::error_code();
+
+  // Windows may not set an error code on failure.
+  else if (result == socket_error_retval && !ec)
+    ec = asio::error::invalid_argument;
+
+  return result == socket_error_retval ? 0 : dest;
+#else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+  const char* result = error_wrapper(::inet_ntop(
+        af, src, dest, static_cast<int>(length)), ec);
+  if (result == 0 && !ec)
+    ec = asio::error::invalid_argument;
+  if (result != 0 && af == ASIO_OS_DEF(AF_INET6) && scope_id != 0)
+  {
+    using namespace std; // For strcat and sprintf.
+    char if_name[IF_NAMESIZE + 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)
+      sprintf(if_name + 1, "%lu", scope_id);
+    strcat(dest, if_name);
+  }
+  return result;
+#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+}
+
+int inet_pton(int af, const char* src, void* dest,
+    unsigned long* scope_id, asio::error_code& ec)
+{
+  clear_last_error();
+#if defined(ASIO_WINDOWS_RUNTIME)
+  using namespace std; // For sscanf.
+  unsigned char* bytes = static_cast<unsigned char*>(dest);
+  if (af == 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 = asio::error::invalid_argument;
+      return -1;
+    }
+    if (b0 > 255 || b1 > 255 || b2 > 255 || b3 > 255)
+    {
+      ec = 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);
+    ec = asio::error_code();
+    return 1;
+  }
+  else if (af == 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 = 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 = 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 = 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 = 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 = 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 = 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];
+
+    ec = asio::error_code();
+    return 1;
+  }
+  else
+  {
+    ec = asio::error::address_family_not_supported;
+    return -1;
+  }
+#elif defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+  using namespace std; // For memcpy and strcmp.
+
+  if (af != ASIO_OS_DEF(AF_INET) && af != ASIO_OS_DEF(AF_INET6))
+  {
+    ec = 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)
+  int num_wide_chars = 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 = error_wrapper(::WSAStringToAddressW(
+        wide_buffer, af, 0, &address.base, &address_length), ec);
+#else
+  int result = error_wrapper(::WSAStringToAddressA(
+        const_cast<char*>(src), af, 0, &address.base, &address_length), ec);
+#endif
+
+  if (af == ASIO_OS_DEF(AF_INET))
+  {
+    if (result != socket_error_retval)
+    {
+      memcpy(dest, &address.v4.sin_addr, sizeof(in4_addr_type));
+      ec = asio::error_code();
+    }
+    else if (strcmp(src, "255.255.255.255") == 0)
+    {
+      static_cast<in4_addr_type*>(dest)->s_addr = INADDR_NONE;
+      ec = asio::error_code();
+    }
+  }
+  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;
+      ec = asio::error_code();
+    }
+  }
+
+  // Windows may not set an error code on failure.
+  if (result == socket_error_retval && !ec)
+    ec = asio::error::invalid_argument;
+
+  if (result != socket_error_retval)
+    ec = asio::error_code();
+
+  return result == socket_error_retval ? -1 : 1;
+#else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+  int result = error_wrapper(::inet_pton(af, src, dest), ec);
+  if (result <= 0 && !ec)
+    ec = asio::error::invalid_argument;
+  if (result > 0 && af == ASIO_OS_DEF(AF_INET6) && scope_id)
+  {
+    using namespace std; // For strchr and atoi.
+    *scope_id = 0;
+    if (const char* if_name = strchr(src, '%'))
+    {
+      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(ASIO_WINDOWS) || defined(__CYGWIN__)
+}
+
+int gethostname(char* name, int namelen, asio::error_code& ec)
+{
+  clear_last_error();
+#if defined(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 = asio::error_code(e->HResult,
+        asio::system_category());
+    return -1;
+  }
+#else // defined(ASIO_WINDOWS_RUNTIME)
+  int result = error_wrapper(::gethostname(name, namelen), ec);
+# if defined(ASIO_WINDOWS)
+  if (result == 0)
+    ec = asio::error_code();
+# endif // defined(ASIO_WINDOWS)
+  return result;
+#endif // defined(ASIO_WINDOWS_RUNTIME)
+}
+
+#if !defined(ASIO_WINDOWS_RUNTIME)
+
+#if defined(ASIO_WINDOWS) || defined(__CYGWIN__) \
+  || defined(__MACH__) && defined(__APPLE__)
+
+// The following functions are only needed for emulation of getaddrinfo and
+// getnameinfo.
+
+inline asio::error_code translate_netdb_error(int error)
+{
+  switch (error)
+  {
+  case 0:
+    return asio::error_code();
+  case HOST_NOT_FOUND:
+    return asio::error::host_not_found;
+  case TRY_AGAIN:
+    return asio::error::host_not_found_try_again;
+  case NO_RECOVERY:
+    return asio::error::no_recovery;
+  case NO_DATA:
+    return asio::error::no_data;
+  default:
+    ASIO_ASSERT(false);
+    return asio::error::invalid_argument;
+  }
+}
+
+inline hostent* gethostbyaddr(const char* addr, int length, int af,
+    hostent* result, char* buffer, int buflength, asio::error_code& ec)
+{
+  clear_last_error();
+#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+  (void)(buffer);
+  (void)(buflength);
+  hostent* retval = error_wrapper(::gethostbyaddr(addr, length, af), ec);
+  if (!retval)
+    return 0;
+  ec = asio::error_code();
+  *result = *retval;
+  return retval;
+#elif defined(__sun) || defined(__QNX__)
+  int error = 0;
+  hostent* retval = error_wrapper(::gethostbyaddr_r(addr, length, af, result,
+        buffer, buflength, &error), ec);
+  if (error)
+    ec = translate_netdb_error(error);
+  return retval;
+#elif defined(__MACH__) && defined(__APPLE__)
+  (void)(buffer);
+  (void)(buflength);
+  int error = 0;
+  hostent* retval = error_wrapper(::getipnodebyaddr(
+        addr, length, af, &error), ec);
+  if (error)
+    ec = translate_netdb_error(error);
+  if (!retval)
+    return 0;
+  *result = *retval;
+  return retval;
+#else
+  hostent* retval = 0;
+  int error = 0;
+  error_wrapper(::gethostbyaddr_r(addr, length, af, result, buffer,
+        buflength, &retval, &error), ec);
+  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, asio::error_code& ec)
+{
+  clear_last_error();
+#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+  (void)(buffer);
+  (void)(buflength);
+  (void)(ai_flags);
+  if (af != ASIO_OS_DEF(AF_INET))
+  {
+    ec = asio::error::address_family_not_supported;
+    return 0;
+  }
+  hostent* retval = error_wrapper(::gethostbyname(name), ec);
+  if (!retval)
+    return 0;
+  ec = asio::error_code();
+  *result = *retval;
+  return result;
+#elif defined(__sun) || defined(__QNX__)
+  (void)(ai_flags);
+  if (af != ASIO_OS_DEF(AF_INET))
+  {
+    ec = asio::error::address_family_not_supported;
+    return 0;
+  }
+  int error = 0;
+  hostent* retval = error_wrapper(::gethostbyname_r(name, result, buffer,
+        buflength, &error), ec);
+  if (error)
+    ec = translate_netdb_error(error);
+  return retval;
+#elif defined(__MACH__) && defined(__APPLE__)
+  (void)(buffer);
+  (void)(buflength);
+  int error = 0;
+  hostent* retval = error_wrapper(::getipnodebyname(
+        name, af, ai_flags, &error), ec);
+  if (error)
+    ec = translate_netdb_error(error);
+  if (!retval)
+    return 0;
+  *result = *retval;
+  return retval;
+#else
+  (void)(ai_flags);
+  if (af != ASIO_OS_DEF(AF_INET))
+  {
+    ec = asio::error::address_family_not_supported;
+    return 0;
+  }
+  hostent* retval = 0;
+  int error = 0;
+  error_wrapper(::gethostbyname_r(name, result,
+        buffer, buflength, &retval, &error), ec);
+  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 ASIO_OS_DEF(AF_INET):
+        search[search_count].host = "0.0.0.0";
+        search[search_count].family = ASIO_OS_DEF(AF_INET);
+        ++search_count;
+        break;
+      case ASIO_OS_DEF(AF_INET6):
+        search[search_count].host = "0::0";
+        search[search_count].family = ASIO_OS_DEF(AF_INET6);
+        ++search_count;
+        break;
+      case ASIO_OS_DEF(AF_UNSPEC):
+        search[search_count].host = "0::0";
+        search[search_count].family = ASIO_OS_DEF(AF_INET6);
+        ++search_count;
+        search[search_count].host = "0.0.0.0";
+        search[search_count].family = 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 ASIO_OS_DEF(AF_INET):
+        search[search_count].host = "localhost";
+        search[search_count].family = ASIO_OS_DEF(AF_INET);
+        ++search_count;
+        break;
+      case ASIO_OS_DEF(AF_INET6):
+        search[search_count].host = "localhost";
+        search[search_count].family = ASIO_OS_DEF(AF_INET6);
+        ++search_count;
+        break;
+      case ASIO_OS_DEF(AF_UNSPEC):
+        search[search_count].host = "localhost";
+        search[search_count].family = ASIO_OS_DEF(AF_INET6);
+        ++search_count;
+        search[search_count].host = "localhost";
+        search[search_count].family = ASIO_OS_DEF(AF_INET);
+        ++search_count;
+        break;
+      default:
+        break;
+      }
+    }
+  }
+  else
+  {
+    // Host is specified.
+    switch (hints->ai_family)
+    {
+    case ASIO_OS_DEF(AF_INET):
+      search[search_count].host = host;
+      search[search_count].family = ASIO_OS_DEF(AF_INET);
+      ++search_count;
+      break;
+    case ASIO_OS_DEF(AF_INET6):
+      search[search_count].host = host;
+      search[search_count].family = ASIO_OS_DEF(AF_INET6);
+      ++search_count;
+      break;
+    case ASIO_OS_DEF(AF_UNSPEC):
+      search[search_count].host = host;
+      search[search_count].family = ASIO_OS_DEF(AF_INET6);
+      ++search_count;
+      search[search_count].host = host;
+      search[search_count].family = 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(ASIO_HAS_SECURE_RTL)
+  strcpy_s(target, max_size, source);
+#else // defined(ASIO_HAS_SECURE_RTL)
+  *target = 0;
+  strncat(target, source, max_size);
+#endif // defined(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 ASIO_OS_DEF(AF_INET):
+    {
+      sockaddr_in4_type* sinptr = gai_alloc<sockaddr_in4_type>();
+      if (sinptr == 0)
+        return EAI_MEMORY;
+      sinptr->sin_family = 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 ASIO_OS_DEF(AF_INET6):
+    {
+      sockaddr_in6_type* sin6ptr = gai_alloc<sockaddr_in6_type>();
+      if (sin6ptr == 0)
+        return EAI_MEMORY;
+      sin6ptr->sin6_family = 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 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 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 ASIO_OS_DEF(AF_UNSPEC):
+    break;
+  case ASIO_OS_DEF(AF_INET):
+  case 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 = 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 != ASIO_OS_DEF(AF_INET6))
+    hints.ai_flags &= ~AI_V4MAPPED;
+#endif
+#if defined(AI_ALL)
+  if (hints.ai_family != 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;
+    asio::error_code ec;
+    if (socket_ops::inet_pton(ASIO_OS_DEF(AF_INET),
+          sptr->host, &inaddr, 0, ec) == 1)
+    {
+      if (hints.ai_family != ASIO_OS_DEF(AF_UNSPEC)
+          && hints.ai_family != ASIO_OS_DEF(AF_INET))
+      {
+        freeaddrinfo_emulation(aihead);
+        gai_free(canon);
+        return EAI_FAMILY;
+      }
+      if (sptr->family == ASIO_OS_DEF(AF_INET))
+      {
+        rc = gai_aistruct(&ainext, &hints, &inaddr, 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(ASIO_OS_DEF(AF_INET6),
+          sptr->host, &in6addr, 0, ec) == 1)
+    {
+      if (hints.ai_family != ASIO_OS_DEF(AF_UNSPEC)
+          && hints.ai_family != ASIO_OS_DEF(AF_INET6))
+      {
+        freeaddrinfo_emulation(aihead);
+        gai_free(canon);
+        return EAI_FAMILY;
+      }
+      if (sptr->family == ASIO_OS_DEF(AF_INET6))
+      {
+        rc = gai_aistruct(&ainext, &hints, &in6addr,
+            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 == asio::error::host_not_found)
+        return EAI_NONAME;
+      if (ec == asio::error::host_not_found_try_again)
+        return EAI_AGAIN;
+      if (ec == asio::error::no_recovery)
+        return EAI_FAIL;
+      if (ec == asio::error::no_data)
+        return EAI_NONAME;
+      return EAI_NONAME;
+    }
+
+    // Check for address family mismatch if one was specified.
+    if (hints.ai_family != 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 asio::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,
+    asio::error_code& ec)
+{
+  using namespace std;
+
+  const char* addr;
+  size_t addr_len;
+  unsigned short port;
+  switch (sa->sa_family)
+  {
+  case ASIO_OS_DEF(AF_INET):
+    if (salen != sizeof(sockaddr_in4_type))
+    {
+      return ec = 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 ASIO_OS_DEF(AF_INET6):
+    if (salen != sizeof(sockaddr_in6_type))
+    {
+      return ec = 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 = 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 = 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 = asio::error::no_buffer_space;
+      }
+#if defined(ASIO_HAS_SECURE_RTL)
+      sprintf_s(serv, servlen, "%u", ntohs(port));
+#else // defined(ASIO_HAS_SECURE_RTL)
+      sprintf(serv, "%u", ntohs(port));
+#endif // defined(ASIO_HAS_SECURE_RTL)
+    }
+    else
+    {
+#if defined(ASIO_HAS_PTHREADS)
+      static ::pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
+      ::pthread_mutex_lock(&mutex);
+#endif // defined(ASIO_HAS_PTHREADS)
+      servent* sptr = ::getservbyport(port, (flags & NI_DGRAM) ? "udp" : 0);
+      if (sptr && sptr->s_name && sptr->s_name[0] != '\0')
+      {
+        gai_strcpy(s

<TRUNCATED>

Mime
View raw message