use std::collections::{HashMap, HashSet};
use std::net::IpAddr;
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 super::Resolver;
const MAX_CONCURRENT_LOOKUPS: usize = 16;
pub async fn resolve_names<S: AsRef<str>>(
exprs: &[S],
ctx: &TargetContext<'_>,
resolver: &Resolver,
) -> HashMap<String, Vec<IpAddr>> {
let names = collect_names(exprs, ctx);
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, ctx, 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)
}
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))
}
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 = match names {
Some(resolver) => to_set(exprs, keywords, zones, resolver).await?,
None => {
let ctx = TargetContext {
keywords,
zones,
hosts: None,
};
ips_of(&target::to_target_map(exprs, PortSet::default(), &ctx)?)
}
};
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> {
if exprs.is_empty() {
return Ok(Exclusions::none());
}
let ips = match names {
Some(resolver) => to_set(exprs, keywords, zones, resolver).await?,
None => {
let ctx = TargetContext {
keywords,
zones,
hosts: None,
};
ips_of(&target::to_target_map(exprs, PortSet::default(), &ctx)?)
}
};
Ok(Exclusions::new(ips))
}
fn collect_names<S: AsRef<str>>(exprs: &[S], ctx: &TargetContext<'_>) -> 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, ctx.keywords, ctx.zones)
&& 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 set: JoinSet<(String, Vec<IpAddr>)> = JoinSet::new();
let mut pending = names.into_iter();
for name in pending.by_ref().take(MAX_CONCURRENT_LOOKUPS) {
spawn_lookup(&mut set, resolver, name);
}
while let Some(joined) = set.join_next().await {
if let Ok((name, addresses)) = joined
&& !addresses.is_empty()
{
resolved.insert(name, addresses);
}
if let Some(name) = pending.next() {
spawn_lookup(&mut set, resolver, name);
}
}
resolved
}
fn spawn_lookup(set: &mut JoinSet<(String, Vec<IpAddr>)>, resolver: &Resolver, name: String) {
let resolver = resolver.clone();
set.spawn(async move {
let addresses = resolver.resolve(&name).await;
(name, addresses)
});
}
#[cfg(test)]
mod tests {
use super::*;
use crate::model::parse::ip::Keyword;
fn keywords(keyword: Keyword, set: &mut IpSet) -> Result<(), IpParseError> {
match keyword {
Keyword::Lan => {
set.insert("192.168.1.1".parse().expect("a valid address"));
Ok(())
}
}
}
#[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.168.1.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,10.1.0.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(&["10.0.0.0/30", "2001:db8::1"], None, None, None)
.await
.expect("literals need nothing looked up");
assert_eq!(targets.ips().len(), 5);
}
#[test]
fn only_the_hostnames_in_a_mixed_list_are_collected() {
let ctx = TargetContext::new().with_keywords(&keywords);
let exprs = [
"192.168.1.10",
"example.com:443",
"10.0.0.0/24",
"raspberrypi.local",
"10.0.0.1-10",
"lan",
];
assert_eq!(
collect_names(&exprs, &ctx),
vec!["example.com".to_string(), "raspberrypi.local".to_string()]
);
}
#[test]
fn a_repeated_name_is_collected_once() {
let ctx = TargetContext::new();
let exprs = ["host.example:80", "host.example:443", "host.example"];
assert_eq!(
collect_names(&exprs, &ctx),
vec!["host.example".to_string()]
);
}
#[test]
fn names_are_found_inside_a_comma_list() {
let ctx = TargetContext::new();
assert_eq!(
collect_names(&["10.0.0.1,db.internal:5432"], &ctx),
vec!["db.internal".to_string()]
);
}
#[test]
fn a_keyword_without_a_resolver_is_not_taken_for_a_name() {
let ctx = TargetContext::new();
assert!(collect_names(&["lan"], &ctx).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(
&["10.0.0.1:80", "10.0.0.2:443", "2001:db8::1"],
None,
None,
&resolver,
)
.await
.expect("literals resolve without a lookup");
assert_eq!(set.len(), 3);
assert!(set.contains(&"10.0.0.1".parse().unwrap()));
assert!(set.contains(&"10.0.0.2".parse().unwrap()));
assert!(set.contains(&"2001:db8::1".parse().unwrap()));
}
}