passenger 6.0.13 → 6.0.15

data/src/cxx_supportlib/vendor-modified/boost/asio/impl/co_spawn.hpp

@@ -2,7 +2,7 @@
 // impl/co_spawn.hpp
 // ~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -200,6 +200,61 @@ private:
   awaitable<T, Executor> awaitable_;
 };
 
+template <typename Handler, typename Executor, typename = void>
+class co_spawn_cancellation_handler
+{
+public:
+  co_spawn_cancellation_handler(const Handler& handler, const Executor& ex)
+    : ex_(boost::asio::get_associated_executor(handler, ex))
+  {
+  }
+
+  cancellation_slot slot()
+  {
+    return signal_.slot();
+  }
+
+  void operator()(cancellation_type_t type)
+  {
+    cancellation_signal* sig = &signal_;
+    boost::asio::dispatch(ex_, [sig, type]{ sig->emit(type); });
+  }
+
+private:
+  cancellation_signal signal_;
+  typename associated_executor<Handler, Executor>::type ex_;
+};
+
+
+template <typename Handler, typename Executor>
+class co_spawn_cancellation_handler<Handler, Executor,
+    typename enable_if<
+      is_same<
+        typename associated_executor<Handler,
+          Executor>::asio_associated_executor_is_unspecialised,
+        void
+      >::value
+    >::type>
+{
+public:
+  co_spawn_cancellation_handler(const Handler&, const Executor&)
+  {
+  }
+
+  cancellation_slot slot()
+  {
+    return signal_.slot();
+  }
+
+  void operator()(cancellation_type_t type)
+  {
+    signal_.emit(type);
+  }
+
+private:
+  cancellation_signal signal_;
+};
+
 template <typename Executor>
 class initiate_co_spawn
 {
@@ -221,17 +276,26 @@ public:
   void operator()(Handler&& handler, F&& f) const
   {
     typedef typename result_of<F()>::type awaitable_type;
+    typedef typename decay<Handler>::type handler_type;
+    typedef co_spawn_cancellation_handler<
+      handler_type, Executor> cancel_handler_type;
+
+    auto slot = boost::asio::get_associated_cancellation_slot(handler);
+    cancel_handler_type* cancel_handler = slot.is_connected()
+      ? &slot.template emplace<cancel_handler_type>(handler, ex_)
+      : nullptr;
 
-    cancellation_state proxy_cancel_state(
-        boost::asio::get_associated_cancellation_slot(handler),
-        enable_total_cancellation());
+    cancellation_slot proxy_slot(
+        cancel_handler
+          ? cancel_handler->slot()
+          : cancellation_slot());
 
-    cancellation_state cancel_state(proxy_cancel_state.slot());
+    cancellation_state cancel_state(proxy_slot);
 
     auto a = (co_spawn_entry_point)(static_cast<awaitable_type*>(nullptr),
         ex_, std::forward<F>(f), std::forward<Handler>(handler));
-    awaitable_handler<executor_type, void>(std::move(a), ex_,
-        proxy_cancel_state.slot(), cancel_state).launch();
+    awaitable_handler<executor_type, void>(std::move(a),
+        ex_, proxy_slot, cancel_state).launch();
   }
 
 private:

data/src/cxx_supportlib/vendor-modified/boost/asio/impl/compose.hpp

@@ -2,7 +2,7 @@
 // impl/compose.hpp
 // ~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -64,6 +64,26 @@ namespace detail
     executor_type executor_;
   };
 
+  template <>
+  struct composed_work_guard<system_executor>
+  {
+  public:
+    typedef system_executor executor_type;
+
+    composed_work_guard(const system_executor&)
+    {
+    }
+
+    void reset()
+    {
+    }
+
+    executor_type get_executor() const BOOST_ASIO_NOEXCEPT
+    {
+      return system_executor();
+    }
+  };
+
 #if !defined(BOOST_ASIO_NO_TS_EXECUTORS)
 
   template <typename Executor>

data/src/cxx_supportlib/vendor-modified/boost/asio/impl/connect.hpp

@@ -2,7 +2,7 @@
 // impl/connect.hpp
 // ~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -26,6 +26,7 @@
 #include <boost/asio/detail/handler_type_requirements.hpp>
 #include <boost/asio/detail/non_const_lvalue.hpp>
 #include <boost/asio/detail/throw_error.hpp>
+#include <boost/asio/detail/type_traits.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/post.hpp>
 
@@ -74,9 +75,9 @@ namespace detail
 
     static const bool value =
       sizeof(asio_connect_condition_check(
-        (*static_cast<legacy_connect_condition_helper<T, Iterator>*>(0))(
-          *static_cast<const boost::system::error_code*>(0),
-          *static_cast<const Iterator*>(0)))) != 1;
+        (declval<legacy_connect_condition_helper<T, Iterator> >())(
+          declval<const boost::system::error_code>(),
+          declval<const Iterator>()))) != 1;
   };
 
   template <typename ConnectCondition, typename Iterator>
@@ -799,103 +800,135 @@ struct associator<Associator,
 
 template <typename Protocol, typename Executor, typename EndpointSequence,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      typename Protocol::endpoint)) RangeConnectHandler>
-inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(RangeConnectHandler,
+      typename Protocol::endpoint)) RangeConnectToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(RangeConnectToken,
     void (boost::system::error_code, typename Protocol::endpoint))
 async_connect(basic_socket<Protocol, Executor>& s,
     const EndpointSequence& endpoints,
-    BOOST_ASIO_MOVE_ARG(RangeConnectHandler) handler,
+    BOOST_ASIO_MOVE_ARG(RangeConnectToken) token,
     typename constraint<is_endpoint_sequence<
         EndpointSequence>::value>::type)
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    async_initiate<RangeConnectToken,
+      void (boost::system::error_code, typename Protocol::endpoint)>(
+        declval<detail::initiate_async_range_connect<Protocol, Executor> >(),
+        token, endpoints, declval<detail::default_connect_condition>())))
 {
-  return async_initiate<RangeConnectHandler,
+  return async_initiate<RangeConnectToken,
     void (boost::system::error_code, typename Protocol::endpoint)>(
       detail::initiate_async_range_connect<Protocol, Executor>(s),
-      handler, endpoints, detail::default_connect_condition());
+      token, endpoints, detail::default_connect_condition());
 }
 
 #if !defined(BOOST_ASIO_NO_DEPRECATED)
 template <typename Protocol, typename Executor, typename Iterator,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      Iterator)) IteratorConnectHandler>
-inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(IteratorConnectHandler,
+      Iterator)) IteratorConnectToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(IteratorConnectToken,
     void (boost::system::error_code, Iterator))
 async_connect(basic_socket<Protocol, Executor>& s, Iterator begin,
-    BOOST_ASIO_MOVE_ARG(IteratorConnectHandler) handler,
+    BOOST_ASIO_MOVE_ARG(IteratorConnectToken) token,
     typename constraint<!is_endpoint_sequence<Iterator>::value>::type)
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    async_initiate<IteratorConnectToken,
+      void (boost::system::error_code, Iterator)>(
+        declval<detail::initiate_async_iterator_connect<Protocol, Executor> >(),
+        token, begin, Iterator(),
+        declval<detail::default_connect_condition>())))
 {
-  return async_initiate<IteratorConnectHandler,
+  return async_initiate<IteratorConnectToken,
     void (boost::system::error_code, Iterator)>(
       detail::initiate_async_iterator_connect<Protocol, Executor>(s),
-      handler, begin, Iterator(), detail::default_connect_condition());
+      token, begin, Iterator(),
+      detail::default_connect_condition());
 }
 #endif // !defined(BOOST_ASIO_NO_DEPRECATED)
 
 template <typename Protocol, typename Executor, typename Iterator,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      Iterator)) IteratorConnectHandler>
-inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(IteratorConnectHandler,
+      Iterator)) IteratorConnectToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(IteratorConnectToken,
     void (boost::system::error_code, Iterator))
 async_connect(basic_socket<Protocol, Executor>& s, Iterator begin, Iterator end,
-    BOOST_ASIO_MOVE_ARG(IteratorConnectHandler) handler)
+    BOOST_ASIO_MOVE_ARG(IteratorConnectToken) token)
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    async_initiate<IteratorConnectToken,
+      void (boost::system::error_code, Iterator)>(
+        declval<detail::initiate_async_iterator_connect<Protocol, Executor> >(),
+        token, begin, end, declval<detail::default_connect_condition>())))
 {
-  return async_initiate<IteratorConnectHandler,
+  return async_initiate<IteratorConnectToken,
     void (boost::system::error_code, Iterator)>(
       detail::initiate_async_iterator_connect<Protocol, Executor>(s),
-      handler, begin, end, detail::default_connect_condition());
+      token, begin, end, detail::default_connect_condition());
 }
 
 template <typename Protocol, typename Executor,
     typename EndpointSequence, typename ConnectCondition,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      typename Protocol::endpoint)) RangeConnectHandler>
-inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(RangeConnectHandler,
+      typename Protocol::endpoint)) RangeConnectToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(RangeConnectToken,
     void (boost::system::error_code, typename Protocol::endpoint))
 async_connect(basic_socket<Protocol, Executor>& s,
     const EndpointSequence& endpoints, ConnectCondition connect_condition,
-    BOOST_ASIO_MOVE_ARG(RangeConnectHandler) handler,
+    BOOST_ASIO_MOVE_ARG(RangeConnectToken) token,
     typename constraint<is_endpoint_sequence<
         EndpointSequence>::value>::type)
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    async_initiate<RangeConnectToken,
+      void (boost::system::error_code, typename Protocol::endpoint)>(
+        declval<detail::initiate_async_range_connect<Protocol, Executor> >(),
+        token, endpoints, connect_condition)))
 {
-  return async_initiate<RangeConnectHandler,
+  return async_initiate<RangeConnectToken,
     void (boost::system::error_code, typename Protocol::endpoint)>(
       detail::initiate_async_range_connect<Protocol, Executor>(s),
-      handler, endpoints, connect_condition);
+      token, endpoints, connect_condition);
 }
 
 #if !defined(BOOST_ASIO_NO_DEPRECATED)
 template <typename Protocol, typename Executor,
     typename Iterator, typename ConnectCondition,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      Iterator)) IteratorConnectHandler>
-inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(IteratorConnectHandler,
+      Iterator)) IteratorConnectToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(IteratorConnectToken,
     void (boost::system::error_code, Iterator))
 async_connect(basic_socket<Protocol, Executor>& s, Iterator begin,
     ConnectCondition connect_condition,
-    BOOST_ASIO_MOVE_ARG(IteratorConnectHandler) handler,
+    BOOST_ASIO_MOVE_ARG(IteratorConnectToken) token,
     typename constraint<!is_endpoint_sequence<Iterator>::value>::type)
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    async_initiate<IteratorConnectToken,
+      void (boost::system::error_code, Iterator)>(
+        declval<detail::initiate_async_iterator_connect<Protocol, Executor> >(),
+        token, begin, Iterator(), connect_condition)))
 {
-  return async_initiate<IteratorConnectHandler,
+  return async_initiate<IteratorConnectToken,
     void (boost::system::error_code, Iterator)>(
       detail::initiate_async_iterator_connect<Protocol, Executor>(s),
-      handler, begin, Iterator(), connect_condition);
+      token, begin, Iterator(), connect_condition);
 }
 #endif // !defined(BOOST_ASIO_NO_DEPRECATED)
 
 template <typename Protocol, typename Executor,
     typename Iterator, typename ConnectCondition,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-      Iterator)) IteratorConnectHandler>
-inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(IteratorConnectHandler,
+      Iterator)) IteratorConnectToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(IteratorConnectToken,
     void (boost::system::error_code, Iterator))
 async_connect(basic_socket<Protocol, Executor>& s, Iterator begin,
     Iterator end, ConnectCondition connect_condition,
-    BOOST_ASIO_MOVE_ARG(IteratorConnectHandler) handler)
+    BOOST_ASIO_MOVE_ARG(IteratorConnectToken) token)
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    async_initiate<IteratorConnectToken,
+      void (boost::system::error_code, Iterator)>(
+        declval<detail::initiate_async_iterator_connect<Protocol, Executor> >(),
+        token, begin, end, connect_condition)))
 {
-  return async_initiate<IteratorConnectHandler,
+  return async_initiate<IteratorConnectToken,
     void (boost::system::error_code, Iterator)>(
       detail::initiate_async_iterator_connect<Protocol, Executor>(s),
-      handler, begin, end, connect_condition);
+      token, begin, end, connect_condition);
 }
 
 } // namespace asio

data/src/cxx_supportlib/vendor-modified/boost/asio/impl/connect_pipe.hpp

@@ -0,0 +1,75 @@
+//
+// impl/connect_pipe.hpp
+// ~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_IMPL_CONNECT_PIPE_HPP
+#define BOOST_ASIO_IMPL_CONNECT_PIPE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_PIPE)
+
+#include <boost/asio/connect_pipe.hpp>
+#include <boost/asio/detail/throw_error.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+template <typename Executor1, typename Executor2>
+void connect_pipe(basic_readable_pipe<Executor1>& read_end,
+    basic_writable_pipe<Executor2>& write_end)
+{
+  boost::system::error_code ec;
+  boost::asio::connect_pipe(read_end, write_end, ec);
+  boost::asio::detail::throw_error(ec, "connect_pipe");
+}
+
+template <typename Executor1, typename Executor2>
+BOOST_ASIO_SYNC_OP_VOID connect_pipe(basic_readable_pipe<Executor1>& read_end,
+    basic_writable_pipe<Executor2>& write_end, boost::system::error_code& ec)
+{
+  detail::native_pipe_handle p[2];
+  detail::create_pipe(p, ec);
+  if (ec)
+    BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
+
+  read_end.assign(p[0], ec);
+  if (ec)
+  {
+    detail::close_pipe(p[0]);
+    detail::close_pipe(p[1]);
+    BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  write_end.assign(p[1], ec);
+  if (ec)
+  {
+    boost::system::error_code temp_ec;
+    read_end.close(temp_ec);
+    detail::close_pipe(p[1]);
+    BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
+  }
+
+  BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
+}
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_HAS_PIPE)
+
+#endif // BOOST_ASIO_IMPL_CONNECT_PIPE_HPP

data/src/cxx_supportlib/vendor-modified/boost/asio/impl/connect_pipe.ipp

@@ -0,0 +1,151 @@
+//
+// impl/connect_pipe.ipp
+// ~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2021 Klemens D. Morgenstern
+//                    (klemens dot morgenstern at gmx dot net)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_IMPL_CONNECT_PIPE_IPP
+#define BOOST_ASIO_IMPL_CONNECT_PIPE_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_PIPE)
+
+#include <boost/asio/connect_pipe.hpp>
+
+#if defined(BOOST_ASIO_HAS_IOCP)
+# include <cstdio>
+# if _WIN32_WINNT >= 0x601
+#  include <bcrypt.h>
+#  if !defined(BOOST_ASIO_NO_DEFAULT_LINKED_LIBS)
+#   if defined(_MSC_VER)
+#    pragma comment(lib, "bcrypt.lib")
+#   endif // defined(_MSC_VER)
+#  endif // !defined(BOOST_ASIO_NO_DEFAULT_LINKED_LIBS)
+# endif // _WIN32_WINNT >= 0x601
+#else // defined(BOOST_ASIO_HAS_IOCP)
+# include <boost/asio/detail/descriptor_ops.hpp>
+#endif // defined(BOOST_ASIO_HAS_IOCP)
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+void create_pipe(native_pipe_handle p[2], boost::system::error_code& ec)
+{
+#if defined(BOOST_ASIO_HAS_IOCP)
+  using namespace std; // For sprintf and memcmp.
+
+  static long counter1 = 0;
+  static long counter2 = 0;
+
+  long n1 = ::InterlockedIncrement(&counter1);
+  long n2 = (static_cast<unsigned long>(n1) % 0x10000000) == 0
+    ? ::InterlockedIncrement(&counter2)
+    : ::InterlockedExchangeAdd(&counter2, 0);
+
+  wchar_t pipe_name[128];
+#if defined(BOOST_ASIO_HAS_SECURE_RTL)
+  swprintf_s(
+#else // defined(BOOST_ASIO_HAS_SECURE_RTL)
+  _snwprintf(
+#endif // defined(BOOST_ASIO_HAS_SECURE_RTL)
+      pipe_name, 128,
+      L"\\\\.\\pipe\\asio-A0812896-741A-484D-AF23-BE51BF620E22-%u-%ld-%ld",
+      static_cast<unsigned int>(::GetCurrentProcessId()), n1, n2);
+
+  p[0] = ::CreateNamedPipeW(pipe_name,
+      PIPE_ACCESS_INBOUND | FILE_FLAG_OVERLAPPED,
+      0, 1, 8192, 8192, 0, 0);
+
+  if (p[0] == INVALID_HANDLE_VALUE)
+  {
+    DWORD last_error = ::GetLastError();
+    ec.assign(last_error, boost::asio::error::get_system_category());
+    return;
+  }
+
+  p[1] = ::CreateFileW(pipe_name, GENERIC_WRITE, 0,
+    0, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0);
+
+  if (p[1] == INVALID_HANDLE_VALUE)
+  {
+    DWORD last_error = ::GetLastError();
+    ::CloseHandle(p[0]);
+    ec.assign(last_error, boost::asio::error::get_system_category());
+    return;
+  }
+
+# if _WIN32_WINNT >= 0x601
+  unsigned char nonce[16];
+  if (::BCryptGenRandom(0, nonce, sizeof(nonce),
+        BCRYPT_USE_SYSTEM_PREFERRED_RNG) != 0)
+  {
+    ec = boost::asio::error::connection_aborted;
+    ::CloseHandle(p[0]);
+    ::CloseHandle(p[1]);
+    return;
+  }
+
+  DWORD bytes_written = 0;
+  BOOL ok = ::WriteFile(p[1], nonce, sizeof(nonce), &bytes_written, 0);
+  if (!ok || bytes_written != sizeof(nonce))
+  {
+    ec = boost::asio::error::connection_aborted;
+    ::CloseHandle(p[0]);
+    ::CloseHandle(p[1]);
+    return;
+  }
+
+  unsigned char nonce_check[sizeof(nonce)];
+  DWORD bytes_read = 0;
+  ok = ::ReadFile(p[0], nonce_check, sizeof(nonce), &bytes_read, 0);
+  if (!ok || bytes_read != sizeof(nonce)
+      || memcmp(nonce, nonce_check, sizeof(nonce)) != 0)
+  {
+    ec = boost::asio::error::connection_aborted;
+    ::CloseHandle(p[0]);
+    ::CloseHandle(p[1]);
+    return;
+  }
+#endif // _WIN32_WINNT >= 0x601
+
+  boost::asio::error::clear(ec);
+#else // defined(BOOST_ASIO_HAS_IOCP)
+  int result = ::pipe(p);
+  detail::descriptor_ops::get_last_error(ec, result != 0);
+#endif // defined(BOOST_ASIO_HAS_IOCP)
+}
+
+void close_pipe(native_pipe_handle p)
+{
+#if defined(BOOST_ASIO_HAS_IOCP)
+  ::CloseHandle(p);
+#else // defined(BOOST_ASIO_HAS_IOCP)
+  boost::system::error_code ignored_ec;
+  detail::descriptor_ops::state_type state = 0;
+  detail::descriptor_ops::close(p, state, ignored_ec);
+#endif // defined(BOOST_ASIO_HAS_IOCP)
+}
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_HAS_PIPE)
+
+#endif // BOOST_ASIO_IMPL_CONNECT_PIPE_IPP

data/src/cxx_supportlib/vendor-modified/boost/asio/impl/defer.hpp

@@ -2,7 +2,7 @@
 // impl/defer.hpp
 // ~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -217,34 +217,44 @@ private:
 
 } // namespace detail
 
-template <BOOST_ASIO_COMPLETION_TOKEN_FOR(void()) CompletionToken>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken, void()) defer(
-    BOOST_ASIO_MOVE_ARG(CompletionToken) token)
+template <BOOST_ASIO_COMPLETION_TOKEN_FOR(void()) NullaryToken>
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(NullaryToken, void()) defer(
+    BOOST_ASIO_MOVE_ARG(NullaryToken) token)
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    async_initiate<NullaryToken, void()>(
+        declval<detail::initiate_defer>(), token)))
 {
-  return async_initiate<CompletionToken, void()>(
+  return async_initiate<NullaryToken, void()>(
       detail::initiate_defer(), token);
 }
 
 template <typename Executor,
-    BOOST_ASIO_COMPLETION_TOKEN_FOR(void()) CompletionToken>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken, void()) defer(
-    const Executor& ex, BOOST_ASIO_MOVE_ARG(CompletionToken) token,
+    BOOST_ASIO_COMPLETION_TOKEN_FOR(void()) NullaryToken>
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(NullaryToken, void()) defer(
+    const Executor& ex, BOOST_ASIO_MOVE_ARG(NullaryToken) token,
     typename constraint<
       execution::is_executor<Executor>::value || is_executor<Executor>::value
     >::type)
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    async_initiate<NullaryToken, void()>(
+        declval<detail::initiate_defer_with_executor<Executor> >(), token)))
 {
-  return async_initiate<CompletionToken, void()>(
+  return async_initiate<NullaryToken, void()>(
       detail::initiate_defer_with_executor<Executor>(ex), token);
 }
 
 template <typename ExecutionContext,
-    BOOST_ASIO_COMPLETION_TOKEN_FOR(void()) CompletionToken>
-inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken, void()) defer(
-    ExecutionContext& ctx, BOOST_ASIO_MOVE_ARG(CompletionToken) token,
+    BOOST_ASIO_COMPLETION_TOKEN_FOR(void()) NullaryToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(NullaryToken, void()) defer(
+    ExecutionContext& ctx, BOOST_ASIO_MOVE_ARG(NullaryToken) token,
     typename constraint<is_convertible<
       ExecutionContext&, execution_context&>::value>::type)
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    async_initiate<NullaryToken, void()>(
+        declval<detail::initiate_defer_with_executor<
+          typename ExecutionContext::executor_type> >(), token)))
 {
-  return async_initiate<CompletionToken, void()>(
+  return async_initiate<NullaryToken, void()>(
       detail::initiate_defer_with_executor<
         typename ExecutionContext::executor_type>(
           ctx.get_executor()), token);