use std::path::{Path, PathBuf};
use std::sync::Arc;
use mlua::ExternalResult as _;
use nitr_std::validation::{
Detection, FileInfo, SNIFF_BYTES, SaveResolver, detect, dimensions, text_subtype_matches,
};
use crate::multipart::{resolve_upload_path, safe_filename};
pub(crate) const SPOOL_DIR: &str = ".nitr-tmp";
pub(crate) fn sweep(upload_root: &Path) {
let dir = upload_root.join(SPOOL_DIR);
match std::fs::remove_dir_all(&dir) {
Ok(()) => tracing::info!("removed stale upload spool {}", dir.display()),
Err(err) if err.kind() == std::io::ErrorKind::NotFound => {}
Err(err) => tracing::warn!("cannot remove the upload spool {}: {err}", dir.display()),
}
}
pub(crate) struct SpoolDir {
path: PathBuf,
}
impl SpoolDir {
pub(crate) fn new(upload_root: &Path) -> Self {
let name = uuid::Uuid::now_v7().simple().to_string();
Self {
path: upload_root.join(SPOOL_DIR).join(name),
}
}
pub(crate) fn path(&self) -> &Path {
&self.path
}
}
impl Drop for SpoolDir {
fn drop(&mut self) {
let path = self.path.clone();
match tokio::runtime::Handle::try_current() {
Ok(handle) => {
handle.spawn_blocking(move || {
let _ = std::fs::remove_dir_all(path);
});
}
Err(_) => {
let _ = std::fs::remove_dir_all(path);
}
}
}
}
struct Utf8Tracker {
valid: bool,
carry: Vec<u8>,
}
impl Utf8Tracker {
fn new() -> Self {
Self {
valid: true,
carry: Vec::new(),
}
}
fn push(&mut self, chunk: &[u8]) {
if !self.valid {
return;
}
let mut buf = std::mem::take(&mut self.carry);
buf.extend_from_slice(chunk);
match std::str::from_utf8(&buf) {
Ok(_) => {}
Err(err) if err.error_len().is_none() => {
self.carry = buf[err.valid_up_to()..].to_vec();
}
Err(_) => self.valid = false,
}
}
fn finish(self) -> bool {
self.valid && self.carry.is_empty()
}
}
pub(crate) struct Spooler {
file: tokio::fs::File,
path: PathBuf,
cap: u64,
size: u64,
prefix: Vec<u8>,
utf8: Utf8Tracker,
}
impl Spooler {
pub(crate) async fn create(dir: &Path, index: usize, cap: u64) -> mlua::Result<Self> {
tokio::fs::create_dir_all(dir).await.into_lua_err()?;
let path = dir.join(index.to_string());
let file = tokio::fs::OpenOptions::new()
.write(true)
.create_new(true)
.open(&path)
.await
.into_lua_err()?;
Ok(Self {
file,
path,
cap,
size: 0,
prefix: Vec::with_capacity(SNIFF_BYTES.min(8 * 1024)),
utf8: Utf8Tracker::new(),
})
}
pub(crate) async fn push(&mut self, chunk: &[u8]) -> mlua::Result<()> {
use tokio::io::AsyncWriteExt as _;
if self.prefix.len() < SNIFF_BYTES {
let take = (SNIFF_BYTES - self.prefix.len()).min(chunk.len());
self.prefix.extend_from_slice(&chunk[..take]);
}
self.utf8.push(chunk);
self.size = self.size.saturating_add(chunk.len() as u64);
if self.size <= self.cap {
self.file.write_all(chunk).await.into_lua_err()?;
}
Ok(())
}
pub(crate) async fn finish(
mut self,
filename: Option<String>,
declared_type: Option<String>,
) -> mlua::Result<(PathBuf, FileInfo)> {
use tokio::io::AsyncWriteExt as _;
self.file.flush().await.into_lua_err()?;
let detected = detect(&self.prefix);
let (width, height) = match detected {
Detection::Detected(media) if media.has_dimensions() => {
dimensions(media, &self.prefix).map_or((None, None), |(w, h)| (Some(w), Some(h)))
}
_ => (None, None),
};
let text_subtype_ok = declared_type
.as_deref()
.is_some_and(|d| text_subtype_matches(d, &self.prefix));
let safe = filename.as_deref().map(safe_filename);
let extension = safe.as_deref().and_then(|name| {
name.rsplit_once('.')
.map(|(_, ext)| ext.to_ascii_lowercase())
.filter(|ext| !ext.is_empty())
});
let info = FileInfo {
filename,
safe_filename: safe,
extension,
declared_type,
detected,
text_subtype_ok,
size: self.size,
cap: self.cap,
width,
height,
utf8: Some(self.utf8.finish()),
};
Ok((self.path, info))
}
pub(crate) fn size(&self) -> u64 {
self.size
}
}
pub(crate) fn resolver(root: Arc<PathBuf>) -> SaveResolver {
Arc::new(move |rel: String| {
let root = root.clone();
Box::pin(async move { resolve_upload_path(&root, &rel).await })
})
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn utf8_is_tracked_across_chunk_boundaries() {
let bytes = "caf\u{e9} ok".as_bytes();
let mut t = Utf8Tracker::new();
t.push(&bytes[..4]);
t.push(&bytes[4..]);
assert!(t.finish());
let mut t = Utf8Tracker::new();
t.push(b"\xFF\xFE");
assert!(!t.finish());
let mut t = Utf8Tracker::new();
t.push(&bytes[..4]);
assert!(!t.finish(), "a dangling lead byte is not complete UTF-8");
}
#[test]
fn spool_paths_are_distinct_children_of_the_spool_root() {
let root = Path::new("/srv/uploads");
let (a, b) = (SpoolDir::new(root), SpoolDir::new(root));
for spool in [&a, &b] {
assert_eq!(spool.path().parent(), Some(root.join(SPOOL_DIR).as_path()));
}
assert_ne!(a.path(), b.path());
}
}