2020-10-30 22:38:23 +00:00
|
|
|
// Static file server that can plug into the PTTH reverse server
|
|
|
|
|
|
|
|
use std::{
|
|
|
|
cmp::{min, max},
|
|
|
|
convert::{Infallible, TryInto},
|
|
|
|
io::SeekFrom,
|
2020-10-30 23:36:32 +00:00
|
|
|
path::{Path, PathBuf},
|
2020-10-31 02:31:03 +00:00
|
|
|
sync::Arc,
|
2020-10-30 22:38:23 +00:00
|
|
|
};
|
|
|
|
|
2020-10-31 02:31:03 +00:00
|
|
|
use handlebars::Handlebars;
|
2020-10-30 22:38:23 +00:00
|
|
|
use tokio::{
|
|
|
|
fs::{
|
|
|
|
File,
|
|
|
|
read_dir,
|
|
|
|
ReadDir,
|
|
|
|
},
|
|
|
|
io::AsyncReadExt,
|
|
|
|
sync::mpsc::{
|
|
|
|
channel,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
use regex::Regex;
|
|
|
|
|
|
|
|
use crate::http_serde;
|
|
|
|
|
|
|
|
fn parse_range_header (range_str: &str) -> (Option <u64>, Option <u64>) {
|
|
|
|
use lazy_static::*;
|
|
|
|
|
|
|
|
lazy_static! {
|
|
|
|
static ref RE: Regex = Regex::new (r"^bytes=(\d*)-(\d*)$").expect ("Couldn't compile regex for Range header");
|
|
|
|
}
|
|
|
|
|
|
|
|
println! ("{}", range_str);
|
|
|
|
|
|
|
|
let caps = match RE.captures (range_str) {
|
|
|
|
Some (x) => x,
|
|
|
|
_ => return (None, None),
|
|
|
|
};
|
|
|
|
let start = caps.get (1).map (|x| x.as_str ());
|
|
|
|
let end = caps.get (2).map (|x| x.as_str ());
|
|
|
|
|
|
|
|
let start = start.map (|x| u64::from_str_radix (x, 10).ok ()).flatten ();
|
|
|
|
let end = end.map (|x| u64::from_str_radix (x, 10).ok ()).flatten ();
|
|
|
|
|
|
|
|
(start, end)
|
|
|
|
}
|
|
|
|
|
2020-10-31 14:35:18 +00:00
|
|
|
use serde::Serialize;
|
|
|
|
use tokio::fs::DirEntry;
|
|
|
|
|
|
|
|
// This could probably be done with borrows, if I owned the
|
|
|
|
// tokio::fs::DirEntry instead of consuming it
|
|
|
|
|
|
|
|
#[derive (Serialize)]
|
|
|
|
struct TemplateDirEntry {
|
|
|
|
trailing_slash: &'static str,
|
|
|
|
file_name: String,
|
|
|
|
encoded_file_name: String,
|
|
|
|
error: bool,
|
|
|
|
}
|
|
|
|
|
|
|
|
async fn read_dir_entry (entry: DirEntry) -> TemplateDirEntry
|
|
|
|
{
|
|
|
|
let trailing_slash = match entry.file_type ().await {
|
|
|
|
Ok (t) => if t.is_dir () {
|
|
|
|
"/"
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
""
|
|
|
|
},
|
|
|
|
Err (_) => "",
|
|
|
|
};
|
|
|
|
|
|
|
|
let file_name = match entry.file_name ().into_string () {
|
|
|
|
Ok (x) => x,
|
|
|
|
Err (_) => return TemplateDirEntry {
|
|
|
|
trailing_slash: "",
|
|
|
|
file_name: "".into (),
|
|
|
|
encoded_file_name: "".into (),
|
|
|
|
error: true,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
use percent_encoding::*;
|
|
|
|
|
|
|
|
let encoded_file_name = utf8_percent_encode (&file_name, CONTROLS).to_string ();
|
|
|
|
|
|
|
|
TemplateDirEntry {
|
|
|
|
trailing_slash: &trailing_slash,
|
|
|
|
file_name,
|
|
|
|
encoded_file_name,
|
|
|
|
error: false,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-10-31 15:28:27 +00:00
|
|
|
use std::borrow::Cow;
|
|
|
|
|
2020-10-31 02:31:03 +00:00
|
|
|
async fn serve_dir (
|
|
|
|
handlebars: Arc <Handlebars <'static>>,
|
2020-10-31 15:28:27 +00:00
|
|
|
path: Cow <'_, str>,
|
2020-10-31 02:31:03 +00:00
|
|
|
mut dir: ReadDir
|
2020-10-31 14:35:18 +00:00
|
|
|
) -> http_serde::Response
|
|
|
|
{
|
|
|
|
let mut entries = vec! [];
|
2020-10-30 22:38:23 +00:00
|
|
|
|
2020-10-31 14:35:18 +00:00
|
|
|
while let Ok (Some (entry)) = dir.next_entry ().await {
|
|
|
|
entries.push (read_dir_entry (entry).await);
|
|
|
|
}
|
2020-10-30 22:38:23 +00:00
|
|
|
|
2020-10-31 14:35:18 +00:00
|
|
|
#[derive (Serialize)]
|
2020-10-31 15:28:27 +00:00
|
|
|
struct TemplateDirPage <'a> {
|
|
|
|
path: Cow <'a, str>,
|
2020-10-31 14:35:18 +00:00
|
|
|
entries: Vec <TemplateDirEntry>,
|
|
|
|
}
|
2020-10-30 22:38:23 +00:00
|
|
|
|
2020-10-31 14:35:18 +00:00
|
|
|
let s = handlebars.render ("file_server_dir", &TemplateDirPage {
|
2020-10-31 15:28:27 +00:00
|
|
|
path,
|
2020-10-31 14:35:18 +00:00
|
|
|
entries,
|
|
|
|
}).unwrap ();
|
2020-10-30 22:38:23 +00:00
|
|
|
|
2020-10-31 14:35:18 +00:00
|
|
|
let mut resp = http_serde::Response::default ();
|
|
|
|
resp
|
|
|
|
.header ("content-type".to_string (), "text/html".to_string ().into_bytes ())
|
|
|
|
.body_bytes (s.into_bytes ())
|
|
|
|
;
|
|
|
|
resp
|
2020-10-30 22:38:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
async fn serve_file (
|
|
|
|
mut f: File,
|
|
|
|
should_send_body: bool,
|
|
|
|
range_start: Option <u64>,
|
|
|
|
range_end: Option <u64>
|
|
|
|
) -> http_serde::Response {
|
|
|
|
let (tx, rx) = channel (2);
|
|
|
|
let body = if should_send_body {
|
2020-10-31 01:35:39 +00:00
|
|
|
Some (rx)
|
2020-10-30 22:38:23 +00:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
None
|
|
|
|
};
|
|
|
|
|
|
|
|
let file_md = f.metadata ().await.unwrap ();
|
|
|
|
let file_len = file_md.len ();
|
|
|
|
|
|
|
|
let start = range_start.unwrap_or (0);
|
|
|
|
let end = range_end.unwrap_or (file_len);
|
|
|
|
|
|
|
|
let start = max (0, min (start, file_len));
|
|
|
|
let end = max (0, min (end, file_len));
|
|
|
|
|
|
|
|
f.seek (SeekFrom::Start (start)).await.unwrap ();
|
|
|
|
|
|
|
|
println! ("Serving range {}-{}", start, end);
|
|
|
|
|
|
|
|
if should_send_body {
|
|
|
|
tokio::spawn (async move {
|
|
|
|
//println! ("Opening file {:?}", path);
|
|
|
|
|
|
|
|
let mut tx = tx;
|
|
|
|
//let mut bytes_sent = 0;
|
|
|
|
let mut bytes_left = end - start;
|
|
|
|
|
|
|
|
loop {
|
|
|
|
let mut buffer = vec! [0u8; 65_536];
|
|
|
|
let bytes_read: u64 = f.read (&mut buffer).await.unwrap ().try_into ().unwrap ();
|
|
|
|
|
|
|
|
let bytes_read = min (bytes_left, bytes_read);
|
|
|
|
|
|
|
|
buffer.truncate (bytes_read.try_into ().unwrap ());
|
|
|
|
|
|
|
|
if bytes_read == 0 {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if tx.send (Ok::<_, Infallible> (buffer)).await.is_err () {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
bytes_left -= bytes_read;
|
|
|
|
if bytes_left == 0 {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
//bytes_sent += bytes_read;
|
|
|
|
//println! ("Sent {} bytes", bytes_sent);
|
|
|
|
|
|
|
|
//delay_for (Duration::from_millis (50)).await;
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
let mut response = http_serde::Response::default ();
|
|
|
|
|
|
|
|
response.header (String::from ("accept-ranges"), b"bytes".to_vec ());
|
|
|
|
|
|
|
|
if range_start.is_none () && range_end.is_none () {
|
|
|
|
response.status_code (http_serde::StatusCode::Ok);
|
|
|
|
response.header (String::from ("content-length"), end.to_string ().into_bytes ());
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
response.status_code (http_serde::StatusCode::PartialContent);
|
|
|
|
response.header (String::from ("content-range"), format! ("bytes {}-{}/{}", start, end - 1, end).into_bytes ());
|
|
|
|
}
|
|
|
|
|
|
|
|
if let Some (body) = body {
|
|
|
|
response.body (body);
|
|
|
|
}
|
|
|
|
|
|
|
|
response
|
|
|
|
}
|
|
|
|
|
|
|
|
async fn serve_error (
|
|
|
|
status_code: http_serde::StatusCode,
|
|
|
|
msg: String
|
|
|
|
)
|
|
|
|
-> http_serde::Response
|
|
|
|
{
|
|
|
|
let mut resp = http_serde::Response::default ();
|
|
|
|
resp.status_code (status_code)
|
2020-10-31 01:35:39 +00:00
|
|
|
.body_bytes (msg.into_bytes ());
|
2020-10-30 22:38:23 +00:00
|
|
|
resp
|
|
|
|
}
|
|
|
|
|
|
|
|
pub async fn serve_all (
|
2020-10-31 02:31:03 +00:00
|
|
|
handlebars: Arc <Handlebars <'static>>,
|
2020-10-30 23:36:32 +00:00
|
|
|
root: &Path,
|
2020-10-30 22:38:23 +00:00
|
|
|
parts: http_serde::RequestParts
|
|
|
|
)
|
|
|
|
-> http_serde::Response
|
|
|
|
{
|
|
|
|
println! ("Client requested {}", parts.uri);
|
|
|
|
let mut range_start = None;
|
|
|
|
let mut range_end = None;
|
|
|
|
|
|
|
|
for (k, v) in parts.headers.iter () {
|
|
|
|
let v = std::str::from_utf8 (v).unwrap ();
|
|
|
|
//println! ("{}: {}", k, v);
|
|
|
|
|
|
|
|
if k == "range" {
|
|
|
|
let (start, end) = parse_range_header (v);
|
|
|
|
range_start = start;
|
|
|
|
range_end = end;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
let should_send_body = match &parts.method {
|
|
|
|
http_serde::Method::Get => true,
|
|
|
|
_ => false,
|
|
|
|
};
|
|
|
|
|
|
|
|
use percent_encoding::*;
|
|
|
|
|
2020-10-31 01:35:39 +00:00
|
|
|
// TODO: There is totally a dir traversal attack in here somewhere
|
|
|
|
|
2020-10-30 22:38:23 +00:00
|
|
|
let encoded_path = &parts.uri [1..];
|
2020-10-31 01:35:39 +00:00
|
|
|
|
2020-10-30 22:38:23 +00:00
|
|
|
let path = percent_decode (encoded_path.as_bytes ()).decode_utf8 ().unwrap ();
|
|
|
|
|
2020-10-30 23:36:32 +00:00
|
|
|
let mut full_path = PathBuf::from (root);
|
2020-10-30 22:38:23 +00:00
|
|
|
full_path.push (&*path);
|
|
|
|
|
|
|
|
if let Ok (dir) = read_dir (&full_path).await {
|
2020-10-31 15:28:27 +00:00
|
|
|
serve_dir (handlebars, full_path.to_string_lossy (), dir).await
|
2020-10-30 22:38:23 +00:00
|
|
|
}
|
|
|
|
else if let Ok (file) = File::open (&full_path).await {
|
|
|
|
serve_file (
|
|
|
|
file,
|
|
|
|
should_send_body,
|
|
|
|
range_start,
|
|
|
|
range_end
|
|
|
|
).await
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
serve_error (http_serde::StatusCode::NotFound, "404 Not Found".into ()).await
|
|
|
|
}
|
|
|
|
}
|
2020-10-31 01:35:39 +00:00
|
|
|
|
|
|
|
#[cfg (test)]
|
|
|
|
mod tests {
|
|
|
|
#[test]
|
|
|
|
fn i_hate_paths () {
|
|
|
|
use std::{
|
|
|
|
ffi::OsStr,
|
|
|
|
path::{Component, Path}
|
|
|
|
};
|
|
|
|
|
|
|
|
let mut components = Path::new ("/home/user").components ();
|
|
|
|
|
|
|
|
assert_eq! (components.next (), Some (Component::RootDir));
|
|
|
|
assert_eq! (components.next (), Some (Component::Normal (OsStr::new ("home"))));
|
|
|
|
assert_eq! (components.next (), Some (Component::Normal (OsStr::new ("user"))));
|
|
|
|
assert_eq! (components.next (), None);
|
|
|
|
|
|
|
|
let mut components = Path::new ("./home/user").components ();
|
|
|
|
|
|
|
|
assert_eq! (components.next (), Some (Component::CurDir));
|
|
|
|
assert_eq! (components.next (), Some (Component::Normal (OsStr::new ("home"))));
|
|
|
|
assert_eq! (components.next (), Some (Component::Normal (OsStr::new ("user"))));
|
|
|
|
assert_eq! (components.next (), None);
|
|
|
|
|
|
|
|
let mut components = Path::new (".").components ();
|
|
|
|
|
|
|
|
assert_eq! (components.next (), Some (Component::CurDir));
|
|
|
|
assert_eq! (components.next (), None);
|
|
|
|
}
|
|
|
|
}
|