Diff coverage report for

//

//

// Copyright (c) 2026 Steve Gerbino

// Copyright (c) 2026 Steve Gerbino

//

//

// Distributed under the Boost Software License, Version 1.0. (See accompanying

// 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)

// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//

//

// Official repository: https://github.com/cppalliance/corosio

// Official repository: https://github.com/cppalliance/corosio

//

//

#ifndef BOOST_COROSIO_NATIVE_DETAIL_SELECT_SELECT_OP_HPP

#ifndef BOOST_COROSIO_NATIVE_DETAIL_SELECT_SELECT_OP_HPP

#define BOOST_COROSIO_NATIVE_DETAIL_SELECT_SELECT_OP_HPP

#define BOOST_COROSIO_NATIVE_DETAIL_SELECT_SELECT_OP_HPP

#include <boost/corosio/detail/platform.hpp>

#include <boost/corosio/detail/platform.hpp>

#if BOOST_COROSIO_HAS_SELECT

#if BOOST_COROSIO_HAS_SELECT

#include <boost/corosio/detail/config.hpp>

#include <boost/corosio/native/detail/reactor/reactor_op.hpp>

#include <boost/corosio/io/io_object.hpp>

#include <boost/corosio/native/detail/reactor/reactor_descriptor_state.hpp>

#include <boost/corosio/endpoint.hpp>

#include <boost/capy/ex/executor_ref.hpp>

#include <coroutine>

#include <boost/capy/error.hpp>

#include <system_error>

#include <boost/corosio/native/detail/make_err.hpp>

#include <boost/corosio/detail/dispatch_coro.hpp>

#include <boost/corosio/detail/scheduler_op.hpp>

#include <boost/corosio/native/detail/endpoint_convert.hpp>

#include <unistd.h>

#include <errno.h>

#include <errno.h>

#include <atomic>

#include <cstddef>

#include <memory>

#include <optional>

#include <stop_token>

#include <netinet/in.h>

#include <sys/select.h>

#include <fcntl.h>

#include <fcntl.h>

#include <sys/socket.h>

#include <sys/socket.h>

#include <sys/uio.h>

#include <unistd.h>

/*

/*

    select Operation State

    File descriptors are registered with the select scheduler once (via

    ======================

    select_descriptor_state) and stay registered until closed.

    Each async I/O operation has a corresponding select_op-derived struct that

    holds the operation's state while it's in flight. The socket impl owns

    fixed slots for each operation type (conn_, rd_, wr_), so only one

    operation of each type can be pending per socket at a time.

    This mirrors the epoll_op design for consistency across backends.

    Completion vs Cancellation Race

    -------------------------------

    The `registered` atomic uses a tri-state (unregistered, registering,

    registered) to handle two races: (1) between register_fd() and the

    reactor seeing an event, and (2) between reactor completion and cancel().

    The registering state closes the window where an event could arrive

    after register_fd() but before the boolean was set. The reactor and

    cancel() both treat registering the same as registered when claiming.

    Whoever atomically exchanges to unregistered "claims" the operation

    and is responsible for completing it. The loser sees unregistered and

    does nothing. The initiating thread uses compare_exchange to transition

    from registering to registered; if this fails, the reactor or cancel

    already claimed the op.

    Impl Lifetime Management

    select() is level-triggered but the descriptor_state pattern

    ------------------------

    (designed for edge-triggered) works correctly: is_enqueued_ CAS

    When cancel() posts an op to the scheduler's ready queue, the socket impl

    prevents double-enqueue, add_ready_events is idempotent, and

    might be destroyed before the scheduler processes the op. The `impl_ptr`

    EAGAIN ops stay parked until the next select() re-reports readiness.

    member holds a shared_ptr to the impl, keeping it alive until the op

    completes.

    EOF Detection

    cancel() captures shared_from_this() into op.impl_ptr to prevent

    -------------

    use-after-free when the socket is closed with pending ops.

    For reads, 0 bytes with no error means EOF. But an empty user buffer also

    returns 0 bytes. The `empty_buffer_read` flag distinguishes these cases.

    SIGPIPE Prevention

    Writes use sendmsg(MSG_NOSIGNAL) on Linux. On macOS/BSD where

    ------------------

    MSG_NOSIGNAL may be absent, SO_NOSIGPIPE is set at socket creation

    Writes use sendmsg() with MSG_NOSIGNAL instead of writev() to prevent

    and accepted-socket setup instead.

    SIGPIPE when the peer has closed.

*/

*/

namespace boost::corosio::detail {

namespace boost::corosio::detail {

// Forward declarations for cancellation support

// Forward declarations

class select_socket;

class select_socket;

class select_acceptor;

class select_acceptor;

struct select_op;

/** Registration state for async operations.

// Forward declaration

class select_scheduler;

    Tri-state enum to handle the race between register_fd() and

/// Per-descriptor state for persistent select registration.

    run_reactor() seeing an event. Setting REGISTERING before

struct select_descriptor_state final : reactor_descriptor_state

    calling register_fd() ensures events delivered during the

{};

    registration window are not dropped.

*/

enum class select_registration_state : std::uint8_t

{

    unregistered, ///< Not registered with reactor

    registering,  ///< register_fd() called, not yet confirmed

    registered    ///< Fully registered, ready for events

};

struct select_op : scheduler_op

/// select base operation — thin wrapper over reactor_op.

struct select_op : reactor_op<select_socket, select_acceptor>

{

{

    struct canceller

    void operator()() override;

    {

        select_op* op;

        void operator()() const noexcept;

    };

    std::coroutine_handle<> h;

    capy::executor_ref ex;

    std::error_code* ec_out = nullptr;

    std::size_t* bytes_out  = nullptr;

    int fd                        = -1;

    int errn                      = 0;

    std::size_t bytes_transferred = 0;

    std::atomic<bool> cancelled{false};

    std::atomic<select_registration_state> registered{

        select_registration_state::unregistered};

    std::optional<std::stop_callback<canceller>> stop_cb;

    // Prevents use-after-free when socket is closed with pending ops.

    std::shared_ptr<void> impl_ptr;

    // For stop_token cancellation - pointer to owning socket/acceptor impl.

    select_socket* socket_impl_     = nullptr;

    select_acceptor* acceptor_impl_ = nullptr;

    {

            select_registration_state::unregistered, std::memory_order_relaxed);

    {

        {

            else

        }

        // Move to stack before destroying the frame

    {

    }

    virtual void cancel() noexcept = 0;

    {

    {

    void start(std::stop_token const& token)

    {

        cancelled.store(false, std::memory_order_release);

        stop_cb.reset();

        socket_impl_   = nullptr;

        acceptor_impl_ = nullptr;

        if (token.stop_possible())

            stop_cb.emplace(token, canceller{this});

    }

    {

    {

    {

};

};

struct select_connect_op final : select_op

/// select connect operation.

struct select_connect_op final : reactor_connect_op<select_op>

    endpoint target_endpoint;

    void reset() noexcept

        select_op::reset();

    void perform_io() noexcept override

        // connect() completion status is retrieved via SO_ERROR, not return value

        int err       = 0;

    // Defined in sockets.cpp where select_socket is complete

{

{

    void operator()() override;

    void operator()() override;

    void cancel() noexcept override;

    void cancel() noexcept override;

};

};

struct select_read_op final : select_op

/// select scatter-read operation.

struct select_read_op final : reactor_read_op<select_op>

    static constexpr std::size_t max_buffers = 16;

    iovec iovecs[max_buffers];

    int iovec_count        = 0;

    bool empty_buffer_read = false;

    bool is_read_operation() const noexcept override

        return !empty_buffer_read;

    void reset() noexcept

        select_op::reset();

    void perform_io() noexcept override

        ssize_t n = ::readv(fd, iovecs, iovec_count);

            complete(errno, 0);

{

{

    void cancel() noexcept override;

    void cancel() noexcept override;

};

};

struct select_write_op final : select_op

/** Provides sendmsg() with EINTR retry for select writes.

{

    static constexpr std::size_t max_buffers = 16;

    iovec iovecs[max_buffers];

    int iovec_count = 0;

    {

    it (macOS/BSD), SO_NOSIGPIPE is set at socket creation time

    and flags=0 is used here.

*/

struct select_write_policy

{

    {

    {

        else

        constexpr int send_flags = 0;

    void cancel() noexcept override;

        ssize_t n;

        do

        {

        }

    }

};

};

struct select_accept_op final : select_op

/// select gather-write operation.

struct select_write_op final : reactor_write_op<select_op, select_write_policy>

{

{

    int accepted_fd                      = -1;

    void cancel() noexcept override;

    io_object::implementation* peer_impl = nullptr;

};

    io_object::implementation** impl_out = nullptr;

    {

*/

struct select_accept_policy

{

    {

    {

        do

        {

        }

        int new_fd =

        {

        {

            {

        }

            }

            // Set non-blocking and close-on-exec flags.

            // A non-blocking socket is essential for the async reactor;

            // if we can't configure it, fail rather than risk blocking.

            {

            }

        }

            {

        {

            }

        }

        }

        }

        else

#ifdef SO_NOSIGPIPE

        int one = 1;

        if (::setsockopt(

                new_fd, SOL_SOCKET, SO_NOSIGPIPE, &one, sizeof(one)) == -1)

        {

        {

            ::close(new_fd);

            errno = err;

            return -1;

        }

        }

#endif

    }

    }

};

    // Defined in acceptors.cpp where select_acceptor is complete

/// select accept operation.

struct select_accept_op final

    : reactor_accept_op<select_op, select_accept_policy>

{

    void operator()() override;

    void operator()() override;

    void cancel() noexcept override;

    void cancel() noexcept override;

};

};

} // namespace boost::corosio::detail

} // namespace boost::corosio::detail

#endif // BOOST_COROSIO_HAS_SELECT

#endif // BOOST_COROSIO_HAS_SELECT

#endif // BOOST_COROSIO_NATIVE_DETAIL_SELECT_SELECT_OP_HPP

#endif // BOOST_COROSIO_NATIVE_DETAIL_SELECT_SELECT_OP_HPP