include/boost/corosio/native/native_local_datagram_socket.hpp

100.0% Lines (134/0/134) 100.0% List of functions (70/0/70)

[ ] prev/next file

native_local_datagram_socket.hpp

f(x) Functions (70)

Function Calls Lines Blocks

Line	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_LOCAL_DATAGRAM_SOCKET_HPP
12		#define BOOST_COROSIO_NATIVE_NATIVE_LOCAL_DATAGRAM_SOCKET_HPP
13
14		#include <boost/corosio/detail/platform.hpp>
15
16		#if BOOST_COROSIO_POSIX
17
18		#include <boost/corosio/local_datagram_socket.hpp>
19		#include <boost/corosio/backend.hpp>
20
21		#ifndef BOOST_COROSIO_MRDOCS
22		#if BOOST_COROSIO_HAS_EPOLL
23		#include <boost/corosio/native/detail/epoll/epoll_types.hpp>
24		#endif
25
26		#if BOOST_COROSIO_HAS_SELECT
27		#include <boost/corosio/native/detail/select/select_types.hpp>
28		#endif
29
30		#if BOOST_COROSIO_HAS_KQUEUE
31		#include <boost/corosio/native/detail/kqueue/kqueue_types.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 Unix datagram socket with devirtualized I/O.
42
43		This class template inherits from @ref local_datagram_socket
44		and shadows the async operations (`send_to`, `recv_from`,
45		`connect`, `send`, `recv`) with versions that call the backend
46		implementation directly, allowing the compiler to inline
47		through the entire call chain.
48
49		Non-async operations (`open`, `close`, `cancel`, `bind`,
50		socket options) remain unchanged and dispatch through the
51		compiled library.
52
53		A `native_local_datagram_socket` IS-A `local_datagram_socket`
54		and can be passed to any function expecting
55		`local_datagram_socket&`, in which case virtual dispatch is
56		used transparently.
57
58		@tparam Backend A backend tag value (e.g., `epoll`) whose type
59		provides the concrete implementation types.
60
61		@par Thread Safety
62		Same as @ref local_datagram_socket.
63
64		@par Example
65		@par !example open_bind_recv
66
67		@see local_datagram_socket, epoll_t, iocp_t
68		*/
69		template<auto Backend>
70		class native_local_datagram_socket : public local_datagram_socket
71		{
72		using backend_type = decltype(Backend);
73		using impl_type = typename backend_type::local_datagram_socket_type;
74		using service_type = typename backend_type::local_datagram_service_type;
75
76	32x	impl_type& get_impl() noexcept
77		{
78	32x	return static_cast<impl_type>(h_.get());
79		}
80
81		template<class ConstBufferSequence>
82		struct native_send_to_awaitable
83		{
84		native_local_datagram_socket& self_;
85		ConstBufferSequence buffers_;
86		corosio::local_endpoint dest_;
87		int flags_;
88		std::stop_token token_;
89		mutable std::error_code ec_;
90		mutable std::size_t bytes_transferred_ = 0;
91
92	8x	native_send_to_awaitable(
93		native_local_datagram_socket& self,
94		ConstBufferSequence buffers,
95		corosio::local_endpoint dest,
96		int flags) noexcept
97	8x	: self_(self)
98	8x	, buffers_(std::move(buffers))
99	8x	, dest_(dest)
100	8x	, flags_(flags)
101		{
102	8x	}
103
104	8x	bool await_ready() const noexcept
105		{
106		// A pre-set ec_ means the initiator failed before
107		// dispatch (e.g. a closed object).
108	8x	return static_cast<bool>(ec_) \|\| token_.stop_requested();
109		}
110
111	8x	[[nodiscard]] capy::io_result<std::size_t> await_resume() const noexcept
112		{
113	8x	if (token_.stop_requested())
114	2x	return {make_error_code(std::errc::operation_canceled), 0};
115	6x	return {ec_, bytes_transferred_};
116		}
117
118	6x	auto await_suspend(std::coroutine_handle<> h, capy::io_env const* env)
119		-> std::coroutine_handle<>
120		{
121	6x	token_ = env->stop_token;
122	18x	return self_.get_impl().send_to(
123	6x	h, env->executor, buffers_, dest_, flags_,
124	18x	token_, &ec_, &bytes_transferred_);
125		}
126		};
127
128		template<class MutableBufferSequence>
129		struct native_recv_from_awaitable
130		{
131		native_local_datagram_socket& self_;
132		MutableBufferSequence buffers_;
133		corosio::local_endpoint& source_;
134		int flags_;
135		std::stop_token token_;
136		mutable std::error_code ec_;
137		mutable std::size_t bytes_transferred_ = 0;
138
139	6x	native_recv_from_awaitable(
140		native_local_datagram_socket& self,
141		MutableBufferSequence buffers,
142		corosio::local_endpoint& source,
143		int flags) noexcept
144	6x	: self_(self)
145	6x	, buffers_(std::move(buffers))
146	6x	, source_(source)
147	6x	, flags_(flags)
148		{
149	6x	}
150
151	6x	bool await_ready() const noexcept
152		{
153		// A pre-set ec_ means the initiator failed before
154		// dispatch (e.g. a closed object).
155	6x	return static_cast<bool>(ec_) \|\| token_.stop_requested();
156		}
157
158	6x	[[nodiscard]] capy::io_result<std::size_t> await_resume() const noexcept
159		{
160	6x	if (token_.stop_requested())
161	2x	return {make_error_code(std::errc::operation_canceled), 0};
162	4x	return {ec_, bytes_transferred_};
163		}
164
165	4x	auto await_suspend(std::coroutine_handle<> h, capy::io_env const* env)
166		-> std::coroutine_handle<>
167		{
168	4x	token_ = env->stop_token;
169	12x	return self_.get_impl().recv_from(
170	4x	h, env->executor, buffers_, &source_, flags_,
171	12x	token_, &ec_, &bytes_transferred_);
172		}
173		};
174
175		struct native_wait_awaitable
176		{
177		native_local_datagram_socket& self_;
178		wait_type w_;
179		std::stop_token token_;
180		mutable std::error_code ec_;
181
182	4x	native_wait_awaitable(
183		native_local_datagram_socket& self, wait_type w) noexcept
184	4x	: self_(self)
185	4x	, w_(w)
186		{
187	4x	}
188
189	4x	bool await_ready() const noexcept
190		{
191		// A pre-set ec_ means the initiator failed before
192		// dispatch (e.g. auto-open).
193	4x	return static_cast<bool>(ec_) \|\| token_.stop_requested();
194		}
195
196	4x	[[nodiscard]] capy::io_result<> await_resume() const noexcept
197		{
198	4x	if (token_.stop_requested())
199	2x	return {make_error_code(std::errc::operation_canceled)};
200	2x	return {ec_};
201		}
202
203	4x	auto await_suspend(std::coroutine_handle<> h, capy::io_env const* env)
204		-> std::coroutine_handle<>
205		{
206	4x	token_ = env->stop_token;
207	12x	return self_.get_impl().wait(
208	12x	h, env->executor, w_, token_, &ec_);
209		}
210		};
211
212		struct native_connect_awaitable
213		{
214		native_local_datagram_socket& self_;
215		corosio::local_endpoint endpoint_;
216		std::stop_token token_;
217		mutable std::error_code ec_;
218
219	10x	native_connect_awaitable(
220		native_local_datagram_socket& self,
221		corosio::local_endpoint ep) noexcept
222	10x	: self_(self)
223	10x	, endpoint_(ep)
224		{
225	10x	}
226
227	10x	bool await_ready() const noexcept
228		{
229		// A pre-set ec_ means the initiator failed before
230		// dispatch (e.g. a closed object).
231	10x	return static_cast<bool>(ec_) \|\| token_.stop_requested();
232		}
233
234	10x	[[nodiscard]] capy::io_result<> await_resume() const noexcept
235		{
236	10x	if (token_.stop_requested())
237	2x	return {make_error_code(std::errc::operation_canceled)};
238	8x	return {ec_};
239		}
240
241	10x	auto await_suspend(std::coroutine_handle<> h, capy::io_env const* env)
242		-> std::coroutine_handle<>
243		{
244	10x	token_ = env->stop_token;
245	30x	return self_.get_impl().connect(
246	30x	h, env->executor, endpoint_, token_, &ec_);
247		}
248		};
249
250		template<class ConstBufferSequence>
251		struct native_send_awaitable
252		{
253		native_local_datagram_socket& self_;
254		ConstBufferSequence buffers_;
255		int flags_;
256		std::stop_token token_;
257		mutable std::error_code ec_;
258		mutable std::size_t bytes_transferred_ = 0;
259
260	6x	native_send_awaitable(
261		native_local_datagram_socket& self,
262		ConstBufferSequence buffers,
263		int flags) noexcept
264	6x	: self_(self)
265	6x	, buffers_(std::move(buffers))
266	6x	, flags_(flags)
267		{
268	6x	}
269
270	6x	bool await_ready() const noexcept
271		{
272		// A pre-set ec_ means the initiator failed before
273		// dispatch (e.g. a closed object).
274	6x	return static_cast<bool>(ec_) \|\| token_.stop_requested();
275		}
276
277	6x	[[nodiscard]] capy::io_result<std::size_t> await_resume() const noexcept
278		{
279	6x	if (token_.stop_requested())
280	2x	return {make_error_code(std::errc::operation_canceled), 0};
281	4x	return {ec_, bytes_transferred_};
282		}
283
284	4x	auto await_suspend(std::coroutine_handle<> h, capy::io_env const* env)
285		-> std::coroutine_handle<>
286		{
287	4x	token_ = env->stop_token;
288	12x	return self_.get_impl().send(
289	4x	h, env->executor, buffers_, flags_,
290	12x	token_, &ec_, &bytes_transferred_);
291		}
292		};
293
294		template<class MutableBufferSequence>
295		struct native_recv_awaitable
296		{
297		native_local_datagram_socket& self_;
298		MutableBufferSequence buffers_;
299		int flags_;
300		std::stop_token token_;
301		mutable std::error_code ec_;
302		mutable std::size_t bytes_transferred_ = 0;
303
304	6x	native_recv_awaitable(
305		native_local_datagram_socket& self,
306		MutableBufferSequence buffers,
307		int flags) noexcept
308	6x	: self_(self)
309	6x	, buffers_(std::move(buffers))
310	6x	, flags_(flags)
311		{
312	6x	}
313
314	6x	bool await_ready() const noexcept
315		{
316		// A pre-set ec_ means the initiator failed before
317		// dispatch (e.g. a closed object).
318	6x	return static_cast<bool>(ec_) \|\| token_.stop_requested();
319		}
320
321	6x	[[nodiscard]] capy::io_result<std::size_t> await_resume() const noexcept
322		{
323	6x	if (token_.stop_requested())
324	2x	return {make_error_code(std::errc::operation_canceled), 0};
325	4x	return {ec_, bytes_transferred_};
326		}
327
328	4x	auto await_suspend(std::coroutine_handle<> h, capy::io_env const* env)
329		-> std::coroutine_handle<>
330		{
331	4x	token_ = env->stop_token;
332	12x	return self_.get_impl().recv(
333	4x	h, env->executor, buffers_, flags_,
334	12x	token_, &ec_, &bytes_transferred_);
335		}
336		};
337
338		public:
339		/** Construct a native socket from an execution context.
340
341		@param ctx The execution context that will own this socket.
342		*/
343	30x	explicit native_local_datagram_socket(capy::execution_context& ctx)
344	30x	: local_datagram_socket(create_handle<service_type>(ctx))
345		{
346	30x	}
347
348		/** Construct a native socket from an executor.
349
350		@param ex The executor whose context will own the socket.
351		*/
352		template<class Ex>
353		requires(!std::same_as<
354		std::remove_cvref_t<Ex>,
355		native_local_datagram_socket>) &&
356		capy::Executor<Ex>
357		explicit native_local_datagram_socket(Ex const& ex)
358		: native_local_datagram_socket(ex.context())
359		{
360		}
361
362		/// Move construct.
363		native_local_datagram_socket(native_local_datagram_socket&&) noexcept =
364		default;
365
366		/// Move assign.
367		native_local_datagram_socket&
368		operator=(native_local_datagram_socket&&) noexcept = default;
369
370		native_local_datagram_socket(native_local_datagram_socket const&) = delete;
371		native_local_datagram_socket&
372		operator=(native_local_datagram_socket const&) = delete;
373
374		/** Send a datagram to the specified destination.
375
376		Calls the backend implementation directly, bypassing virtual
377		dispatch. Otherwise identical to @ref local_datagram_socket::send_to.
378		*/
379		template<capy::ConstBufferSequence CB>
380	8x	[[nodiscard]] auto send_to(
381		CB const& buffers,
382		corosio::local_endpoint dest,
383		corosio::message_flags flags)
384		{
385	8x	native_send_to_awaitable<CB> aw(*this, buffers, dest, static_cast<int>(flags));
386	8x	if (!is_open())
387	2x	aw.ec_ = make_error_code(std::errc::bad_file_descriptor);
388	8x	return aw;
389		}
390
391		/// @overload
392		template<capy::ConstBufferSequence CB>
393	8x	[[nodiscard]] auto send_to(CB const& buffers, corosio::local_endpoint dest)
394		{
395	8x	return send_to(buffers, dest, corosio::message_flags::none);
396		}
397
398		/** Receive a datagram and capture the sender's endpoint.
399
400		Calls the backend implementation directly, bypassing virtual
401		dispatch. Otherwise identical to @ref local_datagram_socket::recv_from.
402		*/
403		template<capy::MutableBufferSequence MB>
404	6x	[[nodiscard]] auto recv_from(
405		MB const& buffers,
406		corosio::local_endpoint& source,
407		corosio::message_flags flags)
408		{
409	6x	native_recv_from_awaitable<MB> aw(*this, buffers, source, static_cast<int>(flags));
410	6x	if (!is_open())
411	2x	aw.ec_ = make_error_code(std::errc::bad_file_descriptor);
412	6x	return aw;
413		}
414
415		/// @overload
416		template<capy::MutableBufferSequence MB>
417	6x	[[nodiscard]] auto recv_from(MB const& buffers, corosio::local_endpoint& source)
418		{
419	6x	return recv_from(buffers, source, corosio::message_flags::none);
420		}
421
422		/** Asynchronously connect to set the default peer.
423
424		Calls the backend implementation directly, bypassing virtual
425		dispatch. Otherwise identical to @ref local_datagram_socket::connect.
426
427		If the socket is not already open, it is opened automatically.
428		*/
429	10x	[[nodiscard]] auto connect(corosio::local_endpoint ep)
430		{
431	10x	native_connect_awaitable aw(*this, ep);
432	10x	if (!is_open())
433	2x	aw.ec_ = open();
434	10x	return aw;
435		}
436
437		/** Send a datagram to the connected peer.
438
439		Calls the backend implementation directly, bypassing virtual
440		dispatch. Otherwise identical to @ref local_datagram_socket::send.
441		*/
442		template<capy::ConstBufferSequence CB>
443	6x	[[nodiscard]] auto send(CB const& buffers, corosio::message_flags flags)
444		{
445	6x	native_send_awaitable<CB> aw(*this, buffers, static_cast<int>(flags));
446	6x	if (!is_open())
447	2x	aw.ec_ = make_error_code(std::errc::bad_file_descriptor);
448	6x	return aw;
449		}
450
451		/// @overload
452		template<capy::ConstBufferSequence CB>
453	6x	[[nodiscard]] auto send(CB const& buffers)
454		{
455	6x	return send(buffers, corosio::message_flags::none);
456		}
457
458		/** Receive a datagram from the connected peer.
459
460		Calls the backend implementation directly, bypassing virtual
461		dispatch. Otherwise identical to @ref local_datagram_socket::recv.
462		*/
463		template<capy::MutableBufferSequence MB>
464	6x	[[nodiscard]] auto recv(MB const& buffers, corosio::message_flags flags)
465		{
466	6x	native_recv_awaitable<MB> aw(*this, buffers, static_cast<int>(flags));
467	6x	if (!is_open())
468	2x	aw.ec_ = make_error_code(std::errc::bad_file_descriptor);
469	6x	return aw;
470		}
471
472		/// @overload
473		template<capy::MutableBufferSequence MB>
474	6x	[[nodiscard]] auto recv(MB const& buffers)
475		{
476	6x	return recv(buffers, corosio::message_flags::none);
477		}
478
479		/** Asynchronously wait for the socket to be ready.
480
481		Calls the backend implementation directly, bypassing virtual
482		dispatch. Otherwise identical to @ref local_datagram_socket::wait.
483
484		@param w The wait direction (read, write, or error).
485
486		@return An awaitable yielding `io_result<>`.
487		*/
488	4x	[[nodiscard]] auto wait(wait_type w)
489		{
490	4x	return native_wait_awaitable(*this, w);
491		}
492		};
493
494		} // namespace boost::corosio
495
496		#endif // BOOST_COROSIO_POSIX
497
498		#endif // BOOST_COROSIO_NATIVE_NATIVE_LOCAL_DATAGRAM_SOCKET_HPP
499