use crate::serve::INDEX_FILE;
use axum::extract::Request;
use axum::middleware::Next;
use axum::response::{IntoResponse, Response};
use file_id::FileId;
use http::{HeaderValue, Method, StatusCode, header};
use percent_encoding::percent_decode_str;
use std::fs::Metadata;
use std::hash::{DefaultHasher, Hash, Hasher};
use std::path::{Component, Path, PathBuf};
use std::time::UNIX_EPOCH;
pub(crate) struct Version {
tag: HeaderValue,
written_second: u64,
}
impl Version {
pub(crate) fn of(identity: Option<FileId>, metadata: &Metadata) -> Option<Version> {
let written = metadata.modified().ok()?.duration_since(UNIX_EPOCH).ok()?;
let mut parts = DefaultHasher::new();
(
identity,
metadata.len(),
written.as_secs(),
written.subsec_nanos(),
)
.hash(&mut parts);
let tag = format!("W/\"{:016x}\"", parts.finish());
Some(Version {
tag: HeaderValue::try_from(tag).ok()?,
written_second: written.as_secs(),
})
}
pub(crate) fn tag(&self) -> HeaderValue {
self.tag.clone()
}
pub(crate) fn is_named_in(&self, if_none_match: &HeaderValue) -> bool {
let Ok(tags) = if_none_match.to_str() else {
return false;
};
let ours = without_weak_mark(self.tag.to_str().unwrap_or_default());
tags.split(',')
.map(str::trim)
.any(|tag| tag == "*" || without_weak_mark(tag) == ours)
}
fn was_written_at(&self, date: &HeaderValue) -> bool {
date.to_str()
.ok()
.and_then(|date| httpdate::parse_http_date(date).ok())
.and_then(|date| date.duration_since(UNIX_EPOCH).ok())
.is_some_and(|date| date.as_secs() == self.written_second)
}
}
pub(crate) fn identity(path: &Path) -> Option<FileId> {
file_id::get_file_id(path).ok()
}
fn without_weak_mark(tag: &str) -> &str {
tag.strip_prefix("W/").unwrap_or(tag)
}
pub(crate) async fn answer_by_version(root: PathBuf, mut request: Request, next: Next) -> Response {
let version = match *request.method() {
Method::GET | Method::HEAD => file_version(&root, request.uri().path()),
_ => None,
};
let headers = request.headers_mut();
let if_none_match = headers.remove(header::IF_NONE_MATCH);
let if_modified_since = headers.remove(header::IF_MODIFIED_SINCE);
let if_range = headers.remove(header::IF_RANGE);
let Some(version) = version else {
return next.run(request).await;
};
let unchanged = match (if_none_match, if_modified_since) {
(Some(tags), _) => version.is_named_in(&tags),
(None, Some(date)) => version.was_written_at(&date),
(None, None) => false,
};
if unchanged {
return (StatusCode::NOT_MODIFIED, [(header::ETAG, version.tag())]).into_response();
}
if if_range.is_some_and(|date| !version.was_written_at(&date)) {
request.headers_mut().remove(header::RANGE);
}
let mut response = next.run(request).await;
if response.status().is_success() {
response.headers_mut().insert(header::ETAG, version.tag());
}
response
}
fn file_version(root: &Path, path: &str) -> Option<Version> {
let decoded = percent_decode_str(path.trim_start_matches('/'))
.decode_utf8()
.ok()?;
let mut file = root.to_path_buf();
for part in Path::new(&*decoded).components() {
match part {
Component::Normal(name)
if Path::new(name)
.components()
.all(|inner| matches!(inner, Component::Normal(_))) =>
{
file.push(name);
}
Component::CurDir => {}
_ => return None,
}
}
if file.is_dir() {
if !path.ends_with('/') {
return None;
}
file.push(INDEX_FILE);
} else if path.ends_with('/') {
return None;
}
let metadata = std::fs::metadata(&file).ok()?;
if !metadata.is_file() {
return None;
}
Version::of(identity(&file), &metadata)
}