pub mod idle;
pub mod sctp;
pub mod tcp;
pub mod udp;
pub use idle::IdlePortScanner;
pub use sctp::SctpPortScanner;
pub use tcp::TcpPortScanner;
pub use udp::UdpPortScanner;
use std::net::IpAddr;
use std::num::NonZeroU32;
use std::time::{Duration, Instant};
use tokio::sync::mpsc;
use crate::config::ProbeTuning;
use crate::evasion::SegmentShaping;
use crate::journal::settle::Outcome;
use crate::model::host::{HostStatus, StatusProtocol, StatusReason};
use crate::model::port::{PortState, Protocol};
use crate::model::target::PlannedTarget;
use crate::report::ScannerKind;
use crate::report::StopReason;
use crate::scanner::audit::{Pacing, ProbeAudit};
use crate::scanner::pacing::congestion::{CongestionWindow, WindowLimits};
use crate::scanner::pacing::deadline::HeldAllowance;
use crate::scanner::pacing::deadline::{AdaptiveDeadline, AdaptiveDeadlineConfig};
use crate::scanner::pacing::retry::{
Due, ProbeLedger, Resolution, RetryPolicy, SilentHostPolicy, saturating_mul,
};
use crate::scanner::session::ScanContext;
use crate::scanner::strategy::raw::neighbors::{
Admission, HoldDowns, NEIGHBOR_RECHECK, NeighborGates, RESOLUTION_BUDGET,
};
use crate::scanner::strategy::{PortScanner, StrategyError};
use crate::system::interface::{NoSource, SourceResolver};
use crate::transport::capture::CapturedSegment;
use crate::transport::kernel_neighbors::NeighborState;
use crate::transport::probe::{Emission, ProbeTransport, SendError};
use crate::{info, warn};
const PORT_RETRY_POLICY: RetryPolicy = RetryPolicy::new(
3,
Duration::from_millis(200),
Duration::from_millis(25),
Duration::from_secs(2),
3.0,
0.3,
Some(SilentHostPolicy::new(32, 2)),
);
const TCP_PORT_WINDOW: WindowLimits = WindowLimits::new(32, 16, 1_024, 64);
const TCP_PORT_UNRESOLVED: usize = 8_192;
const TCP_PORT_RATE_CEILING: NonZeroU32 = NonZeroU32::new(20_000).expect("a non-zero rate");
const UDP_PORT_RATE_PER_SEC: NonZeroU32 = NonZeroU32::new(400).expect("a non-zero rate");
const SEND_SLACK: f64 = 1.5;
fn deadline_for(
config: AdaptiveDeadlineConfig,
retry: &RetryPolicy,
window: WindowLimits,
rate: NonZeroU32,
host_gap: Option<Duration>,
target_count: usize,
) -> AdaptiveDeadlineConfig {
let attempts = u32::from(retry.max_attempts.max(1));
let by_window = retry.longest_timeout() / window.floor.max(1);
let by_rate = saturating_mul(
Duration::from_secs(1),
SEND_SLACK * f64::from(attempts) / f64::from(rate.get()),
);
let by_gap = host_gap.unwrap_or_default().saturating_mul(attempts);
config
.allowing_for(retry.longest_probe_lifetime())
.allowing_pace_of(by_window.max(by_rate).max(by_gap), target_count)
}
pub(crate) type ProbeTarget = (IpAddr, u16);
pub(crate) struct RawProbeScan<T> {
pub resolver: SourceResolver,
pub ctx: ScanContext,
pub transport: ProbeTransport,
pub deadline: AdaptiveDeadline,
pub ledger: ProbeLedger<ProbeTarget, T, u64>,
pub due: Vec<Due<ProbeTarget, u64>>,
pub src_port: u16,
pub emission: Emission,
pub shaping: SegmentShaping,
pub decoys: Vec<IpAddr>,
pub send_failure: Option<String>,
pub unasked_refused: u64,
pub retries_refused: u64,
pub unasked_unsent: u64,
pub unreachable: std::collections::BTreeSet<IpAddr>,
pub(crate) held_down: HoldDowns,
held_allowed: HeldAllowance,
pub(crate) neighbors: NeighborGates,
pub audit: ProbeAudit,
pub window: CongestionWindow,
pub send_tick: Duration,
pub batch: usize,
pub max_unresolved: usize,
pub held: std::collections::BinaryHeap<HeldProbe>,
pub(crate) retries: std::collections::BinaryHeap<HeldProbe>,
}
pub(super) struct CoreParts<'a> {
pub resolver: SourceResolver,
pub ctx: ScanContext,
pub transport: ProbeTransport,
pub tuning: &'a ProbeTuning,
pub src_port: u16,
pub target_count: usize,
pub retry: RetryPolicy,
pub rate: NonZeroU32,
pub deadline: AdaptiveDeadlineConfig,
pub window: WindowLimits,
pub max_unresolved: usize,
}
impl<T: Copy + PartialEq> RawProbeScan<T> {
pub(super) fn new(parts: CoreParts<'_>) -> Self {
let CoreParts {
resolver,
ctx,
transport,
tuning,
src_port,
target_count,
retry,
rate,
deadline,
window,
max_unresolved,
} = parts;
let src_port = transport.reply_port().unwrap_or(src_port);
let (send_tick, batch) = super::raw::pacing_for(rate);
let deadline = deadline_for(
deadline,
&retry,
window,
rate,
ctx.host_probe_interval(),
target_count,
);
let mut core = Self {
resolver,
ctx,
transport,
deadline: AdaptiveDeadline::new(deadline, target_count),
ledger: ProbeLedger::new(retry, target_count.min(max_unresolved)),
due: Vec::new(),
src_port,
emission: tuning.evasion.emission(),
shaping: tuning.evasion.segment_shaping(),
decoys: tuning.evasion.decoys.clone(),
send_failure: None,
unasked_refused: 0,
retries_refused: 0,
unasked_unsent: 0,
unreachable: std::collections::BTreeSet::new(),
held_down: HoldDowns::default(),
held_allowed: HeldAllowance::default(),
neighbors: NeighborGates::default(),
audit: ProbeAudit::new(),
window: CongestionWindow::new(window),
send_tick,
batch,
max_unresolved,
held: std::collections::BinaryHeap::new(),
retries: std::collections::BinaryHeap::new(),
};
core.seed_timing();
core
}
pub fn stop_reason(&self, sending_finished: bool) -> Option<StopReason> {
if let Some(cause) = self.ctx.handle.stopped() {
return Some(cause.into());
}
if self.deadline.hard_deadline_passed() {
return Some(StopReason::DeadlineExpired);
}
if sending_finished && self.ledger.is_empty() && self.held.is_empty() {
return Some(StopReason::AttemptsSpent);
}
None
}
pub fn admitting(&self, sending_finished: bool) -> bool {
self.questions_left(sending_finished)
&& self.window.has_room()
&& self.ledger.len() < self.max_unresolved
}
fn questions_left(&self, sending_finished: bool) -> bool {
!sending_finished || !self.held.is_empty()
}
pub fn held_is_full(&self) -> bool {
self.held.len() >= self.max_unresolved
}
pub(crate) fn sending(&self, sending_finished: bool) -> bool {
self.admitting(sending_finished) || !self.retries.is_empty()
}
fn hold(&mut self, ip: IpAddr, port: u16, position: Option<u64>, ready: Instant) {
let entry = HeldProbe {
ip,
port,
position,
ready,
};
match position {
Some(_) => self.held.push(entry),
None => self.retries.push(entry),
}
}
fn take_ready(&mut self, now: Instant) -> Option<HeldProbe> {
take_ready_from(&mut self.held, &self.ctx, now)
}
pub(crate) fn take_ready_retry(&mut self, now: Instant) -> Option<HeldProbe> {
take_ready_from(&mut self.retries, &self.ctx, now)
}
pub fn record_send(
&mut self,
(host, port): ProbeTarget,
sent: Result<(), &SendError>,
first_attempt: bool,
) {
self.audit.record_send(sent.is_ok());
match (sent, first_attempt) {
(Ok(()), first) => {
self.ctx.host_probed(host, Instant::now());
if first {
self.window.record_send();
} else {
self.window.record_resend();
}
}
(Err(error @ SendError::HeldDown(_)), _) if self.hold_down(host) => {
info!(
verbosity = 2,
"{host} held down by the kernel, asked again in {}s ({error:#})",
self.held_down.hold_down_for.as_secs()
);
}
(Err(error), _) if error.is_unroutable() && !self.ledger.host_has_answered(&host) => {
if self.unreachable.insert(host) {
info!(verbosity = 2, "{host} unreachable ({error:#})");
}
}
(Err(error), first) => {
self.window.record_congestion();
if first {
self.unasked_refused += 1;
} else {
self.retries_refused += 1;
}
if self.send_failure.is_none() {
warn!(verbosity = 2, "probe to {host}:{port} not sent ({error:#})");
self.send_failure = Some(format!("{error:#}"));
}
}
}
}
pub(crate) fn hold_down(&mut self, host: IpAddr) -> bool {
let now = Instant::now();
let Some(until) = self.held_down.hold(host, now) else {
return false;
};
self.allow_until(now, until);
true
}
fn allow_until(&mut self, now: Instant, until: Instant) {
let held = self.held_allowed.take(now, until);
self.deadline.allow_for_holding(held);
}
fn held_down_until(&self, host: IpAddr, now: Instant) -> Option<Instant> {
self.held_down.until(host, now)
}
pub(crate) fn source_for(
&mut self,
target: ProbeTarget,
first_attempt: bool,
) -> Option<IpAddr> {
let refusal = match self.resolver.source(target.0) {
Ok(source) => return Some(source),
Err(NoSource::Unreached) => {
self.record_no_route(target.0);
return None;
}
Err(NoSource::Unasked(error)) => SendError::from_io(error),
Err(NoSource::Unanswered(error)) => SendError::unanswered_route(&error),
};
self.record_send(target, Err(&refusal), first_attempt);
None
}
pub fn record_no_route(&mut self, host: IpAddr) {
if self.unreachable.insert(host) {
let why = if self.resolver.refused_by_route(host) {
self.ctx.note_refused_by_route(host);
"a route refuses it"
} else {
"no source address"
};
info!(verbosity = 2, "{host} unreachable ({why})");
}
}
fn record_unresolved(&mut self, host: IpAddr, state: NeighborState) {
if self.unreachable.insert(host) {
let why = self.neighbors.unreached(host, state);
info!(verbosity = 2, "{host} unreachable ({why})");
}
}
pub(crate) fn admit(&mut self, host: IpAddr, now: Instant) -> Admission {
if self.is_unreachable(&host) {
return Admission::Unreachable;
}
if let Some(until) = self.held_down_until(host, now) {
return Admission::Hold(until);
}
if self.ledger.host_has_answered(&host) {
return Admission::Send;
}
let admission =
self.neighbors
.admit(self.transport.neighbors(), &mut self.resolver, host, now);
if let Some(asked) = self.neighbors.take_asked_again() {
let until = crate::scanner::pacing::timer::later(asked, RESOLUTION_BUDGET);
self.allow_until(now.max(asked), until);
}
if admission == Admission::Unreachable {
self.record_unresolved(host, self.neighbors.given_up_in(host));
}
admission
}
pub(crate) fn pending_neighbor(&mut self, host: IpAddr) -> Option<NeighborState> {
if self.is_unreachable(&host) || self.ledger.host_has_answered(&host) {
return None;
}
self.neighbors
.pending(self.transport.neighbors(), &mut self.resolver, host)
}
pub(crate) fn conclude_pending_neighbors(&mut self) {
for host in self.neighbors.waiting() {
if let Some(state) = self.pending_neighbor(host)
&& state.is_unresolved()
{
self.record_unresolved(host, state);
}
}
}
pub fn is_unreachable(&self, host: &IpAddr) -> bool {
self.unreachable.contains(host) && !self.ledger.host_has_answered(host)
}
pub fn judge_timeout(&mut self, host: IpAddr, silence: PortState) {
self.window.release();
if !self.ledger.host_is_answering(&host) {
self.window.record_progress();
} else if silence == PortState::Filtered {
self.window.record_loss();
} else {
self.window.record_ambiguous_silence();
}
}
pub fn record_answer<P: Copy>(&mut self, resolution: &Resolution<P>) {
self.deadline.mark_activity();
if let Some(rtt) = resolution.rtt {
self.deadline.record_rtt(rtt);
}
match (resolution.attempts, resolution.answered_attempt) {
(1, _) => {
self.window.release();
self.window.record_answer();
}
(_, Some(attempt)) if attempt > 1 => self.window.record_congestion(),
_ => {}
}
self.audit.record_host_found(resolution.answered_attempt);
}
pub fn tick_delay(&self, now: Instant) -> Duration {
let until_deadline_tick = self.deadline.time_until_next_tick();
match self.ledger.next_due() {
Some(due) => until_deadline_tick.min(due.saturating_duration_since(now)),
None => until_deadline_tick,
}
}
pub fn seed_timing(&mut self) {
for host in self.ctx.store.iter() {
self.ledger
.seed_host(host.key().addr(), host.value().telemetry());
}
}
pub fn record_host_down(
&mut self,
key: &ProbeTarget,
token: Option<T>,
sender: IpAddr,
) -> bool {
if !self.ledger.names_attempt(key, token.as_ref()) {
self.audit.record_off_target();
return false;
}
if self.resolver.resolve(key.0) == Some(sender) {
self.record_unresolved(key.0, NeighborState::Failed);
return true;
}
let mut recorded = false;
self.ctx.update_host(key.0, |host| {
host.record_evidence(
HostStatus::Down,
StatusReason::new(StatusProtocol::IcmpUnreachable, "destination unreachable")
.from_source(sender),
);
recorded = true;
});
recorded
}
fn refusals_failure(&self) -> Option<String> {
let cause = self.send_failure.as_deref().unwrap_or("cause unrecorded");
let unasked = crate::logging::counted(u128::from(self.unasked_refused), "port", "ports");
let retries = crate::logging::counted(u128::from(self.retries_refused), "retry", "retries");
match (self.unasked_refused, self.retries_refused) {
(0, 0) => None,
(_, 0) => Some(format!("{unasked} unasked, probes not sent ({cause})")),
(0, _) => Some(format!("{retries} not sent, ports asked less ({cause})")),
(_, _) => Some(format!("{unasked} unasked, {retries} not sent ({cause})")),
}
}
pub fn finish(
&mut self,
kind: ScannerKind,
audit_tag: &str,
silence_verdict: &str,
silence: PortState,
probes: u128,
reason: StopReason,
) {
if let Some(failure) = self.refusals_failure() {
self.ctx.record_failure(kind, failure);
}
for host in &self.unreachable {
if !self.ledger.host_has_answered(host) {
self.ctx.record_unroutable(*host);
}
}
if self.unasked_unsent > 0 {
let deaf = self
.transport
.capture_counts()
.is_some_and(|counts| counts.stopped_early > 0);
let cause = if deaf {
"a capture stopped early, so their probes may have left unseen"
} else {
"this machine accepted their probes and never put them on the wire"
};
self.ctx.record_failure(
kind,
format!(
"{} recorded unasked rather than {silence_verdict}: {cause}",
crate::logging::counted(u128::from(self.unasked_unsent), "port", "ports"),
),
);
}
let capture = self.transport.capture_counts();
self.audit.report(
audit_tag,
probes,
reason,
capture,
Some(Pacing {
window: self.window.summary(),
silence,
unasked: u128::from(self.unasked_refused) + u128::from(self.unasked_unsent),
}),
);
self.ctx.record_probe_stats(self.audit.stats(
kind,
probes,
reason,
capture,
Some(self.window.summary()),
));
}
}
fn take_ready_from(
queue: &mut std::collections::BinaryHeap<HeldProbe>,
ctx: &ScanContext,
now: Instant,
) -> Option<HeldProbe> {
while let Some(next) = queue.peek() {
if next.ready > now {
return None;
}
let mut entry = queue.pop().expect("peeked");
match ctx.host_ready_at(entry.ip, now) {
None => return Some(entry),
Some(ready) => {
entry.ready = ready;
queue.push(entry);
}
}
}
None
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) struct HeldProbe {
ip: IpAddr,
port: u16,
position: Option<u64>,
ready: Instant,
}
impl Ord for HeldProbe {
fn cmp(&self, other: &Self) -> std::cmp::Ordering {
other
.ready
.cmp(&self.ready)
.then_with(|| self.port.cmp(&other.port))
}
}
impl PartialOrd for HeldProbe {
fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
Some(self.cmp(other))
}
}
pub(crate) trait RawPortScan: PortScanner {
type Token: Copy + PartialEq;
fn core(&self) -> &RawProbeScan<Self::Token>;
fn core_mut(&mut self) -> &mut RawProbeScan<Self::Token>;
fn protocol(&self) -> Protocol;
fn silence_means(&self) -> PortState;
fn audit_labels(&self) -> AuditLabels;
fn probe(&mut self, ip: IpAddr, port: u16, position: u64, now: Instant) {
match self.core_mut().admit(ip, now) {
Admission::Send => send_timed(self, ip, port, Some(position), now),
Admission::Hold(ready) => {
self.core_mut().hold(ip, port, Some(position), ready);
return;
}
Admission::Unreachable => {
self.record_unasked_endpoint(ip, port);
return;
}
}
if let Some(ready) = self.core().held_down_until(ip, now) {
self.core_mut().hold(ip, port, Some(position), ready);
return;
}
if !self.core().ledger.contains(&(ip, port)) {
self.record_unasked_endpoint(ip, port);
}
}
fn reprobe(&mut self, ip: IpAddr, port: u16, now: Instant) {
if !self.core().ledger.contains(&(ip, port)) {
return;
}
match self.core_mut().admit(ip, now) {
Admission::Send => send_timed(self, ip, port, None, now),
Admission::Hold(ready) => {
self.core_mut().hold(ip, port, None, ready);
return;
}
Admission::Unreachable => {}
}
if let Some(ready) = self.core().held_down_until(ip, now) {
self.core_mut().hold(ip, port, None, ready);
return;
}
self.core_mut().ledger.resume(&(ip, port), now);
}
fn send(&mut self, ip: IpAddr, port: u16, position: Option<u64>, now: Instant);
fn handle_reply(&mut self, reply: &CapturedSegment, now: Instant);
fn record_port(&mut self, ip: IpAddr, port: u16, state: PortState, sender: Option<IpAddr>);
fn settle(&mut self, outcome: Outcome) {
self.core().ctx.record_outcome(outcome);
}
fn send_probe(&mut self, planned: PlannedTarget) {
if planned.protocol() == self.protocol() {
self.probe(
planned.ip(),
planned.port(),
planned.position,
Instant::now(),
);
}
}
fn hold_probe(&mut self, planned: PlannedTarget, ready: Instant) {
if planned.protocol() == self.protocol() {
self.core_mut()
.hold(planned.ip(), planned.port(), Some(planned.position), ready);
}
}
fn send_held(&mut self, held: HeldProbe, now: Instant) {
match held.position {
Some(position) => self.probe(held.ip, held.port, position, now),
None => self.reprobe(held.ip, held.port, now),
}
}
fn resolve_held(&mut self) {
self.core_mut().retries.clear();
let held = std::mem::take(&mut self.core_mut().held);
for entry in held {
self.record_unasked_endpoint(entry.ip, entry.port);
}
}
fn service_retries(&mut self, now: Instant) {
let core = self.core_mut();
core.ledger.drain_due(now, &mut core.due);
let due = std::mem::take(&mut self.core_mut().due);
let silence = self.silence_means();
for event in &due {
match *event {
Due::Retry {
key: (ip, port),
attempt,
} => {
if attempt == 2 {
self.core_mut().judge_timeout(ip, silence);
}
let core = self.core_mut();
core.ledger.defer(&(ip, port));
let ready = core.ctx.host_ready_at(ip, now).unwrap_or(now);
core.hold(ip, port, None, ready);
}
Due::Exhausted {
key: (ip, port),
payload: position,
attempts,
witnessed,
} => {
if attempts == 1 {
self.core_mut().judge_timeout(ip, silence);
}
match self.core_mut().pending_neighbor(ip) {
Some(NeighborState::Resolving | NeighborState::Failed) => {
self.core_mut()
.hold(ip, port, Some(position), now + NEIGHBOR_RECHECK);
continue;
}
Some(NeighborState::Resolved) | None => {}
}
if self.core().is_unreachable(&ip) {
self.record_unasked_endpoint(ip, port);
continue;
}
if witnessed == 0 && self.core().audit.witnesses_its_sends() {
self.core_mut().unasked_unsent += 1;
self.record_unasked_endpoint(ip, port);
continue;
}
self.record_port(ip, port, silence, None);
self.settle(Outcome::Exhausted { position });
}
}
}
let core = self.core_mut();
core.due = due;
core.due.clear();
}
fn resolve_remaining(&mut self) {
self.core_mut().window.release_all();
for (ip, port) in self.core_mut().ledger.drain_unresolved() {
if self.core().is_unreachable(&ip) {
self.record_unasked_endpoint(ip, port);
continue;
}
self.record_port(ip, port, PortState::Unasked, None);
self.settle(Outcome::Interrupted);
}
}
fn resolve_unasked(&mut self, targets: &mut mpsc::Receiver<PlannedTarget>) -> u128 {
let mut unasked = 0;
while let Ok(target) = targets.try_recv() {
unasked += 1;
self.record_unasked(target);
}
unasked
}
fn record_unasked(&mut self, target: PlannedTarget) {
if target.protocol() != self.protocol() {
return;
}
self.record_unasked_endpoint(target.ip(), target.port());
}
fn record_unasked_endpoint(&mut self, ip: IpAddr, port: u16) {
self.record_port(ip, port, PortState::Unasked, None);
let outcome = if self.core().is_unreachable(&ip) {
Outcome::Unroutable
} else {
Outcome::Unasked
};
self.settle(outcome);
}
}
#[cfg(test)]
pub(crate) fn retry_due<S: RawPortScan>(scanner: &mut S, now: Instant) {
scanner.service_retries(now);
while let Some(retry) = scanner.core_mut().take_ready_retry(now) {
scanner.send_held(retry, now);
}
}
#[cfg(test)]
pub(crate) fn run_out<S: RawPortScan>(scanner: &mut S) {
let mut now = Instant::now();
while !scanner.core().ledger.is_empty() {
now += Duration::from_secs(60);
retry_due(scanner, now);
}
}
fn send_timed<S: RawPortScan + ?Sized>(
scanner: &mut S,
ip: IpAddr,
port: u16,
position: Option<u64>,
now: Instant,
) {
let started = Instant::now();
scanner.send(ip, port, position, now);
let spent = started.elapsed();
scanner.core_mut().deadline.allow_for_sending(spent);
}
fn read_waiting_replies<S: RawPortScan>(scanner: &mut S) {
let waiting = scanner.core().transport.rx.len();
for _ in 0..waiting {
let Ok(reply) = scanner.core_mut().transport.rx.try_recv() else {
return;
};
scanner.core_mut().audit.record_segment();
let received_at = reply.received_at;
scanner.handle_reply(&reply, received_at);
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) struct AuditLabels {
pub tag: &'static str,
pub silence: &'static str,
}
pub(crate) async fn drive<S: RawPortScan>(
scanner: &mut S,
mut targets: mpsc::Receiver<PlannedTarget>,
) -> Result<(), StrategyError> {
crate::fingerprint::load_corpus().await;
let protocol = scanner.protocol();
if let Some(kind) = scanner.core().transport.mismatched_for(protocol) {
while let Some(target) = targets.recv().await {
scanner.record_unasked(target);
}
return Err(StrategyError::MismatchedTransport { kind, protocol });
}
let mut send_tick = tokio::time::interval(scanner.core().send_tick);
send_tick.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Delay);
let mut sending_finished = false;
let mut probes = 0u128;
let reason = loop {
let now = Instant::now();
read_waiting_replies(scanner);
if !scanner.core().questions_left(sending_finished) {
scanner.core_mut().window.stop_admitting();
}
scanner.service_retries(now);
if let Some(reason) = scanner.core().stop_reason(sending_finished) {
break reason;
}
let sending = scanner.core().sending(sending_finished);
let tick = scanner.core().tick_delay(now);
tokio::select! {
_ = send_tick.tick(), if sending => {
let now = Instant::now();
let budget = scanner.core().audit.sends_attempted + scanner.core().batch as u64;
while scanner.core().audit.sends_attempted < budget {
if let Some(retry) = scanner.core_mut().take_ready_retry(now) {
scanner.send_held(retry, now);
continue;
}
if !scanner.core().admitting(sending_finished) {
break;
}
if let Some(held) = scanner.core_mut().take_ready(now) {
scanner.send_held(held, now);
continue;
}
if scanner.core().held_is_full() {
break;
}
match targets.try_recv() {
Ok(target) => {
probes += 1;
if scanner.core().ctx.host_expired(target.ip()) {
scanner.record_unasked(target);
} else if let Some(ready) =
scanner.core().ctx.host_ready_at(target.ip(), now)
{
scanner.hold_probe(target, ready);
} else {
scanner.send_probe(target);
}
}
Err(mpsc::error::TryRecvError::Empty) => break,
Err(mpsc::error::TryRecvError::Disconnected) => {
sending_finished = true;
break;
}
}
}
}
res = scanner.core_mut().transport.rx.recv() => {
match res {
Some(reply) => {
scanner.core_mut().audit.record_segment();
let received_at = reply.received_at;
scanner.handle_reply(&reply, received_at);
}
None => break StopReason::StreamClosed,
}
}
_ = tokio::time::sleep(tick) => {}
}
};
scanner.core_mut().conclude_pending_neighbors();
scanner.resolve_remaining();
scanner.resolve_held();
targets.close();
probes += scanner.resolve_unasked(&mut targets);
let kind = scanner.kind();
let labels = scanner.audit_labels();
let silence = scanner.silence_means();
scanner
.core_mut()
.finish(kind, labels.tag, labels.silence, silence, probes, reason);
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
use std::net::Ipv4Addr;
use crate::scanner::pacing::congestion::WindowLimits;
use crate::scanner::session::ScanSession;
use crate::transport::probe::{Emission, ProbeSender, ProbeTransport, SendError};
#[derive(Default)]
struct NullSender;
impl ProbeSender for NullSender {
fn send(
&self,
_segment: &[u8],
_src: IpAddr,
_dst: IpAddr,
_zone: Option<u32>,
_emission: Emission,
) -> Result<(), SendError> {
Ok(())
}
}
const TARGET: IpAddr = IpAddr::V4(Ipv4Addr::new(192, 0, 2, 10));
fn core() -> (RawProbeScan<()>, ScanSession) {
let (session, ctx) = ScanSession::new();
let (_tx, rx) = tokio::sync::mpsc::channel(1024);
let core = RawProbeScan {
resolver: SourceResolver::from_links(&[]),
ctx,
transport: ProbeTransport::from_parts(Box::new(NullSender), rx),
deadline: AdaptiveDeadline::new(super::super::raw::DEADLINE_CONFIG, 8),
ledger: ProbeLedger::new(super::super::raw::RETRY_POLICY, 8),
due: Vec::new(),
src_port: 54_321,
emission: Emission::routed(),
shaping: SegmentShaping::default(),
decoys: Vec::new(),
send_failure: None,
unasked_refused: 0,
retries_refused: 0,
unasked_unsent: 0,
unreachable: std::collections::BTreeSet::new(),
held_down: HoldDowns::default(),
held_allowed: HeldAllowance::default(),
neighbors: NeighborGates::default(),
audit: ProbeAudit::new(),
window: CongestionWindow::new(WindowLimits::fixed(4)),
send_tick: Duration::from_millis(1),
batch: 1,
max_unresolved: 64,
held: std::collections::BinaryHeap::new(),
retries: std::collections::BinaryHeap::new(),
};
(core, session)
}
fn unsent_failure(core: &mut RawProbeScan<()>) -> String {
core.unasked_unsent = 2;
core.finish(
ScannerKind::SynPort,
"syn-port",
"filtered",
PortState::Filtered,
2,
StopReason::AllResponded,
);
let failures = core.ctx.failures_snapshot();
assert_eq!(failures.len(), 1, "{failures:?}");
failures[0].reason().to_owned()
}
#[test]
fn a_port_scan_outlasts_the_slowest_pace_each_of_its_limits_allows() {
const PORTS: usize = 65_535;
let retry = PORT_RETRY_POLICY;
let attempts = f64::from(retry.max_attempts);
let hundred = NonZeroU32::new(100).expect("non-zero");
let gap = Duration::from_millis(25);
for (case, rate, host_gap) in [
("unlimited", TCP_PORT_RATE_CEILING, None),
("at a hundred a second", hundred, None),
("with a gap at one host", TCP_PORT_RATE_CEILING, Some(gap)),
] {
let given = deadline_for(
super::super::raw::DEADLINE_CONFIG,
&retry,
TCP_PORT_WINDOW,
rate,
host_gap,
PORTS,
)
.max_budget
.for_target_count(PORTS)
.as_secs_f64();
let window = PORTS as f64 * 2.0 * 1.3 / 16.0;
let wire = PORTS as f64 * attempts / f64::from(rate.get());
let spacing = PORTS as f64 * attempts * host_gap.unwrap_or_default().as_secs_f64();
for (limit, needed) in [("window", window), ("rate", wire), ("gap", spacing)] {
assert!(
given >= needed,
"{case}: the {limit} needs {needed:.0} s and the scan is given {given:.0} s"
);
}
}
}
#[test]
fn ports_unseen_after_a_capture_died_are_not_blamed_on_sending() {
let (mut core, _session) = core();
let (_tx, rx) = tokio::sync::mpsc::channel(1024);
core.transport = ProbeTransport::from_parts_deaf(Box::new(NullSender), rx);
let reason = unsent_failure(&mut core);
assert!(
reason.contains("a capture stopped early"),
"the dead capture goes unnamed: {reason}"
);
assert!(!reason.contains("never put them on the wire"), "{reason}");
}
#[test]
fn ports_unseen_with_every_capture_listening_are_blamed_on_sending() {
let (mut core, _session) = core();
let reason = unsent_failure(&mut core);
assert!(reason.contains("never put them on the wire"), "{reason}");
assert!(
!reason.contains(" "),
"the sentence carries a run of spaces from its source: {reason:?}"
);
}
fn spaced_core(gap: Duration) -> (RawProbeScan<()>, ScanSession) {
let (session, ctx) = ScanSession::builder()
.host_probe_interval(Some(gap))
.build();
let (_tx, rx) = tokio::sync::mpsc::channel(1024);
let core = RawProbeScan {
resolver: SourceResolver::from_links(&[]),
ctx,
transport: ProbeTransport::from_parts(Box::new(NullSender), rx),
deadline: AdaptiveDeadline::new(super::super::raw::DEADLINE_CONFIG, 8),
ledger: ProbeLedger::new(super::super::raw::RETRY_POLICY, 8),
due: Vec::new(),
src_port: 54_321,
emission: Emission::routed(),
shaping: SegmentShaping::default(),
decoys: Vec::new(),
send_failure: None,
unasked_refused: 0,
retries_refused: 0,
unasked_unsent: 0,
unreachable: std::collections::BTreeSet::new(),
held_down: HoldDowns::default(),
held_allowed: HeldAllowance::default(),
neighbors: NeighborGates::default(),
audit: ProbeAudit::new(),
window: CongestionWindow::new(WindowLimits::fixed(4)),
send_tick: Duration::from_millis(1),
batch: 1,
max_unresolved: 64,
held: std::collections::BinaryHeap::new(),
retries: std::collections::BinaryHeap::new(),
};
(core, session)
}
#[test]
fn the_earliest_slot_comes_off_the_queue_first() {
let (mut core, _session) = spaced_core(Duration::from_secs(3600));
let now = Instant::now();
core.hold(TARGET, 80, Some(0), now + Duration::from_secs(30));
core.hold(TARGET, 22, Some(1), now + Duration::from_secs(10));
core.hold(TARGET, 443, Some(2), now + Duration::from_secs(20));
assert!(
core.take_ready(now).is_none(),
"nothing is ready yet, and nothing is handed back early"
);
let first = core
.take_ready(now + Duration::from_secs(15))
.expect("the ten-second slot has come round");
assert_eq!(first.port, 22);
}
#[test]
fn a_slot_that_moved_after_the_probe_was_held_is_re_checked() {
let gap = Duration::from_secs(3600);
let (mut core, _session) = spaced_core(gap);
let now = Instant::now();
core.hold(TARGET, 80, Some(0), now);
core.ctx.host_probed(TARGET, now);
assert!(
core.take_ready(now).is_none(),
"the stored instant said now; the host says otherwise and the host wins"
);
assert_eq!(
core.held.len(),
1,
"and the probe is still held, not dropped"
);
assert!(
core.take_ready(now + gap).is_some(),
"once the gap has really run, it is handed back"
);
}
#[test]
fn a_held_probe_keeps_the_scan_open_after_the_stream_ends() {
let (mut core, _session) = spaced_core(Duration::from_secs(3600));
let now = Instant::now();
core.hold(TARGET, 80, Some(0), now + Duration::from_secs(1));
assert_eq!(
core.stop_reason(true),
None,
"the stream is done and the ledger empty, but a probe is still owed"
);
assert!(
core.admitting(true),
"and the send path stays open, since it is the only thing that empties the queue"
);
let _ = core.take_ready(now + Duration::from_secs(1));
core.held.clear();
assert_eq!(
core.stop_reason(true),
Some(StopReason::AttemptsSpent),
"with the queue empty too, waiting cannot change what this found"
);
}
#[test]
fn a_full_queue_stops_the_stream_and_not_the_sending() {
let (mut core, _session) = spaced_core(Duration::from_secs(3600));
let now = Instant::now();
for port in 0..core.max_unresolved {
core.hold(TARGET, port as u16, Some(port as u64), now);
}
assert!(core.held_is_full());
assert!(
core.admitting(false),
"a full queue must not close the one path that drains it"
);
}
#[test]
fn an_empty_ledger_does_not_end_a_scan_that_still_has_targets_coming() {
let (core, _session) = core();
assert_eq!(
core.stop_reason(false),
None,
"the target stream is still open, so nothing has been concluded"
);
assert_eq!(
core.stop_reason(true),
Some(StopReason::AttemptsSpent),
"with the stream done and nothing outstanding, waiting cannot help"
);
}
#[test]
fn an_outstanding_probe_holds_the_scan_open_past_a_dry_target_stream() {
let (mut core, _session) = core();
core.ledger.arm(TARGET, (TARGET, 80), (), 0, Instant::now());
assert_eq!(
core.stop_reason(true),
None,
"a probe is still within its retry schedule"
);
}
#[test]
fn an_abort_outranks_every_other_reason() {
let (mut core, _session) = core();
core.ledger.arm(TARGET, (TARGET, 80), (), 0, Instant::now());
core.ctx.handle.abort();
assert_eq!(core.stop_reason(false), Some(StopReason::Aborted));
}
#[test]
fn the_ledger_stops_admitting_at_the_window() {
let (mut core, _session) = core();
assert!(core.admitting(false), "an empty ledger admits");
for _ in 0..core.window.capacity() {
core.window.record_send();
}
assert!(
!core.admitting(false),
"admitting past the window grows correlation state for nothing"
);
assert!(
!core.admitting(true),
"a finished stream never admits, window or not"
);
}
#[test]
fn the_attempt_that_answered_is_what_moves_the_window() {
let (mut core, _session) = core();
core.window = CongestionWindow::new(WindowLimits::new(64, 4, 512, 512));
core.record_answer(&Resolution {
payload: 0u64,
rtt: None,
attempts: 1,
answered_attempt: Some(1),
});
assert!(core.window.capacity() > 64, "a clean answer buys headroom");
let grown = core.window.capacity();
core.record_answer(&Resolution {
payload: 0u64,
rtt: None,
attempts: 2,
answered_attempt: Some(2),
});
assert!(
core.window.capacity() < grown,
"an answer that needed a retry is loss, and loss cuts the window"
);
}
#[test]
fn a_send_the_kernel_refused_cuts_the_window() {
let full = SendError::Refused("No buffer space available".to_string());
let unresolved = SendError::Unresolved("192.0.2.1 did not answer".to_string());
for (refusal, answered_before) in [(&full, false), (&unresolved, true)] {
let (mut core, _session) = core();
core.window = CongestionWindow::new(WindowLimits::new(64, 4, 512, 512));
if answered_before {
answer_once(&mut core, TARGET);
}
core.record_send((TARGET, 80), Err(refusal), true);
assert!(
core.window.capacity() < 64,
"the local stack refusing is the least ambiguous evidence there is: {refusal}"
);
assert_eq!(
core.window.in_flight(),
0,
"and a probe that never left takes no slot"
);
assert!(core.send_failure.is_some(), "and it is this host's fault");
}
}
#[test]
fn a_refused_send_is_told_once_in_one_short_line() {
let (mut core, _session) = core();
let said = crate::logging::logged(|| {
core.record_send((TARGET, 80), Err(&SendError::OutOfDescriptors), true);
});
assert!(
said.iter()
.all(|line| line.level != tracing::Level::ERROR && line.verbosity >= 2),
"{said:?}"
);
assert_eq!(
core.refusals_failure().as_deref(),
Some("1 port unasked, probes not sent (file limit reached)")
);
}
#[cfg(unix)]
#[test]
fn a_source_lookup_short_of_descriptors_is_a_shortage_not_an_unreachable_host() {
use crate::system::interface::RouteAnswer;
let (mut core, _session) = core();
core.resolver = SourceResolver::from_links(&[]).asking_with(|_: IpAddr| {
RouteAnswer::Unasked(std::io::Error::from_raw_os_error(libc::EMFILE))
});
assert_eq!(core.source_for((TARGET, 80), true), None);
assert!(
!core.is_unreachable(&TARGET),
"the host was filed unreachable"
);
assert_eq!(
core.refusals_failure().as_deref(),
Some("1 port unasked, probes not sent (file limit reached)")
);
}
#[cfg(unix)]
#[test]
fn a_source_lookup_the_routing_table_did_not_answer_leaves_its_host_to_be_asked_again() {
use crate::system::interface::{Link, LinkAddress, RouteAnswer};
let (mut core, _session) = core();
let segment = LinkAddress::new(IpAddr::V4(Ipv4Addr::new(192, 0, 2, 1)), 24);
core.resolver =
SourceResolver::from_links(&[Link::new("test0", 1).with_addresses(vec![segment])])
.asking_with(|_: IpAddr| RouteAnswer::connect_refused(libc::EHOSTDOWN));
assert_eq!(core.source_for((TARGET, 80), true), None);
assert!(
!core.is_unreachable(&TARGET),
"the host was filed unreachable"
);
assert!(!core.resolver.refused_by_route(TARGET));
let failure = core.refusals_failure().expect("the unsent probe is said");
assert!(failure.contains("route lookup failed"), "{failure}");
}
#[cfg(unix)]
#[test]
fn a_host_the_kernel_holds_down_is_asked_again_after_the_hold_down() {
let (mut core, _session) = core();
core.window = CongestionWindow::new(WindowLimits::new(64, 4, 512, 512));
let refused = SendError::from_io(std::io::Error::from_raw_os_error(libc::EHOSTDOWN));
let before = Instant::now();
core.record_send((TARGET, 80), Err(&refused), true);
assert!(
!core.is_unreachable(&TARGET),
"the host was filed unreachable on one hold-down"
);
match core.admit(TARGET, Instant::now()) {
Admission::Hold(ready) => assert!(
ready >= before + core.held_down.hold_down_for,
"held for less than the hold-down"
),
other => panic!("the host's next probe was not held: {other:?}"),
}
assert_eq!(core.window.capacity(), 64, "read as congestion");
assert!(core.send_failure.is_none(), "read as this host's fault");
assert_eq!(core.unasked_refused, 0);
let after = before + core.held_down.hold_down_for + Duration::from_secs(1);
assert_eq!(
core.admit(TARGET, after),
Admission::Send,
"and asked again after it"
);
}
#[cfg(unix)]
#[test]
fn a_host_held_down_again_after_waiting_one_out_is_unreachable() {
let (mut core, _session) = core();
let refused = SendError::from_io(std::io::Error::from_raw_os_error(libc::EHOSTDOWN));
core.record_send((TARGET, 80), Err(&refused), true);
core.held_down.lift(TARGET);
core.record_send((TARGET, 80), Err(&refused), true);
assert!(core.is_unreachable(&TARGET));
assert_eq!(core.admit(TARGET, Instant::now()), Admission::Unreachable);
}
#[cfg(unix)]
#[test]
fn a_hold_down_is_given_to_the_deadline() {
use crate::scanner::pacing::deadline::AdaptiveDeadlineConfig;
use crate::scanner::pacing::timer::ScanBudget;
let (mut core, _session) = core();
let spent = ScanBudget::new(Duration::ZERO, Duration::ZERO, Duration::ZERO);
core.deadline = AdaptiveDeadline::new(
AdaptiveDeadlineConfig::new(spent, spent, Duration::ZERO, Duration::ZERO, 4.0, 8),
1,
);
core.held_down.hold_down_for = Duration::from_secs(3600);
let refused = SendError::from_io(std::io::Error::from_raw_os_error(libc::EHOSTDOWN));
core.record_send((TARGET, 80), Err(&refused), true);
assert!(!core.deadline.hard_deadline_passed());
}
fn core_reading(
state: std::sync::Arc<std::sync::Mutex<Option<NeighborState>>>,
) -> (
RawProbeScan<()>,
ScanSession,
std::sync::Arc<std::sync::atomic::AtomicUsize>,
) {
use crate::system::interface::{Link, LinkAddress};
use crate::transport::kernel_neighbors::{KernelNeighbors, NeighborTable};
let reads = std::sync::Arc::new(std::sync::atomic::AtomicUsize::new(0));
let counted = std::sync::Arc::clone(&reads);
let table = KernelNeighbors::with_reader(Box::new(move || {
counted.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
let state = *state.lock().expect("the test's state");
Ok(state
.map(|state| NeighborTable::from([(TARGET, state)]))
.unwrap_or_default())
}));
let (mut core, session) = core();
let (_tx, rx) = tokio::sync::mpsc::channel(1024);
core.transport =
ProbeTransport::from_parts(Box::new(NullSender), rx).with_kernel_neighbors(table);
core.resolver = SourceResolver::from_links(&[Link::new("test0", 1).with_addresses(vec![
LinkAddress::new(IpAddr::V4(Ipv4Addr::new(192, 0, 2, 1)), 24),
])]);
(core, session, reads)
}
#[test]
fn a_probe_behind_an_unresolved_neighbour_waits_for_the_resolution() {
let state = std::sync::Arc::new(std::sync::Mutex::new(None));
let (mut core, _session, reads) = core_reading(std::sync::Arc::clone(&state));
assert_eq!(
core.admit(TARGET, Instant::now()),
Admission::Send,
"the first starts it"
);
*state.lock().unwrap() = Some(NeighborState::Resolving);
let now = Instant::now();
assert_eq!(
core.admit(TARGET, now),
Admission::Hold(now + NEIGHBOR_RECHECK),
"the next waits on the kernel rather than queueing behind it"
);
*state.lock().unwrap() = Some(NeighborState::Resolved);
std::thread::sleep(NEIGHBOR_RECHECK);
assert_eq!(core.admit(TARGET, Instant::now()), Admission::Send);
let read = reads.load(std::sync::atomic::Ordering::SeqCst);
assert_eq!(core.admit(TARGET, Instant::now()), Admission::Send);
assert_eq!(
reads.load(std::sync::atomic::Ordering::SeqCst),
read,
"a neighbour seen answering is not read about again"
);
assert!(!core.is_unreachable(&TARGET));
}
#[test]
fn a_neighbour_the_kernel_gave_up_on_twice_is_filed_unreachable_without_a_send() {
let state = std::sync::Arc::new(std::sync::Mutex::new(None));
let (mut core, _session, _reads) = core_reading(std::sync::Arc::clone(&state));
assert_eq!(core.admit(TARGET, Instant::now()), Admission::Send);
*state.lock().unwrap() = Some(NeighborState::Failed);
assert_eq!(
core.admit(TARGET, Instant::now()),
Admission::Send,
"one unanswered resolution was taken as the verdict"
);
assert!(!core.is_unreachable(&TARGET));
assert_eq!(core.admit(TARGET, Instant::now()), Admission::Unreachable);
assert!(core.is_unreachable(&TARGET), "the address is filed");
assert!(
core.send_failure.is_none(),
"and nothing on this host failed"
);
}
#[test]
fn a_second_resolution_is_given_to_the_deadline() {
use crate::scanner::pacing::deadline::AdaptiveDeadlineConfig;
use crate::scanner::pacing::timer::ScanBudget;
let state = std::sync::Arc::new(std::sync::Mutex::new(None));
let (mut core, _session, _reads) = core_reading(std::sync::Arc::clone(&state));
let spent = ScanBudget::new(Duration::ZERO, Duration::ZERO, Duration::ZERO);
core.deadline = AdaptiveDeadline::new(
AdaptiveDeadlineConfig::new(spent, spent, Duration::ZERO, Duration::ZERO, 4.0, 8),
1,
);
assert_eq!(core.admit(TARGET, Instant::now()), Admission::Send);
*state.lock().unwrap() = Some(NeighborState::Failed);
assert_eq!(core.admit(TARGET, Instant::now()), Admission::Send);
assert!(!core.deadline.hard_deadline_passed());
}
#[test]
fn a_probe_that_outlived_an_unanswered_resolution_is_pending_on_it() {
let state = std::sync::Arc::new(std::sync::Mutex::new(None));
let (mut core, _session, _reads) = core_reading(std::sync::Arc::clone(&state));
assert_eq!(core.admit(TARGET, Instant::now()), Admission::Send);
*state.lock().unwrap() = Some(NeighborState::Resolving);
assert_eq!(
core.pending_neighbor(TARGET),
Some(NeighborState::Resolving)
);
assert!(
!core.is_unreachable(&TARGET),
"the kernel has not given up, so neither has the scan"
);
}
#[test]
fn a_host_still_waiting_on_its_neighbour_at_the_end_is_filed_unreachable() {
let state = std::sync::Arc::new(std::sync::Mutex::new(None));
let (mut core, _session, _reads) = core_reading(std::sync::Arc::clone(&state));
assert_eq!(core.admit(TARGET, Instant::now()), Admission::Send);
assert!(core.ledger.is_empty(), "no probe of it is on the ledger");
*state.lock().unwrap() = Some(NeighborState::Resolving);
core.conclude_pending_neighbors();
assert!(core.is_unreachable(&TARGET));
}
#[test]
fn a_host_with_no_neighbour_in_the_way_is_never_read_about() {
let state = std::sync::Arc::new(std::sync::Mutex::new(Some(NeighborState::Failed)));
let (mut core, _session, reads) = core_reading(state);
core.resolver = SourceResolver::from_links(&[]);
for _ in 0..3 {
assert_eq!(core.admit(TARGET, Instant::now()), Admission::Send);
}
assert_eq!(reads.load(std::sync::atomic::Ordering::SeqCst), 0);
}
#[test]
fn hosts_behind_a_gateway_that_never_answers_wait_on_it_and_are_unreached() {
const GATEWAY: IpAddr = IpAddr::V4(Ipv4Addr::new(192, 0, 2, 254));
const ROUTED: [IpAddr; 2] = [
IpAddr::V4(Ipv4Addr::new(198, 51, 100, 7)),
IpAddr::V4(Ipv4Addr::new(198, 51, 100, 8)),
];
use crate::transport::kernel_neighbors::{KernelNeighbors, NeighborTable};
let state = std::sync::Arc::new(std::sync::Mutex::new(None));
let read = std::sync::Arc::clone(&state);
let table = KernelNeighbors::with_reader(Box::new(move || {
let state = *read.lock().expect("the test's state");
Ok(state
.map(|state| NeighborTable::from([(GATEWAY, state)]))
.unwrap_or_default())
}))
.routing(Box::new(|address| {
Ok(ROUTED.contains(&address).then_some(GATEWAY))
}));
let (mut core, _session) = core();
let (_tx, rx) = tokio::sync::mpsc::channel(1024);
core.transport =
ProbeTransport::from_parts(Box::new(NullSender), rx).with_kernel_neighbors(table);
assert_eq!(
core.admit(ROUTED[0], Instant::now()),
Admission::Send,
"the first probe through the gateway starts its resolution"
);
*state.lock().unwrap() = Some(NeighborState::Resolving);
let now = Instant::now();
assert_eq!(
core.admit(ROUTED[1], now),
Admission::Hold(now + NEIGHBOR_RECHECK),
"another host behind it waits rather than queueing behind it"
);
*state.lock().unwrap() = Some(NeighborState::Failed);
std::thread::sleep(NEIGHBOR_RECHECK);
assert_eq!(
core.admit(ROUTED[1], Instant::now()),
Admission::Send,
"a probe through the gateway has the kernel ask for it again"
);
assert_eq!(
core.admit(ROUTED[1], Instant::now()),
Admission::Unreachable
);
assert_eq!(
core.pending_neighbor(ROUTED[0]),
Some(NeighborState::Failed),
"the host whose probe started it is read through the gateway too"
);
core.conclude_pending_neighbors();
for host in ROUTED {
assert!(core.is_unreachable(&host), "{host} is unreached");
}
}
#[test]
fn an_address_that_cannot_be_reached_is_not_congestion() {
let (mut core, _session) = core();
core.window = CongestionWindow::new(WindowLimits::new(64, 4, 512, 512));
let dead = SendError::Unresolved("192.0.2.1 did not answer".to_string());
core.record_send((TARGET, 80), Err(&dead), true);
assert_eq!(core.window.capacity(), 64, "the window is untouched");
assert!(
core.send_failure.is_none(),
"and nothing on this host failed"
);
assert!(core.is_unreachable(&TARGET), "the address is what is filed");
}
fn answer_once(core: &mut RawProbeScan<()>, host: IpAddr) {
core.ledger.arm(host, (host, 1), (), 0, Instant::now());
core.ledger
.resolve(&(host, 1), Some(()), Instant::now())
.expect("the armed probe resolves");
}
#[test]
fn silence_from_a_host_that_never_answered_opens_the_window() {
let (mut core, _session) = core();
core.window = CongestionWindow::new(WindowLimits::new(64, 4, 512, 512));
core.window.record_send();
core.judge_timeout(TARGET, PortState::Filtered);
assert!(
core.window.capacity() >= 64,
"nothing this host did says the path is busy"
);
assert_eq!(core.window.in_flight(), 0, "and the slot went back");
}
#[test]
fn silence_from_a_host_that_is_answering_cuts_the_window() {
let (mut core, _session) = core();
core.window = CongestionWindow::new(WindowLimits::new(64, 4, 512, 512));
let now = Instant::now();
core.ledger.arm(TARGET, (TARGET, 22), (), 0, now);
core.ledger.resolve(&(TARGET, 22), None, now);
core.window.record_send();
core.judge_timeout(TARGET, PortState::Filtered);
assert!(
core.window.capacity() < 64,
"a host that talks and then goes quiet is being outrun"
);
assert_eq!(core.window.in_flight(), 0, "and the slot still went back");
}
#[test]
fn silence_from_a_firewall_that_lets_a_port_through_opens_the_window() {
let (mut core, _session) = core();
core.window = CongestionWindow::new(WindowLimits::new(64, 4, 512, 512));
answer_once(&mut core, TARGET);
let now = Instant::now();
let mut due = Vec::new();
for port in 2..=10 {
core.ledger.arm(TARGET, (TARGET, port), (), 0, now);
}
core.ledger
.drain_due(now + Duration::from_secs(10), &mut due);
for _ in &due {
core.window.record_send();
core.judge_timeout(TARGET, PortState::Filtered);
}
assert_eq!(due.len(), 9, "every probe's first timeout was read");
assert!(
core.window.capacity() > 64,
"one answer in ten probes is a firewall, and asking it more slowly \
would not change what it lets through"
);
}
#[test]
fn a_host_down_filed_against_a_host_already_known_reports_it_was_recorded() {
let (mut core, session) = core();
let router: IpAddr = "198.51.100.1".parse().expect("a literal address");
core.ctx.update_host(TARGET, |_| {});
core.ledger.arm(TARGET, (TARGET, 80), (), 0, Instant::now());
assert!(
core.record_host_down(&(TARGET, 80), Some(()), router),
"an unreachable naming a live probe is on the host's record"
);
assert_eq!(
session.hosts().get(TARGET).map(|host| host.status()),
Some(HostStatus::Down)
);
}
#[test]
fn a_host_unreachable_from_this_host_itself_files_the_address_unreachable() {
let state = std::sync::Arc::new(std::sync::Mutex::new(None));
let (mut core, session, _reads) = core_reading(state);
let own: IpAddr = "192.0.2.1".parse().expect("a literal address");
core.ledger.arm(TARGET, (TARGET, 80), (), 0, Instant::now());
assert!(core.record_host_down(&(TARGET, 80), Some(()), own));
assert_ne!(
session.hosts().get(TARGET).map(|host| host.status()),
Some(HostStatus::Down),
"nothing on the network answered for the address"
);
assert!(
core.is_unreachable(&TARGET),
"the address is filed unreached"
);
}
#[test]
fn a_host_down_about_an_excluded_address_reports_nothing_recorded() {
let (mut core, _) = core();
let mut excluded = crate::model::ip::set::IpSet::new();
excluded.insert_range("192.0.2.0/24".parse().expect("a valid range"));
let (session, ctx) = ScanSession::builder()
.excluding(crate::model::exclusion::Exclusions::new(excluded))
.build();
core.ctx = ctx;
let router: IpAddr = "198.51.100.1".parse().expect("a literal address");
core.ledger.arm(TARGET, (TARGET, 80), (), 0, Instant::now());
assert!(!core.record_host_down(&(TARGET, 80), Some(()), router));
assert!(session.hosts().get(TARGET).is_none());
}
}