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

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

	Coverage	Total	Misses	UNC	UBC	GBC	CBC	EUB
Child	Rate	Total	Misses	New Misses		Hits		New Hits
Lines	81.66%	289	53		53		236
Lines	81.66%	289	53			236