passenger 6.0.23 → 6.0.24

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

@@ -70,25 +70,24 @@ int close(int d, state_type& state, boost::system::error_code& ec)
         ::fcntl(d, F_SETFL, flags & ~O_NONBLOCK);
 #else // defined(__SYMBIAN32__) || defined(__EMSCRIPTEN__)
       ioctl_arg_type arg = 0;
-# if defined(ENOTTY) || defined(ENOTCAPABLE)
-      result = ::ioctl(d, FIONBIO, &arg);
-      get_last_error(ec, result < 0);
-      if (false
-#  if defined(ENOTTY)
+      if ((state & possible_dup) == 0)
+      {
+        result = ::ioctl(d, FIONBIO, &arg);
+        get_last_error(ec, result < 0);
+      }
+      if ((state & possible_dup) != 0
+# if defined(ENOTTY)
           || ec.value() == ENOTTY
-#  endif // defined(ENOTTY)
-#  if defined(ENOTCAPABLE)
+# endif // defined(ENOTTY)
+# if defined(ENOTCAPABLE)
           || ec.value() == ENOTCAPABLE
-#  endif // defined(ENOTCAPABLE)
+# endif // defined(ENOTCAPABLE)
         )
       {
         int flags = ::fcntl(d, F_GETFL, 0);
         if (flags >= 0)
           ::fcntl(d, F_SETFL, flags & ~O_NONBLOCK);
       }
-# else // defined(ENOTTY) || defined(ENOTCAPABLE)
-      ::ioctl(d, FIONBIO, &arg);
-# endif // defined(ENOTTY) || defined(ENOTCAPABLE)
 #endif // defined(__SYMBIAN32__) || defined(__EMSCRIPTEN__)
       state &= ~non_blocking;
 
@@ -115,21 +114,24 @@ bool set_user_non_blocking(int d, state_type& state,
   if (result >= 0)
   {
     int flag = (value ? (result | O_NONBLOCK) : (result & ~O_NONBLOCK));
-    result = ::fcntl(d, F_SETFL, flag);
+    result = (flag != result) ? ::fcntl(d, F_SETFL, flag) : 0;
     get_last_error(ec, result < 0);
   }
 #else // defined(__SYMBIAN32__) || defined(__EMSCRIPTEN__)
   ioctl_arg_type arg = (value ? 1 : 0);
-  int result = ::ioctl(d, FIONBIO, &arg);
-  get_last_error(ec, result < 0);
-# if defined(ENOTTY) || defined(ENOTCAPABLE)
-  if (false
-#  if defined(ENOTTY)
+  int result = 0;
+  if ((state & possible_dup) == 0)
+  {
+    result = ::ioctl(d, FIONBIO, &arg);
+    get_last_error(ec, result < 0);
+  }
+  if ((state & possible_dup) != 0
+# if defined(ENOTTY)
       || ec.value() == ENOTTY
-#  endif // defined(ENOTTY)
-#  if defined(ENOTCAPABLE)
+# endif // defined(ENOTTY)
+# if defined(ENOTCAPABLE)
       || ec.value() == ENOTCAPABLE
-#  endif // defined(ENOTCAPABLE)
+# endif // defined(ENOTCAPABLE)
     )
   {
     result = ::fcntl(d, F_GETFL, 0);
@@ -137,11 +139,10 @@ bool set_user_non_blocking(int d, state_type& state,
     if (result >= 0)
     {
       int flag = (value ? (result | O_NONBLOCK) : (result & ~O_NONBLOCK));
-      result = ::fcntl(d, F_SETFL, flag);
+      result = (flag != result) ? ::fcntl(d, F_SETFL, flag) : 0;
       get_last_error(ec, result < 0);
     }
   }
-# endif // defined(ENOTTY) || defined(ENOTCAPABLE)
 #endif // defined(__SYMBIAN32__) || defined(__EMSCRIPTEN__)
 
   if (result >= 0)
@@ -185,21 +186,24 @@ bool set_internal_non_blocking(int d, state_type& state,
   if (result >= 0)
   {
     int flag = (value ? (result | O_NONBLOCK) : (result & ~O_NONBLOCK));
-    result = ::fcntl(d, F_SETFL, flag);
+    result = (flag != result) ? ::fcntl(d, F_SETFL, flag) : 0;
     get_last_error(ec, result < 0);
   }
 #else // defined(__SYMBIAN32__) || defined(__EMSCRIPTEN__)
   ioctl_arg_type arg = (value ? 1 : 0);
-  int result = ::ioctl(d, FIONBIO, &arg);
-  get_last_error(ec, result < 0);
-# if defined(ENOTTY) || defined(ENOTCAPABLE)
-  if (false
-#  if defined(ENOTTY)
+  int result = 0;
+  if ((state & possible_dup) == 0)
+  {
+    result = ::ioctl(d, FIONBIO, &arg);
+    get_last_error(ec, result < 0);
+  }
+  if ((state & possible_dup) != 0
+# if defined(ENOTTY)
       || ec.value() == ENOTTY
-#  endif // defined(ENOTTY)
-#  if defined(ENOTCAPABLE)
+# endif // defined(ENOTTY)
+# if defined(ENOTCAPABLE)
       || ec.value() == ENOTCAPABLE
-#  endif // defined(ENOTCAPABLE)
+# endif // defined(ENOTCAPABLE)
     )
   {
     result = ::fcntl(d, F_GETFL, 0);
@@ -207,11 +211,10 @@ bool set_internal_non_blocking(int d, state_type& state,
     if (result >= 0)
     {
       int flag = (value ? (result | O_NONBLOCK) : (result & ~O_NONBLOCK));
-      result = ::fcntl(d, F_SETFL, flag);
+      result = (flag != result) ? ::fcntl(d, F_SETFL, flag) : 0;
       get_last_error(ec, result < 0);
     }
   }
-# endif // defined(ENOTTY) || defined(ENOTCAPABLE)
 #endif // defined(__SYMBIAN32__) || defined(__EMSCRIPTEN__)
 
   if (result >= 0)

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

@@ -67,7 +67,7 @@ void dev_poll_reactor::shutdown()
   timer_queues_.get_all_timers(ops);
 
   scheduler_.abandon_operations(ops);
-} 
+}
 
 void dev_poll_reactor::notify_fork(
     boost::asio::execution_context::fork_event fork_ev)

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

@@ -199,18 +199,20 @@ boost::system::error_code reactive_descriptor_service::cancel(
 }
 
 void reactive_descriptor_service::do_start_op(implementation_type& impl,
-    int op_type, reactor_op* op, bool is_continuation, bool is_non_blocking,
-    bool noop, void (*on_immediate)(operation* op, bool, const void*),
+    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)
 {
   if (!noop)
   {
-    if ((impl.state_ & descriptor_ops::non_blocking) ||
-        descriptor_ops::set_internal_non_blocking(
+    if ((impl.state_ & descriptor_ops::non_blocking)
+        || !needs_non_blocking
+        || descriptor_ops::set_internal_non_blocking(
           impl.descriptor_, impl.state_, true, op->ec_))
     {
       reactor_.start_op(op_type, impl.descriptor_, impl.reactor_data_, op,
-          is_continuation, is_non_blocking, on_immediate, immediate_arg);
+          is_continuation, allow_speculative, on_immediate, immediate_arg);
       return;
     }
   }

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

@@ -235,19 +235,21 @@ boost::system::error_code reactive_socket_service_base::do_assign(
 }
 
 void reactive_socket_service_base::do_start_op(
-    reactive_socket_service_base::base_implementation_type& impl, int op_type,
-    reactor_op* op, bool is_continuation, bool is_non_blocking, bool noop,
+    reactive_socket_service_base::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)
 {
   if (!noop)
   {
     if ((impl.state_ & socket_ops::non_blocking)
+        || !needs_non_blocking
         || socket_ops::set_internal_non_blocking(
           impl.socket_, impl.state_, true, op->ec_))
     {
       reactor_.start_op(op_type, impl.socket_, impl.reactor_data_, op,
-          is_continuation, is_non_blocking, on_immediate, immediate_arg);
+          is_continuation, allow_speculative, on_immediate, immediate_arg);
       return;
     }
   }
@@ -264,7 +266,7 @@ void reactive_socket_service_base::do_start_accept_op(
   if (!peer_is_open)
   {
     do_start_op(impl, reactor::read_op, op, is_continuation,
-        true, false, on_immediate, immediate_arg);
+        true, false, true, on_immediate, immediate_arg);
   }
   else
   {

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

@@ -41,6 +41,10 @@
 #endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
        // || defined(__MACH__) && defined(__APPLE__)
 
+#if defined(_MSC_VER) && (_MSC_VER >= 1800)
+# include <malloc.h>
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1800)
+
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
@@ -340,25 +344,24 @@ int close(socket_type s, state_type& state,
         ::fcntl(s, F_SETFL, flags & ~O_NONBLOCK);
 # else // defined(__SYMBIAN32__) || defined(__EMSCRIPTEN__)
       ioctl_arg_type arg = 0;
-#  if defined(ENOTTY) || defined(ENOTCAPABLE)
-      result = ::ioctl(s, FIONBIO, &arg);
-      get_last_error(ec, result < 0);
-      if (false
-#   if defined(ENOTTY)
+      if ((state & possible_dup) == 0)
+      {
+        result = ::ioctl(s, FIONBIO, &arg);
+        get_last_error(ec, result < 0);
+      }
+      if ((state & possible_dup) != 0
+#  if defined(ENOTTY)
           || ec.value() == ENOTTY
-#   endif // defined(ENOTTY)
-#   if defined(ENOTCAPABLE)
+#  endif // defined(ENOTTY)
+#  if defined(ENOTCAPABLE)
           || ec.value() == ENOTCAPABLE
-#   endif // defined(ENOTCAPABLE)
+#  endif // defined(ENOTCAPABLE)
         )
       {
         int flags = ::fcntl(s, F_GETFL, 0);
         if (flags >= 0)
           ::fcntl(s, F_SETFL, flags & ~O_NONBLOCK);
       }
-#  else // defined(ENOTTY) || defined(ENOTCAPABLE)
-      ::ioctl(s, FIONBIO, &arg);
-#  endif // defined(ENOTTY) || defined(ENOTCAPABLE)
 # endif // defined(__SYMBIAN32__) || defined(__EMSCRIPTEN__)
 #endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
       state &= ~non_blocking;
@@ -394,21 +397,24 @@ bool set_user_non_blocking(socket_type s,
   if (result >= 0)
   {
     int flag = (value ? (result | O_NONBLOCK) : (result & ~O_NONBLOCK));
-    result = ::fcntl(s, F_SETFL, flag);
+    result = (flag != result) ? ::fcntl(s, F_SETFL, flag) : 0;
     get_last_error(ec, result < 0);
   }
 #else // defined(__SYMBIAN32__) || defined(__EMSCRIPTEN__)
   ioctl_arg_type arg = (value ? 1 : 0);
-  int result = ::ioctl(s, FIONBIO, &arg);
-  get_last_error(ec, result < 0);
-# if defined(ENOTTY) || defined(ENOTCAPABLE)
-  if (false
-#  if defined(ENOTTY)
+  int result = 0;
+  if ((state & possible_dup) == 0)
+  {
+    result = ::ioctl(s, FIONBIO, &arg);
+    get_last_error(ec, result < 0);
+  }
+  if ((state & possible_dup) != 0
+# if defined(ENOTTY)
       || ec.value() == ENOTTY
-#  endif // defined(ENOTTY)
-#  if defined(ENOTCAPABLE)
+# endif // defined(ENOTTY)
+# if defined(ENOTCAPABLE)
       || ec.value() == ENOTCAPABLE
-#  endif // defined(ENOTCAPABLE)
+# endif // defined(ENOTCAPABLE)
     )
   {
     result = ::fcntl(s, F_GETFL, 0);
@@ -416,11 +422,10 @@ bool set_user_non_blocking(socket_type s,
     if (result >= 0)
     {
       int flag = (value ? (result | O_NONBLOCK) : (result & ~O_NONBLOCK));
-      result = ::fcntl(s, F_SETFL, flag);
+      result = (flag != result) ? ::fcntl(s, F_SETFL, flag) : 0;
       get_last_error(ec, result < 0);
     }
   }
-# endif // defined(ENOTTY) || defined(ENOTCAPABLE)
 #endif // defined(__SYMBIAN32__) || defined(__EMSCRIPTEN__)
 
   if (result >= 0)
@@ -468,21 +473,24 @@ bool set_internal_non_blocking(socket_type s,
   if (result >= 0)
   {
     int flag = (value ? (result | O_NONBLOCK) : (result & ~O_NONBLOCK));
-    result = ::fcntl(s, F_SETFL, flag);
+    result = (flag != result) ? ::fcntl(s, F_SETFL, flag) : 0;
     get_last_error(ec, result < 0);
   }
 #else // defined(__SYMBIAN32__) || defined(__EMSCRIPTEN__)
   ioctl_arg_type arg = (value ? 1 : 0);
-  int result = ::ioctl(s, FIONBIO, &arg);
-  get_last_error(ec, result < 0);
-# if defined(ENOTTY) || defined(ENOTCAPABLE)
-  if (false
-#  if defined(ENOTTY)
+  int result = 0;
+  if ((state & possible_dup) == 0)
+  {
+    result = ::ioctl(s, FIONBIO, &arg);
+    get_last_error(ec, result < 0);
+  }
+  if ((state & possible_dup) != 0
+# if defined(ENOTTY)
       || ec.value() == ENOTTY
-#  endif // defined(ENOTTY)
-#  if defined(ENOTCAPABLE)
+# endif // defined(ENOTTY)
+# if defined(ENOTCAPABLE)
       || ec.value() == ENOTCAPABLE
-#  endif // defined(ENOTCAPABLE)
+# endif // defined(ENOTCAPABLE)
     )
   {
     result = ::fcntl(s, F_GETFL, 0);
@@ -490,11 +498,10 @@ bool set_internal_non_blocking(socket_type s,
     if (result >= 0)
     {
       int flag = (value ? (result | O_NONBLOCK) : (result & ~O_NONBLOCK));
-      result = ::fcntl(s, F_SETFL, flag);
+      result = (flag != result) ? ::fcntl(s, F_SETFL, flag) : 0;
       get_last_error(ec, result < 0);
     }
   }
-# endif // defined(ENOTTY) || defined(ENOTCAPABLE)
 #endif // defined(__SYMBIAN32__) || defined(__EMSCRIPTEN__)
 
   if (result >= 0)
@@ -2580,9 +2587,11 @@ const char* inet_ntop(int af, const void* src, char* dest, size_t length,
         || if_indextoname(static_cast<unsigned>(scope_id), if_name + 1) == 0)
 #if defined(BOOST_ASIO_HAS_SNPRINTF)
       snprintf(if_name + 1, sizeof(if_name) - 1, "%lu", scope_id);
-#else // defined(BOOST_ASIO_HAS_SNPRINTF)
+#elif defined(BOOST_ASIO_HAS_SECURE_RTL)
+      sprintf_s(if_name + 1, sizeof(if_name) -1, "%lu", scope_id);
+#else // defined(BOOST_ASIO_HAS_SECURE_RTL)
       sprintf(if_name + 1, "%lu", scope_id);
-#endif // defined(BOOST_ASIO_HAS_SNPRINTF)
+#endif // defined(BOOST_ASIO_HAS_SECURE_RTL)
     strcat(dest, if_name);
   }
   return result;

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

@@ -91,7 +91,7 @@ void socket_select_interrupter::open_descriptors()
   socket_holder server(socket_ops::accept(acceptor.get(), 0, 0, ec));
   if (server.get() == invalid_socket)
     boost::asio::detail::throw_error(ec, "socket_select_interrupter");
-  
+
   ioctl_arg_type non_blocking = 1;
   socket_ops::state_type client_state = 0;
   if (socket_ops::ioctl(client.get(), client_state,

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

@@ -0,0 +1,64 @@
+//
+// detail/initiation_base.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_INITIATION_BASE_HPP
+#define BOOST_ASIO_DETAIL_INITIATION_BASE_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/detail/type_traits.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename Initiation, typename = void>
+class initiation_base : public Initiation
+{
+public:
+  template <typename I>
+  explicit initiation_base(I&& initiation)
+    : Initiation(static_cast<I&&>(initiation))
+  {
+  }
+};
+
+template <typename Initiation>
+class initiation_base<Initiation, enable_if_t<!is_class<Initiation>::value>>
+{
+public:
+  template <typename I>
+  explicit initiation_base(I&& initiation)
+    : initiation_(static_cast<I&&>(initiation))
+  {
+  }
+
+  template <typename... Args>
+  void operator()(Args&&... args) const
+  {
+    initiation_(static_cast<Args&&>(args)...);
+  }
+
+private:
+  Initiation initiation_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_INITIATION_BASE_HPP

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

@@ -55,18 +55,7 @@ inline const volatile T* to_address(const volatile T* p) { return p; }
 inline void* align(std::size_t alignment,
     std::size_t size, void*& ptr, std::size_t& space)
 {
-#if defined(BOOST_ASIO_HAS_STD_ALIGN)
   return std::align(alignment, size, ptr, space);
-#else // defined(BOOST_ASIO_HAS_STD_ALIGN)
-	const uintptr_t intptr = reinterpret_cast<uintptr_t>(ptr);
-	const uintptr_t aligned = (intptr - 1u + alignment) & -alignment;
-	const std::size_t padding = aligned - intptr;
-	if (size + padding > space)
-    return 0;
-	space -= padding;
-	ptr = reinterpret_cast<void*>(aligned);
-  return ptr;
-#endif // defined(BOOST_ASIO_HAS_STD_ALIGN)
 }
 
 } // namespace detail

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

@@ -240,7 +240,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;
     }
@@ -253,7 +253,8 @@ public:
             &reactor_, &impl.reactor_data_, impl.descriptor_, 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;
   }
 
@@ -327,7 +328,7 @@ public:
 
     start_op(impl, reactor::write_op, p.p, is_continuation, true,
         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;
   }
 
@@ -361,7 +362,7 @@ public:
           &impl, impl.descriptor_, "async_write_some(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;
   }
 
@@ -436,7 +437,7 @@ public:
 
     start_op(impl, reactor::read_op, p.p, is_continuation, true,
         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;
   }
 
@@ -470,14 +471,15 @@ public:
           &impl, impl.descriptor_, "async_read_some(null_buffers)"));
 
     start_op(impl, reactor::read_op, p.p,
-        is_continuation, false, false, &io_ex, 0);
+        is_continuation, false, false, false, &io_ex, 0);
     p.v = p.p = 0;
   }
 
 private:
   // Start the asynchronous operation.
-  BOOST_ASIO_DECL void do_start_op(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(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);
 
@@ -485,18 +487,19 @@ private:
   // immediate completion.
   template <typename Op>
   void start_op(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(implementation_type& impl, int op_type, Op* op,
-      bool is_continuation, bool is_non_blocking, bool noop, const void*,
+  void start_op(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<
@@ -507,8 +510,9 @@ private:
         >::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_);
   }
 
   // Helper class used to implement per-operation cancellation

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

@@ -188,7 +188,6 @@ public:
     BOOST_ASIO_HANDLER_INVOCATION_END;
   }
 
-
 private:
   Handler handler_;
   handler_work<Handler, IoExecutor> work_;

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

@@ -308,7 +308,7 @@ public:
           &impl, impl.socket_, "async_send_to"));
 
     start_op(impl, reactor::write_op, p.p,
-        is_continuation, true, false, &io_ex, 0);
+        is_continuation, true, false, true, &io_ex, 0);
     p.v = p.p = 0;
   }
 
@@ -342,7 +342,7 @@ public:
           &impl, impl.socket_, "async_send_to(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;
   }
 
@@ -433,7 +433,7 @@ public:
     start_op(impl,
         (flags & socket_base::message_out_of_band)
           ? reactor::except_op : reactor::read_op,
-        p.p, is_continuation, true, false, &io_ex, 0);
+        p.p, is_continuation, true, false, true, &io_ex, 0);
     p.v = p.p = 0;
   }
 
@@ -472,7 +472,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;
   }