Diff coverage report for

//

// Copyright (c) 2026 Steve Gerbino

//

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

//

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

//

#ifndef BOOST_COROSIO_NATIVE_DETAIL_EPOLL_EPOLL_SOCKET_SERVICE_HPP

#define BOOST_COROSIO_NATIVE_DETAIL_EPOLL_EPOLL_SOCKET_SERVICE_HPP

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

#if BOOST_COROSIO_HAS_EPOLL

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

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

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

#include <boost/corosio/native/detail/epoll/epoll_socket.hpp>

#include <boost/corosio/native/detail/epoll/epoll_scheduler.hpp>

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

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

#include <coroutine>

#include <mutex>

#include <utility>

#include <errno.h>

#include <netinet/in.h>

#include <netinet/tcp.h>

#include <sys/epoll.h>

#include <sys/socket.h>

#include <unistd.h>

/*

    epoll Socket Implementation

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

    Each I/O operation follows the same pattern:

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

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

      3. If EAGAIN/EWOULDBLOCK, register with epoll and wait

    This "try first" approach avoids unnecessary epoll round-trips for

    operations that can complete immediately (common for small reads/writes

    on fast local connections).

    One-Shot Registration

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

    We use one-shot epoll registration: each operation registers, waits for

    one event, then unregisters. This simplifies the state machine since we

    don't need to track whether an fd is currently registered or handle

    re-arming. The tradeoff is slightly more epoll_ctl calls, but the

    simplicity is worth it.

    Cancellation

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

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

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

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

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

    Impl Lifetime with shared_ptr

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

    Socket impls use enable_shared_from_this. The service owns impls via

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

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

    ops to the scheduler.

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

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

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

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

    to be destroyed if no other references exist.

    Service Ownership

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

    epoll_socket_service owns all socket impls. destroy_impl() removes the

    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

    in-flight ops will complete and release their refs.

*/

namespace boost::corosio::detail {

/// State for epoll socket service.

using epoll_socket_state = reactor_service_state<epoll_scheduler, epoll_socket>;

/** epoll socket service implementation.

    Inherits from socket_service to enable runtime polymorphism.

    Uses key_type = socket_service for service lookup.

*/

class BOOST_COROSIO_DECL epoll_socket_service final : public socket_service

{

public:

    explicit epoll_socket_service(capy::execution_context& ctx);

    ~epoll_socket_service() override;

    epoll_socket_service(epoll_socket_service const&)            = delete;

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

    void shutdown() override;

    io_object::implementation* construct() override;

    void destroy(io_object::implementation*) override;

    void close(io_object::handle&) override;

    std::error_code open_socket(

        tcp_socket::implementation& impl,

        int family,

        int type,

        int protocol) override;

    {

    }

    void post(scheduler_op* op);

    void work_started() noexcept;

    void work_finished() noexcept;

private:

    std::unique_ptr<epoll_socket_state> state_;

};

inline void

{

    else

inline void

{

    else

inline void

{

    else

inline void

{

inline void

{

{

inline std::coroutine_handle<>

    std::coroutine_handle<> h,

    capy::executor_ref ex,

    endpoint ep,

    std::stop_token token,

    std::error_code* ec)

{

}

inline std::coroutine_handle<>

    std::coroutine_handle<> h,

    capy::executor_ref ex,

    buffer_param param,

    std::stop_token token,

    std::error_code* ec,

    std::size_t* bytes_out)

{

}

inline std::coroutine_handle<>

    std::coroutine_handle<> h,

    capy::executor_ref ex,

    buffer_param param,

    std::stop_token token,

    std::error_code* ec,

    std::size_t* bytes_out)

{

}

inline void

{

inline void

{

          std::make_unique<epoll_socket_state>(

{

inline void

{

    // Don't clear impl_ptrs_ here. The scheduler shuts down after us and

    // drains completed_ops_, calling destroy() on each queued op. If we

    // released our shared_ptrs now, an epoll_op::destroy() could free the

    // last ref to an impl whose embedded descriptor_state is still linked

    // in the queue — use-after-free on the next pop(). Letting ~state_

    // release the ptrs (during service destruction, after scheduler

    // shutdown) keeps every impl alive until all ops have been drained.

inline io_object::implementation*

{

    {

inline void

{

inline std::error_code

    tcp_socket::implementation& impl, int family, int type, int protocol)

{

    {

    }

    // Register fd with epoll (edge-triggered mode)

    {

}

inline void

{

inline void

{

inline void

{

inline void

{

} // namespace boost::corosio::detail

#endif // BOOST_COROSIO_HAS_EPOLL

#endif // BOOST_COROSIO_NATIVE_DETAIL_EPOLL_EPOLL_SOCKET_SERVICE_HPP