chore(release): version v0.18.0

chore: send not found text when 404
chore: optimize --render-try-index
2026-04-09 00:59:02 +03:00 · 2022-06-18 08:05:18 +08:00 · 2022-06-18 08:03:48 +08:00 · 2022-06-17 19:05:25 +08:00 · 2022-06-17 19:01:17 +08:00 · 2022-06-17 10:59:19 +08:00
17 changed files with 844 additions and 419 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,33 @@

 All notable changes to this project will be documented in this file.

+## [0.18.0] - 2022-06-18
+
+### Features
+
+- Add option --render-try-index ([#47](https://github.com/sigoden/duf/issues/47))
+- Add slash to end of dir href
+
+## [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
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -188,6 +188,27 @@ dependencies = [
 "wasm-bindgen-futures",
 ]

+[[package]]
+name = "async-stream"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dad5c83079eae9969be7fadefe640a1c566901f05ff91ab221de4b6f68d9507e"
+dependencies = [
+ "async-stream-impl",
+ "futures-core",
+]
+
+[[package]]
+name = "async-stream-impl"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "10f203db73a71dfa2fb6dd22763990fa26f3d2625a6da2da900d23b87d26be27"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "async-task"
 version = "4.2.0"
@@ -395,22 +416,21 @@ dependencies = [

 [[package]]
 name = "clap"
-version = "3.1.18"
+version = "3.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2dbdf4bdacb33466e854ce889eee8dfd5729abf7ccd7664d0a2d60cd384440b"
+checksum = "6d20de3739b4fb45a17837824f40aa1769cc7655d7a83e68739a77fe7b30c87a"
 dependencies = [
 "bitflags",
 "clap_lex",
 "indexmap",
- "lazy_static",
 "textwrap",
 ]

 [[package]]
 name = "clap_lex"
-version = "0.2.0"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a37c35f1112dad5e6e0b1adaff798507497a18fceeb30cceb3bae7d1427b9213"
+checksum = "5538cd660450ebeb4234cfecf8f2284b844ffc4c50531e66d584ad5b91293613"
 dependencies = [
 "os_str_bytes",
 ]
@@ -551,10 +571,11 @@ checksum = "fea41bba32d969b513997752735605054bc0dfa92b4c56bf1189f2e174be7a10"

 [[package]]
 name = "duf"
-version = "0.16.0"
+version = "0.18.0"
 dependencies = [
 "assert_cmd",
 "assert_fs",
+ "async-stream",
 "async-walkdir",
 "async_zip",
 "base64",
@@ -578,13 +599,13 @@ dependencies = [
 "reqwest",
 "rstest",
 "rustls",
- "rustls-pemfile 1.0.0",
+ "rustls-pemfile",
 "select",
 "serde",
 "serde_json",
+ "socket2",
 "tokio",
 "tokio-rustls",
- "tokio-stream",
 "tokio-util",
 "url",
 "urlencoding",
@@ -853,13 +874,13 @@ dependencies = [

 [[package]]
 name = "getrandom"
-version = "0.2.6"
+version = "0.2.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9be70c98951c83b8d2f8f60d7065fa6d5146873094452a1008da8c2f1e4205ad"
+checksum = "4eb1a864a501629691edf6c15a593b7a51eebaa1e8468e9ddc623de7c9b58ec6"
 dependencies = [
 "cfg-if",
 "libc",
- "wasi 0.10.0+wasi-snapshot-preview1",
+ "wasi 0.11.0+wasi-snapshot-preview1",
 ]

 [[package]]
@@ -1147,9 +1168,9 @@ dependencies = [

 [[package]]
 name = "js-sys"
-version = "0.3.57"
+version = "0.3.58"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "671a26f820db17c2a2750743f1dd03bafd15b98c9f30c7c2628c024c05d73397"
+checksum = "c3fac17f7123a73ca62df411b1bf727ccc805daa070338fda671c86dac1bdc27"
 dependencies = [
 "wasm-bindgen",
 ]
@@ -1696,7 +1717,7 @@ version = "0.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d34f1408f55294453790c48b2f1ebbb1c5b4b7563eb1f418bcfcfdbb06ebb4e7"
 dependencies = [
- "getrandom 0.2.6",
+ "getrandom 0.2.7",
 ]

 [[package]]
@@ -1760,9 +1781,9 @@ dependencies = [

 [[package]]
 name = "reqwest"
-version = "0.11.10"
+version = "0.11.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46a1f7aa4f35e5e8b4160449f51afc758f0ce6454315a9fa7d0d113e958c41eb"
+checksum = "b75aa69a3f06bbcc66ede33af2af253c6f7a86b1ca0033f60c580a27074fbf92"
 dependencies = [
 "base64",
 "bytes",
@@ -1785,13 +1806,14 @@ dependencies = [
 "percent-encoding",
 "pin-project-lite",
 "rustls",
- "rustls-pemfile 0.3.0",
+ "rustls-pemfile",
 "serde",
 "serde_json",
 "serde_urlencoded",
 "tokio",
 "tokio-native-tls",
 "tokio-rustls",
+ "tower-service",
 "url",
 "wasm-bindgen",
 "wasm-bindgen-futures",
@@ -1862,15 +1884,6 @@ dependencies = [
 "webpki",
 ]

-[[package]]
-name = "rustls-pemfile"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ee86d63972a7c661d1536fefe8c3c8407321c3df668891286de28abcd087360"
-dependencies = [
- "base64",
-]
-
 [[package]]
 name = "rustls-pemfile"
 version = "1.0.0"
@@ -2251,17 +2264,6 @@ dependencies = [
 "webpki",
 ]

-[[package]]
-name = "tokio-stream"
-version = "0.1.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df54d54117d6fdc4e4fea40fe1e4e566b3505700e148a6827e59b34b0d2600d9"
-dependencies = [
- "futures-core",
- "pin-project-lite",
- "tokio",
-]
-
 [[package]]
 name = "tokio-util"
 version = "0.7.3"
@@ -2331,9 +2333,9 @@ checksum = "099b7128301d285f79ddd55b9a83d5e6b9e97c92e0ea0daebee7263e932de992"

 [[package]]
 name = "unicode-ident"
-version = "1.0.0"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d22af068fba1eb5edcb4aea19d382b2a3deb4c8f9d475c589b6ada9e0fd493ee"
+checksum = "5bd2fe26506023ed7b5e1e315add59d6f584c621d037f9368fea9cfb988f368c"

 [[package]]
 name = "unicode-normalization"
@@ -2380,7 +2382,7 @@ version = "1.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dd6469f4314d5f1ffec476e05f17cc9a78bc7a27a6a857842170bdf8d6f98d2f"
 dependencies = [
- "getrandom 0.2.6",
+ "getrandom 0.2.7",
 "rand 0.8.5",
 ]

@@ -2462,9 +2464,9 @@ checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"

 [[package]]
 name = "wasm-bindgen"
-version = "0.2.80"
+version = "0.2.81"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "27370197c907c55e3f1a9fbe26f44e937fe6451368324e009cba39e139dc08ad"
+checksum = "7c53b543413a17a202f4be280a7e5c62a1c69345f5de525ee64f8cfdbc954994"
 dependencies = [
 "cfg-if",
 "wasm-bindgen-macro",
@@ -2472,9 +2474,9 @@ dependencies = [

 [[package]]
 name = "wasm-bindgen-backend"
-version = "0.2.80"
+version = "0.2.81"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53e04185bfa3a779273da532f5025e33398409573f348985af9a1cbf3774d3f4"
+checksum = "5491a68ab4500fa6b4d726bd67408630c3dbe9c4fe7bda16d5c82a1fd8c7340a"
 dependencies = [
 "bumpalo",
 "lazy_static",
@@ -2487,9 +2489,9 @@ dependencies = [

 [[package]]
 name = "wasm-bindgen-futures"
-version = "0.4.30"
+version = "0.4.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f741de44b75e14c35df886aff5f1eb73aa114fa5d4d00dcd37b5e01259bf3b2"
+checksum = "de9a9cec1733468a8c657e57fa2413d2ae2c0129b95e87c5b72b8ace4d13f31f"
 dependencies = [
 "cfg-if",
 "js-sys",
@@ -2499,9 +2501,9 @@ dependencies = [

 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.80"
+version = "0.2.81"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "17cae7ff784d7e83a2fe7611cfe766ecf034111b49deb850a3dc7699c08251f5"
+checksum = "c441e177922bc58f1e12c022624b6216378e5febc2f0533e41ba443d505b80aa"
 dependencies = [
 "quote",
 "wasm-bindgen-macro-support",
@@ -2509,9 +2511,9 @@ dependencies = [

 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.80"
+version = "0.2.81"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "99ec0dc7a4756fffc231aab1b9f2f578d23cd391390ab27f952ae0c9b3ece20b"
+checksum = "7d94ac45fcf608c1f45ef53e748d35660f168490c10b23704c7779ab8f5c3048"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -2522,15 +2524,15 @@ dependencies = [

 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.80"
+version = "0.2.81"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d554b7f530dee5964d9a9468d95c1f8b8acae4f282807e7d27d4b03099a46744"
+checksum = "6a89911bd99e5f3659ec4acf9c4d93b0a90fe4a2a11f15328472058edc5261be"

 [[package]]
 name = "web-sys"
-version = "0.3.57"
+version = "0.3.58"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b17e741662c70c8bd24ac5c5b18de314a2c26c32bf8346ee1e6f53de919c283"
+checksum = "2fed94beee57daf8dd7d51f2b15dc2bcde92d7a72304cdf662a4371008b71b90"
 dependencies = [
 "js-sys",
 "wasm-bindgen",
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "duf"
-version = "0.16.0"
+version = "0.18.0"
 edition = "2021"
 authors = ["sigoden <sigoden@gmail.com>"]
 description = "Duf is a simple file server."
@@ -11,12 +11,11 @@ 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 = ["codec", "io-util"] }
+tokio-util = { version = "0.7",  features = ["io-util"] }
 hyper = { version = "0.14", features = ["http1", "server", "tcp", "stream"] }
 percent-encoding = "2.1"
 serde = { version = "1", features = ["derive"] }
@@ -37,6 +36,8 @@ urlencoding = "2.1"
 xml-rs = "0.8"
 env_logger = { version = "0.9", default-features = false, features = ["humantime"] }
 log = "0.4"
+socket2 = "0.4"
+async-stream = "0.3"

 [dev-dependencies]
 assert_cmd = "2"
--- a/README.md
+++ b/README.md
@@ -30,7 +30,7 @@ cargo install duf
 ### With docker

 ```
-docker run -v /tmp:/tmp -p 5000:5000 --rm -it docker.io/sigoden/duf /tmp
+docker run -v `pwd`:/data -p 5000:5000 --rm -it sigoden/duf /data
 ```

 ### Binaries on macOS, Linux, Windows
@@ -40,60 +40,61 @@ 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: .]

 OPTIONS:
+    -b, --bind <addr>...        Specify bind address
+    -p, --port <port>           Specify port to listen on [default: 5000]
+        --path-prefix <path>    Specify an url path prefix
    -a, --auth <user:pass>      Use HTTP authentication
        --no-auth-access        Not required auth when access static files
    -A, --allow-all             Allow all operations
+        --allow-upload          Allow upload files/folders
        --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]
-        --cors                  Enable CORS, sets `Access-Control-Allow-Origin: *`
-    -h, --help                  Print help information
-    -p, --port <port>           Specify port to listen on [default: 5000]
-        --path-prefix <path>    Specify an url path prefix
        --render-index          Render index.html when requesting a directory
+        --render-try-index      Render index.html if it exists when requesting a directory
        --render-spa            Render for single-page application
+        --cors                  Enable CORS, sets `Access-Control-Allow-Origin: *`
        --tls-cert <path>       Path to an SSL/TLS certificate to serve with HTTPS
        --tls-key <path>        Path to the SSL/TLS certificate's private key
+    -h, --help                  Print help information
    -V, --version               Print version information
 ```

 ## Examples

-You can run this command to start serving your current working directory on 127.0.0.1:5000 by default.
+Serve current working directory, no upload/delete

 ```
 duf
 ```

-...or specify which folder you want to serve.
+Allow upload/delete

 ```
-duf folder_name
+duf -A
 ```

-Allow all operations such as upload, delete
-
-```sh
-duf --allow-all
-```
-
-Only allow upload operation
+Listen on a specific port

 ```
-duf --allow-upload
+duf -p 80
 ```

-Serve a single page application (SPA)
+Protect with authentication
+
+```
+duf -a admin:admin
+```
+
+For a single page application (SPA)

 ```
 duf --render-spa
--- a/assets/index.js
+++ b/assets/index.js
@@ -1,7 +1,6 @@
 /**
 * @typedef {object} PathItem
 * @property {"Dir"|"SymlinkDir"|"File"|"SymlinkFile"} path_type
- * @property {boolean} is_symlink
 * @property {string} name
 * @property {number} mtime
 * @property {number} size
@@ -153,10 +152,11 @@ function addBreadcrumb(value) {
 * @param {number} index 
 */
 function addPath(file, index) {
-  const url = getUrl(file.name)
+  let url = getUrl(file.name)
  let actionDelete = "";
  let actionDownload = "";
  if (file.path_type.endsWith("Dir")) {
+    url += "/";
    actionDownload = `
    <div class="action-btn">
      <a href="${url}?zip" title="Download folder as a .zip file">
--- a/src/args.rs
+++ b/src/args.rs
@@ -1,25 +1,31 @@
-use clap::crate_description;
-use clap::{Arg, ArgMatches};
+use clap::{AppSettings, Arg, ArgMatches, Command};
 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() -> clap::Command<'static> {
-    clap::command!()
-        .about(ABOUT)
+fn app() -> Command<'static> {
+    Command::new(env!("CARGO_CRATE_NAME"))
+        .version(env!("CARGO_PKG_VERSION"))
+        .author(env!("CARGO_PKG_AUTHORS"))
+        .about(concat!(
+            env!("CARGO_PKG_DESCRIPTION"),
+            " - ",
+            env!("CARGO_PKG_REPOSITORY")
+        ))
+        .global_setting(AppSettings::DeriveDisplayOrder)
        .arg(
-            Arg::new("address")
+            Arg::new("bind")
                .short('b')
                .long("bind")
-                .default_value("0.0.0.0")
                .help("Specify bind address")
-                .value_name("address"),
+                .multiple_values(true)
+                .multiple_occurrences(true)
+                .value_name("addr"),
        )
        .arg(
            Arg::new("port")
@@ -41,6 +47,18 @@ fn app() -> clap::Command<'static> {
                .value_name("path")
                .help("Specify an url path prefix"),
        )
+        .arg(
+            Arg::new("auth")
+                .short('a')
+                .long("auth")
+                .help("Use HTTP authentication")
+                .value_name("user:pass"),
+        )
+        .arg(
+            Arg::new("no-auth-access")
+                .long("no-auth-access")
+                .help("Not required auth when access static files"),
+        )
        .arg(
            Arg::new("allow-all")
                .short('A')
@@ -67,25 +85,16 @@ fn app() -> clap::Command<'static> {
                .long("render-index")
                .help("Render index.html when requesting a directory"),
        )
+        .arg(
+            Arg::new("render-try-index")
+                .long("render-try-index")
+                .help("Render index.html if it exists when requesting a directory"),
+        )
        .arg(
            Arg::new("render-spa")
                .long("render-spa")
                .help("Render for single-page application"),
        )
-        .arg(
-            Arg::new("auth")
-                .short('a')
-                .display_order(1)
-                .long("auth")
-                .help("Use HTTP authentication")
-                .value_name("user:pass"),
-        )
-        .arg(
-            Arg::new("no-auth-access")
-                .display_order(1)
-                .long("no-auth-access")
-                .help("Not required auth when access static files"),
-        )
        .arg(
            Arg::new("cors")
                .long("cors")
@@ -111,7 +120,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,
@@ -122,6 +132,7 @@ pub struct Args {
    pub allow_symlink: bool,
    pub render_index: bool,
    pub render_spa: bool,
+    pub render_try_index: bool,
    pub cors: bool,
    pub tls: Option<(Vec<Certificate>, PrivateKey)>,
 }
@@ -132,9 +143,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("bind")
+            .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")
@@ -155,6 +169,7 @@ impl Args {
        let allow_delete = matches.is_present("allow-all") || matches.is_present("allow-delete");
        let allow_symlink = matches.is_present("allow-all") || matches.is_present("allow-symlink");
        let render_index = matches.is_present("render-index");
+        let render_try_index = matches.is_present("render-try-index");
        let render_spa = matches.is_present("render-spa");
        let tls = match (matches.value_of("tls-cert"), matches.value_of("tls-key")) {
            (Some(certs_file), Some(key_file)) => {
@@ -166,7 +181,8 @@ impl Args {
        };

        Ok(Args {
-            addr,
+            addrs,
+            port,
            path,
            path_prefix,
            uri_prefix,
@@ -177,12 +193,31 @@ impl Args {
            allow_upload,
            allow_symlink,
            render_index,
+            render_try_index,
            render_spa,
            tls,
        })
    }

-    /// 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,43 +232,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 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.
-fn load_private_key(filename: &str) -> BoxResult<PrivateKey> {
-    // 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))
-}
--- a/src/auth.rs
+++ b/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
--- a/src/main.rs
+++ b/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
+        ret = join_all(handles) => {
+            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);
--- a/src/server.rs
+++ b/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,
-    ContentType, ETag, HeaderMap, HeaderMapExt, IfModifiedSince, IfNoneMatch, IfRange,
-    LastModified, Range,
+    AcceptRanges, AccessControlAllowCredentials, AccessControlAllowHeaders,
+    AccessControlAllowOrigin, Connection, ContentLength, ContentType, ETag, HeaderMap,
+    HeaderMapExt, IfModifiedSince, IfNoneMatch, IfRange, LastModified, Range,
 };
 use hyper::header::{
-    HeaderValue, ACCEPT, AUTHORIZATION, CONTENT_DISPOSITION, CONTENT_TYPE, ORIGIN, RANGE,
-    WWW_AUTHENTICATE,
+    HeaderValue, ACCEPT, AUTHORIZATION, CONTENT_DISPOSITION, CONTENT_LENGTH, CONTENT_RANGE,
+    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::net::TcpListener;
+use tokio::io::{AsyncSeekExt, AsyncWrite};
 use tokio::{fs, io};
-use tokio_rustls::TlsAcceptor;
-use tokio_util::codec::{BytesCodec, FramedRead};
-use tokio_util::io::{ReaderStream, StreamReader};
+use tokio_util::io::StreamReader;
 use uuid::Uuid;

-type Request = hyper::Request<Body>;
-type Response = hyper::Response<Body>;
+pub type Request = hyper::Request<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 {
-    ($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 {
+pub struct Server {
    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);
-                error!(r#""{} {}" - {} {}"#, method, uri, status, err);
+                *res.status_mut() = status;
+                let status = status.as_u16();
+                error!(r#"{} "{} {}" - {} {}"#, addr.ip(), method, uri, status, err);
                res
            }
        };
@@ -160,7 +102,7 @@ impl InnerService {
        let path = match self.extract_path(req_path) {
            Some(v) => v,
            None => {
-                status!(res, StatusCode::FORBIDDEN);
+                status_forbid(&mut res);
                return Ok(res);
            }
        };
@@ -177,9 +119,10 @@ impl InnerService {
        let allow_delete = self.args.allow_delete;
        let render_index = self.args.render_index;
        let render_spa = self.args.render_spa;
+        let render_try_index = self.args.render_try_index;

        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);
        }

@@ -187,7 +130,9 @@ impl InnerService {
            Method::GET | Method::HEAD => {
                let head_only = method == Method::HEAD;
                if is_dir {
-                    if render_index || render_spa {
+                    if render_try_index && query == "zip" {
+                        self.handle_zip_dir(path, head_only, &mut res).await?;
+                    } else if render_index || render_spa || render_try_index {
                        self.handle_render_index(path, headers, head_only, &mut res)
                            .await?;
                    } else if query == "zip" {
@@ -206,26 +151,26 @@ impl InnerService {
                } else if allow_upload && req_path.ends_with('/') {
                    self.handle_ls_dir(path, false, head_only, &mut res).await?;
                } else {
-                    status!(res, StatusCode::NOT_FOUND);
+                    status_not_found(&mut res);
                }
            }
            Method::OPTIONS => {
-                self.handle_options(&mut res);
+                set_webdav_headers(&mut res);
            }
            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 => {
                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 => match method.as_str() {
@@ -235,37 +180,37 @@ 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 {
-                        status!(res, StatusCode::FORBIDDEN);
+                        status_forbid(&mut res);
                    } else {
                        self.handle_mkcol(path, &mut res).await?;
                    }
                }
                "COPY" => {
                    if !allow_upload {
-                        status!(res, StatusCode::FORBIDDEN);
+                        status_forbid(&mut res);
                    } else if is_miss {
-                        status!(res, StatusCode::NOT_FOUND);
+                        status_not_found(&mut res);
                    } else {
                        self.handle_copy(path, headers, &mut res).await?
                    }
                }
                "MOVE" => {
                    if !allow_upload || !allow_delete {
-                        status!(res, StatusCode::FORBIDDEN);
+                        status_forbid(&mut res);
                    } else if is_miss {
-                        status!(res, StatusCode::NOT_FOUND);
+                        status_not_found(&mut res);
                    } else {
                        self.handle_move(path, headers, &mut res).await?
                    }
@@ -275,19 +220,17 @@ impl InnerService {
                    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);
-                    } else {
-                        status!(res, StatusCode::OK);
+                        status_not_found(&mut res);
                    }
                }
                _ => {
-                    status!(res, StatusCode::METHOD_NOT_ALLOWED);
+                    *res.status_mut() = StatusCode::METHOD_NOT_ALLOWED;
                }
            },
        }
@@ -305,7 +248,7 @@ impl InnerService {
        let mut file = match fs::File::create(&path).await {
            Ok(v) => v,
            Err(_) => {
-                status!(res, StatusCode::FORBIDDEN);
+                status_forbid(res);
                return Ok(());
            }
        };
@@ -320,7 +263,7 @@ impl InnerService {

        io::copy(&mut body_reader, &mut file).await?;

-        status!(res, StatusCode::CREATED);
+        *res.status_mut() = StatusCode::CREATED;
        Ok(())
    }

@@ -330,7 +273,7 @@ impl InnerService {
            false => fs::remove_file(path).await?,
        }

-        status!(res, StatusCode::NO_CONTENT);
+        status_no_content(res);
        Ok(())
    }

@@ -346,7 +289,7 @@ impl InnerService {
            paths = match self.list_dir(path, path).await {
                Ok(paths) => paths,
                Err(_) => {
-                    status!(res, StatusCode::FORBIDDEN);
+                    status_forbid(res);
                    return Ok(());
                }
            }
@@ -404,7 +347,7 @@ impl InnerService {
            .unwrap(),
        );
        res.headers_mut()
-            .insert("content-type", "application/zip".parse().unwrap());
+            .insert("content-type", HeaderValue::from_static("application/zip"));
        if head_only {
            return Ok(());
        }
@@ -414,8 +357,8 @@ impl InnerService {
                error!("Failed to zip {}, {}", path.display(), e);
            }
        });
-        let stream = ReaderStream::new(reader);
-        *res.body_mut() = Body::wrap_stream(stream);
+        let reader = Streamer::new(reader, BUF_SIZE);
+        *res.body_mut() = Body::wrap_stream(reader.into_stream());
        Ok(())
    }

@@ -426,17 +369,19 @@ impl InnerService {
        head_only: bool,
        res: &mut Response,
    ) -> BoxResult<()> {
-        let path = path.join(INDEX_NAME);
-        if fs::metadata(&path)
+        let index_path = path.join(INDEX_NAME);
+        if fs::metadata(&index_path)
            .await
            .ok()
            .map(|v| v.is_file())
            .unwrap_or_default()
        {
-            self.handle_send_file(&path, headers, head_only, res)
+            self.handle_send_file(&index_path, headers, head_only, res)
                .await?;
+        } else if self.args.render_try_index {
+            self.handle_ls_dir(path, true, head_only, res).await?;
        } else {
-            status!(res, StatusCode::NOT_FOUND);
+            status_not_found(res)
        }
        Ok(())
    }
@@ -453,7 +398,7 @@ impl InnerService {
            self.handle_send_file(&path, headers, head_only, res)
                .await?;
        } else {
-            status!(res, StatusCode::NOT_FOUND);
+            status_not_found(res)
        }
        Ok(())
    }
@@ -472,7 +417,7 @@ impl InnerService {
        } else {
            *res.body_mut() = Body::from(FAVICON_ICO);
            res.headers_mut()
-                .insert("content-type", "image/x-icon".parse().unwrap());
+                .insert("content-type", HeaderValue::from_static("image/x-icon"));
        }
        Ok(())
    }
@@ -486,7 +431,7 @@ impl InnerService {
    ) -> 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>() {
@@ -497,66 +442,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
-                .typed_get::<Range>()
-                .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
-            }
+
+        let range = if use_range {
+            parse_range(headers)
        } else {
            None
        };
+
        if let Some(mime) = mime_guess::from_path(&path).first() {
            res.headers_mut().typed_insert(ContentType::from(mime));
+        } else {
+            res.headers_mut().insert(
+                CONTENT_TYPE,
+                HeaderValue::from_static("application/octet-stream"),
+            );
        }
+
        res.headers_mut().typed_insert(AcceptRanges::bytes());
+
+        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()
-            .typed_insert(ContentLength(meta.len() as u64));
+                    .insert(CONTENT_RANGE, content_range.parse().unwrap());
+                res.headers_mut()
+                    .insert(CONTENT_LENGTH, format!("{}", part_size).parse().unwrap());
                if head_only {
                    return Ok(());
                }
-
-        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)
+                *res.body_mut() = Body::wrap_stream(reader.into_stream_sized(part_size));
            } else {
-            let stream = FramedRead::new(file, BytesCodec::new());
-            Body::wrap_stream(stream)
-        };
-        *res.body_mut() = body;
-        Ok(())
+                *res.status_mut() = StatusCode::RANGE_NOT_SATISFIABLE;
+                res.headers_mut()
+                    .insert(CONTENT_RANGE, format!("bytes */{}", size).parse().unwrap());
            }
-
-    fn handle_options(&self, res: &mut Response) {
-        res.headers_mut().insert(
-            "Allow",
-            "GET,HEAD,PUT,OPTIONS,DELETE,PROPFIND,COPY,MOVE"
-                .parse()
-                .unwrap(),
-        );
-        res.headers_mut().insert("DAV", "1".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(
@@ -569,7 +526,7 @@ 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(());
                }
            },
@@ -580,7 +537,7 @@ impl InnerService {
            match self.list_dir(path, &self.args.path).await {
                Ok(child) => paths.extend(child),
                Err(_) => {
-                    status!(res, StatusCode::FORBIDDEN);
+                    status_forbid(res);
                    return Ok(());
                }
            }
@@ -600,14 +557,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(())
    }

@@ -620,14 +577,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::FORBIDDEN);
+            status_forbid(res);
            return Ok(());
        }

@@ -635,7 +592,7 @@ impl InnerService {

        fs::copy(path, &dest).await?;

-        status!(res, StatusCode::NO_CONTENT);
+        status_no_content(res);
        Ok(())
    }

@@ -648,7 +605,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(());
            }
        };
@@ -657,7 +614,7 @@ impl InnerService {

        fs::rename(path, &dest).await?;

-        status!(res, StatusCode::NO_CONTENT);
+        status_no_content(res);
        Ok(())
    }

@@ -670,7 +627,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());
@@ -772,7 +729,9 @@ const DATA =
        };
        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());
        }
@@ -881,9 +840,16 @@ struct PathItem {
 }

 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 href = encode_uri(&format!("{}{}", prefix, &self.name));
+        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!(
@@ -963,6 +929,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()
@@ -974,7 +943,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" ?>
@@ -1024,77 +993,59 @@ fn extract_cache_headers(meta: &Metadata) -> Option<(ETag, LastModified)> {
    Some((etag, last_modified))
 }

-fn to_content_range(range: &Range, complete_length: u64) -> Option<ContentRange> {
-    use core::ops::Bound::{Included, Unbounded};
-    let mut iter = range.iter();
-    let bounds = iter.next();
-
-    if iter.next().is_some() {
-        // Found multiple byte-range-spec. Drop.
-        return None;
+#[derive(Debug)]
+struct RangeValue {
+    start: u64,
+    end: Option<u64>,
 }

-    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) {
-    let prefix = encode_uri(prefix.trim_end_matches('/'));
-    let addrs = retrieve_listening_addrs(addr);
-    let protocol = if tls { "https" } else { "http" };
-    if addrs.len() == 1 {
-        println!("Listening on {}://{}{}", protocol, addr, prefix);
+fn parse_range(headers: &HeaderMap<HeaderValue>) -> Option<RangeValue> {
+    let range_hdr = headers.get(RANGE)?;
+    let hdr = range_hdr.to_str().ok()?;
+    let mut sp = hdr.splitn(2, '=');
+    let units = sp.next().unwrap();
+    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 {
-        let message = addrs
-            .iter()
-            .map(|addr| format!("  {}://{}{}", protocol, addr, prefix))
-            .collect::<Vec<String>>()
-            .join("\n");
-        println!("Listening on:\n{}\n", message);
+                Some(end.parse().ok()?)
            }
-}
-
-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;
+    *res.body_mut() = Body::from("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"));
+}
--- a/src/streamer.rs
+++ b/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()
+    }
+}
--- a/src/tls.rs
+++ b/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))
+}
--- a/tests/bind.rs
+++ b/tests/bind.rs
@@ -19,25 +19,30 @@ fn bind_fails(tmpdir: TempDir, port: u16, #[case] args: &[&str]) -> Result<(), E
        .arg(port.to_string())
        .args(args)
        .assert()
-        .stderr(predicates::str::contains("creating server listener"))
+        .stderr(predicates::str::contains("Failed to bind"))
        .failure();

    Ok(())
 }

 #[rstest]
-fn bind_ipv4(server: TestServer) -> Result<(), Error> {
-    assert!(reqwest::blocking::get(format!("http://127.0.0.1:{}", server.port()).as_str()).is_ok());
-    Ok(())
-}
-
-#[rstest]
-fn bind_ipv6(#[with(&["-b", "::"])] server: TestServer) -> Result<(), Error> {
+#[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(),
-        !cfg!(windows)
+        bind_ipv4
    );
-    assert!(reqwest::blocking::get(format!("http://[::1]:{}", server.port()).as_str()).is_ok());
+    assert_eq!(
+        reqwest::blocking::get(format!("http://[::1]:{}", server.port()).as_str()).is_ok(),
+        bind_ipv6
+    );
+
    Ok(())
 }

--- a/tests/fixtures.rs
+++ b/tests/fixtures.rs
@@ -29,7 +29,11 @@ pub static FILES: &[&str] = &[
    "foo\\bar.test",
 ];

-/// Directory names for testing purpose
+/// Directory names for testing diretory don't exist
+#[allow(dead_code)]
+pub static DIR_NO_FOUND: &str = "dir-no-found/";
+
+/// Directory names for testing diretory don't have index.html
 #[allow(dead_code)]
 pub static DIR_NO_INDEX: &str = "dir-no-index/";

@@ -55,7 +59,7 @@ pub fn tmpdir() -> TempDir {
    }
    for directory in DIRECTORIES {
        for file in FILES {
-            if *directory == DIR_NO_INDEX {
+            if *directory == DIR_NO_INDEX && *file == "index.html" {
                continue;
            }
            tmpdir
@@ -79,7 +83,7 @@ pub fn port() -> u16 {
    free_local_port().expect("Couldn't find a free local port")
 }

-/// Run miniserve as a server; Start with a temporary directory, a free port and some
+/// 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)]
--- a/tests/http.rs
+++ b/tests/http.rs
@@ -134,7 +134,7 @@ fn options_dir(server: TestServer) -> Result<(), Error> {
        resp.headers().get("allow").unwrap(),
        "GET,HEAD,PUT,OPTIONS,DELETE,PROPFIND,COPY,MOVE"
    );
-    assert_eq!(resp.headers().get("dav").unwrap(), "1");
+    assert_eq!(resp.headers().get("dav").unwrap(), "1,2");
    Ok(())
 }

--- a/tests/range.rs
+++ b/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(())
+}
--- a/tests/render.rs
+++ b/tests/render.rs
@@ -1,6 +1,7 @@
 mod fixtures;
+mod utils;

-use fixtures::{server, Error, TestServer, DIR_NO_INDEX};
+use fixtures::{server, Error, TestServer, DIR_NO_FOUND, DIR_NO_INDEX};
 use rstest::rstest;

 #[rstest]
@@ -12,12 +13,43 @@ fn render_index(#[with(&["--render-index"])] server: TestServer) -> Result<(), E
 }

 #[rstest]
-fn render_index_404(#[with(&["--render-index"])] server: TestServer) -> Result<(), Error> {
-    let resp = reqwest::blocking::get(format!("{}/{}", server.url(), DIR_NO_INDEX))?;
+fn render_index2(#[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_try_index(#[with(&["--render-try-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_try_index2(#[with(&["--render-try-index"])] server: TestServer) -> Result<(), Error> {
+    let resp = reqwest::blocking::get(format!("{}{}", server.url(), DIR_NO_INDEX))?;
+    let files: Vec<&str> = self::fixtures::FILES
+        .iter()
+        .filter(|v| **v != "index.html")
+        .cloned()
+        .collect();
+    assert_index_resp!(resp, files);
+    Ok(())
+}
+
+#[rstest]
+fn render_try_index3(#[with(&["--render-try-index"])] server: TestServer) -> Result<(), Error> {
+    let resp = reqwest::blocking::get(format!("{}{}?zip", server.url(), DIR_NO_INDEX))?;
+    assert_eq!(resp.status(), 200);
+    assert_eq!(
+        resp.headers().get("content-type").unwrap(),
+        "application/zip"
+    );
+    Ok(())
+}
+
 #[rstest]
 fn render_spa(#[with(&["--render-spa"])] server: TestServer) -> Result<(), Error> {
    let resp = reqwest::blocking::get(server.url())?;
@@ -27,8 +59,8 @@ fn render_spa(#[with(&["--render-spa"])] server: TestServer) -> Result<(), Error
 }

 #[rstest]
-fn render_spa_no_404(#[with(&["--render-spa"])] server: TestServer) -> Result<(), Error> {
-    let resp = reqwest::blocking::get(format!("{}/{}", server.url(), DIR_NO_INDEX))?;
+fn render_spa2(#[with(&["--render-spa"])] server: TestServer) -> Result<(), Error> {
+    let resp = reqwest::blocking::get(format!("{}{}", server.url(), DIR_NO_FOUND))?;
    let text = resp.text()?;
    assert_eq!(text, "This is index.html");
    Ok(())
--- a/tests/webdav.rs
+++ b/tests/webdav.rs
@@ -10,7 +10,7 @@ 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: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))));
@@ -29,7 +29,7 @@ fn propfind_dir_depth0(server: TestServer) -> Result<(), Error> {
        .send()?;
    assert_eq!(resp.status(), 207);
    let body = resp.text()?;
-    assert!(body.contains("<D:href>/dira</D:href>"));
+    assert!(body.contains("<D:href>/dira/</D:href>"));
    assert!(body.contains("<D:displayname>dira</D:displayname>"));
    assert_eq!(
        body.lines()
Author	SHA1	Message	Date
sigoden	9384cc8587	chore(release): version v0.18.0	2022-06-18 08:05:18 +08:00
sigoden	df48021757	chore: send not found text when 404	2022-06-18 08:03:48 +08:00
sigoden	af866aaaf4	chore: optimize --render-try-index	2022-06-17 19:05:25 +08:00
sigoden	68d238d34d	feat: add slash to end of dir href	2022-06-17 19:01:17 +08:00
sigoden	a10150f2f8	chore: update readme	2022-06-17 10:59:19 +08:00
sigoden	5b11bb75dd	feat: add option --render-try-index (#47 ) close #46	2022-06-17 08:41:01 +08:00
sigoden	6d7da0363c	chore(release): version v0.17.1	2022-06-16 10:31:47 +08:00
sigoden	d8f7335053	fix: range request (#44 ) close #43	2022-06-16 10:24:32 +08:00
sigoden	7fc8fc6236	chore(release): version v0.17.0	2022-06-15 20:31:53 +08:00
sigoden	c7d42a3f1c	fix: webdav propfind dir with slash (#42 )	2022-06-15 20:24:53 +08:00
sigoden	3c4bb77023	refactor: trival changes (#41 ) - refactor status code - log remote addr and time in miliseconds	2022-06-15 19:57:28 +08:00
sigoden	12aafa00d8	feat: listen both ipv4 and ipv6 by default (#40 )	2022-06-15 19:33:51 +08:00