passenger 6.0.26 → 6.1.0

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

@@ -1,187 +0,0 @@
-//
-// detail/impl/socket_select_interrupter.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// 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_IMPL_SOCKET_SELECT_INTERRUPTER_IPP
-#define BOOST_ASIO_DETAIL_IMPL_SOCKET_SELECT_INTERRUPTER_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include <boost/asio/detail/config.hpp>
-
-#if !defined(BOOST_ASIO_WINDOWS_RUNTIME)
-
-#if defined(BOOST_ASIO_WINDOWS) \
-  || defined(__CYGWIN__) \
-  || defined(__SYMBIAN32__)
-
-#include <cstdlib>
-#include <boost/asio/detail/socket_holder.hpp>
-#include <boost/asio/detail/socket_ops.hpp>
-#include <boost/asio/detail/socket_select_interrupter.hpp>
-#include <boost/asio/detail/throw_error.hpp>
-#include <boost/asio/error.hpp>
-
-#include <boost/asio/detail/push_options.hpp>
-
-namespace boost {
-namespace asio {
-namespace detail {
-
-socket_select_interrupter::socket_select_interrupter()
-{
-  open_descriptors();
-}
-
-void socket_select_interrupter::open_descriptors()
-{
-  boost::system::error_code ec;
-  socket_holder acceptor(socket_ops::socket(
-        AF_INET, SOCK_STREAM, IPPROTO_TCP, ec));
-  if (acceptor.get() == invalid_socket)
-    boost::asio::detail::throw_error(ec, "socket_select_interrupter");
-
-  int opt = 1;
-  socket_ops::state_type acceptor_state = 0;
-  socket_ops::setsockopt(acceptor.get(), acceptor_state,
-      SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt), ec);
-
-  using namespace std; // For memset.
-  sockaddr_in4_type addr;
-  std::size_t addr_len = sizeof(addr);
-  memset(&addr, 0, sizeof(addr));
-  addr.sin_family = AF_INET;
-  addr.sin_addr.s_addr = socket_ops::host_to_network_long(INADDR_LOOPBACK);
-  addr.sin_port = 0;
-  if (socket_ops::bind(acceptor.get(), &addr,
-        addr_len, ec) == socket_error_retval)
-    boost::asio::detail::throw_error(ec, "socket_select_interrupter");
-
-  if (socket_ops::getsockname(acceptor.get(), &addr,
-        &addr_len, ec) == socket_error_retval)
-    boost::asio::detail::throw_error(ec, "socket_select_interrupter");
-
-  // Some broken firewalls on Windows will intermittently cause getsockname to
-  // return 0.0.0.0 when the socket is actually bound to 127.0.0.1. We
-  // explicitly specify the target address here to work around this problem.
-  if (addr.sin_addr.s_addr == socket_ops::host_to_network_long(INADDR_ANY))
-    addr.sin_addr.s_addr = socket_ops::host_to_network_long(INADDR_LOOPBACK);
-
-  if (socket_ops::listen(acceptor.get(),
-        SOMAXCONN, ec) == socket_error_retval)
-    boost::asio::detail::throw_error(ec, "socket_select_interrupter");
-
-  socket_holder client(socket_ops::socket(
-        AF_INET, SOCK_STREAM, IPPROTO_TCP, ec));
-  if (client.get() == invalid_socket)
-    boost::asio::detail::throw_error(ec, "socket_select_interrupter");
-
-  if (socket_ops::connect(client.get(), &addr,
-        addr_len, ec) == socket_error_retval)
-    boost::asio::detail::throw_error(ec, "socket_select_interrupter");
-
-  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,
-        FIONBIO, &non_blocking, ec))
-    boost::asio::detail::throw_error(ec, "socket_select_interrupter");
-
-  opt = 1;
-  socket_ops::setsockopt(client.get(), client_state,
-      IPPROTO_TCP, TCP_NODELAY, &opt, sizeof(opt), ec);
-
-  non_blocking = 1;
-  socket_ops::state_type server_state = 0;
-  if (socket_ops::ioctl(server.get(), server_state,
-        FIONBIO, &non_blocking, ec))
-    boost::asio::detail::throw_error(ec, "socket_select_interrupter");
-
-  opt = 1;
-  socket_ops::setsockopt(server.get(), server_state,
-      IPPROTO_TCP, TCP_NODELAY, &opt, sizeof(opt), ec);
-
-  read_descriptor_ = server.release();
-  write_descriptor_ = client.release();
-}
-
-socket_select_interrupter::~socket_select_interrupter()
-{
-  close_descriptors();
-}
-
-void socket_select_interrupter::close_descriptors()
-{
-  boost::system::error_code ec;
-  socket_ops::state_type state = socket_ops::internal_non_blocking;
-  if (read_descriptor_ != invalid_socket)
-    socket_ops::close(read_descriptor_, state, true, ec);
-  if (write_descriptor_ != invalid_socket)
-    socket_ops::close(write_descriptor_, state, true, ec);
-}
-
-void socket_select_interrupter::recreate()
-{
-  close_descriptors();
-
-  write_descriptor_ = invalid_socket;
-  read_descriptor_ = invalid_socket;
-
-  open_descriptors();
-}
-
-void socket_select_interrupter::interrupt()
-{
-  char byte = 0;
-  socket_ops::buf b;
-  socket_ops::init_buf(b, &byte, 1);
-  boost::system::error_code ec;
-  socket_ops::send(write_descriptor_, &b, 1, 0, ec);
-}
-
-bool socket_select_interrupter::reset()
-{
-  char data[1024];
-  socket_ops::buf b;
-  socket_ops::init_buf(b, data, sizeof(data));
-  boost::system::error_code ec;
-  for (;;)
-  {
-    int bytes_read = socket_ops::recv(read_descriptor_, &b, 1, 0, ec);
-    if (bytes_read == sizeof(data))
-      continue;
-    if (bytes_read > 0)
-      return true;
-    if (bytes_read == 0)
-      return false;
-    if (ec == boost::asio::error::would_block
-        || ec == boost::asio::error::try_again)
-      return true;
-    return false;
-  }
-}
-
-} // namespace detail
-} // namespace asio
-} // namespace boost
-
-#include <boost/asio/detail/pop_options.hpp>
-
-#endif // defined(BOOST_ASIO_WINDOWS)
-       // || defined(__CYGWIN__)
-       // || defined(__SYMBIAN32__)
-
-#endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME)
-
-#endif // BOOST_ASIO_DETAIL_IMPL_SOCKET_SELECT_INTERRUPTER_IPP

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

@@ -1,348 +0,0 @@
-//
-// detail/impl/strand_executor_service.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_IMPL_STRAND_EXECUTOR_SERVICE_HPP
-#define BOOST_ASIO_DETAIL_IMPL_STRAND_EXECUTOR_SERVICE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include <boost/asio/detail/fenced_block.hpp>
-#include <boost/asio/detail/recycling_allocator.hpp>
-#include <boost/asio/executor_work_guard.hpp>
-#include <boost/asio/defer.hpp>
-#include <boost/asio/dispatch.hpp>
-#include <boost/asio/post.hpp>
-
-#include <boost/asio/detail/push_options.hpp>
-
-namespace boost {
-namespace asio {
-namespace detail {
-
-template <typename F, typename Allocator>
-class strand_executor_service::allocator_binder
-{
-public:
-  typedef Allocator allocator_type;
-
-  allocator_binder(F&& f, const Allocator& a)
-    : f_(static_cast<F&&>(f)),
-      allocator_(a)
-  {
-  }
-
-  allocator_binder(const allocator_binder& other)
-    : f_(other.f_),
-      allocator_(other.allocator_)
-  {
-  }
-
-  allocator_binder(allocator_binder&& other)
-    : f_(static_cast<F&&>(other.f_)),
-      allocator_(static_cast<allocator_type&&>(other.allocator_))
-  {
-  }
-
-  allocator_type get_allocator() const noexcept
-  {
-    return allocator_;
-  }
-
-  void operator()()
-  {
-    f_();
-  }
-
-private:
-  F f_;
-  allocator_type allocator_;
-};
-
-template <typename Executor>
-class strand_executor_service::invoker<Executor,
-    enable_if_t<
-      execution::is_executor<Executor>::value
-    >>
-{
-public:
-  invoker(const implementation_type& impl, Executor& ex)
-    : impl_(impl),
-      executor_(boost::asio::prefer(ex, execution::outstanding_work.tracked))
-  {
-  }
-
-  invoker(const invoker& other)
-    : impl_(other.impl_),
-      executor_(other.executor_)
-  {
-  }
-
-  invoker(invoker&& other)
-    : impl_(static_cast<implementation_type&&>(other.impl_)),
-      executor_(static_cast<executor_type&&>(other.executor_))
-  {
-  }
-
-  struct on_invoker_exit
-  {
-    invoker* this_;
-
-    ~on_invoker_exit()
-    {
-      if (push_waiting_to_ready(this_->impl_))
-      {
-        recycling_allocator<void> allocator;
-        executor_type ex = this_->executor_;
-        boost::asio::prefer(
-            boost::asio::require(
-              static_cast<executor_type&&>(ex),
-              execution::blocking.never),
-            execution::allocator(allocator)
-          ).execute(static_cast<invoker&&>(*this_));
-      }
-    }
-  };
-
-  void operator()()
-  {
-    // Ensure the next handler, if any, is scheduled on block exit.
-    on_invoker_exit on_exit = { this };
-    (void)on_exit;
-
-    run_ready_handlers(impl_);
-  }
-
-private:
-  typedef decay_t<
-      prefer_result_t<
-        Executor,
-        execution::outstanding_work_t::tracked_t
-      >
-    > executor_type;
-
-  implementation_type impl_;
-  executor_type executor_;
-};
-
-#if !defined(BOOST_ASIO_NO_TS_EXECUTORS)
-
-template <typename Executor>
-class strand_executor_service::invoker<Executor,
-    enable_if_t<
-      !execution::is_executor<Executor>::value
-    >>
-{
-public:
-  invoker(const implementation_type& impl, Executor& ex)
-    : impl_(impl),
-      work_(ex)
-  {
-  }
-
-  invoker(const invoker& other)
-    : impl_(other.impl_),
-      work_(other.work_)
-  {
-  }
-
-  invoker(invoker&& other)
-    : impl_(static_cast<implementation_type&&>(other.impl_)),
-      work_(static_cast<executor_work_guard<Executor>&&>(other.work_))
-  {
-  }
-
-  struct on_invoker_exit
-  {
-    invoker* this_;
-
-    ~on_invoker_exit()
-    {
-      if (push_waiting_to_ready(this_->impl_))
-      {
-        Executor ex(this_->work_.get_executor());
-        recycling_allocator<void> allocator;
-        ex.post(static_cast<invoker&&>(*this_), allocator);
-      }
-    }
-  };
-
-  void operator()()
-  {
-    // Ensure the next handler, if any, is scheduled on block exit.
-    on_invoker_exit on_exit = { this };
-    (void)on_exit;
-
-    run_ready_handlers(impl_);
-  }
-
-private:
-  implementation_type impl_;
-  executor_work_guard<Executor> work_;
-};
-
-#endif // !defined(BOOST_ASIO_NO_TS_EXECUTORS)
-
-template <typename Executor, typename Function>
-inline void strand_executor_service::execute(const implementation_type& impl,
-    Executor& ex, Function&& function,
-    enable_if_t<
-      can_query<Executor, execution::allocator_t<void>>::value
-    >*)
-{
-  return strand_executor_service::do_execute(impl, ex,
-      static_cast<Function&&>(function),
-      boost::asio::query(ex, execution::allocator));
-}
-
-template <typename Executor, typename Function>
-inline void strand_executor_service::execute(const implementation_type& impl,
-    Executor& ex, Function&& function,
-    enable_if_t<
-      !can_query<Executor, execution::allocator_t<void>>::value
-    >*)
-{
-  return strand_executor_service::do_execute(impl, ex,
-      static_cast<Function&&>(function),
-      std::allocator<void>());
-}
-
-template <typename Executor, typename Function, typename Allocator>
-void strand_executor_service::do_execute(const implementation_type& impl,
-    Executor& ex, Function&& function, const Allocator& a)
-{
-  typedef decay_t<Function> function_type;
-
-  // If the executor is not never-blocking, and we are already in the strand,
-  // then the function can run immediately.
-  if (boost::asio::query(ex, execution::blocking) != execution::blocking.never
-      && running_in_this_thread(impl))
-  {
-    // Make a local, non-const copy of the function.
-    function_type tmp(static_cast<Function&&>(function));
-
-    fenced_block b(fenced_block::full);
-    static_cast<function_type&&>(tmp)();
-    return;
-  }
-
-  // Allocate and construct an operation to wrap the function.
-  typedef executor_op<function_type, Allocator> op;
-  typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
-  p.p = new (p.v) op(static_cast<Function&&>(function), a);
-
-  BOOST_ASIO_HANDLER_CREATION((impl->service_->context(), *p.p,
-        "strand_executor", impl.get(), 0, "execute"));
-
-  // Add the function to the strand and schedule the strand if required.
-  bool first = enqueue(impl, p.p);
-  p.v = p.p = 0;
-  if (first)
-  {
-    ex.execute(invoker<Executor>(impl, ex));
-  }
-}
-
-template <typename Executor, typename Function, typename Allocator>
-void strand_executor_service::dispatch(const implementation_type& impl,
-    Executor& ex, Function&& function, const Allocator& a)
-{
-  typedef decay_t<Function> function_type;
-
-  // If we are already in the strand then the function can run immediately.
-  if (running_in_this_thread(impl))
-  {
-    // Make a local, non-const copy of the function.
-    function_type tmp(static_cast<Function&&>(function));
-
-    fenced_block b(fenced_block::full);
-    static_cast<function_type&&>(tmp)();
-    return;
-  }
-
-  // Allocate and construct an operation to wrap the function.
-  typedef executor_op<function_type, Allocator> op;
-  typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
-  p.p = new (p.v) op(static_cast<Function&&>(function), a);
-
-  BOOST_ASIO_HANDLER_CREATION((impl->service_->context(), *p.p,
-        "strand_executor", impl.get(), 0, "dispatch"));
-
-  // Add the function to the strand and schedule the strand if required.
-  bool first = enqueue(impl, p.p);
-  p.v = p.p = 0;
-  if (first)
-  {
-    boost::asio::dispatch(ex,
-        allocator_binder<invoker<Executor>, Allocator>(
-          invoker<Executor>(impl, ex), a));
-  }
-}
-
-// Request invocation of the given function and return immediately.
-template <typename Executor, typename Function, typename Allocator>
-void strand_executor_service::post(const implementation_type& impl,
-    Executor& ex, Function&& function, const Allocator& a)
-{
-  typedef decay_t<Function> function_type;
-
-  // Allocate and construct an operation to wrap the function.
-  typedef executor_op<function_type, Allocator> op;
-  typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
-  p.p = new (p.v) op(static_cast<Function&&>(function), a);
-
-  BOOST_ASIO_HANDLER_CREATION((impl->service_->context(), *p.p,
-        "strand_executor", impl.get(), 0, "post"));
-
-  // Add the function to the strand and schedule the strand if required.
-  bool first = enqueue(impl, p.p);
-  p.v = p.p = 0;
-  if (first)
-  {
-    boost::asio::post(ex,
-        allocator_binder<invoker<Executor>, Allocator>(
-          invoker<Executor>(impl, ex), a));
-  }
-}
-
-// Request invocation of the given function and return immediately.
-template <typename Executor, typename Function, typename Allocator>
-void strand_executor_service::defer(const implementation_type& impl,
-    Executor& ex, Function&& function, const Allocator& a)
-{
-  typedef decay_t<Function> function_type;
-
-  // Allocate and construct an operation to wrap the function.
-  typedef executor_op<function_type, Allocator> op;
-  typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
-  p.p = new (p.v) op(static_cast<Function&&>(function), a);
-
-  BOOST_ASIO_HANDLER_CREATION((impl->service_->context(), *p.p,
-        "strand_executor", impl.get(), 0, "defer"));
-
-  // Add the function to the strand and schedule the strand if required.
-  bool first = enqueue(impl, p.p);
-  p.v = p.p = 0;
-  if (first)
-  {
-    boost::asio::defer(ex,
-        allocator_binder<invoker<Executor>, Allocator>(
-          invoker<Executor>(impl, ex), a));
-  }
-}
-
-} // namespace detail
-} // namespace asio
-} // namespace boost
-
-#include <boost/asio/detail/pop_options.hpp>
-
-#endif // BOOST_ASIO_DETAIL_IMPL_STRAND_EXECUTOR_SERVICE_HPP

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

@@ -1,160 +0,0 @@
-//
-// detail/impl/strand_executor_service.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// 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_IMPL_STRAND_EXECUTOR_SERVICE_IPP
-#define BOOST_ASIO_DETAIL_IMPL_STRAND_EXECUTOR_SERVICE_IPP
-
-#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/strand_executor_service.hpp>
-
-#include <boost/asio/detail/push_options.hpp>
-
-namespace boost {
-namespace asio {
-namespace detail {
-
-strand_executor_service::strand_executor_service(execution_context& ctx)
-  : execution_context_service_base<strand_executor_service>(ctx),
-    mutex_(),
-    salt_(0),
-    impl_list_(0)
-{
-}
-
-void strand_executor_service::shutdown()
-{
-  op_queue<scheduler_operation> ops;
-
-  boost::asio::detail::mutex::scoped_lock lock(mutex_);
-
-  strand_impl* impl = impl_list_;
-  while (impl)
-  {
-    impl->mutex_->lock();
-    impl->shutdown_ = true;
-    ops.push(impl->waiting_queue_);
-    ops.push(impl->ready_queue_);
-    impl->mutex_->unlock();
-    impl = impl->next_;
-  }
-}
-
-strand_executor_service::implementation_type
-strand_executor_service::create_implementation()
-{
-  implementation_type new_impl(new strand_impl);
-  new_impl->locked_ = false;
-  new_impl->shutdown_ = false;
-
-  boost::asio::detail::mutex::scoped_lock lock(mutex_);
-
-  // Select a mutex from the pool of shared mutexes.
-  std::size_t salt = salt_++;
-  std::size_t mutex_index = reinterpret_cast<std::size_t>(new_impl.get());
-  mutex_index += (reinterpret_cast<std::size_t>(new_impl.get()) >> 3);
-  mutex_index ^= salt + 0x9e3779b9 + (mutex_index << 6) + (mutex_index >> 2);
-  mutex_index = mutex_index % num_mutexes;
-  if (!mutexes_[mutex_index].get())
-    mutexes_[mutex_index].reset(new mutex);
-  new_impl->mutex_ = mutexes_[mutex_index].get();
-
-  // Insert implementation into linked list of all implementations.
-  new_impl->next_ = impl_list_;
-  new_impl->prev_ = 0;
-  if (impl_list_)
-    impl_list_->prev_ = new_impl.get();
-  impl_list_ = new_impl.get();
-  new_impl->service_ = this;
-
-  return new_impl;
-}
-
-strand_executor_service::strand_impl::~strand_impl()
-{
-  boost::asio::detail::mutex::scoped_lock lock(service_->mutex_);
-
-  // Remove implementation from linked list of all implementations.
-  if (service_->impl_list_ == this)
-    service_->impl_list_ = next_;
-  if (prev_)
-    prev_->next_ = next_;
-  if (next_)
-    next_->prev_= prev_;
-}
-
-bool strand_executor_service::enqueue(const implementation_type& impl,
-    scheduler_operation* op)
-{
-  impl->mutex_->lock();
-  if (impl->shutdown_)
-  {
-    impl->mutex_->unlock();
-    op->destroy();
-    return false;
-  }
-  else if (impl->locked_)
-  {
-    // Some other function already holds the strand lock. Enqueue for later.
-    impl->waiting_queue_.push(op);
-    impl->mutex_->unlock();
-    return false;
-  }
-  else
-  {
-    // The function is acquiring the strand lock and so is responsible for
-    // scheduling the strand.
-    impl->locked_ = true;
-    impl->mutex_->unlock();
-    impl->ready_queue_.push(op);
-    return true;
-  }
-}
-
-bool strand_executor_service::running_in_this_thread(
-    const implementation_type& impl)
-{
-  return !!call_stack<strand_impl>::contains(impl.get());
-}
-
-bool strand_executor_service::push_waiting_to_ready(implementation_type& impl)
-{
-  impl->mutex_->lock();
-  impl->ready_queue_.push(impl->waiting_queue_);
-  bool more_handlers = impl->locked_ = !impl->ready_queue_.empty();
-  impl->mutex_->unlock();
-  return more_handlers;
-}
-
-void strand_executor_service::run_ready_handlers(implementation_type& impl)
-{
-  // Indicate that this strand is executing on the current thread.
-  call_stack<strand_impl>::context ctx(impl.get());
-
-  // Run all ready handlers. No lock is required since the ready queue is
-  // accessed only within the strand.
-  boost::system::error_code ec;
-  while (scheduler_operation* o = impl->ready_queue_.front())
-  {
-    impl->ready_queue_.pop();
-    o->complete(impl.get(), ec, 0);
-  }
-}
-
-} // namespace detail
-} // namespace asio
-} // namespace boost
-
-#include <boost/asio/detail/pop_options.hpp>
-
-#endif // BOOST_ASIO_DETAIL_IMPL_STRAND_EXECUTOR_SERVICE_IPP