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/detail/config.hpp>

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

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

#include <boost/corosio/endpoint.hpp>

#include <boost/corosio/endpoint.hpp>

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

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

#include <coroutine>

#include <coroutine>

#include <boost/capy/error.hpp>

#include <boost/capy/error.hpp>

#include <system_error>

#include <system_error>

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

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

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

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

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

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

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

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

#include <unistd.h>

#include <unistd.h>

#include <errno.h>

#include <errno.h>

#include <fcntl.h>

#include <fcntl.h>

#include <atomic>

#include <atomic>

#include <cstddef>

#include <cstddef>

#include <memory>

#include <memory>

#include <optional>

#include <optional>

#include <stop_token>

#include <stop_token>

#include <netinet/in.h>

#include <netinet/in.h>

#include <sys/select.h>

#include <sys/select.h>

#include <sys/socket.h>

#include <sys/socket.h>

#include <sys/uio.h>

#include <sys/uio.h>

/*

/*

    select Operation State

    select Operation State

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

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

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

    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

    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

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

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

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

    This mirrors the epoll_op design for consistency across backends.

    This mirrors the epoll_op design for consistency across backends.

    Completion vs Cancellation Race

    Completion vs Cancellation Race

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

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

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

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

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

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

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

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

    The registering state closes the window where an event could arrive

    The registering state closes the window where an event could arrive

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

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

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

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

    Whoever atomically exchanges to unregistered "claims" the operation

    Whoever atomically exchanges to unregistered "claims" the operation

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

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

    does nothing. The initiating thread uses compare_exchange to transition

    does nothing. The initiating thread uses compare_exchange to transition

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

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

    already claimed the op.

    already claimed the op.

    Impl Lifetime Management

    Impl Lifetime Management

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

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

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

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

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

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

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

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

    completes.

    completes.

    EOF Detection

    EOF Detection

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

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

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

    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.

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

    SIGPIPE Prevention

    SIGPIPE Prevention

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

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

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

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

    SIGPIPE when the peer has closed.

    SIGPIPE when the peer has closed.

*/

*/

namespace boost::corosio::detail {

namespace boost::corosio::detail {

// Forward declarations for cancellation support

// Forward declarations for cancellation support

class select_socket;

class select_socket;

class select_acceptor;

class select_acceptor;

/** Registration state for async operations.

/** Registration state for async operations.

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

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

    run_reactor() seeing an event. Setting REGISTERING before

    run_reactor() seeing an event. Setting REGISTERING before

    calling register_fd() ensures events delivered during the

    calling register_fd() ensures events delivered during the

    registration window are not dropped.

    registration window are not dropped.

*/

*/

enum class select_registration_state : std::uint8_t

enum class select_registration_state : std::uint8_t

{

{

    unregistered, ///< Not registered with reactor

    unregistered, ///< Not registered with reactor

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

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

    registered    ///< Fully registered, ready for events

    registered    ///< Fully registered, ready for events

};

};

struct select_op : scheduler_op

struct select_op : scheduler_op

{

{

    struct canceller

    struct canceller

    {

    {

        select_op* op;

        select_op* op;

        void operator()() const noexcept;

        void operator()() const noexcept;

    };

    };

    std::coroutine_handle<> h;

    std::coroutine_handle<> h;

    capy::executor_ref ex;

    capy::executor_ref ex;

    std::error_code* ec_out = nullptr;

    std::error_code* ec_out = nullptr;

    std::size_t* bytes_out  = nullptr;

    std::size_t* bytes_out  = nullptr;

    int fd                        = -1;

    int fd                        = -1;

    int errn                      = 0;

    int errn                      = 0;

    std::size_t bytes_transferred = 0;

    std::size_t bytes_transferred = 0;

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

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

    std::atomic<select_registration_state> registered{

    std::atomic<select_registration_state> registered{

        select_registration_state::unregistered};

        select_registration_state::unregistered};

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

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

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

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

    std::shared_ptr<void> impl_ptr;

    std::shared_ptr<void> impl_ptr;

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

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

    select_socket* socket_impl_     = nullptr;

    select_socket* socket_impl_     = nullptr;

    select_acceptor* acceptor_impl_ = nullptr;

    select_acceptor* acceptor_impl_ = nullptr;

    {

    {

            select_registration_state::unregistered, std::memory_order_relaxed);

            select_registration_state::unregistered, std::memory_order_relaxed);

    {

    {

        {

        {

            else

            else

        }

        }

        // Move to stack before destroying the frame

        // Move to stack before destroying the frame

    {

    {

    }

    }

    virtual void cancel() noexcept = 0;

    virtual void cancel() noexcept = 0;

    {

    {

    {

    {

    // NOLINTNEXTLINE(performance-unnecessary-value-param)

    // NOLINTNEXTLINE(performance-unnecessary-value-param)

    void start(std::stop_token token)

    void start(std::stop_token token)

    {

    {

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

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

        stop_cb.reset();

        stop_cb.reset();

        socket_impl_   = nullptr;

        socket_impl_   = nullptr;

        acceptor_impl_ = nullptr;

        acceptor_impl_ = nullptr;

        if (token.stop_possible())

        if (token.stop_possible())

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

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

    }

    }

    // NOLINTNEXTLINE(performance-unnecessary-value-param)

    // NOLINTNEXTLINE(performance-unnecessary-value-param)

    {

    {

    // NOLINTNEXTLINE(performance-unnecessary-value-param)

    // NOLINTNEXTLINE(performance-unnecessary-value-param)

    {

    {

    {

    {

};

};

struct select_connect_op final : select_op

struct select_connect_op final : select_op

{

{

    endpoint target_endpoint;

    endpoint target_endpoint;

    {

    {

    {

    {

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

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

    // Defined in sockets.cpp where select_socket is complete

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

struct select_read_op final : select_op

{

{

    static constexpr std::size_t max_buffers = 16;

    static constexpr std::size_t max_buffers = 16;

    iovec iovecs[max_buffers];

    iovec iovecs[max_buffers];

    int iovec_count        = 0;

    int iovec_count        = 0;

    bool empty_buffer_read = false;

    bool empty_buffer_read = false;

    {

    {

    }

    }

    {

    {

    {

    {

        else

        else

    void cancel() noexcept override;

    void cancel() noexcept override;

};

};

struct select_write_op final : select_op

struct select_write_op final : select_op

{

{

    static constexpr std::size_t max_buffers = 16;

    static constexpr std::size_t max_buffers = 16;

    iovec iovecs[max_buffers];

    iovec iovecs[max_buffers];

    int iovec_count = 0;

    int iovec_count = 0;

    {

    {

    {

    {

        else

        else

    void cancel() noexcept override;

    void cancel() noexcept override;

};

};

struct select_accept_op final : select_op

struct select_accept_op final : select_op

{

{

    int accepted_fd                      = -1;

    int accepted_fd                      = -1;

    io_object::implementation* peer_impl = nullptr;

    io_object::implementation* peer_impl = nullptr;

    io_object::implementation** impl_out = nullptr;

    io_object::implementation** impl_out = nullptr;

    {

    {

    {

    {

        // Note: select backend uses accept() + fcntl instead of accept4()

        // Note: select backend uses accept() + fcntl instead of accept4()

        // for broader POSIX compatibility

        // for broader POSIX compatibility

        {

        {

            // Reject fds that exceed select()'s FD_SETSIZE limit.

            // Reject fds that exceed select()'s FD_SETSIZE limit.

            // Better to fail now than during later async operations.

            // Better to fail now than during later async operations.

            {

            {

            }

            }

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

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

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

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

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

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

            {

            {

            }

            }

            {

            {

            }

            }

            {

            {

            }

            }

        }

        }

        else

        else

        {

        {

        }

        }

    }

    }

    // Defined in acceptors.cpp where select_acceptor is complete

    // Defined in acceptors.cpp where select_acceptor is complete

    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