use std::net::IpAddr;
use thiserror::Error;
use crate::model::ip::range::{IpError, IpRange};
use crate::model::ip::set::IpSet;
#[non_exhaustive]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Keyword {
Lan,
}
impl Keyword {
pub const ALL: &'static [Self] = &[Self::Lan];
pub fn as_str(self) -> &'static str {
match self {
Keyword::Lan => "lan",
}
}
pub fn from_token(token: &str) -> Option<Self> {
let token = token.trim();
Self::ALL
.iter()
.copied()
.find(|keyword| token.eq_ignore_ascii_case(keyword.as_str()))
}
}
pub fn names_keyword<S: AsRef<str>>(targets: &[S], keyword: Keyword) -> bool {
targets.iter().any(|target| {
target
.as_ref()
.split(',')
.any(|part| Keyword::from_token(part) == Some(keyword))
})
}
#[non_exhaustive]
#[derive(Debug, Clone, PartialEq, Eq, Error)]
pub enum IpParseError {
#[error("Invalid CIDR prefix: {0} (0-32 for IPv4, 0-128 for IPv6)")]
InvalidPrefix(u32),
#[error("Invalid range: start address {0} is greater than end address {1}")]
InvalidRange(IpAddr, IpAddr),
#[error("Malformed IP or range string: '{0}'")]
Malformed(String),
#[error("could not resolve `{keyword}`: {reason}")]
KeywordUnresolved {
keyword: &'static str,
reason: String,
},
#[error("Target input resulted in an empty set")]
EmptySet,
#[error("'{0}': only a link-local address is scoped to an interface")]
ZoneOnUnscopedTarget(String),
#[error("No interface named '{0}'")]
UnknownInterface(String),
}
pub type ResolverFn<'a> = &'a (dyn Fn(Keyword, &mut IpSet) -> Result<(), IpParseError> + Sync);
pub type ZoneResolverFn<'a> = &'a (dyn Fn(&str) -> Option<u32> + Sync);
pub fn to_set<S>(
ips: &[S],
resolver: Option<ResolverFn<'_>>,
zones: Option<ZoneResolverFn<'_>>,
) -> Result<IpSet, IpParseError>
where
S: AsRef<str>,
{
let mut set = IpSet::new();
for ip in ips {
let s = ip.as_ref().trim();
if s.is_empty() {
continue;
}
for part in s.split(',').map(|p| p.trim()).filter(|p| !p.is_empty()) {
insert_expression(part, &mut set, resolver, zones)?;
}
}
if set.is_empty() {
return Err(IpParseError::EmptySet);
}
Ok(set)
}
pub fn insert_expression(
s: &str,
set: &mut IpSet,
resolver: Option<ResolverFn<'_>>,
zones: Option<ZoneResolverFn<'_>>,
) -> Result<(), IpParseError> {
let s = s.trim();
if let Some((address, zone)) = s.split_once('%') {
return parse_scoped(s, address, zone, set, zones);
}
if s.contains('/') {
let range = parse_cidr(s)?;
set.insert_range(as_hosts(range));
return Ok(());
}
if s.contains('-') {
let range = parse_range(s)?;
set.insert_range(as_hosts(range));
return Ok(());
}
if let Some(keyword) = Keyword::from_token(s) {
let Some(resolve) = resolver else {
return Err(IpParseError::KeywordUnresolved {
keyword: keyword.as_str(),
reason: "no resolver was supplied to expand it".to_string(),
});
};
return resolve(keyword, set);
}
let ip = s
.parse::<IpAddr>()
.map_err(|_| IpParseError::Malformed(s.to_string()))?;
set.insert(ip.to_canonical());
Ok(())
}
fn as_hosts(range: IpRange) -> IpRange {
match range {
IpRange::V6(v6) => v6.spelled_ipv4().map_or(range, IpRange::V4),
IpRange::V4(_) => range,
}
}
fn parse_scoped(
original: &str,
address: &str,
zone: &str,
set: &mut IpSet,
zones: Option<ZoneResolverFn<'_>>,
) -> Result<(), IpParseError> {
if zone.is_empty() {
return Err(IpParseError::Malformed(original.to_string()));
}
let range = address
.parse::<IpRange>()
.map_err(|_| IpParseError::Malformed(original.to_string()))?;
let IpRange::V6(v6) = range else {
return Err(IpParseError::ZoneOnUnscopedTarget(original.to_string()));
};
if !v6.is_link_local() {
return Err(IpParseError::ZoneOnUnscopedTarget(original.to_string()));
}
let lookup = zones.ok_or_else(|| IpParseError::UnknownInterface(zone.to_string()))?;
let index = lookup(zone)
.filter(|index| *index != 0)
.ok_or_else(|| IpParseError::UnknownInterface(zone.to_string()))?;
let scoped =
crate::model::ip::range::Ipv6Range::scoped(v6.start_addr(), v6.end_addr(), Some(index))
.map_err(|e| map_range_error(original, e))?;
set.insert_range(IpRange::V6(scoped));
Ok(())
}
fn parse_range(s: &str) -> Result<IpRange, IpParseError> {
s.parse::<IpRange>().map_err(|error| match error {
IpError::InvalidFormat(_) | IpError::AddrParse(_) | IpError::PrefixParse(_) => {
IpParseError::Malformed(s.into())
}
other => map_range_error(s, other),
})
}
fn parse_cidr(s: &str) -> Result<IpRange, IpParseError> {
let (ip_str, prefix_str) = s
.split_once('/')
.ok_or_else(|| IpParseError::Malformed(s.into()))?;
let ip = ip_str
.parse::<IpAddr>()
.map_err(|_| IpParseError::Malformed(s.into()))?;
let prefix = prefix_str
.parse::<u32>()
.map_err(|_| IpParseError::Malformed(s.into()))?;
let prefix = u8::try_from(prefix).map_err(|_| IpParseError::InvalidPrefix(prefix))?;
crate::model::ip::range::cidr_range(ip, prefix).map_err(|e| map_range_error(s, e))
}
fn map_range_error(original: &str, e: IpError) -> IpParseError {
match e {
IpError::InvalidRange(s, e) => IpParseError::InvalidRange(s, e),
IpError::InvalidPrefix(p) => IpParseError::InvalidPrefix(u32::from(p)),
_ => IpParseError::Malformed(original.to_string()),
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::net::Ipv4Addr;
use std::str::FromStr;
#[test]
fn both_ways_into_the_parser_accept_the_same_spellings() {
for expression in [
"198.51.100.1-50",
"192.168.1.1-2.254",
"198.51.100.1-198.51.100.50",
"192.0.2.0/24",
"2001:db8::1-2001:db8::5",
"8.8.8.8",
"198.51.100.0-0",
" 198.51.100.1 ",
] {
let direct = to_set(&[expression], None, None)
.unwrap_or_else(|e| panic!("to_set rejected `{expression}`: {e}"));
let via_set = IpSet::from_str(expression)
.unwrap_or_else(|e| panic!("IpSet::from_str rejected `{expression}`: {e}"));
assert_eq!(
direct, via_set,
"`{expression}` means different things through the two entry points"
);
}
}
#[test]
fn a_mapped_address_is_read_as_the_ipv4_host_it_spells() {
for (mapped, plain) in [
("::ffff:192.0.2.1", "192.0.2.1"),
("::ffff:127.0.0.1", "127.0.0.1"),
("::ffff:192.0.2.0/120", "192.0.2.0/24"),
("::ffff:192.0.2.1-::ffff:192.0.2.9", "192.0.2.1-192.0.2.9"),
("::ffff:0:0/96", "0.0.0.0/0"),
] {
assert_eq!(
to_set(&[mapped], None, None).expect("parses"),
to_set(&[plain], None, None).expect("parses"),
"`{mapped}`"
);
}
}
#[test]
fn a_range_that_only_overlaps_the_mapped_block_is_kept_as_written() {
for written in ["::/0", "::fffe:ffff:ffff-::ffff:0:5"] {
let set = to_set(&[written], None, None).expect("parses");
assert!(set.v4().is_empty(), "`{written}` gained IPv4");
assert_eq!(set, IpSet::from_str(written).expect("parses"));
}
}
#[test]
fn a_single_literal_address_becomes_a_set_of_one() {
let input = vec!["192.0.2.1"];
let set = to_set(&input, None, None).expect("Should parse single IP");
assert_eq!(set.len(), 1);
assert!(set.contains(&IpAddr::V4(Ipv4Addr::new(192, 0, 2, 1))));
}
#[test]
fn one_argument_may_name_several_addresses() {
let input = vec!["198.51.100.1, 198.51.100.2, 198.51.100.5"];
let set = to_set(&input, None, None).expect("Should parse comma list");
assert_eq!(set.len(), 3);
assert!(set.contains(&IpAddr::V4(Ipv4Addr::new(198, 51, 100, 1))));
}
#[test]
fn a_cidr_block_covers_every_address_in_it() {
let input = vec!["203.0.113.0/24"];
let set = to_set(&input, None, None).expect("Should parse CIDR");
assert_eq!(set.len(), 256);
}
#[test]
fn a_shortened_range_end_continues_the_starts_octets() {
let input = vec!["192.168.1.250-2.10"];
let set = to_set(&input, None, None).unwrap();
assert_eq!(set.len(), 17);
}
#[test]
fn a_prefix_longer_than_its_family_allows_is_refused() {
let input = vec!["192.0.2.1/33"];
let result = to_set(&input, None, None);
assert_eq!(result.unwrap_err(), IpParseError::InvalidPrefix(33));
}
#[test]
fn a_prefix_too_large_for_a_u8_is_still_a_prefix() {
let too_large = to_set(&["198.51.100.0/999"], None, None).unwrap_err();
assert_eq!(too_large, IpParseError::InvalidPrefix(999));
assert!(too_large.to_string().contains("0-32"), "{too_large}");
assert!(matches!(
to_set(&["198.51.100.0/wide"], None, None),
Err(IpParseError::Malformed(_))
));
}
#[test]
fn a_prefix_error_names_the_bound_for_both_families() {
let v6 = to_set(&["2001:db8::/129"], None, None).unwrap_err();
assert_eq!(v6, IpParseError::InvalidPrefix(129));
assert!(v6.to_string().contains("0-128"), "{v6}");
let v4 = to_set(&["192.0.2.1/33"], None, None).unwrap_err();
assert!(v4.to_string().contains("0-32"), "{v4}");
}
#[test]
fn a_range_written_backwards_is_refused() {
let input = vec!["198.51.100.10-1"];
let result = to_set(&input, None, None);
assert!(matches!(result, Err(IpParseError::InvalidRange(_, _))));
}
#[test]
fn a_link_local_target_keeps_the_interface_it_names() {
fn zones(name: &str) -> Option<u32> {
(name == "en0").then_some(7)
}
let set = to_set(&["fe80::aa%en0"], None, Some(&zones)).expect("parses");
assert_eq!(set.v6().len(), 1);
assert_eq!(set.v6()[0].zone(), Some(7));
assert!(!set.v6()[0].is_ambiguous());
}
#[test]
fn a_link_local_target_without_an_interface_is_ambiguous() {
let set = to_set(&["fe80::aa"], None, None).expect("parses");
assert!(set.v6()[0].is_ambiguous());
}
#[test]
fn a_resolver_that_answers_zero_has_not_found_an_interface() {
fn zones(_: &str) -> Option<u32> {
Some(0)
}
assert!(matches!(
to_set(&["fe80::aa%en0"], None, Some(&zones)),
Err(IpParseError::UnknownInterface(name)) if name == "en0"
));
}
#[test]
fn an_untrimmed_token_reads_the_same_as_a_trimmed_one() {
let mut set = IpSet::new();
insert_expression(" 198.51.100.1 ", &mut set, None, None).expect("an address with space");
insert_expression("\t192.0.2.0/24\n", &mut set, None, None).expect("a block with space");
insert_expression(" 198.51.100.5-10 ", &mut set, None, None).expect("a range with space");
assert_eq!(set.len(), 1 + 256 + 6);
fn keywords(_: Keyword, set: &mut IpSet) -> Result<(), IpParseError> {
set.insert("203.0.113.1".parse().expect("an address"));
Ok(())
}
let mut keyword = IpSet::new();
insert_expression(" lan ", &mut keyword, Some(&keywords), None).expect("a keyword");
assert_eq!(
keyword.len(),
1,
"which already worked, and is the half it matched"
);
}
#[test]
fn an_unknown_interface_is_refused() {
fn zones(_: &str) -> Option<u32> {
None
}
assert!(matches!(
to_set(&["fe80::aa%wlan9"], None, Some(&zones)),
Err(IpParseError::UnknownInterface(_))
));
assert!(
matches!(
to_set(&["fe80::aa%en0"], None, None),
Err(IpParseError::UnknownInterface(_))
),
"a caller with no lookup cannot express a scoped target and must be told"
);
}
#[test]
fn a_zone_on_a_global_target_is_refused() {
fn zones(_: &str) -> Option<u32> {
Some(7)
}
assert!(matches!(
to_set(&["2001:db8::1%en0"], None, Some(&zones)),
Err(IpParseError::ZoneOnUnscopedTarget(_))
));
assert!(matches!(
to_set(&["192.0.2.1%en0"], None, Some(&zones)),
Err(IpParseError::ZoneOnUnscopedTarget(_))
));
}
#[test]
fn input_naming_no_addresses_is_an_error() {
let input: Vec<&str> = vec!["", " "];
let result = to_set(&input, None, None);
assert_eq!(result.unwrap_err(), IpParseError::EmptySet);
}
}