use dashmap::DashMap;
use std::net::IpAddr;
use std::sync::{Arc, Mutex};
use tokio::sync::mpsc;
use tracing::error;
use crate::core::handle::ScanHandle;
use crate::core::models::host::Host;
use crate::core::report::{ProbeStats, ScannerFailure};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ScannerKind {
Local,
Routed,
SynPort,
Connect,
UdpPort,
Composite,
}
#[derive(Debug, Clone)]
#[non_exhaustive]
pub enum ScanEvent {
HostUpdated(IpAddr),
ScannerFailed {
scanner: ScannerKind,
reason: String,
},
}
pub struct ScanSession {
pub store: Arc<DashMap<IpAddr, Host>>,
pub events: mpsc::UnboundedReceiver<ScanEvent>,
pub handle: ScanHandle,
}
#[derive(Debug, Default)]
pub(crate) struct ProbeStatsLog {
entries: Mutex<Vec<ProbeStats>>,
}
impl ProbeStatsLog {
fn push(&self, stats: ProbeStats) {
let mut entries = self.entries.lock().unwrap_or_else(|e| e.into_inner());
entries.push(stats);
}
fn drain(&self) -> Vec<ProbeStats> {
let mut entries = self.entries.lock().unwrap_or_else(|e| e.into_inner());
std::mem::take(&mut *entries)
}
#[cfg(feature = "test-support")]
fn snapshot(&self) -> Vec<ProbeStats> {
self.entries
.lock()
.unwrap_or_else(|e| e.into_inner())
.clone()
}
}
#[derive(Debug, Default)]
pub(crate) struct FailureLog {
entries: Mutex<Vec<ScannerFailure>>,
}
impl FailureLog {
fn push(&self, failure: ScannerFailure) {
let mut entries = self.entries.lock().unwrap_or_else(|e| e.into_inner());
entries.push(failure);
}
fn drain(&self) -> Vec<ScannerFailure> {
let mut entries = self.entries.lock().unwrap_or_else(|e| e.into_inner());
std::mem::take(&mut *entries)
}
}
#[derive(Clone)]
pub struct ScanContext {
pub handle: ScanHandle,
pub store: Arc<DashMap<IpAddr, Host>>,
pub events_tx: mpsc::UnboundedSender<ScanEvent>,
pub(crate) failures: Arc<FailureLog>,
pub(crate) probe_stats: Arc<ProbeStatsLog>,
}
impl ScanContext {
pub fn write_host(&self, ip: IpAddr, edit: impl FnOnce(&mut Host) -> bool) -> bool {
let mut is_new = false;
let mut host = self.store.entry(ip).or_insert_with(|| {
is_new = true;
Host::new(ip)
});
let changed = edit(&mut host);
drop(host);
if changed || is_new {
let _ = self.events_tx.send(ScanEvent::HostUpdated(ip));
}
is_new
}
pub(crate) fn record_failure(&self, scanner: ScannerKind, reason: String) {
error!("Scanner {scanner:?} failed: {reason}");
self.failures
.push(ScannerFailure::new(scanner, reason.clone()));
let _ = self
.events_tx
.send(ScanEvent::ScannerFailed { scanner, reason });
}
pub(crate) fn record_probe_stats(&self, stats: ProbeStats) {
self.probe_stats.push(stats);
}
pub(crate) fn take_probe_stats(&self) -> Vec<ProbeStats> {
self.probe_stats.drain()
}
#[cfg(feature = "test-support")]
pub fn probe_stats_snapshot(&self) -> Vec<ProbeStats> {
self.probe_stats.snapshot()
}
pub(crate) fn take_failures(&self) -> Vec<ScannerFailure> {
self.failures.drain()
}
pub fn update_host(&self, ip: IpAddr, update: impl FnOnce(&mut Host)) -> bool {
self.write_host(ip, |host| {
update(host);
true
})
}
}
impl ScanSession {
pub fn new() -> (Self, ScanContext) {
let store = Arc::new(DashMap::new());
let handle = ScanHandle::new();
let (events_tx, rx) = mpsc::unbounded_channel();
let session = Self {
store: store.clone(),
events: rx,
handle: handle.clone(),
};
let ctx = ScanContext {
handle,
store,
events_tx,
failures: Arc::new(FailureLog::default()),
probe_stats: Arc::new(ProbeStatsLog::default()),
};
(session, ctx)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_failure_survives_a_consumer_that_never_listens() {
let (session, ctx) = ScanSession::new();
drop(session);
ctx.record_failure(ScannerKind::Routed, "raw socket unavailable".into());
let failures = ctx.take_failures();
assert_eq!(failures.len(), 1);
assert_eq!(failures[0].scanner(), ScannerKind::Routed);
assert_eq!(failures[0].reason(), "raw socket unavailable");
}
#[test]
fn a_failure_reaches_both_the_log_and_the_stream() {
let (mut session, ctx) = ScanSession::new();
ctx.record_failure(ScannerKind::Local, "eth0: no address".into());
match session.events.try_recv() {
Ok(ScanEvent::ScannerFailed { scanner, reason }) => {
assert_eq!(scanner, ScannerKind::Local);
assert_eq!(reason, "eth0: no address");
}
other => panic!("expected a ScannerFailed event, got {other:?}"),
}
assert_eq!(ctx.take_failures().len(), 1);
}
#[test]
fn taking_failures_empties_the_log() {
let (_session, ctx) = ScanSession::new();
ctx.record_failure(ScannerKind::Connect, "refused".into());
assert_eq!(ctx.take_failures().len(), 1);
assert!(ctx.take_failures().is_empty());
}
#[test]
fn failures_from_every_clone_land_in_one_log() {
let (_session, ctx) = ScanSession::new();
let clone = ctx.clone();
ctx.record_failure(ScannerKind::Local, "eth0".into());
clone.record_failure(ScannerKind::Routed, "gateway".into());
assert_eq!(ctx.take_failures().len(), 2);
}
}