passenger 6.0.23 → 6.0.24

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

@@ -230,7 +230,7 @@ public:
     default:
       p.p->ec_ = boost::asio::error::invalid_argument;
       start_op(impl, reactor::read_op, p.p,
-          is_continuation, false, true, &io_ex, 0);
+          is_continuation, false, true, false, &io_ex, 0);
       p.v = p.p = 0;
       return;
     }
@@ -243,7 +243,8 @@ public:
             &reactor_, &impl.reactor_data_, impl.socket_, op_type);
     }
 
-    start_op(impl, op_type, p.p, is_continuation, false, false, &io_ex, 0);
+    start_op(impl, op_type, p.p, is_continuation,
+        false, false, false, &io_ex, 0);
     p.v = p.p = 0;
   }
 
@@ -315,7 +316,7 @@ public:
     start_op(impl, reactor::write_op, p.p, is_continuation, true,
         ((impl.state_ & socket_ops::stream_oriented)
           && buffer_sequence_adapter<boost::asio::const_buffer,
-            ConstBufferSequence>::all_empty(buffers)), &io_ex, 0);
+            ConstBufferSequence>::all_empty(buffers)), true, &io_ex, 0);
     p.v = p.p = 0;
   }
 
@@ -348,7 +349,7 @@ public:
           &impl, impl.socket_, "async_send(null_buffers)"));
 
     start_op(impl, reactor::write_op, p.p,
-        is_continuation, false, false, &io_ex, 0);
+        is_continuation, false, false, false, &io_ex, 0);
     p.v = p.p = 0;
   }
 
@@ -425,7 +426,7 @@ public:
         (flags & socket_base::message_out_of_band) == 0,
         ((impl.state_ & socket_ops::stream_oriented)
           && buffer_sequence_adapter<boost::asio::mutable_buffer,
-            MutableBufferSequence>::all_empty(buffers)), &io_ex, 0);
+            MutableBufferSequence>::all_empty(buffers)), true, &io_ex, 0);
     p.v = p.p = 0;
   }
 
@@ -461,7 +462,7 @@ public:
     start_op(impl,
         (flags & socket_base::message_out_of_band)
           ? reactor::except_op : reactor::read_op,
-        p.p, is_continuation, false, false, &io_ex, 0);
+        p.p, is_continuation, false, false, false, &io_ex, 0);
     p.v = p.p = 0;
   }
 
@@ -533,7 +534,8 @@ public:
         (in_flags & socket_base::message_out_of_band)
           ? reactor::except_op : reactor::read_op,
         p.p, is_continuation,
-        (in_flags & socket_base::message_out_of_band) == 0, false, &io_ex, 0);
+        (in_flags & socket_base::message_out_of_band) == 0,
+        false, true, &io_ex, 0);
     p.v = p.p = 0;
   }
 
@@ -574,7 +576,7 @@ public:
     start_op(impl,
         (in_flags & socket_base::message_out_of_band)
           ? reactor::except_op : reactor::read_op,
-        p.p, is_continuation, false, false, &io_ex, 0);
+        p.p, is_continuation, false, false, false, &io_ex, 0);
     p.v = p.p = 0;
   }
 
@@ -590,8 +592,9 @@ protected:
       const native_handle_type& native_socket, boost::system::error_code& ec);
 
   // Start the asynchronous read or write operation.
-  BOOST_ASIO_DECL void do_start_op(base_implementation_type& impl, int op_type,
-      reactor_op* op, bool is_continuation, bool is_non_blocking, bool noop,
+  BOOST_ASIO_DECL void do_start_op(base_implementation_type& impl,
+      int op_type, reactor_op* op, bool is_continuation,
+      bool allow_speculative, bool noop, bool needs_non_blocking,
       void (*on_immediate)(operation* op, bool, const void*),
       const void* immediate_arg);
 
@@ -599,18 +602,19 @@ protected:
   // immediate completion.
   template <typename Op>
   void start_op(base_implementation_type& impl, int op_type, Op* op,
-      bool is_continuation, bool is_non_blocking, bool noop,
-      const void* io_ex, ...)
+      bool is_continuation, bool allow_speculative, bool noop,
+      bool needs_non_blocking, const void* io_ex, ...)
   {
-    return do_start_op(impl, op_type, op, is_continuation,
-        is_non_blocking, noop, &Op::do_immediate, io_ex);
+    return do_start_op(impl, op_type, op, is_continuation, allow_speculative,
+        noop, needs_non_blocking, &Op::do_immediate, io_ex);
   }
 
   // Start the asynchronous operation for handlers that are not specialised for
   // immediate completion.
   template <typename Op>
-  void start_op(base_implementation_type& impl, int op_type, Op* op,
-      bool is_continuation, bool is_non_blocking, bool noop, const void*,
+  void start_op(base_implementation_type& impl, int op_type,
+      Op* op, bool is_continuation, bool allow_speculative,
+      bool noop, bool needs_non_blocking, const void*,
       enable_if_t<
         is_same<
           typename associated_immediate_executor<
@@ -621,8 +625,9 @@ protected:
         >::value
       >*)
   {
-    return do_start_op(impl, op_type, op, is_continuation, is_non_blocking,
-        noop, &reactor::call_post_immediate_completion, &reactor_);
+    return do_start_op(impl, op_type, op, is_continuation,
+        allow_speculative, noop, needs_non_blocking,
+        &reactor::call_post_immediate_completion, &reactor_);
   }
 
   // Start the asynchronous accept operation.

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

@@ -49,16 +49,25 @@ public:
 
   T* allocate(std::size_t n)
   {
+#if !defined(BOOST_ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
     void* p = thread_info_base::allocate(Purpose(),
         thread_context::top_of_thread_call_stack(),
         sizeof(T) * n, alignof(T));
+#else // !defined(BOOST_ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
+    void* p = boost::asio::aligned_new(align, s);
+#endif // !defined(BOOST_ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
     return static_cast<T*>(p);
   }
 
   void deallocate(T* p, std::size_t n)
   {
+#if !defined(BOOST_ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
     thread_info_base::deallocate(Purpose(),
         thread_context::top_of_thread_call_stack(), p, sizeof(T) * n);
+#else // !defined(BOOST_ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
+    (void)n;
+    boost::asio::aligned_delete(p);
+#endif // !defined(BOOST_ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
   }
 };
 

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

@@ -78,7 +78,7 @@ public:
     {
       // The operation is being run on the worker io_context. Time to perform
       // the resolver operation.
-    
+
       // Perform the blocking endpoint resolution operation.
       char host_name[NI_MAXHOST] = "";
       char service_name[NI_MAXSERV] = "";

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

@@ -86,7 +86,7 @@ public:
     {
       // The operation is being run on the worker io_context. Time to perform
       // the resolver operation.
-    
+
       // Perform the blocking host resolution operation.
       socket_ops::background_getaddrinfo(o->cancel_token_,
           o->query_.host_name().c_str(), o->query_.service_name().c_str(),

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

@@ -90,7 +90,17 @@ public:
     };
   };
 
-  enum { max_mem_index = parallel_group_tag::end_mem_index };
+  struct timed_cancel_tag
+  {
+    enum
+    {
+      cache_size = BOOST_ASIO_RECYCLING_ALLOCATOR_CACHE_SIZE,
+      begin_mem_index = parallel_group_tag::end_mem_index,
+      end_mem_index = begin_mem_index + cache_size
+    };
+  };
+
+  enum { max_mem_index = timed_cancel_tag::end_mem_index };
 
   thread_info_base()
 #if !defined(BOOST_ASIO_NO_EXCEPTIONS)

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

@@ -0,0 +1,363 @@
+//
+// detail/timed_cancel_op.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2024 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_DETAIL_TIMED_CANCEL_OP_HPP
+#define BOOST_ASIO_DETAIL_TIMED_CANCEL_OP_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/associated_cancellation_slot.hpp>
+#include <boost/asio/associator.hpp>
+#include <boost/asio/basic_waitable_timer.hpp>
+#include <boost/asio/cancellation_signal.hpp>
+#include <boost/asio/detail/atomic_count.hpp>
+#include <boost/asio/detail/completion_payload.hpp>
+#include <boost/asio/detail/completion_payload_handler.hpp>
+#include <boost/asio/detail/handler_alloc_helpers.hpp>
+#include <boost/asio/detail/type_traits.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename Op, typename... Signatures>
+class timed_cancel_op_handler;
+
+template <typename Op>
+class timed_cancel_timer_handler;
+
+template <typename Handler, typename Timer, typename... Signatures>
+class timed_cancel_op
+{
+public:
+  using handler_type = Handler;
+
+  BOOST_ASIO_DEFINE_TAGGED_HANDLER_PTR(
+      thread_info_base::timed_cancel_tag, timed_cancel_op);
+
+  timed_cancel_op(Handler& handler, Timer timer,
+      cancellation_type_t cancel_type)
+    : ref_count_(2),
+      handler_(static_cast<Handler&&>(handler)),
+      timer_(static_cast<Timer&&>(timer)),
+      cancellation_type_(cancel_type),
+      cancel_proxy_(nullptr),
+      has_payload_(false),
+      has_pending_timer_wait_(true)
+  {
+  }
+
+  ~timed_cancel_op()
+  {
+    if (has_payload_)
+      payload_storage_.payload_.~payload_type();
+  }
+
+  cancellation_slot get_cancellation_slot() noexcept
+  {
+    return cancellation_signal_.slot();
+  }
+
+  template <typename Initiation, typename... Args>
+  void start(Initiation&& initiation, Args&&... args)
+  {
+    using op_handler_type =
+      timed_cancel_op_handler<timed_cancel_op, Signatures...>;
+    op_handler_type op_handler(this);
+
+    using timer_handler_type =
+      timed_cancel_timer_handler<timed_cancel_op>;
+    timer_handler_type timer_handler(this);
+
+    associated_cancellation_slot_t<Handler> slot
+      = (get_associated_cancellation_slot)(handler_);
+    if (slot.is_connected())
+      cancel_proxy_ = &slot.template emplace<cancel_proxy>(this);
+
+    timer_.async_wait(static_cast<timer_handler_type&&>(timer_handler));
+    async_initiate<op_handler_type, Signatures...>(
+        static_cast<Initiation&&>(initiation),
+        static_cast<op_handler_type&>(op_handler),
+        static_cast<Args&&>(args)...);
+  }
+
+  template <typename Message>
+  void handle_op(Message&& message)
+  {
+    if (cancel_proxy_)
+      cancel_proxy_->op_ = nullptr;
+
+    new (&payload_storage_.payload_) payload_type(
+        static_cast<Message&&>(message));
+    has_payload_ = true;
+
+    if (has_pending_timer_wait_)
+    {
+      timer_.cancel();
+      release();
+    }
+    else
+    {
+      complete();
+    }
+  }
+
+  void handle_timer()
+  {
+    has_pending_timer_wait_ = false;
+
+    if (has_payload_)
+    {
+      complete();
+    }
+    else
+    {
+      cancellation_signal_.emit(cancellation_type_);
+      release();
+    }
+  }
+
+  void release()
+  {
+    if (--ref_count_ == 0)
+    {
+      ptr p = { boost::asio::detail::addressof(handler_), this, this };
+      Handler handler(static_cast<Handler&&>(handler_));
+      p.h = boost::asio::detail::addressof(handler);
+      p.reset();
+    }
+  }
+
+  void complete()
+  {
+    if (--ref_count_ == 0)
+    {
+      ptr p = { boost::asio::detail::addressof(handler_), this, this };
+      completion_payload_handler<payload_type, Handler> handler(
+          static_cast<payload_type&&>(payload_storage_.payload_), handler_);
+      p.h = boost::asio::detail::addressof(handler.handler());
+      p.reset();
+      handler();
+    }
+  }
+
+//private:
+  typedef completion_payload<Signatures...> payload_type;
+
+  struct cancel_proxy
+  {
+    cancel_proxy(timed_cancel_op* op)
+      : op_(op)
+    {
+    }
+
+    void operator()(cancellation_type_t type)
+    {
+      if (op_)
+        op_->cancellation_signal_.emit(type);
+    }
+
+    timed_cancel_op* op_;
+  };
+
+  // The number of handlers that share a reference to the state.
+  atomic_count ref_count_;
+
+  // The handler to be called when the operation completes.
+  Handler handler_;
+
+  // The timer used to determine when to cancel the pending operation.
+  Timer timer_;
+
+  // The cancellation signal and type used to cancel the pending operation.
+  cancellation_signal cancellation_signal_;
+  cancellation_type_t cancellation_type_;
+
+  // A proxy cancel handler used to allow cancellation of the timed operation.
+  cancel_proxy* cancel_proxy_;
+
+  // Arguments to be passed to the completion handler.
+  union payload_storage
+  {
+    payload_storage() {}
+    ~payload_storage() {}
+
+    char dummy_;
+    payload_type payload_;
+  } payload_storage_;
+
+  // Whether the payload storage contains a valid payload.
+  bool has_payload_;
+
+  // Whether the asynchronous wait on the timer is still pending
+  bool has_pending_timer_wait_;
+};
+
+template <typename Op, typename R, typename... Args>
+class timed_cancel_op_handler<Op, R(Args...)>
+{
+public:
+  using cancellation_slot_type = cancellation_slot;
+
+  explicit timed_cancel_op_handler(Op* op)
+    : op_(op)
+  {
+  }
+
+  timed_cancel_op_handler(timed_cancel_op_handler&& other) noexcept
+    : op_(other.op_)
+  {
+    other.op_ = nullptr;
+  }
+
+  ~timed_cancel_op_handler()
+  {
+    if (op_)
+      op_->release();
+  }
+
+  cancellation_slot_type get_cancellation_slot() const noexcept
+  {
+    return op_->get_cancellation_slot();
+  }
+
+  template <typename... Args2>
+  enable_if_t<
+    is_constructible<completion_message<R(Args...)>, int, Args2...>::value
+  > operator()(Args2&&... args)
+  {
+    Op* op = op_;
+    op_ = nullptr;
+    typedef completion_message<R(Args...)> message_type;
+    op->handle_op(message_type(0, static_cast<Args2&&>(args)...));
+  }
+
+//protected:
+  Op* op_;
+};
+
+template <typename Op, typename R, typename... Args, typename... Signatures>
+class timed_cancel_op_handler<Op, R(Args...), Signatures...> :
+  public timed_cancel_op_handler<Op, Signatures...>
+{
+public:
+  using timed_cancel_op_handler<Op, Signatures...>::timed_cancel_op_handler;
+  using timed_cancel_op_handler<Op, Signatures...>::operator();
+
+  template <typename... Args2>
+  enable_if_t<
+    is_constructible<completion_message<R(Args...)>, int, Args2...>::value
+  > operator()(Args2&&... args)
+  {
+    Op* op = this->op_;
+    this->op_ = nullptr;
+    typedef completion_message<R(Args...)> message_type;
+    op->handle_op(message_type(0, static_cast<Args2&&>(args)...));
+  }
+};
+
+template <typename Op>
+class timed_cancel_timer_handler
+{
+public:
+  using cancellation_slot_type = cancellation_slot;
+
+  explicit timed_cancel_timer_handler(Op* op)
+    : op_(op)
+  {
+  }
+
+  timed_cancel_timer_handler(timed_cancel_timer_handler&& other) noexcept
+    : op_(other.op_)
+  {
+    other.op_ = nullptr;
+  }
+
+  ~timed_cancel_timer_handler()
+  {
+    if (op_)
+      op_->release();
+  }
+
+  cancellation_slot_type get_cancellation_slot() const noexcept
+  {
+    return cancellation_slot_type();
+  }
+
+  void operator()(const boost::system::error_code&)
+  {
+    Op* op = op_;
+    op_ = nullptr;
+    op->handle_timer();
+  }
+
+//private:
+  Op* op_;
+};
+
+} // namespace detail
+
+template <template <typename, typename> class Associator,
+    typename Op, typename... Signatures, typename DefaultCandidate>
+struct associator<Associator,
+    detail::timed_cancel_op_handler<Op, Signatures...>, DefaultCandidate>
+  : Associator<typename Op::handler_type, DefaultCandidate>
+{
+  static typename Associator<typename Op::handler_type, DefaultCandidate>::type
+  get(const detail::timed_cancel_op_handler<Op, Signatures...>& h) noexcept
+  {
+    return Associator<typename Op::handler_type, DefaultCandidate>::get(
+        h.op_->handler_);
+  }
+
+  static auto get(const detail::timed_cancel_op_handler<Op, Signatures...>& h,
+      const DefaultCandidate& c) noexcept
+    -> decltype(Associator<typename Op::handler_type, DefaultCandidate>::get(
+        h.op_->handler_, c))
+  {
+    return Associator<typename Op::handler_type, DefaultCandidate>::get(
+        h.op_->handler_, c);
+  }
+};
+
+template <template <typename, typename> class Associator,
+    typename Op, typename DefaultCandidate>
+struct associator<Associator,
+    detail::timed_cancel_timer_handler<Op>, DefaultCandidate>
+  : Associator<typename Op::handler_type, DefaultCandidate>
+{
+  static typename Associator<typename Op::handler_type, DefaultCandidate>::type
+  get(const detail::timed_cancel_timer_handler<Op>& h) noexcept
+  {
+    return Associator<typename Op::handler_type, DefaultCandidate>::get(
+        h.op_->handler_);
+  }
+
+  static auto get(const detail::timed_cancel_timer_handler<Op>& h,
+      const DefaultCandidate& c) noexcept
+    -> decltype(Associator<typename Op::handler_type, DefaultCandidate>::get(
+        h.op_->handler_, c))
+  {
+    return Associator<typename Op::handler_type, DefaultCandidate>::get(
+        h.op_->handler_, c);
+  }
+};
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_TIMED_CANCEL_OP_HPP

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

@@ -42,12 +42,36 @@ struct is_continuation_if_running
   }
 };
 
+template <typename Dispatcher, typename = void>
+struct wrapped_executor
+{
+  typedef Dispatcher executor_type;
+
+  static const Dispatcher& get(const Dispatcher& dispatcher) noexcept
+  {
+    return dispatcher;
+  }
+};
+
+template <typename Dispatcher>
+struct wrapped_executor<Dispatcher,
+    void_type<typename Dispatcher::executor_type>>
+{
+  typedef typename Dispatcher::executor_type executor_type;
+
+  static executor_type get(const Dispatcher& dispatcher) noexcept
+  {
+    return dispatcher.get_executor();
+  }
+};
+
 template <typename Dispatcher, typename Handler,
     typename IsContinuation = is_continuation_delegated>
 class wrapped_handler
 {
 public:
   typedef void result_type;
+  typedef typename wrapped_executor<Dispatcher>::executor_type executor_type;
 
   wrapped_handler(Dispatcher dispatcher, Handler& handler)
     : dispatcher_(dispatcher),
@@ -67,6 +91,11 @@ public:
   {
   }
 
+  executor_type get_executor() const noexcept
+  {
+    return wrapped_executor<Dispatcher>::get(dispatcher_);
+  }
+
   void operator()()
   {
     dispatcher_.dispatch(static_cast<Handler&&>(handler_));
@@ -152,49 +181,6 @@ public:
   Handler handler_;
 };
 
-template <typename Handler, typename Context>
-class rewrapped_handler
-{
-public:
-  explicit rewrapped_handler(Handler& handler, const Context& context)
-    : context_(context),
-      handler_(static_cast<Handler&&>(handler))
-  {
-  }
-
-  explicit rewrapped_handler(const Handler& handler, const Context& context)
-    : context_(context),
-      handler_(handler)
-  {
-  }
-
-  rewrapped_handler(const rewrapped_handler& other)
-    : context_(other.context_),
-      handler_(other.handler_)
-  {
-  }
-
-  rewrapped_handler(rewrapped_handler&& other)
-    : context_(static_cast<Context&&>(other.context_)),
-      handler_(static_cast<Handler&&>(other.handler_))
-  {
-  }
-
-  void operator()()
-  {
-    handler_();
-  }
-
-  void operator()() const
-  {
-    handler_();
-  }
-
-//private:
-  Context context_;
-  Handler handler_;
-};
-
 template <typename Dispatcher, typename Handler, typename IsContinuation>
 inline bool asio_handler_is_continuation(
     wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler)
@@ -202,14 +188,6 @@ inline bool asio_handler_is_continuation(
   return IsContinuation()(this_handler->dispatcher_, this_handler->handler_);
 }
 
-template <typename Dispatcher, typename Context>
-inline bool asio_handler_is_continuation(
-    rewrapped_handler<Dispatcher, Context>* this_handler)
-{
-  return boost_asio_handler_cont_helpers::is_continuation(
-      this_handler->context_);
-}
-
 } // namespace detail
 } // namespace asio
 } // namespace boost

data/src/cxx_supportlib/vendor-modified/boost/asio/execution/allocator.hpp

@@ -226,7 +226,7 @@ const T allocator_t<void>::static_query_v;
 #endif // defined(BOOST_ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
        //   && defined(BOOST_ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
 
-constexpr allocator_t<void> allocator;
+BOOST_ASIO_INLINE_VARIABLE constexpr allocator_t<void> allocator;
 
 } // namespace execution
 

data/src/cxx_supportlib/vendor-modified/boost/asio/execution/blocking.hpp

@@ -893,7 +893,7 @@ const T never_t<I>::static_query_v;
 
 typedef detail::blocking_t<> blocking_t;
 
-constexpr blocking_t blocking;
+BOOST_ASIO_INLINE_VARIABLE constexpr blocking_t blocking;
 
 } // namespace execution
 

data/src/cxx_supportlib/vendor-modified/boost/asio/execution/blocking_adaptation.hpp

@@ -719,7 +719,7 @@ void blocking_execute(
 
 typedef detail::blocking_adaptation_t<> blocking_adaptation_t;
 
-constexpr blocking_adaptation_t blocking_adaptation;
+BOOST_ASIO_INLINE_VARIABLE constexpr blocking_adaptation_t blocking_adaptation;
 
 } // namespace execution
 

data/src/cxx_supportlib/vendor-modified/boost/asio/execution/context.hpp

@@ -139,7 +139,7 @@ const T context_t<I>::static_query_v;
 
 typedef detail::context_t<> context_t;
 
-constexpr context_t context;
+BOOST_ASIO_INLINE_VARIABLE constexpr context_t context;
 
 } // namespace execution