passenger 6.0.11 → 6.0.12

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

@@ -107,7 +107,7 @@ struct require_result
 
 #else // defined(GENERATING_DOCUMENTATION)
 
-namespace asio_require_fn {
+namespace boost_asio_require_fn {
 
 using boost::asio::conditional;
 using boost::asio::decay;
@@ -406,26 +406,26 @@ struct static_instance
 template <typename T>
 const T static_instance<T>::instance = {};
 
-} // namespace asio_require_fn
+} // namespace boost_asio_require_fn
 namespace boost {
 namespace asio {
 namespace {
 
-static BOOST_ASIO_CONSTEXPR const asio_require_fn::impl&
-  require = asio_require_fn::static_instance<>::instance;
+static BOOST_ASIO_CONSTEXPR const boost_asio_require_fn::impl&
+  require = boost_asio_require_fn::static_instance<>::instance;
 
 } // namespace
 
-typedef asio_require_fn::impl require_t;
+typedef boost_asio_require_fn::impl require_t;
 
 #if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
 
 template <typename T, typename... Properties>
 struct can_require :
   integral_constant<bool,
-    asio_require_fn::call_traits<
+    boost_asio_require_fn::call_traits<
       require_t, T, void(Properties...)>::overload
-        != asio_require_fn::ill_formed>
+        != boost_asio_require_fn::ill_formed>
 {
 };
 
@@ -435,24 +435,24 @@ template <typename T, typename P0 = void,
     typename P1 = void, typename P2 = void>
 struct can_require :
   integral_constant<bool,
-    asio_require_fn::call_traits<require_t, T, void(P0, P1, P2)>::overload
-      != asio_require_fn::ill_formed>
+    boost_asio_require_fn::call_traits<require_t, T, void(P0, P1, P2)>::overload
+      != boost_asio_require_fn::ill_formed>
 {
 };
 
 template <typename T, typename P0, typename P1>
 struct can_require<T, P0, P1> :
   integral_constant<bool,
-    asio_require_fn::call_traits<require_t, T, void(P0, P1)>::overload
-      != asio_require_fn::ill_formed>
+    boost_asio_require_fn::call_traits<require_t, T, void(P0, P1)>::overload
+      != boost_asio_require_fn::ill_formed>
 {
 };
 
 template <typename T, typename P0>
 struct can_require<T, P0> :
   integral_constant<bool,
-    asio_require_fn::call_traits<require_t, T, void(P0)>::overload
-      != asio_require_fn::ill_formed>
+    boost_asio_require_fn::call_traits<require_t, T, void(P0)>::overload
+      != boost_asio_require_fn::ill_formed>
 {
 };
 
@@ -477,7 +477,7 @@ constexpr bool can_require_v
 template <typename T, typename... Properties>
 struct is_nothrow_require :
   integral_constant<bool,
-    asio_require_fn::call_traits<
+    boost_asio_require_fn::call_traits<
       require_t, T, void(Properties...)>::is_noexcept>
 {
 };
@@ -488,7 +488,7 @@ template <typename T, typename P0 = void,
     typename P1 = void, typename P2 = void>
 struct is_nothrow_require :
   integral_constant<bool,
-    asio_require_fn::call_traits<
+    boost_asio_require_fn::call_traits<
       require_t, T, void(P0, P1, P2)>::is_noexcept>
 {
 };
@@ -496,7 +496,7 @@ struct is_nothrow_require :
 template <typename T, typename P0, typename P1>
 struct is_nothrow_require<T, P0, P1> :
   integral_constant<bool,
-    asio_require_fn::call_traits<
+    boost_asio_require_fn::call_traits<
       require_t, T, void(P0, P1)>::is_noexcept>
 {
 };
@@ -504,7 +504,7 @@ struct is_nothrow_require<T, P0, P1> :
 template <typename T, typename P0>
 struct is_nothrow_require<T, P0> :
   integral_constant<bool,
-    asio_require_fn::call_traits<
+    boost_asio_require_fn::call_traits<
       require_t, T, void(P0)>::is_noexcept>
 {
 };
@@ -530,7 +530,7 @@ constexpr bool is_nothrow_require_v
 template <typename T, typename... Properties>
 struct require_result
 {
-  typedef typename asio_require_fn::call_traits<
+  typedef typename boost_asio_require_fn::call_traits<
       require_t, T, void(Properties...)>::result_type type;
 };
 
@@ -540,21 +540,21 @@ template <typename T, typename P0 = void,
     typename P1 = void, typename P2 = void>
 struct require_result
 {
-  typedef typename asio_require_fn::call_traits<
+  typedef typename boost_asio_require_fn::call_traits<
       require_t, T, void(P0, P1, P2)>::result_type type;
 };
 
 template <typename T, typename P0, typename P1>
 struct require_result<T, P0, P1>
 {
-  typedef typename asio_require_fn::call_traits<
+  typedef typename boost_asio_require_fn::call_traits<
       require_t, T, void(P0, P1)>::result_type type;
 };
 
 template <typename T, typename P0>
 struct require_result<T, P0>
 {
-  typedef typename asio_require_fn::call_traits<
+  typedef typename boost_asio_require_fn::call_traits<
       require_t, T, void(P0)>::result_type type;
 };
 

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

@@ -107,7 +107,7 @@ struct require_concept_result
 
 #else // defined(GENERATING_DOCUMENTATION)
 
-namespace asio_require_concept_fn {
+namespace boost_asio_require_concept_fn {
 
 using boost::asio::conditional;
 using boost::asio::decay;
@@ -294,24 +294,24 @@ struct static_instance
 template <typename T>
 const T static_instance<T>::instance = {};
 
-} // namespace asio_require_concept_fn
+} // namespace boost_asio_require_concept_fn
 namespace boost {
 namespace asio {
 namespace {
 
-static BOOST_ASIO_CONSTEXPR const asio_require_concept_fn::impl&
-  require_concept = asio_require_concept_fn::static_instance<>::instance;
+static BOOST_ASIO_CONSTEXPR const boost_asio_require_concept_fn::impl&
+  require_concept = boost_asio_require_concept_fn::static_instance<>::instance;
 
 } // namespace
 
-typedef asio_require_concept_fn::impl require_concept_t;
+typedef boost_asio_require_concept_fn::impl require_concept_t;
 
 template <typename T, typename Property>
 struct can_require_concept :
   integral_constant<bool,
-    asio_require_concept_fn::call_traits<
+    boost_asio_require_concept_fn::call_traits<
       require_concept_t, T, void(Property)>::overload !=
-        asio_require_concept_fn::ill_formed>
+        boost_asio_require_concept_fn::ill_formed>
 {
 };
 
@@ -326,7 +326,7 @@ constexpr bool can_require_concept_v
 template <typename T, typename Property>
 struct is_nothrow_require_concept :
   integral_constant<bool,
-    asio_require_concept_fn::call_traits<
+    boost_asio_require_concept_fn::call_traits<
       require_concept_t, T, void(Property)>::is_noexcept>
 {
 };
@@ -342,7 +342,7 @@ constexpr bool is_nothrow_require_concept_v
 template <typename T, typename Property>
 struct require_concept_result
 {
-  typedef typename asio_require_concept_fn::call_traits<
+  typedef typename boost_asio_require_concept_fn::call_traits<
       require_concept_t, T, void(Property)>::result_type type;
 };
 

data/src/cxx_supportlib/vendor-modified/boost/asio/ssl/detail/buffered_handshake_op.hpp

@@ -57,7 +57,7 @@ public:
       const boost::system::error_code& ec,
       const std::size_t& bytes_transferred) const
   {
-    handler(ec, bytes_transferred);
+    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler)(ec, bytes_transferred);
   }
 
 private:

data/src/cxx_supportlib/vendor-modified/boost/asio/ssl/detail/engine.hpp

@@ -67,6 +67,11 @@ public:
   // Destructor.
   BOOST_ASIO_DECL ~engine();
 
+#if defined(BOOST_ASIO_HAS_MOVE)
+  // Move assign from another engine.
+  BOOST_ASIO_DECL engine& operator=(engine&& other) BOOST_ASIO_NOEXCEPT;
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
   // Get the underlying implementation in the native type.
   BOOST_ASIO_DECL SSL* native_handle();
 

data/src/cxx_supportlib/vendor-modified/boost/asio/ssl/detail/handshake_op.hpp

@@ -52,7 +52,7 @@ public:
       const boost::system::error_code& ec,
       const std::size_t&) const
   {
-    handler(ec);
+    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler)(ec);
   }
 
 private:

data/src/cxx_supportlib/vendor-modified/boost/asio/ssl/detail/impl/engine.ipp

@@ -81,6 +81,20 @@ engine::~engine()
     ::SSL_free(ssl_);
 }
 
+#if defined(BOOST_ASIO_HAS_MOVE)
+engine& engine::operator=(engine&& other) BOOST_ASIO_NOEXCEPT
+{
+  if (this != &other)
+  {
+    ssl_ = other.ssl_;
+    ext_bio_ = other.ext_bio_;
+    other.ssl_ = 0;
+    other.ext_bio_ = 0;
+  }
+  return *this;
+}
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
 SSL* engine::native_handle()
 {
   return ssl_;

data/src/cxx_supportlib/vendor-modified/boost/asio/ssl/detail/io.hpp

@@ -17,6 +17,7 @@
 
 #include <boost/asio/detail/config.hpp>
 
+#include <boost/asio/detail/base_from_cancellation_state.hpp>
 #include <boost/asio/detail/handler_tracking.hpp>
 #include <boost/asio/ssl/detail/engine.hpp>
 #include <boost/asio/ssl/detail/stream_core.hpp>
@@ -95,11 +96,13 @@ std::size_t io(Stream& next_layer, stream_core& core,
 
 template <typename Stream, typename Operation, typename Handler>
 class io_op
+  : public boost::asio::detail::base_from_cancellation_state<Handler>
 {
 public:
   io_op(Stream& next_layer, stream_core& core,
       const Operation& op, Handler& handler)
-    : next_layer_(next_layer),
+    : boost::asio::detail::base_from_cancellation_state<Handler>(handler),
+      next_layer_(next_layer),
       core_(core),
       op_(op),
       start_(0),
@@ -111,7 +114,8 @@ public:
 
 #if defined(BOOST_ASIO_HAS_MOVE)
   io_op(const io_op& other)
-    : next_layer_(other.next_layer_),
+    : boost::asio::detail::base_from_cancellation_state<Handler>(other),
+      next_layer_(other.next_layer_),
       core_(other.core_),
       op_(other.op_),
       start_(other.start_),
@@ -123,7 +127,11 @@ public:
   }
 
   io_op(io_op&& other)
-    : next_layer_(other.next_layer_),
+    : boost::asio::detail::base_from_cancellation_state<Handler>(
+        BOOST_ASIO_MOVE_CAST(
+          boost::asio::detail::base_from_cancellation_state<Handler>)(
+            other)),
+      next_layer_(other.next_layer_),
       core_(other.core_),
       op_(BOOST_ASIO_MOVE_CAST(Operation)(other.op_)),
       start_(other.start_),
@@ -263,6 +271,13 @@ public:
           // Release any waiting read operations.
           core_.pending_read_.expires_at(core_.neg_infin());
 
+          // Check for cancellation before continuing.
+          if (this->cancelled() != cancellation_type::none)
+          {
+            ec_ = boost::asio::error::operation_aborted;
+            break;
+          }
+
           // Try the operation again.
           continue;
 
@@ -271,6 +286,13 @@ public:
           // Release any waiting write operations.
           core_.pending_write_.expires_at(core_.neg_infin());
 
+          // Check for cancellation before continuing.
+          if (this->cancelled() != cancellation_type::none)
+          {
+            ec_ = boost::asio::error::operation_aborted;
+            break;
+          }
+
           // Try the operation again.
           continue;
 
@@ -381,32 +403,19 @@ inline void async_io(Stream& next_layer, stream_core& core,
 } // namespace detail
 } // namespace ssl
 
-template <typename Stream, typename Operation,
-    typename Handler, typename Allocator>
-struct associated_allocator<
-    ssl::detail::io_op<Stream, Operation, Handler>, Allocator>
+template <template <typename, typename> class Associator,
+    typename Stream, typename Operation,
+    typename Handler, typename DefaultCandidate>
+struct associator<Associator,
+    ssl::detail::io_op<Stream, Operation, Handler>,
+    DefaultCandidate>
+  : Associator<Handler, DefaultCandidate>
 {
-  typedef typename associated_allocator<Handler, Allocator>::type type;
-
-  static type get(const ssl::detail::io_op<Stream, Operation, Handler>& h,
-      const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
-  {
-    return associated_allocator<Handler, Allocator>::get(h.handler_, a);
-  }
-};
-
-template <typename Stream, typename Operation,
-    typename Handler, typename Executor>
-struct associated_executor<
-    ssl::detail::io_op<Stream, Operation, Handler>, Executor>
-  : detail::associated_executor_forwarding_base<Handler, Executor>
-{
-  typedef typename associated_executor<Handler, Executor>::type type;
-
-  static type get(const ssl::detail::io_op<Stream, Operation, Handler>& h,
-      const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT
+  static typename Associator<Handler, DefaultCandidate>::type get(
+      const ssl::detail::io_op<Stream, Operation, Handler>& h,
+      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
   {
-    return associated_executor<Handler, Executor>::get(h.handler_, ex);
+    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
   }
 };
 

data/src/cxx_supportlib/vendor-modified/boost/asio/ssl/detail/read_op.hpp

@@ -57,7 +57,7 @@ public:
       const boost::system::error_code& ec,
       const std::size_t& bytes_transferred) const
   {
-    handler(ec, bytes_transferred);
+    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler)(ec, bytes_transferred);
   }
 
 private:

data/src/cxx_supportlib/vendor-modified/boost/asio/ssl/detail/shutdown_op.hpp

@@ -52,11 +52,11 @@ public:
       // The engine only generates an eof when the shutdown notification has
       // been received from the peer. This indicates that the shutdown has
       // completed successfully, and thus need not be passed on to the handler.
-      handler(boost::system::error_code());
+      BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler)(boost::system::error_code());
     }
     else
     {
-      handler(ec);
+      BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler)(ec);
     }
   }
 };

data/src/cxx_supportlib/vendor-modified/boost/asio/ssl/detail/stream_core.hpp

@@ -90,6 +90,43 @@ struct stream_core
   {
   }
 
+#if defined(BOOST_ASIO_HAS_MOVE)
+  stream_core& operator=(stream_core&& other)
+  {
+    if (this != &other)
+    {
+      engine_ = BOOST_ASIO_MOVE_CAST(engine)(other.engine_);
+#if defined(BOOST_ASIO_HAS_BOOST_DATE_TIME)
+      pending_read_ =
+        BOOST_ASIO_MOVE_CAST(boost::asio::deadline_timer)(
+          other.pending_read_);
+      pending_write_ =
+        BOOST_ASIO_MOVE_CAST(boost::asio::deadline_timer)(
+          other.pending_write_);
+#else // defined(BOOST_ASIO_HAS_BOOST_DATE_TIME)
+      pending_read_ =
+        BOOST_ASIO_MOVE_CAST(boost::asio::steady_timer)(
+          other.pending_read_);
+      pending_write_ =
+        BOOST_ASIO_MOVE_CAST(boost::asio::steady_timer)(
+          other.pending_write_);
+#endif // defined(BOOST_ASIO_HAS_BOOST_DATE_TIME)
+      output_buffer_space_ =
+        BOOST_ASIO_MOVE_CAST(std::vector<unsigned char>)(
+          other.output_buffer_space_);
+      output_buffer_ = other.output_buffer_;
+      input_buffer_space_ =
+        BOOST_ASIO_MOVE_CAST(std::vector<unsigned char>)(
+          other.input_buffer_space_);
+      input_ = other.input_;
+      other.output_buffer_ = boost::asio::mutable_buffer(0, 0);
+      other.input_buffer_ = boost::asio::mutable_buffer(0, 0);
+      other.input_ = boost::asio::const_buffer(0, 0);
+    }
+    return *this;
+  }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
   // The SSL engine.
   engine engine_;
 

data/src/cxx_supportlib/vendor-modified/boost/asio/ssl/detail/write_op.hpp

@@ -61,7 +61,7 @@ public:
       const boost::system::error_code& ec,
       const std::size_t& bytes_transferred) const
   {
-    handler(ec, bytes_transferred);
+    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler)(ec, bytes_transferred);
   }
 
 private:

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

@@ -398,7 +398,8 @@ context::~context()
   if (handle_)
   {
 #if ((OPENSSL_VERSION_NUMBER >= 0x10100000L) \
-      && !defined(LIBRESSL_VERSION_NUMBER)) \
+      && (!defined(LIBRESSL_VERSION_NUMBER) \
+        || LIBRESSL_VERSION_NUMBER >= 0x2070000fL)) \
     || defined(BOOST_ASIO_USE_WOLFSSL)
     void* cb_userdata = ::SSL_CTX_get_default_passwd_cb_userdata(handle_);
 #else // (OPENSSL_VERSION_NUMBER >= 0x10100000L)
@@ -411,7 +412,8 @@ context::~context()
             cb_userdata);
       delete callback;
 #if ((OPENSSL_VERSION_NUMBER >= 0x10100000L) \
-      && !defined(LIBRESSL_VERSION_NUMBER)) \
+      && (!defined(LIBRESSL_VERSION_NUMBER) \
+        || LIBRESSL_VERSION_NUMBER >= 0x2070000fL)) \
     || defined(BOOST_ASIO_USE_WOLFSSL)
       ::SSL_CTX_set_default_passwd_cb_userdata(handle_, 0);
 #else // (OPENSSL_VERSION_NUMBER >= 0x10100000L)
@@ -760,7 +762,8 @@ BOOST_ASIO_SYNC_OP_VOID context::use_certificate_chain(
   if (bio.p)
   {
 #if ((OPENSSL_VERSION_NUMBER >= 0x10100000L) \
-      && !defined(LIBRESSL_VERSION_NUMBER)) \
+      && (!defined(LIBRESSL_VERSION_NUMBER) \
+        || LIBRESSL_VERSION_NUMBER >= 0x2070000fL)) \
     || defined(BOOST_ASIO_USE_WOLFSSL)
     pem_password_cb* callback = ::SSL_CTX_get_default_passwd_cb(handle_);
     void* cb_userdata = ::SSL_CTX_get_default_passwd_cb_userdata(handle_);
@@ -789,7 +792,8 @@ BOOST_ASIO_SYNC_OP_VOID context::use_certificate_chain(
     }
 
 #if ((OPENSSL_VERSION_NUMBER >= 0x10002000L) \
-      && !defined(LIBRESSL_VERSION_NUMBER)) \
+      && (!defined(LIBRESSL_VERSION_NUMBER) \
+        || LIBRESSL_VERSION_NUMBER >= 0x2090100fL)) \
     || defined(BOOST_ASIO_USE_WOLFSSL)
     ::SSL_CTX_clear_chain_certs(handle_);
 #else
@@ -868,7 +872,8 @@ BOOST_ASIO_SYNC_OP_VOID context::use_private_key(
   ::ERR_clear_error();
 
 #if ((OPENSSL_VERSION_NUMBER >= 0x10100000L) \
-      && !defined(LIBRESSL_VERSION_NUMBER)) \
+      && (!defined(LIBRESSL_VERSION_NUMBER) \
+        || LIBRESSL_VERSION_NUMBER >= 0x2070000fL)) \
     || defined(BOOST_ASIO_USE_WOLFSSL)
     pem_password_cb* callback = ::SSL_CTX_get_default_passwd_cb(handle_);
     void* cb_userdata = ::SSL_CTX_get_default_passwd_cb_userdata(handle_);
@@ -937,7 +942,8 @@ BOOST_ASIO_SYNC_OP_VOID context::use_rsa_private_key(
   ::ERR_clear_error();
 
 #if ((OPENSSL_VERSION_NUMBER >= 0x10100000L) \
-      && !defined(LIBRESSL_VERSION_NUMBER)) \
+      && (!defined(LIBRESSL_VERSION_NUMBER) \
+        || LIBRESSL_VERSION_NUMBER >= 0x2070000fL)) \
     || defined(BOOST_ASIO_USE_WOLFSSL)
     pem_password_cb* callback = ::SSL_CTX_get_default_passwd_cb(handle_);
     void* cb_userdata = ::SSL_CTX_get_default_passwd_cb_userdata(handle_);
@@ -1178,7 +1184,8 @@ BOOST_ASIO_SYNC_OP_VOID context::do_set_password_callback(
     detail::password_callback_base* callback, boost::system::error_code& ec)
 {
 #if ((OPENSSL_VERSION_NUMBER >= 0x10100000L) \
-      && !defined(LIBRESSL_VERSION_NUMBER)) \
+      && (!defined(LIBRESSL_VERSION_NUMBER) \
+        || LIBRESSL_VERSION_NUMBER >= 0x2070000fL)) \
     || defined(BOOST_ASIO_USE_WOLFSSL)
   void* old_callback = ::SSL_CTX_get_default_passwd_cb_userdata(handle_);
   ::SSL_CTX_set_default_passwd_cb_userdata(handle_, callback);

data/src/cxx_supportlib/vendor-modified/boost/asio/ssl/stream.hpp

@@ -116,13 +116,30 @@ public:
    * @param other The other stream object from which the move will occur. Must
    * have no outstanding asynchronous operations associated with it. Following
    * the move, @c other has a valid but unspecified state where the only safe
-   * operation is destruction.
+   * operation is destruction, or use as the target of a move assignment.
    */
   stream(stream&& other)
     : next_layer_(BOOST_ASIO_MOVE_CAST(Stream)(other.next_layer_)),
       core_(BOOST_ASIO_MOVE_CAST(detail::stream_core)(other.core_))
   {
   }
+
+  /// Move-assign a stream from another.
+  /**
+   * @param other The other stream object from which the move will occur. Must
+   * have no outstanding asynchronous operations associated with it. Following
+   * the move, @c other has a valid but unspecified state where the only safe
+   * operation is destruction, or use as the target of a move assignment.
+   */
+  stream& operator=(stream&& other)
+  {
+    if (this != &other)
+    {
+      next_layer_ = BOOST_ASIO_MOVE_CAST(Stream)(other.next_layer_);
+      core_ = BOOST_ASIO_MOVE_CAST(detail::stream_core)(other.core_);
+    }
+    return *this;
+  }
 #endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 
   /// Destructor.
@@ -445,6 +462,17 @@ public:
    * @code void handler(
    *   const boost::system::error_code& error // Result of operation.
    * ); @endcode
+   *
+   * @par Per-Operation Cancellation
+   * This asynchronous operation supports cancellation for the following
+   * boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * if they are also supported by the @c Stream type's @c async_read_some and
+   * @c async_write_some operations.
    */
   template <
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code))
@@ -481,6 +509,17 @@ public:
    *   const boost::system::error_code& error, // Result of operation.
    *   std::size_t bytes_transferred // Amount of buffers used in handshake.
    * ); @endcode
+   *
+   * @par Per-Operation Cancellation
+   * This asynchronous operation supports cancellation for the following
+   * boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * if they are also supported by the @c Stream type's @c async_read_some and
+   * @c async_write_some operations.
    */
   template <typename ConstBufferSequence,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
@@ -535,6 +574,17 @@ public:
    * @code void handler(
    *   const boost::system::error_code& error // Result of operation.
    * ); @endcode
+   *
+   * @par Per-Operation Cancellation
+   * This asynchronous operation supports cancellation for the following
+   * boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * if they are also supported by the @c Stream type's @c async_read_some and
+   * @c async_write_some operations.
    */
   template <
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code))
@@ -622,6 +672,17 @@ public:
    * the peer. Consider using the @ref async_write function if you need to
    * ensure that all data is written before the asynchronous operation
    * completes.
+   *
+   * @par Per-Operation Cancellation
+   * This asynchronous operation supports cancellation for the following
+   * boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * if they are also supported by the @c Stream type's @c async_read_some and
+   * @c async_write_some operations.
    */
   template <typename ConstBufferSequence,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
@@ -709,6 +770,17 @@ public:
    * number of bytes. Consider using the @ref async_read function if you need to
    * ensure that the requested amount of data is read before the asynchronous
    * operation completes.
+   *
+   * @par Per-Operation Cancellation
+   * This asynchronous operation supports cancellation for the following
+   * boost::asio::cancellation_type values:
+   *
+   * @li @c cancellation_type::terminal
+   *
+   * @li @c cancellation_type::partial
+   *
+   * if they are also supported by the @c Stream type's @c async_read_some and
+   * @c async_write_some operations.
    */
   template <typename MutableBufferSequence,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,

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

@@ -47,8 +47,8 @@ public:
 
 #if !defined(GENERATING_DOCUMENTATION)
 private:
-  friend struct asio_require_fn::impl;
-  friend struct asio_prefer_fn::impl;
+  friend struct boost_asio_require_fn::impl;
+  friend struct boost_asio_prefer_fn::impl;
 #endif // !defined(GENERATING_DOCUMENTATION)
 
   /// Obtain an executor with the @c blocking.possibly property.
@@ -178,7 +178,7 @@ private:
 
 #if !defined(GENERATING_DOCUMENTATION)
 private:
-  friend struct asio_query_fn::impl;
+  friend struct boost_asio_query_fn::impl;
   friend struct boost::asio::execution::detail::blocking_t<0>;
   friend struct boost::asio::execution::detail::mapping_t<0>;
   friend struct boost::asio::execution::detail::outstanding_work_t<0>;
@@ -317,7 +317,7 @@ public:
 
 #if !defined(GENERATING_DOCUMENTATION)
 private:
-  friend struct asio_execution_execute_fn::impl;
+  friend struct boost_asio_execution_execute_fn::impl;
 #endif // !defined(GENERATING_DOCUMENTATION)
 
   /// Execution function.