couchbase 3.0.0-universal-darwin-19 → 3.0.1-universal-darwin-19

data/ext/third_party/asio/asio/include/asio/detail/impl/handler_tracking.ipp

@@ -73,11 +73,12 @@ struct handler_tracking::tracking_state
   static_mutex mutex_;
   uint64_t next_id_;
   tss_ptr<completion>* current_completion_;
+  tss_ptr<location>* current_location_;
 };
 
 handler_tracking::tracking_state* handler_tracking::get_state()
 {
-  static tracking_state state = { ASIO_STATIC_MUTEX_INIT, 1, 0 };
+  static tracking_state state = { ASIO_STATIC_MUTEX_INIT, 1, 0, 0 };
   return &state;
 }
 
@@ -90,6 +91,25 @@ void handler_tracking::init()
   static_mutex::scoped_lock lock(state->mutex_);
   if (state->current_completion_ == 0)
     state->current_completion_ = new tss_ptr<completion>;
+  if (state->current_location_ == 0)
+    state->current_location_ = new tss_ptr<location>;
+}
+
+handler_tracking::location::location(
+    const char* file, int line, const char* func)
+  : file_(file),
+    line_(line),
+    func_(func),
+    next_(*get_state()->current_location_)
+{
+  if (file_)
+    *get_state()->current_location_ = this;
+}
+
+handler_tracking::location::~location()
+{
+  if (file_)
+    *get_state()->current_location_ = next_;
 }
 
 void handler_tracking::creation(execution_context&,
@@ -109,6 +129,24 @@ void handler_tracking::creation(execution_context&,
   if (completion* current_completion = *state->current_completion_)
     current_id = current_completion->id_;
 
+  for (location* current_location = *state->current_location_;
+      current_location; current_location = current_location->next_)
+  {
+    write_line(
+#if defined(ASIO_WINDOWS)
+        "@asio|%I64u.%06I64u|%I64u^%I64u|%s%s%.80s%s(%.80s:%d)\n",
+#else // defined(ASIO_WINDOWS)
+        "@asio|%llu.%06llu|%llu^%llu|%s%s%.80s%s(%.80s:%d)\n",
+#endif // defined(ASIO_WINDOWS)
+        timestamp.seconds, timestamp.microseconds,
+        current_id, h.id_,
+        current_location == *state->current_location_ ? "in " : "called from ",
+        current_location->func_ ? "'" : "",
+        current_location->func_ ? current_location->func_ : "",
+        current_location->func_ ? "' " : "",
+        current_location->file_, current_location->line_);
+  }
+
   write_line(
 #if defined(ASIO_WINDOWS)
       "@asio|%I64u.%06I64u|%I64u*%I64u|%.20s@%p.%.50s\n",

data/ext/third_party/asio/asio/include/asio/detail/impl/reactive_serial_port_service.ipp

@@ -69,8 +69,8 @@ asio::error_code reactive_serial_port_service::open(
 
   // Set up default serial port options.
   termios ios;
-  errno = 0;
-  s = descriptor_ops::error_wrapper(::tcgetattr(fd, &ios), ec);
+  s = ::tcgetattr(fd, &ios);
+  descriptor_ops::get_last_error(ec, s < 0);
   if (s >= 0)
   {
 #if defined(_BSD_SOURCE) || defined(_DEFAULT_SOURCE)
@@ -85,8 +85,8 @@ asio::error_code reactive_serial_port_service::open(
 #endif
     ios.c_iflag |= IGNPAR;
     ios.c_cflag |= CREAD | CLOCAL;
-    errno = 0;
-    s = descriptor_ops::error_wrapper(::tcsetattr(fd, TCSANOW, &ios), ec);
+    s = ::tcsetattr(fd, TCSANOW, &ios);
+    descriptor_ops::get_last_error(ec, s < 0);
   }
   if (s < 0)
   {
@@ -111,18 +111,16 @@ asio::error_code reactive_serial_port_service::do_set_option(
     const void* option, asio::error_code& ec)
 {
   termios ios;
-  errno = 0;
-  descriptor_ops::error_wrapper(::tcgetattr(
-        descriptor_service_.native_handle(impl), &ios), ec);
-  if (ec)
+  int s = ::tcgetattr(descriptor_service_.native_handle(impl), &ios);
+  descriptor_ops::get_last_error(ec, s < 0);
+  if (s < 0)
     return ec;
 
   if (store(option, ios, ec))
     return ec;
 
-  errno = 0;
-  descriptor_ops::error_wrapper(::tcsetattr(
-        descriptor_service_.native_handle(impl), TCSANOW, &ios), ec);
+  s = ::tcsetattr(descriptor_service_.native_handle(impl), TCSANOW, &ios);
+  descriptor_ops::get_last_error(ec, s < 0);
   return ec;
 }
 
@@ -132,10 +130,9 @@ asio::error_code reactive_serial_port_service::do_get_option(
     void* option, asio::error_code& ec) const
 {
   termios ios;
-  errno = 0;
-  descriptor_ops::error_wrapper(::tcgetattr(
-        descriptor_service_.native_handle(impl), &ios), ec);
-  if (ec)
+  int s = ::tcgetattr(descriptor_service_.native_handle(impl), &ios);
+  descriptor_ops::get_last_error(ec, s < 0);
+  if (s < 0)
     return ec;
 
   return load(option, ios, ec);

data/ext/third_party/asio/asio/include/asio/detail/impl/scheduler.ipp

@@ -135,6 +135,10 @@ scheduler::~scheduler()
 {
   if (thread_)
   {
+    mutex::scoped_lock lock(mutex_);
+    shutdown_ = true;
+    stop_all_threads(lock);
+    lock.unlock();
     thread_->join();
     delete thread_;
   }
@@ -320,6 +324,12 @@ void scheduler::compensating_work_started()
   ++static_cast<thread_info*>(this_thread)->private_outstanding_work;
 }
 
+void scheduler::capture_current_exception()
+{
+  if (thread_info_base* this_thread = thread_call_stack::contains(this))
+    this_thread->capture_current_exception();
+}
+
 void scheduler::post_immediate_completion(
     scheduler::operation* op, bool is_continuation)
 {
@@ -343,6 +353,30 @@ void scheduler::post_immediate_completion(
   wake_one_thread_and_unlock(lock);
 }
 
+void scheduler::post_immediate_completions(std::size_t n,
+    op_queue<scheduler::operation>& ops, bool is_continuation)
+{
+#if defined(ASIO_HAS_THREADS)
+  if (one_thread_ || is_continuation)
+  {
+    if (thread_info_base* this_thread = thread_call_stack::contains(this))
+    {
+      static_cast<thread_info*>(this_thread)->private_outstanding_work
+        += static_cast<long>(n);
+      static_cast<thread_info*>(this_thread)->private_op_queue.push(ops);
+      return;
+    }
+  }
+#else // defined(ASIO_HAS_THREADS)
+  (void)is_continuation;
+#endif // defined(ASIO_HAS_THREADS)
+
+  increment(outstanding_work_, static_cast<long>(n));
+  mutex::scoped_lock lock(mutex_);
+  op_queue_.push(ops);
+  wake_one_thread_and_unlock(lock);
+}
+
 void scheduler::post_deferred_completion(scheduler::operation* op)
 {
 #if defined(ASIO_HAS_THREADS)
@@ -444,6 +478,7 @@ std::size_t scheduler::do_run_one(mutex::scoped_lock& lock,
 
         // Complete the operation. May throw an exception. Deletes the object.
         o->complete(this, ec, task_result);
+        this_thread.rethrow_pending_exception();
 
         return 1;
       }
@@ -524,6 +559,7 @@ std::size_t scheduler::do_wait_one(mutex::scoped_lock& lock,
 
   // Complete the operation. May throw an exception. Deletes the object.
   o->complete(this, ec, task_result);
+  this_thread.rethrow_pending_exception();
 
   return 1;
 }
@@ -578,6 +614,7 @@ std::size_t scheduler::do_poll_one(mutex::scoped_lock& lock,
 
   // Complete the operation. May throw an exception. Deletes the object.
   o->complete(this, ec, task_result);
+  this_thread.rethrow_pending_exception();
 
   return 1;
 }

data/ext/third_party/asio/asio/include/asio/detail/impl/signal_set_service.ipp

@@ -89,7 +89,8 @@ class signal_set_service::pipe_read_op : public reactor_op
 {
 public:
   pipe_read_op()
-    : reactor_op(&pipe_read_op::do_perform, pipe_read_op::do_complete)
+    : reactor_op(asio::error_code(),
+        &pipe_read_op::do_perform, pipe_read_op::do_complete)
   {
   }
 

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

@@ -73,18 +73,23 @@ inline void clear_last_error()
 
 #if !defined(ASIO_WINDOWS_RUNTIME)
 
-template <typename ReturnType>
-inline ReturnType error_wrapper(ReturnType return_value,
-    asio::error_code& ec)
+inline void get_last_error(
+    asio::error_code& ec, bool is_error_condition)
 {
+  if (!is_error_condition)
+  {
+    ec.assign(0, ec.category());
+  }
+  else
+  {
 #if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  ec = asio::error_code(WSAGetLastError(),
-      asio::error::get_system_category());
+    ec = asio::error_code(WSAGetLastError(),
+        asio::error::get_system_category());
 #else
-  ec = asio::error_code(errno,
-      asio::error::get_system_category());
+    ec = asio::error_code(errno,
+        asio::error::get_system_category());
 #endif
-  return return_value;
+  }
 }
 
 template <typename SockLenType>
@@ -107,17 +112,16 @@ socket_type accept(socket_type s, socket_addr_type* addr,
     return invalid_socket;
   }
 
-  clear_last_error();
-
-  socket_type new_s = error_wrapper(call_accept(
-        &msghdr::msg_namelen, s, addr, addrlen), ec);
+  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 = error_wrapper(::setsockopt(new_s,
-        SOL_SOCKET, SO_NOSIGPIPE, &optval, sizeof(optval)), ec);
+  int result = ::setsockopt(new_s, SOL_SOCKET,
+      SO_NOSIGPIPE, &optval, sizeof(optval));
+  get_last_error(ec, result != 0);
   if (result != 0)
   {
     ::close(new_s);
@@ -125,7 +129,7 @@ socket_type accept(socket_type s, socket_addr_type* addr,
   }
 #endif
 
-  ec = asio::error_code();
+  ec.assign(0, ec.category());
   return new_s;
 }
 
@@ -282,11 +286,8 @@ int bind(socket_type s, const socket_addr_type* addr,
     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();
+  int result = call_bind(&msghdr::msg_namelen, s, addr, addrlen);
+  get_last_error(ec, result != 0);
   return result;
 }
 
@@ -309,12 +310,12 @@ int close(socket_type s, state_type& state,
           SO_LINGER, &opt, sizeof(opt), ignored_ec);
     }
 
-    clear_last_error();
 #if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-    result = error_wrapper(::closesocket(s), ec);
+    result = ::closesocket(s);
 #else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-    result = error_wrapper(::close(s), ec);
+    result = ::close(s);
 #endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+    get_last_error(ec, result != 0);
 
     if (result != 0
         && (ec == asio::error::would_block
@@ -341,17 +342,15 @@ int close(socket_type s, state_type& state,
 #endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
       state &= ~non_blocking;
 
-      clear_last_error();
 #if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-      result = error_wrapper(::closesocket(s), ec);
+      result = ::closesocket(s);
 #else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-      result = error_wrapper(::close(s), ec);
+      result = ::close(s);
 #endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+      get_last_error(ec, result != 0);
     }
   }
 
-  if (result == 0)
-    ec = asio::error_code();
   return result;
 }
 
@@ -364,26 +363,27 @@ bool set_user_non_blocking(socket_type s,
     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);
+  int result = ::ioctlsocket(s, FIONBIO, &arg);
+  get_last_error(ec, result < 0);
 #elif defined(__SYMBIAN32__) || defined(__EMSCRIPTEN__)
-  int result = error_wrapper(::fcntl(s, F_GETFL, 0), ec);
+  int result = ::fcntl(s, F_GETFL, 0);
+  get_last_error(ec, result < 0);
   if (result >= 0)
   {
-    clear_last_error();
     int flag = (value ? (result | O_NONBLOCK) : (result & ~O_NONBLOCK));
-    result = error_wrapper(::fcntl(s, F_SETFL, flag), ec);
+    result = ::fcntl(s, F_SETFL, flag);
+    get_last_error(ec, result < 0);
   }
 #else
   ioctl_arg_type arg = (value ? 1 : 0);
-  int result = error_wrapper(::ioctl(s, FIONBIO, &arg), ec);
+  int result = ::ioctl(s, FIONBIO, &arg);
+  get_last_error(ec, result < 0);
 #endif
 
   if (result >= 0)
   {
-    ec = asio::error_code();
     if (value)
       state |= user_set_non_blocking;
     else
@@ -417,26 +417,27 @@ bool set_internal_non_blocking(socket_type s,
     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);
+  int result = ::ioctlsocket(s, FIONBIO, &arg);
+  get_last_error(ec, result < 0);
 #elif defined(__SYMBIAN32__) || defined(__EMSCRIPTEN__)
-  int result = error_wrapper(::fcntl(s, F_GETFL, 0), ec);
+  int result = ::fcntl(s, F_GETFL, 0);
+  get_last_error(ec, result < 0);
   if (result >= 0)
   {
-    clear_last_error();
     int flag = (value ? (result | O_NONBLOCK) : (result & ~O_NONBLOCK));
-    result = error_wrapper(::fcntl(s, F_SETFL, flag), ec);
+    result = ::fcntl(s, F_SETFL, flag);
+    get_last_error(ec, result < 0);
   }
 #else
   ioctl_arg_type arg = (value ? 1 : 0);
-  int result = error_wrapper(::ioctl(s, FIONBIO, &arg), ec);
+  int result = ::ioctl(s, FIONBIO, &arg);
+  get_last_error(ec, result < 0);
 #endif
 
   if (result >= 0)
   {
-    ec = asio::error_code();
     if (value)
       state |= internal_non_blocking;
     else
@@ -455,10 +456,8 @@ int shutdown(socket_type s, int what, asio::error_code& ec)
     return socket_error_retval;
   }
 
-  clear_last_error();
-  int result = error_wrapper(::shutdown(s, what), ec);
-  if (result == 0)
-    ec = asio::error_code();
+  int result = ::shutdown(s, what);
+  get_last_error(ec, result != 0);
   return result;
 }
 
@@ -478,13 +477,10 @@ int connect(socket_type s, const socket_addr_type* addr,
     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();
+  int result = call_connect(&msghdr::msg_namelen, s, addr, addrlen);
+  get_last_error(ec, result != 0);
 #if defined(__linux__)
-  else if (ec == asio::error::try_again)
+  if (result != 0 && ec == asio::error::try_again)
     ec = asio::error::no_buffer_space;
 #endif // defined(__linux__)
   return result;
@@ -600,7 +596,7 @@ bool non_blocking_connect(socket_type s, asio::error_code& ec)
           asio::error::get_system_category());
     }
     else
-      ec = asio::error_code();
+      ec.assign(0, ec.category());
   }
 
   return true;
@@ -617,10 +613,8 @@ int socketpair(int af, int type, int protocol,
   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();
+  int result = ::socketpair(af, type, protocol, sv);
+  get_last_error(ec, result != 0);
   return result;
 #endif
 }
@@ -636,20 +630,18 @@ bool sockatmark(socket_type s, asio::error_code& ec)
 #if defined(SIOCATMARK)
   ioctl_arg_type value = 0;
 # if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  int result = error_wrapper(::ioctlsocket(s, SIOCATMARK, &value), ec);
+  int result = ::ioctlsocket(s, SIOCATMARK, &value);
 # else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  int result = error_wrapper(::ioctl(s, SIOCATMARK, &value), ec);
+  int result = ::ioctl(s, SIOCATMARK, &value);
 # endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  if (result == 0)
-    ec = asio::error_code();
+  get_last_error(ec, result < 0);
 # 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();
+  int value = ::sockatmark(s);
+  get_last_error(ec, result < 0);
 #endif // defined(SIOCATMARK)
 
   return ec ? false : value != 0;
@@ -665,12 +657,11 @@ size_t available(socket_type s, asio::error_code& ec)
 
   ioctl_arg_type value = 0;
 #if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  int result = error_wrapper(::ioctlsocket(s, FIONREAD, &value), ec);
+  int result = ::ioctlsocket(s, FIONREAD, &value);
 #else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  int result = error_wrapper(::ioctl(s, FIONREAD, &value), ec);
+  int result = ::ioctl(s, FIONREAD, &value);
 #endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  if (result == 0)
-    ec = asio::error_code();
+  get_last_error(ec, result < 0);
 #if defined(ENOTTY)
   if (ec.value() == ENOTTY)
     ec = asio::error::not_socket;
@@ -687,10 +678,8 @@ int listen(socket_type s, int backlog, asio::error_code& ec)
     return socket_error_retval;
   }
 
-  clear_last_error();
-  int result = error_wrapper(::listen(s, backlog), ec);
-  if (result == 0)
-    ec = asio::error_code();
+  int result = ::listen(s, backlog);
+  get_last_error(ec, result != 0);
   return result;
 }
 
@@ -758,14 +747,14 @@ inline void init_msghdr_msg_name(T& name, const 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);
+  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 = asio::error::connection_reset;
   else if (ec.value() == ERROR_PORT_UNREACHABLE)
@@ -774,15 +763,44 @@ signed_size_type recv(socket_type s, buf* bufs, size_t count,
     result = 0;
   if (result != 0)
     return socket_error_retval;
-  ec = asio::error_code();
+  ec.assign(0, ec.category());
   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();
+  signed_size_type result = ::recvmsg(s, &msg, flags);
+  get_last_error(ec, result < 0);
+  return result;
+#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+}
+
+signed_size_type recv1(socket_type s, void* data, size_t size,
+    int flags, asio::error_code& ec)
+{
+#if defined(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 = asio::error::connection_reset;
+  else if (ec.value() == ERROR_PORT_UNREACHABLE)
+    ec = asio::error::connection_refused;
+  else if (ec.value() == WSAEMSGSIZE || ec.value() == ERROR_MORE_DATA)
+    result = 0;
+  if (result != 0)
+    return socket_error_retval;
+  ec.assign(0, ec.category());
+  return bytes_transferred;
+#else // defined(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(ASIO_WINDOWS) || defined(__CYGWIN__)
 }
@@ -799,7 +817,7 @@ size_t sync_recv(socket_type s, state_type state, buf* bufs,
   // A request to read 0 bytes on a stream is a no-op.
   if (all_empty && (state & stream_oriented))
   {
-    ec = asio::error_code();
+    ec.assign(0, ec.category());
     return 0;
   }
 
@@ -809,10 +827,51 @@ size_t sync_recv(socket_type s, state_type state, buf* bufs,
     // 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 = asio::error::eof;
+      return 0;
+    }
+
     // Check if operation succeeded.
-    if (bytes > 0)
+    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, -1, ec) < 0)
+      return 0;
+  }
+}
+
+size_t sync_recv1(socket_type s, state_type state, void* data,
+    size_t size, int flags, 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 (size == 0 && (state & stream_oriented))
+  {
+    ec.assign(0, ec.category());
+    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)
     {
@@ -820,6 +879,10 @@ size_t sync_recv(socket_type s, state_type state, buf* bufs,
       return 0;
     }
 
+    // Check if operation succeeded.
+    if (bytes >= 0)
+      return bytes;
+
     // Operation failed.
     if ((state & user_set_non_blocking)
         || (ec != asio::error::would_block
@@ -882,6 +945,13 @@ bool non_blocking_recv(socket_type s,
       return true;
     }
 
+    // Check if operation succeeded.
+    if (bytes >= 0)
+    {
+      bytes_transferred = bytes;
+      return true;
+    }
+
     // Retry operation if interrupted by signal.
     if (ec == asio::error::interrupted)
       continue;
@@ -891,15 +961,46 @@ bool non_blocking_recv(socket_type s,
         || ec == asio::error::try_again)
       return false;
 
-    // Operation is complete.
+    // Operation failed.
+    bytes_transferred = 0;
+    return true;
+  }
+}
+
+bool non_blocking_recv1(socket_type s,
+    void* data, size_t size, int flags, bool is_stream,
+    asio::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 = asio::error::eof;
+      return true;
+    }
+
+    // Check if operation succeeded.
     if (bytes >= 0)
     {
-      ec = asio::error_code();
       bytes_transferred = bytes;
+      return true;
     }
-    else
-      bytes_transferred = 0;
 
+    // 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 failed.
+    bytes_transferred = 0;
     return true;
   }
 }
@@ -910,15 +1011,15 @@ 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);
+  int result = ::WSARecvFrom(s, bufs, recv_buf_count,
+        &bytes_transferred, &recv_flags, addr, &tmp_addrlen, 0, 0);
+  get_last_error(ec, true);
   *addrlen = (std::size_t)tmp_addrlen;
   if (ec.value() == ERROR_NETNAME_DELETED)
     ec = asio::error::connection_reset;
@@ -928,7 +1029,7 @@ signed_size_type recvfrom(socket_type s, buf* bufs, size_t count,
     result = 0;
   if (result != 0)
     return socket_error_retval;
-  ec = asio::error_code();
+  ec.assign(0, ec.category());
   return bytes_transferred;
 #else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
   msghdr msg = msghdr();
@@ -936,10 +1037,56 @@ signed_size_type recvfrom(socket_type s, buf* bufs, size_t count,
   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);
+  signed_size_type result = ::recvmsg(s, &msg, flags);
+  get_last_error(ec, result < 0);
   *addrlen = msg.msg_namelen;
-  if (result >= 0)
-    ec = asio::error_code();
+  return result;
+#endif // defined(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,
+    socket_addr_type* addr, std::size_t* addrlen)
+{
+  SockLenType tmp_addrlen = addrlen ? (SockLenType)*addrlen : 0;
+  signed_size_type result = ::recvfrom(s, static_cast<char*>(data),
+      size, flags, addr, addrlen ? &tmp_addrlen : 0);
+  if (addrlen)
+    *addrlen = (std::size_t)tmp_addrlen;
+  return result;
+}
+
+signed_size_type recvfrom1(socket_type s, void* data, size_t size,
+    int flags, socket_addr_type* addr, std::size_t* addrlen,
+    asio::error_code& ec)
+{
+#if defined(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, addr, &tmp_addrlen, 0, 0);
+  get_last_error(ec, true);
+  *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;
+  else if (ec.value() == WSAEMSGSIZE || ec.value() == ERROR_MORE_DATA)
+    result = 0;
+  if (result != 0)
+    return socket_error_retval;
+  ec.assign(0, ec.category());
+  return bytes_transferred;
+#else // defined(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(ASIO_WINDOWS) || defined(__CYGWIN__)
 }
@@ -977,6 +1124,39 @@ size_t sync_recvfrom(socket_type s, state_type state, buf* bufs,
   }
 }
 
+size_t sync_recvfrom1(socket_type s, state_type state, void* data,
+    size_t size, int flags, socket_addr_type* addr,
+    std::size_t* addrlen, asio::error_code& ec)
+{
+  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::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 != asio::error::would_block
+          && ec != 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(ASIO_HAS_IOCP)
 
 void complete_iocp_recvfrom(
@@ -1014,6 +1194,13 @@ bool non_blocking_recvfrom(socket_type s,
     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 == asio::error::interrupted)
       continue;
@@ -1023,15 +1210,41 @@ bool non_blocking_recvfrom(socket_type s,
         || ec == asio::error::try_again)
       return false;
 
-    // Operation is complete.
+    // Operation failed.
+    bytes_transferred = 0;
+    return true;
+  }
+}
+
+bool non_blocking_recvfrom1(socket_type s,
+    void* data, size_t size, 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::recvfrom1(
+        s, data, size, flags, addr, addrlen, ec);
+
+    // Check if operation succeeded.
     if (bytes >= 0)
     {
-      ec = asio::error_code();
       bytes_transferred = bytes;
+      return true;
     }
-    else
-      bytes_transferred = 0;
 
+    // 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 failed.
+    bytes_transferred = 0;
     return true;
   }
 }
@@ -1041,7 +1254,6 @@ bool non_blocking_recvfrom(socket_type s,
 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);
@@ -1049,12 +1261,10 @@ signed_size_type recvmsg(socket_type s, buf* bufs, size_t count,
   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);
+  signed_size_type result = ::recvmsg(s, &msg, in_flags);
+  get_last_error(ec, result < 0);
   if (result >= 0)
-  {
-    ec = asio::error_code();
     out_flags = msg.msg_flags;
-  }
   else
     out_flags = 0;
   return result;
@@ -1130,6 +1340,13 @@ bool non_blocking_recvmsg(socket_type s,
     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 == asio::error::interrupted)
       continue;
@@ -1139,15 +1356,8 @@ bool non_blocking_recvmsg(socket_type s,
         || ec == asio::error::try_again)
       return false;
 
-    // Operation is complete.
-    if (bytes >= 0)
-    {
-      ec = asio::error_code();
-      bytes_transferred = bytes;
-    }
-    else
-      bytes_transferred = 0;
-
+    // Operation failed.
+    bytes_transferred = 0;
     return true;
   }
 }
@@ -1157,21 +1367,21 @@ bool non_blocking_recvmsg(socket_type s,
 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);
+  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 = 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();
+  ec.assign(0, ec.category());
   return bytes_transferred;
 #else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
   msghdr msg = msghdr();
@@ -1180,9 +1390,40 @@ signed_size_type send(socket_type s, const buf* bufs, size_t 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();
+  signed_size_type result = ::sendmsg(s, &msg, flags);
+  get_last_error(ec, result < 0);
+  return result;
+#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+}
+
+signed_size_type send1(socket_type s, const void* data, size_t size,
+    int flags, asio::error_code& ec)
+{
+#if defined(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 = asio::error::connection_reset;
+  else if (ec.value() == ERROR_PORT_UNREACHABLE)
+    ec = asio::error::connection_refused;
+  if (result != 0)
+    return socket_error_retval;
+  ec.assign(0, ec.category());
+  return bytes_transferred;
+#else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+#if defined(__linux__)
+  flags |= MSG_NOSIGNAL;
+#endif // defined(__linux__)
+  signed_size_type result = ::send(s,
+      static_cast<const char*>(data), size, flags);
+  get_last_error(ec, result < 0);
   return result;
 #endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
 }
@@ -1199,7 +1440,7 @@ size_t sync_send(socket_type s, state_type state, const buf* bufs,
   // A request to write 0 bytes to a stream is a no-op.
   if (all_empty && (state & stream_oriented))
   {
-    ec = asio::error_code();
+    ec.assign(0, ec.category());
     return 0;
   }
 
@@ -1225,6 +1466,44 @@ size_t sync_send(socket_type s, state_type state, const buf* bufs,
   }
 }
 
+size_t sync_send1(socket_type s, state_type state, const void* data,
+    size_t size, int flags, 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 (size == 0 && (state & stream_oriented))
+  {
+    ec.assign(0, ec.category());
+    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 != asio::error::would_block
+          && ec != 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(ASIO_HAS_IOCP)
 
 void complete_iocp_send(
@@ -1256,6 +1535,13 @@ bool non_blocking_send(socket_type s,
     // 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 == asio::error::interrupted)
       continue;
@@ -1265,15 +1551,39 @@ bool non_blocking_send(socket_type s,
         || ec == asio::error::try_again)
       return false;
 
-    // Operation is complete.
+    // Operation failed.
+    bytes_transferred = 0;
+    return true;
+  }
+}
+
+bool non_blocking_send1(socket_type s,
+    const void* data, size_t size, int flags,
+    asio::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)
     {
-      ec = asio::error_code();
       bytes_transferred = bytes;
+      return true;
     }
-    else
-      bytes_transferred = 0;
 
+    // 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 failed.
+    bytes_transferred = 0;
     return true;
   }
 }
@@ -1284,21 +1594,21 @@ 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),
+  int result = ::WSASendTo(s, const_cast<buf*>(bufs),
         send_buf_count, &bytes_transferred, flags, addr,
-        static_cast<int>(addrlen), 0, 0), ec);
+        static_cast<int>(addrlen), 0, 0);
+  get_last_error(ec, true);
   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();
+  ec.assign(0, ec.category());
   return bytes_transferred;
 #else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
   msghdr msg = msghdr();
@@ -1309,9 +1619,49 @@ signed_size_type sendto(socket_type s, const buf* bufs, size_t 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();
+  signed_size_type result = ::sendmsg(s, &msg, flags);
+  get_last_error(ec, result < 0);
+  return result;
+#endif // defined(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 socket_addr_type* addr, std::size_t addrlen)
+{
+  return ::sendto(s, static_cast<char*>(const_cast<void*>(data)),
+      size, flags, addr, (SockLenType)addrlen);
+}
+
+signed_size_type sendto1(socket_type s, const void* data, size_t size,
+    int flags, const socket_addr_type* addr, std::size_t addrlen,
+    asio::error_code& ec)
+{
+#if defined(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, addr, static_cast<int>(addrlen), 0, 0);
+  get_last_error(ec, true);
+  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.assign(0, ec.category());
+  return bytes_transferred;
+#else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
+#if defined(__linux__)
+  flags |= MSG_NOSIGNAL;
+#endif // defined(__linux__)
+  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(ASIO_WINDOWS) || defined(__CYGWIN__)
 }
@@ -1349,6 +1699,39 @@ size_t sync_sendto(socket_type s, state_type state, const buf* bufs,
   }
 }
 
+size_t sync_sendto1(socket_type s, state_type state, const void* data,
+    size_t size, int flags, const socket_addr_type* addr,
+    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::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 != asio::error::would_block
+          && ec != 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(ASIO_HAS_IOCP)
 
 bool non_blocking_sendto(socket_type s,
@@ -1362,6 +1745,13 @@ bool non_blocking_sendto(socket_type s,
     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 == asio::error::interrupted)
       continue;
@@ -1371,15 +1761,41 @@ bool non_blocking_sendto(socket_type s,
         || ec == asio::error::try_again)
       return false;
 
-    // Operation is complete.
+    // Operation failed.
+    bytes_transferred = 0;
+    return true;
+  }
+}
+
+bool non_blocking_sendto1(socket_type s,
+    const void* data, size_t size, int flags,
+    const socket_addr_type* addr, std::size_t addrlen,
+    asio::error_code& ec, 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)
     {
-      ec = asio::error_code();
       bytes_transferred = bytes;
+      return true;
     }
-    else
-      bytes_transferred = 0;
 
+    // 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 failed.
+    bytes_transferred = 0;
     return true;
   }
 }
@@ -1389,10 +1805,9 @@ bool non_blocking_sendto(socket_type s,
 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(::WSASocketW(af, type, protocol, 0, 0,
-        WSA_FLAG_OVERLAPPED), ec);
+  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;
 
@@ -1406,17 +1821,15 @@ socket_type socket(int af, int type, int protocol,
         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;
+  socket_type s = ::socket(af, type, protocol);
+  get_last_error(ec, s < 0);
 
   int optval = 1;
-  int result = error_wrapper(::setsockopt(s,
-        SOL_SOCKET, SO_NOSIGPIPE, &optval, sizeof(optval)), ec);
+  int result = ::setsockopt(s, SOL_SOCKET,
+      SO_NOSIGPIPE, &optval, sizeof(optval));
+  get_last_error(ec, result != 0);
   if (result != 0)
   {
     ::close(s);
@@ -1425,9 +1838,8 @@ socket_type socket(int af, int type, int protocol,
 
   return s;
 #else
-  int s = error_wrapper(::socket(af, type, protocol), ec);
-  if (s >= 0)
-    ec = asio::error_code();
+  int s = ::socket(af, type, protocol);
+  get_last_error(ec, s < 0);
   return s;
 #endif
 }
@@ -1469,7 +1881,7 @@ int setsockopt(socket_type s, state_type& state, int level, int optname,
       state |= enable_connection_aborted;
     else
       state &= ~enable_connection_aborted;
-    ec = asio::error_code();
+    ec.assign(0, ec.category());
     return 0;
   }
 
@@ -1485,22 +1897,21 @@ int setsockopt(socket_type s, state_type& state, int level, int optname,
     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,
+      int result = sso(s, level, optname,
             reinterpret_cast<const char*>(optval),
-            static_cast<int>(optlen)), ec);
+            static_cast<int>(optlen));
+      get_last_error(ec, result != 0);
+      return result;
     }
   }
   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);
+  int result = call_setsockopt(&msghdr::msg_namelen,
+        s, level, optname, optval, optlen);
+  get_last_error(ec, result != 0);
   if (result == 0)
   {
-    ec = asio::error_code();
-
 #if defined(__MACH__) && defined(__APPLE__) \
   || defined(__NetBSD__) || defined(__FreeBSD__) \
   || defined(__OpenBSD__) || defined(__QNX__)
@@ -1555,7 +1966,7 @@ int getsockopt(socket_type s, state_type state, int level, int optname,
     }
 
     *static_cast<int*>(optval) = (state & enable_connection_aborted) ? 1 : 0;
-    ec = asio::error_code();
+    ec.assign(0, ec.category());
     return 0;
   }
 
@@ -1568,10 +1979,10 @@ int getsockopt(socket_type s, state_type state, int level, int optname,
     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);
+      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))
@@ -1582,7 +1993,7 @@ int getsockopt(socket_type s, state_type state, int level, int optname,
         // value is non-zero (i.e. true). This corresponds to the behavior of
         // IPv6 sockets on Windows platforms pre-Vista.
         *static_cast<DWORD*>(optval) = 1;
-        ec = asio::error_code();
+        ec.assign(0, ec.category());
       }
       return result;
     }
@@ -1590,9 +2001,9 @@ int getsockopt(socket_type s, state_type state, int level, int optname,
   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);
+  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))
   {
@@ -1602,15 +2013,13 @@ int getsockopt(socket_type s, state_type state, int level, int optname,
     // non-zero (i.e. true). This corresponds to the behavior of IPv6 sockets
     // on Windows platforms pre-Vista.
     *static_cast<DWORD*>(optval) = 1;
-    ec = asio::error_code();
+    ec.assign(0, ec.category());
   }
-  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);
+  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))
@@ -1623,8 +2032,6 @@ int getsockopt(socket_type s, state_type state, int level, int optname,
     *static_cast<int*>(optval) /= 2;
   }
 #endif // defined(__linux__)
-  if (result == 0)
-    ec = asio::error_code();
   return result;
 #endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
 }
@@ -1667,7 +2074,7 @@ int getpeername(socket_type s, socket_addr_type* addr,
     }
 
     // The cached value is still valid.
-    ec = asio::error_code();
+    ec.assign(0, ec.category());
     return 0;
   }
 #else // defined(ASIO_WINDOWS) && !defined(ASIO_WINDOWS_APP)
@@ -1676,11 +2083,8 @@ int getpeername(socket_type s, socket_addr_type* addr,
 #endif // defined(ASIO_WINDOWS) && !defined(ASIO_WINDOWS_APP)
        // || 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();
+  int result = call_getpeername(&msghdr::msg_namelen, s, addr, addrlen);
+  get_last_error(ec, result != 0);
   return result;
 }
 
@@ -1703,11 +2107,8 @@ int getsockname(socket_type s, socket_addr_type* addr,
     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();
+  int result = call_getsockname(&msghdr::msg_namelen, s, addr, addrlen);
+  get_last_error(ec, result != 0);
   return result;
 }
 
@@ -1720,20 +2121,17 @@ int ioctl(socket_type s, state_type& state, int cmd,
     return socket_error_retval;
   }
 
-  clear_last_error();
 #if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  int result = error_wrapper(::ioctlsocket(s, cmd, arg), ec);
+  int result = ::ioctlsocket(s, cmd, arg);
 #elif defined(__MACH__) && defined(__APPLE__) \
   || defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__)
-  int result = error_wrapper(::ioctl(s,
-        static_cast<unsigned int>(cmd), arg), ec);
+  int result = ::ioctl(s, static_cast<unsigned int>(cmd), arg);
 #else
-  int result = error_wrapper(::ioctl(s, cmd, arg), ec);
+  int result = ::ioctl(s, cmd, arg);
 #endif
+  get_last_error(ec, result < 0);
   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
@@ -1761,7 +2159,6 @@ int ioctl(socket_type s, state_type& state, int cmd,
 int select(int nfds, fd_set* readfds, fd_set* writefds,
     fd_set* exceptfds, timeval* timeout, asio::error_code& ec)
 {
-  clear_last_error();
 #if defined(__EMSCRIPTEN__)
   exceptfds = 0;
 #endif // defined(__EMSCRIPTEN__)
@@ -1772,7 +2169,7 @@ int select(int nfds, fd_set* readfds, fd_set* writefds,
     if (milliseconds == 0)
       milliseconds = 1; // Force context switch.
     ::Sleep(milliseconds);
-    ec = asio::error_code();
+    ec.assign(0, ec.category());
     return 0;
   }
 
@@ -1791,15 +2188,13 @@ int select(int nfds, fd_set* readfds, fd_set* writefds,
   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);
+  int result = ::pselect(nfds, readfds,
+        writefds, exceptfds, timeout ? &ts : 0, 0);
 #else
-  int result = error_wrapper(::select(nfds, readfds,
-        writefds, exceptfds, timeout), ec);
-  if (result >= 0)
-    ec = asio::error_code();
-  return result;
+  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,
@@ -1833,8 +2228,8 @@ int poll_read(socket_type s, state_type state,
   }
   else
     timeout = 0;
-  clear_last_error();
-  int result = error_wrapper(::select(s + 1, &fds, 0, 0, timeout), ec);
+  int result = ::select(s + 1, &fds, 0, 0, timeout);
+  get_last_error(ec, result < 0);
 #else // defined(ASIO_WINDOWS)
       // || defined(__CYGWIN__)
       // || defined(__SYMBIAN32__)
@@ -1843,16 +2238,14 @@ int poll_read(socket_type s, state_type state,
   fds.events = POLLIN;
   fds.revents = 0;
   int timeout = (state & user_set_non_blocking) ? 0 : msec;
-  clear_last_error();
-  int result = error_wrapper(::poll(&fds, 1, timeout), ec);
+  int result = ::poll(&fds, 1, timeout);
+  get_last_error(ec, result < 0);
 #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();
+    if (state & user_set_non_blocking)
+      ec = asio::error::would_block;
   return result;
 }
 
@@ -1887,8 +2280,8 @@ int poll_write(socket_type s, state_type state,
   }
   else
     timeout = 0;
-  clear_last_error();
-  int result = error_wrapper(::select(s + 1, 0, &fds, 0, timeout), ec);
+  int result = ::select(s + 1, 0, &fds, 0, timeout);
+  get_last_error(ec, result < 0);
 #else // defined(ASIO_WINDOWS)
       // || defined(__CYGWIN__)
       // || defined(__SYMBIAN32__)
@@ -1897,16 +2290,14 @@ int poll_write(socket_type s, state_type state,
   fds.events = POLLOUT;
   fds.revents = 0;
   int timeout = (state & user_set_non_blocking) ? 0 : msec;
-  clear_last_error();
-  int result = error_wrapper(::poll(&fds, 1, timeout), ec);
+  int result = ::poll(&fds, 1, timeout);
+  get_last_error(ec, result < 0);
 #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();
+    if (state & user_set_non_blocking)
+      ec = asio::error::would_block;
   return result;
 }
 
@@ -1941,8 +2332,8 @@ int poll_error(socket_type s, state_type state,
   }
   else
     timeout = 0;
-  clear_last_error();
-  int result = error_wrapper(::select(s + 1, 0, 0, &fds, timeout), ec);
+  int result = ::select(s + 1, 0, 0, &fds, timeout);
+  get_last_error(ec, result < 0);
 #else // defined(ASIO_WINDOWS)
       // || defined(__CYGWIN__)
       // || defined(__SYMBIAN32__)
@@ -1951,16 +2342,14 @@ int poll_error(socket_type s, state_type state,
   fds.events = POLLPRI | POLLERR | POLLHUP;
   fds.revents = 0;
   int timeout = (state & user_set_non_blocking) ? 0 : msec;
-  clear_last_error();
-  int result = error_wrapper(::poll(&fds, 1, timeout), ec);
+  int result = ::poll(&fds, 1, timeout);
+  get_last_error(ec, result < 0);
 #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();
+    if (state & user_set_non_blocking)
+      ec = asio::error::would_block;
   return result;
 }
 
@@ -1991,11 +2380,8 @@ int poll_connect(socket_type s, int msec, asio::error_code& ec)
   }
   else
     timeout = 0;
-  clear_last_error();
-  int result = error_wrapper(::select(
-        s + 1, 0, &write_fds, &except_fds, timeout), ec);
-  if (result >= 0)
-    ec = asio::error_code();
+  int result = ::select(s + 1, 0, &write_fds, &except_fds, timeout);
+  get_last_error(ec, result < 0);
   return result;
 #else // defined(ASIO_WINDOWS)
       // || defined(__CYGWIN__)
@@ -2004,10 +2390,8 @@ int poll_connect(socket_type s, int msec, asio::error_code& ec)
   fds.fd = s;
   fds.events = POLLOUT;
   fds.revents = 0;
-  clear_last_error();
-  int result = error_wrapper(::poll(&fds, 1, msec), ec);
-  if (result >= 0)
-    ec = asio::error_code();
+  int result = ::poll(&fds, 1, msec);
+  get_last_error(ec, result < 0);
   return result;
 #endif // defined(ASIO_WINDOWS)
        // || defined(__CYGWIN__)
@@ -2092,18 +2476,20 @@ const char* inet_ntop(int af, const void* src, char* dest, size_t length,
   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 = error_wrapper(::WSAAddressToStringW(&address.base,
-        address_length, 0, string_buffer, &string_length), ec);
+  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 = error_wrapper(::WSAAddressToStringA(
-        &address.base, address_length, 0, dest, &string_length), ec);
+  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)
-    ec = asio::error_code();
+    ec.assign(0, ec.category());
 
   // Windows may not set an error code on failure.
   else if (result == socket_error_retval && !ec)
@@ -2111,8 +2497,8 @@ const char* inet_ntop(int af, const void* src, char* dest, size_t length,
 
   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);
+  const char* result = ::inet_ntop(af, src, dest, static_cast<int>(length));
+  get_last_error(ec, true);
   if (result == 0 && !ec)
     ec = asio::error::invalid_argument;
   if (result != 0 && af == ASIO_OS_DEF(AF_INET6) && scope_id != 0)
@@ -2157,7 +2543,7 @@ int inet_pton(int af, const char* src, void* dest,
     bytes[1] = static_cast<unsigned char>(b1);
     bytes[2] = static_cast<unsigned char>(b2);
     bytes[3] = static_cast<unsigned char>(b3);
-    ec = asio::error_code();
+    ec.assign(), ec.category());
     return 1;
   }
   else if (af == ASIO_OS_DEF(AF_INET6))
@@ -2273,7 +2659,7 @@ int inet_pton(int af, const char* src, void* dest,
     for (int i = 0; i < num_back_bytes; ++i)
       bytes[16 - num_back_bytes + i] = back_bytes[i];
 
-    ec = asio::error_code();
+    ec.assign(0, ec.category());
     return 1;
   }
   else
@@ -2302,11 +2688,13 @@ int inet_pton(int af, const char* src, void* dest,
   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 = error_wrapper(::WSAStringToAddressW(
-        wide_buffer, af, 0, &address.base, &address_length), ec);
+  int result = ::WSAStringToAddressW(wide_buffer,
+      af, 0, &address.base, &address_length);
+  get_last_error(ec, true);
 #else
-  int result = error_wrapper(::WSAStringToAddressA(
-        const_cast<char*>(src), af, 0, &address.base, &address_length), ec);
+  int result = ::WSAStringToAddressA(const_cast<char*>(src),
+      af, 0, &address.base, &address_length);
+  get_last_error(ec, true);
 #endif
 
   if (af == ASIO_OS_DEF(AF_INET))
@@ -2314,12 +2702,12 @@ int inet_pton(int af, const char* src, void* dest,
     if (result != socket_error_retval)
     {
       memcpy(dest, &address.v4.sin_addr, sizeof(in4_addr_type));
-      ec = asio::error_code();
+      ec.assign(0, ec.category());
     }
     else if (strcmp(src, "255.255.255.255") == 0)
     {
       static_cast<in4_addr_type*>(dest)->s_addr = INADDR_NONE;
-      ec = asio::error_code();
+      ec.assign(0, ec.category());
     }
   }
   else // AF_INET6
@@ -2329,7 +2717,7 @@ int inet_pton(int af, const char* src, void* dest,
       memcpy(dest, &address.v6.sin6_addr, sizeof(in6_addr_type));
       if (scope_id)
         *scope_id = address.v6.sin6_scope_id;
-      ec = asio::error_code();
+      ec.assign(0, ec.category());
     }
   }
 
@@ -2338,7 +2726,7 @@ int inet_pton(int af, const char* src, void* dest,
     ec = asio::error::invalid_argument;
 
   if (result != socket_error_retval)
-    ec = asio::error_code();
+    ec.assign(0, ec.category());
 
   return result == socket_error_retval ? -1 : 1;
 #else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
@@ -2362,7 +2750,8 @@ int inet_pton(int af, const char* src, void* dest,
     src_ptr = src_buf;
   }
 
-  int result = error_wrapper(::inet_pton(af, src_ptr, dest), ec);
+  int result = ::inet_pton(af, src_ptr, dest);
+  get_last_error(ec, true);
   if (result <= 0 && !ec)
     ec = asio::error::invalid_argument;
   if (result > 0 && is_v6 && scope_id)
@@ -2388,7 +2777,6 @@ int inet_pton(int af, const char* src, void* dest,
 
 int gethostname(char* name, int namelen, asio::error_code& ec)
 {
-  clear_last_error();
 #if defined(ASIO_WINDOWS_RUNTIME)
   try
   {
@@ -2419,11 +2807,8 @@ int gethostname(char* name, int namelen, asio::error_code& ec)
     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)
+  int result = ::gethostname(name, namelen);
+  get_last_error(ec, result != 0);
   return result;
 #endif // defined(ASIO_WINDOWS_RUNTIME)
 }
@@ -2458,20 +2843,20 @@ inline asio::error_code translate_netdb_error(int error)
 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);
+  hostent* retval = ::gethostbyaddr(addr, length, af);
+  get_last_error(ec, !retval);
   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);
+  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;
@@ -2479,8 +2864,8 @@ inline hostent* gethostbyaddr(const char* addr, int length, int af,
   (void)(buffer);
   (void)(buflength);
   int error = 0;
-  hostent* retval = error_wrapper(::getipnodebyaddr(
-        addr, length, af, &error), ec);
+  hostent* retval = ::getipnodebyaddr(addr, length, af, &error);
+  get_last_error(ec, !retval);
   if (error)
     ec = translate_netdb_error(error);
   if (!retval)
@@ -2490,8 +2875,10 @@ inline hostent* gethostbyaddr(const char* addr, int length, int af,
 #else
   hostent* retval = 0;
   int error = 0;
-  error_wrapper(::gethostbyaddr_r(addr, length, af, result, buffer,
-        buflength, &retval, &error), ec);
+  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;
@@ -2501,7 +2888,6 @@ inline hostent* gethostbyaddr(const char* addr, int length, int af,
 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);
@@ -2511,10 +2897,10 @@ inline hostent* gethostbyname(const char* name, int af, struct hostent* result,
     ec = asio::error::address_family_not_supported;
     return 0;
   }
-  hostent* retval = error_wrapper(::gethostbyname(name), ec);
+  hostent* retval = ::gethostbyname(name);
+  get_last_error(ec, !retval);
   if (!retval)
     return 0;
-  ec = asio::error_code();
   *result = *retval;
   return result;
 #elif defined(__sun) || defined(__QNX__)
@@ -2525,8 +2911,8 @@ inline hostent* gethostbyname(const char* name, int af, struct hostent* result,
     return 0;
   }
   int error = 0;
-  hostent* retval = error_wrapper(::gethostbyname_r(name, result, buffer,
-        buflength, &error), ec);
+  hostent* retval = ::gethostbyname_r(name, result, buffer, buflength, &error);
+  get_last_error(ec, !retval);
   if (error)
     ec = translate_netdb_error(error);
   return retval;
@@ -2534,8 +2920,8 @@ inline hostent* gethostbyname(const char* name, int af, struct hostent* result,
   (void)(buffer);
   (void)(buflength);
   int error = 0;
-  hostent* retval = error_wrapper(::getipnodebyname(
-        name, af, ai_flags, &error), ec);
+  hostent* retval = ::getipnodebyname(name, af, ai_flags, &error);
+  get_last_error(ec, !retval);
   if (error)
     ec = translate_netdb_error(error);
   if (!retval)
@@ -2551,8 +2937,9 @@ inline hostent* gethostbyname(const char* name, int af, struct hostent* result,
   }
   hostent* retval = 0;
   int error = 0;
-  error_wrapper(::gethostbyname_r(name, result,
-        buffer, buflength, &retval, &error), ec);
+  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;
@@ -3268,7 +3655,7 @@ inline asio::error_code getnameinfo_emulation(
     }
   }
 
-  ec = asio::error_code();
+  ec.assign(0, ec.category());
   return ec;
 }