TLA 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_NATIVE_NATIVE_TCP_ACCEPTOR_HPP
11 : #define BOOST_COROSIO_NATIVE_NATIVE_TCP_ACCEPTOR_HPP
12 :
13 : #include <boost/corosio/tcp_acceptor.hpp>
14 : #include <boost/corosio/backend.hpp>
15 :
16 : #ifndef BOOST_COROSIO_MRDOCS
17 : #if BOOST_COROSIO_HAS_EPOLL
18 : #include <boost/corosio/native/detail/epoll/epoll_types.hpp>
19 : #endif
20 :
21 : #if BOOST_COROSIO_HAS_SELECT
22 : #include <boost/corosio/native/detail/select/select_types.hpp>
23 : #endif
24 :
25 : #if BOOST_COROSIO_HAS_KQUEUE
26 : #include <boost/corosio/native/detail/kqueue/kqueue_types.hpp>
27 : #endif
28 :
29 : #if BOOST_COROSIO_HAS_IOCP
30 : #include <boost/corosio/native/detail/iocp/win_tcp_acceptor_service.hpp>
31 : #endif
32 :
33 : #if BOOST_COROSIO_HAS_IO_URING
34 : #include <boost/corosio/native/detail/io_uring/io_uring_types.hpp>
35 : #endif
36 : #endif // !BOOST_COROSIO_MRDOCS
37 :
38 : namespace boost::corosio {
39 :
40 : /** An asynchronous TCP acceptor with devirtualized accept operations.
41 :
42 : This class template inherits from @ref tcp_acceptor and shadows
43 : the `accept` operation with a version that calls the backend
44 : implementation directly, allowing the compiler to inline through
45 : the entire call chain.
46 :
47 : Non-async operations (`listen`, `close`, `cancel`) remain
48 : unchanged and dispatch through the compiled library.
49 :
50 : A `native_tcp_acceptor` IS-A `tcp_acceptor` and can be passed
51 : to any function expecting `tcp_acceptor&`.
52 :
53 : @tparam Backend A backend tag value (e.g., `epoll`).
54 :
55 : @par Thread Safety
56 : Same as @ref tcp_acceptor.
57 :
58 : @see tcp_acceptor, epoll_t, iocp_t
59 : */
60 : template<auto Backend>
61 : class native_tcp_acceptor : public tcp_acceptor
62 : {
63 : using backend_type = decltype(Backend);
64 : using impl_type = typename backend_type::tcp_acceptor_type;
65 : using service_type = typename backend_type::tcp_acceptor_service_type;
66 :
67 HIT 10 : impl_type& get_impl() noexcept
68 : {
69 10 : return *static_cast<impl_type*>(h_.get());
70 : }
71 :
72 : struct native_wait_awaitable
73 : {
74 : native_tcp_acceptor& acc_;
75 : wait_type w_;
76 : std::stop_token token_;
77 : mutable std::error_code ec_;
78 :
79 2 : native_wait_awaitable(native_tcp_acceptor& acc, wait_type w) noexcept
80 2 : : acc_(acc)
81 2 : , w_(w)
82 : {
83 2 : }
84 :
85 2 : bool await_ready() const noexcept
86 : {
87 2 : return token_.stop_requested();
88 : }
89 :
90 2 : capy::io_result<> await_resume() const noexcept
91 : {
92 2 : if (token_.stop_requested())
93 MIS 0 : return {make_error_code(std::errc::operation_canceled)};
94 HIT 2 : return {ec_};
95 : }
96 :
97 2 : auto await_suspend(std::coroutine_handle<> h, capy::io_env const* env)
98 : -> std::coroutine_handle<>
99 : {
100 2 : token_ = env->stop_token;
101 6 : return acc_.get_impl().wait(
102 6 : h, env->executor, w_, token_, &ec_);
103 : }
104 : };
105 :
106 : struct native_accept_awaitable
107 : {
108 : native_tcp_acceptor& acc_;
109 : tcp_socket& peer_;
110 : std::stop_token token_;
111 : mutable std::error_code ec_;
112 : mutable io_object::implementation* peer_impl_ = nullptr;
113 :
114 8 : native_accept_awaitable(
115 : native_tcp_acceptor& acc, tcp_socket& peer) noexcept
116 8 : : acc_(acc)
117 8 : , peer_(peer)
118 : {
119 8 : }
120 :
121 8 : bool await_ready() const noexcept
122 : {
123 8 : return token_.stop_requested();
124 : }
125 :
126 8 : capy::io_result<> await_resume() const noexcept
127 : {
128 8 : if (token_.stop_requested())
129 MIS 0 : return {make_error_code(std::errc::operation_canceled)};
130 HIT 8 : if (!ec_)
131 8 : acc_.reset_peer_impl(peer_, peer_impl_);
132 8 : return {ec_};
133 : }
134 :
135 8 : auto await_suspend(std::coroutine_handle<> h, capy::io_env const* env)
136 : -> std::coroutine_handle<>
137 : {
138 8 : token_ = env->stop_token;
139 24 : return acc_.get_impl().accept(
140 24 : h, env->executor, token_, &ec_, &peer_impl_);
141 : }
142 : };
143 :
144 : public:
145 : /** Construct a native acceptor from an execution context.
146 :
147 : @param ctx The execution context that will own this acceptor.
148 : */
149 18 : explicit native_tcp_acceptor(capy::execution_context& ctx)
150 18 : : tcp_acceptor(create_handle<service_type>(ctx))
151 : {
152 18 : }
153 :
154 : /** Construct a native acceptor from an executor.
155 :
156 : @param ex The executor whose context will own the acceptor.
157 : */
158 : template<class Ex>
159 : requires(!std::same_as<std::remove_cvref_t<Ex>, native_tcp_acceptor>) &&
160 : capy::Executor<Ex>
161 : explicit native_tcp_acceptor(Ex const& ex)
162 : : native_tcp_acceptor(ex.context())
163 : {
164 : }
165 :
166 : /** Move construct.
167 :
168 : @param other The acceptor to move from.
169 :
170 : @pre No awaitables returned by @p other's methods exist.
171 : @pre The execution context associated with @p other must
172 : outlive this acceptor.
173 : */
174 2 : native_tcp_acceptor(native_tcp_acceptor&&) noexcept = default;
175 :
176 : /** Move assign.
177 :
178 : @param other The acceptor to move from.
179 :
180 : @pre No awaitables returned by either `*this` or @p other's
181 : methods exist.
182 : @pre The execution context associated with @p other must
183 : outlive this acceptor.
184 : */
185 : native_tcp_acceptor& operator=(native_tcp_acceptor&&) noexcept = default;
186 :
187 : native_tcp_acceptor(native_tcp_acceptor const&) = delete;
188 : native_tcp_acceptor& operator=(native_tcp_acceptor const&) = delete;
189 :
190 : /** Asynchronously accept an incoming connection.
191 :
192 : Calls the backend implementation directly, bypassing virtual
193 : dispatch. Otherwise identical to @ref tcp_acceptor::accept.
194 :
195 : @param peer The socket to receive the accepted connection.
196 :
197 : @return An awaitable yielding `io_result<>`.
198 :
199 : @throws std::logic_error if the acceptor is not listening.
200 :
201 : Both this acceptor and @p peer must outlive the returned
202 : awaitable.
203 : */
204 8 : auto accept(tcp_socket& peer)
205 : {
206 8 : if (!is_open())
207 MIS 0 : detail::throw_logic_error("accept: acceptor not listening");
208 HIT 8 : return native_accept_awaitable(*this, peer);
209 : }
210 :
211 : /** Asynchronously wait for the acceptor to be ready.
212 :
213 : Calls the backend implementation directly, bypassing virtual
214 : dispatch. Otherwise identical to @ref tcp_acceptor::wait.
215 :
216 : @param w The wait direction (typically `wait_type::read`).
217 :
218 : @return An awaitable yielding `io_result<>`.
219 : */
220 2 : [[nodiscard]] auto wait(wait_type w)
221 : {
222 2 : return native_wait_awaitable(*this, w);
223 : }
224 : };
225 :
226 : } // namespace boost::corosio
227 :
228 : #endif
|
