TLA Line data Source code
1 : //
2 : // Copyright (c) 2026 Steve Gerbino
3 : // Copyright (c) 2026 Michael Vandeberg
4 : //
5 : // Distributed under the Boost Software License, Version 1.0. (See accompanying
6 : // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
7 : //
8 : // Official repository: https://github.com/cppalliance/corosio
9 : //
10 :
11 : #ifndef BOOST_COROSIO_NATIVE_NATIVE_TCP_SOCKET_HPP
12 : #define BOOST_COROSIO_NATIVE_NATIVE_TCP_SOCKET_HPP
13 :
14 : #include <boost/corosio/tcp_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_IOCP
31 : #include <boost/corosio/native/detail/iocp/win_tcp_acceptor_service.hpp>
32 : #endif
33 :
34 : #if BOOST_COROSIO_HAS_IO_URING
35 : #include <boost/corosio/native/detail/io_uring/io_uring_types.hpp>
36 : #endif
37 : #endif // !BOOST_COROSIO_MRDOCS
38 :
39 : namespace boost::corosio {
40 :
41 : /** An asynchronous TCP socket with devirtualized I/O operations.
42 :
43 : This class template inherits from @ref tcp_socket and shadows
44 : the async operations (`read_some`, `write_some`, `connect`) with
45 : versions that call the backend implementation directly, allowing
46 : the compiler to inline through the entire call chain.
47 :
48 : Non-async operations (`open`, `close`, `cancel`, socket options)
49 : remain unchanged and dispatch through the compiled library.
50 :
51 : A `native_tcp_socket` IS-A `tcp_socket` and can be passed to
52 : any function expecting `tcp_socket&` or `io_stream&`, in which
53 : case virtual dispatch is used transparently.
54 :
55 : @tparam Backend A backend tag value (e.g., `epoll`,
56 : `iocp`) whose type provides the concrete implementation
57 : types.
58 :
59 : @par Thread Safety
60 : Same as @ref tcp_socket.
61 :
62 : @par Example
63 : @par !example native_tcp_socket
64 :
65 : @see tcp_socket, epoll_t, iocp_t
66 : */
67 : template<auto Backend>
68 : class native_tcp_socket : public tcp_socket
69 : {
70 : using backend_type = decltype(Backend);
71 : using impl_type = typename backend_type::tcp_socket_type;
72 : using service_type = typename backend_type::tcp_service_type;
73 :
74 HIT 49 : impl_type& get_impl() noexcept
75 : {
76 49 : return *static_cast<impl_type*>(h_.get());
77 : }
78 :
79 : template<class MutableBufferSequence>
80 : struct native_read_awaitable
81 : {
82 : native_tcp_socket& self_;
83 : MutableBufferSequence buffers_;
84 : std::stop_token token_;
85 : mutable std::error_code ec_;
86 : mutable std::size_t bytes_transferred_ = 0;
87 :
88 10 : native_read_awaitable(
89 : native_tcp_socket& self, MutableBufferSequence buffers) noexcept
90 10 : : self_(self)
91 10 : , buffers_(std::move(buffers))
92 : {
93 10 : }
94 :
95 10 : bool await_ready() const noexcept
96 : {
97 : // A pre-set ec_ means the initiator failed before
98 : // dispatch (e.g. a closed object).
99 10 : return static_cast<bool>(ec_) || token_.stop_requested();
100 : }
101 :
102 10 : [[nodiscard]] capy::io_result<std::size_t> await_resume() const noexcept
103 : {
104 10 : if (token_.stop_requested())
105 4 : return {make_error_code(std::errc::operation_canceled), 0};
106 6 : return {ec_, bytes_transferred_};
107 : }
108 :
109 10 : auto await_suspend(std::coroutine_handle<> h, capy::io_env const* env)
110 : -> std::coroutine_handle<>
111 : {
112 10 : token_ = env->stop_token;
113 30 : return self_.get_impl().read_some(
114 30 : h, env->executor, buffers_, token_, &ec_, &bytes_transferred_);
115 : }
116 : };
117 :
118 : template<class ConstBufferSequence>
119 : struct native_write_awaitable
120 : {
121 : native_tcp_socket& self_;
122 : ConstBufferSequence buffers_;
123 : std::stop_token token_;
124 : mutable std::error_code ec_;
125 : mutable std::size_t bytes_transferred_ = 0;
126 :
127 12 : native_write_awaitable(
128 : native_tcp_socket& self, ConstBufferSequence buffers) noexcept
129 12 : : self_(self)
130 12 : , buffers_(std::move(buffers))
131 : {
132 12 : }
133 :
134 12 : bool await_ready() const noexcept
135 : {
136 : // A pre-set ec_ means the initiator failed before
137 : // dispatch (e.g. a closed object).
138 12 : return static_cast<bool>(ec_) || token_.stop_requested();
139 : }
140 :
141 12 : [[nodiscard]] capy::io_result<std::size_t> await_resume() const noexcept
142 : {
143 12 : if (token_.stop_requested())
144 2 : return {make_error_code(std::errc::operation_canceled), 0};
145 10 : return {ec_, bytes_transferred_};
146 : }
147 :
148 12 : auto await_suspend(std::coroutine_handle<> h, capy::io_env const* env)
149 : -> std::coroutine_handle<>
150 : {
151 12 : token_ = env->stop_token;
152 36 : return self_.get_impl().write_some(
153 36 : h, env->executor, buffers_, token_, &ec_, &bytes_transferred_);
154 : }
155 : };
156 :
157 : struct native_wait_awaitable
158 : {
159 : native_tcp_socket& self_;
160 : wait_type w_;
161 : std::stop_token token_;
162 : mutable std::error_code ec_;
163 :
164 6 : native_wait_awaitable(native_tcp_socket& self, wait_type w) noexcept
165 6 : : self_(self)
166 6 : , w_(w)
167 : {
168 6 : }
169 :
170 6 : bool await_ready() const noexcept
171 : {
172 : // A pre-set ec_ means the initiator failed before
173 : // dispatch (e.g. a closed object).
174 6 : return static_cast<bool>(ec_) || token_.stop_requested();
175 : }
176 :
177 6 : [[nodiscard]] capy::io_result<> await_resume() const noexcept
178 : {
179 6 : if (token_.stop_requested())
180 2 : return {make_error_code(std::errc::operation_canceled)};
181 4 : return {ec_};
182 : }
183 :
184 6 : auto await_suspend(std::coroutine_handle<> h, capy::io_env const* env)
185 : -> std::coroutine_handle<>
186 : {
187 6 : token_ = env->stop_token;
188 18 : return self_.get_impl().wait(
189 18 : h, env->executor, w_, token_, &ec_);
190 : }
191 : };
192 :
193 : struct native_connect_awaitable
194 : {
195 : native_tcp_socket& self_;
196 : endpoint endpoint_;
197 : std::stop_token token_;
198 : mutable std::error_code ec_;
199 :
200 21 : native_connect_awaitable(native_tcp_socket& self, endpoint ep) noexcept
201 21 : : self_(self)
202 21 : , endpoint_(ep)
203 : {
204 21 : }
205 :
206 21 : bool await_ready() const noexcept
207 : {
208 : // A pre-set ec_ means the initiator failed before
209 : // dispatch (e.g. a closed object).
210 21 : return static_cast<bool>(ec_) || token_.stop_requested();
211 : }
212 :
213 21 : [[nodiscard]] capy::io_result<> await_resume() const noexcept
214 : {
215 21 : if (token_.stop_requested())
216 2 : return {make_error_code(std::errc::operation_canceled)};
217 19 : return {ec_};
218 : }
219 :
220 21 : auto await_suspend(std::coroutine_handle<> h, capy::io_env const* env)
221 : -> std::coroutine_handle<>
222 : {
223 21 : token_ = env->stop_token;
224 63 : return self_.get_impl().connect(
225 63 : h, env->executor, endpoint_, token_, &ec_);
226 : }
227 : };
228 :
229 : public:
230 : /** Construct a native socket from an execution context.
231 :
232 : @param ctx The execution context that will own this socket.
233 : */
234 45 : explicit native_tcp_socket(capy::execution_context& ctx)
235 45 : : io_object(create_handle<service_type>(ctx))
236 : {
237 45 : }
238 :
239 : /** Construct a native socket from an executor.
240 :
241 : @param ex The executor whose context will own the socket.
242 : */
243 : template<class Ex>
244 : requires(!std::same_as<std::remove_cvref_t<Ex>, native_tcp_socket>) &&
245 : capy::Executor<Ex>
246 : explicit native_tcp_socket(Ex const& ex) : native_tcp_socket(ex.context())
247 : {
248 : }
249 :
250 : /** Move construct.
251 :
252 : @param other The socket to move from.
253 :
254 : @pre No awaitables returned by @p other's methods exist.
255 : @pre @p other is not referenced as a peer in any outstanding
256 : accept awaitable.
257 : @pre The execution context associated with @p other must
258 : outlive this socket.
259 : */
260 24 : native_tcp_socket(native_tcp_socket&&) noexcept = default;
261 :
262 : /** Move assign.
263 :
264 : @param other The socket to move from.
265 :
266 : @pre No awaitables returned by either `*this` or @p other's
267 : methods exist.
268 : @pre Neither `*this` nor @p other is referenced as a peer in
269 : any outstanding accept awaitable.
270 : @pre The execution context associated with @p other must
271 : outlive this socket.
272 : */
273 3 : native_tcp_socket& operator=(native_tcp_socket&&) noexcept = default;
274 :
275 : native_tcp_socket(native_tcp_socket const&) = delete;
276 : native_tcp_socket& operator=(native_tcp_socket const&) = delete;
277 :
278 : /** Asynchronously read data from the socket.
279 :
280 : Calls the backend implementation directly, bypassing virtual
281 : dispatch. Otherwise identical to @ref io_stream::read_some.
282 :
283 : @param buffers The buffer sequence to read into.
284 :
285 : @return An awaitable yielding `(error_code, std::size_t)`.
286 :
287 : This socket must outlive the returned awaitable. The memory
288 : referenced by @p buffers must remain valid until the operation
289 : completes.
290 : */
291 : template<capy::MutableBufferSequence MB>
292 10 : [[nodiscard]] auto read_some(MB const& buffers)
293 : {
294 10 : return native_read_awaitable<MB>(*this, buffers);
295 : }
296 :
297 : /** Asynchronously write data to the socket.
298 :
299 : Calls the backend implementation directly, bypassing virtual
300 : dispatch. Otherwise identical to @ref io_stream::write_some.
301 :
302 : @param buffers The buffer sequence to write from.
303 :
304 : @return An awaitable yielding `(error_code, std::size_t)`.
305 :
306 : This socket must outlive the returned awaitable. The memory
307 : referenced by @p buffers must remain valid until the operation
308 : completes.
309 : */
310 : template<capy::ConstBufferSequence CB>
311 12 : [[nodiscard]] auto write_some(CB const& buffers)
312 : {
313 12 : return native_write_awaitable<CB>(*this, buffers);
314 : }
315 :
316 : /** Asynchronously connect to a remote endpoint.
317 :
318 : Calls the backend implementation directly, bypassing virtual
319 : dispatch. Otherwise identical to @ref tcp_socket::connect.
320 :
321 : If the socket is not open, it is opened automatically using
322 : the protocol matching the endpoint's address family. An open
323 : failure surfaces through the connect completion.
324 :
325 : @param ep The remote endpoint to connect to.
326 :
327 : @return An awaitable yielding `io_result<>`.
328 :
329 : This socket must outlive the returned awaitable.
330 : */
331 21 : [[nodiscard]] auto connect(endpoint ep)
332 : {
333 21 : native_connect_awaitable aw(*this, ep);
334 21 : if (!is_open())
335 2 : aw.ec_ = open(ep.is_v6() ? tcp::v6() : tcp::v4());
336 21 : return aw;
337 : }
338 :
339 : /** Asynchronously wait for the socket to be ready.
340 :
341 : Calls the backend implementation directly, bypassing virtual
342 : dispatch. Otherwise identical to @ref tcp_socket::wait.
343 :
344 : @param w The wait direction (read, write, or error).
345 :
346 : @return An awaitable yielding `io_result<>`.
347 : */
348 6 : [[nodiscard]] auto wait(wait_type w)
349 : {
350 6 : return native_wait_awaitable(*this, w);
351 : }
352 : };
353 :
354 : } // namespace boost::corosio
355 :
356 : #endif
|
