passenger 6.0.23 → 6.0.24

data/src/cxx_supportlib/Constants.h

@@ -83,7 +83,7 @@
 #define PASSENGER_API_VERSION_MAJOR 0
 #define PASSENGER_API_VERSION_MINOR 3
 #define PASSENGER_DEFAULT_USER "nobody"
-#define PASSENGER_VERSION "6.0.23"
+#define PASSENGER_VERSION "6.0.24"
 #define POOL_HELPER_THREAD_STACK_SIZE 262144
 #define PROCESS_SHUTDOWN_TIMEOUT 60
 #define PROCESS_SHUTDOWN_TIMEOUT_DISPLAY "1 minute"

data/src/cxx_supportlib/DataStructures/StringMap.h

@@ -27,7 +27,6 @@
 #define _PASSENGER_DATA_STRUCTURES_STRING_MAP_H_
 
 #include <string>
-#include <map>
 #include <utility>
 
 #include <StaticString.h>

data/src/cxx_supportlib/FileTools/PathManip.cpp

@@ -27,7 +27,7 @@
 #include <sys/param.h>
 #include <stdlib.h>
 #include <unistd.h>
-#include <limits.h>
+#include <limits.h> // IWYU pragma: keep; for PATH_MAX
 #include <libgen.h>
 
 #ifdef __has_include

data/src/cxx_supportlib/SafeLibev.h

@@ -28,10 +28,8 @@
 
 #include <ev++.h>
 #include <vector>
-#include <list>
 #include <memory>
 #include <boost/thread.hpp>
-#include <boost/scoped_ptr.hpp>
 #include <boost/shared_ptr.hpp>
 #include <boost/function.hpp>
 #include <boost/bind/bind.hpp>
@@ -82,7 +80,7 @@ private:
 	}
 
 	static void timeoutHandler(int revents, void *arg) {
-		boost::scoped_ptr<Callback> callback((Callback *) arg);
+		std::unique_ptr<Callback> callback((Callback *) arg);
 		(*callback)();
 	}
 

data/src/cxx_supportlib/ServerKit/Hooks.h

@@ -61,13 +61,13 @@ struct RefGuard {
 		  file(_file),
 		  line(_line)
 	{
-		if (_hooks != NULL && _hooks->impl != NULL) {
+		if (_hooks != nullptr && _hooks->impl != nullptr) {
 			_hooks->impl->hook_ref(_hooks, _source, _file, _line);
 		}
 	}
 
 	~RefGuard() {
-		if (hooks != NULL && hooks->impl != NULL) {
+		if (hooks != nullptr && hooks->impl != nullptr) {
 			hooks->impl->hook_unref(hooks, source, file, line);
 		}
 	}

data/src/cxx_supportlib/ServerKit/HttpHeaderParser.h

@@ -29,7 +29,6 @@
 #include <boost/cstdint.hpp>
 #include <oxt/backtrace.hpp>
 #include <cstddef>
-#include <cassert>
 #include <cstring>
 #include <MemoryKit/mbuf.h>
 #include <ServerKit/llhttp.h>

data/src/cxx_supportlib/ServerKit/HttpServer.h

@@ -32,7 +32,6 @@
 #include <oxt/macros.hpp>
 #include <algorithm>
 #include <cstdio>
-#include <cmath>
 #include <cassert>
 #include <pthread.h>
 #include <LoggingKit/LoggingKit.h>
@@ -401,8 +400,9 @@ private:
 			if (!req->bodyChannel.acceptingInput()) {
 				if (req->bodyChannel.mayAcceptInputLater()) {
 					client->input.stop();
-					req->bodyChannel.consumedCallback =
-						onRequestBodyChannelConsumed;
+					req->bodyChannel.consumedCallback = [](Channel *channel, unsigned int size) {
+						onRequestBodyChannelConsumed(channel, size);
+					};
 					return Channel::Result(0, false);
 				} else {
 					return Channel::Result(0, true);
@@ -437,8 +437,9 @@ private:
 				return Channel::Result(remaining, false);
 			} else if (req->bodyChannel.mayAcceptInputLater()) {
 				client->input.stop();
-				req->bodyChannel.consumedCallback =
-					onRequestBodyChannelConsumed;
+				req->bodyChannel.consumedCallback = [](Channel *channel, unsigned int size) {
+					onRequestBodyChannelConsumed(channel, size);
+				};
 				return Channel::Result(remaining, false);
 			} else {
 				return Channel::Result(remaining, true);
@@ -468,8 +469,9 @@ private:
 			if (!req->bodyChannel.acceptingInput()) {
 				if (req->bodyChannel.mayAcceptInputLater()) {
 					client->input.stop();
-					req->bodyChannel.consumedCallback =
-						onRequestBodyChannelConsumed;
+					req->bodyChannel.consumedCallback = [](Channel *channel, unsigned int size) {
+						onRequestBodyChannelConsumed(channel, size);
+					};
 					return Channel::Result(0, false);
 				} else {
 					return Channel::Result(0, true);
@@ -510,7 +512,9 @@ private:
 							req->bodyChannel.feed(MemoryKit::mbuf());
 						} else if (req->bodyChannel.mayAcceptInputLater()) {
 							client->input.stop();
-							req->bodyChannel.consumedCallback = onRequestBodyChannelConsumed;
+							req->bodyChannel.consumedCallback = [](Channel *channel, unsigned int size) {
+								onRequestBodyChannelConsumed(channel, size);
+							};
 						}
 					}
 				}
@@ -607,8 +611,9 @@ private:
 		} else if (req->bodyChannel.mayAcceptInputLater()) {
 			SKC_TRACE(client, 3, "BodyChannel currently busy; will feed "
 				"error to bodyChannel later");
-			req->bodyChannel.consumedCallback =
-				onRequestBodyChannelConsumed_onBodyError;
+			req->bodyChannel.consumedCallback =	[](Channel *channel, unsigned int size) {
+				onRequestBodyChannelConsumed_onBodyError(channel, size);
+			};
 			req->bodyError = errcode;
 			return Channel::Result(-1, false);
 		} else {

data/src/cxx_supportlib/ServerKit/Server.h

@@ -38,12 +38,6 @@
 #include <new>
 #include <ev++.h>
 
-// for std::swap()
-#if __cplusplus >= 201103L
-	#include <utility>
-#else
-	#include <algorithm>
-#endif
 #include <sys/socket.h>
 #include <sys/un.h>
 #include <netinet/in.h>

data/src/cxx_supportlib/Utils/AsyncSignalSafeUtils.h

@@ -189,6 +189,8 @@ limitedStrerror(int e, const char *defaultResult = "Unknown error") {
 		return "Operation not permitted";
 	case ETXTBSY:
 		return "Text file busy";
+	case ESRCH:
+		return "Process does not exist";
 	default:
 		return defaultResult;
 	}

data/src/cxx_supportlib/Utils/SpeedMeter.h

@@ -26,9 +26,6 @@
 #ifndef _PASSENGER_SPEED_METER_H_
 #define _PASSENGER_SPEED_METER_H_
 
-#include <cstdio>
-#include <cstdlib>
-#include <cassert>
 #include <limits>
 #include <SystemTools/SystemTime.h>
 

data/src/cxx_supportlib/oxt/implementation.cpp

@@ -26,6 +26,7 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/shared_ptr.hpp>
 #include <boost/make_shared.hpp>
+#include <pthread.h>
 #include "tracable_exception.hpp"
 #include "backtrace.hpp"
 #include "initialize.hpp"
@@ -394,9 +395,19 @@ thread::make_thread_name(const string &given_name) {
 	}
 }
 
+static void
+set_native_thread_name(const string &name) {
+	#if defined(__linux__)
+		pthread_setname_np(pthread_self(), name.c_str());
+	#elif defined(__APPLE__) || defined(__FreeBSD__)
+		pthread_setname_np(name.c_str());
+	#endif
+}
+
 void
 thread::thread_main(const boost::function<void ()> func, thread_local_context_ptr ctx) {
 	set_thread_local_context(ctx);
+	set_native_thread_name(ctx->thread_name);
 
 	if (OXT_LIKELY(global_context != NULL)) {
 		boost::lock_guard<boost::mutex> l(global_context->thread_registration_mutex);

data/src/cxx_supportlib/oxt/system_calls.cpp

@@ -65,9 +65,16 @@ oxt::setup_syscall_interruption_support() {
 	do {
 		ret = sigaction(INTERRUPTION_SIGNAL, &action, NULL);
 	} while (ret == -1 && errno == EINTR);
-	do {
-		ret = siginterrupt(INTERRUPTION_SIGNAL, 1);
-	} while (ret == -1 && errno == EINTR);
+	#if !defined(__linux__)
+		// On Linux, siginterrupt() is deprecated. System call interruption works
+		// by merely calling sigaction() with sa_flags without SA_RESTART.
+		// Unfortunately, this does not seem to be the case on other operationg systems.
+		// For example, on macOS, we need to call *both* sigaction() without SA_RESTART,
+		// *and* siginterrupt().
+		do {
+			ret = siginterrupt(INTERRUPTION_SIGNAL, 1);
+		} while (ret == -1 && errno == EINTR);
+	#endif
 }
 
 void

data/src/cxx_supportlib/oxt/thread.hpp

@@ -35,7 +35,7 @@
 #include <string>
 #include <list>
 #include <unistd.h>
-#include <limits.h>  // for PTHREAD_STACK_MIN
+#include <limits.h> // IWYU pragma: keep; for PTHREAD_STACK_MIN
 
 namespace oxt {
 

data/src/cxx_supportlib/vendor-modified/boost/asio/as_tuple.hpp

@@ -107,16 +107,42 @@ public:
   CompletionToken token_;
 };
 
-/// Adapt a @ref completion_token to specify that the completion handler
-/// arguments should be combined into a single tuple argument.
-template <typename CompletionToken>
-BOOST_ASIO_NODISCARD inline
-constexpr as_tuple_t<decay_t<CompletionToken>>
-as_tuple(CompletionToken&& completion_token)
+/// A function object type that adapts a @ref completion_token to specify that
+/// the completion handler arguments should be combined into a single tuple
+/// argument.
+/**
+ * May also be used directly as a completion token, in which case it adapts the
+ * asynchronous operation's default completion token (or boost::asio::deferred
+ * if no default is available).
+ */
+struct partial_as_tuple
 {
-  return as_tuple_t<decay_t<CompletionToken>>(
-      static_cast<CompletionToken&&>(completion_token));
-}
+  /// Default constructor.
+  constexpr partial_as_tuple()
+  {
+  }
+
+  /// Adapt a @ref completion_token to specify that the completion handler
+  /// arguments should be combined into a single tuple argument.
+  template <typename CompletionToken>
+  BOOST_ASIO_NODISCARD inline
+  constexpr as_tuple_t<decay_t<CompletionToken>>
+  operator()(CompletionToken&& completion_token) const
+  {
+    return as_tuple_t<decay_t<CompletionToken>>(
+        static_cast<CompletionToken&&>(completion_token));
+  }
+};
+
+/// A function object that adapts a @ref completion_token to specify that the
+/// completion handler arguments should be combined into a single tuple
+/// argument.
+/**
+ * May also be used directly as a completion token, in which case it adapts the
+ * asynchronous operation's default completion token (or boost::asio::deferred
+ * if no default is available).
+ */
+BOOST_ASIO_INLINE_VARIABLE constexpr partial_as_tuple as_tuple;
 
 } // namespace asio
 } // namespace boost

data/src/cxx_supportlib/vendor-modified/boost/asio/associated_immediate_executor.hpp

@@ -50,9 +50,10 @@ struct has_immediate_executor_type<T,
 template <typename E, typename = void, typename = void>
 struct default_immediate_executor
 {
-  typedef require_result_t<E, execution::blocking_t::never_t> type;
+  typedef decay_t<require_result_t<E, execution::blocking_t::never_t>> type;
 
-  static type get(const E& e) noexcept
+  static auto get(const E& e) noexcept
+    -> decltype(boost::asio::require(e, execution::blocking.never))
   {
     return boost::asio::require(e, execution::blocking.never);
   }

data/src/cxx_supportlib/vendor-modified/boost/asio/associator.hpp

@@ -24,7 +24,7 @@ namespace asio {
 
 /// Used to generically specialise associators for a type.
 template <template <typename, typename> class Associator,
-    typename T, typename DefaultCandidate>
+    typename T, typename DefaultCandidate, typename _ = void>
 struct associator
 {
 };

data/src/cxx_supportlib/vendor-modified/boost/asio/async_result.hpp

@@ -22,9 +22,6 @@
 
 namespace boost {
 namespace asio {
-
-#if defined(BOOST_ASIO_HAS_CONCEPTS)
-
 namespace detail {
 
 template <typename T>
@@ -71,6 +68,12 @@ struct are_completion_signatures : false_type
 {
 };
 
+template <>
+struct are_completion_signatures<>
+  : true_type
+{
+};
+
 template <typename T0>
 struct are_completion_signatures<T0>
   : is_completion_signature<T0>
@@ -85,6 +88,12 @@ struct are_completion_signatures<T0, TN...>
 {
 };
 
+} // namespace detail
+
+#if defined(BOOST_ASIO_HAS_CONCEPTS)
+
+namespace detail {
+
 template <typename T, typename... Args>
 BOOST_ASIO_CONCEPT callable_with = requires(T&& t, Args&&... args)
 {
@@ -607,14 +616,36 @@ template <typename CompletionToken,
     typename Initiation, typename... Args>
 inline auto async_initiate(Initiation&& initiation,
     type_identity_t<CompletionToken>& token, Args&&... args)
-  -> constraint_t<
-    detail::async_result_has_initiate_memfn<
-      CompletionToken, Signatures...>::value,
-    decltype(
-      async_result<decay_t<CompletionToken>, Signatures...>::initiate(
-        static_cast<Initiation&&>(initiation),
-        static_cast<CompletionToken&&>(token),
-        static_cast<Args&&>(args)...))>
+  -> decltype(enable_if_t<
+    enable_if_t<
+      detail::are_completion_signatures<Signatures...>::value,
+      detail::async_result_has_initiate_memfn<
+        CompletionToken, Signatures...>>::value,
+    async_result<decay_t<CompletionToken>, Signatures...>>::initiate(
+      static_cast<Initiation&&>(initiation),
+      static_cast<CompletionToken&&>(token),
+      static_cast<Args&&>(args)...))
+{
+  return async_result<decay_t<CompletionToken>, Signatures...>::initiate(
+      static_cast<Initiation&&>(initiation),
+      static_cast<CompletionToken&&>(token),
+      static_cast<Args&&>(args)...);
+}
+
+template <
+    BOOST_ASIO_COMPLETION_SIGNATURE... Signatures,
+    typename CompletionToken, typename Initiation, typename... Args>
+inline auto async_initiate(Initiation&& initiation,
+    CompletionToken&& token, Args&&... args)
+  -> decltype(enable_if_t<
+    enable_if_t<
+      detail::are_completion_signatures<Signatures...>::value,
+      detail::async_result_has_initiate_memfn<
+        CompletionToken, Signatures...>>::value,
+    async_result<decay_t<CompletionToken>, Signatures...>>::initiate(
+      static_cast<Initiation&&>(initiation),
+      static_cast<CompletionToken&&>(token),
+      static_cast<Args&&>(args)...))
 {
   return async_result<decay_t<CompletionToken>, Signatures...>::initiate(
       static_cast<Initiation&&>(initiation),
@@ -625,10 +656,13 @@ inline auto async_initiate(Initiation&& initiation,
 template <typename CompletionToken,
     BOOST_ASIO_COMPLETION_SIGNATURE... Signatures,
     typename Initiation, typename... Args>
-inline constraint_t<
-    !detail::async_result_has_initiate_memfn<
-      CompletionToken, Signatures...>::value,
-    typename async_result<decay_t<CompletionToken>, Signatures...>::return_type>
+inline typename enable_if_t<
+    !enable_if_t<
+      detail::are_completion_signatures<Signatures...>::value,
+      detail::async_result_has_initiate_memfn<
+        CompletionToken, Signatures...>>::value,
+    async_result<decay_t<CompletionToken>, Signatures...>
+  >::return_type
 async_initiate(Initiation&& initiation,
     type_identity_t<CompletionToken>& token, Args&&... args)
 {
@@ -644,6 +678,29 @@ async_initiate(Initiation&& initiation,
   return completion.result.get();
 }
 
+template <BOOST_ASIO_COMPLETION_SIGNATURE... Signatures,
+    typename CompletionToken, typename Initiation, typename... Args>
+inline typename enable_if_t<
+    !enable_if_t<
+      detail::are_completion_signatures<Signatures...>::value,
+      detail::async_result_has_initiate_memfn<
+        CompletionToken, Signatures...>>::value,
+    async_result<decay_t<CompletionToken>, Signatures...>
+  >::return_type
+async_initiate(Initiation&& initiation, CompletionToken&& token, Args&&... args)
+{
+  async_completion<CompletionToken, Signatures...> completion(token);
+
+  static_cast<Initiation&&>(initiation)(
+      static_cast<
+        typename async_result<decay_t<CompletionToken>,
+          Signatures...>::completion_handler_type&&>(
+            completion.completion_handler),
+      static_cast<Args&&>(args)...);
+
+  return completion.result.get();
+}
+
 #endif // defined(GENERATING_DOCUMENTATION)
 
 #if defined(BOOST_ASIO_HAS_CONCEPTS)
@@ -883,62 +940,11 @@ template <typename T, typename... Args>
 using completion_signature_of_t =
   typename completion_signature_of<T, Args...>::type;
 
-namespace detail {
-
-template <typename T, typename = void>
-struct default_completion_token_impl
-{
-  typedef void type;
-};
-
-template <typename T>
-struct default_completion_token_impl<T,
-    void_t<typename T::default_completion_token_type>
-  >
-{
-  typedef typename T::default_completion_token_type type;
-};
-
-} // namespace detail
-
-#if defined(GENERATING_DOCUMENTATION)
-
-/// Traits type used to determine the default completion token type associated
-/// with a type (such as an executor).
-/**
- * A program may specialise this traits type if the @c T template parameter in
- * the specialisation is a user-defined type.
- *
- * Specialisations of this trait may provide a nested typedef @c type, which is
- * a default-constructible completion token type.
- */
-template <typename T>
-struct default_completion_token
-{
-  /// If @c T has a nested type @c default_completion_token_type,
-  /// <tt>T::default_completion_token_type</tt>. Otherwise the typedef @c type
-  /// is not defined.
-  typedef see_below type;
-};
-#else
-template <typename T>
-struct default_completion_token
-  : detail::default_completion_token_impl<T>
-{
-};
-#endif
-
-template <typename T>
-using default_completion_token_t = typename default_completion_token<T>::type;
-
-#define BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(e) \
-  = typename ::boost::asio::default_completion_token<e>::type
-#define BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(e) \
-  = typename ::boost::asio::default_completion_token<e>::type()
-
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
+#include <boost/asio/default_completion_token.hpp>
+
 #endif // BOOST_ASIO_ASYNC_RESULT_HPP

data/src/cxx_supportlib/vendor-modified/boost/asio/basic_datagram_socket.hpp

@@ -448,7 +448,7 @@ public:
    * Regardless of whether the asynchronous operation completes immediately or
    * not, the completion handler will not be invoked from within this function.
    * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using boost::asio::post().
+   * manner equivalent to using boost::asio::async_immediate().
    *
    * @par Completion Signature
    * @code void(boost::system::error_code, std::size_t) @endcode
@@ -518,7 +518,7 @@ public:
    * Regardless of whether the asynchronous operation completes immediately or
    * not, the completion handler will not be invoked from within this function.
    * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using boost::asio::post().
+   * manner equivalent to using boost::asio::async_immediate().
    *
    * @par Completion Signature
    * @code void(boost::system::error_code, std::size_t) @endcode
@@ -667,7 +667,7 @@ public:
    * Regardless of whether the asynchronous operation completes immediately or
    * not, the completion handler will not be invoked from within this function.
    * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using boost::asio::post().
+   * manner equivalent to using boost::asio::async_immediate().
    *
    * @par Completion Signature
    * @code void(boost::system::error_code, std::size_t) @endcode
@@ -740,7 +740,7 @@ public:
    * Regardless of whether the asynchronous operation completes immediately or
    * not, the completion handler will not be invoked from within this function.
    * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using boost::asio::post().
+   * manner equivalent to using boost::asio::async_immediate().
    *
    * @par Completion Signature
    * @code void(boost::system::error_code, std::size_t) @endcode
@@ -885,7 +885,7 @@ public:
    * Regardless of whether the asynchronous operation completes immediately or
    * not, the completion handler will not be invoked from within this function.
    * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using boost::asio::post().
+   * manner equivalent to using boost::asio::async_immediate().
    *
    * @par Completion Signature
    * @code void(boost::system::error_code, std::size_t) @endcode
@@ -956,7 +956,7 @@ public:
    * Regardless of whether the asynchronous operation completes immediately or
    * not, the completion handler will not be invoked from within this function.
    * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using boost::asio::post().
+   * manner equivalent to using boost::asio::async_immediate().
    *
    * @par Completion Signature
    * @code void(boost::system::error_code, std::size_t) @endcode
@@ -1027,7 +1027,7 @@ public:
     boost::asio::detail::throw_error(ec, "receive_from");
     return s;
   }
-  
+
   /// Receive a datagram with the endpoint of the sender.
   /**
    * This function is used to receive a datagram. The function call will block
@@ -1054,7 +1054,7 @@ public:
     boost::asio::detail::throw_error(ec, "receive_from");
     return s;
   }
-  
+
   /// Receive a datagram with the endpoint of the sender.
   /**
    * This function is used to receive a datagram. The function call will block
@@ -1108,7 +1108,7 @@ public:
    * Regardless of whether the asynchronous operation completes immediately or
    * not, the completion handler will not be invoked from within this function.
    * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using boost::asio::post().
+   * manner equivalent to using boost::asio::async_immediate().
    *
    * @par Completion Signature
    * @code void(boost::system::error_code, std::size_t) @endcode
@@ -1180,7 +1180,7 @@ public:
    * Regardless of whether the asynchronous operation completes immediately or
    * not, the completion handler will not be invoked from within this function.
    * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using boost::asio::post().
+   * manner equivalent to using boost::asio::async_immediate().
    *
    * @par Completion Signature
    * @code void(boost::system::error_code, std::size_t) @endcode
@@ -1220,7 +1220,7 @@ private:
       const basic_datagram_socket&) = delete;
 
   class initiate_async_send
-  { 
+  {
   public:
     typedef Executor executor_type;
 

data/src/cxx_supportlib/vendor-modified/boost/asio/basic_deadline_timer.hpp

@@ -64,7 +64,7 @@ namespace asio {
  * timer.wait();
  * @endcode
  *
- * @par 
+ * @par
  * Performing an asynchronous wait:
  * @code
  * void handler(const boost::system::error_code& error)
@@ -631,7 +631,7 @@ public:
    * Regardless of whether the asynchronous operation completes immediately or
    * not, the completion handler will not be invoked from within this function.
    * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using boost::asio::post().
+   * manner equivalent to using boost::asio::async_immediate().
    *
    * @par Completion Signature
    * @code void(boost::system::error_code) @endcode

data/src/cxx_supportlib/vendor-modified/boost/asio/basic_random_access_file.hpp

@@ -428,7 +428,7 @@ public:
    * Regardless of whether the asynchronous operation completes immediately or
    * not, the completion handler will not be invoked from within this function.
    * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using boost::asio::post().
+   * manner equivalent to using boost::asio::async_immediate().
    *
    * @par Completion Signature
    * @code void(boost::system::error_code, std::size_t) @endcode
@@ -563,7 +563,7 @@ public:
    * Regardless of whether the asynchronous operation completes immediately or
    * not, the completion handler will not be invoked from within this function.
    * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using boost::asio::post().
+   * manner equivalent to using boost::asio::async_immediate().
    *
    * @par Completion Signature
    * @code void(boost::system::error_code, std::size_t) @endcode