1use crate::network::bogon::{Scope, classify};
7use crossbeam::channel::{self, Receiver, Sender};
8use dashmap::DashMap;
9use dashmap::mapref::entry::Entry;
10use dns_lookup::lookup_addr;
11use log::debug;
12use std::net::IpAddr;
13use std::sync::atomic::{AtomicBool, Ordering};
14use std::sync::{Arc, Condvar, Mutex};
15use std::thread::{self, JoinHandle};
16use std::time::{Duration, Instant};
17
18#[derive(Debug, Clone, Copy, PartialEq, Eq)]
20pub(crate) enum ResolutionState {
21 Pending,
23 Resolved,
25 Failed,
27}
28
29#[derive(Debug, Clone, Copy)]
30struct ResolutionRequest {
31 ip: IpAddr,
32 reserved_at: Instant,
33}
34
35type Worker = Box<dyn FnOnce() + Send + 'static>;
36type StartupGate = Arc<(Mutex<Option<bool>>, Condvar)>;
37
38fn wait_for_startup(gate: &StartupGate) -> bool {
39 let (state, ready) = &**gate;
40 let mut state = state.lock().unwrap_or_else(|error| error.into_inner());
41 while state.is_none() {
42 state = ready.wait(state).unwrap_or_else(|error| error.into_inner());
43 }
44 state.unwrap_or(false)
45}
46
47fn release_startup_gate(gate: &StartupGate, start: bool) {
48 let (state, ready) = &**gate;
49 *state.lock().unwrap_or_else(|error| error.into_inner()) = Some(start);
50 ready.notify_all();
51}
52
53#[derive(Debug, Clone)]
55pub(crate) struct CachedHostname {
56 pub hostname: Option<String>,
58 pub resolved_at: Instant,
60 pub state: ResolutionState,
62}
63
64const PENDING_TIMEOUT: Duration = Duration::from_secs(30);
67
68impl CachedHostname {
69 fn is_fresh(&self, cache_ttl: Duration, negative_cache_ttl: Duration) -> bool {
73 let age = self.resolved_at.elapsed();
74 match self.state {
75 ResolutionState::Resolved => age < cache_ttl,
76 ResolutionState::Failed => age < negative_cache_ttl,
77 ResolutionState::Pending => age < PENDING_TIMEOUT,
78 }
79 }
80
81 fn pending() -> Self {
82 Self {
83 hostname: None,
84 resolved_at: Instant::now(),
85 state: ResolutionState::Pending,
86 }
87 }
88
89 fn resolved(hostname: String) -> Self {
90 Self {
91 hostname: Some(hostname),
92 resolved_at: Instant::now(),
93 state: ResolutionState::Resolved,
94 }
95 }
96
97 fn failed() -> Self {
98 Self {
99 hostname: None,
100 resolved_at: Instant::now(),
101 state: ResolutionState::Failed,
102 }
103 }
104}
105
106#[derive(Debug, Clone)]
108pub(crate) struct DnsResolverConfig {
109 pub cache_ttl: Duration,
111 pub negative_cache_ttl: Duration,
113 pub max_cache_size: usize,
115 pub request_queue_capacity: usize,
117 pub resolver_threads: usize,
119 pub shutdown_timeout: Duration,
121}
122
123impl Default for DnsResolverConfig {
124 fn default() -> Self {
125 Self {
126 cache_ttl: Duration::from_secs(300), negative_cache_ttl: Duration::from_secs(60), max_cache_size: 10000,
129 request_queue_capacity: 10000,
130 resolver_threads: 4,
131 shutdown_timeout: Duration::from_secs(1),
132 }
133 }
134}
135
136#[derive(Default)]
137struct DnsResolverLifecycle {
138 started: bool,
139 stopped: bool,
140 handles: Vec<JoinHandle<()>>,
141 stop_report: Option<DnsStopReport>,
142}
143
144#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
152pub struct DnsStopReport {
153 pub joined: usize,
155 pub panicked: usize,
157 pub timed_out: usize,
159}
160
161pub struct DnsResolver {
163 cache: Arc<DashMap<IpAddr, CachedHostname>>,
165 request_tx: Sender<ResolutionRequest>,
167 request_rx: Receiver<ResolutionRequest>,
169 lifecycle: Mutex<DnsResolverLifecycle>,
171 should_stop: Arc<AtomicBool>,
173 config: DnsResolverConfig,
175}
176
177impl DnsResolver {
178 fn new_deferred(config: DnsResolverConfig) -> Self {
180 let cache = Arc::new(DashMap::new());
181 let (request_tx, request_rx) = channel::bounded(config.request_queue_capacity);
182 let should_stop = Arc::new(AtomicBool::new(false));
183
184 Self {
185 cache,
186 request_tx,
187 request_rx,
188 lifecycle: Mutex::new(DnsResolverLifecycle::default()),
189 should_stop,
190 config,
191 }
192 }
193
194 pub fn with_defaults_deferred() -> Self {
200 Self::new_deferred(DnsResolverConfig::default())
201 }
202
203 pub fn start(&self) -> anyhow::Result<()> {
211 self.start_with_spawner(|name, worker| thread::Builder::new().name(name).spawn(worker))
212 }
213
214 fn start_with_spawner(
215 &self,
216 mut spawn: impl FnMut(String, Worker) -> std::io::Result<JoinHandle<()>>,
217 ) -> anyhow::Result<()> {
218 let mut lifecycle = self
219 .lifecycle
220 .lock()
221 .unwrap_or_else(|error| error.into_inner());
222 if lifecycle.started || lifecycle.stopped || self.should_stop.load(Ordering::Acquire) {
223 return Ok(());
224 }
225
226 let startup_gate = Arc::new((Mutex::new(None), Condvar::new()));
230 let mut handles = Vec::with_capacity(self.config.resolver_threads + 1);
231
232 for index in 0..self.config.resolver_threads {
233 let rx = self.request_rx.clone();
234 let cache = Arc::clone(&self.cache);
235 let should_stop = Arc::clone(&self.should_stop);
236 let worker_gate = Arc::clone(&startup_gate);
237
238 let worker: Worker = Box::new(move || {
239 if !wait_for_startup(&worker_gate) {
240 return;
241 }
242
243 debug!("DNS resolver thread {} started", index);
244
245 while !should_stop.load(Ordering::Relaxed) {
246 match rx.recv_timeout(Duration::from_millis(100)) {
247 Ok(request) => {
248 let reservation_is_current =
249 cache.get(&request.ip).is_some_and(|entry| {
250 entry.state == ResolutionState::Pending
251 && entry.resolved_at == request.reserved_at
252 });
253 if !reservation_is_current {
254 continue;
255 }
256
257 let result = match lookup_addr(&request.ip) {
258 Ok(hostname) => {
259 debug!("Resolved {} -> {}", request.ip, hostname);
260 CachedHostname::resolved(hostname)
261 }
262 Err(error) => {
263 debug!("Failed to resolve {}: {}", request.ip, error);
264 CachedHostname::failed()
265 }
266 };
267
268 if let Entry::Occupied(mut entry) = cache.entry(request.ip)
272 && entry.get().state == ResolutionState::Pending
273 && entry.get().resolved_at == request.reserved_at
274 {
275 entry.insert(result);
276 }
277 }
278 Err(crossbeam::channel::RecvTimeoutError::Timeout) => continue,
279 Err(crossbeam::channel::RecvTimeoutError::Disconnected) => break,
280 }
281 }
282
283 debug!("DNS resolver thread {} stopping", index);
284 });
285
286 match spawn(format!("dns-resolver-{index}"), worker) {
287 Ok(handle) => handles.push(handle),
288 Err(error) => {
289 return Err(Self::rollback_failed_start(&startup_gate, handles, error));
290 }
291 }
292 }
293
294 let cache = Arc::clone(&self.cache);
295 let should_stop = Arc::clone(&self.should_stop);
296 let cache_ttl = self.config.cache_ttl;
297 let negative_cache_ttl = self.config.negative_cache_ttl;
298 let max_cache_size = self.config.max_cache_size;
299 let worker_gate = Arc::clone(&startup_gate);
300 let cleanup: Worker = Box::new(move || {
301 if !wait_for_startup(&worker_gate) {
302 return;
303 }
304
305 debug!("DNS cache cleanup thread started");
306
307 while !should_stop.load(Ordering::Relaxed) {
308 thread::park_timeout(Duration::from_secs(30));
311
312 if should_stop.load(Ordering::Relaxed) {
313 break;
314 }
315
316 cache.retain(|_, entry| entry.is_fresh(cache_ttl, negative_cache_ttl));
318
319 if cache.len() > max_cache_size {
321 let mut entries: Vec<_> =
322 cache.iter().map(|e| (*e.key(), e.resolved_at)).collect();
323 entries.sort_by_key(|(_, time)| *time);
324
325 let to_remove = cache.len() - max_cache_size;
326 for (ip, _) in entries.into_iter().take(to_remove) {
327 cache.remove(&ip);
328 }
329 }
330
331 debug!("DNS cache size: {}", cache.len());
332 }
333
334 debug!("DNS cache cleanup thread stopping");
335 });
336
337 match spawn("dns-cache-cleanup".to_string(), cleanup) {
338 Ok(handle) => handles.push(handle),
339 Err(error) => {
340 return Err(Self::rollback_failed_start(&startup_gate, handles, error));
341 }
342 }
343
344 lifecycle.started = true;
345 lifecycle.handles = handles;
346 release_startup_gate(&startup_gate, true);
347 Ok(())
348 }
349
350 fn rollback_failed_start(
351 startup_gate: &StartupGate,
352 handles: Vec<JoinHandle<()>>,
353 error: std::io::Error,
354 ) -> anyhow::Error {
355 release_startup_gate(startup_gate, false);
356 let panicked = handles
357 .into_iter()
358 .map(|handle| handle.join().is_err())
359 .filter(|panicked| *panicked)
360 .count();
361 if panicked == 0 {
362 anyhow::anyhow!("failed to spawn DNS worker: {error}")
363 } else {
364 anyhow::anyhow!(
365 "failed to spawn DNS worker: {error}; {panicked} staged worker(s) panicked during rollback"
366 )
367 }
368 }
369
370 pub fn request_resolution(&self, ip: IpAddr) {
372 if self.should_stop.load(Ordering::Acquire)
373 || matches!(classify(ip), Scope::Loopback | Scope::LinkLocal)
374 {
375 return;
376 }
377
378 let pending = CachedHostname::pending();
379 let request = ResolutionRequest {
380 ip,
381 reserved_at: pending.resolved_at,
382 };
383 match self.cache.entry(ip) {
384 Entry::Occupied(mut entry) => {
385 if entry
386 .get()
387 .is_fresh(self.config.cache_ttl, self.config.negative_cache_ttl)
388 {
389 return;
390 }
391 entry.insert(pending);
392 }
393 Entry::Vacant(entry) => {
394 entry.insert(pending);
395 }
396 }
397
398 if self.request_tx.try_send(request).is_err() {
402 self.cache.remove_if(&ip, |_, entry| {
403 entry.state == ResolutionState::Pending && entry.resolved_at == request.reserved_at
404 });
405 }
406 }
407
408 pub fn get_hostname(&self, ip: &IpAddr) -> Option<String> {
410 self.request_resolution(*ip);
411
412 self.cache.get(ip).and_then(|entry| {
413 if entry.state == ResolutionState::Resolved {
414 entry.hostname.clone()
415 } else {
416 None
417 }
418 })
419 }
420
421 pub fn stop(&self) -> DnsStopReport {
428 self.should_stop.store(true, Ordering::Release);
429
430 let mut lifecycle = self.lifecycle.lock().unwrap_or_else(|e| e.into_inner());
431 if let Some(report) = lifecycle.stop_report {
432 return report;
433 }
434
435 lifecycle.stopped = true;
436
437 for handle in &lifecycle.handles {
438 handle.thread().unpark();
439 }
440
441 let deadline = Instant::now() + self.config.shutdown_timeout;
442 let mut report = DnsStopReport::default();
443
444 while !lifecycle.handles.is_empty() {
445 let mut index = 0;
446 while index < lifecycle.handles.len() {
447 if lifecycle.handles[index].is_finished() {
448 let handle = lifecycle.handles.swap_remove(index);
449 if handle.join().is_err() {
450 report.panicked += 1;
451 debug!("DNS worker thread panicked during shutdown");
452 } else {
453 report.joined += 1;
454 }
455 } else {
456 index += 1;
457 }
458 }
459
460 if lifecycle.handles.is_empty() {
461 break;
462 }
463
464 let now = Instant::now();
465 if now >= deadline {
466 report.timed_out = lifecycle.handles.len();
467 lifecycle.handles.clear();
468 break;
469 }
470
471 thread::sleep((deadline - now).min(Duration::from_millis(1)));
472 }
473
474 lifecycle.stop_report = Some(report);
475 report
476 }
477}
478
479impl Drop for DnsResolver {
480 fn drop(&mut self) {
481 let _ = self.stop();
482 }
483}
484
485#[cfg(test)]
486mod tests {
487 use super::*;
488
489 #[test]
490 fn test_cached_hostname_states() {
491 let pending = CachedHostname::pending();
492 assert_eq!(pending.state, ResolutionState::Pending);
493 assert!(pending.hostname.is_none());
494
495 let resolved = CachedHostname::resolved("example.com".to_string());
496 assert_eq!(resolved.state, ResolutionState::Resolved);
497 assert_eq!(resolved.hostname, Some("example.com".to_string()));
498
499 let failed = CachedHostname::failed();
500 assert_eq!(failed.state, ResolutionState::Failed);
501 assert!(failed.hostname.is_none());
502 }
503
504 #[test]
505 fn test_loopback_skip() {
506 let config = DnsResolverConfig {
507 resolver_threads: 1,
508 ..Default::default()
509 };
510 let resolver = DnsResolver::new_deferred(config);
511 resolver.start().unwrap();
512
513 resolver.request_resolution("127.0.0.1".parse().unwrap());
515 assert!(
516 resolver
517 .get_hostname(&"127.0.0.1".parse().unwrap())
518 .is_none()
519 );
520
521 let report = resolver.stop();
522 assert_eq!(report.timed_out, 0);
523 }
524
525 #[test]
526 fn deferred_resolver_stays_inactive_until_started() {
527 let resolver = DnsResolver::new_deferred(DnsResolverConfig {
528 resolver_threads: 0,
529 ..Default::default()
530 });
531
532 {
533 let lifecycle = resolver.lifecycle.lock().unwrap();
534 assert!(!lifecycle.started);
535 assert!(!lifecycle.stopped);
536 assert!(lifecycle.handles.is_empty());
537 }
538
539 resolver.start().unwrap();
540 {
541 let lifecycle = resolver.lifecycle.lock().unwrap();
542 assert!(lifecycle.started);
543 assert!(!lifecycle.stopped);
544 assert_eq!(lifecycle.handles.len(), 1);
545 }
546
547 resolver.start().unwrap();
549 assert_eq!(resolver.lifecycle.lock().unwrap().handles.len(), 1);
550
551 resolver.stop();
552 }
553
554 #[test]
555 fn stopped_deferred_resolver_cannot_be_started() {
556 let resolver = DnsResolver::new_deferred(DnsResolverConfig {
557 resolver_threads: 0,
558 ..Default::default()
559 });
560
561 let report = resolver.stop();
562 assert_eq!(report, DnsStopReport::default());
563 resolver.start().unwrap();
564
565 let lifecycle = resolver.lifecycle.lock().unwrap();
566 assert!(!lifecycle.started);
567 assert!(lifecycle.stopped);
568 assert!(lifecycle.handles.is_empty());
569 }
570
571 #[test]
572 fn request_queue_is_bounded_and_non_blocking() {
573 let resolver = DnsResolver::new_deferred(DnsResolverConfig {
574 request_queue_capacity: 1,
575 resolver_threads: 0,
576 ..Default::default()
577 });
578 let first = "192.0.2.1".parse().unwrap();
579 let second = "192.0.2.2".parse().unwrap();
580
581 resolver.request_resolution(first);
582 resolver.request_resolution(second);
583
584 assert_eq!(resolver.request_rx.len(), 1);
585 assert_eq!(resolver.request_rx.try_recv().unwrap().ip, first);
586 assert!(resolver.request_rx.try_recv().is_err());
587 }
588
589 #[test]
590 fn repeated_requests_share_one_queue_reservation() {
591 let resolver = DnsResolver::new_deferred(DnsResolverConfig {
592 request_queue_capacity: 4,
593 resolver_threads: 0,
594 ..Default::default()
595 });
596 let address = "192.0.2.1".parse().unwrap();
597
598 for _ in 0..32 {
599 resolver.request_resolution(address);
600 }
601
602 assert_eq!(resolver.request_rx.len(), 1);
603 assert_eq!(resolver.request_rx.try_recv().unwrap().ip, address);
604 assert!(resolver.request_rx.try_recv().is_err());
605 }
606
607 #[test]
608 fn concurrent_requests_share_one_queue_reservation() {
609 let resolver = Arc::new(DnsResolver::new_deferred(DnsResolverConfig {
610 request_queue_capacity: 32,
611 resolver_threads: 0,
612 ..Default::default()
613 }));
614 let address = "192.0.2.1".parse().unwrap();
615 let ready = Arc::new(std::sync::Barrier::new(17));
616 let mut callers = Vec::new();
617 for _ in 0..16 {
618 let resolver = Arc::clone(&resolver);
619 let ready = Arc::clone(&ready);
620 callers.push(thread::spawn(move || {
621 ready.wait();
622 resolver.request_resolution(address);
623 }));
624 }
625
626 ready.wait();
627 for caller in callers {
628 caller.join().unwrap();
629 }
630
631 assert_eq!(resolver.request_rx.len(), 1);
632 assert_eq!(resolver.request_rx.try_recv().unwrap().ip, address);
633 }
634
635 #[test]
636 fn full_queue_releases_reservation_for_retry() {
637 let resolver = DnsResolver::new_deferred(DnsResolverConfig {
638 request_queue_capacity: 1,
639 resolver_threads: 0,
640 ..Default::default()
641 });
642 let first = "192.0.2.1".parse().unwrap();
643 let retry = "192.0.2.2".parse().unwrap();
644
645 resolver.request_resolution(first);
646 resolver.request_resolution(retry);
647 assert!(!resolver.cache.contains_key(&retry));
648
649 assert_eq!(resolver.request_rx.try_recv().unwrap().ip, first);
650 resolver.request_resolution(retry);
651 assert_eq!(resolver.request_rx.try_recv().unwrap().ip, retry);
652 }
653
654 #[test]
655 fn failed_start_joins_staged_workers_and_can_be_retried() {
656 let resolver = DnsResolver::new_deferred(DnsResolverConfig {
657 resolver_threads: 2,
658 ..Default::default()
659 });
660 let staged_worker_exited = Arc::new(AtomicBool::new(false));
661 let exited = Arc::clone(&staged_worker_exited);
662 let mut attempts = 0;
663
664 let error = resolver
665 .start_with_spawner(move |name, worker| {
666 attempts += 1;
667 if attempts == 2 {
668 return Err(std::io::Error::other("injected spawn failure"));
669 }
670 let exited = Arc::clone(&exited);
671 thread::Builder::new().name(name).spawn(move || {
672 worker();
673 exited.store(true, Ordering::Release);
674 })
675 })
676 .unwrap_err();
677
678 assert!(error.to_string().contains("injected spawn failure"));
679 assert!(staged_worker_exited.load(Ordering::Acquire));
680 {
681 let lifecycle = resolver.lifecycle.lock().unwrap();
682 assert!(!lifecycle.started);
683 assert!(!lifecycle.stopped);
684 assert!(lifecycle.handles.is_empty());
685 }
686
687 resolver.start().unwrap();
688 assert_eq!(resolver.lifecycle.lock().unwrap().handles.len(), 3);
689 let report = resolver.stop();
690 assert_eq!(report.joined, 3);
691 assert_eq!(report.timed_out, 0);
692 }
693
694 #[test]
695 fn stop_joins_workers_and_is_idempotent() {
696 let resolver = DnsResolver::new_deferred(DnsResolverConfig {
697 resolver_threads: 1,
698 ..Default::default()
699 });
700 resolver.start().unwrap();
701 assert_eq!(resolver.lifecycle.lock().unwrap().handles.len(), 2);
702
703 let before_stop = Instant::now();
704 let report = resolver.stop();
705 assert!(before_stop.elapsed() < Duration::from_secs(1));
706 assert_eq!(report.joined, 2);
707 assert_eq!(report.panicked, 0);
708 assert_eq!(report.timed_out, 0);
709
710 {
711 let lifecycle = resolver.lifecycle.lock().unwrap();
712 assert!(lifecycle.started);
713 assert!(lifecycle.stopped);
714 assert!(lifecycle.handles.is_empty());
715 }
716
717 assert_eq!(resolver.stop(), report);
718 assert!(resolver.lifecycle.lock().unwrap().handles.is_empty());
719 }
720
721 #[test]
722 fn stop_detaches_stalled_worker_at_shared_deadline() {
723 let resolver = DnsResolver::new_deferred(DnsResolverConfig {
724 resolver_threads: 0,
725 shutdown_timeout: Duration::from_millis(25),
726 ..Default::default()
727 });
728 let (release_tx, release_rx) = channel::bounded::<()>(0);
729 let stalled = thread::spawn(move || {
730 let _ = release_rx.recv();
731 });
732 resolver.lifecycle.lock().unwrap().handles.push(stalled);
733
734 let before_stop = Instant::now();
735 let report = resolver.stop();
736
737 assert!(before_stop.elapsed() < Duration::from_millis(250));
738 assert_eq!(
739 report,
740 DnsStopReport {
741 joined: 0,
742 panicked: 0,
743 timed_out: 1,
744 }
745 );
746 assert_eq!(resolver.stop(), report);
747
748 let _ = release_tx.send(());
750 }
751
752 #[test]
753 fn test_default_config() {
754 let config = DnsResolverConfig::default();
755 assert_eq!(config.cache_ttl, Duration::from_secs(300));
756 assert_eq!(config.negative_cache_ttl, Duration::from_secs(60));
757 assert_eq!(config.max_cache_size, 10000);
758 assert_eq!(config.request_queue_capacity, 10000);
759 assert_eq!(config.resolver_threads, 4);
760 assert_eq!(config.shutdown_timeout, Duration::from_secs(1));
761 }
762}