75 lines
2.5 KiB
Rust
75 lines
2.5 KiB
Rust
use std::{io, path::{Path, PathBuf}};
|
|
use sha2::{Sha256, Digest};
|
|
use klog_types::FileInfo;
|
|
|
|
pub fn files_root(data_dir: &Path) -> PathBuf {
|
|
data_dir.join("files")
|
|
}
|
|
|
|
pub fn validate_filename(name: &str) -> bool {
|
|
!name.is_empty()
|
|
&& name != "."
|
|
&& name != ".."
|
|
&& !name.contains('/')
|
|
&& !name.contains('\\')
|
|
&& !name.contains('\0')
|
|
}
|
|
|
|
pub async fn list_all_files(data_dir: &Path) -> io::Result<Vec<FileInfo>> {
|
|
let root = files_root(data_dir);
|
|
let mut result = Vec::new();
|
|
|
|
let mut user_dirs = match tokio::fs::read_dir(&root).await {
|
|
Ok(d) => d,
|
|
Err(e) if e.kind() == io::ErrorKind::NotFound => return Ok(result),
|
|
Err(e) => return Err(e),
|
|
};
|
|
|
|
while let Some(user_entry) = user_dirs.next_entry().await? {
|
|
if !user_entry.file_type().await?.is_dir() {
|
|
continue;
|
|
}
|
|
let username = user_entry.file_name().to_string_lossy().to_string();
|
|
let user_dir = root.join(&username);
|
|
|
|
let mut files = tokio::fs::read_dir(&user_dir).await?;
|
|
while let Some(file_entry) = files.next_entry().await? {
|
|
if !file_entry.file_type().await?.is_file() {
|
|
continue;
|
|
}
|
|
let filename = file_entry.file_name().to_string_lossy().to_string();
|
|
let path = user_dir.join(&filename);
|
|
let sha256 = hash_file(&path).await?;
|
|
result.push(FileInfo { username: username.clone(), filename, sha256 });
|
|
}
|
|
}
|
|
|
|
Ok(result)
|
|
}
|
|
|
|
pub async fn hash_file(path: &Path) -> io::Result<String> {
|
|
let data = tokio::fs::read(path).await?;
|
|
let mut hasher = Sha256::new();
|
|
hasher.update(&data);
|
|
Ok(hex::encode(hasher.finalize()))
|
|
}
|
|
|
|
pub async fn read_file(data_dir: &Path, username: &str, filename: &str) -> io::Result<Vec<u8>> {
|
|
tokio::fs::read(files_root(data_dir).join(username).join(filename)).await
|
|
}
|
|
|
|
pub async fn write_file(data_dir: &Path, username: &str, filename: &str, data: &[u8]) -> io::Result<()> {
|
|
let dir = files_root(data_dir).join(username);
|
|
tokio::fs::create_dir_all(&dir).await?;
|
|
tokio::fs::write(dir.join(filename), data).await
|
|
}
|
|
|
|
pub async fn delete_file(data_dir: &Path, username: &str, filename: &str) -> io::Result<bool> {
|
|
let path = files_root(data_dir).join(username).join(filename);
|
|
match tokio::fs::remove_file(&path).await {
|
|
Ok(()) => Ok(true),
|
|
Err(e) if e.kind() == io::ErrorKind::NotFound => Ok(false),
|
|
Err(e) => Err(e),
|
|
}
|
|
}
|