use crate::finding::Severity;
#[cfg(any(
feature = "ext",
feature = "fat",
feature = "exfat",
feature = "btrfs",
feature = "apfs"
))]
pub(crate) const MAX_PATH: usize = 4096;
#[cfg(any(
feature = "ext",
feature = "fat",
feature = "exfat",
feature = "btrfs",
feature = "apfs"
))]
pub const MAX_SYMLINK_HOPS: u32 = 40;
#[derive(Clone, Copy, PartialEq, Eq, Debug, Default)]
#[non_exhaustive]
pub enum ReadPolicy {
#[default]
Strict,
Lenient,
}
impl ReadPolicy {
#[must_use]
pub fn is_fatal(self, severity: Severity) -> bool {
match self {
ReadPolicy::Strict => severity >= Severity::Conformance,
ReadPolicy::Lenient => false,
}
}
}
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
#[non_exhaustive]
pub struct Limits {
pub max_findings: usize,
pub max_walk_entries: usize,
pub max_file_bytes: u64,
}
impl Limits {
#[must_use]
pub const fn new() -> Self {
Self {
max_findings: crate::finding::FindingReport::MAX_FINDINGS,
max_walk_entries: usize::MAX,
max_file_bytes: u64::MAX,
}
}
#[must_use]
pub const fn max_findings(mut self, max: usize) -> Self {
self.max_findings = max;
self
}
#[must_use]
pub const fn max_walk_entries(mut self, max: usize) -> Self {
self.max_walk_entries = max;
self
}
#[must_use]
pub const fn max_file_bytes(mut self, max: u64) -> Self {
self.max_file_bytes = max;
self
}
}
impl Default for Limits {
fn default() -> Self {
Self::new()
}
}
#[derive(Clone, Copy, PartialEq, Eq, Debug, Default)]
#[non_exhaustive]
pub struct OpenOptions {
pub base: u64,
pub len: Option<u64>,
pub policy: ReadPolicy,
pub limits: Limits,
}
impl OpenOptions {
#[must_use]
pub const fn new() -> Self {
Self {
base: 0,
len: None,
policy: ReadPolicy::Strict,
limits: Limits::new(),
}
}
#[must_use]
pub const fn base(mut self, base: u64) -> Self {
self.base = base;
self
}
#[must_use]
pub const fn len(mut self, len: u64) -> Self {
self.len = Some(len);
self
}
#[must_use]
pub const fn policy(mut self, policy: ReadPolicy) -> Self {
self.policy = policy;
self
}
#[must_use]
pub const fn limits(mut self, limits: Limits) -> Self {
self.limits = limits;
self
}
}
#[cfg(test)]
mod tests {
use super::{Limits, OpenOptions, ReadPolicy};
use crate::finding::Severity;
#[test]
fn strict_is_fatal_from_conformance_up_and_lenient_never_is() {
for severity in [
Severity::Conformance,
Severity::Integrity,
Severity::Structural,
] {
assert!(ReadPolicy::Strict.is_fatal(severity), "{severity:?}");
assert!(!ReadPolicy::Lenient.is_fatal(severity), "{severity:?}");
}
assert!(!ReadPolicy::Strict.is_fatal(Severity::Cosmetic));
assert!(!ReadPolicy::Lenient.is_fatal(Severity::Cosmetic));
}
#[test]
fn the_default_limits_cap_only_findings() {
let limits = Limits::new();
assert_eq!(limits.max_walk_entries, usize::MAX);
assert_eq!(limits.max_file_bytes, u64::MAX);
assert_eq!(
limits.max_findings,
crate::finding::FindingReport::MAX_FINDINGS
);
assert_eq!(Limits::default(), limits);
}
#[test]
fn open_options_carry_what_they_were_given() {
let options = OpenOptions::new()
.base(1 << 20)
.len(16 << 20)
.policy(ReadPolicy::Lenient)
.limits(Limits::new().max_file_bytes(4096));
assert_eq!(options.base, 1 << 20);
assert_eq!(options.len, Some(16 << 20));
assert_eq!(
OpenOptions::new().len,
None,
"the source's own end by default"
);
assert_eq!(options.policy, ReadPolicy::Lenient);
assert_eq!(options.limits.max_file_bytes, 4096);
assert_eq!(OpenOptions::default(), OpenOptions::new());
}
}