include/boost/corosio/native/detail/reactor/reactor_op.hpp

77.8% Lines (161/207) 78.7% List of functions (170/216) 14.8% Branches (45/304)

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

reactor_op.hpp

f(x) Functions (216)

Function Calls Lines Branches Blocks

Line	Branch	Hits	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_DETAIL_REACTOR_REACTOR_OP_HPP
11			#define BOOST_COROSIO_NATIVE_DETAIL_REACTOR_REACTOR_OP_HPP
12
13			#include <boost/corosio/native/detail/reactor/reactor_op_base.hpp>
14			#include <boost/corosio/io/io_object.hpp>
15			#include <boost/corosio/endpoint.hpp>
16			#include <boost/corosio/detail/continuation_op.hpp>
17			#include <boost/capy/ex/executor_ref.hpp>
18
19			#include <atomic>
20			#include <coroutine>
21			#include <cstddef>
22			#include <memory>
23			#include <optional>
24			#include <stop_token>
25			#include <system_error>
26
27			#include <errno.h>
28
29			#include <netinet/in.h>
30			#include <sys/socket.h>
31			#include <sys/uio.h>
32
33			namespace boost::corosio::detail {
34
35			/** Base operation for reactor-based backends.
36
37			Holds per-operation state that depends on the concrete backend
38			socket/acceptor types: coroutine handle, executor, output
39			pointers, file descriptor, stop_callback, and type-specific
40			impl pointers.
41
42			Fields shared across all backends (errn, bytes_transferred,
43			cancelled, impl_ptr, perform_io, complete) live in
44			reactor_op_base so the scheduler and descriptor_state can
45			access them without template instantiation.
46
47			@tparam Socket The backend socket impl type (forward-declared).
48			@tparam Acceptor The backend acceptor impl type (forward-declared).
49			*/
50			template<class Socket, class Acceptor>
51			struct reactor_op : reactor_op_base
52			{
53			/// Stop-token callback that invokes cancel() on the target op.
54			struct canceller
55			{
56			reactor_op* op;
57		729x	void operator()() const noexcept
58			{
59		729x	op->cancel();
60		729x	}
61			};
62
63			/// Caller's coroutine handle to resume on completion.
64			std::coroutine_handle<> h;
65
66			/// Scheduler-ready continuation for executor dispatch/post (wraps h).
67			detail::continuation_op cont_op;
68
69			/// Executor for dispatching the completion.
70			capy::executor_ref ex;
71
72			/// Output pointer for the error code.
73		67523x	std::error_code* ec_out = nullptr;
74
75			/// Output pointer for bytes transferred.
76		67523x	std::size_t* bytes_out = nullptr;
77
78			/// File descriptor this operation targets.
79		67523x	int fd = -1;
80
81			/// Stop-token callback registration.
82			std::optional<std::stop_callback<canceller>> stop_cb;
83
84			/// Owning socket impl (for stop_token cancellation).
85		67523x	Socket* socket_impl_ = nullptr;
86
87			/// Owning acceptor impl (for stop_token cancellation).
88		67523x	Acceptor* acceptor_impl_ = nullptr;
89
90		202569x	reactor_op() = default;
91
92			/// Reset operation state for reuse.
93		1658218x	void reset() noexcept
94			{
95		1658218x	fd = -1;
96		1658218x	errn = 0;
97		1658218x	bytes_transferred = 0;
98		1658218x	cancelled.store(false, std::memory_order_relaxed);
99		1658218x	impl_ptr.reset();
100		1658218x	socket_impl_ = nullptr;
101		1658218x	acceptor_impl_ = nullptr;
102		1658218x	}
103
104			/// Return true if this is a read-direction operation.
105		160069x	virtual bool is_read_operation() const noexcept
106			{
107		160069x	return false;
108			}
109
110			/// Cancel this operation via the owning impl.
111			virtual void cancel() noexcept = 0;
112
113			/// Destroy without invoking.
114		✗	void destroy() override
115			{
116		✗	stop_cb.reset();
117		✗	reactor_op_base::destroy();
118		✗	}
119
120			/// Arm the stop-token callback for a socket operation.
121		401707x	void start(std::stop_token const& token, Socket* impl)
122			{
123		401707x	cancelled.store(false, std::memory_order_release);
124		401707x	stop_cb.reset();
125		401707x	socket_impl_ = impl;
126		401707x	acceptor_impl_ = nullptr;
127
128	8/16 ✓ Branch 0 taken 191152 times. ✓ Branch 1 taken 39 times. ✓ Branch 2 taken 209203 times. ✓ Branch 3 taken 1289 times. ✓ Branch 4 taken 5 times. ✗ Branch 5 not taken. ✓ Branch 6 taken 7 times. ✗ Branch 7 not taken. ✗ Branch 8 not taken. ✗ Branch 9 not taken. ✗ Branch 10 not taken. ✗ Branch 11 not taken. ✓ Branch 12 taken 5 times. ✗ Branch 13 not taken. ✓ Branch 14 taken 7 times. ✗ Branch 15 not taken.	401707x	if (token.stop_possible())
129		1328x	stop_cb.emplace(token, canceller{this});
130		401707x	}
131
132			/// Arm the stop-token callback for an acceptor operation.
133		7247x	void start(std::stop_token const& token, Acceptor* impl)
134			{
135		7247x	cancelled.store(false, std::memory_order_release);
136		7247x	stop_cb.reset();
137		7247x	socket_impl_ = nullptr;
138		7247x	acceptor_impl_ = impl;
139
140	4/8 ✓ Branch 0 taken 1828 times. ✗ Branch 1 not taken. ✓ Branch 2 taken 5408 times. ✓ Branch 3 taken 9 times. ✗ Branch 4 not taken. ✗ Branch 5 not taken. ✓ Branch 6 taken 2 times. ✗ Branch 7 not taken.	7247x	if (token.stop_possible())
141		9x	stop_cb.emplace(token, canceller{this});
142		7247x	}
143			};
144
145			/** Shared connect operation.
146
147			Checks SO_ERROR for connect completion status. The operator()()
148			and cancel() are provided by the concrete backend type.
149
150			@tparam Base The backend's base op type.
151			@tparam Endpoint The endpoint type (endpoint or local_endpoint).
152			*/
153			template<class Base, class Endpoint = endpoint>
154			struct reactor_connect_op : Base
155			{
156			/// Endpoint to connect to.
157			Endpoint target_endpoint;
158
159			/// Reset operation state for reuse.
160		7262x	void reset() noexcept
161			{
162		7262x	Base::reset();
163		7262x	target_endpoint = Endpoint{};
164		7262x	}
165
166		7239x	void perform_io() noexcept override
167			{
168		7239x	int err = 0;
169		7239x	socklen_t len = sizeof(err);
170	4/32 ✓ Branch 0 taken 1833 times. ✗ Branch 1 not taken. ✗ Branch 2 not taken. ✓ Branch 3 taken 1833 times. ✓ Branch 4 taken 5406 times. ✗ Branch 5 not taken. ✗ Branch 6 not taken. ✓ Branch 7 taken 5406 times. ✗ Branch 8 not taken. ✗ Branch 9 not taken. ✗ Branch 10 not taken. ✗ Branch 11 not taken. ✗ Branch 12 not taken. ✗ Branch 13 not taken. ✗ Branch 14 not taken. ✗ Branch 15 not taken. ✗ Branch 16 not taken. ✗ Branch 17 not taken. ✗ Branch 18 not taken. ✗ Branch 19 not taken. ✗ Branch 20 not taken. ✗ Branch 21 not taken. ✗ Branch 22 not taken. ✗ Branch 23 not taken. ✗ Branch 24 not taken. ✗ Branch 25 not taken. ✗ Branch 26 not taken. ✗ Branch 27 not taken. ✗ Branch 28 not taken. ✗ Branch 29 not taken. ✗ Branch 30 not taken. ✗ Branch 31 not taken.	7239x	if (::getsockopt(this->fd, SOL_SOCKET, SO_ERROR, &err, &len) < 0)
171		✗	err = errno;
172		7239x	this->complete(err, 0);
173		7239x	}
174			};
175
176			/** Shared scatter-read operation.
177
178			Uses readv() with an EINTR retry loop.
179
180			@tparam Base The backend's base op type.
181			*/
182			template<class Base>
183		21888x	struct reactor_read_op : Base
184			{
185			/// Maximum scatter-gather buffer count.
186			static constexpr std::size_t max_buffers = 16;
187
188			/// Scatter-gather I/O vectors.
189			iovec iovecs[max_buffers];
190
191			/// Number of active I/O vectors.
192		21888x	int iovec_count = 0;
193
194			/// True for zero-length reads (completed immediately).
195		21888x	bool empty_buffer_read = false;
196
197			/// Return true (this is a read-direction operation).
198		233518x	bool is_read_operation() const noexcept override
199			{
200		233518x	return !empty_buffer_read;
201			}
202
203		757828x	void reset() noexcept
204			{
205		757828x	Base::reset();
206		757828x	iovec_count = 0;
207		757828x	empty_buffer_read = false;
208		757828x	}
209
210		108188x	void perform_io() noexcept override
211			{
212			ssize_t n;
213		108188x	do
214			{
215	2/8 ✓ Branch 0 taken 44006 times. ✗ Branch 1 not taken. ✓ Branch 2 taken 64182 times. ✗ Branch 3 not taken. ✗ Branch 4 not taken. ✗ Branch 5 not taken. ✗ Branch 6 not taken. ✗ Branch 7 not taken.	108188x	n = ::readv(this->fd, iovecs, iovec_count);
216		216376x	}
217	6/16 ✓ Branch 0 taken 951 times. ✓ Branch 1 taken 43055 times. ✓ Branch 2 taken 951 times. ✗ Branch 3 not taken. ✓ Branch 4 taken 410 times. ✓ Branch 5 taken 63772 times. ✓ Branch 6 taken 410 times. ✗ Branch 7 not taken. ✗ Branch 8 not taken. ✗ Branch 9 not taken. ✗ Branch 10 not taken. ✗ Branch 11 not taken. ✗ Branch 12 not taken. ✗ Branch 13 not taken. ✗ Branch 14 not taken. ✗ Branch 15 not taken.	108188x	while (n < 0 && errno == EINTR);
218
219	4/8 ✓ Branch 0 taken 951 times. ✓ Branch 1 taken 43055 times. ✓ Branch 2 taken 410 times. ✓ Branch 3 taken 63772 times. ✗ Branch 4 not taken. ✗ Branch 5 not taken. ✗ Branch 6 not taken. ✗ Branch 7 not taken.	108188x	if (n >= 0)
220		106827x	this->complete(0, static_cast<std::size_t>(n));
221			else
222	2/8 ✓ Branch 0 taken 951 times. ✗ Branch 1 not taken. ✓ Branch 2 taken 410 times. ✗ Branch 3 not taken. ✗ Branch 4 not taken. ✗ Branch 5 not taken. ✗ Branch 6 not taken. ✗ Branch 7 not taken.	1361x	this->complete(errno, 0);
223		108188x	}
224			};
225
226			/** Shared gather-write operation.
227
228			Delegates the actual syscall to WritePolicy::write(fd, iovecs, count),
229			which returns ssize_t (bytes written or -1 with errno set).
230
231			@tparam Base The backend's base op type.
232			@tparam WritePolicy Provides `static ssize_t write(int, iovec*, int)`.
233			*/
234			template<class Base, class WritePolicy>
235		21888x	struct reactor_write_op : Base
236			{
237			/// The write syscall policy type.
238			using write_policy = WritePolicy;
239
240			/// Maximum scatter-gather buffer count.
241			static constexpr std::size_t max_buffers = 16;
242
243			/// Scatter-gather I/O vectors.
244			iovec iovecs[max_buffers];
245
246			/// Number of active I/O vectors.
247		21888x	int iovec_count = 0;
248
249		885779x	void reset() noexcept
250			{
251		885779x	Base::reset();
252		885779x	iovec_count = 0;
253		885779x	}
254
255		✗	void perform_io() noexcept override
256			{
257		✗	ssize_t n = WritePolicy::write(this->fd, iovecs, iovec_count);
258		✗	if (n >= 0)
259		✗	this->complete(0, static_cast<std::size_t>(n));
260			else
261		✗	this->complete(errno, 0);
262		✗	}
263			};
264
265			/** Shared accept operation.
266
267			Delegates the actual syscall to AcceptPolicy::do_accept(fd, peer_storage),
268			which returns the accepted fd or -1 with errno set.
269
270			@tparam Base The backend's base op type.
271			@tparam AcceptPolicy Provides `static int do_accept(int, sockaddr_storage&)`.
272			*/
273			template<class Base, class AcceptPolicy>
274		1189x	struct reactor_accept_op : Base
275			{
276			/// File descriptor of the accepted connection.
277		1189x	int accepted_fd = -1;
278
279			/// Pointer to the peer socket implementation.
280		1189x	io_object::implementation* peer_impl = nullptr;
281
282			/// Output pointer for the accepted implementation.
283		1189x	io_object::implementation** impl_out = nullptr;
284
285			/// Peer address storage filled by accept.
286		1189x	sockaddr_storage peer_storage{};
287
288			/// Peer address length returned by accept.
289		1189x	socklen_t peer_addrlen = 0;
290
291		7247x	void reset() noexcept
292			{
293		7247x	Base::reset();
294		7247x	accepted_fd = -1;
295		7247x	peer_impl = nullptr;
296		7247x	impl_out = nullptr;
297		7247x	peer_storage = {};
298		7247x	peer_addrlen = 0;
299		7247x	}
300
301		7235x	void perform_io() noexcept override
302			{
303		7235x	int new_fd = AcceptPolicy::do_accept(
304		7235x	this->fd, peer_storage, peer_addrlen);
305	3/8 ✓ Branch 0 taken 1825 times. ✗ Branch 1 not taken. ✓ Branch 2 taken 5408 times. ✗ Branch 3 not taken. ✗ Branch 4 not taken. ✗ Branch 5 not taken. ✓ Branch 6 taken 2 times. ✗ Branch 7 not taken.	7235x	if (new_fd >= 0)
306			{
307		7235x	accepted_fd = new_fd;
308		7235x	this->complete(0, 0);
309		7235x	}
310			else
311			{
312		✗	this->complete(errno, 0);
313			}
314		7235x	}
315			};
316
317			/** Shared connected send operation for datagram sockets.
318
319			Uses sendmsg() with msg_name=nullptr (connected mode).
320
321			@tparam Base The backend's base op type.
322			*/
323			template<class Base>
324		134x	struct reactor_send_op : Base
325			{
326			/// Maximum scatter-gather buffer count.
327			static constexpr std::size_t max_buffers = 16;
328
329			/// Scatter-gather I/O vectors.
330			iovec iovecs[max_buffers];
331
332			/// Number of active I/O vectors.
333		134x	int iovec_count = 0;
334
335			/// User-supplied message flags.
336		134x	int msg_flags = 0;
337
338		14x	void reset() noexcept
339			{
340		14x	Base::reset();
341		14x	iovec_count = 0;
342		14x	msg_flags = 0;
343		14x	}
344
345		✗	void perform_io() noexcept override
346			{
347		✗	msghdr msg{};
348		✗	msg.msg_iov = iovecs;
349		✗	msg.msg_iovlen = static_cast<std::size_t>(iovec_count);
350
351			#ifdef MSG_NOSIGNAL
352		✗	int send_flags = msg_flags \| MSG_NOSIGNAL;
353			#else
354			int send_flags = msg_flags;
355			#endif
356
357			ssize_t n;
358		✗	do
359			{
360		✗	n = ::sendmsg(this->fd, &msg, send_flags);
361		✗	}
362		✗	while (n < 0 && errno == EINTR);
363
364		✗	if (n >= 0)
365		✗	this->complete(0, static_cast<std::size_t>(n));
366			else
367		✗	this->complete(errno, 0);
368		✗	}
369			};
370
371			/** Shared connected recv operation for datagram sockets.
372
373			Uses recvmsg() with msg_name=nullptr (connected mode).
374			Unlike reactor_read_op, does not map n==0 to EOF
375			(zero-length datagrams are valid).
376
377			@tparam Base The backend's base op type.
378			*/
379			template<class Base>
380		134x	struct reactor_recv_op : Base
381			{
382			/// Maximum scatter-gather buffer count.
383			static constexpr std::size_t max_buffers = 16;
384
385			/// Scatter-gather I/O vectors.
386			iovec iovecs[max_buffers];
387
388			/// Number of active I/O vectors.
389		134x	int iovec_count = 0;
390
391			/// User-supplied message flags.
392		134x	int msg_flags = 0;
393
394			/// Return true (this is a read-direction operation).
395		✗	bool is_read_operation() const noexcept override
396			{
397		✗	return true;
398			}
399
400		14x	void reset() noexcept
401			{
402		14x	Base::reset();
403		14x	iovec_count = 0;
404		14x	msg_flags = 0;
405		14x	}
406
407		2x	void perform_io() noexcept override
408			{
409		2x	msghdr msg{};
410		2x	msg.msg_iov = iovecs;
411		2x	msg.msg_iovlen = static_cast<std::size_t>(iovec_count);
412
413			ssize_t n;
414		2x	do
415			{
416	2/8 ✓ Branch 0 taken 1 time. ✗ Branch 1 not taken. ✗ Branch 2 not taken. ✗ Branch 3 not taken. ✓ Branch 4 taken 1 time. ✗ Branch 5 not taken. ✗ Branch 6 not taken. ✗ Branch 7 not taken.	2x	n = ::recvmsg(this->fd, &msg, msg_flags);
417		4x	}
418	2/16 ✗ Branch 0 not taken. ✓ Branch 1 taken 1 time. ✗ Branch 2 not taken. ✗ Branch 3 not taken. ✗ Branch 4 not taken. ✗ Branch 5 not taken. ✗ Branch 6 not taken. ✗ Branch 7 not taken. ✗ Branch 8 not taken. ✓ Branch 9 taken 1 time. ✗ Branch 10 not taken. ✗ Branch 11 not taken. ✗ Branch 12 not taken. ✗ Branch 13 not taken. ✗ Branch 14 not taken. ✗ Branch 15 not taken.	2x	while (n < 0 && errno == EINTR);
419
420	2/8 ✗ Branch 0 not taken. ✓ Branch 1 taken 1 time. ✗ Branch 2 not taken. ✗ Branch 3 not taken. ✗ Branch 4 not taken. ✓ Branch 5 taken 1 time. ✗ Branch 6 not taken. ✗ Branch 7 not taken.	2x	if (n >= 0)
421		2x	this->complete(0, static_cast<std::size_t>(n));
422			else
423		✗	this->complete(errno, 0);
424		2x	}
425			};
426
427			/** Shared send_to operation for datagram sockets.
428
429			Uses sendmsg() with the destination endpoint in msg_name.
430
431			@tparam Base The backend's base op type.
432			*/
433			template<class Base>
434		134x	struct reactor_send_to_op : Base
435			{
436			/// Maximum scatter-gather buffer count.
437			static constexpr std::size_t max_buffers = 16;
438
439			/// Scatter-gather I/O vectors.
440			iovec iovecs[max_buffers];
441
442			/// Number of active I/O vectors.
443		134x	int iovec_count = 0;
444
445			/// Destination address storage.
446		134x	sockaddr_storage dest_storage{};
447
448			/// Destination address length.
449		134x	socklen_t dest_len = 0;
450
451			/// User-supplied message flags.
452		134x	int msg_flags = 0;
453
454		30x	void reset() noexcept
455			{
456		30x	Base::reset();
457		30x	iovec_count = 0;
458		30x	dest_storage = {};
459		30x	dest_len = 0;
460		30x	msg_flags = 0;
461		30x	}
462
463		✗	void perform_io() noexcept override
464			{
465		✗	msghdr msg{};
466		✗	msg.msg_name = &dest_storage;
467		✗	msg.msg_namelen = dest_len;
468		✗	msg.msg_iov = iovecs;
469		✗	msg.msg_iovlen = static_cast<std::size_t>(iovec_count);
470
471			#ifdef MSG_NOSIGNAL
472		✗	int send_flags = msg_flags \| MSG_NOSIGNAL;
473			#else
474			int send_flags = msg_flags;
475			#endif
476
477			ssize_t n;
478		✗	do
479			{
480		✗	n = ::sendmsg(this->fd, &msg, send_flags);
481		✗	}
482		✗	while (n < 0 && errno == EINTR);
483
484		✗	if (n >= 0)
485		✗	this->complete(0, static_cast<std::size_t>(n));
486			else
487		✗	this->complete(errno, 0);
488		✗	}
489			};
490
491			/** Shared recv_from operation for datagram sockets.
492
493			Uses recvmsg() with msg_name to capture the source endpoint.
494
495			@tparam Base The backend's base op type.
496			@tparam Endpoint The endpoint type (endpoint or local_endpoint).
497			*/
498			template<class Base, class Endpoint = endpoint>
499		134x	struct reactor_recv_from_op : Base
500			{
501			/// Maximum scatter-gather buffer count.
502			static constexpr std::size_t max_buffers = 16;
503
504			/// Scatter-gather I/O vectors.
505			iovec iovecs[max_buffers];
506
507			/// Number of active I/O vectors.
508		134x	int iovec_count = 0;
509
510			/// Source address storage filled by recvmsg.
511		134x	sockaddr_storage source_storage{};
512
513			/// Actual source address length returned by recvmsg.
514		134x	socklen_t source_addrlen = 0;
515
516			/// Output pointer for the source endpoint (set by do_recv_from).
517		134x	Endpoint* source_out = nullptr;
518
519			/// User-supplied message flags.
520		134x	int msg_flags = 0;
521
522			/// Return true (this is a read-direction operation).
523		✗	bool is_read_operation() const noexcept override
524			{
525		✗	return true;
526			}
527
528		44x	void reset() noexcept
529			{
530		44x	Base::reset();
531		44x	iovec_count = 0;
532		44x	source_storage = {};
533		44x	source_addrlen = 0;
534		44x	source_out = nullptr;
535		44x	msg_flags = 0;
536		44x	}
537
538		11x	void perform_io() noexcept override
539			{
540		11x	msghdr msg{};
541		11x	msg.msg_name = &source_storage;
542		11x	msg.msg_namelen = sizeof(source_storage);
543		11x	msg.msg_iov = iovecs;
544		11x	msg.msg_iovlen = static_cast<std::size_t>(iovec_count);
545
546			ssize_t n;
547		11x	do
548			{
549	2/8 ✓ Branch 0 taken 9 times. ✗ Branch 1 not taken. ✓ Branch 2 taken 2 times. ✗ Branch 3 not taken. ✗ Branch 4 not taken. ✗ Branch 5 not taken. ✗ Branch 6 not taken. ✗ Branch 7 not taken.	11x	n = ::recvmsg(this->fd, &msg, msg_flags);
550		22x	}
551	2/16 ✗ Branch 0 not taken. ✓ Branch 1 taken 9 times. ✗ Branch 2 not taken. ✗ Branch 3 not taken. ✗ Branch 4 not taken. ✓ Branch 5 taken 2 times. ✗ Branch 6 not taken. ✗ Branch 7 not taken. ✗ Branch 8 not taken. ✗ Branch 9 not taken. ✗ Branch 10 not taken. ✗ Branch 11 not taken. ✗ Branch 12 not taken. ✗ Branch 13 not taken. ✗ Branch 14 not taken. ✗ Branch 15 not taken.	11x	while (n < 0 && errno == EINTR);
552
553	2/8 ✗ Branch 0 not taken. ✓ Branch 1 taken 9 times. ✗ Branch 2 not taken. ✓ Branch 3 taken 2 times. ✗ Branch 4 not taken. ✗ Branch 5 not taken. ✗ Branch 6 not taken. ✗ Branch 7 not taken.	11x	if (n >= 0)
554			{
555		11x	source_addrlen = msg.msg_namelen;
556		11x	this->complete(0, static_cast<std::size_t>(n));
557		11x	}
558			else
559		✗	this->complete(errno, 0);
560		11x	}
561			};
562
563			} // namespace boost::corosio::detail
564
565			#endif // BOOST_COROSIO_NATIVE_DETAIL_REACTOR_REACTOR_OP_HPP
566