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_URING
31 : #include <boost/corosio/native/detail/uring/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 16 : impl_type& get_impl() noexcept
74 : {
75 16 : 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 6 : native_wait_awaitable(
86 : native_local_stream_acceptor& acc, wait_type w) noexcept
87 6 : : acc_(acc)
88 6 : , w_(w)
89 : {
90 6 : }
91 :
92 6 : bool await_ready() const noexcept
93 : {
94 : // A pre-set ec_ means the initiator failed before
95 : // dispatch (e.g. a closed object).
96 6 : return static_cast<bool>(ec_) || token_.stop_requested();
97 : }
98 :
99 6 : [[nodiscard]] capy::io_result<> await_resume() const noexcept
100 : {
101 6 : if (token_.stop_requested())
102 2 : return {make_error_code(std::errc::operation_canceled)};
103 4 : return {ec_};
104 : }
105 :
106 6 : auto await_suspend(std::coroutine_handle<> h, capy::io_env const* env)
107 : -> std::coroutine_handle<>
108 : {
109 6 : token_ = env->stop_token;
110 6 : return acc_.get_impl().wait(h, env->executor, w_, token_, &ec_);
111 : }
112 : };
113 :
114 : struct native_accept_awaitable
115 : {
116 : native_local_stream_acceptor& acc_;
117 : local_stream_socket& peer_;
118 : std::stop_token token_;
119 : mutable std::error_code ec_;
120 : mutable io_object::implementation* peer_impl_ = nullptr;
121 :
122 8 : native_accept_awaitable(
123 : native_local_stream_acceptor& acc,
124 : local_stream_socket& peer) noexcept
125 8 : : acc_(acc)
126 8 : , peer_(peer)
127 : {
128 8 : }
129 :
130 8 : bool await_ready() const noexcept
131 : {
132 : // A pre-set ec_ means the initiator failed before
133 : // dispatch (e.g. a closed object).
134 8 : return static_cast<bool>(ec_) || token_.stop_requested();
135 : }
136 :
137 8 : [[nodiscard]] capy::io_result<> await_resume() const noexcept
138 : {
139 8 : if (token_.stop_requested())
140 2 : return {make_error_code(std::errc::operation_canceled)};
141 6 : if (!ec_)
142 4 : acc_.reset_peer_impl(peer_, peer_impl_);
143 6 : return {ec_};
144 : }
145 :
146 6 : auto await_suspend(std::coroutine_handle<> h, capy::io_env const* env)
147 : -> std::coroutine_handle<>
148 : {
149 6 : token_ = env->stop_token;
150 18 : return acc_.get_impl().accept(
151 18 : h, env->executor, token_, &ec_, &peer_impl_);
152 : }
153 : };
154 :
155 : struct native_move_accept_awaitable
156 : {
157 : native_local_stream_acceptor& acc_;
158 : std::stop_token token_;
159 : mutable std::error_code ec_;
160 : mutable io_object::implementation* peer_impl_ = nullptr;
161 :
162 6 : explicit native_move_accept_awaitable(
163 : native_local_stream_acceptor& acc) noexcept
164 6 : : acc_(acc)
165 : {
166 6 : }
167 :
168 6 : bool await_ready() const noexcept
169 : {
170 : // A pre-set ec_ means the initiator failed before
171 : // dispatch (e.g. a closed object).
172 6 : return static_cast<bool>(ec_) || token_.stop_requested();
173 : }
174 :
175 : [[nodiscard]] capy::io_result<native_local_stream_socket<Backend>>
176 6 : await_resume() const noexcept
177 : {
178 6 : if (token_.stop_requested())
179 : return {
180 2 : make_error_code(std::errc::operation_canceled),
181 2 : native_local_stream_socket<Backend>(acc_.context())};
182 4 : if (ec_ || !peer_impl_)
183 : return {
184 2 : ec_, native_local_stream_socket<Backend>(acc_.context())};
185 :
186 2 : native_local_stream_socket<Backend> peer(acc_.context());
187 2 : acc_.reset_peer_impl(peer, peer_impl_);
188 2 : return {ec_, std::move(peer)};
189 2 : }
190 :
191 4 : auto await_suspend(std::coroutine_handle<> h, capy::io_env const* env)
192 : -> std::coroutine_handle<>
193 : {
194 4 : token_ = env->stop_token;
195 12 : return acc_.get_impl().accept(
196 12 : h, env->executor, token_, &ec_, &peer_impl_);
197 : }
198 : };
199 :
200 : public:
201 : /** Construct a native acceptor from an execution context.
202 :
203 : @param ctx The execution context that will own this acceptor.
204 : */
205 18 : explicit native_local_stream_acceptor(capy::execution_context& ctx)
206 18 : : local_stream_acceptor(create_handle<service_type>(ctx), ctx)
207 : {
208 18 : }
209 :
210 : /** Construct a native acceptor from an executor.
211 :
212 : @param ex The executor whose context will own the acceptor.
213 : */
214 : template<class Ex>
215 : requires(!std::same_as<
216 : std::remove_cvref_t<Ex>,
217 : native_local_stream_acceptor>) &&
218 : capy::Executor<Ex>
219 : explicit native_local_stream_acceptor(Ex const& ex)
220 : : native_local_stream_acceptor(ex.context())
221 : {
222 : }
223 :
224 : /// Move construct.
225 2 : native_local_stream_acceptor(native_local_stream_acceptor&&) noexcept =
226 : default;
227 :
228 : /// Move assign.
229 : native_local_stream_acceptor&
230 : operator=(native_local_stream_acceptor&&) noexcept = default;
231 :
232 : native_local_stream_acceptor(native_local_stream_acceptor const&) = delete;
233 : native_local_stream_acceptor&
234 : operator=(native_local_stream_acceptor const&) = delete;
235 :
236 : /** Asynchronously accept an incoming connection.
237 :
238 : Calls the backend implementation directly, bypassing virtual
239 : dispatch. Otherwise identical to @ref local_stream_acceptor::accept.
240 :
241 : @param peer The socket to receive the accepted connection.
242 :
243 : @return An awaitable yielding `io_result<>`.
244 :
245 : A closed acceptor reports `errc::bad_file_descriptor`.
246 :
247 : Both this acceptor and @p peer must outlive the returned
248 : awaitable.
249 : */
250 8 : [[nodiscard]] auto accept(local_stream_socket& peer)
251 : {
252 8 : native_accept_awaitable aw(*this, peer);
253 8 : if (!is_open())
254 2 : aw.ec_ = make_error_code(std::errc::bad_file_descriptor);
255 8 : return aw;
256 : }
257 :
258 : /** Asynchronously accept an incoming connection, returning the peer.
259 :
260 : Calls the backend implementation directly, bypassing virtual
261 : dispatch. The accepted peer is returned as a
262 : @ref native_local_stream_socket so that subsequent I/O on it
263 : is also devirtualized.
264 :
265 : @return An awaitable yielding
266 : `io_result<native_local_stream_socket<Backend>>`.
267 :
268 : A closed acceptor reports `errc::bad_file_descriptor`.
269 :
270 : @throws std::logic_error If the acceptor has been moved from.
271 :
272 : This acceptor must outlive the returned awaitable.
273 : */
274 8 : [[nodiscard]] auto accept()
275 : {
276 : // The awaitable builds the peer from context(), which a
277 : // moved-from acceptor no longer has.
278 8 : if (!h_)
279 2 : detail::throw_logic_error("accept: acceptor moved-from");
280 6 : native_move_accept_awaitable aw(*this);
281 6 : if (!is_open())
282 2 : aw.ec_ = make_error_code(std::errc::bad_file_descriptor);
283 6 : return aw;
284 : }
285 :
286 : /** Asynchronously wait for the acceptor to be ready.
287 :
288 : Calls the backend implementation directly, bypassing virtual
289 : dispatch. Otherwise identical to @ref local_stream_acceptor::wait.
290 :
291 : @param w The wait direction (typically `wait_type::read`).
292 :
293 : @return An awaitable yielding `io_result<>`.
294 : */
295 6 : [[nodiscard]] auto wait(wait_type w)
296 : {
297 6 : return native_wait_awaitable(*this, w);
298 : }
299 : };
300 :
301 : } // namespace boost::corosio
302 :
303 : #endif // BOOST_COROSIO_NATIVE_NATIVE_LOCAL_STREAM_ACCEPTOR_HPP
|
