use hyper::{Body, Request, Response, StatusCode};
use std::{
future::Future,
net::{IpAddr, SocketAddr},
path::PathBuf,
sync::Arc,
};
#[cfg(any(
feature = "compression",
feature = "compression-gzip",
feature = "compression-brotli",
feature = "compression-zstd",
feature = "compression-deflate"
))]
use crate::compression;
use crate::compression_static;
#[cfg(feature = "basic-auth")]
use crate::basic_auth;
#[cfg(feature = "fallback-page")]
use crate::fallback_page;
#[cfg(feature = "metrics")]
use crate::metrics;
#[cfg(feature = "experimental")]
use crate::mem_cache::cache::MemCacheOpts;
use crate::{
Error, Result, control_headers, cors, custom_headers, error_page, health,
http_ext::MethodExt,
log_addr, maintenance_mode, redirects, rewrites, security_headers,
settings::Advanced,
static_files::{self, HandleOpts},
text_charset, virtual_hosts,
};
#[cfg(feature = "directory-listing")]
use crate::directory_listing::DirListFmt;
#[cfg(feature = "directory-listing-download")]
use crate::directory_listing_download::DirDownloadFmt;
pub struct RequestHandlerOpts {
pub root_dir: PathBuf,
#[cfg(feature = "experimental")]
pub memory_cache: Option<MemCacheOpts>,
pub compression: bool,
#[cfg(any(
feature = "compression",
feature = "compression-gzip",
feature = "compression-brotli",
feature = "compression-zstd",
feature = "compression-deflate"
))]
pub compression_level: crate::settings::CompressionLevel,
pub compression_static: bool,
#[cfg(feature = "directory-listing")]
#[cfg_attr(docsrs, doc(cfg(feature = "directory-listing")))]
pub dir_listing: bool,
#[cfg(feature = "directory-listing")]
#[cfg_attr(docsrs, doc(cfg(feature = "directory-listing")))]
pub dir_listing_order: u8,
#[cfg(feature = "directory-listing")]
#[cfg_attr(docsrs, doc(cfg(feature = "directory-listing")))]
pub dir_listing_format: DirListFmt,
#[cfg(feature = "directory-listing-download")]
#[cfg_attr(docsrs, doc(cfg(feature = "directory-listing-download")))]
pub dir_listing_download: Vec<DirDownloadFmt>,
pub cors: Option<cors::Configured>,
pub security_headers: bool,
pub cache_control_headers: bool,
pub page404: PathBuf,
pub page50x: PathBuf,
#[cfg(feature = "fallback-page")]
#[cfg_attr(docsrs, doc(cfg(feature = "fallback-page")))]
pub page_fallback: Vec<u8>,
#[cfg(feature = "basic-auth")]
#[cfg_attr(docsrs, doc(cfg(feature = "basic-auth")))]
pub basic_auth: String,
pub index_files: Vec<String>,
pub log_remote_address: bool,
pub log_x_real_ip: bool,
pub log_forwarded_for: bool,
pub trusted_proxies: Vec<IpAddr>,
pub redirect_trailing_slash: bool,
pub ignore_hidden_files: bool,
pub disable_symlinks: bool,
pub use_relative_root: bool,
pub accept_markdown: bool,
pub text_charset: bool,
pub health: bool,
#[cfg(feature = "metrics")]
pub metrics_enabled: bool,
pub maintenance_mode: bool,
pub maintenance_mode_status: StatusCode,
pub maintenance_mode_file: PathBuf,
pub advanced_opts: Option<Advanced>,
}
impl Default for RequestHandlerOpts {
fn default() -> Self {
Self {
root_dir: PathBuf::from("./public"),
compression: true,
compression_static: false,
#[cfg(any(
feature = "compression",
feature = "compression-gzip",
feature = "compression-brotli",
feature = "compression-zstd",
feature = "compression-deflate"
))]
compression_level: crate::settings::CompressionLevel::Default,
#[cfg(feature = "directory-listing")]
dir_listing: false,
#[cfg(feature = "directory-listing")]
dir_listing_order: 6, #[cfg(feature = "directory-listing")]
dir_listing_format: DirListFmt::Html,
#[cfg(feature = "directory-listing-download")]
dir_listing_download: Vec::new(),
cors: None,
#[cfg(feature = "experimental")]
memory_cache: None,
security_headers: false,
cache_control_headers: true,
page404: PathBuf::from("./404.html"),
page50x: PathBuf::from("./50x.html"),
#[cfg(feature = "fallback-page")]
page_fallback: Vec::new(),
#[cfg(feature = "basic-auth")]
basic_auth: String::new(),
index_files: vec!["index.html".into()],
log_remote_address: false,
log_x_real_ip: false,
log_forwarded_for: false,
trusted_proxies: Vec::new(),
redirect_trailing_slash: true,
ignore_hidden_files: false,
disable_symlinks: false,
use_relative_root: false,
accept_markdown: false,
text_charset: true,
health: false,
#[cfg(feature = "metrics")]
metrics_enabled: false,
maintenance_mode: false,
maintenance_mode_status: StatusCode::SERVICE_UNAVAILABLE,
maintenance_mode_file: PathBuf::new(),
advanced_opts: None,
}
}
}
pub struct RequestHandler {
pub opts: Arc<RequestHandlerOpts>,
}
impl RequestHandler {
pub fn handle<'a>(
&'a self,
req: &'a mut Request<Body>,
remote_addr: Option<SocketAddr>,
) -> impl Future<Output = Result<Response<Body>, Error>> + Send + 'a {
let mut base_path = &self.opts.root_dir;
#[cfg(feature = "directory-listing")]
let dir_listing = self.opts.dir_listing;
#[cfg(feature = "directory-listing")]
let dir_listing_order = self.opts.dir_listing_order;
#[cfg(feature = "directory-listing")]
let dir_listing_format = &self.opts.dir_listing_format;
#[cfg(feature = "directory-listing-download")]
let dir_listing_download = &self.opts.dir_listing_download;
let redirect_trailing_slash = self.opts.redirect_trailing_slash;
let compression_static = self.opts.compression_static;
let ignore_hidden_files = self.opts.ignore_hidden_files;
let disable_symlinks = self.opts.disable_symlinks;
let index_files: Vec<&str> = self.opts.index_files.iter().map(|s| s.as_str()).collect();
#[cfg(feature = "experimental")]
let memory_cache = self.opts.memory_cache.as_ref();
log_addr::pre_process(&self.opts, req, remote_addr);
async move {
#[cfg(feature = "metrics")]
let req_start = std::time::Instant::now();
#[cfg(feature = "metrics")]
let metrics_enabled = self.opts.metrics_enabled;
#[cfg(feature = "metrics")]
if metrics_enabled {
metrics::inc_requests_inflight();
}
let result: Result<Response<Body>, Error> = async {
if !req.method().is_allowed() {
return error_page::error_response(
req.uri(),
req.method(),
&StatusCode::METHOD_NOT_ALLOWED,
&self.opts.page404,
&self.opts.page50x,
);
}
if let Some(result) = health::pre_process(&self.opts, req) {
return result;
}
if let Some(result) = cors::pre_process(&self.opts, req) {
return result;
}
#[cfg(feature = "basic-auth")]
if let Some(response) = basic_auth::pre_process(&self.opts, req) {
return response;
}
#[cfg(feature = "metrics")]
if let Some(result) = metrics::pre_process(&self.opts, req) {
return result;
}
if let Some(response) = maintenance_mode::pre_process(&self.opts, req) {
return response;
}
if let Some(result) = redirects::pre_process(&self.opts, req) {
return result;
}
if let Some(result) = rewrites::pre_process(&self.opts, req) {
return result;
}
if let Some(advanced) = &self.opts.advanced_opts {
if let Some(root) =
virtual_hosts::get_real_root(req, advanced.virtual_hosts.as_deref())
{
base_path = root;
}
}
let index_files = index_files.as_ref();
let uri_path_md = if self.opts.accept_markdown {
crate::markdown::pre_process(
req,
base_path,
req.uri().path(),
self.opts.ignore_hidden_files,
)
} else {
None
};
let uri_path = uri_path_md.as_deref().unwrap_or(req.uri().path());
let (resp, file_path) = match static_files::handle(&HandleOpts {
method: req.method(),
headers: req.headers(),
#[cfg(feature = "experimental")]
memory_cache,
base_path,
uri_path,
uri_query: req.uri().query(),
#[cfg(feature = "directory-listing")]
dir_listing,
#[cfg(feature = "directory-listing")]
dir_listing_order,
#[cfg(feature = "directory-listing")]
dir_listing_format,
#[cfg(feature = "directory-listing-download")]
dir_listing_download,
redirect_trailing_slash,
compression_static,
ignore_hidden_files,
index_files,
disable_symlinks,
})
.await
{
Ok(result) if req.method().is_options() => (result.resp, None),
Ok(result) => (result.resp, Some(result.file_path)),
Err(status) => {
#[cfg(feature = "fallback-page")]
let will_serve_fallback = fallback_page::can_serve(&self.opts, req, status);
#[cfg(not(feature = "fallback-page"))]
let will_serve_fallback = false;
let resp = if will_serve_fallback {
error_page::error_response_without_logging(
req.uri(),
req.method(),
&status,
&self.opts.page404,
&self.opts.page50x,
)?
} else {
error_page::error_response(
req.uri(),
req.method(),
&status,
&self.opts.page404,
&self.opts.page50x,
)?
};
(resp, None)
}
};
#[cfg(feature = "fallback-page")]
let resp = fallback_page::post_process(&self.opts, req, resp)?;
let resp = cors::post_process(&self.opts, req, resp)?;
let resp = crate::markdown::post_process(uri_path_md.is_some(), &self.opts, resp)?;
let resp = text_charset::post_process(&self.opts, resp)?;
let resp = compression_static::post_process(&self.opts, req, resp)?;
#[cfg(any(
feature = "compression",
feature = "compression-gzip",
feature = "compression-brotli",
feature = "compression-zstd",
feature = "compression-deflate"
))]
let resp = compression::post_process(&self.opts, req, resp)?;
let resp = control_headers::post_process(&self.opts, req, resp)?;
let resp = security_headers::post_process(&self.opts, req, resp)?;
let resp = custom_headers::post_process(&self.opts, req, resp, file_path.as_ref())?;
Ok(resp)
}
.await;
#[cfg(feature = "metrics")]
if metrics_enabled {
metrics::dec_requests_inflight();
if let Ok(ref resp) = result {
let bytes = resp
.headers()
.get(hyper::header::CONTENT_LENGTH)
.and_then(|v| v.to_str().ok())
.and_then(|v| v.parse::<u64>().ok())
.unwrap_or(0);
metrics::record_request(
req,
resp.status(),
bytes,
req_start.elapsed().as_secs_f64(),
self.opts
.advanced_opts
.as_ref()
.and_then(|opts| opts.virtual_hosts.as_deref()),
);
}
}
result
}
}
}
#[cfg(all(test, feature = "basic-auth", feature = "experimental"))]
mod tests {
use hyper::{Body, Method, Request, StatusCode, header::HeaderValue};
use std::sync::Arc;
use std::time::Duration;
use super::{RequestHandler, RequestHandlerOpts};
use crate::mem_cache::cache::{CACHE_STORE, MemCacheOpts};
#[tokio::test]
async fn basic_auth_options_never_serves_cached_file() {
let temp_dir = tempfile::tempdir().expect("unexpected error creating web root");
let root_dir = temp_dir
.path()
.canonicalize()
.expect("unexpected error canonicalizing web root");
std::fs::write(root_dir.join("secret.txt"), "secret")
.expect("unexpected error writing protected file");
let _ = CACHE_STORE.set(
mini_moka::sync::Cache::builder()
.max_capacity(8)
.time_to_live(Duration::from_secs(60))
.build(),
);
let req_handler = RequestHandler {
opts: Arc::new(RequestHandlerOpts {
root_dir,
memory_cache: Some(MemCacheOpts::new(8)),
basic_auth: "jq:$2y$05$32zazJ1yzhlDHnt26L3MFOgY0HVqPmDUvG0KUx6cjf9RDiUGp/M9q"
.into(),
cors: crate::cors::new("*", "", ""),
..Default::default()
}),
};
let request = |method: Method, headers: &[(&'static str, &'static str)]| {
let mut req = Request::new(Body::empty());
*req.method_mut() = method;
*req.uri_mut() = "http://localhost/secret.txt".parse().unwrap();
for (name, value) in headers {
req.headers_mut()
.insert(*name, HeaderValue::from_static(value));
}
req
};
let body = |resp: hyper::Response<Body>| async {
hyper::body::to_bytes(resp.into_body()).await.unwrap()
};
let mut req = request(Method::GET, &[("authorization", "Basic anE6anE=")]);
let resp = req_handler.handle(&mut req, None).await.unwrap();
assert_eq!(resp.status(), StatusCode::OK);
assert_eq!(body(resp).await, "secret");
let key = compact_str::CompactString::from(
req_handler
.opts
.root_dir
.join("secret.txt")
.to_str()
.expect("unexpected non-UTF-8 web root"),
);
assert!(
CACHE_STORE
.get()
.and_then(|store| store.get(&key))
.is_some(),
"file was not cached"
);
let mut req = request(Method::OPTIONS, &[]);
let resp = req_handler.handle(&mut req, None).await.unwrap();
assert_eq!(resp.status(), StatusCode::UNAUTHORIZED);
assert_ne!(body(resp).await, "secret");
let mut req = request(
Method::OPTIONS,
&[
("origin", "https://example.com"),
("access-control-request-method", "GET"),
],
);
let resp = req_handler.handle(&mut req, None).await.unwrap();
assert_eq!(resp.status(), StatusCode::NO_CONTENT);
assert!(body(resp).await.is_empty());
}
}
#[cfg(all(
test,
feature = "experimental",
any(feature = "compression", feature = "compression-gzip")
))]
mod mem_cache_compression_tests {
use hyper::{Body, Method, Request, StatusCode, header::HeaderValue};
use std::sync::Arc;
use std::time::Duration;
use super::{RequestHandler, RequestHandlerOpts};
use crate::mem_cache::cache::{CACHE_STORE, MemCacheOpts};
#[tokio::test]
async fn mem_cache_partial_content_is_not_compressed() {
let temp_dir = tempfile::tempdir().expect("unexpected error creating web root");
let root_dir = temp_dir
.path()
.canonicalize()
.expect("unexpected error canonicalizing web root");
let data = "<p>lorem ipsum dolor sit amet</p>\n".repeat(64);
std::fs::write(root_dir.join("page.html"), &data).expect("unexpected error writing file");
let _ = CACHE_STORE.set(
mini_moka::sync::Cache::builder()
.max_capacity(8)
.time_to_live(Duration::from_secs(60))
.build(),
);
let req_handler = RequestHandler {
opts: Arc::new(RequestHandlerOpts {
root_dir,
compression: true,
memory_cache: Some(MemCacheOpts::new(8)),
..Default::default()
}),
};
let request = |headers: &[(&'static str, &'static str)]| {
let mut req = Request::new(Body::empty());
*req.method_mut() = Method::GET;
*req.uri_mut() = "http://localhost/page.html".parse().unwrap();
for (name, value) in headers {
req.headers_mut()
.insert(*name, HeaderValue::from_static(value));
}
req
};
let mut req = request(&[]);
let resp = req_handler.handle(&mut req, None).await.unwrap();
assert_eq!(resp.status(), StatusCode::OK);
let body = hyper::body::to_bytes(resp.into_body()).await.unwrap();
assert_eq!(body, data.as_bytes());
let key = compact_str::CompactString::from(
req_handler
.opts
.root_dir
.join("page.html")
.to_str()
.expect("unexpected non-UTF-8 web root"),
);
assert!(
CACHE_STORE
.get()
.and_then(|store| store.get(&key))
.is_some(),
"file was not cached"
);
let mut req = request(&[("accept-encoding", "gzip"), ("range", "bytes=0-399")]);
let resp = req_handler.handle(&mut req, None).await.unwrap();
assert_eq!(resp.status(), StatusCode::PARTIAL_CONTENT);
assert_eq!(
resp.headers().get("content-encoding"),
None,
"a 206 response must not be compressed"
);
assert_eq!(
resp.headers()["content-range"],
format!("bytes 0-399/{}", data.len())
);
assert_eq!(resp.headers()["content-length"], "400");
let body = hyper::body::to_bytes(resp.into_body()).await.unwrap();
assert_eq!(body, data.as_bytes()[..400]);
}
}