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