#[cfg(any(feature = "ext", feature = "fat", feature = "exfat", feature = "btrfs"))]
use std::io::{Read, Result, Seek, SeekFrom};
#[cfg(any(feature = "ext", feature = "fat", feature = "exfat", feature = "btrfs"))]
use std::io::Write;
#[cfg(any(feature = "ext", feature = "fat", feature = "exfat", feature = "btrfs"))]
pub(crate) struct ByteSink<W> {
sink: W,
written_end: u64,
}
#[cfg(any(feature = "ext", feature = "fat", feature = "exfat", feature = "btrfs"))]
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(())
}
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"))]
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"))]
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"))]
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,
}
}
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 = "exfat", feature = "btrfs")
))]
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_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"))]
#[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"))]
#[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));
}
}