Diff coverage for include/boost/corosio/native/detail/posix/posix_resolver

	Coverage	Total	Misses	UNC	LBC	UIC	UBC	GBC	GIC	GNC	CBC	EUB	ECB	DUB	DCB
Lines	82.37%	278	49				49		1	1	227				1
Lines	82.37%	278	49		229	2

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