use crate::{info, warn};
use std::net::{IpAddr, Ipv4Addr};
use crate::model::{
ip::{
range::{IpError, IpRange, Ipv4Range},
set::IpSet,
},
parse::{IpParseError, ip::Keyword},
};
use crate::system::interface;
pub fn resolve_zone(name: &str) -> Option<u32> {
crate::system::interface::interfaces()
.into_iter()
.find(|link| link.name() == name)
.map(|link| link.index())
}
pub fn resolve_keyword(keyword: Keyword, ip_set: &mut IpSet) -> Result<(), IpParseError> {
match keyword {
Keyword::Lan => resolve_lan(ip_set),
}
}
fn lan_unresolved(reason: impl Into<String>) -> IpParseError {
IpParseError::KeywordUnresolved {
keyword: Keyword::Lan.as_str(),
reason: reason.into(),
}
}
fn resolve_lan(set: &mut IpSet) -> Result<(), IpParseError> {
let link = interface::lan_link()
.ok_or_else(|| lan_unresolved("no active network interface was found"))?;
let Some(net) = link.ipv4 else {
return Err(lan_unresolved(format!(
"{} has no private IPv4 network to sweep{}. Give an explicit range, \
or an IPv6 target on this link.",
link.link.name(),
match link.link_local() {
Some(addr) => format!(" (its addressing is IPv6: {addr})"),
None => String::new(),
}
)));
};
let network = net.network();
let (IpAddr::V4(first), IpAddr::V4(last)) = (network.start_addr(), network.end_addr()) else {
return Err(lan_unresolved("the LAN link's IPv4 network is not IPv4"));
};
let start_u32 = u32::from(first).saturating_add(1);
let end_u32 = u32::from(last).saturating_sub(1);
if start_u32 <= end_u32 {
let range = Ipv4Range::new(Ipv4Addr::from(start_u32), Ipv4Addr::from(end_u32)).map_err(
|e| match e {
IpError::InvalidRange(s, e) => IpParseError::InvalidRange(s, e),
_ => lan_unresolved("the network's own ends are out of order"),
},
)?;
info!(
verbosity = 3,
"resolved LAN: {} - {}",
range.start_addr(),
range.end_addr()
);
set.insert_range(IpRange::V4(range));
} else {
warn!("small subnet; scanning full network range");
let range = Ipv4Range::new(first, last).expect("a network's own ends are ordered");
set.insert_range(IpRange::V4(range));
}
Ok(())
}