use std::collections::BTreeSet;
use std::net::IpAddr;
use crate::diff::change::{Change, Presence};
use crate::diff::port::{self, Clocks, PortDelta, PresenceFor};
use crate::diff::scope::ScopeIndex;
use crate::model::host::os::OsFingerprint;
use crate::model::host::{Host, HostStatus, NetworkRole};
use crate::model::mac::MacAddr;
#[derive(Debug, Clone)]
pub struct HostDelta {
address: IpAddr,
presence: Presence,
baseline: Option<Host>,
current: Option<Host>,
baseline_records: usize,
current_records: usize,
changes: Vec<HostChange>,
ports: Vec<PortDelta>,
}
impl HostDelta {
pub fn address(&self) -> IpAddr {
self.address
}
pub fn presence(&self) -> Presence {
self.presence
}
pub fn baseline(&self) -> Option<&Host> {
self.baseline.as_ref()
}
pub fn current(&self) -> Option<&Host> {
self.current.as_ref()
}
pub fn records(&self) -> (usize, usize) {
(self.baseline_records, self.current_records)
}
pub fn is_regrouped(&self) -> bool {
self.baseline_records > 1 || self.current_records > 1
}
pub fn changes(&self) -> &[HostChange] {
&self.changes
}
pub fn ports(&self) -> &[PortDelta] {
&self.ports
}
pub fn is_empty(&self) -> bool {
self.presence.is_in_both() && self.changes.is_empty() && self.ports.is_empty()
}
}
#[non_exhaustive]
#[derive(Debug, Clone, PartialEq)]
pub enum HostChange {
Status(Change<HostStatus>),
Hostname(Change<Option<String>>),
Addresses {
gained: Vec<IpAddr>,
lost: Vec<IpAddr>,
},
Os(Box<Change<Option<OsFingerprint>>>),
Macs {
gained: Vec<MacAddr>,
lost: Vec<MacAddr>,
},
Vendor(Change<Option<String>>),
Roles {
gained: Vec<NetworkRole>,
lost: Vec<NetworkRole>,
},
}
#[allow(clippy::too_many_arguments)]
pub(crate) fn compare(
baseline: Option<&Host>,
current: Option<&Host>,
baseline_records: usize,
current_records: usize,
baseline_scope: &ScopeIndex,
current_scope: &ScopeIndex,
address: &IpAddr,
clocks: &Clocks,
) -> HostDelta {
let address = *address;
let known = current
.or(baseline)
.expect("a delta has a record on one side");
let baseline_coverage = baseline_scope.of_host(known);
let current_coverage = current_scope.of_host(baseline.or(current).expect("likewise"));
let presence = match (baseline, current) {
(Some(_), Some(_)) => Presence::Both,
(None, Some(_)) => Presence::Added {
before: baseline_coverage,
},
(Some(_), None) => Presence::Removed {
after: current_coverage,
},
(None, None) => unreachable!("a host delta has a record on at least one side"),
};
let changes = match (baseline, current) {
(Some(before), Some(after)) => changes_between(before, after),
_ => Vec::new(),
};
let ports = port::compare(
&baseline.map(collect_ports).unwrap_or_default(),
¤t.map(collect_ports).unwrap_or_default(),
PresenceFor {
baseline: &|number, protocol| {
baseline_scope.endpoint(baseline_coverage, number, protocol)
},
current: &|number, protocol| current_scope.endpoint(current_coverage, number, protocol),
},
clocks,
);
HostDelta {
address,
presence,
baseline: baseline.cloned(),
current: current.cloned(),
baseline_records,
current_records,
changes,
ports,
}
}
fn collect_ports(host: &Host) -> Vec<&crate::model::port::Port> {
host.ports().collect()
}
fn changes_between(before: &Host, after: &Host) -> Vec<HostChange> {
let mut changes = Vec::new();
if let Some(status) = Change::between(before.status(), after.status()) {
changes.push(HostChange::Status(status));
}
if let Some(hostname) = Change::between(
before.hostname().map(str::to_owned),
after.hostname().map(str::to_owned),
) {
changes.push(HostChange::Hostname(hostname));
}
let (gained, lost) = difference(before.ips().iter().copied(), after.ips().iter().copied());
if !gained.is_empty() || !lost.is_empty() {
changes.push(HostChange::Addresses { gained, lost });
}
if !same_system(before.os(), after.os()) {
changes.push(HostChange::Os(Box::new(Change::new(
before.os().cloned(),
after.os().cloned(),
))));
}
let (gained, lost) = difference(
before
.hardware()
.into_iter()
.flat_map(|hardware| hardware.macs().keys().copied()),
after
.hardware()
.into_iter()
.flat_map(|hardware| hardware.macs().keys().copied()),
);
if !gained.is_empty() || !lost.is_empty() {
changes.push(HostChange::Macs { gained, lost });
}
if let Some(vendor) = Change::between(
before.vendor().map(str::to_owned),
after.vendor().map(str::to_owned),
) {
changes.push(HostChange::Vendor(vendor));
}
let (gained, lost) = difference(
before.network_roles().iter().copied(),
after.network_roles().iter().copied(),
);
if !gained.is_empty() || !lost.is_empty() {
changes.push(HostChange::Roles { gained, lost });
}
changes
}
fn same_system(before: Option<&OsFingerprint>, after: Option<&OsFingerprint>) -> bool {
match (before, after) {
(None, None) => true,
(Some(before), Some(after)) => {
before.name() == after.name()
&& before.family() == after.family()
&& before.generation() == after.generation()
&& before.vendor() == after.vendor()
&& before.kernel() == after.kernel()
&& before.cpes() == after.cpes()
}
_ => false,
}
}
fn difference<T: Ord + Clone>(
before: impl Iterator<Item = T>,
after: impl Iterator<Item = T>,
) -> (Vec<T>, Vec<T>) {
let before: BTreeSet<T> = before.collect();
let after: BTreeSet<T> = after.collect();
let gained = after.difference(&before).cloned().collect();
let lost = before.difference(&after).cloned().collect();
(gained, lost)
}