passenger 6.0.11 → 6.0.14

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

@@ -20,7 +20,9 @@
 #if !defined(BOOST_ASIO_HAS_IOCP) \
   && !defined(BOOST_ASIO_WINDOWS_RUNTIME)
 
+#include <boost/asio/associated_cancellation_slot.hpp>
 #include <boost/asio/buffer.hpp>
+#include <boost/asio/cancellation_type.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/execution_context.hpp>
 #include <boost/asio/socket_base.hpp>
@@ -200,6 +202,9 @@ public:
     bool is_continuation =
       boost_asio_handler_cont_helpers::is_continuation(handler);
 
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_wait_op<Handler, IoExecutor> op;
     typename op::ptr p = { boost::asio::detail::addressof(handler),
@@ -228,6 +233,14 @@ public:
         return;
     }
 
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ =
+        &slot.template emplace<reactor_op_cancellation>(
+            &reactor_, &impl.reactor_data_, impl.socket_, op_type);
+    }
+
     start_op(impl, op_type, p.p, is_continuation, false, false);
     p.v = p.p = 0;
   }
@@ -275,6 +288,9 @@ public:
     bool is_continuation =
       boost_asio_handler_cont_helpers::is_continuation(handler);
 
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_socket_send_op<
         ConstBufferSequence, Handler, IoExecutor> op;
@@ -283,6 +299,14 @@ public:
     p.p = new (p.v) op(success_ec_, impl.socket_,
         impl.state_, buffers, flags, handler, io_ex);
 
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ =
+        &slot.template emplace<reactor_op_cancellation>(
+            &reactor_, &impl.reactor_data_, impl.socket_, reactor::write_op);
+    }
+
     BOOST_ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "socket",
           &impl, impl.socket_, "async_send"));
 
@@ -301,12 +325,23 @@ public:
     bool is_continuation =
       boost_asio_handler_cont_helpers::is_continuation(handler);
 
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_null_buffers_op<Handler, IoExecutor> op;
     typename op::ptr p = { boost::asio::detail::addressof(handler),
       op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(success_ec_, handler, io_ex);
 
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ =
+        &slot.template emplace<reactor_op_cancellation>(
+            &reactor_, &impl.reactor_data_, impl.socket_, reactor::write_op);
+    }
+
     BOOST_ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "socket",
           &impl, impl.socket_, "async_send(null_buffers)"));
 
@@ -358,6 +393,9 @@ public:
     bool is_continuation =
       boost_asio_handler_cont_helpers::is_continuation(handler);
 
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_socket_recv_op<
         MutableBufferSequence, Handler, IoExecutor> op;
@@ -366,6 +404,14 @@ public:
     p.p = new (p.v) op(success_ec_, impl.socket_,
         impl.state_, buffers, flags, handler, io_ex);
 
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ =
+        &slot.template emplace<reactor_op_cancellation>(
+            &reactor_, &impl.reactor_data_, impl.socket_, reactor::read_op);
+    }
+
     BOOST_ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "socket",
           &impl, impl.socket_, "async_receive"));
 
@@ -389,12 +435,23 @@ public:
     bool is_continuation =
       boost_asio_handler_cont_helpers::is_continuation(handler);
 
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_null_buffers_op<Handler, IoExecutor> op;
     typename op::ptr p = { boost::asio::detail::addressof(handler),
       op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(success_ec_, handler, io_ex);
 
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ =
+        &slot.template emplace<reactor_op_cancellation>(
+            &reactor_, &impl.reactor_data_, impl.socket_, reactor::read_op);
+    }
+
     BOOST_ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "socket",
           &impl, impl.socket_, "async_receive(null_buffers)"));
 
@@ -447,6 +504,9 @@ public:
     bool is_continuation =
       boost_asio_handler_cont_helpers::is_continuation(handler);
 
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_socket_recvmsg_op<
         MutableBufferSequence, Handler, IoExecutor> op;
@@ -455,6 +515,14 @@ public:
     p.p = new (p.v) op(success_ec_, impl.socket_,
         buffers, in_flags, out_flags, handler, io_ex);
 
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ =
+        &slot.template emplace<reactor_op_cancellation>(
+            &reactor_, &impl.reactor_data_, impl.socket_, reactor::read_op);
+    }
+
     BOOST_ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "socket",
           &impl, impl.socket_, "async_receive_with_flags"));
 
@@ -476,12 +544,23 @@ public:
     bool is_continuation =
       boost_asio_handler_cont_helpers::is_continuation(handler);
 
+    typename associated_cancellation_slot<Handler>::type slot
+      = boost::asio::get_associated_cancellation_slot(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_null_buffers_op<Handler, IoExecutor> op;
     typename op::ptr p = { boost::asio::detail::addressof(handler),
       op::ptr::allocate(handler), 0 };
     p.p = new (p.v) op(success_ec_, handler, io_ex);
 
+    // Optionally register for per-operation cancellation.
+    if (slot.is_connected())
+    {
+      p.p->cancellation_key_ =
+        &slot.template emplace<reactor_op_cancellation>(
+            &reactor_, &impl.reactor_data_, impl.socket_, reactor::read_op);
+    }
+
     BOOST_ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "socket",
           &impl, impl.socket_, "async_receive_with_flags(null_buffers)"));
 
@@ -520,6 +599,38 @@ protected:
       reactor_op* op, bool is_continuation,
       const socket_addr_type* addr, size_t addrlen);
 
+  // Helper class used to implement per-operation cancellation
+  class reactor_op_cancellation
+  {
+  public:
+    reactor_op_cancellation(reactor* r,
+        reactor::per_descriptor_data* p, int d, int o)
+      : reactor_(r),
+        reactor_data_(p),
+        descriptor_(d),
+        op_type_(o)
+    {
+    }
+
+    void operator()(cancellation_type_t type)
+    {
+      if (!!(type &
+            (cancellation_type::terminal
+              | cancellation_type::partial
+              | cancellation_type::total)))
+      {
+        reactor_->cancel_ops_by_key(descriptor_,
+            *reactor_data_, op_type_, this);
+      }
+    }
+
+  private:
+    reactor* reactor_;
+    reactor::per_descriptor_data* reactor_data_;
+    int descriptor_;
+    int op_type_;
+  };
+
   // The selector that performs event demultiplexing for the service.
   reactor& reactor_;
 

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

@@ -31,6 +31,9 @@ public:
   // The error code to be passed to the completion handler.
   boost::system::error_code ec_;
 
+  // The operation key used for targeted cancellation.
+  void* cancellation_key_;
+
   // The number of bytes transferred, to be passed to the completion handler.
   std::size_t bytes_transferred_;
 
@@ -51,6 +54,7 @@ protected:
       perform_func_type perform_func, func_type complete_func)
     : operation(complete_func),
       ec_(success_ec),
+      cancellation_key_(0),
       bytes_transferred_(0),
       perform_func_(perform_func)
   {

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

@@ -101,6 +101,50 @@ public:
     return this->cancel_operations(operations_.find(descriptor), ops, ec);
   }
 
+  // Cancel operations associated with the descriptor identified by the
+  // supplied iterator, and the specified cancellation key. Any operations
+  // pending for the descriptor with the key will be cancelled. Returns true if
+  // any operations were cancelled, in which case the reactor's event
+  // demultiplexing function may need to be interrupted and restarted.
+  bool cancel_operations_by_key(iterator i, op_queue<operation>& ops,
+      void* cancellation_key, const boost::system::error_code& ec =
+        boost::asio::error::operation_aborted)
+  {
+    bool result = false;
+    if (i != operations_.end())
+    {
+      op_queue<reactor_op> other_ops;
+      while (reactor_op* op = i->second.front())
+      {
+        i->second.pop();
+        if (op->cancellation_key_ == cancellation_key)
+        {
+          op->ec_ = ec;
+          ops.push(op);
+          result = true;
+        }
+        else
+          other_ops.push(op);
+      }
+      i->second.push(other_ops);
+      if (i->second.empty())
+        operations_.erase(i);
+    }
+    return result;
+  }
+
+  // Cancel all operations associated with the descriptor. Any operations
+  // pending for the descriptor will be cancelled. Returns true if any
+  // operations were cancelled, in which case the reactor's event
+  // demultiplexing function may need to be interrupted and restarted.
+  bool cancel_operations_by_key(Descriptor descriptor, op_queue<operation>& ops,
+      void* cancellation_key, const boost::system::error_code& ec =
+        boost::asio::error::operation_aborted)
+  {
+    return this->cancel_operations_by_key(
+        operations_.find(descriptor), ops, cancellation_key, ec);
+  }
+
   // Whether there are no operations in the queue.
   bool empty() const
   {

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

@@ -50,7 +50,8 @@ public:
   T* allocate(std::size_t n)
   {
     void* p = thread_info_base::allocate(Purpose(),
-        thread_context::top_of_thread_call_stack(), sizeof(T) * n);
+        thread_context::top_of_thread_call_stack(),
+        sizeof(T) * n, BOOST_ASIO_ALIGNOF(T));
     return static_cast<T*>(p);
   }
 

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

@@ -80,8 +80,8 @@ public:
       // the resolver operation.
     
       // Perform the blocking endpoint resolution operation.
-      char host_name[NI_MAXHOST];
-      char service_name[NI_MAXSERV];
+      char host_name[NI_MAXHOST] = "";
+      char service_name[NI_MAXSERV] = "";
       socket_ops::background_getnameinfo(o->cancel_token_, o->endpoint_.data(),
           o->endpoint_.size(), host_name, NI_MAXHOST, service_name, NI_MAXSERV,
           o->endpoint_.protocol().type(), o->ec_);

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

@@ -91,10 +91,7 @@ public:
       per_descriptor_data& descriptor_data, reactor_op* op);
 
   // Post a reactor operation for immediate completion.
-  void post_immediate_completion(reactor_op* op, bool is_continuation)
-  {
-    scheduler_.post_immediate_completion(op, is_continuation);
-  }
+  void post_immediate_completion(reactor_op* op, bool is_continuation);
 
   // Start a new operation. The reactor operation will be performed when the
   // given descriptor is flagged as ready, or an error has occurred.
@@ -106,6 +103,13 @@ public:
   // operation_aborted error.
   BOOST_ASIO_DECL void cancel_ops(socket_type descriptor, per_descriptor_data&);
 
+  // Cancel all operations associated with the given descriptor and key. The
+  // handlers associated with the descriptor will be invoked with the
+  // operation_aborted error.
+  BOOST_ASIO_DECL void cancel_ops_by_key(socket_type descriptor,
+      per_descriptor_data& descriptor_data,
+      int op_type, void* cancellation_key);
+
   // Cancel any operations that are running against the descriptor and remove
   // its registration from the reactor. The reactor resources associated with
   // the descriptor must be released by calling cleanup_descriptor_data.
@@ -149,6 +153,12 @@ public:
       typename timer_queue<Time_Traits>::per_timer_data& timer,
       std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)());
 
+  // Cancel the timer operations associated with the given key.
+  template <typename Time_Traits>
+  void cancel_timer_by_key(timer_queue<Time_Traits>& queue,
+      typename timer_queue<Time_Traits>::per_timer_data* timer,
+      void* cancellation_key);
+
   // Move the timer operations associated with the given timer.
   template <typename Time_Traits>
   void move_timer(timer_queue<Time_Traits>& queue,

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

@@ -18,6 +18,7 @@
 #include <boost/asio/detail/config.hpp>
 #include <climits>
 #include <cstddef>
+#include <boost/asio/detail/memory.hpp>
 #include <boost/asio/detail/noncopyable.hpp>
 
 #if defined(BOOST_ASIO_HAS_STD_EXCEPTION_PTR) \
@@ -33,25 +34,66 @@ namespace boost {
 namespace asio {
 namespace detail {
 
+#ifndef BOOST_ASIO_RECYCLING_ALLOCATOR_CACHE_SIZE
+# define BOOST_ASIO_RECYCLING_ALLOCATOR_CACHE_SIZE 2
+#endif // BOOST_ASIO_RECYCLING_ALLOCATOR_CACHE_SIZE
+
 class thread_info_base
   : private noncopyable
 {
 public:
   struct default_tag
   {
-    enum { mem_index = 0 };
+    enum
+    {
+      cache_size = BOOST_ASIO_RECYCLING_ALLOCATOR_CACHE_SIZE,
+      begin_mem_index = 0,
+      end_mem_index = cache_size
+    };
   };
 
   struct awaitable_frame_tag
   {
-    enum { mem_index = 1 };
+    enum
+    {
+      cache_size = BOOST_ASIO_RECYCLING_ALLOCATOR_CACHE_SIZE,
+      begin_mem_index = default_tag::end_mem_index,
+      end_mem_index = begin_mem_index + cache_size
+    };
   };
 
   struct executor_function_tag
   {
-    enum { mem_index = 2 };
+    enum
+    {
+      cache_size = BOOST_ASIO_RECYCLING_ALLOCATOR_CACHE_SIZE,
+      begin_mem_index = awaitable_frame_tag::end_mem_index,
+      end_mem_index = begin_mem_index + cache_size
+    };
+  };
+
+  struct cancellation_signal_tag
+  {
+    enum
+    {
+      cache_size = BOOST_ASIO_RECYCLING_ALLOCATOR_CACHE_SIZE,
+      begin_mem_index = executor_function_tag::end_mem_index,
+      end_mem_index = begin_mem_index + cache_size
+    };
+  };
+
+  struct parallel_group_tag
+  {
+    enum
+    {
+      cache_size = BOOST_ASIO_RECYCLING_ALLOCATOR_CACHE_SIZE,
+      begin_mem_index = cancellation_signal_tag::end_mem_index,
+      end_mem_index = begin_mem_index + cache_size
+    };
   };
 
+  enum { max_mem_index = parallel_group_tag::end_mem_index };
+
   thread_info_base()
 #if defined(BOOST_ASIO_HAS_STD_EXCEPTION_PTR) \
   && !defined(BOOST_ASIO_NO_EXCEPTIONS)
@@ -71,13 +113,14 @@ public:
       // it is significantly faster when using a tight io_context::poll() loop
       // in latency sensitive applications.
       if (reusable_memory_[i])
-        ::operator delete(reusable_memory_[i]);
+        aligned_delete(reusable_memory_[i]);
     }
   }
 
-  static void* allocate(thread_info_base* this_thread, std::size_t size)
+  static void* allocate(thread_info_base* this_thread,
+      std::size_t size, std::size_t align = BOOST_ASIO_DEFAULT_ALIGN)
   {
-    return allocate(default_tag(), this_thread, size);
+    return allocate(default_tag(), this_thread, size, align);
   }
 
   static void deallocate(thread_info_base* this_thread,
@@ -88,26 +131,43 @@ public:
 
   template <typename Purpose>
   static void* allocate(Purpose, thread_info_base* this_thread,
-      std::size_t size)
+      std::size_t size, std::size_t align = BOOST_ASIO_DEFAULT_ALIGN)
   {
     std::size_t chunks = (size + chunk_size - 1) / chunk_size;
 
-    if (this_thread && this_thread->reusable_memory_[Purpose::mem_index])
+    if (this_thread)
     {
-      void* const pointer = this_thread->reusable_memory_[Purpose::mem_index];
-      this_thread->reusable_memory_[Purpose::mem_index] = 0;
-
-      unsigned char* const mem = static_cast<unsigned char*>(pointer);
-      if (static_cast<std::size_t>(mem[0]) >= chunks)
+      for (int mem_index = Purpose::begin_mem_index;
+          mem_index < Purpose::end_mem_index; ++mem_index)
       {
-        mem[size] = mem[0];
-        return pointer;
+        if (this_thread->reusable_memory_[mem_index])
+        {
+          void* const pointer = this_thread->reusable_memory_[mem_index];
+          unsigned char* const mem = static_cast<unsigned char*>(pointer);
+          if (static_cast<std::size_t>(mem[0]) >= chunks
+              && reinterpret_cast<std::size_t>(pointer) % align == 0)
+          {
+            this_thread->reusable_memory_[mem_index] = 0;
+            mem[size] = mem[0];
+            return pointer;
+          }
+        }
       }
 
-      ::operator delete(pointer);
+      for (int mem_index = Purpose::begin_mem_index;
+          mem_index < Purpose::end_mem_index; ++mem_index)
+      {
+        if (this_thread->reusable_memory_[mem_index])
+        {
+          void* const pointer = this_thread->reusable_memory_[mem_index];
+          this_thread->reusable_memory_[mem_index] = 0;
+          aligned_delete(pointer);
+          break;
+        }
+      }
     }
 
-    void* const pointer = ::operator new(chunks * chunk_size + 1);
+    void* const pointer = aligned_new(align, chunks * chunk_size + 1);
     unsigned char* const mem = static_cast<unsigned char*>(pointer);
     mem[size] = (chunks <= UCHAR_MAX) ? static_cast<unsigned char>(chunks) : 0;
     return pointer;
@@ -119,16 +179,23 @@ public:
   {
     if (size <= chunk_size * UCHAR_MAX)
     {
-      if (this_thread && this_thread->reusable_memory_[Purpose::mem_index] == 0)
+      if (this_thread)
       {
-        unsigned char* const mem = static_cast<unsigned char*>(pointer);
-        mem[0] = mem[size];
-        this_thread->reusable_memory_[Purpose::mem_index] = pointer;
-        return;
+        for (int mem_index = Purpose::begin_mem_index;
+            mem_index < Purpose::end_mem_index; ++mem_index)
+        {
+          if (this_thread->reusable_memory_[mem_index] == 0)
+          {
+            unsigned char* const mem = static_cast<unsigned char*>(pointer);
+            mem[0] = mem[size];
+            this_thread->reusable_memory_[mem_index] = pointer;
+            return;
+          }
+        }
       }
     }
 
-    ::operator delete(pointer);
+    aligned_delete(pointer);
   }
 
   void capture_current_exception()
@@ -172,7 +239,6 @@ public:
 
 private:
   enum { chunk_size = 4 };
-  enum { max_mem_index = 3 };
   void* reusable_memory_[max_mem_index];
 
 #if defined(BOOST_ASIO_HAS_STD_EXCEPTION_PTR) \

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

@@ -151,7 +151,12 @@ public:
       while (!heap_.empty() && !Time_Traits::less_than(now, heap_[0].time_))
       {
         per_timer_data* timer = heap_[0].timer_;
-        ops.push(timer->op_queue_);
+        while (wait_op* op = timer->op_queue_.front())
+        {
+          timer->op_queue_.pop();
+          op->ec_ = boost::system::error_code();
+          ops.push(op);
+        }
         remove_timer(*timer);
       }
     }
@@ -193,6 +198,30 @@ public:
     return num_cancelled;
   }
 
+  // Cancel and dequeue a specific operation for the given timer.
+  void cancel_timer_by_key(per_timer_data* timer,
+      op_queue<operation>& ops, void* cancellation_key)
+  {
+    if (timer->prev_ != 0 || timer == timers_)
+    {
+      op_queue<wait_op> other_ops;
+      while (wait_op* op = timer->op_queue_.front())
+      {
+        timer->op_queue_.pop();
+        if (op->cancellation_key_ == cancellation_key)
+        {
+          op->ec_ = boost::asio::error::operation_aborted;
+          ops.push(op);
+        }
+        else
+          other_ops.push(op);
+      }
+      timer->op_queue_.push(other_ops);
+      if (timer->op_queue_.empty())
+        remove_timer(*timer);
+    }
+  }
+
   // Move operations from one timer to another, empty timer.
   void move_timer(per_timer_data& target, per_timer_data& source)
   {

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

@@ -78,6 +78,10 @@ public:
       per_timer_data& timer, op_queue<operation>& ops,
       std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)());
 
+  // Cancel and dequeue operations for the given timer and key.
+  BOOST_ASIO_DECL void cancel_timer_by_key(per_timer_data* timer,
+      op_queue<operation>& ops, void* cancellation_key);
+
   // Move operations from one timer to another, empty timer.
   BOOST_ASIO_DECL void move_timer(per_timer_data& target,
       per_timer_data& source);

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

@@ -31,9 +31,13 @@ public:
   // The error code to be passed to the completion handler.
   boost::system::error_code ec_;
 
+  // The operation key used for targeted cancellation.
+  void* cancellation_key_;
+
 protected:
   wait_op(func_type func)
-    : operation(func)
+    : operation(func),
+      cancellation_key_(0)
   {
   }
 };

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

@@ -16,6 +16,7 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
+#include <boost/asio/detail/bind_handler.hpp>
 #include <boost/asio/detail/type_traits.hpp>
 #include <boost/asio/associated_executor.hpp>
 #include <boost/asio/associated_allocator.hpp>
@@ -82,7 +83,8 @@ public:
         boost::asio::prefer(executor_,
           execution::blocking.possibly,
           execution::allocator((get_associated_allocator)(handler_))),
-        BOOST_ASIO_MOVE_CAST(Handler)(handler_));
+        boost::asio::detail::bind_handler(
+          BOOST_ASIO_MOVE_CAST(Handler)(handler_)));
   }
 
 private:
@@ -130,7 +132,8 @@ public:
     typename associated_allocator<Handler>::type alloc(
         (get_associated_allocator)(handler_));
     work_.get_executor().dispatch(
-        BOOST_ASIO_MOVE_CAST(Handler)(handler_), alloc);
+        boost::asio::detail::bind_handler(
+          BOOST_ASIO_MOVE_CAST(Handler)(handler_)), alloc);
     work_.reset();
   }