include/boost/corosio/native/native_tcp_acceptor.hpp

96.5% Lines (55 / 57) 88.9% Branches (16 / 18) 100.0% Functions (18 / 18)

[ ] prev/next file n p prev/next uncovered line

native_tcp_acceptor.hpp

f(x) Functions (18)

Function Calls Lines Branches Blocks

Line	Branch	Hits	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_ACCEPTOR_HPP
12			#define BOOST_COROSIO_NATIVE_NATIVE_TCP_ACCEPTOR_HPP
13
14			#include <boost/corosio/tcp_acceptor.hpp>
15			#include <boost/corosio/backend.hpp>
16			#include <boost/corosio/detail/op_base.hpp>
17
18			#ifndef BOOST_COROSIO_MRDOCS
19			#if BOOST_COROSIO_HAS_EPOLL
20			#include <boost/corosio/native/detail/epoll/epoll_types.hpp>
21			#endif
22
23			#if BOOST_COROSIO_HAS_SELECT
24			#include <boost/corosio/native/detail/select/select_types.hpp>
25			#endif
26
27			#if BOOST_COROSIO_HAS_KQUEUE
28			#include <boost/corosio/native/detail/kqueue/kqueue_types.hpp>
29			#endif
30
31			#if BOOST_COROSIO_HAS_IOCP
32			#include <boost/corosio/native/detail/iocp/win_tcp_acceptor_service.hpp>
33			#endif
34
35			#if BOOST_COROSIO_HAS_URING
36			#include <boost/corosio/native/detail/uring/uring_types.hpp>
37			#endif
38			#endif // !BOOST_COROSIO_MRDOCS
39
40			namespace boost::corosio {
41
42			/** Accepts TCP connections, calling the backend directly.
43
44			This class template inherits from @ref tcp_acceptor. It shadows the
45			`accept` operation with a version that calls the backend
46			implementation directly. The compiler can then inline through the
47			entire call chain.
48
49			Non-async operations (`listen`, `close`, `cancel`) remain
50			unchanged and dispatch through the compiled library.
51
52			A `native_tcp_acceptor` IS-A `tcp_acceptor` and can be passed
53			to any function expecting `tcp_acceptor&`.
54
55			@tparam Backend A backend tag value (e.g., `epoll`).
56
57			@par Thread Safety
58			Same as @ref tcp_acceptor.
59
60			@see @ref tcp_acceptor, @ref epoll_t, @ref iocp_t
61			*/
62			template<auto Backend>
63			class native_tcp_acceptor : public tcp_acceptor
64			{
65			using backend_type = decltype(Backend);
66			using impl_type = typename backend_type::tcp_acceptor_type;
67			using service_type = typename backend_type::tcp_acceptor_service_type;
68
69		13x	impl_type& get_impl() noexcept
70			{
71		13x	return static_cast<impl_type>(h_.get());
72			}
73
74			struct native_wait_awaitable : detail::void_op_base<native_wait_awaitable>
75			{
76			native_tcp_acceptor& acc_;
77			wait_type w_;
78
79		3x	native_wait_awaitable(native_tcp_acceptor& acc, wait_type w) noexcept
80		3x	: acc_(acc)
81		3x	, w_(w)
82			{
83		3x	}
84
85			std::coroutine_handle<>
86		2x	dispatch(capy::continuation& cont, capy::executor_ref ex) const
87			{
88	1/1 ✓ Branch 4 → 5 taken 2 times.	2x	return acc_.get_impl().wait(cont, ex, w_, this->token_, &this->ec_);
89			}
90			};
91
92			struct native_accept_awaitable
93			: detail::void_op_base<native_accept_awaitable>
94			{
95			native_tcp_acceptor& acc_;
96			tcp_socket& peer_;
97			mutable io_object::implementation* peer_impl_ = nullptr;
98
99		12x	native_accept_awaitable(
100			native_tcp_acceptor& acc, tcp_socket& peer) noexcept
101		12x	: acc_(acc)
102		12x	, peer_(peer)
103			{
104		12x	}
105
106			// A peer accepted for an awaiter that never resumed is closed
107			// here, or nothing would own it.
108		24x	~native_accept_awaitable()
109			{
110	1/2 ✗ Branch 2 → 3 not taken. ✓ Branch 2 → 4 taken 24 times.	24x	if (peer_impl_)
111		✗	discard_peer(acc_, peer_impl_);
112		24x	}
113
114		12x	[[nodiscard]] capy::results<> await_resume() const noexcept
115			{
116	2/2 ✓ Branch 3 → 4 taken 10 times. ✓ Branch 3 → 7 taken 2 times.	12x	if (!this->ec_)
117		10x	acc_.reset_peer_impl(peer_, std::exchange(peer_impl_, nullptr));
118		12x	return {this->ec_};
119			}
120
121			std::coroutine_handle<>
122		10x	dispatch(capy::continuation& cont, capy::executor_ref ex) const
123			{
124	1/1 ✓ Branch 4 → 5 taken 10 times.	30x	return acc_.get_impl().accept(
125		30x	cont, ex, this->token_, &this->ec_, &peer_impl_);
126			}
127			};
128
129			struct native_accept_value_awaitable
130			: detail::void_op_base<native_accept_value_awaitable>
131			{
132			native_tcp_acceptor& acc_;
133			mutable io_object::implementation* peer_impl_ = nullptr;
134
135		4x	explicit native_accept_value_awaitable(
136			native_tcp_acceptor& acc) noexcept
137		4x	: acc_(acc)
138			{
139		4x	}
140
141			// A peer accepted for an awaiter that never resumed is closed
142			// here, or nothing would own it.
143		8x	~native_accept_value_awaitable()
144			{
145	1/2 ✗ Branch 2 → 3 not taken. ✓ Branch 2 → 4 taken 8 times.	8x	if (peer_impl_)
146		✗	discard_peer(acc_, peer_impl_);
147		8x	}
148
149		4x	[[nodiscard]] capy::results<tcp_socket> await_resume() noexcept
150			{
151		4x	return take_peer(acc_, this->ec_, peer_impl_);
152			}
153
154			std::coroutine_handle<>
155		1x	dispatch(capy::continuation& cont, capy::executor_ref ex) const
156			{
157	1/1 ✓ Branch 4 → 5 taken 1 time.	3x	return acc_.get_impl().accept(
158		3x	cont, ex, this->token_, &this->ec_, &peer_impl_);
159			}
160			};
161
162			public:
163			/** Construct a native acceptor from an execution context.
164
165			@param ctx The execution context that owns this acceptor.
166			*/
167		19x	explicit native_tcp_acceptor(capy::execution_context& ctx)
168	2/2 ✓ Branch 2 → 3 taken 19 times. ✓ Branch 3 → 4 taken 19 times.	19x	: tcp_acceptor(handle(ctx, ctx.use_service<service_type>()))
169			{
170		19x	}
171
172			/** Construct a native acceptor from an executor.
173
174			@param ex The executor whose context owns the acceptor.
175
176			@tparam Ex A type satisfying @ref capy::Executor. Must not
177			be `native_tcp_acceptor` itself (disables implicit
178			conversion from move).
179			*/
180			template<class Ex>
181			requires(!std::same_as<std::remove_cvref_t<Ex>, native_tcp_acceptor>) &&
182			capy::Executor<Ex>
183			explicit native_tcp_acceptor(Ex const& ex)
184			: native_tcp_acceptor(ex.context())
185			{
186			}
187
188			/** Construct a native acceptor that is open, bound, and listening.
189
190			Creates a fully bound listening acceptor in a single
191			expression, throwing the codes the piecewise `open()` +
192			`set_option()` + `bind()` + `listen()` path reports. The
193			address family is deduced from @p ep, and address reuse is
194			configured as by the @ref tcp_acceptor convenience
195			constructor.
196
197			@param ctx The execution context that owns this acceptor.
198			@param ep The local endpoint to bind to.
199			@param backlog The maximum pending connection queue length.
200
201			@throws std::system_error on open, configuration, bind, or
202			listen failure.
203			*/
204		4x	native_tcp_acceptor(
205			capy::execution_context& ctx, endpoint ep, int backlog = 128)
206			: tcp_acceptor(
207	3/3 ✓ Branch 2 → 3 taken 4 times. ✓ Branch 3 → 4 taken 4 times. ✓ Branch 4 → 5 taken 3 times.	4x	handle(ctx, ctx.use_service<service_type>()), ep, backlog)
208			{
209		3x	}
210
211			/** Construct a native acceptor that is open, bound, and listening.
212
213			@param ex The executor whose context owns the acceptor.
214			@param ep The local endpoint to bind to.
215			@param backlog The maximum pending connection queue length.
216
217			@tparam Ex A type satisfying @ref capy::Executor.
218
219			@throws std::system_error on open, configuration, bind, or
220			listen failure.
221			*/
222			template<class Ex>
223			requires capy::Executor<Ex>
224		1x	native_tcp_acceptor(Ex const& ex, endpoint ep, int backlog = 128)
225		1x	: native_tcp_acceptor(ex.context(), ep, backlog)
226			{
227		1x	}
228
229			/** Move construct.
230
231			@param other The acceptor to move from.
232
233			@pre No awaitables returned by @p other's methods exist.
234			@pre The execution context associated with @p other must
235			outlive this acceptor.
236			*/
237		2x	native_tcp_acceptor(native_tcp_acceptor&&) noexcept = default;
238
239			/** Move assign.
240
241			@param other The acceptor to move from.
242
243			@pre No awaitables returned by either `*this` or @p other's
244			methods exist.
245			@pre The execution context associated with @p other must
246			outlive this acceptor.
247			*/
248			native_tcp_acceptor& operator=(native_tcp_acceptor&&) noexcept = default;
249
250			/// Copy construction is disabled; the handle is uniquely owned.
251			native_tcp_acceptor(native_tcp_acceptor const&) = delete;
252			/// Copy assignment is disabled; the handle is uniquely owned.
253			native_tcp_acceptor& operator=(native_tcp_acceptor const&) = delete;
254
255			/** Asynchronously accept an incoming connection.
256
257			Calls the backend implementation directly, bypassing virtual
258			dispatch. Otherwise identical to @ref tcp_acceptor::accept.
259
260			@param peer The socket to receive the accepted connection.
261
262			@return An awaitable yielding `results<>`.
263
264			A closed or moved-from acceptor reports
265			`errc::bad_file_descriptor`.
266
267			Both this acceptor and @p peer must outlive the returned
268			awaitable.
269			*/
270		12x	[[nodiscard]] auto accept(tcp_socket& peer)
271			{
272		12x	native_accept_awaitable aw(*this, peer);
273	2/2 ✓ Branch 4 → 5 taken 1 time. ✓ Branch 4 → 6 taken 11 times.	12x	if (!is_open())
274		1x	aw.ec_ = make_error_code(std::errc::bad_file_descriptor);
275		12x	return aw;
276			}
277
278			/** Asynchronously accept an incoming connection, returning the peer.
279
280			Calls the backend implementation directly, bypassing virtual
281			dispatch. Otherwise identical to @ref tcp_acceptor::accept().
282
283			@return An awaitable yielding `results<tcp_socket>`.
284
285			A closed or moved-from acceptor reports
286			`errc::bad_file_descriptor`.
287			On failure the returned socket is default-constructed and not
288			open. It has no context, so it may only be destroyed, assigned,
289			or checked with `is_open()`.
290
291			This acceptor must outlive the returned awaitable.
292			*/
293		4x	[[nodiscard]] auto accept()
294			{
295		4x	native_accept_value_awaitable aw(*this);
296	2/2 ✓ Branch 4 → 5 taken 2 times. ✓ Branch 4 → 6 taken 2 times.	4x	if (!is_open())
297		2x	aw.ec_ = make_error_code(std::errc::bad_file_descriptor);
298		4x	return aw;
299			}
300
301			/** Asynchronously wait for the acceptor to be ready.
302
303			Calls the backend implementation directly, bypassing virtual
304			dispatch. Otherwise identical to @ref tcp_acceptor::wait.
305
306			@param w The wait direction (typically `wait_type::read`).
307
308			@return An awaitable yielding `results<>`.
309			*/
310		3x	[[nodiscard]] auto wait(wait_type w)
311			{
312		3x	return native_wait_awaitable(*this, w);
313			}
314			};
315
316			} // namespace boost::corosio
317
318			#endif
319