use std::io::{Read, Seek};
use crate::policy::OpenOptions;
#[non_exhaustive]
pub enum FsReader<R> {
#[cfg(feature = "ext")]
Ext(crate::read::Reader<R>),
#[cfg(feature = "fat")]
Fat(crate::fat::Reader<R>),
#[cfg(feature = "exfat")]
ExFat(crate::exfat::Reader<R>),
#[cfg(feature = "btrfs")]
Btrfs(crate::btrfs::Reader<R>),
#[cfg(feature = "apfs")]
Apfs(crate::apfs::Reader<R>),
}
impl<R> FsReader<R> {
#[must_use]
pub fn family(&self) -> crate::finding::Family {
match self {
#[cfg(feature = "ext")]
FsReader::Ext(_) => crate::finding::Family::Ext,
#[cfg(feature = "fat")]
FsReader::Fat(_) => crate::finding::Family::Fat,
#[cfg(feature = "exfat")]
FsReader::ExFat(_) => crate::finding::Family::ExFat,
#[cfg(feature = "btrfs")]
FsReader::Btrfs(_) => crate::finding::Family::Btrfs,
#[cfg(feature = "apfs")]
FsReader::Apfs(_) => crate::finding::Family::Apfs,
}
}
}
#[derive(Clone, PartialEq, Eq, Debug, thiserror::Error)]
#[non_exhaustive]
pub enum OpenError {
#[error(transparent)]
Detect(#[from] crate::detect::DetectError),
#[error("{family} image refused: {message}", family = .family.as_str())]
#[non_exhaustive]
Refused {
family: crate::finding::Family,
message: String,
},
}
pub fn open<R: Read + Seek>(src: R) -> Result<FsReader<R>, OpenError> {
open_with(src, &OpenOptions::new())
}
pub fn open_with<R: Read + Seek>(
mut src: R,
options: &OpenOptions,
) -> Result<FsReader<R>, OpenError> {
let mut detect = crate::DetectOptions::new().base(options.base);
detect.len = options.len;
match crate::detect_with(&mut src, &detect)? {
#[cfg(feature = "ext")]
crate::Filesystem::Ext(_) => {
let ext = crate::read::OpenOptions::new().common(*options);
crate::read::Reader::open_with(src, &ext)
.map(FsReader::Ext)
.map_err(|e| OpenError::Refused {
family: crate::finding::Family::Ext,
message: e.to_string(),
})
}
#[cfg(feature = "fat")]
crate::Filesystem::Fat(_) => {
let fat = crate::fat::OpenOptions::new().common(*options);
crate::fat::Reader::open_with(src, &fat)
.map(FsReader::Fat)
.map_err(|e| OpenError::Refused {
family: crate::finding::Family::Fat,
message: e.to_string(),
})
}
#[cfg(feature = "exfat")]
crate::Filesystem::ExFat => crate::exfat::Reader::open_with(src, options)
.map(FsReader::ExFat)
.map_err(|e| OpenError::Refused {
family: crate::finding::Family::ExFat,
message: e.to_string(),
}),
#[cfg(feature = "btrfs")]
crate::Filesystem::Btrfs => crate::btrfs::Reader::open_with(src, options)
.map(FsReader::Btrfs)
.map_err(|e| OpenError::Refused {
family: crate::finding::Family::Btrfs,
message: e.to_string(),
}),
#[cfg(feature = "apfs")]
crate::Filesystem::Apfs => {
let apfs = crate::apfs::OpenOptions::new().common(*options);
crate::apfs::Reader::open_with(src, &apfs)
.map(FsReader::Apfs)
.map_err(|e| OpenError::Refused {
family: crate::finding::Family::Apfs,
message: e.to_string(),
})
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[cfg(any(feature = "ext", feature = "fat", feature = "exfat"))]
use crate::time::Timestamp;
use crate::tree::{FsTree, TreeError};
use std::io::Cursor;
#[cfg(any(feature = "ext", feature = "fat", feature = "exfat"))]
const TIME: Timestamp = Timestamp::from_secs(1_426_325_212);
fn images() -> Vec<(crate::finding::Family, Vec<u8>)> {
let mut out = Vec::new();
#[cfg(feature = "ext")]
{
use crate::ext::{FormatOptions, format};
use crate::source::TreeBuilder;
let options = FormatOptions::new([0x5a; 16], TIME, [0xa5; 16]);
let image = format(TreeBuilder::new(), 8 << 20, options).expect("format an ext image");
out.push((crate::finding::Family::Ext, image.into_bytes()));
}
#[cfg(feature = "fat")]
{
use crate::fat::{FormatOptions, format};
use crate::source::TreeBuilder;
let options = FormatOptions::new(0x1234_abcd, TIME);
let image = format(TreeBuilder::new(), 8 << 20, options).expect("format a FAT image");
out.push((crate::finding::Family::Fat, image.into_bytes()));
}
#[cfg(feature = "exfat")]
{
use crate::exfat::{FormatOptions, format};
use crate::source::{Metadata, TreeBuilder};
let source =
TreeBuilder::new().file(b"/READY.TXT".to_vec(), b"", Metadata::new(0o644, TIME));
let image = format(source, 8 << 20, FormatOptions::new(0x1234_abcd))
.expect("format an exFAT image");
out.push((crate::finding::Family::ExFat, image.into_bytes()));
}
#[cfg(feature = "btrfs")]
{
use std::io::Read;
let mut src = crate::btrfs::forge::Forge::populated().source();
let mut bytes = Vec::new();
src.read_to_end(&mut bytes).expect("the forged device");
out.push((crate::finding::Family::Btrfs, bytes));
}
#[cfg(feature = "apfs")]
{
out.push((
crate::finding::Family::Apfs,
crate::apfs::forge::Forge::populated().image(),
));
}
assert!(
!out.is_empty(),
"this module is compiled only where a family is",
);
out
}
fn paths<T: FsTree>(tree: &mut T) -> Vec<Vec<u8>> {
let mut names = Vec::new();
tree.walk_tree::<TreeError, _>(|_, entry| {
names.push(entry.path.to_vec());
Ok(())
})
.expect("walk");
names
}
#[test]
fn every_compiled_in_family_is_reachable_without_being_named() {
for (family, bytes) in images() {
let reader = open(Cursor::new(&bytes))
.unwrap_or_else(|e| panic!("{}: open: {e}", family.as_str()));
assert_eq!(reader.family(), family);
let names = match reader {
#[cfg(feature = "ext")]
FsReader::Ext(mut r) => paths(&mut r),
#[cfg(feature = "fat")]
FsReader::Fat(mut r) => paths(&mut r),
#[cfg(feature = "exfat")]
FsReader::ExFat(mut r) => paths(&mut r),
#[cfg(feature = "btrfs")]
FsReader::Btrfs(mut r) => paths(&mut r),
#[cfg(feature = "apfs")]
FsReader::Apfs(mut r) => paths(&mut r),
};
assert_eq!(names.first(), Some(&Vec::new()), "{}", family.as_str());
let mut distinct = names.clone();
distinct.sort();
distinct.dedup();
assert_eq!(distinct.len(), names.len(), "{}", family.as_str());
}
}
#[test]
fn a_source_no_compiled_in_family_recognizes_is_reported_as_undetected() {
match open(Cursor::new(vec![0u8; 1 << 20])) {
Err(OpenError::Detect(_)) => {}
Err(e) => panic!("expected a detection failure, got {e}"),
Ok(_) => panic!("a megabyte of zeroes is not a filesystem"),
}
}
}