use std::path::{Path, PathBuf};
use std::sync::atomic::{AtomicU64, Ordering};
use crate::{Error, Result};
pub const OUTPUT_IS_INPUT: &str = "raw files are never modified";
pub fn same_file(a: &Path, b: &Path) -> bool {
if a == b || real_path(a) == real_path(b) {
return true;
}
#[cfg(unix)]
if let (Ok(ma), Ok(mb)) = (std::fs::metadata(a), std::fs::metadata(b)) {
use std::os::unix::fs::MetadataExt;
return ma.dev() == mb.dev() && ma.ino() == mb.ino();
}
false
}
pub fn real_path(p: &Path) -> PathBuf {
let abs = std::path::absolute(p).unwrap_or_else(|_| p.to_path_buf());
let mut base = abs.as_path();
let mut rest = Vec::new();
loop {
if let Ok(real) = std::fs::canonicalize(base) {
let mut out = real;
for c in rest.iter().rev() {
match c {
std::path::Component::ParentDir => {
out.pop();
}
std::path::Component::CurDir => {}
c => out.push(c),
}
}
return out;
}
match (base.parent(), base.components().next_back()) {
(Some(parent), Some(last)) => {
rest.push(last);
base = parent;
}
_ => return abs,
}
}
}
fn inside(output: &Path, dir: &Path) -> bool {
if !dir.is_dir() || !output.exists() {
return false;
}
matches!(
(std::fs::canonicalize(output), std::fs::canonicalize(dir)),
(Ok(o), Ok(d)) if o.starts_with(&d)
)
}
pub fn refuse_inputs<'a, I>(output: &Path, inputs: I) -> Result<()>
where
I: IntoIterator<Item = &'a Path>,
{
for input in inputs {
if same_file(output, input) || inside(output, input) {
return Err(Error::Usage(format!(
"output {} is the input file {}; {OUTPUT_IS_INPUT}",
output.display(),
input.display()
)));
}
}
Ok(())
}
pub fn refuse_dataset(output: &Path, input: &Path, ds: &dyn crate::Dataset) -> Result<()> {
let members = ds.member_files();
refuse_inputs(
output,
std::iter::once(input).chain(members.iter().map(PathBuf::as_path)),
)
}
pub fn temp_path(path: &Path) -> PathBuf {
static NEXT: AtomicU64 = AtomicU64::new(0);
let n = NEXT.fetch_add(1, Ordering::Relaxed);
let name = path
.file_name()
.map_or_else(|| "out".into(), |n| n.to_string_lossy().into_owned());
path.with_file_name(format!(".{name}.tmp-{}-{n}", std::process::id()))
}
pub fn write_verified(path: &Path, bytes: &[u8], overwrite: bool, inputs: &[&Path]) -> Result<()> {
refuse_inputs(path, inputs.iter().copied())?;
if path.exists() && !overwrite {
return Err(Error::Usage(format!(
"{} exists; pass --overwrite to replace it",
path.display()
)));
}
if let Some(parent) = path.parent().filter(|p| !p.as_os_str().is_empty()) {
std::fs::create_dir_all(parent).map_err(|e| Error::io(parent, e))?;
}
let tmp = temp_path(path);
let result = (|| {
std::fs::write(&tmp, bytes).map_err(|e| Error::io(&tmp, e))?;
let back = std::fs::read(&tmp).map_err(|e| Error::io(&tmp, e))?;
if back != bytes {
return Err(Error::Other(format!(
"{}: read-back differs from what was written",
tmp.display()
)));
}
std::fs::rename(&tmp, path).map_err(|e| Error::io(path, e))
})();
if result.is_err() {
let _ = std::fs::remove_file(&tmp);
}
result
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn the_input_is_refused_however_it_is_spelled() {
let d = tempfile::tempdir().unwrap();
let data = d.path().join("data");
std::fs::create_dir(&data).unwrap();
let input = data.join("x.ome.tiff");
std::fs::write(&input, b"raw").unwrap();
let dotted = d.path().join("data/../data/x.ome.tiff");
let dot = d.path().join("data/./x.ome.tiff");
let missing = d.path().join("data/new/../x.ome.tiff");
for out in [&input, &dotted, &dot, &missing] {
let e = refuse_inputs(out, [input.as_path()]).unwrap_err();
assert_eq!(e.exit_code(), 2, "{}", out.display());
assert!(e.to_string().contains(OUTPUT_IS_INPUT));
}
#[cfg(unix)]
{
let link = d.path().join("link.tiff");
std::os::unix::fs::symlink(&input, &link).unwrap();
let hard = d.path().join("hard.tiff");
std::fs::hard_link(&input, &hard).unwrap();
assert!(refuse_inputs(&link, [input.as_path()]).is_err());
assert!(refuse_inputs(&hard, [input.as_path()]).is_err());
}
let other = data.join("x.png");
refuse_inputs(&other, [input.as_path()]).unwrap();
assert_eq!(
real_path(&d.path().join("data/new/../x.ome.tiff")),
std::fs::canonicalize(&input).unwrap()
);
refuse_inputs(&other, [data.as_path()]).unwrap();
assert!(refuse_inputs(&input, [data.as_path()]).is_err());
assert!(write_verified(&dotted, b"new", true, &[&input]).is_err());
assert_eq!(std::fs::read(&input).unwrap(), b"raw");
}
#[test]
fn writes_through_unique_temporary_files() {
let d = tempfile::tempdir().unwrap();
let p = d.path().join("sub/out.csv");
assert_ne!(temp_path(&p), temp_path(&p));
write_verified(&p, b"a,b\n", false, &[]).unwrap();
assert_eq!(std::fs::read(&p).unwrap(), b"a,b\n");
assert!(write_verified(&p, b"x", false, &[]).is_err());
write_verified(&p, b"x", true, &[]).unwrap();
let names: Vec<_> = std::fs::read_dir(d.path().join("sub"))
.unwrap()
.map(|e| e.unwrap().file_name())
.collect();
assert_eq!(names.len(), 1, "{names:?}");
}
}