fixes PR004

This commit is contained in:
2026-03-24 13:40:46 +00:00
parent 384587bb04
commit 5ec270dd43
3 changed files with 206 additions and 17 deletions
@@ -5,6 +5,7 @@ pub enum FsError {
NotFound,
AlreadyExists,
PermissionDenied,
InvalidPath(String),
NotMounted,
IOError(String),
Other(String),
@@ -16,6 +17,7 @@ impl fmt::Display for FsError {
FsError::NotFound => write!(f, "File or directory not found"),
FsError::AlreadyExists => write!(f, "Already exists"),
FsError::PermissionDenied => write!(f, "Permission denied"),
FsError::InvalidPath(s) => write!(f, "Invalid path: {}", s),
FsError::NotMounted => write!(f, "Filesystem not mounted"),
FsError::IOError(s) => write!(f, "IO Error: {}", s),
FsError::Other(s) => write!(f, "Error: {}", s),
@@ -34,40 +34,63 @@ impl VirtualFS {
self.backend.is_some()
}
fn normalize_path(&self, path: &str) -> String {
fn normalize_path(path: &str) -> Result<String, FsError> {
let mut normalized = path.replace('\\', "/");
if !normalized.starts_with('/') {
normalized = format!("/{}", normalized);
}
normalized
let mut segments = Vec::new();
for segment in normalized.split('/') {
match segment {
"" | "." => continue,
".." => {
return Err(FsError::InvalidPath(
"parent traversal '..' is not allowed".to_string(),
));
}
_ => segments.push(segment),
}
}
if segments.is_empty() {
Ok("/".to_string())
} else {
Ok(format!("/{}", segments.join("/")))
}
}
pub fn list_dir(&self, path: &str) -> Result<Vec<FsEntry>, FsError> {
let normalized = self.normalize_path(path);
let normalized = Self::normalize_path(path)?;
let backend = self.backend.as_ref().ok_or(FsError::NotMounted)?;
backend.list_dir(&normalized)
}
pub fn read_file(&self, path: &str) -> Result<Vec<u8>, FsError> {
let normalized = self.normalize_path(path);
let normalized = Self::normalize_path(path)?;
let backend = self.backend.as_ref().ok_or(FsError::NotMounted)?;
backend.read_file(&normalized)
}
pub fn write_file(&mut self, path: &str, data: &[u8]) -> Result<(), FsError> {
let normalized = self.normalize_path(path);
let normalized = Self::normalize_path(path)?;
let backend = self.backend.as_mut().ok_or(FsError::NotMounted)?;
backend.write_file(&normalized, data)
}
pub fn delete(&mut self, path: &str) -> Result<(), FsError> {
let normalized = self.normalize_path(path);
let normalized = Self::normalize_path(path)?;
if normalized == "/" {
return Err(FsError::PermissionDenied);
}
let backend = self.backend.as_mut().ok_or(FsError::NotMounted)?;
backend.delete(&normalized)
}
pub fn exists(&self, path: &str) -> bool {
let normalized = self.normalize_path(path);
let Ok(normalized) = Self::normalize_path(path) else {
return false;
};
self.backend.as_ref().map(|b| b.exists(&normalized)).unwrap_or(false)
}
@@ -80,15 +103,31 @@ impl VirtualFS {
mod tests {
use super::*;
use std::collections::HashMap;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::Arc;
#[derive(Default)]
struct CallCounters {
list_dir: AtomicUsize,
read_file: AtomicUsize,
write_file: AtomicUsize,
delete: AtomicUsize,
exists: AtomicUsize,
}
struct MockBackend {
files: HashMap<String, Vec<u8>>,
healthy: bool,
calls: Arc<CallCounters>,
}
impl MockBackend {
fn new() -> Self {
Self { files: HashMap::new(), healthy: true }
Self::with_calls(Arc::new(CallCounters::default()))
}
fn with_calls(calls: Arc<CallCounters>) -> Self {
Self { files: HashMap::new(), healthy: true, calls }
}
}
@@ -98,6 +137,7 @@ mod tests {
}
fn unmount(&mut self) {}
fn list_dir(&self, _path: &str) -> Result<Vec<FsEntry>, FsError> {
self.calls.list_dir.fetch_add(1, Ordering::Relaxed);
Ok(self
.files
.keys()
@@ -105,17 +145,21 @@ mod tests {
.collect())
}
fn read_file(&self, path: &str) -> Result<Vec<u8>, FsError> {
self.calls.read_file.fetch_add(1, Ordering::Relaxed);
self.files.get(path).cloned().ok_or(FsError::NotFound)
}
fn write_file(&mut self, path: &str, data: &[u8]) -> Result<(), FsError> {
self.calls.write_file.fetch_add(1, Ordering::Relaxed);
self.files.insert(path.to_string(), data.to_vec());
Ok(())
}
fn delete(&mut self, path: &str) -> Result<(), FsError> {
self.calls.delete.fetch_add(1, Ordering::Relaxed);
self.files.remove(path);
Ok(())
}
fn exists(&self, path: &str) -> bool {
self.calls.exists.fetch_add(1, Ordering::Relaxed);
self.files.contains_key(path)
}
fn is_healthy(&self) -> bool {
@@ -152,4 +196,44 @@ mod tests {
vfs.mount(Box::new(backend)).unwrap();
assert!(!vfs.is_healthy());
}
#[test]
fn test_normalize_path_rejects_parent_traversal() {
for path in ["../x", "/../x", "/user/../../x", "\\user\\..\\..\\x"] {
let error = VirtualFS::normalize_path(path).unwrap_err();
assert!(matches!(error, FsError::InvalidPath(_)));
}
}
#[test]
fn test_invalid_paths_never_reach_backend() {
let calls = Arc::new(CallCounters::default());
let mut vfs = VirtualFS::new();
vfs.mount(Box::new(MockBackend::with_calls(calls.clone()))).unwrap();
assert!(matches!(vfs.read_file("../secret.txt"), Err(FsError::InvalidPath(_))));
assert!(matches!(
vfs.write_file("/user/../../secret.txt", b"nope"),
Err(FsError::InvalidPath(_))
));
assert!(matches!(vfs.delete("\\user\\..\\secret.txt"), Err(FsError::InvalidPath(_))));
assert!(matches!(vfs.list_dir("/../"), Err(FsError::InvalidPath(_))));
assert!(!vfs.exists("../x"));
assert_eq!(calls.read_file.load(Ordering::Relaxed), 0);
assert_eq!(calls.write_file.load(Ordering::Relaxed), 0);
assert_eq!(calls.delete.load(Ordering::Relaxed), 0);
assert_eq!(calls.list_dir.load(Ordering::Relaxed), 0);
assert_eq!(calls.exists.load(Ordering::Relaxed), 0);
}
#[test]
fn test_delete_root_is_rejected_before_backend() {
let calls = Arc::new(CallCounters::default());
let mut vfs = VirtualFS::new();
vfs.mount(Box::new(MockBackend::with_calls(calls.clone()))).unwrap();
assert!(matches!(vfs.delete("/"), Err(FsError::PermissionDenied)));
assert_eq!(calls.delete.load(Ordering::Relaxed), 0);
}
}