use std::io::{self, Read, Seek, SeekFrom, Write};
use std::path::Path;
use std::sync::{Arc, Mutex};
use std::time::SystemTime;
pub trait FileStream: Read + Seek + Send + 'static {
fn size(&mut self) -> io::Result<u64> {
let current = self.stream_position()?;
let end = self.seek(SeekFrom::End(0))?;
if current != end {
self.seek(SeekFrom::Start(current))?;
}
Ok(end)
}
}
impl<T: Read + Seek + Send + 'static> FileStream for T {}
pub trait WritableFile: FileStream + Write {
fn set_len(&mut self, len: u64) -> io::Result<()>;
}
#[derive(Debug, Clone, Copy)]
pub struct VolumeInfo {
pub capacity: u64,
pub available: u64,
pub block_size: u32,
}
#[must_use]
pub(crate) fn no_space() -> io::Error {
#[cfg(windows)]
{
io::Error::from_raw_os_error(112)
}
#[cfg(not(windows))]
{
io::Error::from_raw_os_error(28)
}
}
#[cfg(hookfs_backend)]
#[must_use]
pub(crate) fn read_only() -> io::Error {
io::Error::new(io::ErrorKind::PermissionDenied, "virtual file is read-only")
}
#[derive(Debug, Clone)]
pub struct VfsMetadata {
pub len: u64,
pub is_dir: bool,
pub readonly: bool,
pub mtime: Option<SystemTime>,
}
impl VfsMetadata {
#[must_use]
pub fn file(len: u64) -> Self {
Self {
len,
is_dir: false,
readonly: true,
mtime: None,
}
}
#[must_use]
pub fn file_rw(len: u64) -> Self {
Self {
len,
is_dir: false,
readonly: false,
mtime: None,
}
}
#[must_use]
pub fn dir() -> Self {
Self {
len: 0,
is_dir: true,
readonly: true,
mtime: None,
}
}
}
#[derive(Debug, Clone)]
pub struct VfsDirEntry {
pub name: std::ffi::OsString,
pub metadata: VfsMetadata,
}
#[derive(Debug, Clone, Copy, Default)]
#[allow(clippy::struct_excessive_bools)] pub struct OpenOptions {
pub read: bool,
pub write: bool,
pub create: bool,
pub create_new: bool,
pub truncate: bool,
pub append: bool,
}
impl OpenOptions {
#[must_use]
pub fn read_only() -> Self {
Self {
read: true,
..Self::default()
}
}
#[must_use]
pub fn write_truncate() -> Self {
Self {
read: false,
write: true,
create: true,
truncate: true,
..Self::default()
}
}
#[must_use]
pub fn creates(&self) -> bool {
self.create || self.create_new
}
}
pub trait VirtualFs: Send + Sync + 'static {
fn open(&self, path: &Path, opts: &OpenOptions) -> Option<io::Result<Box<dyn FileStream>>>;
fn metadata(&self, path: &Path) -> Option<io::Result<VfsMetadata>>;
fn read_dir(&self, path: &Path) -> Option<io::Result<Vec<VfsDirEntry>>>;
fn exists(&self, path: &Path) -> Option<bool> {
self.metadata(path).map(|r| r.is_ok())
}
fn open_write(
&self,
path: &Path,
opts: &OpenOptions,
) -> Option<io::Result<Box<dyn WritableFile>>> {
let _ = (path, opts);
None
}
fn remove(&self, path: &Path) -> Option<io::Result<()>> {
let _ = path;
None
}
fn rename(&self, from: &Path, to: &Path) -> Option<io::Result<()>> {
let _ = (from, to);
None
}
fn create_dir(&self, path: &Path) -> Option<io::Result<()>> {
let _ = path;
None
}
fn set_len(&self, path: &Path, len: u64) -> Option<io::Result<()>> {
let _ = (path, len);
None
}
fn volume_info(&self) -> Option<VolumeInfo> {
None
}
}
pub(crate) struct SharedSource {
inner: Mutex<Box<dyn FileStream>>,
size: u64,
}
impl SharedSource {
pub(crate) fn new<R: FileStream>(mut stream: R) -> io::Result<Arc<Self>> {
let size = stream.size()?;
stream.seek(SeekFrom::Start(0))?;
Ok(Arc::new(Self {
inner: Mutex::new(Box::new(stream)),
size,
}))
}
pub(crate) fn size(&self) -> u64 {
self.size
}
fn read_at(&self, pos: u64, buf: &mut [u8]) -> io::Result<usize> {
let mut guard = self
.inner
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
guard.seek(SeekFrom::Start(pos))?;
guard.read(buf)
}
}
pub(crate) struct SourceCursor {
source: Arc<SharedSource>,
pos: u64,
}
impl SourceCursor {
pub(crate) fn new(source: Arc<SharedSource>) -> Self {
Self { source, pos: 0 }
}
}
impl Read for SourceCursor {
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
if self.pos >= self.source.size() {
return Ok(0); }
let n = self.source.read_at(self.pos, buf)?;
self.pos = self.pos.saturating_add(n as u64);
Ok(n)
}
}
impl Seek for SourceCursor {
fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
let size = self.source.size();
let target: i128 = match pos {
SeekFrom::Start(off) => i128::from(off),
SeekFrom::End(off) => i128::from(size) + i128::from(off),
SeekFrom::Current(off) => i128::from(self.pos) + i128::from(off),
};
if target < 0 {
return Err(io::Error::new(
io::ErrorKind::InvalidInput,
"seek to a negative position",
));
}
let target = u64::try_from(target)
.map_err(|_| io::Error::new(io::ErrorKind::InvalidInput, "seek offset overflow"))?;
self.pos = target;
Ok(self.pos)
}
fn stream_position(&mut self) -> io::Result<u64> {
Ok(self.pos)
}
}