use std::collections::HashMap;
use std::fmt;
use std::net::IpAddr;
use thiserror::Error;
use crate::model::ip::set::IpSet;
use crate::model::parse::ip::{IpParseError, ResolverFn, ZoneResolverFn, insert_expression};
use crate::model::port::{PortSet, PortSetParseError};
use crate::model::target::{TargetMap, TargetSet};
pub type HostLookup<'a> = &'a (dyn Fn(&str) -> Option<Vec<IpAddr>> + Sync);
#[must_use]
#[non_exhaustive]
#[derive(Default, Clone, Copy)]
pub struct TargetContext<'a> {
pub keywords: Option<ResolverFn<'a>>,
pub zones: Option<ZoneResolverFn<'a>>,
pub hosts: Option<HostLookup<'a>>,
}
impl<'a> TargetContext<'a> {
pub fn new() -> Self {
Self::default()
}
pub fn with_keywords(mut self, keywords: ResolverFn<'a>) -> Self {
self.keywords = Some(keywords);
self
}
pub fn with_zones(mut self, zones: ZoneResolverFn<'a>) -> Self {
self.zones = Some(zones);
self
}
pub fn with_hosts(mut self, hosts: HostLookup<'a>) -> Self {
self.hosts = Some(hosts);
self
}
}
impl fmt::Debug for TargetContext<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("TargetContext")
.field("keywords", &self.keywords.is_some())
.field("zones", &self.zones.is_some())
.field("hosts", &self.hosts.is_some())
.finish()
}
}
#[non_exhaustive]
#[derive(Debug, Clone, PartialEq, Eq, Error)]
pub enum TargetParseError {
#[error("a target expression cannot be empty")]
Empty,
#[error("a target of {0} space{1}; a stray '\\' in the shell?")]
Blank(usize, &'static str),
#[error("'{0}': a bracketed address must be closed with ']'")]
UnbalancedBracket(String),
#[error("'{0}': expected ':' and a port specification after ']'")]
TrailingText(String),
#[error("'{0}': the ':' is not followed by a port specification")]
EmptyPorts(String),
#[error("'{expression}': {source}")]
Address {
expression: String,
#[source]
source: IpParseError,
},
#[error("'{expression}': {source}")]
Ports {
expression: String,
#[source]
source: PortSetParseError,
},
#[error("'{0}': this is a hostname, and no host lookup was supplied to resolve it")]
NoHostLookup(String),
#[error("'{0}': not a valid address, range or hostname")]
MistypedAddress(String),
#[error(
"'{0}': not an address, and a hostname cannot contain ':'. \
An IPv6 target carrying ports must be bracketed, as in `[2001:db8::1]:443`"
)]
UnbracketedAddress(String),
#[error("'{0}': no address could be resolved for this name")]
UnknownHost(String),
#[error("'{0}': this named no addresses to scan")]
ResolvedToNothing(String),
}
fn blank_or_empty(token: &str) -> TargetParseError {
let spaces = token.chars().count();
match spaces {
0 => TargetParseError::Empty,
1 => TargetParseError::Blank(1, ""),
_ => TargetParseError::Blank(spaces, "s"),
}
}
#[non_exhaustive]
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct TargetExpr<'a> {
pub address: &'a str,
pub ports: Option<&'a str>,
}
impl<'a> TargetExpr<'a> {
pub fn parse(token: &'a str) -> Result<Self, TargetParseError> {
let trimmed = token.trim();
if trimmed.is_empty() {
return Err(blank_or_empty(token));
}
let token = trimmed;
if let Some(rest) = token.strip_prefix('[') {
let close = rest
.find(']')
.ok_or_else(|| TargetParseError::UnbalancedBracket(token.to_string()))?;
let address = &rest[..close];
let tail = &rest[close + 1..];
if address.is_empty() {
return Err(TargetParseError::Empty);
}
return match tail.strip_prefix(':') {
None if tail.is_empty() => Ok(Self {
address,
ports: None,
}),
None => Err(TargetParseError::TrailingText(token.to_string())),
Some("") => Err(TargetParseError::EmptyPorts(token.to_string())),
Some(ports) => Ok(Self {
address,
ports: Some(ports),
}),
};
}
let colons = token.matches(':').count();
let dotted_first = match (token.find('.'), token.find(':')) {
(Some(dot), Some(colon)) => dot < colon,
_ => false,
};
if colons >= 1 && (dotted_first || colons == 1) {
let (address, ports) = token.split_once(':').expect("a colon was found");
if address.is_empty() {
return Err(TargetParseError::Empty);
}
if ports.is_empty() {
return Err(TargetParseError::EmptyPorts(token.to_string()));
}
return Ok(Self {
address,
ports: Some(ports),
});
}
Ok(Self {
address: token,
ports: None,
})
}
pub fn addresses(&self) -> impl Iterator<Item = &'a str> {
self.address
.split(',')
.map(str::trim)
.filter(|part| !part.is_empty())
}
}
const GROUPING_SAMPLE: usize = 1_024;
const MIN_REGROUPED_SHARE: usize = 16;
#[derive(Debug, Clone)]
pub struct TargetMapBuilder {
default_ports: PortSet,
groups: Vec<(PortSet, IpSet)>,
index: Option<HashMap<PortSet, usize>>,
accepted: usize,
gross_addresses: u128,
}
impl TargetMapBuilder {
pub fn new(default_ports: PortSet) -> Self {
Self {
default_ports,
groups: Vec::new(),
index: Some(HashMap::new()),
accepted: 0,
gross_addresses: 0,
}
}
pub fn push(&mut self, token: &str, ctx: &TargetContext<'_>) -> Result<(), TargetParseError> {
let expr = TargetExpr::parse(token)?;
let ports = match expr.ports {
Some(spec) => PortSet::parse_scan(spec).map_err(|source| TargetParseError::Ports {
expression: token.trim().to_string(),
source,
})?,
None => self.default_ports.clone(),
};
let mut resolved = IpSet::new();
for address in expr.addresses() {
match insert_expression(address, &mut resolved, ctx.keywords, ctx.zones) {
Ok(()) => {}
Err(IpParseError::Malformed(_)) => {
self.resolve_host(address, &mut resolved, ctx)?;
}
Err(source) => {
return Err(TargetParseError::Address {
expression: token.trim().to_string(),
source,
});
}
}
}
if resolved.is_empty() {
return Err(TargetParseError::ResolvedToNothing(
token.trim().to_string(),
));
}
self.gross_addresses = self.gross_addresses.saturating_add(resolved.len_gross());
self.accepted += 1;
let existing = self
.index
.as_ref()
.and_then(|index| index.get(&ports).copied());
match existing {
Some(slot) => {
let target = &mut self.groups[slot].1;
for range in resolved.v4() {
target.push_v4_range(*range);
}
for range in resolved.v6() {
target.push_v6_range(*range);
}
}
None => {
let slot = self.groups.len();
if let Some(index) = self.index.as_mut() {
index.insert(ports.clone(), slot);
}
self.groups.push((ports, resolved));
}
}
self.reconsider_grouping();
Ok(())
}
fn reconsider_grouping(&mut self) {
if self.index.is_none() || self.accepted < GROUPING_SAMPLE {
return;
}
let regrouped = self.accepted - self.groups.len();
if regrouped * MIN_REGROUPED_SHARE < self.accepted {
self.index = None;
}
}
fn resolve_host(
&self,
name: &str,
into: &mut IpSet,
ctx: &TargetContext<'_>,
) -> Result<(), TargetParseError> {
match host_name(name) {
HostName::Yes => {}
HostName::Unbracketed => {
return Err(TargetParseError::UnbracketedAddress(name.to_string()));
}
HostName::Mistyped => {
return Err(TargetParseError::MistypedAddress(name.to_string()));
}
}
let lookup = ctx
.hosts
.ok_or_else(|| TargetParseError::NoHostLookup(name.to_string()))?;
let addresses = lookup(name).unwrap_or_default();
if addresses.is_empty() {
return Err(TargetParseError::UnknownHost(name.to_string()));
}
for address in addresses {
into.insert(address);
}
Ok(())
}
pub fn group_count(&self) -> usize {
self.groups.len()
}
pub fn address_count(&mut self) -> u128 {
self.groups
.iter_mut()
.map(|(_, ips)| {
ips.canonicalize();
ips.len()
})
.fold(0u128, |total, count| total.saturating_add(count))
}
pub fn gross_address_count(&self) -> u128 {
self.gross_addresses
}
pub fn is_empty(&self) -> bool {
self.groups.is_empty()
}
pub fn build(self) -> TargetMap {
let mut map = TargetMap::new();
for (ports, ips) in self.groups {
map.add_unit(TargetSet::new(ips, ports));
}
map
}
}
pub(crate) fn host_name(token: &str) -> HostName {
if let Some((_, tail)) = token.rsplit_once(':') {
return if PortSet::try_from(tail).is_ok() {
HostName::Unbracketed
} else {
HostName::Mistyped
};
}
let name_character = |c: char| c.is_alphanumeric() || matches!(c, '-' | '_' | '.');
let last_label = token
.strip_suffix('.')
.unwrap_or(token)
.rsplit('.')
.next()
.unwrap_or_default();
let numeric = |label: &str| {
label
.split('-')
.all(|part| !part.is_empty() && part.bytes().all(|byte| byte.is_ascii_digit()))
};
let leading: Vec<&str> = token
.strip_suffix('.')
.unwrap_or(token)
.rsplit('.')
.skip(1)
.collect();
let address_shaped = leading.len() >= 3 && leading.iter().all(|label| numeric(label));
if token.chars().all(name_character)
&& last_label.chars().any(char::is_alphabetic)
&& !address_shaped
{
HostName::Yes
} else {
HostName::Mistyped
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum HostName {
Yes,
Unbracketed,
Mistyped,
}
pub fn to_target_map<S>(
targets: &[S],
default_ports: PortSet,
ctx: &TargetContext<'_>,
) -> Result<TargetMap, TargetParseError>
where
S: AsRef<str>,
{
let mut builder = TargetMapBuilder::new(default_ports);
for target in targets {
builder.push(target.as_ref(), ctx)?;
}
Ok(builder.build())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_context_can_be_held_across_a_spawn() {
fn sent<T: Send + Sync>() {}
sent::<TargetContext<'static>>();
}
use crate::model::parse::ip::Keyword;
use crate::model::target::Target;
use std::net::Ipv4Addr;
fn ports(spec: &str) -> PortSet {
PortSet::try_from(spec).expect("test port specification parses")
}
#[test]
fn an_ipv6_address_is_never_split_at_its_own_colons() {
for token in [
"fe80::1",
"2001:db8::1",
"2001:db8::1:80",
"fe80::1%en0",
"2001:db8::1-2001:db8::5",
"::1",
] {
let expr = TargetExpr::parse(token).expect("parses");
assert_eq!(expr.address, token, "{token} lost part of its address");
assert_eq!(expr.ports, None, "{token} acquired ports it does not name");
}
}
#[test]
fn brackets_separate_an_ipv6_address_from_its_ports() {
let cases = [
("[2001:db8::1]:443", "2001:db8::1", Some("443")),
("[fe80::1%en0]:22", "fe80::1%en0", Some("22")),
("[2001:db8::1]", "2001:db8::1", None),
(
"[2001:db8::]:80,443,u:53",
"2001:db8::",
Some("80,443,u:53"),
),
];
for (token, address, port_spec) in cases {
let expr = TargetExpr::parse(token).expect("parses");
assert_eq!(expr.address, address);
assert_eq!(expr.ports, port_spec);
}
}
#[test]
fn a_single_colon_separates_ports() {
let cases = [
("192.0.2.1:80", "192.0.2.1", Some("80")),
("198.51.100.0/24:1-1024", "198.51.100.0/24", Some("1-1024")),
("198.51.100.1-50:80,443", "198.51.100.1-50", Some("80,443")),
("scanme.example:22", "scanme.example", Some("22")),
(" 192.0.2.1:80 ", "192.0.2.1", Some("80")),
];
for (token, address, port_spec) in cases {
let expr = TargetExpr::parse(token).expect("parses");
assert_eq!(expr.address, address);
assert_eq!(expr.ports, port_spec);
}
}
#[test]
fn a_udp_port_needs_no_brackets_on_an_address_that_has_a_dot() {
let cases = [
("192.0.2.1:u:53", "192.0.2.1", Some("u:53")),
("192.0.2.1:u:53,u:161", "192.0.2.1", Some("u:53,u:161")),
(
"198.51.100.0/24:80,u:53",
"198.51.100.0/24",
Some("80,u:53"),
),
("db.internal:u:53", "db.internal", Some("u:53")),
];
for (token, address, port_spec) in cases {
let expr = TargetExpr::parse(token).expect("parses");
assert_eq!(expr.address, address, "{token}");
assert_eq!(expr.ports, port_spec, "{token}");
}
for token in ["2001:db8::1", "::ffff:192.0.2.1", "2001:db8::192.0.2.1"] {
let expr = TargetExpr::parse(token).expect("parses");
assert_eq!(expr.address, token, "{token} was split");
assert_eq!(expr.ports, None, "{token} acquired ports");
}
}
#[test]
fn an_unbracketed_ipv6_target_with_ports_says_what_to_do_about_it() {
let mut builder = TargetMapBuilder::new(ports("80"));
let err = builder
.push("2001:db8::zz:443", &TargetContext::new())
.expect_err("not an address");
assert!(
matches!(err, TargetParseError::UnbracketedAddress(_)),
"got {err:?}"
);
assert!(
err.to_string().contains("[2001:db8::1]:443"),
"the error has to show the way out: {err}"
);
}
#[test]
fn a_separator_without_a_port_specification_is_refused() {
assert!(matches!(
TargetExpr::parse("192.0.2.1:"),
Err(TargetParseError::EmptyPorts(_))
));
assert!(matches!(
TargetExpr::parse("[2001:db8::1]:"),
Err(TargetParseError::EmptyPorts(_))
));
assert!(matches!(
TargetExpr::parse("[2001:db8::1"),
Err(TargetParseError::UnbalancedBracket(_))
));
assert!(matches!(
TargetExpr::parse("[2001:db8::1]443"),
Err(TargetParseError::TrailingText(_))
));
assert!(matches!(
TargetExpr::parse(":80"),
Err(TargetParseError::Empty)
));
let blank = TargetExpr::parse(" ").expect_err("whitespace is not a target");
assert!(
matches!(blank, TargetParseError::Blank(3, "s")),
"{blank:?}"
);
assert_eq!(
blank.to_string(),
"a target of 3 spaces; a stray '\\' in the shell?"
);
let one = TargetExpr::parse(" ").expect_err("a space is not a target");
assert_eq!(
one.to_string(),
"a target of 1 space; a stray '\\' in the shell?"
);
assert!(matches!(
TargetExpr::parse(""),
Err(TargetParseError::Empty)
));
}
#[test]
fn a_port_specification_naming_nothing_is_refused() {
let mut builder = TargetMapBuilder::new(ports("80"));
let ctx = TargetContext::new();
let error = builder
.push("192.0.2.1:,", &ctx)
.expect_err("a port half naming nothing");
assert!(error.to_string().contains("names no ports"), "{error}");
assert!(builder.is_empty(), "and nothing was added");
}
#[test]
fn targets_are_grouped_by_port_specification_not_by_token() {
let mut builder = TargetMapBuilder::new(ports("80"));
let ctx = TargetContext::new();
for octet in 0..=255u8 {
let target = format!("192.0.2.{octet}");
builder.push(&target, &ctx).expect("parses");
}
assert_eq!(builder.group_count(), 1, "one port specification, one unit");
assert_eq!(builder.address_count(), 256);
let map = builder.build();
assert_eq!(map.units.len(), 1);
assert_eq!(map.gross_targets().unwrap(), 256);
}
#[test]
fn distinct_port_specifications_get_distinct_units_in_first_seen_order() {
let mut builder = TargetMapBuilder::new(ports("80"));
let ctx = TargetContext::new();
builder.push("198.51.100.1:22", &ctx).unwrap();
builder.push("198.51.100.2:443", &ctx).unwrap();
builder.push("198.51.100.3:22", &ctx).unwrap();
builder.push("198.51.100.4", &ctx).unwrap();
assert_eq!(builder.group_count(), 3, "22, 443, and the default 80");
let map = builder.build();
assert_eq!(map.units[0].ports(), &ports("22"));
assert_eq!(map.units[0].ips().len(), 2, "198.51.100.1 and 198.51.100.3");
assert_eq!(map.units[1].ports(), &ports("443"));
assert_eq!(map.units[2].ports(), &ports("80"));
}
#[test]
fn port_specifications_group_by_what_they_mean_not_how_they_are_written() {
let mut builder = TargetMapBuilder::new(ports("80"));
let ctx = TargetContext::new();
builder.push("198.51.100.1:80,443", &ctx).unwrap();
builder.push("198.51.100.2:443,80", &ctx).unwrap();
builder.push("198.51.100.3:80-81,443", &ctx).unwrap();
assert_eq!(
builder.group_count(),
2,
"80 with 443 once, 80 through 81 with 443 once"
);
}
#[test]
fn a_keyword_that_resolves_to_nothing_says_what_went_wrong() {
fn resolves_to_nothing(_: Keyword, _: &mut IpSet) -> Result<(), IpParseError> {
Ok(())
}
let ctx = TargetContext::new().with_keywords(&resolves_to_nothing);
let mut builder = TargetMapBuilder::new(ports("80"));
let error = builder.push("lan", &ctx).expect_err("nothing was named");
assert_eq!(
error,
TargetParseError::ResolvedToNothing("lan".to_string()),
"the word it was said about has to be in it"
);
assert!(!error.to_string().contains("cannot be empty"), "{error}");
assert_eq!(
builder.push(" ", &ctx).expect_err("nothing was written"),
TargetParseError::Blank(3, "s")
);
assert_eq!(
builder.push("", &ctx).expect_err("nothing was written"),
TargetParseError::Empty
);
}
#[test]
fn a_hostname_without_a_lookup_is_refused_rather_than_skipped() {
let mut builder = TargetMapBuilder::new(ports("80"));
let err = builder
.push("scanme.example", &TargetContext::new())
.expect_err("a hostname needs a lookup");
assert!(
matches!(err, TargetParseError::NoHostLookup(ref name) if name == "scanme.example")
);
assert!(builder.is_empty(), "a refused target left nothing behind");
}
#[test]
fn a_hostname_resolves_through_the_callers_lookup() {
let lookup = |name: &str| match name {
"one.example" => Some(vec![IpAddr::V4(Ipv4Addr::new(198, 51, 100, 1))]),
"two.example" => Some(vec![
IpAddr::V4(Ipv4Addr::new(198, 51, 100, 2)),
IpAddr::V4(Ipv4Addr::new(198, 51, 100, 3)),
]),
_ => None,
};
let ctx = TargetContext::new().with_hosts(&lookup);
let mut builder = TargetMapBuilder::new(ports("80"));
builder.push("one.example", &ctx).unwrap();
builder.push("two.example:443", &ctx).unwrap();
assert_eq!(builder.address_count(), 3);
assert_eq!(builder.group_count(), 2);
let err = builder
.push("nowhere.example", &ctx)
.expect_err("a name with no records is not a target");
assert!(matches!(err, TargetParseError::UnknownHost(_)));
}
#[test]
fn a_malformed_address_is_reported_as_an_address() {
let lookup = |_: &str| -> Option<Vec<IpAddr>> {
panic!("a bad prefix must never be offered to a host lookup")
};
let ctx = TargetContext::new().with_hosts(&lookup);
let mut builder = TargetMapBuilder::new(ports("80"));
let err = builder.push("192.0.2.1/33", &ctx).expect_err("refused");
assert!(matches!(
err,
TargetParseError::Address {
source: IpParseError::InvalidPrefix(33),
..
}
));
}
#[test]
fn a_mistyped_range_is_refused_without_a_lookup() {
let lookup =
|name: &str| -> Option<Vec<IpAddr>> { panic!("{name} was offered to a host lookup") };
let ctx = TargetContext::new().with_hosts(&lookup);
for token in [
"10.10.10.*",
"10.10.1-5.1-254",
"10.10.10.1-256",
"10.10.10.0/",
"/0",
"192.0.2.300",
"2001:db8::1-ff",
"10.10.10.1a",
"10.10.10.a",
"10.10.10.1-2.example",
] {
let mut builder = TargetMapBuilder::new(ports("80"));
let err = builder.push(token, &ctx).expect_err(token);
assert!(
matches!(err, TargetParseError::MistypedAddress(ref t) if t == token),
"{token}: {err:?}"
);
assert_eq!(host_name(token), HostName::Mistyped, "{token}");
}
}
#[test]
fn a_name_of_any_ordinary_shape_still_reaches_the_lookup() {
for name in [
"printer",
"nas-1",
"scanme.example",
"scanme.example.",
"host_1.corp.example",
"3com.example",
"bücher.example",
"xn--bcher-kva.example",
"0.pool.ntp.example",
"192.0.2.1.sslip.example",
"1.2.0.192.in-addr.arpa",
] {
assert_eq!(host_name(name), HostName::Yes, "{name}");
}
assert_eq!(host_name("2001:db8::zz:443"), HostName::Unbracketed);
}
#[test]
fn a_malformed_port_specification_is_reported_as_ports() {
let mut builder = TargetMapBuilder::new(ports("80"));
let err = builder
.push("198.51.100.1:http", &TargetContext::new())
.expect_err("refused");
assert!(matches!(err, TargetParseError::Ports { .. }));
assert!(builder.is_empty());
}
#[test]
fn a_bracketed_link_local_target_keeps_its_interface() {
fn zones(name: &str) -> Option<u32> {
(name == "en0").then_some(7)
}
let ctx = TargetContext::new().with_zones(&zones);
let mut builder = TargetMapBuilder::new(ports("80"));
builder.push("[fe80::aa%en0]:22", &ctx).unwrap();
let map = builder.build();
assert_eq!(map.units[0].ips().v6()[0].zone(), Some(7));
assert_eq!(map.units[0].ports(), &ports("22"));
}
#[test]
fn a_resolver_may_close_over_what_it_needs_to_answer() {
let interfaces = [("en0".to_string(), 7u32), ("utun3".to_string(), 12)];
let zones = |name: &str| {
interfaces
.iter()
.find(|(known, _)| known == name)
.map(|(_, index)| *index)
};
let ctx = TargetContext::new().with_zones(&zones);
let mut builder = TargetMapBuilder::new(ports("80"));
builder.push("[fe80::aa%utun3]:22", &ctx).expect("parses");
let map = builder.build();
assert_eq!(map.units[0].ips().v6()[0].zone(), Some(12));
}
#[test]
fn the_running_address_total_matches_what_the_groups_hold() {
let ctx = TargetContext::new();
let mut builder = TargetMapBuilder::new(ports("80"));
for target in [
"198.51.100.0/24",
"198.51.100.5",
"192.0.2.1:22",
"2001:db8::/120",
"203.0.113.1,203.0.113.2,203.0.113.3",
"[fe80::1]:443",
] {
builder.push(target, &ctx).expect("parses");
}
let walked = builder
.groups
.iter()
.fold(0u128, |total, (_, ips)| total + ips.len_gross());
assert_eq!(builder.gross_address_count(), walked);
assert!(builder.gross_address_count() >= builder.address_count());
}
#[test]
fn address_count_reports_what_a_block_holds_not_what_was_written() {
let mut builder = TargetMapBuilder::new(ports("80"));
builder.push("10.0.0.0/8", &TargetContext::new()).unwrap();
assert_eq!(builder.address_count(), 16_777_216);
let mut everything = TargetMapBuilder::new(ports("80"));
everything.push("::/0", &TargetContext::new()).unwrap();
assert_eq!(everything.address_count(), u128::MAX);
}
#[test]
fn a_comma_separates_addresses_before_the_ports_and_ports_after_them() {
let ctx = TargetContext::new();
let mut hosts = TargetMapBuilder::new(ports("80"));
hosts.push("198.51.100.1,198.51.100.2:443", &ctx).unwrap();
assert_eq!(hosts.address_count(), 2);
assert_eq!(hosts.build().units[0].ports(), &ports("443"));
let mut services = TargetMapBuilder::new(ports("80"));
services.push("198.51.100.1:80,443", &ctx).unwrap();
assert_eq!(services.address_count(), 1);
assert_eq!(services.build().units[0].ports(), &ports("80,443"));
let mut bare = TargetMapBuilder::new(ports("80"));
bare.push("198.51.100.1, 198.51.100.2 ,198.51.100.3", &ctx)
.unwrap();
assert_eq!(bare.address_count(), 3);
}
fn grouped_by_hand(tokens: &[String], default: &PortSet) -> Vec<(PortSet, Vec<Target>)> {
let mut order: Vec<PortSet> = Vec::new();
let mut groups: HashMap<PortSet, IpSet> = HashMap::new();
for token in tokens {
let expr = TargetExpr::parse(token).expect("parses");
let ports = match expr.ports {
Some(spec) => PortSet::try_from(spec).expect("ports parse"),
None => default.clone(),
};
if !groups.contains_key(&ports) {
order.push(ports.clone());
groups.insert(ports.clone(), IpSet::new());
}
let ips = groups.get_mut(&ports).expect("just inserted");
for address in expr.addresses() {
insert_expression(address, ips, None, None).expect("addresses parse");
}
}
order
.into_iter()
.map(|ports| {
let ips = groups.remove(&ports).expect("one group per spelling");
let unit = TargetSet::new(ips, ports.clone());
(ports, unit.iter().collect())
})
.collect()
}
fn units_of(map: &TargetMap) -> Vec<(PortSet, Vec<Target>)> {
map.units
.iter()
.map(|unit| (unit.ports().clone(), unit.iter().collect()))
.collect()
}
#[test]
fn the_map_is_the_same_either_side_of_the_grouping_threshold() {
let ctx = TargetContext::new();
let default = ports("80");
for count in [
GROUPING_SAMPLE - 1,
GROUPING_SAMPLE + 1,
GROUPING_SAMPLE * 4,
] {
let tokens: Vec<String> = (0..count)
.map(|i| format!("10.0.{}.{}:{}", i / 256, i % 256, 1 + i))
.collect();
let mut builder = TargetMapBuilder::new(default.clone());
for token in &tokens {
builder.push(token, &ctx).expect("parses");
}
let built = builder.build();
assert_eq!(
units_of(&built),
grouped_by_hand(&tokens, &default),
"{count} expressions, none of them sharing a specification"
);
}
}
#[test]
fn a_file_that_never_groups_gives_the_index_up() {
let mut builder = TargetMapBuilder::new(ports("80"));
let ctx = TargetContext::new();
for i in 0..GROUPING_SAMPLE {
let token = format!("10.0.{}.{}:{}", i / 256, i % 256, 1 + i);
builder.push(&token, &ctx).expect("parses");
}
assert_eq!(builder.group_count(), GROUPING_SAMPLE);
builder.push("10.9.9.9:1", &ctx).expect("parses");
assert_eq!(builder.group_count(), GROUPING_SAMPLE + 1);
let map = builder.build();
assert_eq!(map.units[0].ports(), &ports("1"));
assert_eq!(map.units[GROUPING_SAMPLE].ports(), &ports("1"));
assert_eq!(
map.gross_targets().unwrap(),
GROUPING_SAMPLE as u128 + 1,
"both units are still scanned, on the ports they named"
);
}
#[test]
fn a_file_that_groups_keeps_its_index_however_long_it_is() {
let mut builder = TargetMapBuilder::new(ports("80"));
let ctx = TargetContext::new();
for i in 0..GROUPING_SAMPLE * 4 {
let token = format!("10.0.{}.{}", i / 256, i % 256);
builder.push(&token, &ctx).expect("parses");
}
assert_eq!(builder.group_count(), 1);
}
#[test]
fn the_index_is_kept_or_given_up_on_how_much_actually_regroups() {
let ctx = TargetContext::new();
let lines = GROUPING_SAMPLE * 4;
for (every, kept) in [(8usize, true), (32, false)] {
let mut builder = TargetMapBuilder::new(ports("80"));
for i in 0..lines {
let spec = 1 + i - usize::from(i % every == every - 1);
let token = format!("10.0.{}.{}:{}", i / 256, i % 256, spec);
builder.push(&token, &ctx).expect("parses");
}
let regrouped = lines / every;
if kept {
assert_eq!(
builder.group_count(),
lines - regrouped,
"one line in {every} joined the group before it"
);
} else {
assert!(
builder.group_count() > lines - regrouped,
"one line in {every} is too little to keep an index for"
);
}
}
}
#[test]
fn overlapping_targets_in_one_group_merge_rather_than_duplicate() {
let mut builder = TargetMapBuilder::new(ports("80"));
let ctx = TargetContext::new();
builder.push("10.0.0.0/24", &ctx).unwrap();
builder.push("10.0.0.5", &ctx).unwrap();
builder.push("10.0.0.128-10.0.1.10", &ctx).unwrap();
assert_eq!(builder.address_count(), 267, "0.0-1.10, counted once each");
assert_eq!(builder.group_count(), 1);
}
}