use std::io::{Read, Seek};
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
#[non_exhaustive]
pub enum Filesystem {
#[cfg(feature = "ext")]
Ext(crate::feature::Profile),
}
#[derive(Clone, Copy, PartialEq, Eq, Debug, Default)]
#[non_exhaustive]
pub struct DetectOptions {
pub base: u64,
}
impl DetectOptions {
#[must_use]
pub const fn new() -> Self {
Self { base: 0 }
}
#[must_use]
pub const fn base(mut self, base: u64) -> Self {
self.base = base;
self
}
}
#[derive(Clone, PartialEq, Eq, Debug, thiserror::Error)]
#[non_exhaustive]
pub enum DetectError {
#[error("i/o error: {message}")]
#[non_exhaustive]
Io {
kind: std::io::ErrorKind,
message: String,
},
#[error("unrecognized filesystem: no compiled-in family claims this image")]
Unrecognized,
}
pub fn detect<R: Read + Seek>(src: R) -> Result<Filesystem, DetectError> {
detect_with(src, &DetectOptions::new())
}
pub fn detect_with<R: Read + Seek>(
src: R,
options: &DetectOptions,
) -> Result<Filesystem, DetectError> {
#[cfg(feature = "ext")]
{
use crate::read::{OpenOptions, ReadError, ReadPolicy, Reader};
let open = OpenOptions::new()
.base(options.base)
.policy(ReadPolicy::Lenient);
match Reader::open_with(src, &open) {
Ok(reader) => Ok(Filesystem::Ext(reader.profile())),
Err(ReadError::Io { kind, message }) => Err(DetectError::Io { kind, message }),
Err(_) => Err(DetectError::Unrecognized),
}
}
#[cfg(not(feature = "ext"))]
{
let _ = (src, options);
Err(DetectError::Unrecognized)
}
}
#[cfg(all(test, feature = "ext"))]
mod tests {
use std::io::Cursor;
use super::{DetectOptions, Filesystem, detect, detect_with};
use crate::feature::Profile;
use crate::materialize::{FormatOptions, format};
use crate::ondisk::Timestamp;
use crate::source::TreeBuilder;
fn image() -> Vec<u8> {
let time = Timestamp::from_secs(1_700_000_000);
let options = FormatOptions::new([7; 16], time, [0; 16]);
format(TreeBuilder::new(), 32 << 20, options)
.expect("format")
.into_bytes()
}
#[test]
fn detect_labels_a_formatted_image_by_its_family() {
assert_eq!(
detect(Cursor::new(image())).expect("detect"),
Filesystem::Ext(Profile::Ext4)
);
}
#[test]
fn detect_rejects_a_non_filesystem_source() {
let junk = vec![0u8; 64 << 10];
assert!(matches!(
detect(Cursor::new(junk)),
Err(super::DetectError::Unrecognized)
));
}
#[test]
fn detection_answers_at_the_offset_it_is_given() {
const BASE: u64 = 1 << 20;
let mut disk = vec![0u8; BASE as usize];
disk.extend_from_slice(&image());
assert!(matches!(
detect(Cursor::new(&disk)),
Err(super::DetectError::Unrecognized)
));
assert_eq!(
detect_with(Cursor::new(&disk), &DetectOptions::new().base(BASE)).expect("detect"),
Filesystem::Ext(Profile::Ext4)
);
}
#[test]
fn a_quirk_a_strict_read_refuses_is_still_a_filesystem() {
let mut bytes = image();
let off = 1024 + 0x60;
let mut incompat =
u32::from_le_bytes([bytes[off], bytes[off + 1], bytes[off + 2], bytes[off + 3]]);
incompat |= 0x8000_0000;
bytes[off..off + 4].copy_from_slice(&incompat.to_le_bytes());
assert!(
crate::read::Reader::open(Cursor::new(&bytes)).is_err(),
"a strict read must refuse an incompat feature it does not interpret"
);
assert_eq!(
detect(Cursor::new(&bytes)).expect("detection is not strictness"),
Filesystem::Ext(Profile::Ext4)
);
}
}