use crate::detect::corpus::DetectionError;
use crate::evasion::EvasionError;
use crate::export::ExportError;
use crate::import::ImportError;
#[cfg(feature = "journal-format")]
use crate::journal::format::JournalError;
#[cfg(feature = "journal-format")]
use crate::journal::lock::LockRefused;
#[cfg(feature = "journal-format")]
use crate::journal::manifest::PlanChanged;
#[cfg(feature = "journal-format")]
use crate::journal::store::OpenError;
use crate::model::parse::ip::IpParseError;
use crate::model::parse::target::TargetParseError;
use crate::model::port::set::PortSetParseError;
use crate::scanner::ScanError;
#[cfg(feature = "import-request")]
use crate::import::request::RequestError;
#[cfg(feature = "import-settings")]
use crate::import::settings::SettingsError;
pub trait Coded {
fn code(&self) -> &'static str;
}
impl Coded for ScanError {
fn code(&self) -> &'static str {
match self {
ScanError::WrongPhase => "scan.wrong_phase",
#[cfg(feature = "journal-format")]
ScanError::PlanChanged(changed) => changed.code(),
ScanError::Evasion(evasion) => evasion.code(),
ScanError::TaskFailed { panicked: true, .. } => "scan.task_panicked",
ScanError::TaskFailed { .. } => "scan.task_failed",
}
}
}
#[cfg(feature = "journal-format")]
impl Coded for PlanChanged {
fn code(&self) -> &'static str {
"journal.plan_changed"
}
}
impl Coded for EvasionError {
fn code(&self) -> &'static str {
match self {
EvasionError::FragmentTooSmall { .. } => "evasion.fragment_too_small",
EvasionError::HopLimitZero => "evasion.hop_limit_zero",
EvasionError::PaddingTooLarge { .. } => "evasion.padding_too_large",
EvasionError::SourcePortZero => "evasion.source_port_zero",
}
}
}
impl Coded for ExportError {
fn code(&self) -> &'static str {
match self {
ExportError::Io(_) => "export.io",
ExportError::Render { .. } => "export.render",
}
}
}
#[cfg(feature = "journal-format")]
impl Coded for JournalError {
fn code(&self) -> &'static str {
match self {
JournalError::Io(_) => "journal.io",
JournalError::Malformed { .. } => "journal.malformed",
JournalError::NotAJournal => "journal.not_a_journal",
JournalError::VersionTooNew { .. } => "journal.version_too_new",
}
}
}
#[cfg(feature = "journal-format")]
impl Coded for OpenError {
fn code(&self) -> &'static str {
match self {
OpenError::Journal(journal) => journal.code(),
OpenError::Locked(refused) => refused.code(),
OpenError::PlanChanged(changed) => changed.code(),
OpenError::VersionTooOld { .. } => "journal.version_too_old",
OpenError::WrongPhase { .. } => "journal.wrong_phase",
}
}
}
#[cfg(feature = "journal-format")]
impl Coded for LockRefused {
fn code(&self) -> &'static str {
match self {
LockRefused::Held(_) => "journal.locked",
LockRefused::Io(_) => "journal.lock_io",
}
}
}
impl Coded for DetectionError {
fn code(&self) -> &'static str {
match self {
DetectionError::Body(_) => "detection.body",
DetectionError::Compute(_) => "detection.compute",
DetectionError::Flow(_) => "detection.flow",
DetectionError::Host(_) => "detection.host",
DetectionError::InSource { cause, .. } => cause.code(),
DetectionError::Parse(_) => "detection.parse",
DetectionError::Pattern(_) => "detection.pattern",
DetectionError::Tier(_) => "detection.tier",
DetectionError::UnusedBody { .. } => "detection.unused_body",
}
}
}
impl Coded for TargetParseError {
fn code(&self) -> &'static str {
match self {
TargetParseError::Address { source, .. } => source.code(),
TargetParseError::Ports { source, .. } => source.code(),
TargetParseError::Blank(..) => "target.blank",
TargetParseError::Empty => "target.empty",
TargetParseError::EmptyPorts(_) => "target.empty_ports",
TargetParseError::MistypedAddress(_) => "target.mistyped_address",
TargetParseError::NoHostLookup(_) => "target.no_host_lookup",
TargetParseError::ResolvedToNothing(_) => "target.resolved_to_nothing",
TargetParseError::TrailingText(_) => "target.trailing_text",
TargetParseError::UnbalancedBracket(_) => "target.unbalanced_bracket",
TargetParseError::UnbracketedAddress(_) => "target.unbracketed_address",
TargetParseError::UnknownHost(_) => "target.unknown_host",
}
}
}
impl Coded for IpParseError {
fn code(&self) -> &'static str {
match self {
IpParseError::EmptySet => "address.empty_set",
IpParseError::InvalidPrefix(_) => "address.invalid_prefix",
IpParseError::InvalidRange(..) => "address.invalid_range",
IpParseError::KeywordUnresolved { .. } => "address.keyword_unresolved",
IpParseError::Malformed(_) => "address.malformed",
IpParseError::UnknownInterface(_) => "address.unknown_interface",
IpParseError::ZoneOnUnscopedTarget(_) => "address.zone_on_unscoped_target",
}
}
}
impl Coded for PortSetParseError {
fn code(&self) -> &'static str {
match self {
PortSetParseError::InvalidPort { .. } => "ports.invalid_port",
PortSetParseError::InvalidRange { .. } => "ports.invalid_range",
PortSetParseError::MalformedSpec(_) => "ports.malformed_spec",
}
}
}
impl Coded for ImportError {
fn code(&self) -> &'static str {
match self {
ImportError::Io(_) => "import.io",
ImportError::LineTooLong { .. } => "import.line_too_long",
ImportError::InvalidUtf8 { .. } => "import.invalid_utf8",
ImportError::DocumentTooLarge { .. } => "import.document_too_large",
ImportError::TooManyHosts { .. } => "import.too_many_hosts",
ImportError::TooManyTokens { .. } => "import.too_many_tokens",
ImportError::TooManyAddresses { .. } => "import.too_many_addresses",
ImportError::Target { source, .. } => source.code(),
ImportError::Malformed { .. } => "import.malformed",
}
}
}
#[cfg(feature = "import-request")]
impl Coded for RequestError {
fn code(&self) -> &'static str {
match self {
RequestError::NoTargets => "request.no_targets",
RequestError::Ports { .. } => "request.bad_ports",
RequestError::Targets(source) => source.code(),
}
}
}
#[cfg(feature = "import-settings")]
impl Coded for SettingsError {
fn code(&self) -> &'static str {
match self {
SettingsError::Io { .. } => "settings.io",
SettingsError::Malformed(_) => "settings.malformed",
SettingsError::NoPath => "settings.no_path",
SettingsError::TooLarge { .. } => "settings.too_large",
SettingsError::UnknownProfile { .. } => "settings.unknown_profile",
}
}
}
#[cfg(test)]
mod tests {
use super::*;
fn sample() -> Vec<&'static str> {
vec![
ScanError::WrongPhase.code(),
EvasionError::HopLimitZero.code(),
EvasionError::FragmentTooSmall {
mtu: 8,
minimum: 28,
}
.code(),
ExportError::Render {
format: "html",
message: String::new(),
}
.code(),
IpParseError::EmptySet.code(),
IpParseError::InvalidPrefix(33).code(),
TargetParseError::Empty.code(),
TargetParseError::UnknownHost("nowhere".into()).code(),
PortSetParseError::InvalidRange { start: 9, end: 1 }.code(),
PortSetParseError::MalformedSpec("x".into()).code(),
DetectionError::Parse("bad toml".into()).code(),
]
}
#[test]
fn every_code_reads_area_then_what() {
for code in sample() {
let (area, what) = code
.split_once('.')
.unwrap_or_else(|| panic!("{code} names no area"));
assert!(!area.is_empty(), "{code} has an empty area");
assert!(!what.is_empty(), "{code} says nothing about what happened");
assert!(
code.chars()
.all(|c| c.is_ascii_lowercase() || c == '.' || c == '_'),
"{code} is not a lower-case dotted name"
);
}
}
#[test]
fn a_wrapping_error_reports_the_reason_rather_than_itself() {
assert_eq!(
ScanError::Evasion(EvasionError::HopLimitZero).code(),
"evasion.hop_limit_zero"
);
assert_eq!(
TargetParseError::Address {
expression: "10.0.0.".into(),
source: IpParseError::Malformed("10.0.0.".into()),
}
.code(),
"address.malformed"
);
assert_eq!(
TargetParseError::Ports {
expression: "198.51.100.1:x".into(),
source: PortSetParseError::MalformedSpec("x".into()),
}
.code(),
"ports.malformed_spec"
);
}
#[test]
fn a_panic_and_a_failure_are_not_the_same_code() {
let panicked = ScanError::TaskFailed {
panicked: true,
detail: "index out of bounds".into(),
};
let failed = ScanError::TaskFailed {
panicked: false,
detail: "cancelled".into(),
};
assert_eq!(panicked.code(), "scan.task_panicked");
assert_eq!(failed.code(), "scan.task_failed");
}
#[test]
fn the_codes_are_what_they_were() {
assert_eq!(ScanError::WrongPhase.code(), "scan.wrong_phase");
assert_eq!(
EvasionError::SourcePortZero.code(),
"evasion.source_port_zero"
);
assert_eq!(
EvasionError::PaddingTooLarge {
padding: 9000,
limit: 1500
}
.code(),
"evasion.padding_too_large"
);
assert_eq!(ExportError::Io(broken_pipe()).code(), "export.io");
assert_eq!(IpParseError::EmptySet.code(), "address.empty_set");
assert_eq!(
IpParseError::UnknownInterface("en9".into()).code(),
"address.unknown_interface"
);
assert_eq!(TargetParseError::Empty.code(), "target.empty");
assert_eq!(
TargetParseError::UnbalancedBracket("[::1".into()).code(),
"target.unbalanced_bracket"
);
assert_eq!(
PortSetParseError::InvalidRange { start: 9, end: 1 }.code(),
"ports.invalid_range"
);
assert_eq!(DetectionError::Tier("4".into()).code(), "detection.tier");
}
#[cfg(feature = "journal-format")]
#[test]
fn the_journal_codes_are_what_they_were() {
assert_eq!(JournalError::NotAJournal.code(), "journal.not_a_journal");
assert_eq!(
JournalError::VersionTooNew {
found: 9,
understood: 1
}
.code(),
"journal.version_too_new"
);
assert_eq!(
OpenError::VersionTooOld {
found: 0,
understood: 1
}
.code(),
"journal.version_too_old"
);
assert_eq!(
OpenError::Journal(JournalError::NotAJournal).code(),
"journal.not_a_journal",
"an open that failed on the format reports the format's reason"
);
}
fn broken_pipe() -> std::io::Error {
std::io::Error::new(std::io::ErrorKind::BrokenPipe, "gone")
}
}