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 12 : impl_type& get_impl() noexcept
68 : {
69 12 : 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 : struct native_accept_value_awaitable
145 : {
146 : native_tcp_acceptor& acc_;
147 : tcp_socket peer_;
148 : std::stop_token token_;
149 : mutable std::error_code ec_;
150 : mutable io_object::implementation* peer_impl_ = nullptr;
151 :
152 2 : explicit native_accept_value_awaitable(native_tcp_acceptor& acc)
153 2 : : acc_(acc)
154 2 : , peer_(acc.context())
155 : {
156 2 : }
157 :
158 2 : bool await_ready() const noexcept
159 : {
160 2 : return token_.stop_requested();
161 : }
162 :
163 2 : capy::io_result<tcp_socket> await_resume() noexcept
164 : {
165 2 : if (token_.stop_requested())
166 MIS 0 : return {make_error_code(std::errc::operation_canceled),
167 0 : std::move(peer_)};
168 HIT 2 : if (!ec_ && peer_impl_)
169 2 : acc_.reset_peer_impl(peer_, peer_impl_);
170 2 : return {ec_, std::move(peer_)};
171 : }
172 :
173 2 : auto await_suspend(std::coroutine_handle<> h, capy::io_env const* env)
174 : -> std::coroutine_handle<>
175 : {
176 2 : token_ = env->stop_token;
177 6 : return acc_.get_impl().accept(
178 6 : h, env->executor, token_, &ec_, &peer_impl_);
179 : }
180 : };
181 :
182 : public:
183 : /** Construct a native acceptor from an execution context.
184 :
185 : @param ctx The execution context that will own this acceptor.
186 : */
187 20 : explicit native_tcp_acceptor(capy::execution_context& ctx)
188 20 : : tcp_acceptor(create_handle<service_type>(ctx))
189 : {
190 20 : }
191 :
192 : /** Construct a native acceptor from an executor.
193 :
194 : @param ex The executor whose context will own the acceptor.
195 : */
196 : template<class Ex>
197 : requires(!std::same_as<std::remove_cvref_t<Ex>, native_tcp_acceptor>) &&
198 : capy::Executor<Ex>
199 : explicit native_tcp_acceptor(Ex const& ex)
200 : : native_tcp_acceptor(ex.context())
201 : {
202 : }
203 :
204 : /** Move construct.
205 :
206 : @param other The acceptor to move from.
207 :
208 : @pre No awaitables returned by @p other's methods exist.
209 : @pre The execution context associated with @p other must
210 : outlive this acceptor.
211 : */
212 2 : native_tcp_acceptor(native_tcp_acceptor&&) noexcept = default;
213 :
214 : /** Move assign.
215 :
216 : @param other The acceptor to move from.
217 :
218 : @pre No awaitables returned by either `*this` or @p other's
219 : methods exist.
220 : @pre The execution context associated with @p other must
221 : outlive this acceptor.
222 : */
223 : native_tcp_acceptor& operator=(native_tcp_acceptor&&) noexcept = default;
224 :
225 : native_tcp_acceptor(native_tcp_acceptor const&) = delete;
226 : native_tcp_acceptor& operator=(native_tcp_acceptor const&) = delete;
227 :
228 : /** Asynchronously accept an incoming connection.
229 :
230 : Calls the backend implementation directly, bypassing virtual
231 : dispatch. Otherwise identical to @ref tcp_acceptor::accept.
232 :
233 : @param peer The socket to receive the accepted connection.
234 :
235 : @return An awaitable yielding `io_result<>`.
236 :
237 : @throws std::logic_error if the acceptor is not listening.
238 :
239 : Both this acceptor and @p peer must outlive the returned
240 : awaitable.
241 : */
242 8 : auto accept(tcp_socket& peer)
243 : {
244 8 : if (!is_open())
245 MIS 0 : detail::throw_logic_error("accept: acceptor not listening");
246 HIT 8 : return native_accept_awaitable(*this, peer);
247 : }
248 :
249 : /** Asynchronously accept an incoming connection, returning the peer.
250 :
251 : Calls the backend implementation directly, bypassing virtual
252 : dispatch. Otherwise identical to @ref tcp_acceptor::accept().
253 :
254 : @return An awaitable yielding `io_result<tcp_socket>`.
255 :
256 : @throws std::logic_error if the acceptor is not listening.
257 :
258 : This acceptor must outlive the returned awaitable.
259 : */
260 2 : auto accept()
261 : {
262 2 : if (!is_open())
263 MIS 0 : detail::throw_logic_error("accept: acceptor not listening");
264 HIT 2 : return native_accept_value_awaitable(*this);
265 : }
266 :
267 : /** Asynchronously wait for the acceptor to be ready.
268 :
269 : Calls the backend implementation directly, bypassing virtual
270 : dispatch. Otherwise identical to @ref tcp_acceptor::wait.
271 :
272 : @param w The wait direction (typically `wait_type::read`).
273 :
274 : @return An awaitable yielding `io_result<>`.
275 : */
276 2 : [[nodiscard]] auto wait(wait_type w)
277 : {
278 2 : return native_wait_awaitable(*this, w);
279 : }
280 : };
281 :
282 : } // namespace boost::corosio
283 :
284 : #endif
|
