Skip to main content

hyprstream_containedfs/
canonical_root.rs

1//! Canonicalize-based path containment (cross-platform fallback).
2//!
3//! Uses `fs::canonicalize` + prefix check for path containment.
4//! This is TOCTOU-vulnerable but functional for development/macOS.
5
6use crate::error::FsError;
7use crate::path::validate_relative_path;
8use crate::types::{DirEntry, FsHandle, OpenMode, Stat};
9use crate::ContainedFs;
10use std::fs::{self, File};
11use std::path::{Path, PathBuf};
12use std::sync::Arc;
13
14/// Canonicalize-based path containment (non-Linux fallback).
15///
16/// Uses `fs::canonicalize` + prefix check. TOCTOU-vulnerable but
17/// acceptable for development/macOS.
18pub struct CanonicalRoot {
19    root: PathBuf,
20}
21
22impl CanonicalRoot {
23    /// Create a new CanonicalRoot for the given root path.
24    #[allow(clippy::new_ret_no_self)]
25    pub fn new(path: &Path) -> Result<Arc<dyn ContainedFs>, FsError> {
26        let root = fs::canonicalize(path).map_err(FsError::Io)?;
27        Ok(Arc::new(Self { root }))
28    }
29
30    /// Validate and resolve a relative path within the root.
31    fn resolve(&self, relative: &str) -> Result<PathBuf, FsError> {
32        let validated = validate_relative_path(relative)?;
33        let full = self.root.join(&validated);
34        // Try to canonicalize; if the file doesn't exist yet, check the parent
35        let resolved = if full.exists() {
36            fs::canonicalize(&full).map_err(FsError::Io)?
37        } else {
38            // For non-existent files, canonicalize the parent and append the filename
39            if let Some(parent) = full.parent() {
40                if parent.exists() {
41                    let canonical_parent = fs::canonicalize(parent).map_err(FsError::Io)?;
42                    if !canonical_parent.starts_with(&self.root) {
43                        return Err(FsError::path_escape("escaped root via parent"));
44                    }
45                    canonical_parent.join(full.file_name().unwrap_or_default())
46                } else {
47                    full
48                }
49            } else {
50                full
51            }
52        };
53        if !resolved.starts_with(&self.root) {
54            return Err(FsError::path_escape("escaped root"));
55        }
56        Ok(resolved)
57    }
58}
59
60impl ContainedFs for CanonicalRoot {
61    fn walk(&self, path: &str) -> Result<FsHandle, FsError> {
62        let resolved = self.resolve(path)?;
63        Ok(FsHandle::from_path(resolved, path.to_owned()))
64    }
65
66    fn open(&self, path: &str, mode: OpenMode) -> Result<File, FsError> {
67        let resolved = self.resolve(path)?;
68        mode.to_open_options().open(&resolved).map_err(FsError::Io)
69    }
70
71    fn create(&self, path: &str, mode: OpenMode) -> Result<File, FsError> {
72        let resolved = self.resolve(path)?;
73        mode.to_create_options().open(&resolved).map_err(|e| {
74            if e.kind() == std::io::ErrorKind::AlreadyExists {
75                FsError::AlreadyExists(path.to_owned())
76            } else {
77                FsError::Io(e)
78            }
79        })
80    }
81
82    fn mkdir(&self, path: &str) -> Result<(), FsError> {
83        let resolved = self.resolve(path)?;
84        fs::create_dir(&resolved).map_err(|e| {
85            if e.kind() == std::io::ErrorKind::AlreadyExists {
86                FsError::AlreadyExists(path.to_owned())
87            } else {
88                FsError::Io(e)
89            }
90        })
91    }
92
93    fn mkdir_all(&self, path: &str) -> Result<(), FsError> {
94        let resolved = self.resolve(path)?;
95        fs::create_dir_all(&resolved).map_err(FsError::Io)
96    }
97
98    fn stat(&self, path: &str) -> Result<Stat, FsError> {
99        let resolved = self.resolve(path)?;
100        let meta = fs::metadata(&resolved).map_err(FsError::Io)?;
101        let name = Path::new(path)
102            .file_name()
103            .map(|n| n.to_string_lossy().to_string())
104            .unwrap_or_default();
105        Ok(Stat::from_metadata(&meta, name))
106    }
107
108    fn rename(&self, src: &str, dst: &str) -> Result<(), FsError> {
109        let src_path = self.resolve(src)?;
110        let dst_path = self.resolve(dst)?;
111        fs::rename(&src_path, &dst_path).map_err(FsError::Io)
112    }
113
114    fn remove(&self, path: &str) -> Result<(), FsError> {
115        let resolved = self.resolve(path)?;
116        if resolved.is_dir() {
117            fs::remove_dir(&resolved).map_err(FsError::Io)
118        } else {
119            fs::remove_file(&resolved).map_err(FsError::Io)
120        }
121    }
122
123    fn readdir(&self, path: &str) -> Result<Vec<DirEntry>, FsError> {
124        let resolved = self.resolve(path)?;
125        let mut entries = Vec::new();
126        for entry in fs::read_dir(&resolved).map_err(FsError::Io)? {
127            let entry = entry.map_err(FsError::Io)?;
128            let name = entry.file_name().to_string_lossy().to_string();
129            if name == "." || name == ".." {
130                continue;
131            }
132            let meta = entry.metadata().map_err(FsError::Io)?;
133            entries.push(DirEntry {
134                name,
135                is_dir: meta.is_dir(),
136                size: meta.len(),
137            });
138        }
139        Ok(entries)
140    }
141
142    fn copy(&self, src: &str, dst: &str) -> Result<(), FsError> {
143        let src_path = self.resolve(src)?;
144        let dst_path = self.resolve(dst)?;
145        reflink_copy::reflink_or_copy(&src_path, &dst_path)
146            .map(|_| ())
147            .map_err(|e| FsError::Io(std::io::Error::other(e)))
148    }
149}