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_LOCAL_STREAM_ACCEPTOR_HPP
11 : #define BOOST_COROSIO_NATIVE_NATIVE_LOCAL_STREAM_ACCEPTOR_HPP
12 :
13 : #include <boost/corosio/local_stream_acceptor.hpp>
14 : #include <boost/corosio/native/native_local_stream_socket.hpp>
15 : #include <boost/corosio/backend.hpp>
16 :
17 : #ifndef BOOST_COROSIO_MRDOCS
18 : #if BOOST_COROSIO_HAS_EPOLL
19 : #include <boost/corosio/native/detail/epoll/epoll_types.hpp>
20 : #endif
21 :
22 : #if BOOST_COROSIO_HAS_SELECT
23 : #include <boost/corosio/native/detail/select/select_types.hpp>
24 : #endif
25 :
26 : #if BOOST_COROSIO_HAS_KQUEUE
27 : #include <boost/corosio/native/detail/kqueue/kqueue_types.hpp>
28 : #endif
29 :
30 : #if BOOST_COROSIO_HAS_IO_URING
31 : #include <boost/corosio/native/detail/io_uring/io_uring_types.hpp>
32 : #endif
33 :
34 : #if BOOST_COROSIO_HAS_IOCP
35 : #include <boost/corosio/native/detail/iocp/win_local_stream_acceptor_service.hpp>
36 : #endif
37 : #endif // !BOOST_COROSIO_MRDOCS
38 :
39 : namespace boost::corosio {
40 :
41 : /** An asynchronous Unix stream acceptor with devirtualized accept.
42 :
43 : This class template inherits from @ref local_stream_acceptor
44 : and shadows both `accept` overloads (the peer-reference form
45 : and the move-return form) with versions that call the backend
46 : implementation directly, allowing the compiler to inline
47 : through the entire call chain. The move-return form yields a
48 : @ref native_local_stream_socket so subsequent I/O on the peer
49 : is also devirtualized.
50 :
51 : Non-async operations (`listen`, `close`, `cancel`) remain
52 : unchanged and dispatch through the compiled library.
53 :
54 : A `native_local_stream_acceptor` IS-A `local_stream_acceptor`
55 : and can be passed to any function expecting
56 : `local_stream_acceptor&`.
57 :
58 : @tparam Backend A backend tag value (e.g., `epoll`).
59 :
60 : @par Thread Safety
61 : Same as @ref local_stream_acceptor.
62 :
63 : @see local_stream_acceptor, epoll_t, iocp_t
64 : */
65 : template<auto Backend>
66 : class native_local_stream_acceptor : public local_stream_acceptor
67 : {
68 : using backend_type = decltype(Backend);
69 : using impl_type = typename backend_type::local_stream_acceptor_type;
70 : using service_type =
71 : typename backend_type::local_stream_acceptor_service_type;
72 :
73 HIT 10 : impl_type& get_impl() noexcept
74 : {
75 10 : return *static_cast<impl_type*>(h_.get());
76 : }
77 :
78 : struct native_wait_awaitable
79 : {
80 : native_local_stream_acceptor& acc_;
81 : wait_type w_;
82 : std::stop_token token_;
83 : mutable std::error_code ec_;
84 :
85 4 : native_wait_awaitable(
86 : native_local_stream_acceptor& acc, wait_type w) noexcept
87 4 : : acc_(acc)
88 4 : , w_(w)
89 : {
90 4 : }
91 :
92 4 : bool await_ready() const noexcept
93 : {
94 : // A pre-set ec_ means the initiator failed before
95 : // dispatch (e.g. a closed object).
96 4 : return static_cast<bool>(ec_) || token_.stop_requested();
97 : }
98 :
99 4 : [[nodiscard]] capy::io_result<> await_resume() const noexcept
100 : {
101 4 : if (token_.stop_requested())
102 MIS 0 : return {make_error_code(std::errc::operation_canceled)};
103 HIT 4 : return {ec_};
104 : }
105 :
106 4 : auto await_suspend(std::coroutine_handle<> h, capy::io_env const* env)
107 : -> std::coroutine_handle<>
108 : {
109 4 : token_ = env->stop_token;
110 12 : return acc_.get_impl().wait(
111 12 : h, env->executor, w_, token_, &ec_);
112 : }
113 : };
114 :
115 : struct native_accept_awaitable
116 : {
117 : native_local_stream_acceptor& acc_;
118 : local_stream_socket& peer_;
119 : std::stop_token token_;
120 : mutable std::error_code ec_;
121 : mutable io_object::implementation* peer_impl_ = nullptr;
122 :
123 6 : native_accept_awaitable(
124 : native_local_stream_acceptor& acc,
125 : local_stream_socket& peer) noexcept
126 6 : : acc_(acc)
127 6 : , peer_(peer)
128 : {
129 6 : }
130 :
131 6 : bool await_ready() const noexcept
132 : {
133 : // A pre-set ec_ means the initiator failed before
134 : // dispatch (e.g. a closed object).
135 6 : return static_cast<bool>(ec_) || token_.stop_requested();
136 : }
137 :
138 6 : [[nodiscard]] capy::io_result<> await_resume() const noexcept
139 : {
140 6 : if (token_.stop_requested())
141 MIS 0 : return {make_error_code(std::errc::operation_canceled)};
142 HIT 6 : if (!ec_)
143 4 : acc_.reset_peer_impl(peer_, peer_impl_);
144 6 : return {ec_};
145 : }
146 :
147 4 : auto await_suspend(std::coroutine_handle<> h, capy::io_env const* env)
148 : -> std::coroutine_handle<>
149 : {
150 4 : token_ = env->stop_token;
151 12 : return acc_.get_impl().accept(
152 12 : h, env->executor, token_, &ec_, &peer_impl_);
153 : }
154 : };
155 :
156 : struct native_move_accept_awaitable
157 : {
158 : native_local_stream_acceptor& acc_;
159 : std::stop_token token_;
160 : mutable std::error_code ec_;
161 : mutable io_object::implementation* peer_impl_ = nullptr;
162 :
163 4 : explicit native_move_accept_awaitable(
164 : native_local_stream_acceptor& acc) noexcept
165 4 : : acc_(acc)
166 : {
167 4 : }
168 :
169 4 : bool await_ready() const noexcept
170 : {
171 : // A pre-set ec_ means the initiator failed before
172 : // dispatch (e.g. a closed object).
173 4 : return static_cast<bool>(ec_) || token_.stop_requested();
174 : }
175 :
176 : [[nodiscard]] capy::io_result<native_local_stream_socket<Backend>>
177 4 : await_resume() const noexcept
178 : {
179 4 : if (token_.stop_requested())
180 : return {
181 MIS 0 : make_error_code(std::errc::operation_canceled),
182 0 : native_local_stream_socket<Backend>(acc_.context())};
183 HIT 4 : if (ec_ || !peer_impl_)
184 : return {
185 2 : ec_,
186 2 : native_local_stream_socket<Backend>(acc_.context())};
187 :
188 2 : native_local_stream_socket<Backend> peer(acc_.context());
189 2 : acc_.reset_peer_impl(peer, peer_impl_);
190 2 : return {ec_, std::move(peer)};
191 2 : }
192 :
193 2 : auto await_suspend(std::coroutine_handle<> h, capy::io_env const* env)
194 : -> std::coroutine_handle<>
195 : {
196 2 : token_ = env->stop_token;
197 6 : return acc_.get_impl().accept(
198 6 : h, env->executor, token_, &ec_, &peer_impl_);
199 : }
200 : };
201 :
202 : public:
203 : /** Construct a native acceptor from an execution context.
204 :
205 : @param ctx The execution context that will own this acceptor.
206 : */
207 16 : explicit native_local_stream_acceptor(capy::execution_context& ctx)
208 16 : : local_stream_acceptor(create_handle<service_type>(ctx), ctx)
209 : {
210 16 : }
211 :
212 : /** Construct a native acceptor from an executor.
213 :
214 : @param ex The executor whose context will own the acceptor.
215 : */
216 : template<class Ex>
217 : requires(!std::same_as<
218 : std::remove_cvref_t<Ex>,
219 : native_local_stream_acceptor>) &&
220 : capy::Executor<Ex>
221 : explicit native_local_stream_acceptor(Ex const& ex)
222 : : native_local_stream_acceptor(ex.context())
223 : {
224 : }
225 :
226 : /// Move construct.
227 2 : native_local_stream_acceptor(native_local_stream_acceptor&&) noexcept =
228 : default;
229 :
230 : /// Move assign.
231 : native_local_stream_acceptor&
232 : operator=(native_local_stream_acceptor&&) noexcept = default;
233 :
234 : native_local_stream_acceptor(native_local_stream_acceptor const&) = delete;
235 : native_local_stream_acceptor&
236 : operator=(native_local_stream_acceptor const&) = delete;
237 :
238 : /** Asynchronously accept an incoming connection.
239 :
240 : Calls the backend implementation directly, bypassing virtual
241 : dispatch. Otherwise identical to @ref local_stream_acceptor::accept.
242 :
243 : @param peer The socket to receive the accepted connection.
244 :
245 : @return An awaitable yielding `io_result<>`.
246 :
247 : A closed acceptor reports `errc::bad_file_descriptor`.
248 :
249 : Both this acceptor and @p peer must outlive the returned
250 : awaitable.
251 : */
252 6 : [[nodiscard]] auto accept(local_stream_socket& peer)
253 : {
254 6 : native_accept_awaitable aw(*this, peer);
255 6 : if (!is_open())
256 2 : aw.ec_ = make_error_code(std::errc::bad_file_descriptor);
257 6 : return aw;
258 : }
259 :
260 : /** Asynchronously accept an incoming connection, returning the peer.
261 :
262 : Calls the backend implementation directly, bypassing virtual
263 : dispatch. The accepted peer is returned as a
264 : @ref native_local_stream_socket so that subsequent I/O on it
265 : is also devirtualized.
266 :
267 : @return An awaitable yielding
268 : `io_result<native_local_stream_socket<Backend>>`.
269 :
270 : A closed acceptor reports `errc::bad_file_descriptor`.
271 :
272 : @throws std::logic_error If the acceptor has been moved from.
273 :
274 : This acceptor must outlive the returned awaitable.
275 : */
276 6 : [[nodiscard]] auto accept()
277 : {
278 : // The awaitable builds the peer from context(), which a
279 : // moved-from acceptor no longer has.
280 6 : if (!h_)
281 2 : detail::throw_logic_error("accept: acceptor moved-from");
282 4 : native_move_accept_awaitable aw(*this);
283 4 : if (!is_open())
284 2 : aw.ec_ = make_error_code(std::errc::bad_file_descriptor);
285 4 : return aw;
286 : }
287 :
288 : /** Asynchronously wait for the acceptor to be ready.
289 :
290 : Calls the backend implementation directly, bypassing virtual
291 : dispatch. Otherwise identical to @ref local_stream_acceptor::wait.
292 :
293 : @param w The wait direction (typically `wait_type::read`).
294 :
295 : @return An awaitable yielding `io_result<>`.
296 : */
297 4 : [[nodiscard]] auto wait(wait_type w)
298 : {
299 4 : return native_wait_awaitable(*this, w);
300 : }
301 : };
302 :
303 : } // namespace boost::corosio
304 :
305 : #endif // BOOST_COROSIO_NATIVE_NATIVE_LOCAL_STREAM_ACCEPTOR_HPP
|
