use std::collections::VecDeque;
use std::ffi::{OsStr, OsString};
use std::fs::{File, Metadata};
use std::os::fd::OwnedFd;
use std::os::unix::ffi::OsStrExt as _;
use std::path::{Path, PathBuf};
use rustix::fs::{
AtFlags, CWD, Dir, FileType, Mode, OFlags, Stat, fstat, openat, readlinkat, statat,
};
use super::{Entry, EntryKind, Want, device_identity, not_regular, outside, read_capped};
use crate::error::TreeError;
use crate::path::RelPath;
use crate::tree::FileId;
use super::DiskTree;
use super::unix_root::{Root, climb, same};
const SYMLINK_HOPS: usize = 40;
pub(super) struct Handle {
file: File,
metadata: Metadata,
parent: Option<(OwnedFd, OsString)>,
}
enum Step {
Up,
Name(OsString),
}
fn steps(text: &[u8]) -> Vec<Step> {
text.split(|byte| *byte == b'/')
.filter(|part| !part.is_empty() && *part != b".")
.map(|part| {
if part == b".." {
Step::Up
} else {
Step::Name(OsStr::from_bytes(part).to_os_string())
}
})
.collect()
}
pub(super) fn open(
tree: &DiskTree,
path: &RelPath,
want: Want,
shown: &str,
) -> Result<Handle, TreeError> {
hook!(tree, before_open);
let (fd, parent) = walk(tree, path, want, shown)?;
hook!(tree, after_open);
let file = File::from(fd);
let metadata = file.metadata().map_err(|e| TreeError::from_io(shown, e))?;
want.require(&metadata, shown)?;
Ok(Handle {
file,
metadata,
parent,
})
}
type Walked = (OwnedFd, Option<(OwnedFd, OsString)>);
struct Walk<'a> {
tree: &'a DiskTree,
shown: &'a str,
current: OwnedFd,
current_status: Stat,
ancestors: Vec<Stat>,
inside: bool,
queue: VecDeque<Step>,
hops: usize,
final_link: bool,
}
impl Walk<'_> {
fn root(&self) -> &Root {
&self.tree.root_directory
}
fn fail(&self, error: std::io::Error) -> TreeError {
if self.inside {
TreeError::from_io(self.shown, error)
} else {
outside(self.shown)
}
}
fn up(&mut self) -> Result<(), TreeError> {
if !self.inside {
return Err(outside(self.shown));
}
let Some(parent) = self.ancestors.pop() else {
return Err(outside(self.shown));
};
let opened = openat(
&self.current,
"..",
OFlags::RDONLY | OFlags::DIRECTORY | OFlags::CLOEXEC,
Mode::empty(),
)
.map_err(|_| outside(self.shown))?;
let reached = fstat(&opened).map_err(|_| outside(self.shown))?;
if !same(&reached, &parent) {
return Err(outside(self.shown));
}
self.current = opened;
self.current_status = reached;
Ok(())
}
fn descend(&mut self, opened: OwnedFd) -> Result<(), TreeError> {
let reached = fstat(&opened).map_err(|e| self.fail(e.into()))?;
if !self.inside && self.root().is(&reached) {
self.ancestors.clear();
self.inside = true;
} else if self.inside {
let left = std::mem::replace(&mut self.current_status, reached);
self.ancestors.push(left);
self.current = opened;
return Ok(());
}
self.current = opened;
self.current_status = reached;
Ok(())
}
fn hop(&mut self) -> Result<(), TreeError> {
self.hops += 1;
if self.hops > SYMLINK_HOPS {
return Err(if self.inside {
TreeError::SymlinkLoop {
path: self.shown.to_owned(),
}
} else {
outside(self.shown)
});
}
Ok(())
}
fn retake(&mut self, name: OsString) -> Result<(), TreeError> {
self.hop()?;
self.queue.push_front(Step::Name(name));
Ok(())
}
fn follow(&mut self, name: OsString) -> Result<(), TreeError> {
self.hop()?;
let target = match readlinkat(&self.current, name.as_os_str(), Vec::new()) {
Ok(target) => target,
Err(rustix::io::Errno::INVAL) => return self.retake(name),
Err(e) => return Err(self.fail(e.into())),
};
let target = target.as_bytes();
if target.starts_with(b"/") {
self.current = openat(
CWD,
"/",
OFlags::RDONLY | OFlags::DIRECTORY | OFlags::CLOEXEC,
Mode::empty(),
)
.map_err(|e| self.fail(e.into()))?;
self.ancestors.clear();
self.current_status = fstat(&self.current).map_err(|e| self.fail(e.into()))?;
self.inside = self.root().is(&self.current_status);
}
for step in steps(target).into_iter().rev() {
self.queue.push_front(step);
}
Ok(())
}
fn name(&mut self, name: OsString, want: Want) -> Result<Option<Walked>, TreeError> {
let last = self.queue.is_empty();
if last && !self.inside {
return Err(outside(self.shown));
}
let directory = !last || want != Want::File;
let mut flags = OFlags::RDONLY | OFlags::NOFOLLOW | OFlags::CLOEXEC | OFlags::NONBLOCK;
if directory {
flags |= OFlags::DIRECTORY;
}
#[cfg(test)]
self.tree.note_open(flags.bits());
match openat(&self.current, name.as_os_str(), flags, Mode::empty()) {
Ok(_) if last && self.final_link => Err(not_regular(self.shown)),
Ok(opened) if last => {
let parent = if want == Want::File {
let directory = self
.current
.try_clone()
.map_err(|e| TreeError::from_io(self.shown, e))?;
Some((directory, name))
} else {
None
};
Ok(Some((opened, parent)))
}
Ok(opened) => self.descend(opened).map(|()| None),
Err(error) => {
hook!(self.tree, mid_step);
let status = statat(&self.current, name.as_os_str(), AtFlags::SYMLINK_NOFOLLOW)
.map_err(|e| self.fail(e.into()))?;
let kind = FileType::from_raw_mode(status.st_mode);
if kind != FileType::Symlink {
if changed(error, kind, directory) {
return self.retake(name).map(|()| None);
}
if last && directory && error == rustix::io::Errno::NOTDIR {
return Err(not_regular(self.shown));
}
return Err(self.fail(error.into()));
}
self.final_link |= last && want == Want::Listing;
self.follow(name).map(|()| None)
}
}
}
}
fn changed(error: rustix::io::Errno, kind: FileType, directory: bool) -> bool {
use rustix::io::Errno;
match error {
Errno::LOOP | Errno::MLINK | Errno::NOENT => true,
Errno::NOTDIR => directory && kind == FileType::Directory,
_ => false,
}
}
fn walk(tree: &DiskTree, path: &RelPath, want: Want, shown: &str) -> Result<Walked, TreeError> {
let root = &tree.root_directory;
let current = root
.dir
.try_clone()
.map_err(|e| TreeError::from_io(shown, e))?;
let current_status = fstat(¤t).map_err(|e| TreeError::from_io(shown, e.into()))?;
let mut walk = Walk {
tree,
shown,
current,
current_status,
ancestors: Vec::new(),
inside: true,
queue: steps(path.as_str().as_bytes()).into(),
hops: 0,
final_link: false,
};
while let Some(step) = walk.queue.pop_front() {
match step {
Step::Up => walk.up()?,
Step::Name(name) => {
if let Some(walked) = walk.name(name, want)? {
return Ok(walked);
}
}
}
}
if !walk.inside {
Err(outside(shown))
} else if walk.final_link {
Err(not_regular(shown))
} else {
Ok((walk.current, None))
}
}
fn kind_of(file_type: FileType) -> EntryKind {
match file_type {
FileType::Symlink => EntryKind::Symlink,
FileType::Directory => EntryKind::Dir,
FileType::RegularFile => EntryKind::File,
_ => EntryKind::Other,
}
}
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> {
let io = |e: rustix::io::Errno| TreeError::from_io(shown, e.into());
let before = statat(&self.file, name, AtFlags::SYMLINK_NOFOLLOW).map_err(io)?;
if FileType::from_raw_mode(before.st_mode) != FileType::Symlink {
return Err(not_regular(shown));
}
let target = readlinkat(&self.file, name, Vec::new()).map_err(io)?;
between();
let repeated = readlinkat(&self.file, name, Vec::new()).map_err(io)?;
let after = statat(&self.file, name, AtFlags::SYMLINK_NOFOLLOW).map_err(io)?;
if !same(&before, &after) || before.st_mode != after.st_mode || target != repeated {
return Err(super::capture::changed(shown));
}
Ok((
FileId::from_device(after.st_dev, after.st_ino),
PathBuf::from(OsStr::from_bytes(target.to_bytes())),
))
}
#[expect(
clippy::unnecessary_wraps,
reason = "the signature is shared with Windows, where the identity can fail"
)]
pub(super) fn identity(&self, _root: &Path, _shown: &str) -> Result<FileId, TreeError> {
Ok(device_identity(&self.metadata))
}
pub(super) fn recheck(&self, root: &Root, shown: &str) -> Result<(), TreeError> {
let start = match &self.parent {
Some((parent, name)) => {
let found = statat(parent, name.as_os_str(), AtFlags::SYMLINK_NOFOLLOW)
.map_err(|_| outside(shown))?;
let held = fstat(&self.file).map_err(|_| outside(shown))?;
if !same(&found, &held) {
return Err(outside(shown));
}
parent.try_clone()
}
None => self.file.try_clone().map(OwnedFd::from),
}
.map_err(|e| TreeError::from_io(shown, e))?;
climb(start, root, shown)
}
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> {
let io = |e: rustix::io::Errno| TreeError::from_io(shown, e.into());
let mut listing = Dir::read_from(&self.file).map_err(io)?;
let mut entries = Vec::new();
while let Some(item) = listing.read() {
let item = item.map_err(io)?;
let raw = item.file_name();
let bytes = raw.to_bytes();
if bytes == b"." || bytes == b".." {
continue;
}
super::entry_room(entries.len(), max_entries, shown)?;
let name = std::str::from_utf8(bytes).map_err(|_| TreeError::NonUtf8Name {
path: shown.to_owned(),
name: String::from_utf8_lossy(bytes).into_owned(),
})?;
let file_type = match item.file_type() {
FileType::Unknown => FileType::from_raw_mode(
statat(&self.file, raw, AtFlags::SYMLINK_NOFOLLOW)
.map_err(io)?
.st_mode,
),
known => known,
};
entries.push(Entry {
name: name.to_owned(),
kind: kind_of(file_type),
});
}
Ok(entries)
}
pub(super) fn lookup(&self, name: &str, shown: &str) -> Result<Option<EntryKind>, TreeError> {
match statat(&self.file, name, AtFlags::SYMLINK_NOFOLLOW) {
Ok(status) => Ok(Some(kind_of(FileType::from_raw_mode(status.st_mode)))),
Err(rustix::io::Errno::NOENT | rustix::io::Errno::NOTDIR) => Ok(None),
Err(e) => Err(TreeError::from_io(shown, e.into())),
}
}
}