use std::collections::HashMap;
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex};
use std::time::Duration;
use snare_interpose::{Lookup, Resolver, Reverse};
use crate::events::{Fault, RecordedEvent};
use crate::readiness::{Deadline, readiness};
use crate::scope::SimShared;
#[derive(Clone, Debug, Default, PartialEq)]
pub struct DnsPolicy {
pub latency: Duration,
pub failure: Option<DnsFailure>,
pub failure_rate: f64,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum DnsFailure {
NotFound,
TryAgain,
Fail,
}
struct Entry {
key: String,
canonical: String,
addrs: Vec<IpAddr>,
}
#[derive(Default)]
struct Table {
entries: Vec<Entry>,
policies: HashMap<String, DnsPolicy>,
default: DnsPolicy,
}
#[derive(Default)]
pub(crate) struct Hosts {
table: Mutex<Table>,
real: AtomicBool,
}
fn key(name: &str) -> String {
name.strip_suffix('.').unwrap_or(name).to_ascii_lowercase()
}
const LOOPBACKS: [IpAddr; 2] = [
IpAddr::V6(Ipv6Addr::LOCALHOST),
IpAddr::V4(Ipv4Addr::LOCALHOST),
];
fn builtin(key: &str) -> Option<Lookup> {
(key == "localhost" || (cfg!(windows) && key.is_empty())).then(|| Lookup::Addrs {
canonical: "localhost".into(),
addrs: LOOPBACKS.to_vec(),
})
}
impl Hosts {
fn table<R>(&self, f: impl FnOnce(&mut Table) -> R) -> R {
snare_interpose::real(|| f(&mut self.table.lock().unwrap_or_else(|e| e.into_inner())))
}
pub(crate) fn add(&self, name: &str, addrs: impl IntoIterator<Item = IpAddr>) {
let canonical = name.strip_suffix('.').unwrap_or(name).to_string();
let key = key(name);
let addrs: Vec<IpAddr> = addrs.into_iter().collect();
self.table(
|table| match table.entries.iter_mut().find(|e| e.key == key) {
Some(entry) => {
entry.canonical = canonical;
entry.addrs = addrs;
}
None => table.entries.push(Entry {
key,
canonical,
addrs,
}),
},
);
}
pub(crate) fn remove(&self, name: &str) {
let key = key(name);
self.table(|table| table.entries.retain(|e| e.key != key));
}
pub(crate) fn update_policy(&self, name: &str, change: impl FnOnce(&mut DnsPolicy)) {
let key = key(name);
self.table(|table| {
let policy = table.policies.entry(key.clone()).or_default();
change(policy);
if *policy == DnsPolicy::default() {
table.policies.remove(&key);
}
});
}
pub(crate) fn update_default_policy(&self, change: impl FnOnce(&mut DnsPolicy)) {
self.table(|table| change(&mut table.default));
}
pub(crate) fn set_real(&self, on: bool) {
self.real.store(on, Ordering::Relaxed);
}
fn lookup(&self, shared: &SimShared, name: &str) -> Lookup {
let key = key(name);
let (found, policy) = self.table(|table| {
let found = table
.entries
.iter()
.find(|e| e.key == key)
.map(|e| Lookup::Addrs {
canonical: e.canonical.clone(),
addrs: e.addrs.clone(),
});
let policy = table.policies.get(&key).unwrap_or(&table.default).clone();
(found, policy)
});
if policy.latency.is_zero() {
snare_interpose::charge_latency();
} else {
let deadline = Deadline::after(policy.latency);
readiness().wait_until("dns lookup", Some(deadline), || false);
}
let fails = if policy.failure_rate > 0.0 {
shared.policies.unit() < policy.failure_rate
} else {
policy.failure.is_some()
};
if fails {
let failure = policy.failure.unwrap_or(DnsFailure::TryAgain);
shared.record(RecordedEvent::Fault {
addr: None,
fault: Fault::Dns {
name: name.to_string(),
failure,
},
});
return match failure {
DnsFailure::NotFound => Lookup::NotFound,
DnsFailure::TryAgain => Lookup::TryAgain,
DnsFailure::Fail => Lookup::Fail,
};
}
match found.or_else(|| builtin(&key)) {
Some(found) => found,
None if self.real.load(Ordering::Relaxed) => Lookup::Real,
None => Lookup::NotFound,
}
}
fn reverse(&self, ip: IpAddr) -> Reverse {
let found = self.table(|table| {
table
.entries
.iter()
.find(|e| e.addrs.contains(&ip))
.map(|e| e.canonical.clone())
});
match found {
Some(name) => Reverse::Name(name),
None if !cfg!(windows) && LOOPBACKS.contains(&ip) => Reverse::Name("localhost".into()),
None if self.real.load(Ordering::Relaxed) => Reverse::Real,
None => Reverse::NotFound,
}
}
}
pub(crate) struct SimResolver(pub(crate) Arc<SimShared>);
impl Resolver for SimResolver {
fn lookup(&self, name: &str) -> Lookup {
self.0.dns.lookup(&self.0, name)
}
fn reverse(&self, ip: IpAddr) -> Reverse {
self.0.dns.reverse(ip)
}
}
#[track_caller]
pub fn add_host(name: &str, addrs: impl IntoIterator<Item = IpAddr>) {
crate::scope::here().dns.add(name, addrs);
}
#[track_caller]
pub fn remove_host(name: &str) {
crate::scope::here().dns.remove(name);
}
#[track_caller]
pub fn set_dns_policy(name: &str, change: impl FnOnce(&mut DnsPolicy)) {
crate::scope::here().dns.update_policy(name, change);
}
#[track_caller]
pub fn set_default_dns_policy(change: impl FnOnce(&mut DnsPolicy)) {
crate::scope::here().dns.update_default_policy(change);
}
#[derive(Default)]
pub(crate) struct DnsSetup {
hosts: Vec<(String, Vec<IpAddr>)>,
resolve_real: Vec<String>,
real: bool,
}
impl DnsSetup {
pub(crate) fn add_host(&mut self, name: &str, addrs: impl IntoIterator<Item = IpAddr>) {
self.hosts
.push((name.to_string(), addrs.into_iter().collect()));
}
pub(crate) fn resolve_real(&mut self, name: &str) {
self.resolve_real.push(name.to_string());
}
pub(crate) fn real_dns(&mut self) {
self.real = true;
}
#[track_caller]
pub(crate) fn check(&self, deterministic: bool) {
assert!(
!(self.real && deterministic),
"SimBuilder::real_dns cannot be combined with deterministic(): a real lookup blocks \
in the OS while the thread holds the schedule; snapshot names with resolve_real \
instead"
);
}
#[track_caller]
pub(crate) fn apply(self, shared: &Arc<SimShared>) {
for (name, addrs) in self.hosts {
shared.dns.add(&name, addrs);
}
for name in self.resolve_real {
let found = snare_interpose::real(|| {
use std::net::ToSocketAddrs;
(name.as_str(), 0).to_socket_addrs()
});
let found = match found {
Ok(found) => found,
Err(e) => panic!("resolve_real({name:?}): the real resolver failed: {e}"),
};
let mut addrs: Vec<IpAddr> = Vec::new();
for addr in found {
if !addrs.contains(&addr.ip()) {
addrs.push(addr.ip());
}
}
shared.dns.add(&name, addrs);
}
shared.dns.set_real(self.real);
}
pub(crate) fn resolver(shared: &Arc<SimShared>) -> Arc<dyn Resolver> {
Arc::new(SimResolver(shared.clone()))
}
}