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_TCP_SERVICE_HPP

#define BOOST_COROSIO_NATIVE_DETAIL_EPOLL_EPOLL_TCP_SERVICE_HPP

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

#if BOOST_COROSIO_HAS_EPOLL

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

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

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

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

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

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

#include <coroutine>

#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_tcp_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 {

/** epoll TCP service implementation.

    Inherits from tcp_service to enable runtime polymorphism.

    Uses key_type = tcp_service for service lookup.

*/

class BOOST_COROSIO_DECL epoll_tcp_service final

    : public reactor_socket_service<

          epoll_tcp_service,

          tcp_service,

          epoll_scheduler,

          epoll_tcp_socket>

{

public:

    {

    std::error_code open_socket(

        tcp_socket::implementation& impl,

        int family,

        int type,

        int protocol) override;

    std::error_code

    bind_socket(tcp_socket::implementation& impl, endpoint ep) override;

};

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

{

inline std::error_code

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

{

    {

    }

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

    {

}

inline std::error_code

    tcp_socket::implementation& impl, endpoint ep)

{

}

} // namespace boost::corosio::detail

#endif // BOOST_COROSIO_HAS_EPOLL

#endif // BOOST_COROSIO_NATIVE_DETAIL_EPOLL_EPOLL_TCP_SERVICE_HPP