use std::path::{Component, Path, PathBuf};
use std::sync::atomic::{AtomicBool, Ordering};
use super::authority::AuthorityRefusal;
static NEXT_ROOT: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(1);
static NEXT_TEMP: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(1);
const MAX_TEMP_ATTEMPTS: u32 = 16;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct PhysicalRootIdentity(std::num::NonZeroU64);
impl PhysicalRootIdentity {
pub fn fresh() -> Self {
let raw = NEXT_ROOT.fetch_add(1, Ordering::Relaxed);
Self(std::num::NonZeroU64::new(raw).expect("root counter starts at 1"))
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum RootRefusal {
LeaseRevoked,
EscapesRoot {
requested: PathBuf,
},
LinkComponent {
component: PathBuf,
},
Unreadable {
path: PathBuf,
message: String,
},
}
impl From<RootRefusal> for AuthorityRefusal {
fn from(_: RootRefusal) -> Self {
AuthorityRefusal::PhysicalRootReplaced
}
}
#[derive(Debug)]
pub struct PhysicalRootLease {
identity: PhysicalRootIdentity,
root: PathBuf,
revoked: AtomicBool,
}
impl PhysicalRootLease {
pub fn take(root: impl Into<PathBuf>) -> Self {
Self {
identity: PhysicalRootIdentity::fresh(),
root: root.into(),
revoked: AtomicBool::new(false),
}
}
pub fn identity(&self) -> PhysicalRootIdentity {
self.identity
}
pub fn root(&self) -> &Path {
&self.root
}
pub fn is_live(&self) -> bool {
!self.revoked.load(Ordering::Acquire)
}
pub fn revoke(&self) {
self.revoked.store(true, Ordering::Release);
}
pub fn resolve_beneath(&self, relative: &Path) -> Result<ResolvedTarget, RootRefusal> {
if !self.is_live() {
return Err(RootRefusal::LeaseRevoked);
}
let mut components = Vec::new();
for component in relative.components() {
match component {
Component::Normal(part) => components.push(part.to_os_string()),
Component::CurDir => {}
Component::ParentDir | Component::RootDir | Component::Prefix(_) => {
return Err(RootRefusal::EscapesRoot {
requested: relative.to_path_buf(),
});
}
}
}
let Some((leaf, parents)) = components.split_last() else {
return Err(RootRefusal::EscapesRoot {
requested: relative.to_path_buf(),
});
};
let mut parent = self.root.clone();
for part in parents {
parent.push(part);
self.refuse_link(&parent)?;
}
Ok(ResolvedTarget {
parent,
leaf: leaf.clone(),
})
}
fn refuse_link(&self, path: &Path) -> Result<(), RootRefusal> {
match std::fs::symlink_metadata(path) {
Ok(metadata) => {
if metadata.file_type().is_symlink()
|| crate::paths::metadata_is_reparse_point(&metadata)
{
Err(RootRefusal::LinkComponent {
component: path.to_path_buf(),
})
} else {
Ok(())
}
}
Err(error) if error.kind() == std::io::ErrorKind::NotFound => Ok(()),
Err(error) => Err(RootRefusal::Unreadable {
path: path.to_path_buf(),
message: error.to_string(),
}),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ResolvedTarget {
parent: PathBuf,
leaf: std::ffi::OsString,
}
impl ResolvedTarget {
pub fn parent(&self) -> &Path {
&self.parent
}
pub fn leaf(&self) -> &std::ffi::OsStr {
&self.leaf
}
pub fn path(&self) -> PathBuf {
self.parent.join(&self.leaf)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ReplacementStep {
TempCreated,
Replaced,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct WriteReceipt {
steps: Vec<ReplacementStep>,
target: PathBuf,
lease: PhysicalRootIdentity,
}
impl WriteReceipt {
pub fn steps(&self) -> &[ReplacementStep] {
&self.steps
}
pub fn target(&self) -> &Path {
&self.target
}
pub fn lease(&self) -> PhysicalRootIdentity {
self.lease
}
}
pub fn replace_beneath(
lease: &PhysicalRootLease,
relative: &Path,
contents: &[u8],
) -> Result<WriteReceipt, RootRefusal> {
let target = lease.resolve_beneath(relative)?;
lease.refuse_link(&target.path())?;
let mut steps = Vec::new();
if let Some(parent) = target.path().parent() {
std::fs::create_dir_all(parent).map_err(|error| RootRefusal::Unreadable {
path: parent.to_path_buf(),
message: error.to_string(),
})?;
}
let mut temp_path = PathBuf::new();
let mut file = None;
for attempt in 0..MAX_TEMP_ATTEMPTS {
let mut name = target.leaf().to_os_string();
name.push(format!(
".symforge-tmp-{}-{}-{attempt}",
std::process::id(),
NEXT_TEMP.fetch_add(1, Ordering::Relaxed)
));
let candidate = target.parent().join(&name);
match std::fs::OpenOptions::new()
.write(true)
.create_new(true)
.open(&candidate)
{
Ok(handle) => {
temp_path = candidate;
file = Some(handle);
break;
}
Err(error) if error.kind() == std::io::ErrorKind::AlreadyExists => continue,
Err(error) => {
return Err(RootRefusal::Unreadable {
path: candidate,
message: error.to_string(),
});
}
}
}
let Some(mut handle) = file else {
return Err(RootRefusal::Unreadable {
path: target.parent().to_path_buf(),
message: "no unused temporary name was available beneath the leased root".to_owned(),
});
};
let written = std::io::Write::write_all(&mut handle, contents).and_then(|()| handle.sync_all());
drop(handle);
if let Err(error) = written {
let _ = std::fs::remove_file(&temp_path);
return Err(RootRefusal::Unreadable {
path: temp_path,
message: error.to_string(),
});
}
steps.push(ReplacementStep::TempCreated);
if let Err(error) = std::fs::rename(&temp_path, target.path()) {
let _ = std::fs::remove_file(&temp_path);
return Err(RootRefusal::Unreadable {
path: target.path(),
message: error.to_string(),
});
}
steps.push(ReplacementStep::Replaced);
Ok(WriteReceipt {
steps,
target: target.path(),
lease: lease.identity(),
})
}