use std::collections::HashMap;
use std::io::{Read, Seek};
use std::sync::{Mutex, MutexGuard, PoisonError};
use forensic_vfs::{
Allocation, ByteRun, DirEntry as VfsDirEntry, DirStream, ExtentStream, FileId, FileSystem,
FsKind, FsMeta, MacbTimes, NodeKind, NodeStream, ResidencyKind, RunAlloc, RunFlags, RunInfo,
SectorSizes, SmallHex, StreamId, StreamInfo, StreamKind, TimeZonePolicy, VfsError, VfsResult,
};
use crate::{
read_dir_at_lba, read_fe_data, read_fe_file_type, UdfState, FILE_TYPE_BLOCK_DEVICE,
FILE_TYPE_CHAR_DEVICE, FILE_TYPE_DIRECTORY, FILE_TYPE_FIFO, FILE_TYPE_LINK, FILE_TYPE_SOCKET,
};
#[cfg(feature = "vfs")]
fn kind_of_file_type(file_type: u8) -> NodeKind {
match file_type {
FILE_TYPE_DIRECTORY => NodeKind::Dir,
crate::FILE_TYPE_REGULAR => NodeKind::File,
FILE_TYPE_LINK => NodeKind::Symlink,
FILE_TYPE_CHAR_DEVICE => NodeKind::CharDevice,
FILE_TYPE_BLOCK_DEVICE => NodeKind::BlockDevice,
FILE_TYPE_FIFO => NodeKind::Fifo,
FILE_TYPE_SOCKET => NodeKind::Socket,
_ => NodeKind::Other,
}
}
#[cfg(feature = "vfs")]
fn kind_from_fid_only(is_dir: bool) -> NodeKind {
if is_dir {
NodeKind::Dir
} else {
NodeKind::Other
}
}
#[derive(Clone, Copy)]
struct FeMeta {
is_dir: bool,
kind: NodeKind,
size: u64,
}
struct Inner<R> {
reader: R,
cache: HashMap<u32, FeMeta>,
}
pub struct UdfVfs<R: Read + Seek> {
inner: Mutex<Inner<R>>,
state: UdfState,
}
impl<R: Read + Seek + Send> UdfVfs<R> {
pub fn open(mut reader: R) -> VfsResult<Self> {
let state = crate::parse_udf_state_checked(&mut reader)
.map_err(|source| VfsError::Io {
op: "udf bootstrap",
source,
})?
.ok_or(VfsError::Bootstrap {
stage: "udf mount",
detail: "no valid UDF AVDP/VDS/FSD chain".to_string(),
})?;
let mut cache = HashMap::new();
cache.insert(
state.root_fe_lba,
FeMeta {
is_dir: true,
kind: NodeKind::Dir,
size: 0,
},
);
Ok(Self {
inner: Mutex::new(Inner { reader, cache }),
state,
})
}
fn lock(&self) -> MutexGuard<'_, Inner<R>> {
self.inner.lock().unwrap_or_else(PoisonError::into_inner)
}
}
fn fe_lba_of(id: FileId) -> VfsResult<u32> {
match id {
FileId::Opaque(n) => u32::try_from(n).map_err(|_| VfsError::Unsupported {
layer: "udf file-id",
scheme: format!("Opaque({n})"),
}),
other => Err(VfsError::Unsupported {
layer: "udf file-id",
scheme: format!("{other:?}"),
}),
}
}
fn require_default_stream(stream: StreamId) -> VfsResult<()> {
match stream {
StreamId::Default => Ok(()),
other => Err(VfsError::Unsupported {
layer: "udf stream",
scheme: format!("{other:?}"),
}),
}
}
fn extended_attributes<R: Read + Seek>(
reader: &mut R,
block_size: u32,
fe_lba: u32,
) -> VfsResult<Vec<crate::xattr::UdfExtendedAttribute>> {
crate::read_fe_extended_attributes(reader, block_size, fe_lba).ok_or_else(|| VfsError::Decode {
layer: "udf",
offset: u64::from(fe_lba) * u64::from(block_size),
detail: format!(
"File Entry at LBA {fe_lba} has an extended-attribute space that cannot be \
read or parsed: L_EA overruns the {block_size}-byte block, or the space does \
not begin with an Extended Attribute Header Descriptor (tag 262)"
),
bytes: SmallHex::new(&[]),
})
}
impl<R: Read + Seek + Send> UdfVfs<R> {
fn resolve(inner: &mut Inner<R>, fe_lba: u32, block_size: u32) -> VfsResult<FeMeta> {
if let Some(m) = inner.cache.get(&fe_lba) {
return Ok(*m);
}
match read_fe_file_type(&mut inner.reader, block_size, fe_lba) {
Some(ft) => {
let is_dir = ft == FILE_TYPE_DIRECTORY;
let size =
crate::read_fe_info_len(&mut inner.reader, block_size, fe_lba).unwrap_or(0);
let m = FeMeta {
is_dir,
kind: kind_of_file_type(ft),
size,
};
inner.cache.insert(fe_lba, m);
Ok(m)
}
None => Err(VfsError::Decode {
layer: "udf",
offset: u64::from(fe_lba) * u64::from(block_size),
detail: format!(
"no File Entry at LBA {fe_lba}; enumerate its parent directory first"
),
bytes: SmallHex::new(&[]),
}),
}
}
fn dir_children(&self, fe_lba: u32) -> VfsResult<(Vec<crate::UdfFileEntry>, Vec<FeMeta>)> {
let block_size = self.state.block_size;
let partition_start = self.state.partition_start;
let mut inner = self.lock();
let meta = Self::resolve(&mut inner, fe_lba, block_size)?;
if !meta.is_dir {
return Err(VfsError::Decode {
layer: "udf",
offset: u64::from(fe_lba) * u64::from(block_size),
detail: format!("File Entry at LBA {fe_lba} is not a directory"),
bytes: SmallHex::new(&[]),
});
}
let children = read_dir_at_lba(&mut inner.reader, block_size, partition_start, fe_lba)
.ok_or_else(|| VfsError::Decode {
layer: "udf",
offset: u64::from(fe_lba) * u64::from(block_size),
detail: format!("directory File Entry at LBA {fe_lba} could not be read"),
bytes: SmallHex::new(&[]),
})?;
let mut metas = Vec::with_capacity(children.len());
for c in &children {
let meta = match read_fe_file_type(&mut inner.reader, block_size, c.fe_lba) {
Some(ft) => FeMeta {
is_dir: ft == FILE_TYPE_DIRECTORY,
kind: kind_of_file_type(ft),
size: c.size,
},
None => FeMeta {
is_dir: c.is_dir,
kind: kind_from_fid_only(c.is_dir),
size: c.size,
},
};
inner.cache.insert(c.fe_lba, meta);
metas.push(meta);
}
Ok((children, metas))
}
}
impl<R: Read + Seek + Send> FileSystem for UdfVfs<R> {
fn kind(&self) -> FsKind {
FsKind::UDF
}
fn root(&self) -> FileId {
FileId::Opaque(u64::from(self.state.root_fe_lba))
}
fn sector_sizes(&self) -> SectorSizes {
SectorSizes {
logical: self.state.block_size,
physical: self.state.block_size,
cluster_or_block: self.state.block_size,
}
}
fn timestamp_zone(&self) -> TimeZonePolicy {
TimeZonePolicy::Utc
}
fn read_dir(&self, ino: FileId) -> VfsResult<DirStream> {
let fe_lba = fe_lba_of(ino)?;
let (children, metas) = self.dir_children(fe_lba)?;
let out: Vec<VfsResult<VfsDirEntry>> = children
.into_iter()
.zip(metas)
.map(|(c, meta)| {
Ok(VfsDirEntry {
name: c.name.into_bytes(),
id: FileId::Opaque(u64::from(c.fe_lba)),
kind: meta.kind,
})
})
.collect();
Ok(DirStream::new(out.into_iter()))
}
fn extents(&self, ino: FileId, stream: StreamId) -> VfsResult<ExtentStream> {
let fe_lba = fe_lba_of(ino)?;
require_default_stream(stream)?;
let block_size = self.state.block_size;
let mut inner = self.lock();
let meta = Self::resolve(&mut inner, fe_lba, block_size)?;
if meta.size == 0 {
return Ok(ExtentStream::empty());
}
let run = RunInfo {
run: ByteRun {
image_offset: 0,
len: meta.size,
flags: RunFlags::default(),
},
alloc: RunAlloc::Allocated,
};
Ok(ExtentStream::new(std::iter::once(Ok(run))))
}
fn lookup(&self, parent: FileId, name: &[u8]) -> VfsResult<Option<FileId>> {
let fe_lba = fe_lba_of(parent)?;
let (children, _) = self.dir_children(fe_lba)?;
for c in &children {
if name.eq_ignore_ascii_case(c.name.as_bytes()) {
return Ok(Some(FileId::Opaque(u64::from(c.fe_lba))));
}
}
Ok(None)
}
fn meta(&self, ino: FileId) -> VfsResult<FsMeta> {
let fe_lba = fe_lba_of(ino)?;
let block_size = self.state.block_size;
let mut inner = self.lock();
let m = Self::resolve(&mut inner, fe_lba, block_size)?;
Ok(FsMeta {
ino: u64::from(fe_lba),
kind: m.kind,
allocated: Allocation::Allocated,
size: m.size,
nlink: 1,
uid: None,
gid: None,
mode: None,
times: MacbTimes {
modified: None,
accessed: None,
changed: None,
born: None,
},
streams: Vec::new(),
residency: ResidencyKind::NonResident,
link_target: None,
})
}
fn data_streams(&self, ino: FileId) -> VfsResult<Vec<StreamInfo>> {
let fe_lba = fe_lba_of(ino)?;
let block_size = self.state.block_size;
let mut inner = self.lock();
let meta = Self::resolve(&mut inner, fe_lba, block_size)?;
let mut out = vec![StreamInfo {
id: StreamId::Default,
name: None,
size: meta.size,
residency: ResidencyKind::NonResident,
kind: StreamKind::Data,
}];
let eas = extended_attributes(&mut inner.reader, block_size, fe_lba)?;
for (i, ea) in eas.iter().enumerate() {
out.push(StreamInfo {
id: StreamId::Xattr(u16::try_from(i).unwrap_or(u16::MAX)),
name: ea.name().map(|n| n.as_bytes().to_vec()),
size: ea.value().len() as u64,
residency: ResidencyKind::Resident {
inline_len: u32::try_from(ea.value().len()).unwrap_or(u32::MAX),
},
kind: StreamKind::Xattr,
});
}
Ok(out)
}
fn read_at(&self, ino: FileId, stream: StreamId, off: u64, buf: &mut [u8]) -> VfsResult<usize> {
let fe_lba = fe_lba_of(ino)?;
if let StreamId::Xattr(idx) = stream {
let block_size = self.state.block_size;
let mut inner = self.lock();
Self::resolve(&mut inner, fe_lba, block_size)?;
let eas = extended_attributes(&mut inner.reader, block_size, fe_lba)?;
let ea = eas.get(idx as usize).ok_or_else(|| VfsError::Unsupported {
layer: "udf xattr index",
scheme: format!("attribute {idx} of {}", eas.len()),
})?;
let value = ea.value();
let start = usize::try_from(off).unwrap_or(usize::MAX);
let Some(avail) = value.get(start..) else {
return Ok(0);
};
let n = avail.len().min(buf.len());
buf[..n].copy_from_slice(&avail[..n]);
return Ok(n);
}
require_default_stream(stream)?;
let block_size = self.state.block_size;
let partition_start = self.state.partition_start;
let mut inner = self.lock();
Self::resolve(&mut inner, fe_lba, block_size)?;
let Some(data) = read_fe_data(&mut inner.reader, block_size, partition_start, fe_lba)
else {
return Ok(0);
};
let Ok(start) = usize::try_from(off) else {
return Ok(0); };
if start >= data.len() {
return Ok(0);
}
let n = (data.len() - start).min(buf.len());
if let (Some(dst), Some(src)) = (buf.get_mut(..n), data.get(start..start + n)) {
dst.copy_from_slice(src);
}
Ok(n)
}
fn read_link(&self, ino: FileId, cap: usize) -> VfsResult<Vec<u8>> {
let fe_lba = fe_lba_of(ino)?;
let block_size = self.state.block_size;
let partition_start = self.state.partition_start;
let mut inner = self.lock();
let meta = Self::resolve(&mut inner, fe_lba, block_size)?;
if meta.kind != NodeKind::Symlink {
return Ok(Vec::new());
}
if let Some(info_len) = crate::read_fe_info_len(&mut inner.reader, block_size, fe_lba) {
if info_len > u64::from(block_size) {
return Err(VfsError::Decode {
layer: "udf",
offset: u64::from(fe_lba) * u64::from(block_size) + 56,
detail: format!(
"symbolic link File Entry at LBA {fe_lba} declares {info_len} bytes \
of path data, more than one {block_size}-byte block (Linux \
refuses such a link with ENAMETOOLONG)"
),
bytes: SmallHex::new(&info_len.to_le_bytes()),
});
}
}
let data = read_fe_data(&mut inner.reader, block_size, partition_start, fe_lba)
.ok_or_else(|| VfsError::Decode {
layer: "udf",
offset: u64::from(fe_lba) * u64::from(block_size),
detail: format!("symbolic link File Entry at LBA {fe_lba} could not be read"),
bytes: SmallHex::new(&[]),
})?;
let mut target = crate::decode_symlink_target(&data).into_bytes();
target.truncate(cap);
Ok(target)
}
fn deleted(&self) -> VfsResult<NodeStream> {
Ok(NodeStream::empty())
}
fn unallocated(&self) -> VfsResult<ExtentStream> {
Ok(ExtentStream::empty())
}
}
#[cfg(test)]
mod tests {
use super::*;
use forensic_vfs::{Allocation, NodeKind, RunAlloc};
use std::fs::File;
use std::io::Cursor;
const PLAIN: &str = "udf_plain.img";
fn image_with_eas(header_tag: u16) -> Vec<u8> {
use crate::test_support::{BS, INLINE_FILE_FE};
let mut ea = vec![0u8; 24];
ea[0..2].copy_from_slice(&header_tag.to_le_bytes());
let mut imp = vec![0u8; 53]; imp[0..4].copy_from_slice(&2048u32.to_le_bytes());
imp[4] = 1;
imp[8..12].copy_from_slice(&53u32.to_le_bytes());
imp[12..16].copy_from_slice(&5u32.to_le_bytes()); imp[17..26].copy_from_slice(b"*UDF Test"); imp[48..53].copy_from_slice(b"hello");
ea.extend_from_slice(&imp);
let mut times = vec![0u8; 16];
times[0..4].copy_from_slice(&5u32.to_le_bytes());
times[4] = 1;
times[8..12].copy_from_slice(&16u32.to_le_bytes());
ea.extend_from_slice(×);
let mut img = crate::test_support::image();
let o = INLINE_FILE_FE as usize * BS;
let area = o + 176;
img[o + 168..o + 172].copy_from_slice(&(ea.len() as u32).to_le_bytes()); img[o + 172..o + 176].copy_from_slice(&4u32.to_le_bytes()); img[area..area + ea.len()].copy_from_slice(&ea);
img[area + ea.len()..area + ea.len() + 4].copy_from_slice(b"abcd");
img
}
fn inline_file(fs: &UdfVfs<Cursor<Vec<u8>>>) -> FileId {
fs.read_dir(fs.root())
.expect("root read_dir")
.map(|e| e.expect("entry"))
.find(|e| e.name == b"inline.txt")
.expect("inline.txt present")
.id
}
#[test]
fn data_streams_lists_every_extended_attribute_named_or_not() {
let fs = UdfVfs::open(Cursor::new(image_with_eas(262))).expect("open synthetic image");
let id = inline_file(&fs);
let streams = fs.data_streams(id).expect("data_streams");
assert_eq!(streams.len(), 3, "contents + two attributes: {streams:?}");
assert!(matches!(streams[0].id, StreamId::Default));
assert_eq!(streams[0].size, 4);
assert!(matches!(streams[1].id, StreamId::Xattr(0)));
assert!(matches!(streams[1].kind, StreamKind::Xattr));
assert_eq!(streams[1].name.as_deref(), Some(&b"*UDF Test"[..]));
assert_eq!(streams[1].size, 5);
assert!(matches!(streams[2].id, StreamId::Xattr(1)));
assert_eq!(streams[2].name, None, "a File Times record has no name");
assert_eq!(
streams[2].size, 16,
"an unnamed record's value is the whole record"
);
let mut buf = [0u8; 16];
assert_eq!(
fs.read_at(id, StreamId::Xattr(0), 0, &mut buf)
.expect("read"),
5
);
assert_eq!(&buf[..5], b"hello");
assert_eq!(
fs.read_at(id, StreamId::Xattr(0), 3, &mut buf)
.expect("read"),
2
);
assert_eq!(&buf[..2], b"lo");
assert_eq!(
fs.read_at(id, StreamId::Xattr(0), 99, &mut buf)
.expect("past end"),
0
);
assert_eq!(
fs.read_at(id, StreamId::Xattr(1), 0, &mut buf)
.expect("read"),
16
);
let err = fs
.read_at(id, StreamId::Xattr(7), 0, &mut buf)
.expect_err("there is no attribute 7");
assert!(err.to_string().contains("attribute 7 of 2"), "{err}");
assert_eq!(
fs.read_at(id, StreamId::Default, 0, &mut buf)
.expect("read"),
4
);
assert_eq!(&buf[..4], b"abcd");
}
#[test]
fn a_damaged_extended_attribute_space_is_loud_not_empty() {
let fs = UdfVfs::open(Cursor::new(image_with_eas(0))).expect("open synthetic image");
let id = inline_file(&fs);
let err = fs
.data_streams(id)
.expect_err("a damaged attribute space must not read as none");
assert!(err.to_string().contains("extended-attribute"), "{err}");
let mut buf = [0u8; 8];
let err = fs
.read_at(id, StreamId::Xattr(0), 0, &mut buf)
.expect_err("a damaged attribute space must not read as attribute-not-found");
assert!(err.to_string().contains("extended-attribute"), "{err}");
}
fn open_plain() -> Option<UdfVfs<File>> {
let path = format!("{}/../tests/data/{}", env!("CARGO_MANIFEST_DIR"), PLAIN);
let f = File::open(path).ok()?;
UdfVfs::open(f).ok()
}
#[test]
fn synthetic_symlink_classifies_and_reads_link() {
let fs =
UdfVfs::open(Cursor::new(crate::test_support::image())).expect("open synthetic image");
let children: Vec<_> = fs
.read_dir(fs.root())
.expect("root read_dir")
.map(|e| e.expect("entry"))
.collect();
let link = children
.iter()
.find(|e| e.name == b"lnk")
.expect("synthetic symlink present");
assert_eq!(link.kind, NodeKind::Symlink);
assert_eq!(
fs.read_link(link.id, 4096).expect("read_link"),
b"../README.txt"
);
assert_eq!(fs.meta(link.id).expect("meta").kind, NodeKind::Symlink);
}
#[test]
fn a_symlink_longer_than_one_block_is_refused_loud() {
use crate::test_support::{BS, SYMLINK_FE};
let mut img = crate::test_support::image();
let declared = BS as u64 + 1;
let o = SYMLINK_FE as usize * BS;
img[o + 34..o + 36].copy_from_slice(&0u16.to_le_bytes()); img[o + 56..o + 64].copy_from_slice(&declared.to_le_bytes());
img[o + 172..o + 176].copy_from_slice(&8u32.to_le_bytes()); img[o + 176..o + 180].copy_from_slice(&(declared as u32).to_le_bytes());
img[o + 180..o + 184].copy_from_slice(&16u32.to_le_bytes()); for rec in img[16 * BS..18 * BS].chunks_exact_mut(4) {
rec.copy_from_slice(&[4, 0, 0, 0]); }
let fs = UdfVfs::open(Cursor::new(img)).expect("open synthetic image");
let children: Vec<_> = fs
.read_dir(fs.root())
.expect("root read_dir")
.map(|e| e.expect("entry"))
.collect();
let link = children
.iter()
.find(|e| e.name == b"lnk")
.expect("synthetic symlink present");
assert_eq!(link.kind, NodeKind::Symlink);
let err = fs
.read_link(link.id, 4096)
.expect_err("a symlink longer than one block must be refused");
let msg = err.to_string();
assert!(
msg.contains("513") && msg.contains("512"),
"error must name the declared length and the block size: {msg}"
);
}
#[test]
fn synthetic_symlink_with_unreadable_data_is_loud() {
let mut img = crate::test_support::image();
let o = crate::test_support::SYMLINK_FE as usize * crate::test_support::BS;
img[o + 34] = 0x07;
img[o + 35] = 0x00;
let fs = UdfVfs::open(Cursor::new(img)).expect("open synthetic image");
let children: Vec<_> = fs
.read_dir(fs.root())
.expect("root read_dir")
.map(|e| e.expect("entry"))
.collect();
let link = children
.iter()
.find(|e| e.name == b"lnk")
.expect("synthetic symlink present");
assert!(matches!(link.kind, NodeKind::Symlink));
assert!(
fs.read_link(link.id, 4096).is_err(),
"unreadable symlink data must be loud"
);
}
#[test]
fn a_child_whose_file_entry_is_unreadable_is_unclassified_not_a_file() {
let path = format!(
"{}/../tests/data/udf_all_node_types.img",
env!("CARGO_MANIFEST_DIR")
);
let full = std::fs::read(&path).expect("udf_all_node_types.img committed");
let fs = UdfVfs::open(Cursor::new(full[..139_000].to_vec()))
.expect("truncated image still mounts");
let nodes = fs
.read_dir(fs.root())
.expect("root read_dir")
.filter_map(Result::ok)
.find(|e| e.name == b"nodes")
.map(|e| e.id)
.expect("nodes/ still listed");
let kinds: Vec<_> = fs
.read_dir(nodes)
.expect("nodes read_dir")
.filter_map(Result::ok)
.map(|e| (String::from_utf8_lossy(&e.name).into_owned(), e.kind))
.collect();
for (name, kind) in &kinds {
if name == "fifo" || name == "socket" {
assert_eq!(
*kind,
NodeKind::Other,
"{name}: File Entry past EOF must read as unclassified"
);
}
}
assert!(
kinds
.iter()
.any(|(n, k)| n == "chardev" && *k == NodeKind::CharDevice),
"a readable child still classifies: {kinds:?}"
);
}
#[test]
fn a_fid_alone_cannot_classify_a_non_directory() {
assert_eq!(kind_from_fid_only(true), NodeKind::Dir);
assert_eq!(kind_from_fid_only(false), NodeKind::Other);
}
#[test]
fn icb_file_type_maps_to_its_node_kind() {
for (ft, want) in [
(FILE_TYPE_DIRECTORY, NodeKind::Dir),
(crate::FILE_TYPE_REGULAR, NodeKind::File),
(FILE_TYPE_BLOCK_DEVICE, NodeKind::BlockDevice),
(FILE_TYPE_CHAR_DEVICE, NodeKind::CharDevice),
(FILE_TYPE_FIFO, NodeKind::Fifo),
(FILE_TYPE_SOCKET, NodeKind::Socket),
(FILE_TYPE_LINK, NodeKind::Symlink),
] {
assert_eq!(kind_of_file_type(ft), want, "file_type 0x{ft:02x}");
}
for ft in [0x00, 0x01, 0x02, 0x03, 0x08, 0x0b, 0x0d, 0xff] {
assert_eq!(
kind_of_file_type(ft),
NodeKind::Other,
"unmodelled file_type 0x{ft:02x} must not read as File"
);
}
}
#[test]
fn every_non_regular_node_type_is_classified() {
let path = format!(
"{}/../tests/data/udf_all_node_types.img",
env!("CARGO_MANIFEST_DIR")
);
let Ok(f) = File::open(&path) else {
eprintln!("skip: udf_all_node_types.img fixture absent");
return;
};
let Ok(fs) = UdfVfs::open(f) else {
eprintln!("skip: udf_all_node_types.img did not mount");
return;
};
let root = fs.root();
let root_children: Vec<_> = fs
.read_dir(root)
.expect("root read_dir")
.map(|e| e.expect("entry"))
.collect();
let nodes = root_children
.iter()
.find(|e| e.name == b"nodes")
.expect("nodes dir present");
assert_eq!(nodes.kind, NodeKind::Dir);
let children: Vec<_> = fs
.read_dir(nodes.id)
.expect("nodes read_dir")
.map(|e| e.expect("entry"))
.collect();
for (name, want) in [
(&b"symlink"[..], NodeKind::Symlink),
(&b"chardev"[..], NodeKind::CharDevice),
(&b"blockdev"[..], NodeKind::BlockDevice),
(&b"fifo"[..], NodeKind::Fifo),
(&b"socket"[..], NodeKind::Socket),
] {
let e = children
.iter()
.find(|e| e.name == name)
.expect("every node type present under nodes/");
assert_eq!(
e.kind,
want,
"read_dir kind for {}",
String::from_utf8_lossy(name)
);
assert_eq!(
fs.meta(e.id).expect("meta").kind,
want,
"meta kind for {}",
String::from_utf8_lossy(name)
);
let target = fs.read_link(e.id, 4096).expect("read_link");
if want == NodeKind::Symlink {
assert_eq!(
target, b"../README.txt",
"the symlink's target is the driver's own resolution"
);
} else {
assert!(
target.is_empty(),
"{} carries no link target",
String::from_utf8_lossy(name)
);
}
}
}
#[test]
fn udf_symlink_surfaces_as_symlink_with_target() {
let path = format!(
"{}/../tests/data/udf_symlink.img",
env!("CARGO_MANIFEST_DIR")
);
let Ok(f) = File::open(&path) else {
eprintln!("skip: udf_symlink.img fixture absent");
return;
};
let Ok(fs) = UdfVfs::open(f) else {
eprintln!("skip: udf_symlink.img did not mount");
return;
};
let root = fs.root();
let root_children: Vec<_> = fs
.read_dir(root)
.expect("root read_dir")
.map(|e| e.expect("entry"))
.collect();
let nested = root_children
.iter()
.find(|e| e.name == b"nested")
.expect("nested dir present");
assert_eq!(nested.kind, NodeKind::Dir);
let nested_children: Vec<_> = fs
.read_dir(nested.id)
.expect("nested read_dir")
.map(|e| e.expect("entry"))
.collect();
let link = nested_children
.iter()
.find(|e| e.name == b"readme-link.txt")
.expect("readme-link.txt present");
assert_eq!(
link.kind,
NodeKind::Symlink,
"the adapter must classify the PATH_COMPONENT record as a symlink"
);
assert_eq!(
fs.read_link(link.id, 4096).expect("read_link"),
b"../README.txt",
"the decoded target must match the Linux UDF driver's own resolution"
);
assert_eq!(
fs.read_link(link.id, 4).expect("read_link capped"),
b"../R",
"a cap shorter than the target must truncate it"
);
assert_eq!(
fs.read_link(link.id, 0).expect("read_link zero cap"),
b"",
"cap == 0 must yield an empty target"
);
let meta = fs.meta(link.id).expect("symlink meta");
assert_eq!(meta.kind, NodeKind::Symlink);
let readme = root_children
.iter()
.find(|e| e.name == b"README.txt")
.expect("README.txt present");
assert_eq!(readme.kind, NodeKind::File);
assert_eq!(
fs.read_link(readme.id, 4096)
.expect("read_link regular file"),
b""
);
}
#[test]
fn kind_root_and_zone() {
let Some(fs) = open_plain() else {
eprintln!("skip: {PLAIN} fixture absent");
return;
};
assert_eq!(fs.kind(), FsKind::UDF);
assert!(matches!(fs.root(), FileId::Opaque(_)));
assert_eq!(fs.timestamp_zone(), TimeZonePolicy::Utc);
let ss = fs.sector_sizes();
assert_eq!(ss.logical, 512);
assert_eq!(ss.cluster_or_block, 512);
assert!(ss.physical >= 512);
let m = fs.meta(fs.root()).expect("root meta");
assert_eq!(m.kind, NodeKind::Dir);
}
#[test]
fn lists_root() {
let Some(fs) = open_plain() else {
eprintln!("skip: {PLAIN} fixture absent");
return;
};
let root = fs.root();
let entries: Vec<_> = fs
.read_dir(root)
.expect("read_dir")
.map(|e| e.expect("entry"))
.collect();
for e in &entries {
assert!(matches!(e.id, FileId::Opaque(_)));
}
}
#[test]
fn root_extents_and_meta_shape() {
let Some(fs) = open_plain() else {
eprintln!("skip: {PLAIN} fixture absent");
return;
};
let m = fs.meta(fs.root()).expect("root meta");
assert_eq!(m.allocated, Allocation::Allocated);
assert_eq!(m.nlink, 1);
assert!(m.times.modified.is_none());
let runs: Vec<_> = fs
.extents(fs.root(), StreamId::Default)
.expect("extents")
.map(|r| r.expect("run"))
.collect();
assert!(runs.len() <= 1);
if let Some(r) = runs.first() {
assert_eq!(r.alloc, RunAlloc::Allocated);
}
}
#[test]
fn read_at_with_offset() {
let Some(fs) = open_plain() else {
eprintln!("skip: {PLAIN} fixture absent");
return;
};
let mut buf = [0u8; 32];
let n = fs
.read_at(fs.root(), StreamId::Default, 0, &mut buf)
.expect("read_at");
assert!(n <= buf.len());
assert_eq!(
fs.read_at(fs.root(), StreamId::Default, u64::from(u32::MAX), &mut buf)
.expect("eof read"),
0
);
}
#[test]
fn empty_forensic_surfaces() {
let Some(fs) = open_plain() else {
eprintln!("skip: {PLAIN} fixture absent");
return;
};
assert_eq!(fs.deleted().unwrap().count(), 0);
assert_eq!(fs.unallocated().unwrap().count(), 0);
assert!(fs.read_link(fs.root(), 4096).unwrap().is_empty());
}
#[test]
fn wrong_file_id_and_stream_are_loud() {
let Some(fs) = open_plain() else {
eprintln!("skip: {PLAIN} fixture absent");
return;
};
assert!(fs.meta(FileId::NtfsRef { entry: 5, seq: 1 }).is_err());
assert!(fs.read_dir(FileId::NtfsRef { entry: 5, seq: 1 }).is_err());
assert!(fs
.lookup(FileId::NtfsRef { entry: 5, seq: 1 }, b"x")
.is_err());
assert!(fs
.read_link(FileId::NtfsRef { entry: 5, seq: 1 }, 8)
.is_err());
assert!(fs
.read_at(fs.root(), StreamId::Named(1), 0, &mut [0u8; 4])
.is_err());
assert!(fs.extents(fs.root(), StreamId::Named(1)).is_err());
}
#[test]
fn read_dir_on_a_file_is_loud() {
let Some(fs) = open_plain() else {
eprintln!("skip: {PLAIN} fixture absent");
return;
};
let bogus = FileId::Opaque(u64::from(u32::MAX));
assert!(fs.read_dir(bogus).is_err());
}
#[test]
fn meta_on_untraversed_file_is_loud() {
let Some(fs) = open_plain() else {
eprintln!("skip: {PLAIN} fixture absent");
return;
};
assert!(fs.meta(FileId::Opaque(9_999_999)).is_err());
}
#[test]
fn lookup_missing_is_none() {
let Some(fs) = open_plain() else {
eprintln!("skip: {PLAIN} fixture absent");
return;
};
assert!(fs.lookup(fs.root(), b"NOPE.NOTPRESENT").unwrap().is_none());
}
#[test]
fn fe_lba_of_rejects_non_opaque_and_overflow() {
assert!(super::fe_lba_of(FileId::Opaque(42)).is_ok());
assert!(super::fe_lba_of(FileId::Opaque(u64::from(u32::MAX) + 1)).is_err());
assert!(super::fe_lba_of(FileId::NtfsRef { entry: 1, seq: 1 }).is_err());
}
use crate::test_support as ts;
fn open_rich() -> UdfVfs<Cursor<Vec<u8>>> {
UdfVfs::open(Cursor::new(ts::image())).expect("rich synthetic UDF opens")
}
#[test]
fn rich_lists_and_looks_up_children() {
let fs = open_rich();
let root = fs.root();
let names: Vec<String> = fs
.read_dir(root)
.expect("read_dir")
.map(|e| String::from_utf8_lossy(&e.expect("entry").name).into_owned())
.collect();
assert!(names.iter().any(|n| n == "inline.txt"), "names: {names:?}");
assert!(names.iter().any(|n| n == "sub"), "names: {names:?}");
let id = fs
.lookup(root, b"INLINE.TXT")
.expect("lookup")
.expect("inline.txt found");
assert!(matches!(id, FileId::Opaque(_)));
assert!(fs.lookup(root, b"NOPE").expect("lookup").is_none());
}
#[test]
fn meta_and_extents_on_uncached_file() {
let fs = open_rich();
let file = FileId::Opaque(u64::from(ts::INLINE_FILE_FE));
let m = fs.meta(file).expect("uncached file meta");
assert_eq!(m.kind, NodeKind::File);
assert_eq!(m.size, 4);
let runs: Vec<_> = fs
.extents(file, StreamId::Default)
.expect("extents")
.map(|r| r.expect("run"))
.collect();
assert_eq!(runs.len(), 1);
assert_eq!(runs[0].run.len, 4);
assert_eq!(runs[0].alloc, RunAlloc::Allocated);
}
#[test]
fn read_at_returns_file_bytes_across_extents() {
let fs = open_rich();
let inline = FileId::Opaque(u64::from(ts::INLINE_FILE_FE));
let mut buf = [0u8; 8];
let n = fs
.read_at(inline, StreamId::Default, 0, &mut buf)
.expect("read inline");
assert_eq!(&buf[..n], b"abcd");
let short = FileId::Opaque(u64::from(ts::SHORT_FILE_FE));
let mut big = vec![0u8; ts::SHORT_FILE_LEN as usize];
let got = fs
.read_at(short, StreamId::Default, 0, &mut big)
.expect("read short");
assert_eq!(got as u64, ts::SHORT_FILE_LEN);
assert_eq!(big[0], 0x41);
assert_eq!(big[599], 0x42);
}
#[test]
fn read_dir_and_read_at_on_broken_dir_are_honest() {
let fs = open_rich();
let _ = fs.read_dir(fs.root()).expect("read root").count();
assert!(fs
.read_dir(FileId::Opaque(u64::from(ts::INLINE_FILE_FE)))
.is_err());
assert!(fs
.read_dir(FileId::Opaque(u64::from(ts::BROKEN_DIR_FE)))
.is_err());
assert_eq!(
fs.read_at(
FileId::Opaque(u64::from(ts::BROKEN_DIR_FE)),
StreamId::Default,
0,
&mut [0u8; 4],
)
.expect("read broken dir"),
0
);
}
#[test]
fn open_surfaces_io_and_bootstrap_failures() {
use std::io::{self, Read, Seek, SeekFrom};
struct Faulty;
impl Read for Faulty {
fn read(&mut self, _b: &mut [u8]) -> io::Result<usize> {
Err(io::Error::other("device read fault"))
}
}
impl Seek for Faulty {
fn seek(&mut self, _p: SeekFrom) -> io::Result<u64> {
Ok(0)
}
}
assert!(matches!(UdfVfs::open(Faulty), Err(VfsError::Io { .. })));
let non_udf = Cursor::new(vec![0u8; 257 * 2048]);
assert!(matches!(
UdfVfs::open(non_udf),
Err(VfsError::Bootstrap { .. })
));
}
}