use std::collections::{BTreeMap, HashMap, HashSet};
use std::net::IpAddr;
use std::sync::Arc;
use tokio::task::JoinSet;
use crate::config::ZondConfig;
use crate::model::exclusion::Exclusions;
use crate::model::ip::set::IpSet;
use crate::model::parse::ip::{
IpParseError, Keyword, ResolverFn, ZoneResolverFn, insert_expression, names_keyword,
};
use crate::model::parse::target::{self, TargetContext, TargetExpr, TargetParseError};
use crate::model::port::PortSet;
use crate::model::target::TargetMap;
use crate::system::interface;
use crate::warn;
use super::{Resolver, Snapshot};
const MAX_CONCURRENT_LOOKUPS: usize = 16;
pub async fn resolve_names<S: AsRef<str>>(
exprs: &[S],
resolver: &Resolver,
) -> HashMap<String, Vec<IpAddr>> {
let names = collect_names(exprs);
resolve_all(names, resolver).await
}
pub async fn to_target_map<S: AsRef<str>>(
exprs: &[S],
default_ports: PortSet,
ctx: &TargetContext<'_>,
resolver: &Resolver,
) -> Result<TargetMap, TargetParseError> {
let resolved = resolve_names(exprs, resolver).await;
let lookup = |name: &str| resolved.get(name).cloned();
let ctx = TargetContext {
keywords: ctx.keywords,
zones: ctx.zones,
hosts: Some(&lookup),
};
target::to_target_map(exprs, default_ports, &ctx)
}
#[derive(Debug, Clone)]
pub struct PortScanTargets {
map: TargetMap,
names: BTreeMap<IpAddr, String>,
}
impl PortScanTargets {
pub fn map(&self) -> &TargetMap {
&self.map
}
pub fn into_map(self) -> TargetMap {
self.map
}
pub fn names(&self) -> &BTreeMap<IpAddr, String> {
&self.names
}
pub fn apply_to(&self, cfg: &mut ZondConfig) {
cfg.target_names = self.names.clone();
}
#[cfg(feature = "import-request")]
pub(crate) fn with_unported_on(&self, ports: &PortSet) -> Self {
let mut map = TargetMap::new();
for unit in &self.map.units {
if unit.ports().is_empty() {
map.add_unit(crate::model::target::TargetSet::new(
unit.ips().clone(),
ports.clone(),
));
} else {
map.add_unit(unit.clone());
}
}
Self {
map,
names: self.names.clone(),
}
}
}
#[cfg(feature = "import-request")]
pub(crate) async fn for_request<S: AsRef<str>>(
exprs: &[S],
names: Option<&Resolver>,
) -> Result<(DiscoveryTargets, PortScanTargets), TargetParseError> {
let ctx = TargetContext {
keywords: Some(&interface::resolve_keyword),
zones: Some(&interface::resolve_zone),
hosts: None,
};
let plan = for_port_scan(exprs, PortSet::new(), &ctx, names).await?;
let discovery = DiscoveryTargets {
ips: ips_of(&plan.map),
segment_sweep: names_keyword(exprs, Keyword::Lan),
};
Ok((discovery, plan))
}
pub async fn for_port_scan<S: AsRef<str>>(
exprs: &[S],
default_ports: PortSet,
ctx: &TargetContext<'_>,
names: Option<&Resolver>,
) -> Result<PortScanTargets, TargetParseError> {
let Some(resolver) = names else {
let map = target::to_target_map(exprs, default_ports, ctx)?;
return Ok(PortScanTargets {
map,
names: BTreeMap::new(),
});
};
let written = collect_names(exprs);
let resolved = resolve_all(written.clone(), resolver).await;
let lookup = |name: &str| resolved.get(name).cloned();
let with_lookup = TargetContext {
keywords: ctx.keywords,
zones: ctx.zones,
hosts: Some(&lookup),
};
let map = target::to_target_map(exprs, default_ports, &with_lookup)?;
Ok(PortScanTargets {
map,
names: names_by_address(&written, &resolved),
})
}
fn names_by_address(
written: &[String],
resolved: &HashMap<String, Vec<IpAddr>>,
) -> BTreeMap<IpAddr, String> {
let mut names: BTreeMap<IpAddr, String> = BTreeMap::new();
for name in written {
let bare = name.strip_suffix('.').unwrap_or(name);
let mut shared = None;
for address in resolved.get(name).into_iter().flatten() {
match names.get(address) {
Some(first) if first != bare => shared = Some((*address, first.clone())),
Some(_) => {}
None => {
names.insert(*address, bare.to_string());
}
}
}
if let Some((address, first)) = shared {
crate::info!(
verbosity = 1,
"{bare} not asked by name at {address} (asked as {first})"
);
}
}
names
}
pub async fn to_set<S: AsRef<str>>(
exprs: &[S],
keywords: Option<ResolverFn<'_>>,
zones: Option<ZoneResolverFn<'_>>,
resolver: &Resolver,
) -> Result<IpSet, TargetParseError> {
let ctx = TargetContext {
keywords,
zones,
hosts: None,
};
let map = to_target_map(exprs, PortSet::default(), &ctx, resolver).await?;
Ok(ips_of(&map))
}
async fn addresses_of<S: AsRef<str>>(
exprs: &[S],
names: Option<&Resolver>,
keywords: Option<ResolverFn<'_>>,
zones: Option<ZoneResolverFn<'_>>,
) -> Result<IpSet, TargetParseError> {
match names {
Some(resolver) => to_set(exprs, keywords, zones, resolver).await,
None => {
let ctx = TargetContext {
keywords,
zones,
hosts: None,
};
Ok(ips_of(&target::to_target_map(
exprs,
PortSet::default(),
&ctx,
)?))
}
}
}
fn ips_of(map: &TargetMap) -> IpSet {
let mut set = IpSet::new();
for unit in &map.units {
for range in unit.ips().v4() {
set.push_v4_range(*range);
}
for range in unit.ips().v6() {
set.push_v6_range(*range);
}
}
set.canonicalize();
set
}
#[derive(Debug, Clone)]
pub struct DiscoveryTargets {
ips: IpSet,
segment_sweep: bool,
}
impl DiscoveryTargets {
pub fn ips(&self) -> &IpSet {
&self.ips
}
pub fn into_ips(self) -> IpSet {
self.ips
}
pub fn segment_sweep(&self) -> bool {
self.segment_sweep
}
pub fn apply_to(&self, cfg: &mut ZondConfig) {
cfg.segment_sweep = self.segment_sweep;
}
}
pub async fn for_discovery<S: AsRef<str>>(
exprs: &[S],
names: Option<&Resolver>,
) -> Result<DiscoveryTargets, TargetParseError> {
for_discovery_with(
exprs,
names,
Some(&interface::resolve_keyword),
Some(&interface::resolve_zone),
)
.await
}
pub async fn for_discovery_with<S: AsRef<str>>(
exprs: &[S],
names: Option<&Resolver>,
keywords: Option<ResolverFn<'_>>,
zones: Option<ZoneResolverFn<'_>>,
) -> Result<DiscoveryTargets, TargetParseError> {
let ips = addresses_of(exprs, names, keywords, zones).await?;
let segment_sweep = names_keyword(exprs, Keyword::Lan);
Ok(DiscoveryTargets { ips, segment_sweep })
}
pub async fn for_exclusion<S: AsRef<str>>(
exprs: &[S],
names: Option<&Resolver>,
) -> Result<Exclusions, TargetParseError> {
for_exclusion_with(
exprs,
names,
Some(&interface::resolve_keyword),
Some(&interface::resolve_zone),
)
.await
}
pub async fn for_exclusion_with<S: AsRef<str>>(
exprs: &[S],
names: Option<&Resolver>,
keywords: Option<ResolverFn<'_>>,
zones: Option<ZoneResolverFn<'_>>,
) -> Result<Exclusions, TargetParseError> {
Ok(Exclusions::new(
addresses_of(exprs, names, keywords, zones).await?,
))
}
fn collect_names<S: AsRef<str>>(exprs: &[S]) -> Vec<String> {
let mut names = Vec::new();
let mut seen = HashSet::new();
for token in exprs {
let Ok(expr) = TargetExpr::parse(token.as_ref()) else {
continue;
};
for address in expr.addresses() {
let mut throwaway = IpSet::new();
if let Err(IpParseError::Malformed(_)) =
insert_expression(address, &mut throwaway, None, None)
&& target::host_name(address) == target::HostName::Yes
&& seen.insert(address.to_string())
{
names.push(address.to_string());
}
}
}
names
}
async fn resolve_all(names: Vec<String>, resolver: &Resolver) -> HashMap<String, Vec<IpAddr>> {
let mut resolved = HashMap::new();
if names.is_empty() {
return resolved;
}
let mut spellings: HashMap<String, Vec<String>> = HashMap::new();
let mut order = Vec::new();
for name in names {
let folded = name.to_ascii_lowercase();
let written = spellings.entry(folded.clone()).or_default();
if written.is_empty() {
order.push(folded);
}
written.push(name);
}
let snapshot = Arc::new(resolver.snapshot());
let mut set: JoinSet<(String, Vec<IpAddr>)> = JoinSet::new();
let mut pending = order.into_iter();
for name in pending.by_ref().take(MAX_CONCURRENT_LOOKUPS) {
spawn_lookup(&mut set, resolver, &snapshot, name);
}
while let Some(joined) = set.join_next().await {
match joined {
Ok((folded, addresses)) if !addresses.is_empty() => {
for spelling in spellings.remove(&folded).unwrap_or_default() {
resolved.insert(spelling, addresses.clone());
}
}
Ok(_) => {}
Err(e) => warn!("a name lookup did not finish: {e}"),
}
if let Some(name) = pending.next() {
spawn_lookup(&mut set, resolver, &snapshot, name);
}
}
resolved
}
fn spawn_lookup(
set: &mut JoinSet<(String, Vec<IpAddr>)>,
resolver: &Resolver,
snapshot: &Arc<Snapshot>,
name: String,
) {
let resolver = resolver.clone();
let snapshot = Arc::clone(snapshot);
set.spawn(async move {
let addresses = resolver.resolve_in(&snapshot, &name).await;
(name, addresses)
});
}
#[cfg(test)]
mod tests {
use super::*;
use crate::model::parse::ip::Keyword;
#[test]
fn a_token_the_builder_will_refuse_is_never_put_on_the_network() {
let refused = [
"192.0.2.300", "999.999.999.999", "192.0.2", ];
assert_eq!(
collect_names(&refused),
Vec::<String>::new(),
"a mistyped address was collected as a name to look up"
);
for token in refused {
assert_eq!(target::host_name(token), target::HostName::Mistyped);
}
assert_eq!(
collect_names(&["nas.local", "example.com"]),
vec!["nas.local".to_string(), "example.com".to_string()]
);
}
#[test]
fn a_name_written_two_ways_is_looked_up_once() {
let collected = collect_names(&["NAS", "nas", "Nas"]);
assert_eq!(collected.len(), 3);
let folded: std::collections::HashSet<String> = collected
.iter()
.map(|name| name.to_ascii_lowercase())
.collect();
assert_eq!(folded.len(), 1, "three spellings of one host");
}
fn keywords(keyword: Keyword, set: &mut IpSet) -> Result<(), IpParseError> {
match keyword {
Keyword::Lan => {
set.insert("192.0.2.1".parse().expect("a valid address"));
Ok(())
}
}
}
#[tokio::test]
async fn a_keyword_is_resolved_once_per_call() {
use std::sync::atomic::{AtomicUsize, Ordering};
let calls = AtomicUsize::new(0);
let counting = |keyword: Keyword, set: &mut IpSet| {
calls.fetch_add(1, Ordering::Relaxed);
keywords(keyword, set)
};
let resolver = Resolver::from_system();
let set = to_set(&["lan", "203.0.113.1"], Some(&counting), None, &resolver)
.await
.expect("the keyword resolver answers");
assert_eq!(set.len(), 2);
assert_eq!(calls.load(Ordering::Relaxed), 1);
}
#[tokio::test]
async fn only_the_keyword_asks_for_a_segment_sweep() {
let keyword = for_discovery_with(&["lan"], None, Some(&keywords), None)
.await
.expect("the keyword resolver answers");
assert!(keyword.segment_sweep());
assert_eq!(keyword.ips().len(), 1);
let spelled_out = for_discovery_with(&["192.0.2.1"], None, Some(&keywords), None)
.await
.expect("a literal address");
assert!(!spelled_out.segment_sweep());
assert_eq!(spelled_out.ips().len(), 1);
}
#[tokio::test]
async fn the_keyword_is_found_alongside_other_targets() {
let mixed = for_discovery_with(&["lan,198.51.100.0/30"], None, Some(&keywords), None)
.await
.expect("the keyword resolver answers");
assert!(mixed.segment_sweep());
}
#[tokio::test]
async fn applying_targets_to_a_config_sets_the_sweep() {
let targets = for_discovery_with(&["lan"], None, Some(&keywords), None)
.await
.expect("the keyword resolver answers");
let mut cfg = ZondConfig::default();
assert!(!cfg.segment_sweep, "off until something asks for it");
targets.apply_to(&mut cfg);
assert!(cfg.segment_sweep);
}
#[tokio::test]
async fn a_name_is_refused_when_no_resolver_is_offered() {
let refused = for_discovery_with(&["one.one.one.one"], None, Some(&keywords), None).await;
let Err(TargetParseError::NoHostLookup(expression)) = refused else {
panic!("a name with nothing to resolve it is not a target");
};
assert_eq!(expression, "one.one.one.one");
}
#[tokio::test]
async fn addresses_still_resolve_with_no_name_resolver() {
let targets = for_discovery_with(&["198.51.100.0/30", "2001:db8::1"], None, None, None)
.await
.expect("literals need nothing looked up");
assert_eq!(targets.ips().len(), 5);
}
#[test]
fn an_address_is_asked_for_by_the_first_name_that_led_to_it() {
let shared: IpAddr = "192.0.2.10".parse().expect("an address");
let own: IpAddr = "192.0.2.11".parse().expect("an address");
let written = vec!["box.example.".to_string(), "dev.box.example".to_string()];
let resolved = HashMap::from([
("dev.box.example".to_string(), vec![shared, own]),
("box.example.".to_string(), vec![shared]),
]);
let mut names = BTreeMap::new();
let logged = crate::logging::logged(|| names = names_by_address(&written, &resolved));
assert_eq!(names.get(&shared).map(String::as_str), Some("box.example"));
assert_eq!(names.get(&own).map(String::as_str), Some("dev.box.example"));
let said: Vec<_> = logged
.iter()
.filter(|line| line.message.contains("not asked by name"))
.collect();
assert_eq!(said.len(), 1, "{logged:?}");
assert_eq!(said[0].verbosity, 1);
assert_eq!(
said[0].message,
"dev.box.example not asked by name at 192.0.2.10 (asked as box.example)"
);
}
#[test]
fn only_the_hostnames_in_a_mixed_list_are_collected() {
let exprs = [
"192.0.2.10",
"example.com:443",
"198.51.100.0/24",
"raspberrypi.local",
"198.51.100.1-10",
"lan",
];
assert_eq!(
collect_names(&exprs),
vec!["example.com".to_string(), "raspberrypi.local".to_string()]
);
}
#[test]
fn a_repeated_name_is_collected_once() {
let exprs = ["host.example:80", "host.example:443", "host.example"];
assert_eq!(collect_names(&exprs), vec!["host.example".to_string()]);
}
#[test]
fn names_are_found_inside_a_comma_list() {
assert_eq!(
collect_names(&["198.51.100.1,db.internal:5432"]),
vec!["db.internal".to_string()]
);
}
#[test]
fn a_keyword_without_a_resolver_is_not_taken_for_a_name() {
assert!(collect_names(&["lan"]).is_empty());
}
#[tokio::test]
async fn resolving_no_names_yields_an_empty_map() {
let resolver = Resolver::from_system();
assert!(resolve_all(Vec::new(), &resolver).await.is_empty());
}
#[tokio::test]
async fn to_set_unions_every_group_across_both_families() {
let resolver = Resolver::from_system();
let set = to_set(
&["198.51.100.1:80", "198.51.100.2:443", "2001:db8::1"],
None,
None,
&resolver,
)
.await
.expect("literals resolve without a lookup");
assert_eq!(set.len(), 3);
assert!(set.contains(&"198.51.100.1".parse().unwrap()));
assert!(set.contains(&"198.51.100.2".parse().unwrap()));
assert!(set.contains(&"2001:db8::1".parse().unwrap()));
}
}