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_SOCKET_SERVICE_HPP

#ifndef BOOST_COROSIO_NATIVE_DETAIL_SELECT_SELECT_SOCKET_SERVICE_HPP

#define BOOST_COROSIO_NATIVE_DETAIL_SELECT_SELECT_SOCKET_SERVICE_HPP

#define BOOST_COROSIO_NATIVE_DETAIL_SELECT_SELECT_SOCKET_SERVICE_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/capy/ex/execution_context.hpp>

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

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

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

#include <boost/corosio/native/detail/select/select_socket.hpp>

#include <boost/corosio/native/detail/select/select_socket.hpp>

#include <boost/corosio/native/detail/select/select_scheduler.hpp>

#include <boost/corosio/native/detail/select/select_scheduler.hpp>

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

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

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

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

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

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

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

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

#include <boost/capy/buffers.hpp>

#include <boost/capy/buffers.hpp>

#include <errno.h>

#include <errno.h>

#include <fcntl.h>

#include <fcntl.h>

#include <netinet/in.h>

#include <netinet/in.h>

#include <netinet/tcp.h>

#include <netinet/tcp.h>

#include <sys/socket.h>

#include <sys/socket.h>

#include <unistd.h>

#include <unistd.h>

#include <memory>

#include <memory>

#include <mutex>

#include <mutex>

#include <unordered_map>

#include <unordered_map>

/*

/*

    select Socket Implementation

    select Socket Implementation

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

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

    This mirrors the epoll_sockets design for behavioral consistency.

    This mirrors the epoll_sockets design for behavioral consistency.

    Each I/O operation follows the same pattern:

    Each I/O operation follows the same pattern:

      1. Try the syscall immediately (non-blocking socket)

      1. Try the syscall immediately (non-blocking socket)

      2. If it succeeds or fails with a real error, post to completion queue

      2. If it succeeds or fails with a real error, post to completion queue

      3. If EAGAIN/EWOULDBLOCK, register with select scheduler and wait

      3. If EAGAIN/EWOULDBLOCK, register with select scheduler and wait

    Cancellation

    Cancellation

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

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

    See op.hpp for the completion/cancellation race handling via the

    See op.hpp for the completion/cancellation race handling via the

    `registered` atomic. cancel() must complete pending operations (post

    `registered` atomic. cancel() must complete pending operations (post

    them with cancelled flag) so coroutines waiting on them can resume.

    them with cancelled flag) so coroutines waiting on them can resume.

    close_socket() calls cancel() first to ensure this.

    close_socket() calls cancel() first to ensure this.

    Impl Lifetime with shared_ptr

    Impl Lifetime with shared_ptr

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

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

    Socket impls use enable_shared_from_this. The service owns impls via

    Socket impls use enable_shared_from_this. The service owns impls via

    shared_ptr maps (socket_ptrs_) keyed by raw pointer for O(1) lookup and

    shared_ptr maps (socket_ptrs_) keyed by raw pointer for O(1) lookup and

    removal. When a user calls close(), we call cancel() which posts pending

    removal. When a user calls close(), we call cancel() which posts pending

    ops to the scheduler.

    ops to the scheduler.

    CRITICAL: The posted ops must keep the impl alive until they complete.

    CRITICAL: The posted ops must keep the impl alive until they complete.

    Otherwise the scheduler would process a freed op (use-after-free). The

    Otherwise the scheduler would process a freed op (use-after-free). The

    cancel() method captures shared_from_this() into op.impl_ptr before

    cancel() method captures shared_from_this() into op.impl_ptr before

    posting. When the op completes, impl_ptr is cleared, allowing the impl

    posting. When the op completes, impl_ptr is cleared, allowing the impl

    to be destroyed if no other references exist.

    to be destroyed if no other references exist.

    Service Ownership

    Service Ownership

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

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

    select_socket_service owns all socket impls. destroy() removes the

    select_socket_service owns all socket impls. destroy() removes the

    shared_ptr from the map, but the impl may survive if ops still hold

    shared_ptr from the map, but the impl may survive if ops still hold

    impl_ptr refs. shutdown() closes all sockets and clears the map; any

    impl_ptr refs. shutdown() closes all sockets and clears the map; any

    in-flight ops will complete and release their refs.

    in-flight ops will complete and release their refs.

*/

*/

namespace boost::corosio::detail {

namespace boost::corosio::detail {

/** State for select socket service. */

/** State for select socket service. */

class select_socket_state

class select_socket_state

{

{

public:

public:

    {

    {

    select_scheduler& sched_;

    select_scheduler& sched_;

    std::mutex mutex_;

    std::mutex mutex_;

    intrusive_list<select_socket> socket_list_;

    intrusive_list<select_socket> socket_list_;

    std::unordered_map<select_socket*, std::shared_ptr<select_socket>>

    std::unordered_map<select_socket*, std::shared_ptr<select_socket>>

        socket_ptrs_;

        socket_ptrs_;

};

};

/** select socket service implementation.

/** select socket service implementation.

    Inherits from socket_service to enable runtime polymorphism.

    Inherits from socket_service to enable runtime polymorphism.

    Uses key_type = socket_service for service lookup.

    Uses key_type = socket_service for service lookup.

*/

*/

class BOOST_COROSIO_DECL select_socket_service final : public socket_service

class BOOST_COROSIO_DECL select_socket_service final : public socket_service

{

{

public:

public:

    explicit select_socket_service(capy::execution_context& ctx);

    explicit select_socket_service(capy::execution_context& ctx);

    ~select_socket_service() override;

    ~select_socket_service() override;

    select_socket_service(select_socket_service const&)            = delete;

    select_socket_service(select_socket_service const&)            = delete;

    select_socket_service& operator=(select_socket_service const&) = delete;

    select_socket_service& operator=(select_socket_service const&) = delete;

    void shutdown() override;

    void shutdown() override;

    io_object::implementation* construct() override;

    io_object::implementation* construct() override;

    void destroy(io_object::implementation*) override;

    void destroy(io_object::implementation*) override;

    void close(io_object::handle&) override;

    void close(io_object::handle&) override;

    std::error_code

    std::error_code open_socket(

    open_socket(tcp_socket::implementation& impl,

        tcp_socket::implementation& impl,

                int family, int type, int protocol) override;

        int family,

        int type,

        int protocol) override;

    {

    {

    }

    }

    void post(select_op* op);

    void post(select_op* op);

    void work_started() noexcept;

    void work_started() noexcept;

    void work_finished() noexcept;

    void work_finished() noexcept;

private:

private:

    std::unique_ptr<select_socket_state> state_;

    std::unique_ptr<select_socket_state> state_;

};

};

// Backward compatibility alias

// Backward compatibility alias

using select_sockets = select_socket_service;

using select_sockets = select_socket_service;

inline void

inline void

{

{

inline void

inline void

{

{

    else

    else

inline void

inline void

{

{

    else

    else

inline void

inline void

{

{

    else

    else

inline void

inline void

{

{

    // Cache endpoints on successful connect

    // Cache endpoints on successful connect

    {

    {

    }

    }

    {

    {

        else

        else

    }

    }

    // Move to stack before destroying the frame

    // Move to stack before destroying the frame

{

{

inline std::coroutine_handle<>

inline std::coroutine_handle<>

    std::coroutine_handle<> h,

    std::coroutine_handle<> h,

    capy::executor_ref ex,

    capy::executor_ref ex,

    endpoint ep,

    endpoint ep,

    std::stop_token token,

    std::stop_token token,

    std::error_code* ec)

    std::error_code* ec)

{

{

    socklen_t addrlen =

    socklen_t addrlen =

    {

    {

        // Sync success — cache endpoints immediately

        // Sync success — cache endpoints immediately

        // completion is always posted to scheduler queue, never inline.

        // completion is always posted to scheduler queue, never inline.

    }

    }

    {

    {

        // Set registering BEFORE register_fd to close the race window where

        // Set registering BEFORE register_fd to close the race window where

        // reactor sees an event before we set registered. The reactor treats

        // reactor sees an event before we set registered. The reactor treats

        // registering the same as registered when claiming the op.

        // registering the same as registered when claiming the op.

            select_registration_state::registering, std::memory_order_release);

            select_registration_state::registering, std::memory_order_release);

        // Transition to registered. If this fails, reactor or cancel already

        // Transition to registered. If this fails, reactor or cancel already

        // claimed the op (state is now unregistered), so we're done. However,

        // claimed the op (state is now unregistered), so we're done. However,

        // we must still deregister the fd because cancel's deregister_fd may

        // we must still deregister the fd because cancel's deregister_fd may

        // have run before our register_fd, leaving the fd orphaned.

        // have run before our register_fd, leaving the fd orphaned.

                expected, select_registration_state::registered,

                expected, select_registration_state::registered,

                std::memory_order_acq_rel))

                std::memory_order_acq_rel))

        {

        {

            // completion is always posted to scheduler queue, never inline.

            // completion is always posted to scheduler queue, never inline.

        }

        }

        // If cancelled was set before we registered, handle it now.

        // If cancelled was set before we registered, handle it now.

        {

        {

                select_registration_state::unregistered,

                select_registration_state::unregistered,

                std::memory_order_acq_rel);

                std::memory_order_acq_rel);

            {

            {

                    fd_, select_scheduler::event_write);

                    fd_, select_scheduler::event_write);

            }

            }

        }

        }

        // completion is always posted to scheduler queue, never inline.

        // completion is always posted to scheduler queue, never inline.

    }

    }

    // completion is always posted to scheduler queue, never inline.

    // completion is always posted to scheduler queue, never inline.

}

}

inline std::coroutine_handle<>

inline std::coroutine_handle<>

    std::coroutine_handle<> h,

    std::coroutine_handle<> h,

    capy::executor_ref ex,

    capy::executor_ref ex,

    io_buffer_param param,

    buffer_param param,

    std::stop_token token,

    std::stop_token token,

    std::error_code* ec,

    std::error_code* ec,

    std::size_t* bytes_out)

    std::size_t* bytes_out)

{

{

    {

    {

    }

    }

    {

    {

    }

    }

    {

    {

    }

    }

    {

    {

    }

    }

    {

    {

        // Set registering BEFORE register_fd to close the race window where

        // Set registering BEFORE register_fd to close the race window where

        // reactor sees an event before we set registered.

        // reactor sees an event before we set registered.

            select_registration_state::registering, std::memory_order_release);

            select_registration_state::registering, std::memory_order_release);

        // Transition to registered. If this fails, reactor or cancel already

        // Transition to registered. If this fails, reactor or cancel already

        // claimed the op (state is now unregistered), so we're done. However,

        // claimed the op (state is now unregistered), so we're done. However,

        // we must still deregister the fd because cancel's deregister_fd may

        // we must still deregister the fd because cancel's deregister_fd may

        // have run before our register_fd, leaving the fd orphaned.

        // have run before our register_fd, leaving the fd orphaned.

                expected, select_registration_state::registered,

                expected, select_registration_state::registered,

                std::memory_order_acq_rel))

                std::memory_order_acq_rel))

        {

        {

        }

        }

        // If cancelled was set before we registered, handle it now.

        // If cancelled was set before we registered, handle it now.

        {

        {

                select_registration_state::unregistered,

                select_registration_state::unregistered,

                std::memory_order_acq_rel);

                std::memory_order_acq_rel);

            {

            {

                    fd_, select_scheduler::event_read);

                    fd_, select_scheduler::event_read);

            }

            }

        }

        }

    }

    }

}

}

inline std::coroutine_handle<>

inline std::coroutine_handle<>

    std::coroutine_handle<> h,

    std::coroutine_handle<> h,

    capy::executor_ref ex,

    capy::executor_ref ex,

    io_buffer_param param,

    buffer_param param,

    std::stop_token token,

    std::stop_token token,

    std::error_code* ec,

    std::error_code* ec,

    std::size_t* bytes_out)

    std::size_t* bytes_out)

{

{

    {

    {

    }

    }

    {

    {

    }

    }

    {

    {

    }

    }

    {

    {

        // Set registering BEFORE register_fd to close the race window where

        // Set registering BEFORE register_fd to close the race window where

        // reactor sees an event before we set registered.

        // reactor sees an event before we set registered.

            select_registration_state::registering, std::memory_order_release);

            select_registration_state::registering, std::memory_order_release);

        // Transition to registered. If this fails, reactor or cancel already

        // Transition to registered. If this fails, reactor or cancel already

        // claimed the op (state is now unregistered), so we're done. However,

        // claimed the op (state is now unregistered), so we're done. However,

        // we must still deregister the fd because cancel's deregister_fd may

        // we must still deregister the fd because cancel's deregister_fd may

        // have run before our register_fd, leaving the fd orphaned.

        // have run before our register_fd, leaving the fd orphaned.

                expected, select_registration_state::registered,

                expected, select_registration_state::registered,

                std::memory_order_acq_rel))

                std::memory_order_acq_rel))

        {

        {

        }

        }

        // If cancelled was set before we registered, handle it now.

        // If cancelled was set before we registered, handle it now.

        {

        {

                select_registration_state::unregistered,

                select_registration_state::unregistered,

                std::memory_order_acq_rel);

                std::memory_order_acq_rel);

            {

            {

                    fd_, select_scheduler::event_write);

                    fd_, select_scheduler::event_write);

            }

            }

        }

        }

    }

    }

}

}

inline std::error_code

inline std::error_code

{

{

    int how;

    int how;

    {

    {

    }

    }

}

}