use std::fs::{File, Metadata};
use std::path::{Path, PathBuf};
use super::{
DiskTree, Entry, EntryKind, Want, link_read_error, lookup, open_error, read_capped,
read_entries, refuse_unless_directory, verify_handle_path,
};
use crate::error::TreeError;
use crate::path::RelPath;
use crate::tree::FileId;
pub(super) struct Handle {
file: File,
path: PathBuf,
}
pub(super) fn open(
tree: &DiskTree,
path: &RelPath,
want: Want,
shown: &str,
) -> Result<Handle, TreeError> {
let candidate = tree.candidate(path);
let canonical = tree.contain(&candidate, shown)?;
if want == Want::Listing {
refuse_unless_directory(&candidate, shown)?;
}
hook!(tree, before_open);
let file = open_handle(tree, &canonical, want).map_err(|e| open_error(shown, e))?;
hook!(tree, after_open);
let path = verified_path(&tree.root, &file, shown)?;
let metadata = file.metadata().map_err(|e| TreeError::from_io(shown, e))?;
want.require(&metadata, shown)?;
Ok(Handle { file, path })
}
fn verified_path(root: &Path, file: &File, shown: &str) -> Result<PathBuf, TreeError> {
let path = path_of(file).map_err(|e| link_read_error(shown, e))?;
verify_handle_path(root, &path, shown)?;
Ok(path)
}
#[cfg(windows)]
fn path_of(file: &File) -> std::io::Result<PathBuf> {
super::final_path::of(file)
}
#[cfg(windows)]
const FILE_SHARE_READ: u32 = 0x0000_0001;
#[cfg(windows)]
const FILE_SHARE_WRITE: u32 = 0x0000_0002;
#[cfg(windows)]
const FILE_FLAG_BACKUP_SEMANTICS: u32 = 0x0200_0000;
#[cfg(windows)]
fn open_handle(_tree: &DiskTree, path: &Path, _want: Want) -> std::io::Result<File> {
use std::os::windows::fs::OpenOptionsExt as _;
std::fs::OpenOptions::new()
.read(true)
.share_mode(FILE_SHARE_READ | FILE_SHARE_WRITE)
.custom_flags(FILE_FLAG_BACKUP_SEMANTICS)
.open(path)
}
impl Handle {
pub(super) fn metadata(&self, shown: &str) -> Result<Metadata, TreeError> {
self.file
.metadata()
.map_err(|e| TreeError::from_io(shown, e))
}
pub(super) fn link(
&self,
_name: &str,
shown: &str,
_between: impl FnOnce(),
) -> Result<(FileId, PathBuf), TreeError> {
Err(TreeError::from_io(
shown,
std::io::Error::new(
std::io::ErrorKind::Unsupported,
"verified lexical-link capture is unavailable on this host",
),
))
}
#[cfg(windows)]
pub(super) fn identity(&self, root: &Path, shown: &str) -> Result<FileId, TreeError> {
let below = self
.path
.strip_prefix(root)
.map_err(|_| super::outside(shown))?;
Ok(FileId::from_key(below.as_os_str().as_encoded_bytes()))
}
pub(super) fn recheck(&self, root: &Path, shown: &str) -> Result<(), TreeError> {
verified_path(root, &self.file, shown).map(drop)
}
pub(super) fn read(&self, max_bytes: u64, shown: &str) -> Result<Vec<u8>, TreeError> {
read_capped(&self.file, max_bytes, shown)
}
pub(super) fn entries(&self, shown: &str, max_entries: usize) -> Result<Vec<Entry>, TreeError> {
read_entries(&self.path, shown, max_entries)
}
pub(super) fn lookup(&self, name: &str, shown: &str) -> Result<Option<EntryKind>, TreeError> {
lookup(&self.path.join(name), shown)
}
}