#[cfg(any(
feature = "ext",
feature = "fat",
feature = "exfat",
feature = "btrfs",
feature = "apfs"
))]
use std::io::{Read, Result, Seek, SeekFrom};
#[cfg(any(
feature = "ext",
feature = "fat",
feature = "exfat",
feature = "btrfs",
feature = "apfs"
))]
use std::io::Write;
#[cfg(any(
feature = "ext",
feature = "fat",
feature = "exfat",
feature = "btrfs",
feature = "apfs"
))]
pub(crate) struct ByteSink<W> {
sink: W,
written_end: u64,
}
#[cfg(any(
feature = "ext",
feature = "fat",
feature = "exfat",
feature = "btrfs",
feature = "apfs"
))]
impl<W: Write + Seek> ByteSink<W> {
pub(crate) fn new(sink: W) -> Self {
Self {
sink,
written_end: 0,
}
}
pub(crate) fn write_at(&mut self, offset: u64, bytes: &[u8]) -> Result<()> {
let end = offset.checked_add(bytes.len() as u64).ok_or_else(|| {
std::io::Error::new(
std::io::ErrorKind::InvalidInput,
"a write's end overflows the offset space",
)
})?;
self.sink.seek(SeekFrom::Start(offset))?;
self.sink.write_all(bytes)?;
self.written_end = self.written_end.max(end);
Ok(())
}
#[cfg(feature = "exfat")]
pub(crate) fn flush(&mut self) -> Result<()> {
self.sink.flush()
}
pub(crate) fn extend_to(&mut self, size: u64) -> Result<()> {
if size == 0 {
return Ok(());
}
if self.written_end < size {
self.write_at(size - 1, &[0])?;
}
Ok(())
}
}
#[cfg(any(
feature = "ext",
feature = "fat",
feature = "exfat",
feature = "btrfs",
feature = "apfs"
))]
pub(crate) fn read_exact_at<R: Read + Seek>(
src: &mut R,
offset: u64,
len: usize,
) -> Result<Vec<u8>> {
let mut buf = vec![0u8; len];
read_exact_into(src, offset, &mut buf)?;
Ok(buf)
}
#[cfg(any(
feature = "ext",
feature = "fat",
feature = "exfat",
feature = "btrfs",
feature = "apfs"
))]
pub(crate) fn read_exact_into<R: Read + Seek>(
src: &mut R,
offset: u64,
buf: &mut [u8],
) -> Result<()> {
src.seek(SeekFrom::Start(offset))?;
src.read_exact(buf)
}
#[cfg(any(
feature = "ext",
feature = "fat",
feature = "exfat",
feature = "btrfs",
feature = "apfs"
))]
pub(crate) struct Bounded<R> {
inner: R,
end: Option<u64>,
at: Option<u64>,
}
#[cfg(any(
feature = "ext",
feature = "fat",
feature = "exfat",
feature = "btrfs",
feature = "apfs"
))]
impl<R> Bounded<R> {
pub(crate) fn new(inner: R, base: u64, len: Option<u64>) -> Self {
Self {
inner,
end: len.map(|len| base.saturating_add(len)),
at: None,
}
}
fn room(&mut self, wanted: usize) -> Result<usize>
where
R: Seek,
{
let Some(end) = self.end else {
return Ok(wanted);
};
let at = match self.at {
Some(at) => at,
None => {
let at = self.inner.stream_position()?;
self.at = Some(at);
at
}
};
let room = end.saturating_sub(at);
Ok(usize::try_from(room).map_or(wanted, |room| room.min(wanted)))
}
}
#[cfg(any(
feature = "ext",
feature = "fat",
feature = "exfat",
feature = "btrfs",
feature = "apfs"
))]
impl<R: Read + Seek> Read for Bounded<R> {
fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
let take = self.room(buf.len())?;
let n = self.inner.read(&mut buf[..take])?;
if let Some(at) = self.at.as_mut() {
*at += n as u64;
}
Ok(n)
}
}
#[cfg(any(
feature = "ext",
feature = "fat",
feature = "exfat",
feature = "btrfs",
feature = "apfs"
))]
impl<R: Seek> Seek for Bounded<R> {
fn seek(&mut self, pos: SeekFrom) -> Result<u64> {
self.at = None;
let to = match (pos, self.end) {
(SeekFrom::End(delta), Some(end)) => {
let stop = self.inner.seek(SeekFrom::End(0))?.min(end);
let to = stop.checked_add_signed(delta).ok_or_else(|| {
std::io::Error::new(
std::io::ErrorKind::InvalidInput,
"a seek from the region's end leaves the offset space",
)
})?;
self.inner.seek(SeekFrom::Start(to))?
}
_ => self.inner.seek(pos)?,
};
self.at = Some(to);
Ok(to)
}
}
#[cfg(feature = "ext")]
impl<W: Write + Seek> Write for Bounded<W> {
fn write(&mut self, buf: &[u8]) -> Result<usize> {
let take = self.room(buf.len())?;
let n = self.inner.write(&buf[..take])?;
if let Some(at) = self.at.as_mut() {
*at += n as u64;
}
Ok(n)
}
fn flush(&mut self) -> Result<()> {
self.inner.flush()
}
}
#[cfg(any(
feature = "ext",
feature = "fat",
feature = "exfat",
feature = "btrfs",
feature = "apfs"
))]
pub(crate) const fn offset_of(base: u64, index: u64, unit: u64) -> Option<u64> {
match index.checked_mul(unit) {
Some(within) => base.checked_add(within),
None => None,
}
}
#[cfg(any(
feature = "ext",
feature = "fat",
feature = "exfat",
feature = "btrfs",
feature = "apfs"
))]
pub(crate) fn image_buffer(bytes: u64) -> Option<Vec<u8>> {
let len = usize::try_from(bytes).ok()?;
Vec::<u8>::new().try_reserve_exact(len).ok()?;
Some(vec![0u8; len])
}
pub(crate) fn io_fault(err: &std::io::Error) -> (std::io::ErrorKind, String) {
(err.kind(), err.to_string())
}
macro_rules! io_error {
($ty:ty) => {
impl From<std::io::Error> for $ty {
fn from(e: std::io::Error) -> Self {
let (kind, message) = $crate::io::io_fault(&e);
Self::Io { kind, message }
}
}
};
}
pub(crate) use io_error;
#[cfg(all(test, any(feature = "ext", feature = "fat", feature = "btrfs")))]
pub(crate) type ReadLog = std::rc::Rc<std::cell::RefCell<Vec<(u64, usize)>>>;
#[cfg(all(test, any(feature = "ext", feature = "fat", feature = "btrfs")))]
pub(crate) struct Counting {
inner: std::io::Cursor<Vec<u8>>,
reads: ReadLog,
}
#[cfg(all(test, any(feature = "ext", feature = "fat", feature = "btrfs")))]
impl Counting {
pub(crate) fn new(bytes: Vec<u8>) -> (Self, ReadLog) {
let reads = ReadLog::default();
let source = Self {
inner: std::io::Cursor::new(bytes),
reads: std::rc::Rc::clone(&reads),
};
(source, reads)
}
}
#[cfg(all(test, any(feature = "ext", feature = "fat", feature = "btrfs")))]
impl Read for Counting {
fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
let at = self.inner.position();
self.reads.borrow_mut().push((at, buf.len()));
self.inner.read(buf)
}
}
#[cfg(all(test, any(feature = "ext", feature = "fat", feature = "btrfs")))]
impl Seek for Counting {
fn seek(&mut self, pos: SeekFrom) -> Result<u64> {
self.inner.seek(pos)
}
}
#[cfg(all(
test,
any(
feature = "ext",
feature = "fat",
feature = "exfat",
feature = "btrfs",
feature = "apfs"
)
))]
mod tests {
use super::*;
use std::io::Cursor;
#[cfg(any(feature = "ext", feature = "fat", feature = "exfat", feature = "btrfs"))]
#[test]
fn a_destination_reaches_the_size_its_last_written_byte_did_not() {
let mut sink = ByteSink::new(Cursor::new(Vec::new()));
sink.write_at(0, &[1, 2, 3]).expect("write");
sink.extend_to(16).expect("extend");
let out = sink.sink.into_inner();
assert_eq!(
out.len(),
16,
"the destination is as long as the filesystem"
);
assert_eq!(&out[..3], &[1, 2, 3]);
assert!(
out[3..].iter().all(|&b| b == 0),
"everything the format did not write reads as zero"
);
}
#[cfg(any(feature = "ext", feature = "fat", feature = "exfat", feature = "btrfs"))]
#[test]
fn a_destination_already_long_enough_is_left_alone() {
let mut sink = ByteSink::new(Cursor::new(Vec::new()));
sink.write_at(0, &[7; 8]).expect("write");
sink.extend_to(8).expect("extend");
assert_eq!(sink.sink.into_inner().len(), 8);
}
#[cfg(any(feature = "ext", feature = "fat", feature = "exfat", feature = "btrfs"))]
#[test]
fn a_destination_of_no_bytes_at_all_has_no_last_byte_to_write() {
let mut sink = ByteSink::new(Cursor::new(Vec::new()));
sink.extend_to(0).expect("extend");
assert!(sink.sink.into_inner().is_empty());
}
#[cfg(any(feature = "ext", feature = "fat", feature = "exfat", feature = "btrfs"))]
#[test]
fn the_high_water_mark_is_the_highest_offset_written_not_the_last() {
let mut sink = ByteSink::new(Cursor::new(Vec::new()));
sink.write_at(32, &[1]).expect("write");
sink.write_at(0, &[1]).expect("write");
sink.extend_to(33).expect("extend");
assert_eq!(sink.sink.into_inner().len(), 33);
}
#[test]
fn a_read_takes_exactly_the_bytes_asked_for_at_the_offset_asked_for() {
let mut src = Cursor::new((0u8..32).collect::<Vec<_>>());
assert_eq!(read_exact_at(&mut src, 8, 4).expect("read"), [8, 9, 10, 11]);
assert_eq!(read_exact_at(&mut src, 0, 2).expect("read"), [0, 1]);
}
#[test]
fn a_bounded_source_ends_at_its_region_and_measures_to_it() {
let bytes: Vec<u8> = (0u8..64).collect();
let mut src = Bounded::new(Cursor::new(bytes.clone()), 8, Some(16));
assert_eq!(src.seek(SeekFrom::End(0)).expect("seek"), 24);
assert_eq!(src.seek(SeekFrom::End(-4)).expect("seek"), 20);
assert_eq!(read_exact_at(&mut src, 8, 16).expect("read"), &bytes[8..24]);
let err = read_exact_at(&mut src, 20, 8).expect_err("past the region");
assert_eq!(err.kind(), std::io::ErrorKind::UnexpectedEof);
let err = read_exact_at(&mut src, 40, 1).expect_err("past the region");
assert_eq!(err.kind(), std::io::ErrorKind::UnexpectedEof);
}
#[test]
fn a_bounded_source_is_no_longer_than_the_source_under_it() {
let mut src = Bounded::new(Cursor::new(vec![0u8; 32]), 8, Some(1 << 20));
assert_eq!(src.seek(SeekFrom::End(0)).expect("seek"), 32);
let mut src = Bounded::new(Cursor::new(vec![0u8; 32]), 8, None);
assert_eq!(src.seek(SeekFrom::End(0)).expect("seek"), 32);
assert_eq!(read_exact_at(&mut src, 0, 32).expect("read").len(), 32);
let mut src = Bounded::new(Cursor::new(vec![0u8; 32]), u64::MAX - 1, Some(8));
assert_eq!(src.seek(SeekFrom::End(0)).expect("seek"), 32);
}
#[test]
fn a_bounded_source_bounds_a_read_from_wherever_the_source_stood() {
let mut inner = Cursor::new((0u8..32).collect::<Vec<_>>());
inner.set_position(12);
let mut src = Bounded::new(inner, 0, Some(16));
let mut buf = [0u8; 8];
assert_eq!(
src.read(&mut buf).expect("read"),
4,
"four bytes remain in the region"
);
assert_eq!(&buf[..4], &[12, 13, 14, 15]);
assert_eq!(src.read(&mut buf).expect("read"), 0);
}
#[cfg(feature = "ext")]
#[test]
fn a_bounded_destination_takes_no_byte_past_its_region() {
let mut dest = Bounded::new(Cursor::new(vec![0u8; 32]), 4, Some(8));
dest.seek(SeekFrom::Start(10)).expect("seek");
let err = dest.write_all(&[0xff; 4]).expect_err("past the region");
assert_eq!(err.kind(), std::io::ErrorKind::WriteZero);
let bytes = dest.inner.into_inner();
assert_eq!(
&bytes[10..12],
&[0xff, 0xff],
"the two bytes inside the region"
);
assert_eq!(&bytes[12..14], &[0, 0], "nothing past it");
}
#[test]
fn a_read_running_past_the_end_is_the_end_of_the_source_saying_so() {
let mut src = Cursor::new(vec![0u8; 4]);
let err = read_exact_at(&mut src, 2, 8).expect_err("a source of four bytes holds none");
assert_eq!(err.kind(), std::io::ErrorKind::UnexpectedEof);
}
#[cfg(any(
feature = "ext",
feature = "fat",
feature = "exfat",
feature = "btrfs",
feature = "apfs"
))]
#[test]
fn an_offset_is_the_base_plus_as_many_units_as_asked_for() {
assert_eq!(offset_of(1024, 3, 4096), Some(1024 + 3 * 4096));
assert_eq!(offset_of(1024, 7, 1), Some(1031));
assert_eq!(offset_of(0, 5, 512), Some(2560));
}
#[cfg(any(
feature = "ext",
feature = "fat",
feature = "exfat",
feature = "btrfs",
feature = "apfs"
))]
#[test]
fn an_offset_that_leaves_the_range_is_no_offset_rather_than_a_small_one() {
assert_eq!(offset_of(0, u64::MAX, 2), None, "the product wraps");
assert_eq!(offset_of(u64::MAX, 1, 1), None, "the sum wraps");
assert_eq!(offset_of(u64::MAX - 1, 1, 1), Some(u64::MAX));
}
}