include/boost/corosio/native/detail/posix/posix_resolver_service.hpp

95.2% Lines (277/291) 93.5% List of functions (29/31)

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

posix_resolver_service.hpp

f(x) Functions (31)

Function Calls Lines Blocks

Line	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_POSIX_POSIX_RESOLVER_SERVICE_HPP
11		#define BOOST_COROSIO_NATIVE_DETAIL_POSIX_POSIX_RESOLVER_SERVICE_HPP
12
13		#include <boost/corosio/detail/platform.hpp>
14
15		#if BOOST_COROSIO_POSIX
16
17		#include <boost/corosio/native/detail/posix/posix_resolver.hpp>
18		#include <boost/corosio/native/detail/reactor/reactor_scheduler.hpp>
19		#include <boost/corosio/detail/thread_pool.hpp>
20
21		#include <unordered_map>
22
23		namespace boost::corosio::detail {
24
25		/** Resolver service for POSIX backends.
26
27		Owns all posix_resolver instances. Thread lifecycle is managed
28		by the thread_pool service.
29		*/
30		class BOOST_COROSIO_DECL posix_resolver_service final
31		: public capy::execution_context::service
32		, public io_object::io_service
33		{
34		public:
35		using key_type = posix_resolver_service;
36
37	1018x	posix_resolver_service(capy::execution_context& ctx, scheduler& sched)
38	2036x	: sched_(&sched)
39	1018x	, pool_(ctx.use_service<thread_pool>())
40		{
41	1018x	}
42
43	2036x	~posix_resolver_service() override = default;
44
45		posix_resolver_service(posix_resolver_service const&) = delete;
46		posix_resolver_service& operator=(posix_resolver_service const&) = delete;
47
48		io_object::implementation* construct() override;
49
50	42x	void destroy(io_object::implementation* p) override
51		{
52	42x	auto& impl = static_cast<posix_resolver&>(*p);
53	42x	impl.cancel();
54	42x	destroy_impl(impl);
55	42x	}
56
57		void shutdown() override;
58		void destroy_impl(posix_resolver& impl);
59
60		void post(scheduler_op* op);
61		void work_started() noexcept;
62		void work_finished() noexcept;
63
64		/** Return the resolver thread pool. */
65	33x	thread_pool& pool() noexcept
66		{
67	33x	return pool_;
68		}
69
70		/** Return true if single-threaded mode is active. */
71	35x	bool single_threaded() const noexcept
72		{
73	35x	return static_cast<reactor_scheduler const*>(sched_)
74	35x	->is_single_threaded();
75		}
76
77		private:
78		scheduler* sched_;
79		thread_pool& pool_;
80		std::mutex mutex_;
81		intrusive_list<posix_resolver> resolver_list_;
82		std::unordered_map<posix_resolver*, std::shared_ptr<posix_resolver>>
83		resolver_ptrs_;
84		};
85
86		/** Get or create the resolver service for the given context.
87
88		This function is called by the concrete scheduler during initialization
89		to create the resolver service with a reference to itself.
90
91		@param ctx Reference to the owning execution_context.
92		@param sched Reference to the scheduler for posting completions.
93		@return Reference to the resolver service.
94		*/
95		posix_resolver_service&
96		get_resolver_service(capy::execution_context& ctx, scheduler& sched);
97
98		// ---------------------------------------------------------------------------
99		// Inline implementation
100		// ---------------------------------------------------------------------------
101
102		// posix_resolver_detail helpers
103
104		inline int
105	21x	posix_resolver_detail::flags_to_hints(resolve_flags flags)
106		{
107	21x	int hints = 0;
108
109	21x	if ((flags & resolve_flags::passive) != resolve_flags::none)
110	1x	hints \|= AI_PASSIVE;
111	21x	if ((flags & resolve_flags::numeric_host) != resolve_flags::none)
112	12x	hints \|= AI_NUMERICHOST;
113	21x	if ((flags & resolve_flags::numeric_service) != resolve_flags::none)
114	9x	hints \|= AI_NUMERICSERV;
115	21x	if ((flags & resolve_flags::address_configured) != resolve_flags::none)
116	1x	hints \|= AI_ADDRCONFIG;
117	21x	if ((flags & resolve_flags::v4_mapped) != resolve_flags::none)
118	1x	hints \|= AI_V4MAPPED;
119	21x	if ((flags & resolve_flags::all_matching) != resolve_flags::none)
120	1x	hints \|= AI_ALL;
121
122	21x	return hints;
123		}
124
125		inline int
126	12x	posix_resolver_detail::flags_to_ni_flags(reverse_flags flags)
127		{
128	12x	int ni_flags = 0;
129
130	12x	if ((flags & reverse_flags::numeric_host) != reverse_flags::none)
131	6x	ni_flags \|= NI_NUMERICHOST;
132	12x	if ((flags & reverse_flags::numeric_service) != reverse_flags::none)
133	6x	ni_flags \|= NI_NUMERICSERV;
134	12x	if ((flags & reverse_flags::name_required) != reverse_flags::none)
135	1x	ni_flags \|= NI_NAMEREQD;
136	12x	if ((flags & reverse_flags::datagram_service) != reverse_flags::none)
137	1x	ni_flags \|= NI_DGRAM;
138
139	12x	return ni_flags;
140		}
141
142		inline resolver_results
143	16x	posix_resolver_detail::convert_results(
144		struct addrinfo* ai, std::string_view host, std::string_view service)
145		{
146	16x	std::vector<resolver_entry> entries;
147	16x	entries.reserve(4); // Most lookups return 1-4 addresses
148
149	32x	for (auto* p = ai; p != nullptr; p = p->ai_next)
150		{
151	16x	if (p->ai_family == AF_INET)
152		{
153	14x	auto* addr = reinterpret_cast<sockaddr_in*>(p->ai_addr);
154	14x	auto ep = from_sockaddr_in(*addr);
155	14x	entries.emplace_back(ep, host, service);
156		}
157	2x	else if (p->ai_family == AF_INET6)
158		{
159	2x	auto* addr = reinterpret_cast<sockaddr_in6*>(p->ai_addr);
160	2x	auto ep = from_sockaddr_in6(*addr);
161	2x	entries.emplace_back(ep, host, service);
162		}
163		}
164
165	32x	return resolver_results(std::move(entries));
166	16x	}
167
168		inline std::error_code
169	14x	posix_resolver_detail::make_gai_error(int gai_err)
170		{
171		// Map GAI errors to appropriate generic error codes
172	14x	switch (gai_err)
173		{
174	1x	case EAI_AGAIN:
175		// Temporary failure - try again later
176	1x	return std::error_code(
177		static_cast<int>(std::errc::resource_unavailable_try_again),
178	1x	std::generic_category());
179
180	1x	case EAI_BADFLAGS:
181		// Invalid flags
182	1x	return std::error_code(
183		static_cast<int>(std::errc::invalid_argument),
184	1x	std::generic_category());
185
186	1x	case EAI_FAIL:
187		// Non-recoverable failure
188	1x	return std::error_code(
189	1x	static_cast<int>(std::errc::io_error), std::generic_category());
190
191	1x	case EAI_FAMILY:
192		// Address family not supported
193	1x	return std::error_code(
194		static_cast<int>(std::errc::address_family_not_supported),
195	1x	std::generic_category());
196
197	1x	case EAI_MEMORY:
198		// Memory allocation failure
199	1x	return std::error_code(
200		static_cast<int>(std::errc::not_enough_memory),
201	1x	std::generic_category());
202
203	5x	case EAI_NONAME:
204		// Host or service not found
205	5x	return std::error_code(
206		static_cast<int>(std::errc::no_such_device_or_address),
207	5x	std::generic_category());
208
209	1x	case EAI_SERVICE:
210		// Service not supported for socket type
211	1x	return std::error_code(
212		static_cast<int>(std::errc::invalid_argument),
213	1x	std::generic_category());
214
215	1x	case EAI_SOCKTYPE:
216		// Socket type not supported
217	1x	return std::error_code(
218		static_cast<int>(std::errc::not_supported),
219	1x	std::generic_category());
220
221	1x	case EAI_SYSTEM:
222		// System error - use errno
223	1x	return std::error_code(errno, std::generic_category());
224
225	1x	default:
226		// Unknown error
227	1x	return std::error_code(
228	1x	static_cast<int>(std::errc::io_error), std::generic_category());
229		}
230		}
231
232		// posix_resolver
233
234	42x	inline posix_resolver::posix_resolver(posix_resolver_service& svc) noexcept
235	42x	: svc_(svc)
236		{
237	42x	}
238
239		// posix_resolver::resolve_op implementation
240
241		inline void
242	21x	posix_resolver::resolve_op::reset() noexcept
243		{
244	21x	host.clear();
245	21x	service.clear();
246	21x	flags = resolve_flags::none;
247	21x	stored_results = resolver_results{};
248	21x	gai_error = 0;
249	21x	cancelled.store(false, std::memory_order_relaxed);
250	21x	stop_cb.reset();
251	21x	ec_out = nullptr;
252	21x	out = nullptr;
253	21x	}
254
255		inline void
256	21x	posix_resolver::resolve_op::operator()()
257		{
258	21x	stop_cb.reset(); // Disconnect stop callback
259
260	21x	bool const was_cancelled = cancelled.load(std::memory_order_acquire);
261
262	21x	if (ec_out)
263		{
264	21x	if (was_cancelled)
265	1x	*ec_out = capy::error::canceled;
266	20x	else if (gai_error != 0)
267	4x	*ec_out = posix_resolver_detail::make_gai_error(gai_error);
268		else
269	16x	*ec_out = {}; // Clear on success
270		}
271
272	21x	if (out && !was_cancelled && gai_error == 0)
273	16x	*out = std::move(stored_results);
274
275	21x	impl->svc_.work_finished();
276	21x	cont_op.cont.h = h;
277	21x	dispatch_coro(ex, cont_op.cont).resume();
278	21x	}
279
280		inline void
281	✗	posix_resolver::resolve_op::destroy()
282		{
283	✗	stop_cb.reset();
284	✗	}
285
286		inline void
287	47x	posix_resolver::resolve_op::request_cancel() noexcept
288		{
289	47x	cancelled.store(true, std::memory_order_release);
290	47x	}
291
292		inline void
293	21x	posix_resolver::resolve_op::start(std::stop_token const& token)
294		{
295	21x	cancelled.store(false, std::memory_order_release);
296	21x	stop_cb.reset();
297
298	21x	if (token.stop_possible())
299	1x	stop_cb.emplace(token, canceller{this});
300	21x	}
301
302		// posix_resolver::reverse_resolve_op implementation
303
304		inline void
305	12x	posix_resolver::reverse_resolve_op::reset() noexcept
306		{
307	12x	ep = endpoint{};
308	12x	flags = reverse_flags::none;
309	12x	stored_host.clear();
310	12x	stored_service.clear();
311	12x	gai_error = 0;
312	12x	cancelled.store(false, std::memory_order_relaxed);
313	12x	stop_cb.reset();
314	12x	ec_out = nullptr;
315	12x	result_out = nullptr;
316	12x	}
317
318		inline void
319	12x	posix_resolver::reverse_resolve_op::operator()()
320		{
321	12x	stop_cb.reset(); // Disconnect stop callback
322
323	12x	bool const was_cancelled = cancelled.load(std::memory_order_acquire);
324
325	12x	if (ec_out)
326		{
327	12x	if (was_cancelled)
328	1x	*ec_out = capy::error::canceled;
329	11x	else if (gai_error != 0)
330	1x	*ec_out = posix_resolver_detail::make_gai_error(gai_error);
331		else
332	10x	*ec_out = {}; // Clear on success
333		}
334
335	12x	if (result_out && !was_cancelled && gai_error == 0)
336		{
337	30x	*result_out = reverse_resolver_result(
338	30x	ep, std::move(stored_host), std::move(stored_service));
339		}
340
341	12x	impl->svc_.work_finished();
342	12x	cont_op.cont.h = h;
343	12x	dispatch_coro(ex, cont_op.cont).resume();
344	12x	}
345
346		inline void
347	✗	posix_resolver::reverse_resolve_op::destroy()
348		{
349	✗	stop_cb.reset();
350	✗	}
351
352		inline void
353	47x	posix_resolver::reverse_resolve_op::request_cancel() noexcept
354		{
355	47x	cancelled.store(true, std::memory_order_release);
356	47x	}
357
358		inline void
359	12x	posix_resolver::reverse_resolve_op::start(std::stop_token const& token)
360		{
361	12x	cancelled.store(false, std::memory_order_release);
362	12x	stop_cb.reset();
363
364	12x	if (token.stop_possible())
365	1x	stop_cb.emplace(token, canceller{this});
366	12x	}
367
368		// posix_resolver implementation
369
370		inline std::coroutine_handle<>
371	22x	posix_resolver::resolve(
372		std::coroutine_handle<> h,
373		capy::executor_ref ex,
374		std::string_view host,
375		std::string_view service,
376		resolve_flags flags,
377		std::stop_token token,
378		std::error_code* ec,
379		resolver_results* out)
380		{
381	22x	if (svc_.single_threaded())
382		{
383	1x	*ec = std::make_error_code(std::errc::operation_not_supported);
384	1x	op_.cont_op.cont.h = h;
385	1x	return dispatch_coro(ex, op_.cont_op.cont);
386		}
387
388	21x	auto& op = op_;
389	21x	op.reset();
390	21x	op.h = h;
391	21x	op.ex = ex;
392	21x	op.impl = this;
393	21x	op.ec_out = ec;
394	21x	op.out = out;
395	21x	op.host = host;
396	21x	op.service = service;
397	21x	op.flags = flags;
398	21x	op.start(token);
399
400		// Keep io_context alive while resolution is pending
401	21x	op.ex.on_work_started();
402
403		// Prevent impl destruction while work is in flight
404	21x	resolve_pool_op_.resolver_ = this;
405	21x	resolve_pool_op_.ref_ = this->shared_from_this();
406	21x	resolve_pool_op_.func_ = &posix_resolver::do_resolve_work;
407	21x	if (!svc_.pool().post(&resolve_pool_op_))
408		{
409		// Pool shut down — complete with cancellation
410	✗	resolve_pool_op_.ref_.reset();
411	✗	op.cancelled.store(true, std::memory_order_release);
412	✗	svc_.post(&op_);
413		}
414	21x	return std::noop_coroutine();
415		}
416
417		inline std::coroutine_handle<>
418	13x	posix_resolver::reverse_resolve(
419		std::coroutine_handle<> h,
420		capy::executor_ref ex,
421		endpoint const& ep,
422		reverse_flags flags,
423		std::stop_token token,
424		std::error_code* ec,
425		reverse_resolver_result* result_out)
426		{
427	13x	if (svc_.single_threaded())
428		{
429	1x	*ec = std::make_error_code(std::errc::operation_not_supported);
430	1x	reverse_op_.cont_op.cont.h = h;
431	1x	return dispatch_coro(ex, reverse_op_.cont_op.cont);
432		}
433
434	12x	auto& op = reverse_op_;
435	12x	op.reset();
436	12x	op.h = h;
437	12x	op.ex = ex;
438	12x	op.impl = this;
439	12x	op.ec_out = ec;
440	12x	op.result_out = result_out;
441	12x	op.ep = ep;
442	12x	op.flags = flags;
443	12x	op.start(token);
444
445		// Keep io_context alive while resolution is pending
446	12x	op.ex.on_work_started();
447
448		// Prevent impl destruction while work is in flight
449	12x	reverse_pool_op_.resolver_ = this;
450	12x	reverse_pool_op_.ref_ = this->shared_from_this();
451	12x	reverse_pool_op_.func_ = &posix_resolver::do_reverse_resolve_work;
452	12x	if (!svc_.pool().post(&reverse_pool_op_))
453		{
454		// Pool shut down — complete with cancellation
455	✗	reverse_pool_op_.ref_.reset();
456	✗	op.cancelled.store(true, std::memory_order_release);
457	✗	svc_.post(&reverse_op_);
458		}
459	12x	return std::noop_coroutine();
460		}
461
462		inline void
463	46x	posix_resolver::cancel() noexcept
464		{
465	46x	op_.request_cancel();
466	46x	reverse_op_.request_cancel();
467	46x	}
468
469		inline void
470	21x	posix_resolver::do_resolve_work(pool_work_item* w) noexcept
471		{
472	21x	auto* pw = static_cast<pool_op*>(w);
473	21x	auto* self = pw->resolver_;
474
475	21x	struct addrinfo hints{};
476	21x	hints.ai_family = AF_UNSPEC;
477	21x	hints.ai_socktype = SOCK_STREAM;
478	21x	hints.ai_flags = posix_resolver_detail::flags_to_hints(self->op_.flags);
479
480	21x	struct addrinfo* ai = nullptr;
481	63x	int result = ::getaddrinfo(
482	42x	self->op_.host.empty() ? nullptr : self->op_.host.c_str(),
483	42x	self->op_.service.empty() ? nullptr : self->op_.service.c_str(), &hints,
484		&ai);
485
486	21x	if (!self->op_.cancelled.load(std::memory_order_acquire))
487		{
488	20x	if (result == 0 && ai)
489		{
490	32x	self->op_.stored_results = posix_resolver_detail::convert_results(
491	16x	ai, self->op_.host, self->op_.service);
492	16x	self->op_.gai_error = 0;
493		}
494		else
495		{
496	4x	self->op_.gai_error = result;
497		}
498		}
499
500	21x	if (ai)
501	17x	::freeaddrinfo(ai);
502
503		// Move ref to stack before post — post may trigger destroy_impl
504		// which erases the last shared_ptr, destroying self (and pw)
505	21x	auto ref = std::move(pw->ref_);
506	21x	self->svc_.post(&self->op_);
507	21x	}
508
509		inline void
510	12x	posix_resolver::do_reverse_resolve_work(pool_work_item* w) noexcept
511		{
512	12x	auto* pw = static_cast<pool_op*>(w);
513	12x	auto* self = pw->resolver_;
514
515	12x	sockaddr_storage ss{};
516		socklen_t ss_len;
517
518	12x	if (self->reverse_op_.ep.is_v4())
519		{
520	10x	auto sa = to_sockaddr_in(self->reverse_op_.ep);
521	10x	std::memcpy(&ss, &sa, sizeof(sa));
522	10x	ss_len = sizeof(sockaddr_in);
523		}
524		else
525		{
526	2x	auto sa = to_sockaddr_in6(self->reverse_op_.ep);
527	2x	std::memcpy(&ss, &sa, sizeof(sa));
528	2x	ss_len = sizeof(sockaddr_in6);
529		}
530
531		char host[NI_MAXHOST];
532		char service[NI_MAXSERV];
533
534	12x	int result = ::getnameinfo(
535		reinterpret_cast<sockaddr*>(&ss), ss_len, host, sizeof(host), service,
536		sizeof(service),
537		posix_resolver_detail::flags_to_ni_flags(self->reverse_op_.flags));
538
539	12x	if (!self->reverse_op_.cancelled.load(std::memory_order_acquire))
540		{
541	11x	if (result == 0)
542		{
543	10x	self->reverse_op_.stored_host = host;
544	10x	self->reverse_op_.stored_service = service;
545	10x	self->reverse_op_.gai_error = 0;
546		}
547		else
548		{
549	1x	self->reverse_op_.gai_error = result;
550		}
551		}
552
553		// Move ref to stack before post — post may trigger destroy_impl
554		// which erases the last shared_ptr, destroying self (and pw)
555	12x	auto ref = std::move(pw->ref_);
556	12x	self->svc_.post(&self->reverse_op_);
557	12x	}
558
559		// posix_resolver_service implementation
560
561		inline void
562	1018x	posix_resolver_service::shutdown()
563		{
564	1018x	std::lock_guard<std::mutex> lock(mutex_);
565
566		// Cancel all resolvers (sets cancelled flag checked by pool threads)
567	1018x	for (auto* impl = resolver_list_.pop_front(); impl != nullptr;
568	✗	impl = resolver_list_.pop_front())
569		{
570	✗	impl->cancel();
571		}
572
573		// Clear the map which releases shared_ptrs.
574		// The thread pool service shuts down separately via
575		// execution_context service ordering.
576	1018x	resolver_ptrs_.clear();
577	1018x	}
578
579		inline io_object::implementation*
580	42x	posix_resolver_service::construct()
581		{
582	42x	auto ptr = std::make_shared<posix_resolver>(*this);
583	42x	auto* impl = ptr.get();
584
585		{
586	42x	std::lock_guard<std::mutex> lock(mutex_);
587	42x	resolver_list_.push_back(impl);
588	42x	resolver_ptrs_[impl] = std::move(ptr);
589	42x	}
590
591	42x	return impl;
592	42x	}
593
594		inline void
595	42x	posix_resolver_service::destroy_impl(posix_resolver& impl)
596		{
597	42x	std::lock_guard<std::mutex> lock(mutex_);
598	42x	resolver_list_.remove(&impl);
599	42x	resolver_ptrs_.erase(&impl);
600	42x	}
601
602		inline void
603	33x	posix_resolver_service::post(scheduler_op* op)
604		{
605	33x	sched_->post(op);
606	33x	}
607
608		inline void
609		posix_resolver_service::work_started() noexcept
610		{
611		sched_->work_started();
612		}
613
614		inline void
615	33x	posix_resolver_service::work_finished() noexcept
616		{
617	33x	sched_->work_finished();
618	33x	}
619
620		// Free function to get/create the resolver service
621
622		inline posix_resolver_service&
623	1018x	get_resolver_service(capy::execution_context& ctx, scheduler& sched)
624		{
625	1018x	return ctx.make_service<posix_resolver_service>(sched);
626		}
627
628		} // namespace boost::corosio::detail
629
630		#endif // BOOST_COROSIO_POSIX
631
632		#endif // BOOST_COROSIO_NATIVE_DETAIL_POSIX_POSIX_RESOLVER_SERVICE_HPP
633