chore(release): version v0.17.1

close #43

CHANGELOG.md

@@ -2,6 +2,57 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.17.1] - 2022-06-16
+
+### Bug Fixes
+
+- Range request ([#44](https://github.com/sigoden/duf/issues/44))
+
+## [0.17.0] - 2022-06-15
+
+### Bug Fixes
+
+- Webdav propfind dir with slash ([#42](https://github.com/sigoden/duf/issues/42))
+
+### Features
+
+- Listen both ipv4 and ipv6 by default ([#40](https://github.com/sigoden/duf/issues/40))
+
+### Refactor
+
+- Trival changes ([#41](https://github.com/sigoden/duf/issues/41))
+
+## [0.16.0] - 2022-06-12
+
+### Features
+
+- Implement head method ([#33](https://github.com/sigoden/duf/issues/33))
+- Display upload speed and time left ([#34](https://github.com/sigoden/duf/issues/34))
+- Support tls-key in pkcs#8 format ([#35](https://github.com/sigoden/duf/issues/35))
+- Options method return status 200
+
+### Testing
+
+- Add integration tests ([#36](https://github.com/sigoden/duf/issues/36))
+
+## [0.15.1] - 2022-06-11
+
+### Bug Fixes
+
+- Cannot upload ([#32](https://github.com/sigoden/duf/issues/32))
+
+## [0.15.0] - 2022-06-10
+
+### Bug Fixes
+
+- Encode webdav href as uri ([#28](https://github.com/sigoden/duf/issues/28))
+- Query dir param
+
+### Features
+
+- Add basic dark theme ([#29](https://github.com/sigoden/duf/issues/29))
+- Add empty state placeholder to page([#30](https://github.com/sigoden/duf/issues/30))
+
 ## [0.14.0] - 2022-06-07
 
 ### Bug Fixes

Cargo.toml

@@ -1,23 +1,21 @@
 [package]
 name = "duf"
-version = "0.14.0"
+version = "0.17.1"
 edition = "2021"
 authors = ["sigoden <sigoden@gmail.com>"]
 description = "Duf is a simple file server."
 license = "MIT OR Apache-2.0"
 homepage = "https://github.com/sigoden/duf"
 repository = "https://github.com/sigoden/duf"
-autotests = false
 categories = ["command-line-utilities", "web-programming::http-server"]
 keywords = ["static", "file", "server", "webdav", "cli"]
 
 [dependencies]
-clap = { version = "3", default-features = false, features = ["std", "cargo"] }
+clap = { version = "3", default-features = false, features = ["std"] }
 chrono = "0.4"
 tokio = { version = "1", features = ["rt-multi-thread", "macros", "fs", "io-util", "signal"]}
 tokio-rustls = "0.23"
-tokio-stream = { version = "0.1", features = ["net"] }
+tokio-util = { version = "0.7",  features = ["io-util"] }
-tokio-util = { version = "0.7",  features = ["codec", "io-util"] }
 hyper = { version = "0.14", features = ["http1", "server", "tcp", "stream"] }
 percent-encoding = "2.1"
 serde = { version = "1", features = ["derive"] }
@@ -25,19 +23,34 @@ serde_json = "1"
 futures = "0.3"
 base64 = "0.13"
 async_zip = "0.0.7"
-async-walkdir = "0.2.0"
+async-walkdir = "0.2"
-headers = "0.3.7"
+headers = "0.3"
-mime_guess = "2.0.4"
+mime_guess = "2.0"
-get_if_addrs = "0.5.3"
+get_if_addrs = "0.5"
 rustls = { version = "0.20", default-features = false, features = ["tls12"] }
 rustls-pemfile = "1"
-md5 = "0.7.0"
+md5 = "0.7"
-lazy_static = "1.4.0"
+lazy_static = "1.4"
-uuid = { version = "1.1.1", features = ["v4", "fast-rng"] }
+uuid = { version = "1.1", features = ["v4", "fast-rng"] }
-urlencoding = "2.1.0"
+urlencoding = "2.1"
 xml-rs = "0.8"
-env_logger = { version = "0.9.0", default-features = false, features = ["humantime"] }
+env_logger = { version = "0.9", default-features = false, features = ["humantime"] }
-log = "0.4.17"
+log = "0.4"
+socket2 = "0.4"
+async-stream = "0.3"
+
+[dev-dependencies]
+assert_cmd = "2"
+reqwest = { version = "0.11", features = ["blocking", "multipart", "rustls-tls"], default-features = false }
+assert_fs = "1"
+select = "0.5"
+port_check = "0.1"
+rstest = "0.13"
+regex = "1"
+pretty_assertions = "1.2"
+url = "2"
+diqwest = { version = "1", features = ["blocking"] }
+predicates = "2"
 
 [profile.release]
 lto = true

README.md

@@ -40,10 +40,10 @@ Download from [Github Releases](https://github.com/sigoden/duf/releases), unzip
 ## CLI
 
 ```
-Duf is a simple file server.
+Duf is a simple file server. - https://github.com/sigoden/duf
 
 USAGE:
-    duf [OPTIONS] [path]
+    duf [OPTIONS] [--] [path]
 
 ARGS:
     <path>    Path to a root directory for serving files [default: .]
@@ -55,7 +55,7 @@ OPTIONS:
         --allow-delete          Allow delete files/folders
         --allow-symlink         Allow symlink to files/folders outside root directory
         --allow-upload          Allow upload files/folders
-    -b, --bind <address>        Specify bind address [default: 0.0.0.0]
+    -b, --bind <address>...     Specify bind address
         --cors                  Enable CORS, sets `Access-Control-Allow-Origin: *`
     -h, --help                  Print help information
     -p, --port <port>           Specify port to listen on [default: 5000]

assets/index.css

@@ -93,10 +93,20 @@ body {
   display: none;
 }
 
+.upload-status span {
+  width: 70px;
+  display: inline-block;
+}
+
 .main {
   padding: 0 1em;
 }
 
+.empty-folder {
+  padding-top: 1rem;
+  font-style: italic;
+}
+
 .uploaders-table th,
 .paths-table th {
   text-align: left;
@@ -173,3 +183,39 @@ body {
 .uploader {
   padding-right: 1em;
 }
+
+/* dark theme */
+@media (prefers-color-scheme: dark) {
+  body {
+    background-color: #000;
+  }
+
+  html,
+  .breadcrumb>b,
+  .searchbar #search {
+    color: #fff;
+  }
+
+  .uploaders-table th,
+  .paths-table th {
+    color: #ddd;
+  }
+
+  svg,
+  .path svg {
+    fill: #d0e6ff;
+  }
+
+  .searchbar {
+    background-color: #111;
+    border-color: #fff6;
+  }
+
+  .searchbar svg {
+    fill: #fff6;
+  }
+
+  .path a {
+    color: #3191ff;
+  }
+} 

assets/index.html

@@ -31,11 +31,12 @@
     </form>
   </div>
   <div class="main">
+    <div class="empty-folder hidden"></div>
     <table class="uploaders-table hidden">
       <thead>
         <tr>
           <th class="cell-name">Name</th>
-          <th class="cell-status">Status</th>
+          <th class="cell-status">Speed - Progress - Time Left</th>
         </tr>
       </thead>
     </table>

assets/index.js

@@ -7,11 +7,29 @@
  * @property {number} size
  */
 
+// https://stackoverflow.com/a/901144/3642588
+const params = new Proxy(new URLSearchParams(window.location.search), {
+  get: (searchParams, prop) => searchParams.get(prop),
+});
+
+const dirEmptyNote = params.q ? 'No results' : DATA.dir_exists ? 'Empty folder' : 'Folder will be created when a file is uploaded';
 
 /**
  * @type Element
  */
-let $pathsTable, $pathsTableBody, $uploadersTable;
+let $pathsTable;
+/**
+ * @type Element
+ */
+let $pathsTableBody;
+/**
+ * @type Element
+ */
+let $uploadersTable;
+/**
+ * @type Element
+ */
+let $emptyFolder;
 /**
  * @type string
  */
@@ -34,6 +52,14 @@ class Uploader {
    * @type Element
    */
   $uploadStatus;
+  /**
+   * @type number
+   */
+  uploaded = 0;
+  /**
+   * @type number
+   */
+  lastUptime = 0;
   static globalIdx = 0;
   constructor(file, dirs) {
     this.name = [...dirs, file.name].join("/");
@@ -50,10 +76,12 @@ class Uploader {
       <div>${getSvg("File")}</div>
       <a href="${url}">${name}</a>
     </td>
-    <td class="cell-status" id="uploadStatus${idx}"></td>
+    <td class="cell-status upload-status" id="uploadStatus${idx}"></td>
   </tr>`);
     $uploadersTable.classList.remove("hidden");
+    $emptyFolder.classList.add("hidden");
     this.$uploadStatus = document.getElementById(`uploadStatus${idx}`);
+    this.lastUptime = Date.now();
 
     const ajax = new XMLHttpRequest();
     ajax.upload.addEventListener("progress", e => this.progress(e), false);
@@ -73,8 +101,15 @@ class Uploader {
   }
 
   progress(event) {
-    const percent = (event.loaded / event.total) * 100;
+    let now = Date.now();
-    this.$uploadStatus.innerHTML = `${percent.toFixed(2)}%`;
+    let speed = (event.loaded - this.uploaded) / (now - this.lastUptime) * 1000;
+    let [speedValue, speedUnit] = formatSize(speed);
+    const speedText = `${speedValue}${speedUnit.toLowerCase()}/s`;
+    const progress = formatPercent((event.loaded / event.total) * 100);
+    const duration = formatDuration((event.total - event.loaded) / speed)
+    this.$uploadStatus.innerHTML = `<span>${speedText}</span><span>${progress}</span><span>${duration}</span>`;
+    this.uploaded = event.loaded;
+    this.lastUptime = now;
   }
 
   complete() {
@@ -155,7 +190,7 @@ function addPath(file, index) {
     <a href="${url}" title="${file.name}">${file.name}</a>
   </td>
   <td class="cell-mtime">${formatMtime(file.mtime)}</td>
-  <td class="cell-size">${formatSize(file.size)}</td>
+  <td class="cell-size">${formatSize(file.size).join(" ")}</td>
   ${actionCell}
 </tr>`)
 }
@@ -180,6 +215,8 @@ async function deletePath(index) {
         DATA.paths[index] = null;
         if (!DATA.paths.find(v => !!v)) {
           $pathsTable.classList.add("hidden");
+          $emptyFolder.textContent = dirEmptyNote;
+          $emptyFolder.classList.remove("hidden");
         }
     } else {
       throw new Error(await res.text())
@@ -263,17 +300,38 @@ function padZero(value, size) {
 }
 
 function formatSize(size) {
-  if (!size) return ""
+  if (!size) return []
   const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
-  if (size == 0) return '0 Byte';
+  if (size == 0) return [0, "Byte"];
   const i = parseInt(Math.floor(Math.log(size) / Math.log(1024)));
-  return Math.round(size / Math.pow(1024, i), 2) + ' ' + sizes[i];
+  return [Math.round(size / Math.pow(1024, i), 2), sizes[i]];
+}
+
+function formatDuration(seconds) {
+  seconds = Math.ceil(seconds);
+  let h = Math.floor(seconds / 3600);
+  let m = Math.floor((seconds - h * 3600) / 60);
+  let s = seconds - h * 3600 - m * 60
+  return `${padZero(h, 2)}:${padZero(m, 2)}:${padZero(s, 2)}`;
+}
+
+function formatPercent(precent) {
+  if (precent > 10) {
+    return precent.toFixed(1) + "%";
+  } else {
+    return precent.toFixed(2) + "%";
+  }
 }
 
 function ready() {
   $pathsTable = document.querySelector(".paths-table")
   $pathsTableBody = document.querySelector(".paths-table tbody");
   $uploadersTable = document.querySelector(".uploaders-table");
+  $emptyFolder = document.querySelector(".empty-folder");
+
+  if (params.q) {
+    document.getElementById('search').value = params.q;
+  }
 
   addBreadcrumb(DATA.breadcrumb);
   if (Array.isArray(DATA.paths)) {
@@ -284,6 +342,10 @@ function ready() {
     for (let i = 0; i < len; i++) {
       addPath(DATA.paths[i], i);
     }
+    if (len == 0) {
+      $emptyFolder.textContent = dirEmptyNote;
+      $emptyFolder.classList.remove("hidden");
+    }
   }
   if (DATA.allow_upload) {
     dropzone();

src/args.rs

@@ -1,24 +1,29 @@
-use clap::crate_description;
+use clap::{Arg, ArgMatches, Command};
-use clap::{Arg, ArgMatches};
 use rustls::{Certificate, PrivateKey};
-use std::net::{IpAddr, SocketAddr};
+use std::env;
+use std::net::IpAddr;
 use std::path::{Path, PathBuf};
-use std::{env, fs, io};
 
 use crate::auth::parse_auth;
+use crate::tls::{load_certs, load_private_key};
 use crate::BoxResult;
 
-const ABOUT: &str = concat!("\n", crate_description!()); // Add extra newline.
+fn app() -> Command<'static> {
-
+    Command::new(env!("CARGO_CRATE_NAME"))
-fn app() -> clap::Command<'static> {
+        .version(env!("CARGO_PKG_VERSION"))
-    clap::command!()
+        .author(env!("CARGO_PKG_AUTHORS"))
-        .about(ABOUT)
+        .about(concat!(
+            env!("CARGO_PKG_DESCRIPTION"),
+            " - ",
+            env!("CARGO_PKG_REPOSITORY")
+        ))
         .arg(
             Arg::new("address")
                 .short('b')
                 .long("bind")
-                .default_value("0.0.0.0")
                 .help("Specify bind address")
+                .multiple_values(true)
+                .multiple_occurrences(true)
                 .value_name("address"),
         )
         .arg(
@@ -111,7 +116,8 @@ pub fn matches() -> ArgMatches {
 
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub struct Args {
-    pub addr: SocketAddr,
+    pub addrs: Vec<IpAddr>,
+    pub port: u16,
     pub path: PathBuf,
     pub path_prefix: String,
     pub uri_prefix: String,
@@ -132,9 +138,12 @@ impl Args {
     /// If a parsing error ocurred, exit the process and print out informative
     /// error message to user.
     pub fn parse(matches: ArgMatches) -> BoxResult<Args> {
-        let ip = matches.value_of("address").unwrap_or_default();
         let port = matches.value_of_t::<u16>("port")?;
-        let addr = to_addr(ip, port)?;
+        let addrs = matches
+            .values_of("address")
+            .map(|v| v.collect())
+            .unwrap_or_else(|| vec!["0.0.0.0", "::"]);
+        let addrs: Vec<IpAddr> = Args::parse_addrs(&addrs)?;
         let path = Args::parse_path(matches.value_of_os("path").unwrap_or_default())?;
         let path_prefix = matches
             .value_of("path-prefix")
@@ -166,7 +175,8 @@ impl Args {
         };
 
         Ok(Args {
-            addr,
+            addrs,
+            port,
             path,
             path_prefix,
             uri_prefix,
@@ -182,7 +192,25 @@ impl Args {
         })
     }
 
-    /// Parse path.
+    fn parse_addrs(addrs: &[&str]) -> BoxResult<Vec<IpAddr>> {
+        let mut ip_addrs = vec![];
+        let mut invalid_addrs = vec![];
+        for addr in addrs {
+            match addr.parse::<IpAddr>() {
+                Ok(v) => {
+                    ip_addrs.push(v);
+                }
+                Err(_) => {
+                    invalid_addrs.push(*addr);
+                }
+            }
+        }
+        if !invalid_addrs.is_empty() {
+            return Err(format!("Invalid bind address `{}`", invalid_addrs.join(",")).into());
+        }
+        Ok(ip_addrs)
+    }
+
     fn parse_path<P: AsRef<Path>>(path: P) -> BoxResult<PathBuf> {
         let path = path.as_ref();
         if !path.exists() {
@@ -197,40 +225,3 @@ impl Args {
             .map_err(|err| format!("Failed to access path `{}`: {}", path.display(), err,).into())
     }
 }
-
-fn to_addr(ip: &str, port: u16) -> BoxResult<SocketAddr> {
-    let ip: IpAddr = ip.parse()?;
-    Ok(SocketAddr::new(ip, port))
-}
-
-// Load public certificate from file.
-fn load_certs(filename: &str) -> BoxResult<Vec<Certificate>> {
-    // Open certificate file.
-    let certfile =
-        fs::File::open(&filename).map_err(|e| format!("Failed to open {}: {}", &filename, e))?;
-    let mut reader = io::BufReader::new(certfile);
-
-    // Load and return certificate.
-    let certs = rustls_pemfile::certs(&mut reader).map_err(|_| "Failed to load certificate")?;
-    if certs.is_empty() {
-        return Err("Expected at least one certificate".into());
-    }
-    Ok(certs.into_iter().map(Certificate).collect())
-}
-
-// Load private key from file.
-fn load_private_key(filename: &str) -> BoxResult<PrivateKey> {
-    // Open keyfile.
-    let keyfile =
-        fs::File::open(&filename).map_err(|e| format!("Failed to open {}: {}", &filename, e))?;
-    let mut reader = io::BufReader::new(keyfile);
-
-    // Load and return a single private key.
-    let keys = rustls_pemfile::rsa_private_keys(&mut reader)
-        .map_err(|e| format!("There was a problem with reading private key: {:?}", e))?;
-
-    if keys.len() != 1 {
-        return Err("Expected a single private key".into());
-    }
-    Ok(PrivateKey(keys[0].to_owned()))
-}

src/auth.rs

@@ -23,7 +23,7 @@ lazy_static! {
 pub fn generate_www_auth(stale: bool) -> String {
     let str_stale = if stale { "stale=true," } else { "" };
     format!(
-        "Digest realm=\"{}\",nonce=\"{}\",{}qop=\"auth\",algorithm=\"MD5\"",
+        "Digest realm=\"{}\",nonce=\"{}\",{}qop=\"auth\"",
         REALM,
         create_nonce(),
         str_stale

src/main.rs

@@ -1,17 +1,29 @@
 mod args;
 mod auth;
 mod server;
+mod streamer;
+mod tls;
 
 #[macro_use]
 extern crate log;
 
-pub type BoxResult<T> = Result<T, Box<dyn std::error::Error>>;
-
-use std::env;
-use std::io::Write;
-
 use crate::args::{matches, Args};
-use crate::server::serve;
+use crate::server::{Request, Server};
+use crate::tls::{TlsAcceptor, TlsStream};
+
+use std::io::Write;
+use std::net::{IpAddr, SocketAddr, TcpListener as StdTcpListener};
+use std::{env, sync::Arc};
+
+use futures::future::join_all;
+use tokio::net::TcpListener;
+use tokio::task::JoinHandle;
+
+use hyper::server::conn::{AddrIncoming, AddrStream};
+use hyper::service::{make_service_fn, service_fn};
+use rustls::ServerConfig;
+
+pub type BoxResult<T> = Result<T, Box<dyn std::error::Error>>;
 
 #[tokio::main]
 async fn main() {
@@ -24,15 +36,24 @@ async fn run() -> BoxResult<()> {
     }
     env_logger::builder()
         .format(|buf, record| {
-            let timestamp = buf.timestamp();
+            let timestamp = buf.timestamp_millis();
             writeln!(buf, "[{} {}] {}", timestamp, record.level(), record.args())
         })
         .init();
 
     let args = Args::parse(matches())?;
+    let args = Arc::new(args);
+    let handles = serve(args.clone())?;
+    print_listening(args)?;
+
     tokio::select! {
-        ret = serve(args) => {
+        ret = join_all(handles) => {
-            ret
+            for r in ret {
+                if let Err(e) = r {
+                    error!("{}", e);
+                }
+            }
+            Ok(())
         },
         _ = shutdown_signal() => {
             Ok(())
@@ -40,6 +61,121 @@ async fn run() -> BoxResult<()> {
     }
 }
 
+fn serve(args: Arc<Args>) -> BoxResult<Vec<JoinHandle<Result<(), hyper::Error>>>> {
+    let inner = Arc::new(Server::new(args.clone()));
+    let mut handles = vec![];
+    let port = args.port;
+    for ip in args.addrs.iter() {
+        let inner = inner.clone();
+        let incoming = create_addr_incoming(SocketAddr::new(*ip, port))
+            .map_err(|e| format!("Failed to bind `{}:{}`, {}", ip, port, e))?;
+        let serv_func = move |remote_addr: SocketAddr| {
+            let inner = inner.clone();
+            async move {
+                Ok::<_, hyper::Error>(service_fn(move |req: Request| {
+                    let inner = inner.clone();
+                    inner.call(req, remote_addr)
+                }))
+            }
+        };
+        match args.tls.clone() {
+            Some((certs, key)) => {
+                let config = ServerConfig::builder()
+                    .with_safe_defaults()
+                    .with_no_client_auth()
+                    .with_single_cert(certs, key)?;
+                let config = Arc::new(config);
+                let accepter = TlsAcceptor::new(config.clone(), incoming);
+                let new_service = make_service_fn(move |socket: &TlsStream| {
+                    let remote_addr = socket.remote_addr();
+                    serv_func(remote_addr)
+                });
+                let server = tokio::spawn(hyper::Server::builder(accepter).serve(new_service));
+                handles.push(server);
+            }
+            None => {
+                let new_service = make_service_fn(move |socket: &AddrStream| {
+                    let remote_addr = socket.remote_addr();
+                    serv_func(remote_addr)
+                });
+                let server = tokio::spawn(hyper::Server::builder(incoming).serve(new_service));
+                handles.push(server);
+            }
+        };
+    }
+    Ok(handles)
+}
+
+fn create_addr_incoming(addr: SocketAddr) -> BoxResult<AddrIncoming> {
+    use socket2::{Domain, Protocol, Socket, Type};
+    let socket = Socket::new(Domain::for_address(addr), Type::STREAM, Some(Protocol::TCP))?;
+    if addr.is_ipv6() {
+        socket.set_only_v6(true)?;
+    }
+    socket.set_reuse_address(true)?;
+    socket.bind(&addr.into())?;
+    socket.listen(1024 /* Default backlog */)?;
+    let std_listener = StdTcpListener::from(socket);
+    std_listener.set_nonblocking(true)?;
+    let incoming = AddrIncoming::from_listener(TcpListener::from_std(std_listener)?)?;
+    Ok(incoming)
+}
+
+fn print_listening(args: Arc<Args>) -> BoxResult<()> {
+    let mut addrs = vec![];
+    let (mut ipv4, mut ipv6) = (false, false);
+    for ip in args.addrs.iter() {
+        if ip.is_unspecified() {
+            if ip.is_ipv6() {
+                ipv6 = true;
+            } else {
+                ipv4 = true;
+            }
+        } else {
+            addrs.push(*ip);
+        }
+    }
+    if ipv4 || ipv6 {
+        let ifaces = get_if_addrs::get_if_addrs()
+            .map_err(|e| format!("Failed to get local interface addresses: {}", e))?;
+        for iface in ifaces.into_iter() {
+            let local_ip = iface.ip();
+            if ipv4 && local_ip.is_ipv4() {
+                addrs.push(local_ip)
+            }
+            if ipv6 && local_ip.is_ipv6() {
+                addrs.push(local_ip)
+            }
+        }
+    }
+    addrs.sort_unstable();
+    let urls = addrs
+        .into_iter()
+        .map(|addr| match addr {
+            IpAddr::V4(_) => format!("{}:{}", addr, args.port),
+            IpAddr::V6(_) => format!("[{}]:{}", addr, args.port),
+        })
+        .map(|addr| match &args.tls {
+            Some(_) => format!("https://{}", addr),
+            None => format!("http://{}", addr),
+        })
+        .map(|url| format!("{}{}", url, args.uri_prefix))
+        .collect::<Vec<_>>();
+
+    if urls.len() == 1 {
+        println!("Listening on {}", urls[0]);
+    } else {
+        let info = urls
+            .iter()
+            .map(|v| format!("  {}", v))
+            .collect::<Vec<String>>()
+            .join("\n");
+        println!("Listening on:\n{}\n", info);
+    }
+
+    Ok(())
+}
+
 fn handle_err<T>(err: Box<dyn std::error::Error>) -> T {
     eprintln!("error: {}", err);
     std::process::exit(1);

src/server.rs

@@ -1,4 +1,5 @@
 use crate::auth::{generate_www_auth, valid_digest};
+use crate::streamer::Streamer;
 use crate::{Args, BoxResult};
 use xml::escape::escape_str_pcdata;
 
@@ -8,129 +9,70 @@ use async_zip::Compression;
 use chrono::{TimeZone, Utc};
 use futures::stream::StreamExt;
 use futures::TryStreamExt;
-use get_if_addrs::get_if_addrs;
 use headers::{
-    AcceptRanges, AccessControlAllowHeaders, AccessControlAllowOrigin, ContentLength, ContentRange,
+    AcceptRanges, AccessControlAllowCredentials, AccessControlAllowHeaders,
-    ContentType, ETag, HeaderMap, HeaderMapExt, IfModifiedSince, IfNoneMatch, IfRange,
+    AccessControlAllowOrigin, Connection, ContentLength, ContentType, ETag, HeaderMap,
-    LastModified, Range,
+    HeaderMapExt, IfModifiedSince, IfNoneMatch, IfRange, LastModified, Range,
 };
 use hyper::header::{
-    HeaderValue, ACCEPT, AUTHORIZATION, CONTENT_DISPOSITION, CONTENT_TYPE, ORIGIN, RANGE,
+    HeaderValue, ACCEPT, AUTHORIZATION, CONTENT_DISPOSITION, CONTENT_LENGTH, CONTENT_RANGE,
-    WWW_AUTHENTICATE,
+    CONTENT_TYPE, ORIGIN, RANGE, WWW_AUTHENTICATE,
 };
-use hyper::service::{make_service_fn, service_fn};
 use hyper::{Body, Method, StatusCode, Uri};
 use percent_encoding::percent_decode;
-use rustls::ServerConfig;
 use serde::Serialize;
-use std::convert::Infallible;
 use std::fs::Metadata;
-use std::net::{IpAddr, SocketAddr};
+use std::io::SeekFrom;
+use std::net::SocketAddr;
 use std::path::{Path, PathBuf};
 use std::sync::Arc;
 use std::time::SystemTime;
 use tokio::fs::File;
-use tokio::io::{AsyncReadExt, AsyncSeekExt, AsyncWrite};
+use tokio::io::{AsyncSeekExt, AsyncWrite};
-use tokio::net::TcpListener;
 use tokio::{fs, io};
-use tokio_rustls::TlsAcceptor;
+use tokio_util::io::StreamReader;
-use tokio_util::codec::{BytesCodec, FramedRead};
-use tokio_util::io::{ReaderStream, StreamReader};
 use uuid::Uuid;
 
-type Request = hyper::Request<Body>;
+pub type Request = hyper::Request<Body>;
-type Response = hyper::Response<Body>;
+pub type Response = hyper::Response<Body>;
 
 const INDEX_HTML: &str = include_str!("../assets/index.html");
 const INDEX_CSS: &str = include_str!("../assets/index.css");
 const INDEX_JS: &str = include_str!("../assets/index.js");
 const FAVICON_ICO: &[u8] = include_bytes!("../assets/favicon.ico");
 const INDEX_NAME: &str = "index.html";
-const BUF_SIZE: usize = 1024 * 16;
+const BUF_SIZE: usize = 65536;
 
-macro_rules! status {
+pub struct Server {
-    ($res:ident, $status:expr) => {
-        *$res.status_mut() = $status;
-        *$res.body_mut() = Body::from($status.canonical_reason().unwrap_or_default());
-    };
-}
-
-pub async fn serve(args: Args) -> BoxResult<()> {
-    let args = Arc::new(args);
-    let inner = Arc::new(InnerService::new(args.clone()));
-    match args.tls.clone() {
-        Some((certs, key)) => {
-            let config = ServerConfig::builder()
-                .with_safe_defaults()
-                .with_no_client_auth()
-                .with_single_cert(certs, key)?;
-            let tls_acceptor = TlsAcceptor::from(Arc::new(config));
-            let arc_acceptor = Arc::new(tls_acceptor);
-            let listener = TcpListener::bind(&args.addr).await?;
-            let incoming = tokio_stream::wrappers::TcpListenerStream::new(listener);
-            let incoming =
-                hyper::server::accept::from_stream(incoming.filter_map(|socket| async {
-                    match socket {
-                        Ok(stream) => match arc_acceptor.clone().accept(stream).await {
-                            Ok(val) => Some(Ok::<_, Infallible>(val)),
-                            Err(_) => None,
-                        },
-                        Err(_) => None,
-                    }
-                }));
-            let server = hyper::Server::builder(incoming).serve(make_service_fn(move |_| {
-                let inner = inner.clone();
-                async move {
-                    Ok::<_, Infallible>(service_fn(move |req| {
-                        let inner = inner.clone();
-                        inner.call(req)
-                    }))
-                }
-            }));
-            print_listening(&args.addr, &args.uri_prefix, true);
-            server.await?;
-        }
-        None => {
-            let server = hyper::Server::try_bind(&args.addr)?.serve(make_service_fn(move |_| {
-                let inner = inner.clone();
-                async move {
-                    Ok::<_, Infallible>(service_fn(move |req| {
-                        let inner = inner.clone();
-                        inner.call(req)
-                    }))
-                }
-            }));
-            print_listening(&args.addr, &args.uri_prefix, false);
-            server.await?;
-        }
-    }
-    Ok(())
-}
-
-struct InnerService {
     args: Arc<Args>,
 }
 
-impl InnerService {
+impl Server {
     pub fn new(args: Arc<Args>) -> Self {
         Self { args }
     }
 
-    pub async fn call(self: Arc<Self>, req: Request) -> Result<Response, hyper::Error> {
+    pub async fn call(
+        self: Arc<Self>,
+        req: Request,
+        addr: SocketAddr,
+    ) -> Result<Response, hyper::Error> {
         let method = req.method().clone();
         let uri = req.uri().clone();
         let cors = self.args.cors;
 
         let mut res = match self.handle(req).await {
             Ok(res) => {
-                info!(r#""{} {}" - {}"#, method, uri, res.status());
+                let status = res.status().as_u16();
+                info!(r#"{} "{} {}" - {}"#, addr.ip(), method, uri, status,);
                 res
             }
             Err(err) => {
                 let mut res = Response::default();
                 let status = StatusCode::INTERNAL_SERVER_ERROR;
-                status!(res, status);
+                *res.status_mut() = status;
-                error!(r#""{} {}" - {} {}"#, method, uri, status, err);
+                let status = status.as_u16();
+                error!(r#"{} "{} {}" - {} {}"#, addr.ip(), method, uri, status, err);
                 res
             }
         };
@@ -149,11 +91,18 @@ impl InnerService {
         }
 
         let req_path = req.uri().path();
+        let headers = req.headers();
+        let method = req.method().clone();
+
+        if req_path == "/favicon.ico" && method == Method::GET {
+            self.handle_send_favicon(req.headers(), &mut res).await?;
+            return Ok(res);
+        }
 
         let path = match self.extract_path(req_path) {
             Some(v) => v,
             None => {
-                status!(res, StatusCode::FORBIDDEN);
+                status_forbid(&mut res);
                 return Ok(res);
             }
         };
@@ -172,64 +121,53 @@ impl InnerService {
         let render_spa = self.args.render_spa;
 
         if !self.args.allow_symlink && !is_miss && !self.is_root_contained(path).await {
-            status!(res, StatusCode::NOT_FOUND);
+            status_not_found(&mut res);
-            return Ok(res);
-        }
-        if is_miss && path.ends_with("favicon.ico") {
-            *res.body_mut() = Body::from(FAVICON_ICO);
-            res.headers_mut()
-                .insert("content-type", "image/x-icon".parse().unwrap());
             return Ok(res);
         }
 
-        let headers = req.headers();
+        match method {
-
+            Method::GET | Method::HEAD => {
-        match req.method() {
+                let head_only = method == Method::HEAD;
-            &Method::GET => {
                 if is_dir {
                     if render_index || render_spa {
-                        self.handle_render_index(path, headers, &mut res).await?;
+                        self.handle_render_index(path, headers, head_only, &mut res)
+                            .await?;
                     } else if query == "zip" {
-                        self.handle_zip_dir(path, &mut res).await?;
+                        self.handle_zip_dir(path, head_only, &mut res).await?;
-                    } else if query.starts_with("q=") {
+                    } else if let Some(q) = query.strip_prefix("q=") {
-                        self.handle_query_dir(path, &query[3..], &mut res).await?;
+                        self.handle_query_dir(path, q, head_only, &mut res).await?;
                     } else {
-                        self.handle_ls_dir(path, true, &mut res).await?;
+                        self.handle_ls_dir(path, true, head_only, &mut res).await?;
                     }
                 } else if is_file {
-                    self.handle_send_file(path, headers, &mut res).await?;
+                    self.handle_send_file(path, headers, head_only, &mut res)
+                        .await?;
                 } else if render_spa {
-                    self.handle_render_spa(path, headers, &mut res).await?;
+                    self.handle_render_spa(path, headers, head_only, &mut res)
+                        .await?;
                 } else if allow_upload && req_path.ends_with('/') {
-                    self.handle_ls_dir(path, false, &mut res).await?;
+                    self.handle_ls_dir(path, false, head_only, &mut res).await?;
                 } else {
-                    status!(res, StatusCode::NOT_FOUND);
+                    status_not_found(&mut res);
                 }
             }
-            &Method::OPTIONS => {
+            Method::OPTIONS => {
-                self.handle_method_options(&mut res);
+                set_webdav_headers(&mut res);
             }
-            &Method::PUT => {
+            Method::PUT => {
                 if !allow_upload || (!allow_delete && is_file && size > 0) {
-                    status!(res, StatusCode::FORBIDDEN);
+                    status_forbid(&mut res);
                 } else {
                     self.handle_upload(path, req, &mut res).await?;
                 }
             }
-            &Method::DELETE => {
+            Method::DELETE => {
                 if !allow_delete {
-                    status!(res, StatusCode::FORBIDDEN);
+                    status_forbid(&mut res);
                 } else if !is_miss {
                     self.handle_delete(path, is_dir, &mut res).await?
                 } else {
-                    status!(res, StatusCode::NOT_FOUND);
+                    status_not_found(&mut res);
-                }
-            }
-            &Method::HEAD => {
-                if is_miss {
-                    status!(res, StatusCode::NOT_FOUND);
-                } else {
-                    status!(res, StatusCode::OK);
                 }
             }
             method => match method.as_str() {
@@ -239,41 +177,57 @@ impl InnerService {
                     } else if is_file {
                         self.handle_propfind_file(path, &mut res).await?;
                     } else {
-                        status!(res, StatusCode::NOT_FOUND);
+                        status_not_found(&mut res);
                     }
                 }
                 "PROPPATCH" => {
                     if is_file {
                         self.handle_proppatch(req_path, &mut res).await?;
                     } else {
-                        status!(res, StatusCode::NOT_FOUND);
+                        status_not_found(&mut res);
                     }
                 }
-                "MKCOL" if allow_upload && is_miss => self.handle_mkcol(path, &mut res).await?,
+                "MKCOL" => {
-                "COPY" if allow_upload && !is_miss => {
+                    if !allow_upload || !is_miss {
+                        status_forbid(&mut res);
+                    } else {
+                        self.handle_mkcol(path, &mut res).await?;
+                    }
+                }
+                "COPY" => {
+                    if !allow_upload {
+                        status_forbid(&mut res);
+                    } else if is_miss {
+                        status_not_found(&mut res);
+                    } else {
                         self.handle_copy(path, headers, &mut res).await?
                     }
-                "MOVE" if allow_upload && allow_delete && !is_miss => {
+                }
+                "MOVE" => {
+                    if !allow_upload || !allow_delete {
+                        status_forbid(&mut res);
+                    } else if is_miss {
+                        status_not_found(&mut res);
+                    } else {
                         self.handle_move(path, headers, &mut res).await?
                     }
+                }
                 "LOCK" => {
                     // Fake lock
                     if is_file {
                         self.handle_lock(req_path, &mut res).await?;
                     } else {
-                        status!(res, StatusCode::NOT_FOUND);
+                        status_not_found(&mut res);
                     }
                 }
                 "UNLOCK" => {
                     // Fake unlock
                     if is_miss {
-                        status!(res, StatusCode::NOT_FOUND);
+                        status_not_found(&mut res);
-                    } else {
-                        status!(res, StatusCode::OK);
                     }
                 }
                 _ => {
-                    status!(res, StatusCode::METHOD_NOT_ALLOWED);
+                    *res.status_mut() = StatusCode::METHOD_NOT_ALLOWED;
                 }
             },
         }
@@ -288,7 +242,13 @@ impl InnerService {
     ) -> BoxResult<()> {
         ensure_path_parent(path).await?;
 
-        let mut file = fs::File::create(&path).await?;
+        let mut file = match fs::File::create(&path).await {
+            Ok(v) => v,
+            Err(_) => {
+                status_forbid(res);
+                return Ok(());
+            }
+        };
 
         let body_with_io_error = req
             .body_mut()
@@ -300,7 +260,7 @@ impl InnerService {
 
         io::copy(&mut body_reader, &mut file).await?;
 
-        status!(res, StatusCode::CREATED);
+        *res.status_mut() = StatusCode::CREATED;
         Ok(())
     }
 
@@ -310,28 +270,35 @@ impl InnerService {
             false => fs::remove_file(path).await?,
         }
 
-        status!(res, StatusCode::NO_CONTENT);
+        status_no_content(res);
         Ok(())
     }
 
-    async fn handle_ls_dir(&self, path: &Path, exist: bool, res: &mut Response) -> BoxResult<()> {
+    async fn handle_ls_dir(
+        &self,
+        path: &Path,
+        exist: bool,
+        head_only: bool,
+        res: &mut Response,
+    ) -> BoxResult<()> {
         let mut paths = vec![];
         if exist {
             paths = match self.list_dir(path, path).await {
                 Ok(paths) => paths,
                 Err(_) => {
-                    status!(res, StatusCode::FORBIDDEN);
+                    status_forbid(res);
                     return Ok(());
                 }
             }
         };
-        self.send_index(path, paths, res)
+        self.send_index(path, paths, exist, head_only, res)
     }
 
     async fn handle_query_dir(
         &self,
         path: &Path,
         query: &str,
+        head_only: bool,
         res: &mut Response,
     ) -> BoxResult<()> {
         let mut paths: Vec<PathItem> = vec![];
@@ -354,23 +321,20 @@ impl InnerService {
                 }
             }
         }
-        self.send_index(path, paths, res)
+        self.send_index(path, paths, true, head_only, res)
     }
 
-    async fn handle_zip_dir(&self, path: &Path, res: &mut Response) -> BoxResult<()> {
+    async fn handle_zip_dir(
+        &self,
+        path: &Path,
+        head_only: bool,
+        res: &mut Response,
+    ) -> BoxResult<()> {
         let (mut writer, reader) = tokio::io::duplex(BUF_SIZE);
         let filename = path
             .file_name()
             .and_then(|v| v.to_str())
             .ok_or_else(|| format!("Failed to get name of `{}`", path.display()))?;
-        let path = path.to_owned();
-        tokio::spawn(async move {
-            if let Err(e) = zip_dir(&mut writer, &path).await {
-                error!("Failed to zip {}, {}", path.display(), e);
-            }
-        });
-        let stream = ReaderStream::new(reader);
-        *res.body_mut() = Body::wrap_stream(stream);
         res.headers_mut().insert(
             CONTENT_DISPOSITION,
             HeaderValue::from_str(&format!(
@@ -379,6 +343,19 @@ impl InnerService {
             ))
             .unwrap(),
         );
+        res.headers_mut()
+            .insert("content-type", HeaderValue::from_static("application/zip"));
+        if head_only {
+            return Ok(());
+        }
+        let path = path.to_owned();
+        tokio::spawn(async move {
+            if let Err(e) = zip_dir(&mut writer, &path).await {
+                error!("Failed to zip {}, {}", path.display(), e);
+            }
+        });
+        let reader = Streamer::new(reader, BUF_SIZE);
+        *res.body_mut() = Body::wrap_stream(reader.into_stream());
         Ok(())
     }
 
@@ -386,6 +363,7 @@ impl InnerService {
         &self,
         path: &Path,
         headers: &HeaderMap<HeaderValue>,
+        head_only: bool,
         res: &mut Response,
     ) -> BoxResult<()> {
         let path = path.join(INDEX_NAME);
@@ -395,9 +373,10 @@ impl InnerService {
             .map(|v| v.is_file())
             .unwrap_or_default()
         {
-            self.handle_send_file(&path, headers, res).await?;
+            self.handle_send_file(&path, headers, head_only, res)
+                .await?;
         } else {
-            status!(res, StatusCode::NOT_FOUND);
+            status_not_found(res)
         }
         Ok(())
     }
@@ -406,13 +385,34 @@ impl InnerService {
         &self,
         path: &Path,
         headers: &HeaderMap<HeaderValue>,
+        head_only: bool,
         res: &mut Response,
     ) -> BoxResult<()> {
         if path.extension().is_none() {
             let path = self.args.path.join(INDEX_NAME);
-            self.handle_send_file(&path, headers, res).await?;
+            self.handle_send_file(&path, headers, head_only, res)
+                .await?;
         } else {
-            status!(res, StatusCode::NOT_FOUND);
+            status_not_found(res)
+        }
+        Ok(())
+    }
+
+    async fn handle_send_favicon(
+        &self,
+        headers: &HeaderMap<HeaderValue>,
+        res: &mut Response,
+    ) -> BoxResult<()> {
+        let path = self.args.path.join("favicon.ico");
+        let meta = fs::metadata(&path).await.ok();
+        let is_file = meta.map(|v| v.is_file()).unwrap_or_default();
+        if is_file {
+            self.handle_send_file(path.as_path(), headers, false, res)
+                .await?;
+        } else {
+            *res.body_mut() = Body::from(FAVICON_ICO);
+            res.headers_mut()
+                .insert("content-type", HeaderValue::from_static("image/x-icon"));
         }
         Ok(())
     }
@@ -421,11 +421,12 @@ impl InnerService {
         &self,
         path: &Path,
         headers: &HeaderMap<HeaderValue>,
+        head_only: bool,
         res: &mut Response,
     ) -> BoxResult<()> {
         let (file, meta) = tokio::join!(fs::File::open(path), fs::metadata(path),);
         let (mut file, meta) = (file?, meta?);
-        let mut maybe_range = true;
+        let mut use_range = true;
         if let Some((etag, last_modified)) = extract_cache_headers(&meta) {
             let cached = {
                 if let Some(if_none_match) = headers.typed_get::<IfNoneMatch>() {
@@ -436,65 +437,78 @@ impl InnerService {
                     false
                 }
             };
-            res.headers_mut().typed_insert(last_modified);
-            res.headers_mut().typed_insert(etag.clone());
             if cached {
-                status!(res, StatusCode::NOT_MODIFIED);
+                *res.status_mut() = StatusCode::NOT_MODIFIED;
                 return Ok(());
             }
+
+            res.headers_mut().typed_insert(last_modified);
+            res.headers_mut().typed_insert(etag.clone());
+
             if headers.typed_get::<Range>().is_some() {
-                maybe_range = headers
+                use_range = headers
                     .typed_get::<IfRange>()
                     .map(|if_range| !if_range.is_modified(Some(&etag), Some(&last_modified)))
                     // Always be fresh if there is no validators
                     .unwrap_or(true);
             } else {
-                maybe_range = false;
+                use_range = false;
             }
         }
-        let file_range = if maybe_range {
+
-            if let Some(content_range) = headers
+        let range = if use_range {
-                .typed_get::<Range>()
+            parse_range(headers)
-                .and_then(|range| to_content_range(&range, meta.len()))
-            {
-                res.headers_mut().typed_insert(content_range.clone());
-                *res.status_mut() = StatusCode::PARTIAL_CONTENT;
-                content_range.bytes_range()
-            } else {
-                None
-            }
         } else {
             None
         };
+
         if let Some(mime) = mime_guess::from_path(&path).first() {
             res.headers_mut().typed_insert(ContentType::from(mime));
-        }
-        let body = if let Some((begin, end)) = file_range {
-            file.seek(io::SeekFrom::Start(begin)).await?;
-            let stream = FramedRead::new(file.take(end - begin + 1), BytesCodec::new());
-            Body::wrap_stream(stream)
         } else {
-            let stream = FramedRead::new(file, BytesCodec::new());
+            res.headers_mut().insert(
-            Body::wrap_stream(stream)
+                CONTENT_TYPE,
-        };
+                HeaderValue::from_static("application/octet-stream"),
-        *res.body_mut() = body;
+            );
-        res.headers_mut().typed_insert(AcceptRanges::bytes());
-        res.headers_mut()
-            .typed_insert(ContentLength(meta.len() as u64));
-
-        Ok(())
         }
 
-    fn handle_method_options(&self, res: &mut Response) {
+        res.headers_mut().typed_insert(AcceptRanges::bytes());
-        res.headers_mut().insert(
-            "Allow",
-            "GET,HEAD,PUT,OPTIONS,DELETE,PROPFIND,COPY,MOVE"
-                .parse()
-                .unwrap(),
-        );
-        res.headers_mut().insert("DAV", "1".parse().unwrap());
 
-        status!(res, StatusCode::NO_CONTENT);
+        let size = meta.len();
+
+        if let Some(range) = range {
+            if range
+                .end
+                .map_or_else(|| range.start < size, |v| v >= range.start)
+                && file.seek(SeekFrom::Start(range.start)).await.is_ok()
+            {
+                let end = range.end.unwrap_or(size - 1).min(size - 1);
+                let part_size = end - range.start + 1;
+                let reader = Streamer::new(file, BUF_SIZE);
+                *res.status_mut() = StatusCode::PARTIAL_CONTENT;
+                let content_range = format!("bytes {}-{}/{}", range.start, end, size);
+                res.headers_mut()
+                    .insert(CONTENT_RANGE, content_range.parse().unwrap());
+                res.headers_mut()
+                    .insert(CONTENT_LENGTH, format!("{}", part_size).parse().unwrap());
+                if head_only {
+                    return Ok(());
+                }
+                *res.body_mut() = Body::wrap_stream(reader.into_stream_sized(part_size));
+            } else {
+                *res.status_mut() = StatusCode::RANGE_NOT_SATISFIABLE;
+                res.headers_mut()
+                    .insert(CONTENT_RANGE, format!("bytes */{}", size).parse().unwrap());
+            }
+        } else {
+            res.headers_mut()
+                .insert(CONTENT_LENGTH, format!("{}", size).parse().unwrap());
+            if head_only {
+                return Ok(());
+            }
+            let reader = Streamer::new(file, BUF_SIZE);
+            *res.body_mut() = Body::wrap_stream(reader.into_stream());
+        }
+        Ok(())
     }
 
     async fn handle_propfind_dir(
@@ -507,18 +521,18 @@ impl InnerService {
             Some(v) => match v.to_str().ok().and_then(|v| v.parse().ok()) {
                 Some(v) => v,
                 None => {
-                    status!(res, StatusCode::BAD_REQUEST);
+                    *res.status_mut() = StatusCode::BAD_REQUEST;
                     return Ok(());
                 }
             },
-            None => 0,
+            None => 1,
         };
         let mut paths = vec![self.to_pathitem(path, &self.args.path).await?.unwrap()];
-        if depth > 0 {
+        if depth != 0 {
             match self.list_dir(path, &self.args.path).await {
                 Ok(child) => paths.extend(child),
                 Err(_) => {
-                    status!(res, StatusCode::FORBIDDEN);
+                    status_forbid(res);
                     return Ok(());
                 }
             }
@@ -538,14 +552,14 @@ impl InnerService {
         if let Some(pathitem) = self.to_pathitem(path, &self.args.path).await? {
             res_multistatus(res, &pathitem.to_dav_xml(self.args.uri_prefix.as_str()));
         } else {
-            status!(res, StatusCode::NOT_FOUND);
+            status_not_found(res);
         }
         Ok(())
     }
 
     async fn handle_mkcol(&self, path: &Path, res: &mut Response) -> BoxResult<()> {
         fs::create_dir_all(path).await?;
-        status!(res, StatusCode::CREATED);
+        *res.status_mut() = StatusCode::CREATED;
         Ok(())
     }
 
@@ -558,14 +572,14 @@ impl InnerService {
         let dest = match self.extract_dest(headers) {
             Some(dest) => dest,
             None => {
-                status!(res, StatusCode::BAD_REQUEST);
+                *res.status_mut() = StatusCode::BAD_REQUEST;
                 return Ok(());
             }
         };
 
         let meta = fs::symlink_metadata(path).await?;
         if meta.is_dir() {
-            status!(res, StatusCode::BAD_REQUEST);
+            status_forbid(res);
             return Ok(());
         }
 
@@ -573,7 +587,7 @@ impl InnerService {
 
         fs::copy(path, &dest).await?;
 
-        status!(res, StatusCode::NO_CONTENT);
+        status_no_content(res);
         Ok(())
     }
 
@@ -586,7 +600,7 @@ impl InnerService {
         let dest = match self.extract_dest(headers) {
             Some(dest) => dest,
             None => {
-                status!(res, StatusCode::BAD_REQUEST);
+                *res.status_mut() = StatusCode::BAD_REQUEST;
                 return Ok(());
             }
         };
@@ -595,7 +609,7 @@ impl InnerService {
 
         fs::rename(path, &dest).await?;
 
-        status!(res, StatusCode::NO_CONTENT);
+        status_no_content(res);
         Ok(())
     }
 
@@ -608,7 +622,7 @@ impl InnerService {
 
         res.headers_mut().insert(
             "content-type",
-            "application/xml; charset=utf-8".parse().unwrap(),
+            HeaderValue::from_static("application/xml; charset=utf-8"),
         );
         res.headers_mut()
             .insert("lock-token", format!("<{}>", token).parse().unwrap());
@@ -644,6 +658,8 @@ impl InnerService {
         &self,
         path: &Path,
         mut paths: Vec<PathItem>,
+        exist: bool,
+        head_only: bool,
         res: &mut Response,
     ) -> BoxResult<()> {
         paths.sort_unstable();
@@ -656,6 +672,7 @@ impl InnerService {
             paths,
             allow_upload: self.args.allow_upload,
             allow_delete: self.args.allow_delete,
+            dir_exists: exist,
         };
         let data = serde_json::to_string(&data).unwrap();
         let output = INDEX_HTML.replace(
@@ -664,7 +681,10 @@ impl InnerService {
                 r#"
 <title>Files in {}/ - Duf</title>
 <style>{}</style>
-<script>var DATA = {}; {}</script>
+<script>
+const DATA = 
+{}
+{}</script>
 "#,
                 rel_path.display(),
                 INDEX_CSS,
@@ -672,9 +692,14 @@ impl InnerService {
                 INDEX_JS
             ),
         );
-        *res.body_mut() = output.into();
         res.headers_mut()
             .typed_insert(ContentType::from(mime_guess::mime::TEXT_HTML_UTF_8));
+        res.headers_mut()
+            .typed_insert(ContentLength(output.as_bytes().len() as u64));
+        if head_only {
+            return Ok(());
+        }
+        *res.body_mut() = output.into();
         Ok(())
     }
 
@@ -699,7 +724,9 @@ impl InnerService {
         };
         if !pass {
             let value = generate_www_auth(false);
-            status!(res, StatusCode::UNAUTHORIZED);
+            set_webdav_headers(res);
+            *res.status_mut() = StatusCode::UNAUTHORIZED;
+            res.headers_mut().typed_insert(Connection::close());
             res.headers_mut()
                 .insert(WWW_AUTHENTICATE, value.parse().unwrap());
         }
@@ -780,15 +807,9 @@ impl InnerService {
             PathType::Dir | PathType::SymlinkDir => None,
             PathType::File | PathType::SymlinkFile => Some(meta.len()),
         };
-        let base_name = rel_path
-            .file_name()
-            .and_then(|v| v.to_str())
-            .unwrap_or("/")
-            .to_owned();
         let name = normalize_path(rel_path);
         Ok(Some(PathItem {
             path_type,
-            base_name,
             name,
             mtime,
             size,
@@ -802,24 +823,33 @@ struct IndexData {
     paths: Vec<PathItem>,
     allow_upload: bool,
     allow_delete: bool,
+    dir_exists: bool,
 }
 
 #[derive(Debug, Serialize, Eq, PartialEq, Ord, PartialOrd)]
 struct PathItem {
     path_type: PathType,
-    base_name: String,
     name: String,
     mtime: u64,
     size: Option<u64>,
 }
 
 impl PathItem {
+    pub fn is_dir(&self) -> bool {
+        self.path_type == PathType::Dir || self.path_type == PathType::SymlinkDir
+    }
+
     pub fn to_dav_xml(&self, prefix: &str) -> String {
         let mtime = Utc.timestamp_millis(self.mtime as i64).to_rfc2822();
+        let mut href = encode_uri(&format!("{}{}", prefix, &self.name));
+        if self.is_dir() && !href.ends_with('/') {
+            href.push('/');
+        }
+        let displayname = escape_str_pcdata(self.base_name());
         match self.path_type {
             PathType::Dir | PathType::SymlinkDir => format!(
                 r#"<D:response>
-<D:href>{}{}</D:href>
+<D:href>{}</D:href>
 <D:propstat>
 <D:prop>
 <D:displayname>{}</D:displayname>
@@ -829,14 +859,11 @@ impl PathItem {
 <D:status>HTTP/1.1 200 OK</D:status>
 </D:propstat>
 </D:response>"#,
-                escape_str_pcdata(prefix),
+                href, displayname, mtime
-                escape_str_pcdata(&self.name),
-                escape_str_pcdata(&self.base_name),
-                mtime
             ),
             PathType::File | PathType::SymlinkFile => format!(
                 r#"<D:response>
-<D:href>{}{}</D:href>
+<D:href>{}</D:href>
 <D:propstat>
 <D:prop>
 <D:displayname>{}</D:displayname>
@@ -847,14 +874,19 @@ impl PathItem {
 <D:status>HTTP/1.1 200 OK</D:status>
 </D:propstat>
 </D:response>"#,
-                escape_str_pcdata(prefix),
+                href,
-                escape_str_pcdata(&self.name),
+                displayname,
-                escape_str_pcdata(&self.base_name),
                 self.size.unwrap_or_default(),
                 mtime
             ),
         }
     }
+    fn base_name(&self) -> &str {
+        Path::new(&self.name)
+            .file_name()
+            .and_then(|v| v.to_str())
+            .unwrap_or_default()
+    }
 }
 
 #[derive(Debug, Serialize, Eq, PartialEq, Ord, PartialOrd)]
@@ -892,6 +924,9 @@ async fn ensure_path_parent(path: &Path) -> BoxResult<()> {
 fn add_cors(res: &mut Response) {
     res.headers_mut()
         .typed_insert(AccessControlAllowOrigin::ANY);
+    res.headers_mut()
+        .typed_insert(AccessControlAllowCredentials);
+
     res.headers_mut().typed_insert(
         vec![RANGE, CONTENT_TYPE, ACCEPT, ORIGIN, WWW_AUTHENTICATE]
             .into_iter()
@@ -903,7 +938,7 @@ fn res_multistatus(res: &mut Response, content: &str) {
     *res.status_mut() = StatusCode::MULTI_STATUS;
     res.headers_mut().insert(
         "content-type",
-        "application/xml; charset=utf-8".parse().unwrap(),
+        HeaderValue::from_static("application/xml; charset=utf-8"),
     );
     *res.body_mut() = Body::from(format!(
         r#"<?xml version="1.0" encoding="utf-8" ?>
@@ -953,76 +988,58 @@ fn extract_cache_headers(meta: &Metadata) -> Option<(ETag, LastModified)> {
     Some((etag, last_modified))
 }
 
-fn to_content_range(range: &Range, complete_length: u64) -> Option<ContentRange> {
+#[derive(Debug)]
-    use core::ops::Bound::{Included, Unbounded};
+struct RangeValue {
-    let mut iter = range.iter();
+    start: u64,
-    let bounds = iter.next();
+    end: Option<u64>,
-
-    if iter.next().is_some() {
-        // Found multiple byte-range-spec. Drop.
-        return None;
-    }
-
-    bounds.and_then(|b| match b {
-        (Included(start), Included(end)) if start <= end && start < complete_length => {
-            ContentRange::bytes(
-                start..=end.min(complete_length.saturating_sub(1)),
-                complete_length,
-            )
-            .ok()
-        }
-        (Included(start), Unbounded) if start < complete_length => {
-            ContentRange::bytes(start.., complete_length).ok()
-        }
-        (Unbounded, Included(end)) if end > 0 => {
-            ContentRange::bytes(complete_length.saturating_sub(end).., complete_length).ok()
-        }
-        _ => None,
-    })
 }
 
-fn print_listening(addr: &SocketAddr, prefix: &str, tls: bool) {
+fn parse_range(headers: &HeaderMap<HeaderValue>) -> Option<RangeValue> {
-    let prefix = encode_uri(prefix.trim_end_matches('/'));
+    let range_hdr = headers.get(RANGE)?;
-    let addrs = retrieve_listening_addrs(addr);
+    let hdr = range_hdr.to_str().ok()?;
-    let protocol = if tls { "https" } else { "http" };
+    let mut sp = hdr.splitn(2, '=');
-    if addrs.len() == 1 {
+    let units = sp.next().unwrap();
-        eprintln!("Listening on {}://{}{}", protocol, addr, prefix);
+    if units == "bytes" {
+        let range = sp.next()?;
+        let mut sp_range = range.splitn(2, '-');
+        let start: u64 = sp_range.next().unwrap().parse().ok()?;
+        let end: Option<u64> = if let Some(end) = sp_range.next() {
+            if end.is_empty() {
+                None
             } else {
-        eprintln!("Listening on:");
+                Some(end.parse().ok()?)
-        for addr in addrs {
-            eprintln!("  {}://{}{}", protocol, addr, prefix);
             }
-        eprintln!();
-    }
-}
-
-fn retrieve_listening_addrs(addr: &SocketAddr) -> Vec<SocketAddr> {
-    let ip = addr.ip();
-    let port = addr.port();
-    if ip.is_unspecified() {
-        if let Ok(interfaces) = get_if_addrs() {
-            let mut ifaces: Vec<IpAddr> = interfaces
-                .into_iter()
-                .map(|v| v.ip())
-                .filter(|v| {
-                    if ip.is_ipv4() {
-                        v.is_ipv4()
         } else {
-                        v.is_ipv6()
+            None
+        };
+        Some(RangeValue { start, end })
+    } else {
+        None
     }
-                })
-                .collect();
-            ifaces.sort();
-            return ifaces
-                .into_iter()
-                .map(|v| SocketAddr::new(v, port))
-                .collect();
-        }
-    }
-    vec![addr.to_owned()]
 }
 
 fn encode_uri(v: &str) -> String {
     let parts: Vec<_> = v.split('/').map(urlencoding::encode).collect();
     parts.join("/")
 }
+
+fn status_forbid(res: &mut Response) {
+    *res.status_mut() = StatusCode::FORBIDDEN;
+}
+
+fn status_not_found(res: &mut Response) {
+    *res.status_mut() = StatusCode::NOT_FOUND;
+}
+
+fn status_no_content(res: &mut Response) {
+    *res.status_mut() = StatusCode::NO_CONTENT;
+}
+
+fn set_webdav_headers(res: &mut Response) {
+    res.headers_mut().insert(
+        "Allow",
+        HeaderValue::from_static("GET,HEAD,PUT,OPTIONS,DELETE,PROPFIND,COPY,MOVE"),
+    );
+    res.headers_mut()
+        .insert("DAV", HeaderValue::from_static("1,2"));
+}

src/streamer.rs

@@ -0,0 +1,68 @@
+use async_stream::stream;
+use futures::{Stream, StreamExt};
+use std::io::Error;
+use std::pin::Pin;
+use tokio::io::{AsyncRead, AsyncReadExt};
+
+pub struct Streamer<R>
+where
+    R: AsyncRead + Unpin + Send + 'static,
+{
+    reader: R,
+    buf_size: usize,
+}
+
+impl<R> Streamer<R>
+where
+    R: AsyncRead + Unpin + Send + 'static,
+{
+    #[inline]
+    pub fn new(reader: R, buf_size: usize) -> Self {
+        Self { reader, buf_size }
+    }
+    pub fn into_stream(
+        mut self,
+    ) -> Pin<Box<impl ?Sized + Stream<Item = Result<Vec<u8>, Error>> + 'static>> {
+        let stream = stream! {
+            loop {
+                let mut buf = vec![0; self.buf_size];
+                let r = self.reader.read(&mut buf).await?;
+                if r == 0 {
+                    break
+                }
+                buf.truncate(r);
+                yield Ok(buf);
+            }
+        };
+        stream.boxed()
+    }
+    // allow truncation as truncated remaining is always less than buf_size: usize
+    pub fn into_stream_sized(
+        mut self,
+        max_length: u64,
+    ) -> Pin<Box<impl ?Sized + Stream<Item = Result<Vec<u8>, Error>> + 'static>> {
+        let stream = stream! {
+        let mut remaining = max_length;
+            loop {
+                if remaining == 0 {
+                    break;
+                }
+                let bs = if remaining >= self.buf_size as u64 {
+                    self.buf_size
+                } else {
+                    remaining as usize
+                };
+                let mut buf = vec![0; bs];
+                let r = self.reader.read(&mut buf).await?;
+                if r == 0 {
+                    break;
+                } else {
+                    buf.truncate(r);
+                    yield Ok(buf);
+                }
+                remaining -= r as u64;
+            }
+        };
+        stream.boxed()
+    }
+}

src/tls.rs

@@ -0,0 +1,158 @@
+use core::task::{Context, Poll};
+use futures::ready;
+use hyper::server::accept::Accept;
+use hyper::server::conn::{AddrIncoming, AddrStream};
+use rustls::{Certificate, PrivateKey};
+use std::future::Future;
+use std::net::SocketAddr;
+use std::pin::Pin;
+use std::sync::Arc;
+use std::{fs, io};
+use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
+use tokio_rustls::rustls::ServerConfig;
+
+enum State {
+    Handshaking(tokio_rustls::Accept<AddrStream>),
+    Streaming(tokio_rustls::server::TlsStream<AddrStream>),
+}
+
+// tokio_rustls::server::TlsStream doesn't expose constructor methods,
+// so we have to TlsAcceptor::accept and handshake to have access to it
+// TlsStream implements AsyncRead/AsyncWrite handshaking tokio_rustls::Accept first
+pub struct TlsStream {
+    state: State,
+    remote_addr: SocketAddr,
+}
+
+impl TlsStream {
+    fn new(stream: AddrStream, config: Arc<ServerConfig>) -> TlsStream {
+        let remote_addr = stream.remote_addr();
+        let accept = tokio_rustls::TlsAcceptor::from(config).accept(stream);
+        TlsStream {
+            state: State::Handshaking(accept),
+            remote_addr,
+        }
+    }
+    pub fn remote_addr(&self) -> SocketAddr {
+        self.remote_addr
+    }
+}
+
+impl AsyncRead for TlsStream {
+    fn poll_read(
+        self: Pin<&mut Self>,
+        cx: &mut Context,
+        buf: &mut ReadBuf,
+    ) -> Poll<io::Result<()>> {
+        let pin = self.get_mut();
+        match pin.state {
+            State::Handshaking(ref mut accept) => match ready!(Pin::new(accept).poll(cx)) {
+                Ok(mut stream) => {
+                    let result = Pin::new(&mut stream).poll_read(cx, buf);
+                    pin.state = State::Streaming(stream);
+                    result
+                }
+                Err(err) => Poll::Ready(Err(err)),
+            },
+            State::Streaming(ref mut stream) => Pin::new(stream).poll_read(cx, buf),
+        }
+    }
+}
+
+impl AsyncWrite for TlsStream {
+    fn poll_write(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        let pin = self.get_mut();
+        match pin.state {
+            State::Handshaking(ref mut accept) => match ready!(Pin::new(accept).poll(cx)) {
+                Ok(mut stream) => {
+                    let result = Pin::new(&mut stream).poll_write(cx, buf);
+                    pin.state = State::Streaming(stream);
+                    result
+                }
+                Err(err) => Poll::Ready(Err(err)),
+            },
+            State::Streaming(ref mut stream) => Pin::new(stream).poll_write(cx, buf),
+        }
+    }
+
+    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        match self.state {
+            State::Handshaking(_) => Poll::Ready(Ok(())),
+            State::Streaming(ref mut stream) => Pin::new(stream).poll_flush(cx),
+        }
+    }
+
+    fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        match self.state {
+            State::Handshaking(_) => Poll::Ready(Ok(())),
+            State::Streaming(ref mut stream) => Pin::new(stream).poll_shutdown(cx),
+        }
+    }
+}
+
+pub struct TlsAcceptor {
+    config: Arc<ServerConfig>,
+    incoming: AddrIncoming,
+}
+
+impl TlsAcceptor {
+    pub fn new(config: Arc<ServerConfig>, incoming: AddrIncoming) -> TlsAcceptor {
+        TlsAcceptor { config, incoming }
+    }
+}
+
+impl Accept for TlsAcceptor {
+    type Conn = TlsStream;
+    type Error = io::Error;
+
+    fn poll_accept(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<Self::Conn, Self::Error>>> {
+        let pin = self.get_mut();
+        match ready!(Pin::new(&mut pin.incoming).poll_accept(cx)) {
+            Some(Ok(sock)) => Poll::Ready(Some(Ok(TlsStream::new(sock, pin.config.clone())))),
+            Some(Err(e)) => Poll::Ready(Some(Err(e))),
+            None => Poll::Ready(None),
+        }
+    }
+}
+
+// Load public certificate from file.
+pub fn load_certs(filename: &str) -> Result<Vec<Certificate>, Box<dyn std::error::Error>> {
+    // Open certificate file.
+    let certfile = fs::File::open(&filename)
+        .map_err(|e| format!("Failed to access `{}`, {}", &filename, e))?;
+    let mut reader = io::BufReader::new(certfile);
+
+    // Load and return certificate.
+    let certs = rustls_pemfile::certs(&mut reader).map_err(|_| "Failed to load certificate")?;
+    if certs.is_empty() {
+        return Err("No supported certificate in file".into());
+    }
+    Ok(certs.into_iter().map(Certificate).collect())
+}
+
+// Load private key from file.
+pub fn load_private_key(filename: &str) -> Result<PrivateKey, Box<dyn std::error::Error>> {
+    // Open keyfile.
+    let keyfile = fs::File::open(&filename)
+        .map_err(|e| format!("Failed to access `{}`, {}", &filename, e))?;
+    let mut reader = io::BufReader::new(keyfile);
+
+    // Load and return a single private key.
+    let keys = rustls_pemfile::read_all(&mut reader)
+        .map_err(|e| format!("There was a problem with reading private key: {:?}", e))?
+        .into_iter()
+        .find_map(|item| match item {
+            rustls_pemfile::Item::RSAKey(key) | rustls_pemfile::Item::PKCS8Key(key) => Some(key),
+            _ => None,
+        })
+        .ok_or("No supported private key in file")?;
+
+    Ok(PrivateKey(keys))
+}

tests/allow.rs

@@ -0,0 +1,61 @@
+mod fixtures;
+mod utils;
+
+use fixtures::{server, Error, TestServer};
+use rstest::rstest;
+
+#[rstest]
+fn default_not_allow_upload(server: TestServer) -> Result<(), Error> {
+    let url = format!("{}file1", server.url());
+    let resp = fetch!(b"PUT", &url).body(b"abc".to_vec()).send()?;
+    assert_eq!(resp.status(), 403);
+    Ok(())
+}
+
+#[rstest]
+fn default_not_allow_delete(server: TestServer) -> Result<(), Error> {
+    let url = format!("{}test.html", server.url());
+    let resp = fetch!(b"DELETE", &url).send()?;
+    assert_eq!(resp.status(), 403);
+    Ok(())
+}
+
+#[rstest]
+fn default_not_exist_dir(server: TestServer) -> Result<(), Error> {
+    let resp = reqwest::blocking::get(format!("{}404/", server.url()))?;
+    assert_eq!(resp.status(), 404);
+    Ok(())
+}
+
+#[rstest]
+fn allow_upload_not_exist_dir(
+    #[with(&["--allow-upload"])] server: TestServer,
+) -> Result<(), Error> {
+    let resp = reqwest::blocking::get(format!("{}404/", server.url()))?;
+    assert_eq!(resp.status(), 200);
+    Ok(())
+}
+
+#[rstest]
+fn allow_upload_no_override(#[with(&["--allow-upload"])] server: TestServer) -> Result<(), Error> {
+    let url = format!("{}index.html", server.url());
+    let resp = fetch!(b"PUT", &url).body(b"abc".to_vec()).send()?;
+    assert_eq!(resp.status(), 403);
+    Ok(())
+}
+
+#[rstest]
+fn allow_delete_no_override(#[with(&["--allow-delete"])] server: TestServer) -> Result<(), Error> {
+    let url = format!("{}index.html", server.url());
+    let resp = fetch!(b"PUT", &url).body(b"abc".to_vec()).send()?;
+    assert_eq!(resp.status(), 403);
+    Ok(())
+}
+
+#[rstest]
+fn allow_upload_delete_can_override(#[with(&["-A"])] server: TestServer) -> Result<(), Error> {
+    let url = format!("{}index.html", server.url());
+    let resp = fetch!(b"PUT", &url).body(b"abc".to_vec()).send()?;
+    assert_eq!(resp.status(), 201);
+    Ok(())
+}

tests/auth.rs

@@ -0,0 +1,38 @@
+mod fixtures;
+mod utils;
+
+use diqwest::blocking::WithDigestAuth;
+use fixtures::{server, Error, TestServer};
+use rstest::rstest;
+
+#[rstest]
+fn no_auth(#[with(&["--auth", "user:pass", "-A"])] server: TestServer) -> Result<(), Error> {
+    let resp = reqwest::blocking::get(server.url())?;
+    assert_eq!(resp.status(), 401);
+    assert!(resp.headers().contains_key("www-authenticate"));
+    let url = format!("{}file1", server.url());
+    let resp = fetch!(b"PUT", &url).body(b"abc".to_vec()).send()?;
+    assert_eq!(resp.status(), 401);
+    Ok(())
+}
+
+#[rstest]
+fn auth(#[with(&["--auth", "user:pass", "-A"])] server: TestServer) -> Result<(), Error> {
+    let url = format!("{}file1", server.url());
+    let resp = fetch!(b"PUT", &url).body(b"abc".to_vec()).send()?;
+    assert_eq!(resp.status(), 401);
+    let resp = fetch!(b"PUT", &url)
+        .body(b"abc".to_vec())
+        .send_with_digest_auth("user", "pass")?;
+    assert_eq!(resp.status(), 201);
+    Ok(())
+}
+
+#[rstest]
+fn auth_skip_access(
+    #[with(&["--auth", "user:pass", "--no-auth-access"])] server: TestServer,
+) -> Result<(), Error> {
+    let resp = reqwest::blocking::get(server.url())?;
+    assert_eq!(resp.status(), 200);
+    Ok(())
+}

tests/bind.rs

@@ -0,0 +1,85 @@
+mod fixtures;
+
+use fixtures::{port, server, tmpdir, Error, TestServer};
+
+use assert_cmd::prelude::*;
+use assert_fs::fixture::TempDir;
+use regex::Regex;
+use rstest::rstest;
+use std::io::{BufRead, BufReader};
+use std::process::{Command, Stdio};
+
+#[rstest]
+#[case(&["-b", "20.205.243.166"])]
+fn bind_fails(tmpdir: TempDir, port: u16, #[case] args: &[&str]) -> Result<(), Error> {
+    Command::cargo_bin("duf")?
+        .env("RUST_LOG", "false")
+        .arg(tmpdir.path())
+        .arg("-p")
+        .arg(port.to_string())
+        .args(args)
+        .assert()
+        .stderr(predicates::str::contains("Failed to bind"))
+        .failure();
+
+    Ok(())
+}
+
+#[rstest]
+#[case(server(&[] as &[&str]), true, true)]
+#[case(server(&["-b", "0.0.0.0"]), true, false)]
+#[case(server(&["-b", "127.0.0.1", "-b", "::1"]), true, true)]
+fn bind_ipv4_ipv6(
+    #[case] server: TestServer,
+    #[case] bind_ipv4: bool,
+    #[case] bind_ipv6: bool,
+) -> Result<(), Error> {
+    assert_eq!(
+        reqwest::blocking::get(format!("http://127.0.0.1:{}", server.port()).as_str()).is_ok(),
+        bind_ipv4
+    );
+    assert_eq!(
+        reqwest::blocking::get(format!("http://[::1]:{}", server.port()).as_str()).is_ok(),
+        bind_ipv6
+    );
+
+    Ok(())
+}
+
+#[rstest]
+#[case(&[] as &[&str])]
+#[case(&["--path-prefix", "/prefix"])]
+fn validate_printed_urls(tmpdir: TempDir, port: u16, #[case] args: &[&str]) -> Result<(), Error> {
+    let mut child = Command::cargo_bin("duf")?
+        .env("RUST_LOG", "false")
+        .arg(tmpdir.path())
+        .arg("-p")
+        .arg(port.to_string())
+        .args(args)
+        .stdout(Stdio::piped())
+        .spawn()?;
+
+    // WARN assumes urls list is terminated by an empty line
+    let url_lines = BufReader::new(child.stdout.take().unwrap())
+        .lines()
+        .map(|line| line.expect("Error reading stdout"))
+        .take_while(|line| !line.is_empty()) /* non-empty lines */
+        .collect::<Vec<_>>();
+    let url_lines = url_lines.join("\n");
+
+    let urls = Regex::new(r"http://[a-zA-Z0-9\.\[\]:/]+")
+        .unwrap()
+        .captures_iter(url_lines.as_str())
+        .map(|caps| caps.get(0).unwrap().as_str())
+        .collect::<Vec<_>>();
+
+    assert!(!urls.is_empty());
+
+    for url in urls {
+        reqwest::blocking::get(url)?.error_for_status()?;
+    }
+
+    child.kill()?;
+
+    Ok(())
+}

tests/cors.rs

@@ -0,0 +1,37 @@
+mod fixtures;
+mod utils;
+
+use fixtures::{server, Error, TestServer};
+use rstest::rstest;
+
+#[rstest]
+fn cors(#[with(&["--cors"])] server: TestServer) -> Result<(), Error> {
+    let resp = reqwest::blocking::get(server.url())?;
+
+    assert_eq!(
+        resp.headers().get("access-control-allow-origin").unwrap(),
+        "*"
+    );
+    assert_eq!(
+        resp.headers().get("access-control-allow-headers").unwrap(),
+        "range, content-type, accept, origin, www-authenticate"
+    );
+
+    Ok(())
+}
+
+#[rstest]
+fn cors_options(#[with(&["--cors"])] server: TestServer) -> Result<(), Error> {
+    let resp = fetch!(b"OPTIONS", server.url()).send()?;
+
+    assert_eq!(
+        resp.headers().get("access-control-allow-origin").unwrap(),
+        "*"
+    );
+    assert_eq!(
+        resp.headers().get("access-control-allow-headers").unwrap(),
+        "range, content-type, accept, origin, www-authenticate"
+    );
+
+    Ok(())
+}

tests/data/cert.pem

@@ -0,0 +1,29 @@
+-----BEGIN CERTIFICATE-----
+MIIFCTCCAvGgAwIBAgIUcegjikATvwNSIbN43QybKWIcKSMwDQYJKoZIhvcNAQEL
+BQAwFDESMBAGA1UEAwwJbG9jYWxob3N0MB4XDTIyMDYxMTA4NTQyMloXDTMyMDYw
+ODA4NTQyMlowFDESMBAGA1UEAwwJbG9jYWxob3N0MIICIjANBgkqhkiG9w0BAQEF
+AAOCAg8AMIICCgKCAgEAo2wdMbFPkX7CAF/Y+hVj5bwm4dlxhwW2Z9Ic2RZFC5w2
+oK2XwyasDBEqDlgv/bN4xObAVlDZ/4/SuTVSDrNB8dtQl7GTWptpbFKJUdNocU88
+wqd4k/cLZg2aiQqnZKD88w/AxXnYw+F8yU0pFGj9GX0S5at3/V1hrBVxVO8Y99bb
+gnJA8NMm0Pw2xYZS++ULuzoECk0xbNdtbtPrIuweI5mMvsJvtiw67EIdl3N9Lj5p
+L4a7X1C0Xk5H4mOcwM0qq3m31HsCW91PMCjU6suo764rx5Jqv0n9HCNxdiSEadCw
+f+GrmKtFOw3DcGPETg5AJR8H3rG1agKKjI+vRtL/tZ7coFOhZKXdjGvvUFcWcqO+
+GppHh16pzJDXi2qeD9Cu5b2ayM2uBnfV7Q3FjOeDqD+BCJ0ClaqNmAD9TF2htzdu
+Inl+G3OJb4cqaYjaF5YmiZISfrimK5eR2I3et5cqnbuDHMKvDfUd9Jgj/2IqPOHJ
+EguuXSO7WNKfQmlTv7EN/xrD6jiB/M8ADaSxjCqTbtKNyCbJlu2Wy9WlDXwPkNW8
+g70T4Br4U4Iy3N/0w2lAAhiizdC2jkehSKmWE2nmixGSXxkSOMgXQXDJ9RBtDQfd
+8ym/ADfyVndUSnHvf9jCH1NPHlFbB7RVSvUHX22Qq63NUvhV32ct+/IyD/qPpl0C
+AwEAAaNTMFEwHQYDVR0OBBYEFKwSSbPXBIkmzja3/cNJyqhWy96WMB8GA1UdIwQY
+MBaAFKwSSbPXBIkmzja3/cNJyqhWy96WMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZI
+hvcNAQELBQADggIBAHcrdu1nGDN5YvcHXzbBx73AC921fmn5xxzeFRO7af157g5h
+4zornLMk4Obp+UGkMbWK4K0NAQXKKm5WjcmoOHNRg7TgTE7b1gcVuS4phdwlIqA6
+eZGg+NWZyeaIJNjdHgWgGoe+S+5Ne1I7sDKiEXrOzITJrDcQgBKFF08kqT6UNY2W
+q90m+olPtrewAMgWllpxJ90u4qifPcwP+neDZJim9MhVYtHHeFsmyzlS185iasj8
+sxvp5HDTopmz0tDuiLHvOMKmyf7vapsnbqEGngQi2qV9rBmldyRLnWSe8u/FN31f
+zhSk1ikSm1cQ/iyL898XexSmTafyaF8ELswdIMHkGZkVQurWeKn3/CEDXokXkpMI
+4dlCSgM7SU+XtcjtXbR8/pHpcW2ZnBR0la/qIv81aNKkJeUkTcPC8BUv4jI/oT6z
+LRrvRjMnHJjnADACuutlNRU4/e7h1XuvlXgFHsp63k7GJXouoIwdHjfkErZXsoEX
+WeS+pPatkT7wbhfgYVwglMRIpgCu++htSRCV/lbSuYzCG6mKtxJyy4eslSjpHNPG
+wELDKgzsgLtuTyNfP458O9i8x6wf9J6eVaHe3nqgqkOnnmQxEYnsPaFUMWG1/DYi
+U+mA/VdQrPe3J4Z082sCe4MVmTzWlWCDpNFFQpv51NbWzc/kuIZuJCAwoZD0
+-----END CERTIFICATE-----

tests/data/generate_tls_certs.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+openssl req -subj '/CN=localhost' -x509 -newkey rsa:4096 -keyout key_pkcs8.pem -out cert.pem -nodes -days 3650
+openssl rsa -in key_pkcs8.pem -out key_pkcs1.pem

tests/data/key_pkcs1.pem

@@ -0,0 +1,51 @@
+-----BEGIN RSA PRIVATE KEY-----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=
+-----END RSA PRIVATE KEY-----

tests/data/key_pkcs8.pem

@@ -0,0 +1,52 @@
+-----BEGIN PRIVATE KEY-----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+-----END PRIVATE KEY-----

tests/favicon.rs

@@ -0,0 +1,25 @@
+mod fixtures;
+mod utils;
+
+use fixtures::{server, Error, TestServer};
+use rstest::rstest;
+
+#[rstest]
+fn default_favicon(server: TestServer) -> Result<(), Error> {
+    let resp = reqwest::blocking::get(format!("{}favicon.ico", server.url()))?;
+    assert_eq!(resp.status(), 200);
+    assert_eq!(resp.headers().get("content-type").unwrap(), "image/x-icon");
+    Ok(())
+}
+
+#[rstest]
+fn exist_favicon(#[with(&["-A"])] server: TestServer) -> Result<(), Error> {
+    let url = format!("{}favicon.ico", server.url());
+    let data = b"abc";
+    let resp = fetch!(b"PUT", &url).body(data.to_vec()).send()?;
+    assert_eq!(resp.status(), 201);
+    let resp = reqwest::blocking::get(url)?;
+    assert_eq!(resp.status(), 200);
+    assert_eq!(resp.bytes()?, data.to_vec());
+    Ok(())
+}

tests/fixtures.rs

@@ -0,0 +1,191 @@
+use assert_cmd::prelude::*;
+use assert_fs::fixture::TempDir;
+use assert_fs::prelude::*;
+use port_check::free_local_port;
+use reqwest::Url;
+use rstest::fixture;
+use std::process::{Child, Command, Stdio};
+use std::thread::sleep;
+use std::time::{Duration, Instant};
+
+#[allow(dead_code)]
+pub type Error = Box<dyn std::error::Error>;
+
+/// File names for testing purpose
+#[allow(dead_code)]
+pub static FILES: &[&str] = &[
+    "test.txt",
+    "test.html",
+    "index.html",
+    "test.mkv",
+    #[cfg(not(windows))]
+    "test \" \' & < >.csv",
+    "😀.data",
+    "⎙.mp4",
+    "#[]{}()@!$&'`+,;= %20.test",
+    #[cfg(unix)]
+    ":?#[]{}<>()@!$&'`|*+,;= %20.test",
+    #[cfg(not(windows))]
+    "foo\\bar.test",
+];
+
+/// Directory names for testing purpose
+#[allow(dead_code)]
+pub static DIR_NO_INDEX: &str = "dir-no-index/";
+
+/// Directory names for testing purpose
+#[allow(dead_code)]
+pub static DIRECTORIES: &[&str] = &["dira/", "dirb/", "dirc/", DIR_NO_INDEX];
+
+/// Name of a deeply nested file
+#[allow(dead_code)]
+pub static DEEPLY_NESTED_FILE: &str = "very/deeply/nested/test.rs";
+
+/// Test fixture which creates a temporary directory with a few files and directories inside.
+/// The directories also contain files.
+#[fixture]
+#[allow(dead_code)]
+pub fn tmpdir() -> TempDir {
+    let tmpdir = assert_fs::TempDir::new().expect("Couldn't create a temp dir for tests");
+    for file in FILES {
+        tmpdir
+            .child(file)
+            .write_str(&format!("This is {}", file))
+            .expect("Couldn't write to file");
+    }
+    for directory in DIRECTORIES {
+        for file in FILES {
+            if *directory == DIR_NO_INDEX {
+                continue;
+            }
+            tmpdir
+                .child(format!("{}{}", directory, file))
+                .write_str(&format!("This is {}{}", directory, file))
+                .expect("Couldn't write to file");
+        }
+    }
+
+    tmpdir
+        .child(&DEEPLY_NESTED_FILE)
+        .write_str("File in a deeply nested directory.")
+        .expect("Couldn't write to file");
+    tmpdir
+}
+
+/// Get a free port.
+#[fixture]
+#[allow(dead_code)]
+pub fn port() -> u16 {
+    free_local_port().expect("Couldn't find a free local port")
+}
+
+/// Run duf as a server; Start with a temporary directory, a free port and some
+/// optional arguments then wait for a while for the server setup to complete.
+#[fixture]
+#[allow(dead_code)]
+pub fn server<I>(#[default(&[] as &[&str])] args: I) -> TestServer
+where
+    I: IntoIterator + Clone,
+    I::Item: AsRef<std::ffi::OsStr>,
+{
+    let port = port();
+    let tmpdir = tmpdir();
+    let child = Command::cargo_bin("duf")
+        .expect("Couldn't find test binary")
+        .env("RUST_LOG", "false")
+        .arg(tmpdir.path())
+        .arg("-p")
+        .arg(port.to_string())
+        .args(args.clone())
+        .stdout(Stdio::null())
+        .spawn()
+        .expect("Couldn't run test binary");
+    let is_tls = args
+        .into_iter()
+        .any(|x| x.as_ref().to_str().unwrap().contains("tls"));
+
+    wait_for_port(port);
+    TestServer::new(port, tmpdir, child, is_tls)
+}
+
+/// Same as `server()` but ignore stderr
+#[fixture]
+#[allow(dead_code)]
+pub fn server_no_stderr<I>(#[default(&[] as &[&str])] args: I) -> TestServer
+where
+    I: IntoIterator + Clone,
+    I::Item: AsRef<std::ffi::OsStr>,
+{
+    let port = port();
+    let tmpdir = tmpdir();
+    let child = Command::cargo_bin("duf")
+        .expect("Couldn't find test binary")
+        .env("RUST_LOG", "false")
+        .arg(tmpdir.path())
+        .arg("-p")
+        .arg(port.to_string())
+        .args(args.clone())
+        .stdout(Stdio::null())
+        .stderr(Stdio::null())
+        .spawn()
+        .expect("Couldn't run test binary");
+    let is_tls = args
+        .into_iter()
+        .any(|x| x.as_ref().to_str().unwrap().contains("tls"));
+
+    wait_for_port(port);
+    TestServer::new(port, tmpdir, child, is_tls)
+}
+
+/// Wait a max of 1s for the port to become available.
+fn wait_for_port(port: u16) {
+    let start_wait = Instant::now();
+
+    while !port_check::is_port_reachable(format!("localhost:{}", port)) {
+        sleep(Duration::from_millis(100));
+
+        if start_wait.elapsed().as_secs() > 1 {
+            panic!("timeout waiting for port {}", port);
+        }
+    }
+}
+
+#[allow(dead_code)]
+pub struct TestServer {
+    port: u16,
+    tmpdir: TempDir,
+    child: Child,
+    is_tls: bool,
+}
+
+#[allow(dead_code)]
+impl TestServer {
+    pub fn new(port: u16, tmpdir: TempDir, child: Child, is_tls: bool) -> Self {
+        Self {
+            port,
+            tmpdir,
+            child,
+            is_tls,
+        }
+    }
+
+    pub fn url(&self) -> Url {
+        let protocol = if self.is_tls { "https" } else { "http" };
+        Url::parse(&format!("{}://localhost:{}", protocol, self.port)).unwrap()
+    }
+
+    pub fn path(&self) -> &std::path::Path {
+        self.tmpdir.path()
+    }
+
+    pub fn port(&self) -> u16 {
+        self.port
+    }
+}
+
+impl Drop for TestServer {
+    fn drop(&mut self) {
+        self.child.kill().expect("Couldn't kill test server");
+        self.child.wait().unwrap();
+    }
+}

tests/http.rs

@@ -0,0 +1,184 @@
+mod fixtures;
+mod utils;
+
+use fixtures::{server, Error, TestServer};
+use rstest::rstest;
+
+#[rstest]
+fn get_dir(server: TestServer) -> Result<(), Error> {
+    let resp = reqwest::blocking::get(server.url())?;
+    assert_index_resp!(resp);
+    Ok(())
+}
+
+#[rstest]
+fn head_dir(server: TestServer) -> Result<(), Error> {
+    let resp = fetch!(b"HEAD", server.url()).send()?;
+    assert_eq!(resp.status(), 200);
+    assert_eq!(
+        resp.headers().get("content-type").unwrap(),
+        "text/html; charset=utf-8"
+    );
+    assert_eq!(resp.text()?, "");
+    Ok(())
+}
+
+#[rstest]
+fn get_dir_404(server: TestServer) -> Result<(), Error> {
+    let resp = reqwest::blocking::get(format!("{}404/", server.url()))?;
+    assert_eq!(resp.status(), 404);
+    Ok(())
+}
+
+#[rstest]
+fn head_dir_404(server: TestServer) -> Result<(), Error> {
+    let resp = fetch!(b"HEAD", format!("{}404/", server.url())).send()?;
+    assert_eq!(resp.status(), 404);
+    Ok(())
+}
+
+#[rstest]
+fn get_dir_zip(server: TestServer) -> Result<(), Error> {
+    let resp = reqwest::blocking::get(format!("{}?zip", server.url()))?;
+    assert_eq!(resp.status(), 200);
+    assert_eq!(
+        resp.headers().get("content-type").unwrap(),
+        "application/zip"
+    );
+    assert!(resp.headers().contains_key("content-disposition"));
+    Ok(())
+}
+
+#[rstest]
+fn head_dir_zip(server: TestServer) -> Result<(), Error> {
+    let resp = fetch!(b"HEAD", format!("{}?zip", server.url())).send()?;
+    assert_eq!(resp.status(), 200);
+    assert_eq!(
+        resp.headers().get("content-type").unwrap(),
+        "application/zip"
+    );
+    assert!(resp.headers().contains_key("content-disposition"));
+    assert_eq!(resp.text()?, "");
+    Ok(())
+}
+
+#[rstest]
+fn get_dir_search(server: TestServer) -> Result<(), Error> {
+    let resp = reqwest::blocking::get(format!("{}?q={}", server.url(), "test.html"))?;
+    assert_eq!(resp.status(), 200);
+    let paths = utils::retrive_index_paths(&resp.text()?);
+    assert!(!paths.is_empty());
+    for p in paths {
+        assert!(p.contains(&"test.html"));
+    }
+    Ok(())
+}
+
+#[rstest]
+fn head_dir_search(server: TestServer) -> Result<(), Error> {
+    let resp = fetch!(b"HEAD", format!("{}?q={}", server.url(), "test.html")).send()?;
+    assert_eq!(resp.status(), 200);
+    assert_eq!(
+        resp.headers().get("content-type").unwrap(),
+        "text/html; charset=utf-8"
+    );
+    assert_eq!(resp.text()?, "");
+    Ok(())
+}
+
+#[rstest]
+fn get_file(server: TestServer) -> Result<(), Error> {
+    let resp = reqwest::blocking::get(format!("{}index.html", server.url()))?;
+    assert_eq!(resp.status(), 200);
+    assert_eq!(resp.headers().get("content-type").unwrap(), "text/html");
+    assert_eq!(resp.headers().get("accept-ranges").unwrap(), "bytes");
+    assert!(resp.headers().contains_key("etag"));
+    assert!(resp.headers().contains_key("last-modified"));
+    assert!(resp.headers().contains_key("content-length"));
+    assert_eq!(resp.text()?, "This is index.html");
+    Ok(())
+}
+
+#[rstest]
+fn head_file(server: TestServer) -> Result<(), Error> {
+    let resp = fetch!(b"HEAD", format!("{}index.html", server.url())).send()?;
+    assert_eq!(resp.status(), 200);
+    assert_eq!(resp.headers().get("content-type").unwrap(), "text/html");
+    assert_eq!(resp.headers().get("accept-ranges").unwrap(), "bytes");
+    assert!(resp.headers().contains_key("etag"));
+    assert!(resp.headers().contains_key("last-modified"));
+    assert!(resp.headers().contains_key("content-length"));
+    assert_eq!(resp.text()?, "");
+    Ok(())
+}
+
+#[rstest]
+fn get_file_404(server: TestServer) -> Result<(), Error> {
+    let resp = reqwest::blocking::get(format!("{}404", server.url()))?;
+    assert_eq!(resp.status(), 404);
+    Ok(())
+}
+
+#[rstest]
+fn head_file_404(server: TestServer) -> Result<(), Error> {
+    let resp = fetch!(b"HEAD", format!("{}404", server.url())).send()?;
+    assert_eq!(resp.status(), 404);
+    Ok(())
+}
+
+#[rstest]
+fn options_dir(server: TestServer) -> Result<(), Error> {
+    let resp = fetch!(b"OPTIONS", format!("{}index.html", server.url())).send()?;
+    assert_eq!(resp.status(), 200);
+    assert_eq!(
+        resp.headers().get("allow").unwrap(),
+        "GET,HEAD,PUT,OPTIONS,DELETE,PROPFIND,COPY,MOVE"
+    );
+    assert_eq!(resp.headers().get("dav").unwrap(), "1,2");
+    Ok(())
+}
+
+#[rstest]
+fn put_file(#[with(&["-A"])] server: TestServer) -> Result<(), Error> {
+    let url = format!("{}file1", server.url());
+    let resp = fetch!(b"PUT", &url).body(b"abc".to_vec()).send()?;
+    assert_eq!(resp.status(), 201);
+    let resp = reqwest::blocking::get(url)?;
+    assert_eq!(resp.status(), 200);
+    Ok(())
+}
+
+#[rstest]
+fn put_file_create_dir(#[with(&["-A"])] server: TestServer) -> Result<(), Error> {
+    let url = format!("{}xyz/file1", server.url());
+    let resp = fetch!(b"PUT", &url).body(b"abc".to_vec()).send()?;
+    assert_eq!(resp.status(), 201);
+    let resp = reqwest::blocking::get(url)?;
+    assert_eq!(resp.status(), 200);
+    Ok(())
+}
+
+#[rstest]
+fn put_file_conflict_dir(#[with(&["-A"])] server: TestServer) -> Result<(), Error> {
+    let url = format!("{}dira", server.url());
+    let resp = fetch!(b"PUT", &url).body(b"abc".to_vec()).send()?;
+    assert_eq!(resp.status(), 403);
+    Ok(())
+}
+
+#[rstest]
+fn delete_file(#[with(&["-A"])] server: TestServer) -> Result<(), Error> {
+    let url = format!("{}test.html", server.url());
+    let resp = fetch!(b"DELETE", &url).send()?;
+    assert_eq!(resp.status(), 204);
+    let resp = reqwest::blocking::get(url)?;
+    assert_eq!(resp.status(), 404);
+    Ok(())
+}
+
+#[rstest]
+fn delete_file_404(#[with(&["-A"])] server: TestServer) -> Result<(), Error> {
+    let resp = fetch!(b"DELETE", format!("{}file1", server.url())).send()?;
+    assert_eq!(resp.status(), 404);
+    Ok(())
+}

tests/path_prefix.rs

@@ -0,0 +1,30 @@
+mod fixtures;
+mod utils;
+
+use fixtures::{server, Error, TestServer};
+use rstest::rstest;
+
+#[rstest]
+fn path_prefix_index(#[with(&["--path-prefix", "xyz"])] server: TestServer) -> Result<(), Error> {
+    let resp = reqwest::blocking::get(format!("{}{}", server.url(), "xyz"))?;
+    assert_index_resp!(resp);
+    Ok(())
+}
+
+#[rstest]
+fn path_prefix_file(#[with(&["--path-prefix", "xyz"])] server: TestServer) -> Result<(), Error> {
+    let resp = reqwest::blocking::get(format!("{}{}/index.html", server.url(), "xyz"))?;
+    assert_eq!(resp.status(), 200);
+    assert_eq!(resp.text()?, "This is index.html");
+    Ok(())
+}
+
+#[rstest]
+fn path_prefix_propfind(
+    #[with(&["--path-prefix", "xyz"])] server: TestServer,
+) -> Result<(), Error> {
+    let resp = fetch!(b"PROPFIND", format!("{}{}", server.url(), "xyz")).send()?;
+    let text = resp.text()?;
+    assert!(text.contains("<D:href>/xyz/</D:href>"));
+    Ok(())
+}

tests/range.rs

@@ -0,0 +1,45 @@
+mod fixtures;
+mod utils;
+
+use fixtures::{server, Error, TestServer};
+use headers::HeaderValue;
+use rstest::rstest;
+
+#[rstest]
+fn get_file_range(server: TestServer) -> Result<(), Error> {
+    let resp = fetch!(b"GET", format!("{}index.html", server.url()))
+        .header("range", HeaderValue::from_static("bytes=0-6"))
+        .send()?;
+    assert_eq!(resp.status(), 206);
+    assert_eq!(resp.headers().get("content-range").unwrap(), "bytes 0-6/18");
+    assert_eq!(resp.headers().get("accept-ranges").unwrap(), "bytes");
+    assert_eq!(resp.headers().get("content-length").unwrap(), "7");
+    assert_eq!(resp.text()?, "This is");
+    Ok(())
+}
+
+#[rstest]
+fn get_file_range_beyond(server: TestServer) -> Result<(), Error> {
+    let resp = fetch!(b"GET", format!("{}index.html", server.url()))
+        .header("range", HeaderValue::from_static("bytes=12-20"))
+        .send()?;
+    assert_eq!(resp.status(), 206);
+    assert_eq!(
+        resp.headers().get("content-range").unwrap(),
+        "bytes 12-17/18"
+    );
+    assert_eq!(resp.headers().get("accept-ranges").unwrap(), "bytes");
+    assert_eq!(resp.headers().get("content-length").unwrap(), "6");
+    assert_eq!(resp.text()?, "x.html");
+    Ok(())
+}
+
+#[rstest]
+fn get_file_range_invalid(server: TestServer) -> Result<(), Error> {
+    let resp = fetch!(b"GET", format!("{}index.html", server.url()))
+        .header("range", HeaderValue::from_static("bytes=20-"))
+        .send()?;
+    assert_eq!(resp.status(), 416);
+    assert_eq!(resp.headers().get("content-range").unwrap(), "bytes */18");
+    Ok(())
+}

tests/render.rs

@@ -0,0 +1,35 @@
+mod fixtures;
+
+use fixtures::{server, Error, TestServer, DIR_NO_INDEX};
+use rstest::rstest;
+
+#[rstest]
+fn render_index(#[with(&["--render-index"])] server: TestServer) -> Result<(), Error> {
+    let resp = reqwest::blocking::get(server.url())?;
+    let text = resp.text()?;
+    assert_eq!(text, "This is index.html");
+    Ok(())
+}
+
+#[rstest]
+fn render_index_404(#[with(&["--render-index"])] server: TestServer) -> Result<(), Error> {
+    let resp = reqwest::blocking::get(format!("{}/{}", server.url(), DIR_NO_INDEX))?;
+    assert_eq!(resp.status(), 404);
+    Ok(())
+}
+
+#[rstest]
+fn render_spa(#[with(&["--render-spa"])] server: TestServer) -> Result<(), Error> {
+    let resp = reqwest::blocking::get(server.url())?;
+    let text = resp.text()?;
+    assert_eq!(text, "This is index.html");
+    Ok(())
+}
+
+#[rstest]
+fn render_spa_no_404(#[with(&["--render-spa"])] server: TestServer) -> Result<(), Error> {
+    let resp = reqwest::blocking::get(format!("{}/{}", server.url(), DIR_NO_INDEX))?;
+    let text = resp.text()?;
+    assert_eq!(text, "This is index.html");
+    Ok(())
+}

tests/symlink.rs

@@ -0,0 +1,46 @@
+mod fixtures;
+mod utils;
+
+use assert_fs::fixture::TempDir;
+use fixtures::{server, tmpdir, Error, TestServer};
+use rstest::rstest;
+
+#[cfg(unix)]
+use std::os::unix::fs::symlink as symlink_dir;
+#[cfg(windows)]
+use std::os::windows::fs::symlink_dir;
+
+#[rstest]
+fn default_not_allow_symlink(server: TestServer, tmpdir: TempDir) -> Result<(), Error> {
+    // Create symlink directory "foo" to point outside the root
+    let dir = "foo";
+    symlink_dir(tmpdir.path(), server.path().join(dir)).expect("Couldn't create symlink");
+    let resp = reqwest::blocking::get(format!("{}{}", server.url(), dir))?;
+    assert_eq!(resp.status(), 404);
+    let resp = reqwest::blocking::get(format!("{}{}/index.html", server.url(), dir))?;
+    assert_eq!(resp.status(), 404);
+    let resp = reqwest::blocking::get(server.url())?;
+    let paths = utils::retrive_index_paths(&resp.text()?);
+    assert!(!paths.is_empty());
+    assert!(!paths.contains(&format!("{}/", dir)));
+    Ok(())
+}
+
+#[rstest]
+fn allow_symlink(
+    #[with(&["--allow-symlink"])] server: TestServer,
+    tmpdir: TempDir,
+) -> Result<(), Error> {
+    // Create symlink directory "foo" to point outside the root
+    let dir = "foo";
+    symlink_dir(tmpdir.path(), server.path().join(dir)).expect("Couldn't create symlink");
+    let resp = reqwest::blocking::get(format!("{}{}", server.url(), dir))?;
+    assert_eq!(resp.status(), 200);
+    let resp = reqwest::blocking::get(format!("{}{}/index.html", server.url(), dir))?;
+    assert_eq!(resp.status(), 200);
+    let resp = reqwest::blocking::get(server.url())?;
+    let paths = utils::retrive_index_paths(&resp.text()?);
+    assert!(!paths.is_empty());
+    assert!(paths.contains(&format!("{}/", dir)));
+    Ok(())
+}

tests/tls.rs

@@ -0,0 +1,51 @@
+mod fixtures;
+mod utils;
+
+use assert_cmd::Command;
+use fixtures::{server, Error, TestServer};
+use predicates::str::contains;
+use reqwest::blocking::ClientBuilder;
+use rstest::rstest;
+
+/// Can start the server with TLS and receive encrypted responses.
+#[rstest]
+#[case(server(&[
+        "--tls-cert", "tests/data/cert.pem",
+        "--tls-key", "tests/data/key_pkcs8.pem",
+]))]
+#[case(server(&[
+        "--tls-cert", "tests/data/cert.pem",
+        "--tls-key", "tests/data/key_pkcs1.pem",
+]))]
+fn tls_works(#[case] server: TestServer) -> Result<(), Error> {
+    let client = ClientBuilder::new()
+        .danger_accept_invalid_certs(true)
+        .build()?;
+    let resp = client.get(server.url()).send()?.error_for_status()?;
+    assert_index_resp!(resp);
+    Ok(())
+}
+
+/// Wrong path for cert throws error.
+#[rstest]
+fn wrong_path_cert() -> Result<(), Error> {
+    Command::cargo_bin("duf")?
+        .args(&["--tls-cert", "wrong", "--tls-key", "tests/data/key.pem"])
+        .assert()
+        .failure()
+        .stderr(contains("error: Failed to access `wrong`"));
+
+    Ok(())
+}
+
+/// Wrong paths for key throws errors.
+#[rstest]
+fn wrong_path_key() -> Result<(), Error> {
+    Command::cargo_bin("duf")?
+        .args(&["--tls-cert", "tests/data/cert.pem", "--tls-key", "wrong"])
+        .assert()
+        .failure()
+        .stderr(contains("error: Failed to access `wrong`"));
+
+    Ok(())
+}

tests/utils.rs

@@ -0,0 +1,61 @@
+use serde_json::Value;
+use std::collections::HashSet;
+
+#[macro_export]
+macro_rules! assert_index_resp {
+    ($resp:ident) => {
+        assert_index_resp!($resp, self::fixtures::FILES)
+    };
+    ($resp:ident, $files:expr) => {
+        assert_eq!($resp.status(), 200);
+        let body = $resp.text()?;
+        let paths = self::utils::retrive_index_paths(&body);
+        assert!(!paths.is_empty());
+        for file in $files {
+            assert!(paths.contains(&file.to_string()));
+        }
+    };
+}
+
+#[macro_export]
+macro_rules! fetch {
+    ($method:literal, $url:expr) => {
+        reqwest::blocking::Client::new().request(hyper::Method::from_bytes($method)?, $url)
+    };
+}
+
+#[allow(dead_code)]
+pub fn retrive_index_paths(index: &str) -> HashSet<String> {
+    retrive_index_paths_impl(index).unwrap_or_default()
+}
+
+#[allow(dead_code)]
+pub fn encode_uri(v: &str) -> String {
+    let parts: Vec<_> = v.split('/').map(urlencoding::encode).collect();
+    parts.join("/")
+}
+
+fn retrive_index_paths_impl(index: &str) -> Option<HashSet<String>> {
+    let lines: Vec<&str> = index.lines().collect();
+    let (i, _) = lines
+        .iter()
+        .enumerate()
+        .find(|(_, v)| v.contains("const DATA"))?;
+    let line = lines.get(i + 1)?;
+    let value: Value = line.parse().ok()?;
+    let paths = value
+        .get("paths")?
+        .as_array()?
+        .iter()
+        .flat_map(|v| {
+            let name = v.get("name")?.as_str()?;
+            let path_type = v.get("path_type")?.as_str()?;
+            if path_type.ends_with("Dir") {
+                Some(format!("{}/", name))
+            } else {
+                Some(name.to_owned())
+            }
+        })
+        .collect();
+    Some(paths)
+}

tests/webdav.rs

@@ -0,0 +1,203 @@
+mod fixtures;
+mod utils;
+
+use fixtures::{server, Error, TestServer, FILES};
+use rstest::rstest;
+use xml::escape::escape_str_pcdata;
+
+#[rstest]
+fn propfind_dir(server: TestServer) -> Result<(), Error> {
+    let resp = fetch!(b"PROPFIND", format!("{}dira", server.url())).send()?;
+    assert_eq!(resp.status(), 207);
+    let body = resp.text()?;
+    assert!(body.contains("<D:href>/dira/</D:href>"));
+    assert!(body.contains("<D:displayname>dira</D:displayname>"));
+    for f in FILES {
+        assert!(body.contains(&format!("<D:href>/dira/{}</D:href>", utils::encode_uri(f))));
+        assert!(body.contains(&format!(
+            "<D:displayname>{}</D:displayname>",
+            escape_str_pcdata(f)
+        )));
+    }
+    Ok(())
+}
+
+#[rstest]
+fn propfind_dir_depth0(server: TestServer) -> Result<(), Error> {
+    let resp = fetch!(b"PROPFIND", format!("{}dira", server.url()))
+        .header("depth", "0")
+        .send()?;
+    assert_eq!(resp.status(), 207);
+    let body = resp.text()?;
+    assert!(body.contains("<D:href>/dira/</D:href>"));
+    assert!(body.contains("<D:displayname>dira</D:displayname>"));
+    assert_eq!(
+        body.lines()
+            .filter(|v| *v == "<D:status>HTTP/1.1 200 OK</D:status>")
+            .count(),
+        1
+    );
+    Ok(())
+}
+
+#[rstest]
+fn propfind_404(server: TestServer) -> Result<(), Error> {
+    let resp = fetch!(b"PROPFIND", format!("{}404", server.url())).send()?;
+    assert_eq!(resp.status(), 404);
+    Ok(())
+}
+
+#[rstest]
+fn propfind_file(server: TestServer) -> Result<(), Error> {
+    let resp = fetch!(b"PROPFIND", format!("{}test.html", server.url())).send()?;
+    assert_eq!(resp.status(), 207);
+    let body = resp.text()?;
+    assert!(body.contains("<D:href>/test.html</D:href>"));
+    assert!(body.contains("<D:displayname>test.html</D:displayname>"));
+    assert_eq!(
+        body.lines()
+            .filter(|v| *v == "<D:status>HTTP/1.1 200 OK</D:status>")
+            .count(),
+        1
+    );
+    Ok(())
+}
+
+#[rstest]
+fn proppatch_file(#[with(&["-A"])] server: TestServer) -> Result<(), Error> {
+    let resp = fetch!(b"PROPPATCH", format!("{}test.html", server.url())).send()?;
+    assert_eq!(resp.status(), 207);
+    let body = resp.text()?;
+    assert!(body.contains("<D:href>/test.html</D:href>"));
+    Ok(())
+}
+
+#[rstest]
+fn proppatch_404(#[with(&["-A"])] server: TestServer) -> Result<(), Error> {
+    let resp = fetch!(b"PROPPATCH", format!("{}404", server.url())).send()?;
+    assert_eq!(resp.status(), 404);
+    Ok(())
+}
+
+#[rstest]
+fn mkcol_dir(#[with(&["-A"])] server: TestServer) -> Result<(), Error> {
+    let resp = fetch!(b"MKCOL", format!("{}newdir", server.url())).send()?;
+    assert_eq!(resp.status(), 201);
+    Ok(())
+}
+
+#[rstest]
+fn mkcol_not_allow_upload(server: TestServer) -> Result<(), Error> {
+    let resp = fetch!(b"MKCOL", format!("{}newdir", server.url())).send()?;
+    assert_eq!(resp.status(), 403);
+    Ok(())
+}
+
+#[rstest]
+fn copy_file(#[with(&["-A"])] server: TestServer) -> Result<(), Error> {
+    let new_url = format!("{}test2.html", server.url());
+    let resp = fetch!(b"COPY", format!("{}test.html", server.url()))
+        .header("Destination", &new_url)
+        .send()?;
+    assert_eq!(resp.status(), 204);
+    let resp = reqwest::blocking::get(new_url)?;
+    assert_eq!(resp.status(), 200);
+    Ok(())
+}
+
+#[rstest]
+fn copy_not_allow_upload(server: TestServer) -> Result<(), Error> {
+    let new_url = format!("{}test2.html", server.url());
+    let resp = fetch!(b"COPY", format!("{}test.html", server.url()))
+        .header("Destination", &new_url)
+        .send()?;
+    assert_eq!(resp.status(), 403);
+    Ok(())
+}
+
+#[rstest]
+fn copy_file_404(#[with(&["-A"])] server: TestServer) -> Result<(), Error> {
+    let new_url = format!("{}test2.html", server.url());
+    let resp = fetch!(b"COPY", format!("{}404", server.url()))
+        .header("Destination", &new_url)
+        .send()?;
+    assert_eq!(resp.status(), 404);
+    Ok(())
+}
+
+#[rstest]
+fn move_file(#[with(&["-A"])] server: TestServer) -> Result<(), Error> {
+    let origin_url = format!("{}test.html", server.url());
+    let new_url = format!("{}test2.html", server.url());
+    let resp = fetch!(b"MOVE", &origin_url)
+        .header("Destination", &new_url)
+        .send()?;
+    assert_eq!(resp.status(), 204);
+    let resp = reqwest::blocking::get(new_url)?;
+    assert_eq!(resp.status(), 200);
+    let resp = reqwest::blocking::get(origin_url)?;
+    assert_eq!(resp.status(), 404);
+    Ok(())
+}
+
+#[rstest]
+fn move_not_allow_upload(#[with(&["--allow-delete"])] server: TestServer) -> Result<(), Error> {
+    let origin_url = format!("{}test.html", server.url());
+    let new_url = format!("{}test2.html", server.url());
+    let resp = fetch!(b"MOVE", &origin_url)
+        .header("Destination", &new_url)
+        .send()?;
+    assert_eq!(resp.status(), 403);
+    Ok(())
+}
+
+#[rstest]
+fn move_not_allow_delete(#[with(&["--allow-upload"])] server: TestServer) -> Result<(), Error> {
+    let origin_url = format!("{}test.html", server.url());
+    let new_url = format!("{}test2.html", server.url());
+    let resp = fetch!(b"MOVE", &origin_url)
+        .header("Destination", &new_url)
+        .send()?;
+    assert_eq!(resp.status(), 403);
+    Ok(())
+}
+
+#[rstest]
+fn move_file_404(#[with(&["-A"])] server: TestServer) -> Result<(), Error> {
+    let new_url = format!("{}test2.html", server.url());
+    let resp = fetch!(b"MOVE", format!("{}404", server.url()))
+        .header("Destination", &new_url)
+        .send()?;
+    assert_eq!(resp.status(), 404);
+    Ok(())
+}
+
+#[rstest]
+fn lock_file(#[with(&["-A"])] server: TestServer) -> Result<(), Error> {
+    let resp = fetch!(b"LOCK", format!("{}test.html", server.url())).send()?;
+    assert_eq!(resp.status(), 200);
+    let body = resp.text()?;
+    assert!(body.contains("<D:href>/test.html</D:href>"));
+    Ok(())
+}
+
+#[rstest]
+fn lock_file_404(#[with(&["-A"])] server: TestServer) -> Result<(), Error> {
+    let resp = fetch!(b"LOCK", format!("{}404", server.url())).send()?;
+    assert_eq!(resp.status(), 404);
+    Ok(())
+}
+
+#[rstest]
+fn unlock_file(#[with(&["-A"])] server: TestServer) -> Result<(), Error> {
+    let resp = fetch!(b"LOCK", format!("{}test.html", server.url())).send()?;
+    assert_eq!(resp.status(), 200);
+    Ok(())
+}
+
+#[rstest]
+fn unlock_file_404(#[with(&["-A"])] server: TestServer) -> Result<(), Error> {
+    let resp = fetch!(b"LOCK", format!("{}404", server.url())).send()?;
+    assert_eq!(resp.status(), 404);
+    Ok(())
+}