Line data    Source code

       1              : //
       2              : // Copyright (c) 2026 Steve Gerbino
       3              : //
       4              : // Distributed under the Boost Software License, Version 1.0. (See accompanying
       5              : // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
       6              : //
       7              : // Official repository: https://github.com/cppalliance/corosio
       8              : //
       9              : 
      10              : #ifndef BOOST_COROSIO_DETAIL_EPOLL_ACCEPTORS_HPP
      11              : #define BOOST_COROSIO_DETAIL_EPOLL_ACCEPTORS_HPP
      12              : 
      13              : #include <boost/corosio/detail/platform.hpp>
      14              : 
      15              : #if BOOST_COROSIO_HAS_EPOLL
      16              : 
      17              : #include <boost/corosio/detail/config.hpp>
      18              : #include <boost/corosio/tcp_acceptor.hpp>
      19              : #include <boost/capy/ex/executor_ref.hpp>
      20              : #include <boost/capy/ex/execution_context.hpp>
      21              : #include "src/detail/intrusive.hpp"
      22              : #include "src/detail/socket_service.hpp"
      23              : 
      24              : #include "src/detail/epoll/op.hpp"
      25              : #include "src/detail/epoll/scheduler.hpp"
      26              : 
      27              : #include <memory>
      28              : #include <mutex>
      29              : #include <unordered_map>
      30              : 
      31              : namespace boost::corosio::detail {
      32              : 
      33              : class epoll_acceptor_service;
      34              : class epoll_acceptor_impl;
      35              : class epoll_socket_service;
      36              : 
      37              : /// Acceptor implementation for epoll backend.
      38              : class epoll_acceptor_impl
      39              :     : public tcp_acceptor::acceptor_impl
      40              :     , public std::enable_shared_from_this<epoll_acceptor_impl>
      41              :     , public intrusive_list<epoll_acceptor_impl>::node
      42              : {
      43              :     friend class epoll_acceptor_service;
      44              : 
      45              : public:
      46              :     explicit epoll_acceptor_impl(epoll_acceptor_service& svc) noexcept;
      47              : 
      48              :     void release() override;
      49              : 
      50              :     std::coroutine_handle<> accept(
      51              :         std::coroutine_handle<>,
      52              :         capy::executor_ref,
      53              :         std::stop_token,
      54              :         std::error_code*,
      55              :         io_object::io_object_impl**) override;
      56              : 
      57              :     int native_handle() const noexcept { return fd_; }
      58           12 :     endpoint local_endpoint() const noexcept override { return local_endpoint_; }
      59              :     bool is_open() const noexcept { return fd_ >= 0; }
      60              :     void cancel() noexcept override;
      61              :     void cancel_single_op(epoll_op& op) noexcept;
      62              :     void close_socket() noexcept;
      63           62 :     void set_local_endpoint(endpoint ep) noexcept { local_endpoint_ = ep; }
      64              : 
      65         5017 :     epoll_acceptor_service& service() noexcept { return svc_; }
      66              : 
      67              :     epoll_accept_op acc_;
      68              :     descriptor_state desc_state_;
      69              : 
      70              : private:
      71              :     epoll_acceptor_service& svc_;
      72              :     int fd_ = -1;
      73              :     endpoint local_endpoint_;
      74              : };
      75              : 
      76              : /** State for epoll acceptor service. */
      77              : class epoll_acceptor_state
      78              : {
      79              : public:
      80          189 :     explicit epoll_acceptor_state(epoll_scheduler& sched) noexcept
      81          189 :         : sched_(sched)
      82              :     {
      83          189 :     }
      84              : 
      85              :     epoll_scheduler& sched_;
      86              :     std::mutex mutex_;
      87              :     intrusive_list<epoll_acceptor_impl> acceptor_list_;
      88              :     std::unordered_map<epoll_acceptor_impl*, std::shared_ptr<epoll_acceptor_impl>> acceptor_ptrs_;
      89              : };
      90              : 
      91              : /** epoll acceptor service implementation.
      92              : 
      93              :     Inherits from acceptor_service to enable runtime polymorphism.
      94              :     Uses key_type = acceptor_service for service lookup.
      95              : */
      96              : class epoll_acceptor_service : public acceptor_service
      97              : {
      98              : public:
      99              :     explicit epoll_acceptor_service(capy::execution_context& ctx);
     100              :     ~epoll_acceptor_service();
     101              : 
     102              :     epoll_acceptor_service(epoll_acceptor_service const&) = delete;
     103              :     epoll_acceptor_service& operator=(epoll_acceptor_service const&) = delete;
     104              : 
     105              :     void shutdown() override;
     106              : 
     107              :     tcp_acceptor::acceptor_impl& create_acceptor_impl() override;
     108              :     void destroy_acceptor_impl(tcp_acceptor::acceptor_impl& impl) override;
     109              :     std::error_code open_acceptor(
     110              :         tcp_acceptor::acceptor_impl& impl,
     111              :         endpoint ep,
     112              :         int backlog) override;
     113              : 
     114          124 :     epoll_scheduler& scheduler() const noexcept { return state_->sched_; }
     115              :     void post(epoll_op* op);
     116              :     void work_started() noexcept;
     117              :     void work_finished() noexcept;
     118              : 
     119              :     /** Get the socket service for creating peer sockets during accept. */
     120              :     epoll_socket_service* socket_service() const noexcept;
     121              : 
     122              : private:
     123              :     capy::execution_context& ctx_;
     124              :     std::unique_ptr<epoll_acceptor_state> state_;
     125              : };
     126              : 
     127              : } // namespace boost::corosio::detail
     128              : 
     129              : #endif // BOOST_COROSIO_HAS_EPOLL
     130              : 
     131              : #endif // BOOST_COROSIO_DETAIL_EPOLL_ACCEPTORS_HPP