passenger 5.3.3 → 5.3.4

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

@@ -0,0 +1,136 @@
+//
+// detail/resolve_query_op.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2018 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_RESOLVE_QUERY_OP_HPP
+#define BOOST_ASIO_DETAIL_RESOLVE_QUERY_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/error.hpp>
+#include <boost/asio/io_context.hpp>
+#include <boost/asio/ip/basic_resolver_query.hpp>
+#include <boost/asio/ip/basic_resolver_results.hpp>
+#include <boost/asio/detail/bind_handler.hpp>
+#include <boost/asio/detail/fenced_block.hpp>
+#include <boost/asio/detail/handler_alloc_helpers.hpp>
+#include <boost/asio/detail/handler_invoke_helpers.hpp>
+#include <boost/asio/detail/memory.hpp>
+#include <boost/asio/detail/resolve_op.hpp>
+#include <boost/asio/detail/socket_ops.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename Protocol, typename Handler>
+class resolve_query_op : public resolve_op
+{
+public:
+  BOOST_ASIO_DEFINE_HANDLER_PTR(resolve_query_op);
+
+  typedef boost::asio::ip::basic_resolver_query<Protocol> query_type;
+  typedef boost::asio::ip::basic_resolver_results<Protocol> results_type;
+
+  resolve_query_op(socket_ops::weak_cancel_token_type cancel_token,
+      const query_type& query, io_context_impl& ioc, Handler& handler)
+    : resolve_op(&resolve_query_op::do_complete),
+      cancel_token_(cancel_token),
+      query_(query),
+      io_context_impl_(ioc),
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)),
+      addrinfo_(0)
+  {
+    handler_work<Handler>::start(handler_);
+  }
+
+  ~resolve_query_op()
+  {
+    if (addrinfo_)
+      socket_ops::freeaddrinfo(addrinfo_);
+  }
+
+  static void do_complete(void* owner, operation* base,
+      const boost::system::error_code& /*ec*/,
+      std::size_t /*bytes_transferred*/)
+  {
+    // Take ownership of the operation object.
+    resolve_query_op* o(static_cast<resolve_query_op*>(base));
+    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
+
+    if (owner && owner != &o->io_context_impl_)
+    {
+      // 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(),
+          o->query_.hints(), &o->addrinfo_, o->ec_);
+
+      // Pass operation back to main io_context for completion.
+      o->io_context_impl_.post_deferred_completion(o);
+      p.v = p.p = 0;
+    }
+    else
+    {
+      // The operation has been returned to the main io_context. The completion
+      // handler is ready to be delivered.
+
+      // Take ownership of the operation's outstanding work.
+      handler_work<Handler> w(o->handler_);
+
+      BOOST_ASIO_HANDLER_COMPLETION((*o));
+
+      // Make a copy of the handler so that the memory can be deallocated
+      // before the upcall is made. Even if we're not about to make an upcall,
+      // a sub-object of the handler may be the true owner of the memory
+      // associated with the handler. Consequently, a local copy of the handler
+      // is required to ensure that any owning sub-object remains valid until
+      // after we have deallocated the memory here.
+      detail::binder2<Handler, boost::system::error_code, results_type>
+        handler(o->handler_, o->ec_, results_type());
+      p.h = boost::asio::detail::addressof(handler.handler_);
+      if (o->addrinfo_)
+      {
+        handler.arg2_ = results_type::create(o->addrinfo_,
+            o->query_.host_name(), o->query_.service_name());
+      }
+      p.reset();
+
+      if (owner)
+      {
+        fenced_block b(fenced_block::half);
+        BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, "..."));
+        w.complete(handler, handler.handler_);
+        BOOST_ASIO_HANDLER_INVOCATION_END;
+      }
+    }
+  }
+
+private:
+  socket_ops::weak_cancel_token_type cancel_token_;
+  query_type query_;
+  io_context_impl& io_context_impl_;
+  Handler handler_;
+  boost::asio::detail::addrinfo_type* addrinfo_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_RESOLVE_QUERY_OP_HPP

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

@@ -2,7 +2,7 @@
 // detail/resolver_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2017 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 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)
@@ -19,11 +19,12 @@
 
 #if !defined(BOOST_ASIO_WINDOWS_RUNTIME)
 
-#include <boost/asio/ip/basic_resolver_iterator.hpp>
 #include <boost/asio/ip/basic_resolver_query.hpp>
-#include <boost/asio/detail/addressof.hpp>
+#include <boost/asio/ip/basic_resolver_results.hpp>
+#include <boost/asio/detail/concurrency_hint.hpp>
+#include <boost/asio/detail/memory.hpp>
 #include <boost/asio/detail/resolve_endpoint_op.hpp>
-#include <boost/asio/detail/resolve_op.hpp>
+#include <boost/asio/detail/resolve_query_op.hpp>
 #include <boost/asio/detail/resolver_service_base.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
@@ -33,7 +34,9 @@ namespace asio {
 namespace detail {
 
 template <typename Protocol>
-class resolver_service : public resolver_service_base
+class resolver_service :
+  public service_base<resolver_service<Protocol> >,
+  public resolver_service_base
 {
 public:
   // The implementation type of the resolver. A cancellation token is used to
@@ -46,17 +49,30 @@ public:
   // The query type.
   typedef boost::asio::ip::basic_resolver_query<Protocol> query_type;
 
-  // The iterator type.
-  typedef boost::asio::ip::basic_resolver_iterator<Protocol> iterator_type;
+  // The results type.
+  typedef boost::asio::ip::basic_resolver_results<Protocol> results_type;
 
   // Constructor.
-  resolver_service(boost::asio::io_service& io_service)
-    : resolver_service_base(io_service)
+  resolver_service(boost::asio::io_context& io_context)
+    : service_base<resolver_service<Protocol> >(io_context),
+      resolver_service_base(io_context)
   {
   }
 
+  // Destroy all user-defined handler objects owned by the service.
+  void shutdown()
+  {
+    this->base_shutdown();
+  }
+
+  // Perform any fork-related housekeeping.
+  void notify_fork(boost::asio::io_context::fork_event fork_ev)
+  {
+    this->base_notify_fork(fork_ev);
+  }
+
   // Resolve a query to a list of entries.
-  iterator_type resolve(implementation_type&, const query_type& query,
+  results_type resolve(implementation_type&, const query_type& query,
       boost::system::error_code& ec)
   {
     boost::asio::detail::addrinfo_type* address_info = 0;
@@ -65,7 +81,7 @@ public:
         query.service_name().c_str(), query.hints(), &address_info, ec);
     auto_addrinfo auto_address_info(address_info);
 
-    return ec ? iterator_type() : iterator_type::create(
+    return ec ? results_type() : results_type::create(
         address_info, query.host_name(), query.service_name());
   }
 
@@ -75,20 +91,20 @@ public:
       const query_type& query, Handler& handler)
   {
     // Allocate and construct an operation to wrap the handler.
-    typedef resolve_op<Protocol, Handler> op;
+    typedef resolve_query_op<Protocol, Handler> op;
     typename op::ptr p = { boost::asio::detail::addressof(handler),
-      boost_asio_handler_alloc_helpers::allocate(
-        sizeof(op), handler), 0 };
-    p.p = new (p.v) op(impl, query, io_service_impl_, handler);
+      op::ptr::allocate(handler), 0 };
+    p.p = new (p.v) op(impl, query, io_context_impl_, handler);
 
-    BOOST_ASIO_HANDLER_CREATION((p.p, "resolver", &impl, "async_resolve"));
+    BOOST_ASIO_HANDLER_CREATION((io_context_impl_.context(),
+          *p.p, "resolver", &impl, 0, "async_resolve"));
 
     start_resolve_op(p.p);
     p.v = p.p = 0;
   }
 
   // Resolve an endpoint to a list of entries.
-  iterator_type resolve(implementation_type&,
+  results_type resolve(implementation_type&,
       const endpoint_type& endpoint, boost::system::error_code& ec)
   {
     char host_name[NI_MAXHOST];
@@ -97,7 +113,7 @@ public:
         host_name, NI_MAXHOST, service_name, NI_MAXSERV,
         endpoint.protocol().type(), ec);
 
-    return ec ? iterator_type() : iterator_type::create(
+    return ec ? results_type() : results_type::create(
         endpoint, host_name, service_name);
   }
 
@@ -109,11 +125,11 @@ public:
     // Allocate and construct an operation to wrap the handler.
     typedef resolve_endpoint_op<Protocol, Handler> op;
     typename op::ptr p = { boost::asio::detail::addressof(handler),
-      boost_asio_handler_alloc_helpers::allocate(
-        sizeof(op), handler), 0 };
-    p.p = new (p.v) op(impl, endpoint, io_service_impl_, handler);
+      op::ptr::allocate(handler), 0 };
+    p.p = new (p.v) op(impl, endpoint, io_context_impl_, handler);
 
-    BOOST_ASIO_HANDLER_CREATION((p.p, "resolver", &impl, "async_resolve"));
+    BOOST_ASIO_HANDLER_CREATION((io_context_impl_.context(),
+          *p.p, "resolver", &impl, 0, "async_resolve"));
 
     start_resolve_op(p.p);
     p.v = p.p = 0;

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

@@ -2,7 +2,7 @@
 // detail/resolver_service_base.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2017 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 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)
@@ -17,10 +17,11 @@
 
 #include <boost/asio/detail/config.hpp>
 #include <boost/asio/error.hpp>
-#include <boost/asio/io_service.hpp>
+#include <boost/asio/executor_work_guard.hpp>
+#include <boost/asio/io_context.hpp>
 #include <boost/asio/detail/mutex.hpp>
 #include <boost/asio/detail/noncopyable.hpp>
-#include <boost/asio/detail/operation.hpp>
+#include <boost/asio/detail/resolve_op.hpp>
 #include <boost/asio/detail/socket_ops.hpp>
 #include <boost/asio/detail/socket_types.hpp>
 #include <boost/asio/detail/scoped_ptr.hpp>
@@ -40,17 +41,17 @@ public:
   typedef socket_ops::shared_cancel_token_type implementation_type;
 
   // Constructor.
-  BOOST_ASIO_DECL resolver_service_base(boost::asio::io_service& io_service);
+  BOOST_ASIO_DECL resolver_service_base(boost::asio::io_context& io_context);
 
   // Destructor.
   BOOST_ASIO_DECL ~resolver_service_base();
 
   // Destroy all user-defined handler objects owned by the service.
-  BOOST_ASIO_DECL void shutdown_service();
+  BOOST_ASIO_DECL void base_shutdown();
 
   // Perform any fork-related housekeeping.
-  BOOST_ASIO_DECL void fork_service(
-      boost::asio::io_service::fork_event fork_ev);
+  BOOST_ASIO_DECL void base_notify_fork(
+      boost::asio::io_context::fork_event fork_ev);
 
   // Construct a new resolver implementation.
   BOOST_ASIO_DECL void construct(implementation_type& impl);
@@ -58,12 +59,21 @@ public:
   // Destroy a resolver implementation.
   BOOST_ASIO_DECL void destroy(implementation_type&);
 
+  // Move-construct a new resolver implementation.
+  BOOST_ASIO_DECL void move_construct(implementation_type& impl,
+      implementation_type& other_impl);
+
+  // Move-assign from another resolver implementation.
+  BOOST_ASIO_DECL void move_assign(implementation_type& impl,
+      resolver_service_base& other_service,
+      implementation_type& other_impl);
+
   // Cancel pending asynchronous operations.
   BOOST_ASIO_DECL void cancel(implementation_type& impl);
 
 protected:
   // Helper function to start an asynchronous resolve operation.
-  BOOST_ASIO_DECL void start_resolve_op(operation* op);
+  BOOST_ASIO_DECL void start_resolve_op(resolve_op* op);
 
 #if !defined(BOOST_ASIO_WINDOWS_RUNTIME)
   // Helper class to perform exception-safe cleanup of addrinfo objects.
@@ -92,29 +102,30 @@ protected:
   };
 #endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME)
 
-  // Helper class to run the work io_service in a thread.
-  class work_io_service_runner;
+  // Helper class to run the work io_context in a thread.
+  class work_io_context_runner;
 
   // Start the work thread if it's not already running.
   BOOST_ASIO_DECL void start_work_thread();
 
-  // The io_service implementation used to post completions.
-  io_service_impl& io_service_impl_;
+  // The io_context implementation used to post completions.
+  io_context_impl& io_context_impl_;
 
 private:
   // Mutex to protect access to internal data.
   boost::asio::detail::mutex mutex_;
 
-  // Private io_service used for performing asynchronous host resolution.
-  boost::asio::detail::scoped_ptr<boost::asio::io_service> work_io_service_;
+  // Private io_context used for performing asynchronous host resolution.
+  boost::asio::detail::scoped_ptr<boost::asio::io_context> work_io_context_;
 
-  // The work io_service implementation used to post completions.
-  io_service_impl& work_io_service_impl_;
+  // The work io_context implementation used to post completions.
+  io_context_impl& work_io_context_impl_;
 
-  // Work for the private io_service to perform.
-  boost::asio::detail::scoped_ptr<boost::asio::io_service::work> work_;
+  // Work for the private io_context to perform.
+  boost::asio::executor_work_guard<
+      boost::asio::io_context::executor_type> work_;
 
-  // Thread used for running the work io_service's run loop.
+  // Thread used for running the work io_context's run loop.
   boost::asio::detail::scoped_ptr<boost::asio::detail::thread> work_thread_;
 };
 

data/src/cxx_supportlib/vendor-modified/boost/asio/detail/{task_io_service.hpp → scheduler.hpp}

@@ -1,15 +1,15 @@
 //
-// detail/task_io_service.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
+// detail/scheduler.hpp
+// ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2017 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2018 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_TASK_IO_SERVICE_HPP
-#define BOOST_ASIO_DETAIL_TASK_IO_SERVICE_HPP
+#ifndef BOOST_ASIO_DETAIL_SCHEDULER_HPP
+#define BOOST_ASIO_DETAIL_SCHEDULER_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
@@ -17,17 +17,15 @@
 
 #include <boost/asio/detail/config.hpp>
 
-#if !defined(BOOST_ASIO_HAS_IOCP)
-
 #include <boost/system/error_code.hpp>
-#include <boost/asio/io_service.hpp>
+#include <boost/asio/execution_context.hpp>
 #include <boost/asio/detail/atomic_count.hpp>
-#include <boost/asio/detail/call_stack.hpp>
-#include <boost/asio/detail/event.hpp>
-#include <boost/asio/detail/mutex.hpp>
+#include <boost/asio/detail/conditionally_enabled_event.hpp>
+#include <boost/asio/detail/conditionally_enabled_mutex.hpp>
 #include <boost/asio/detail/op_queue.hpp>
 #include <boost/asio/detail/reactor_fwd.hpp>
-#include <boost/asio/detail/task_io_service_operation.hpp>
+#include <boost/asio/detail/scheduler_operation.hpp>
+#include <boost/asio/detail/thread_context.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
@@ -35,21 +33,22 @@ namespace boost {
 namespace asio {
 namespace detail {
 
-struct task_io_service_thread_info;
+struct scheduler_thread_info;
 
-class task_io_service
-  : public boost::asio::detail::service_base<task_io_service>
+class scheduler
+  : public execution_context_service_base<scheduler>,
+    public thread_context
 {
 public:
-  typedef task_io_service_operation operation;
+  typedef scheduler_operation operation;
 
   // Constructor. Specifies the number of concurrent threads that are likely to
-  // run the io_service. If set to 1 certain optimisation are performed.
-  BOOST_ASIO_DECL task_io_service(boost::asio::io_service& io_service,
-      std::size_t concurrency_hint = 0);
+  // run the scheduler. If set to 1 certain optimisation are performed.
+  BOOST_ASIO_DECL scheduler(boost::asio::execution_context& ctx,
+      int concurrency_hint = 0);
 
   // Destroy all user-defined handler objects owned by the service.
-  BOOST_ASIO_DECL void shutdown_service();
+  BOOST_ASIO_DECL void shutdown();
 
   // Initialise the task, if required.
   BOOST_ASIO_DECL void init_task();
@@ -60,6 +59,10 @@ public:
   // Run until interrupted or one operation is performed.
   BOOST_ASIO_DECL std::size_t run_one(boost::system::error_code& ec);
 
+  // Run until timeout, interrupted, or one operation is performed.
+  BOOST_ASIO_DECL std::size_t wait_one(
+      long usec, boost::system::error_code& ec);
+
   // Poll for operations without blocking.
   BOOST_ASIO_DECL std::size_t poll(boost::system::error_code& ec);
 
@@ -69,11 +72,11 @@ public:
   // Interrupt the event processing loop.
   BOOST_ASIO_DECL void stop();
 
-  // Determine whether the io_service is stopped.
+  // Determine whether the scheduler is stopped.
   BOOST_ASIO_DECL bool stopped() const;
 
-  // Reset in preparation for a subsequent run invocation.
-  BOOST_ASIO_DECL void reset();
+  // Restart in preparation for a subsequent run invocation.
+  BOOST_ASIO_DECL void restart();
 
   // Notify that some work has started.
   void work_started()
@@ -81,6 +84,10 @@ public:
     ++outstanding_work_;
   }
 
+  // Used to compensate for a forthcoming work_finished call. Must be called
+  // from within a scheduler-owned thread.
+  BOOST_ASIO_DECL void compensating_work_started();
+
   // Notify that some work has finished.
   void work_finished()
   {
@@ -94,14 +101,6 @@ public:
     return thread_call_stack::contains(this) != 0;
   }
 
-  // Request invocation of the given handler.
-  template <typename Handler>
-  void dispatch(Handler& handler);
-
-  // Request invocation of the given handler and return immediately.
-  template <typename Handler>
-  void post(Handler& handler);
-
   // Request invocation of the given operation and return immediately. Assumes
   // that work_started() has not yet been called for the operation.
   BOOST_ASIO_DECL void post_immediate_completion(
@@ -115,22 +114,38 @@ public:
   // that work_started() was previously called for each operation.
   BOOST_ASIO_DECL void post_deferred_completions(op_queue<operation>& ops);
 
-  // Process unfinished operations as part of a shutdown_service operation.
-  // Assumes that work_started() was previously called for the operations.
+  // Enqueue the given operation following a failed attempt to dispatch the
+  // operation for immediate invocation.
+  BOOST_ASIO_DECL void do_dispatch(operation* op);
+
+  // Process unfinished operations as part of a shutdownoperation. Assumes that
+  // work_started() was previously called for the operations.
   BOOST_ASIO_DECL void abandon_operations(op_queue<operation>& ops);
 
+  // Get the concurrency hint that was used to initialise the scheduler.
+  int concurrency_hint() const
+  {
+    return concurrency_hint_;
+  }
+
 private:
-  // Structure containing thread-specific data.
-  typedef task_io_service_thread_info thread_info;
+  // The mutex type used by this scheduler.
+  typedef conditionally_enabled_mutex mutex;
 
-  // Enqueue the given operation following a failed attempt to dispatch the
-  // operation for immediate invocation.
-  BOOST_ASIO_DECL void do_dispatch(operation* op);
+  // The event type used by this scheduler.
+  typedef conditionally_enabled_event event;
+
+  // Structure containing thread-specific data.
+  typedef scheduler_thread_info thread_info;
 
   // Run at most one operation. May block.
   BOOST_ASIO_DECL std::size_t do_run_one(mutex::scoped_lock& lock,
       thread_info& this_thread, const boost::system::error_code& ec);
 
+  // Run at most one operation with a timeout. May block.
+  BOOST_ASIO_DECL std::size_t do_wait_one(mutex::scoped_lock& lock,
+      thread_info& this_thread, long usec, const boost::system::error_code& ec);
+
   // Poll for at most one operation.
   BOOST_ASIO_DECL std::size_t do_poll_one(mutex::scoped_lock& lock,
       thread_info& this_thread, const boost::system::error_code& ec);
@@ -183,8 +198,8 @@ private:
   // Flag to indicate that the dispatcher has been shut down.
   bool shutdown_;
 
-  // Per-thread call stack to track the state of each thread in the io_service.
-  typedef call_stack<task_io_service, thread_info> thread_call_stack;
+  // The concurrency hint used to initialise the scheduler.
+  const int concurrency_hint_;
 };
 
 } // namespace detail
@@ -193,11 +208,8 @@ private:
 
 #include <boost/asio/detail/pop_options.hpp>
 
-#include <boost/asio/detail/impl/task_io_service.hpp>
 #if defined(BOOST_ASIO_HEADER_ONLY)
-# include <boost/asio/detail/impl/task_io_service.ipp>
+# include <boost/asio/detail/impl/scheduler.ipp>
 #endif // defined(BOOST_ASIO_HEADER_ONLY)
 
-#endif // !defined(BOOST_ASIO_HAS_IOCP)
-
-#endif // BOOST_ASIO_DETAIL_TASK_IO_SERVICE_HPP
+#endif // BOOST_ASIO_DETAIL_SCHEDULER_HPP