chore(release): version v0.19.0

close #50

BREAKING CHANGE: rename duf to dufs

CHANGELOG.md

@@ -2,67 +2,88 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.19.0] - 2022-06-19
+
+### Features
+
+- [**breaking**] Path level access control ([#52](https://github.com/sigoden/dufs/issues/52))
+- Serve single file ([#54](https://github.com/sigoden/dufs/issues/54))
+- Ui hidden root dirname ([#58](https://github.com/sigoden/dufs/issues/58))
+- Reactive webpage ([#51](https://github.com/sigoden/dufs/issues/51))
+- [**breaking**] Rename to dufs ([#59](https://github.com/sigoden/dufs/issues/59))
+
+### Refactor
+
+- [**breaking**] Rename --cors to --enable-cors ([#57](https://github.com/sigoden/dufs/issues/57))
+
+## [0.18.0] - 2022-06-18
+
+### Features
+
+- Add option --render-try-index ([#47](https://github.com/sigoden/dufs/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))
+- Range request ([#44](https://github.com/sigoden/dufs/issues/44))
 
 ## [0.17.0] - 2022-06-15
 
 ### Bug Fixes
 
-- Webdav propfind dir with slash ([#42](https://github.com/sigoden/duf/issues/42))
+- Webdav propfind dir with slash ([#42](https://github.com/sigoden/dufs/issues/42))
 
 ### Features
 
-- Listen both ipv4 and ipv6 by default ([#40](https://github.com/sigoden/duf/issues/40))
+- Listen both ipv4 and ipv6 by default ([#40](https://github.com/sigoden/dufs/issues/40))
 
 ### Refactor
 
-- Trival changes ([#41](https://github.com/sigoden/duf/issues/41))
+- Trival changes ([#41](https://github.com/sigoden/dufs/issues/41))
 
 ## [0.16.0] - 2022-06-12
 
 ### Features
 
-- Implement head method ([#33](https://github.com/sigoden/duf/issues/33))
+- Implement head method ([#33](https://github.com/sigoden/dufs/issues/33))
-- Display upload speed and time left ([#34](https://github.com/sigoden/duf/issues/34))
+- Display upload speed and time left ([#34](https://github.com/sigoden/dufs/issues/34))
-- Support tls-key in pkcs#8 format ([#35](https://github.com/sigoden/duf/issues/35))
+- Support tls-key in pkcs#8 format ([#35](https://github.com/sigoden/dufs/issues/35))
 - Options method return status 200
 
 ### Testing
 
-- Add integration tests ([#36](https://github.com/sigoden/duf/issues/36))
+- Add integration tests ([#36](https://github.com/sigoden/dufs/issues/36))
 
 ## [0.15.1] - 2022-06-11
 
 ### Bug Fixes
 
-- Cannot upload ([#32](https://github.com/sigoden/duf/issues/32))
+- Cannot upload ([#32](https://github.com/sigoden/dufs/issues/32))
 
 ## [0.15.0] - 2022-06-10
 
 ### Bug Fixes
 
-- Encode webdav href as uri ([#28](https://github.com/sigoden/duf/issues/28))
+- Encode webdav href as uri ([#28](https://github.com/sigoden/dufs/issues/28))
 - Query dir param
 
 ### Features
 
-- Add basic dark theme ([#29](https://github.com/sigoden/duf/issues/29))
+- Add basic dark theme ([#29](https://github.com/sigoden/dufs/issues/29))
-- Add empty state placeholder to page([#30](https://github.com/sigoden/duf/issues/30))
+- Add empty state placeholder to page([#30](https://github.com/sigoden/dufs/issues/30))
 
 ## [0.14.0] - 2022-06-07
 
 ### Bug Fixes
 
-- Send index page with content-type ([#26](https://github.com/sigoden/duf/issues/26))
+- Send index page with content-type ([#26](https://github.com/sigoden/dufs/issues/26))
 
 ### Features
 
-- Support ipv6 ([#25](https://github.com/sigoden/duf/issues/25))
+- Support ipv6 ([#25](https://github.com/sigoden/dufs/issues/25))
-- Add favicon ([#27](https://github.com/sigoden/duf/issues/27))
+- Add favicon ([#27](https://github.com/sigoden/dufs/issues/27))
 
 ## [0.13.2] - 2022-06-06
 
@@ -75,11 +96,11 @@ All notable changes to this project will be documented in this file.
 
 ### Bug Fixes
 
-- Escape filename ([#21](https://github.com/sigoden/duf/issues/21))
+- Escape filename ([#21](https://github.com/sigoden/dufs/issues/21))
 
 ### Refactor
 
-- Use logger ([#22](https://github.com/sigoden/duf/issues/22))
+- Use logger ([#22](https://github.com/sigoden/dufs/issues/22))
 
 ## [0.13.0] - 2022-06-05
 
@@ -89,16 +110,16 @@ All notable changes to this project will be documented in this file.
 
 ### Features
 
-- Implement more webdav methods ([#13](https://github.com/sigoden/duf/issues/13))
+- Implement more webdav methods ([#13](https://github.com/sigoden/dufs/issues/13))
-- Use digest auth ([#14](https://github.com/sigoden/duf/issues/14))
+- Use digest auth ([#14](https://github.com/sigoden/dufs/issues/14))
-- Add webdav proppatch handler ([#18](https://github.com/sigoden/duf/issues/18))
+- Add webdav proppatch handler ([#18](https://github.com/sigoden/dufs/issues/18))
 
 ## [0.12.1] - 2022-06-04
 
 ### Features
 
-- Support webdav ([#10](https://github.com/sigoden/duf/issues/10))
+- Support webdav ([#10](https://github.com/sigoden/dufs/issues/10))
-- Remove unzip uploaded feature ([#11](https://github.com/sigoden/duf/issues/11))
+- Remove unzip uploaded feature ([#11](https://github.com/sigoden/dufs/issues/11))
 
 ## [0.11.0] - 2022-06-03
 

Cargo.lock

@@ -570,8 +570,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fea41bba32d969b513997752735605054bc0dfa92b4c56bf1189f2e174be7a10"
 
 [[package]]
-name = "duf"
+name = "dufs"
-version = "0.17.1"
+version = "0.19.0"
 dependencies = [
  "assert_cmd",
  "assert_fs",

Cargo.toml

@@ -1,12 +1,12 @@
 [package]
-name = "duf"
+name = "dufs"
-version = "0.17.1"
+version = "0.19.0"
 edition = "2021"
 authors = ["sigoden <sigoden@gmail.com>"]
-description = "Duf is a simple file server."
+description = "Dufs is a simple file server."
 license = "MIT OR Apache-2.0"
-homepage = "https://github.com/sigoden/duf"
+homepage = "https://github.com/sigoden/dufs"
-repository = "https://github.com/sigoden/duf"
+repository = "https://github.com/sigoden/dufs"
 categories = ["command-line-utilities", "web-programming::http-server"]
 keywords = ["static", "file", "server", "webdav", "cli"]
 

Dockerfile

@@ -6,5 +6,5 @@ COPY . .
 RUN cargo build --target x86_64-unknown-linux-musl --release
 
 FROM scratch
-COPY --from=builder /app/target/x86_64-unknown-linux-musl/release/duf /bin/
+COPY --from=builder /app/target/x86_64-unknown-linux-musl/release/dufs /bin/
-ENTRYPOINT ["/bin/duf"]
+ENTRYPOINT ["/bin/dufs"]

README.md

@@ -1,11 +1,11 @@
-# Duf
+# Dufs (Old Name: Duf)
 
-[![CI](https://github.com/sigoden/duf/actions/workflows/ci.yaml/badge.svg)](https://github.com/sigoden/duf/actions/workflows/ci.yaml)
+[![CI](https://github.com/sigoden/dufs/actions/workflows/ci.yaml/badge.svg)](https://github.com/sigoden/dufs/actions/workflows/ci.yaml)
-[![Crates](https://img.shields.io/crates/v/duf.svg)](https://crates.io/crates/duf)
+[![Crates](https://img.shields.io/crates/v/dufs.svg)](https://crates.io/crates/dufs)
 
-Duf is a simple file server. Support static serve, search, upload, webdav...
+Dufs is a simple file server. Support static serve, search, upload, webdav...
 
-![demo](https://user-images.githubusercontent.com/4012553/171526189-09afc2de-793f-4216-b3d5-31ea408d3610.png)
+![demo](https://user-images.githubusercontent.com/4012553/174486522-7af350e6-0195-4f4a-8480-d9464fc6452f.png)
 
 ## Features
 
@@ -14,7 +14,7 @@ Duf is a simple file server. Support static serve, search, upload, webdav...
 - Upload files and folders (Drag & Drop)
 - Search files
 - Partial responses (Parallel/Resume download)
-- Authentication
+- Path level access control
 - Support https
 - Support webdav
 - Easy to use with curl
@@ -24,116 +24,168 @@ Duf is a simple file server. Support static serve, search, upload, webdav...
 ### With cargo
 
 ```
-cargo install duf
+cargo install dufs
 ```
 
 ### 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/dufs /data
 ```
 
 ### Binaries on macOS, Linux, Windows
 
-Download from [Github Releases](https://github.com/sigoden/duf/releases), unzip and add duf to your $PATH.
+Download from [Github Releases](https://github.com/sigoden/dufs/releases), unzip and add dufs to your $PATH.
 
 ## CLI
 
 ```
-Duf is a simple file server. - https://github.com/sigoden/duf
+Dufs is a simple file server. - https://github.com/sigoden/dufs
 
 USAGE:
-    duf [OPTIONS] [--] [path]
+    dufs [OPTIONS] [--] [path]
 
 ARGS:
     <path>    Path to a root directory for serving files [default: .]
 
 OPTIONS:
-    -a, --auth <user:pass>      Use HTTP authentication
+    -b, --bind <addr>...        Specify bind address
-        --no-auth-access        Not required auth when access static files
-    -A, --allow-all             Allow all operations
-        --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
-        --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
+    -a, --auth <rule>...        Add auth for path
+    -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
+        --enable-cors           Enable CORS, sets `Access-Control-Allow-Origin: *`
         --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
         --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
+dufs
 ```
 
-...or specify which folder you want to serve.
+Allow upload/delete
 
 ```
-duf folder_name
+dufs -A
 ```
 
-Allow all operations such as upload, delete
+Listen on a specific port
-
-```sh
-duf --allow-all
-```
-
-Only allow upload operation
 
 ```
-duf --allow-upload
+dufs -p 80
 ```
 
-Serve a single page application (SPA)
+For a single page application (SPA)
 
 ```
-duf --render-spa
+dufs --render-spa
 ```
 
 Use https
 
 ```
-duf --tls-cert my.crt --tls-key my.key
+dufs --tls-cert my.crt --tls-key my.key
 ```
 
 ## API
 
 Download a file
 ```
-curl http://127.0.0.1:5000/some-file
+curl http://127.0.0.1:5000/path-to-file
 ```
 
 Download a folder as zip file
 
 ```
-curl -o some-folder.zip http://127.0.0.1:5000/some-folder?zip
+curl -o path-to-folder.zip http://127.0.0.1:5000/path-to-folder?zip
 ```
 
 Upload a file
 
 ```
-curl --upload-file some-file http://127.0.0.1:5000/some-file
+curl --upload-file path-to-file http://127.0.0.1:5000/path-to-file
 ```
 
 Delete a file/folder
 
 ```
-curl -X DELETE http://127.0.0.1:5000/some-file
+curl -X DELETE http://127.0.0.1:5000/path-to-file
 ```
 
+## Details
+
+<details>
+<summary>
+
+#### 1. Control render logic
+
+</summary>
+
+
+The default render logic is:
+
+-  If request for a folder, rendering the directory listing. 
+-  If request for a file, rendering the file.
+-  If request target does not exist, returns 404.
+
+The `--render-*` options change the render logic:
+
+- `--render-index`: If request for a folder, rendering index.html in the folder. If the index.html file does not exist, return 404.
+- `--render-try-index`: Like `--render-index`, rendering the directory listing if the index.html file does not exist, other than return 404.
+- `--render-spa`: If request target does not exist, rendering `/index.html`
+
+</details>
+
+<details>
+<summary>
+
+#### 2. Path level access control
+
+</summary>
+
+```
+dufs -a <path>@<readwrite>[@<readonly>]
+```
+
+- `<path>`: Path to protected
+- `<readwrite>`: Account with readwrite permission, required
+- `<readonly>`: Account with readonly permission, optional
+
+> `*` as `<readonly>` means `<path>` is public, everyone can access/download it.
+
+For example:
+
+```
+dufs -a /@admin:pass@* -a /ui@designer:pass1 -A
+```
+- All files/folders are public to access/download.
+- Account `admin:pass` can upload/delete/download any files/folders.
+- Account `designer:pass1` can upload/delete/download any files/folders in the `ui` folder.
+
+Curl with digest auth:
+
+```
+curl --digest -u designer:pass1 http://127.0.0.1:5000/ui/path-to-file
+```
+
+</details>
+
 ## License
 
-Copyright (c) 2022 duf-developers.
+Copyright (c) 2022 dufs-developers.
 
-duf is made available under the terms of either the MIT License or the Apache License 2.0, at your option.
+dufs is made available under the terms of either the MIT License or the Apache License 2.0, at your option.
 
 See the LICENSE-APACHE and LICENSE-MIT files for license details.

assets/index.css

@@ -4,10 +4,6 @@ html {
   color: #24292e;
 }
 
-body {
-  width: 700px;
-}
-
 .hidden {
   display: none;
 }
@@ -21,6 +17,7 @@ body {
 
 .breadcrumb {
   font-size: 1.25em;
+  padding-right: 0.6em;
 }
 
 .breadcrumb > a {
@@ -45,12 +42,11 @@ body {
 .breadcrumb svg {
   height: 100%;
   fill: rgba(3,47,98,0.5);
-  padding-right: 0.5em;
-  padding-left: 0.5em;
 }
 
 .toolbox {
   display: flex;
+  margin-right: 10px;
 }
 
 .searchbar {
@@ -62,7 +58,7 @@ body {
   transition: all .15s;
   border: 1px #ddd solid;
   border-radius: 15px;
-  margin: 0 0 2px 10px;
+  margin-bottom: 2px;
 }
 
 .searchbar #search {
@@ -152,10 +148,10 @@ body {
   height: 100%;
   fill: rgba(3,47,98,0.5);
   padding-right: 0.5em;
+  vertical-align: text-top;
 }
 
 .path {
-  display: flex;
   list-style: none;
 }
 
@@ -166,6 +162,8 @@ body {
   overflow: hidden;
   display: block;
   text-decoration: none;
+  max-width: calc(100vw - 375px);
+  min-width: 400px;
 }
 
 .path a:hover {
@@ -203,7 +201,7 @@ body {
 
   svg,
   .path svg {
-    fill: #d0e6ff;
+    fill: #fff;
   }
 
   .searchbar {

assets/index.html

@@ -35,16 +35,16 @@
     <table class="uploaders-table hidden">
       <thead>
         <tr>
-          <th class="cell-name">Name</th>
+          <th class="cell-name" colspan="2">Name</th>
-          <th class="cell-status">Speed - Progress - Time Left</th>
+          <th class="cell-status">Progress</th>
         </tr>
       </thead>
     </table>
     <table class="paths-table hidden">
       <thead>
         <tr>
-          <th class="cell-name">Name</th>
+          <th class="cell-name" colspan="2">Name</th>
-          <th class="cell-mtime">Date modify</th>
+          <th class="cell-mtime">Last modified</th>
           <th class="cell-size">Size</th>
           <th class="cell-actions">Actions</th>
         </tr>

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
@@ -30,10 +29,6 @@ let $uploadersTable;
  * @type Element
  */
 let $emptyFolder;
-/**
- * @type string
- */
-let baseDir;
 
 class Uploader {
   /**
@@ -72,8 +67,10 @@ class Uploader {
     let url = getUrl(name);
     $uploadersTable.insertAdjacentHTML("beforeend", `
   <tr id="upload${idx}" class="uploader">
+    <td class="path cell-icon">
+      ${getSvg(file.path_type)}
+    </td>
     <td class="path cell-name">
-      <div>${getSvg("File")}</div>
       <a href="${url}">${name}</a>
     </td>
     <td class="cell-status upload-status" id="uploadStatus${idx}"></td>
@@ -123,29 +120,39 @@ class Uploader {
 
 /**
  * Add breadcrumb
- * @param {string} value 
+ * @param {string} href 
+ * @param {string} uri_prefix
  */
-function addBreadcrumb(value) {
+function addBreadcrumb(href, uri_prefix) {
   const $breadcrumb = document.querySelector(".breadcrumb");
-  const parts = value.split("/").filter(v => !!v);
+  let parts = [];
+  if (href === "/") {
+    parts = [""];
+  } else {
+    parts = href.split("/");
+  }
   const len = parts.length;
-  let path = "";
+  let path = uri_prefix;
   for (let i = 0; i < len; i++) {
     const name = parts[i];
     if (i > 0) {
-      path  += "/" + name;
+      if (!path.endsWith("/")) {
+        path  += "/";
       }
-    if (i === len - 1) {
+      path += encodeURI(name);
+    }
+    if (i === 0) {
+      $breadcrumb.insertAdjacentHTML("beforeend", `<a href="${path}"><svg width="16" height="16" viewBox="0 0 16 16"><path d="M6.5 14.5v-3.505c0-.245.25-.495.5-.495h2c.25 0 .5.25.5.5v3.5a.5.5 0 0 0 .5.5h4a.5.5 0 0 0 .5-.5v-7a.5.5 0 0 0-.146-.354L13 5.793V2.5a.5.5 0 0 0-.5-.5h-1a.5.5 0 0 0-.5.5v1.293L8.354 1.146a.5.5 0 0 0-.708 0l-6 6A.5.5 0 0 0 1.5 7.5v7a.5.5 0 0 0 .5.5h4a.5.5 0 0 0 .5-.5z"/></svg></a>`);
+    } else if (i === len - 1) {
       $breadcrumb.insertAdjacentHTML("beforeend", `<b>${name}</b>`);
-      baseDir = name;
-    } else if (i === 0) {
-      $breadcrumb.insertAdjacentHTML("beforeend", `<a href="/"><b>${name}</b></a>`);
     } else {
-      $breadcrumb.insertAdjacentHTML("beforeend", `<a href="${encodeURI(path)}">${name}</a>`);
+      $breadcrumb.insertAdjacentHTML("beforeend", `<a href="${path}">${name}</a>`);
     }
+    if (i !== len - 1) {
       $breadcrumb.insertAdjacentHTML("beforeend", `<span class="separator">/</span>`);
     }
   }
+}
 
 /**
  * Add pathitem
@@ -153,10 +160,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">
@@ -185,8 +193,10 @@ function addPath(file, index) {
 
   $pathsTableBody.insertAdjacentHTML("beforeend", `
 <tr id="addPath${index}">
+  <td class="path cell-icon">
+    ${getSvg(file.path_type)}
+  </td>
   <td class="path cell-name">
-    <div>${getSvg(file.path_type)}</div>
     <a href="${url}" title="${file.name}">${file.name}</a>
   </td>
   <td class="cell-mtime">${formatMtime(file.mtime)}</td>
@@ -292,7 +302,7 @@ function formatMtime(mtime) {
   const day = padZero(date.getDate(), 2);
   const hours = padZero(date.getHours(), 2);
   const minutes = padZero(date.getMinutes(), 2);
-  return `${year}/${month}/${day} ${hours}:${minutes}`;
+  return `${year}-${month}-${day} ${hours}:${minutes}`;
 }
 
 function padZero(value, size) {
@@ -333,7 +343,7 @@ function ready() {
     document.getElementById('search').value = params.q;
   }
 
-  addBreadcrumb(DATA.breadcrumb);
+  addBreadcrumb(DATA.href, DATA.uri_prefix);
   if (Array.isArray(DATA.paths)) {
     const len = DATA.paths.length;
     if (len > 0) {

src/args.rs

@@ -1,10 +1,10 @@
-use clap::{Arg, ArgMatches, Command};
+use clap::{AppSettings, Arg, ArgMatches, Command};
 use rustls::{Certificate, PrivateKey};
 use std::env;
 use std::net::IpAddr;
 use std::path::{Path, PathBuf};
 
-use crate::auth::parse_auth;
+use crate::auth::AccessControl;
 use crate::tls::{load_certs, load_private_key};
 use crate::BoxResult;
 
@@ -17,14 +17,15 @@ fn app() -> Command<'static> {
             " - ",
             env!("CARGO_PKG_REPOSITORY")
         ))
+        .global_setting(AppSettings::DeriveDisplayOrder)
         .arg(
-            Arg::new("address")
+            Arg::new("bind")
                 .short('b')
                 .long("bind")
                 .help("Specify bind address")
                 .multiple_values(true)
                 .multiple_occurrences(true)
-                .value_name("address"),
+                .value_name("addr"),
         )
         .arg(
             Arg::new("port")
@@ -46,6 +47,15 @@ fn app() -> Command<'static> {
                 .value_name("path")
                 .help("Specify an url path prefix"),
         )
+        .arg(
+            Arg::new("auth")
+                .short('a')
+                .long("auth")
+                .help("Add auth for path")
+                .multiple_values(true)
+                .multiple_occurrences(true)
+                .value_name("rule"),
+        )
         .arg(
             Arg::new("allow-all")
                 .short('A')
@@ -67,35 +77,26 @@ fn app() -> Command<'static> {
                 .long("allow-symlink")
                 .help("Allow symlink to files/folders outside root directory"),
         )
+        .arg(
+            Arg::new("enable-cors")
+                .long("enable-cors")
+                .help("Enable CORS, sets `Access-Control-Allow-Origin: *`"),
+        )
         .arg(
             Arg::new("render-index")
                 .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")
-                .help("Enable CORS, sets `Access-Control-Allow-Origin: *`"),
-        )
         .arg(
             Arg::new("tls-cert")
                 .long("tls-cert")
@@ -114,21 +115,22 @@ pub fn matches() -> ArgMatches {
     app().get_matches()
 }
 
-#[derive(Debug, Clone, Eq, PartialEq)]
+#[derive(Debug, Clone)]
 pub struct Args {
     pub addrs: Vec<IpAddr>,
     pub port: u16,
     pub path: PathBuf,
+    pub path_is_file: bool,
     pub path_prefix: String,
     pub uri_prefix: String,
-    pub auth: Option<(String, String)>,
+    pub auth: AccessControl,
-    pub no_auth_access: bool,
     pub allow_upload: bool,
     pub allow_delete: bool,
     pub allow_symlink: bool,
     pub render_index: bool,
     pub render_spa: bool,
-    pub cors: bool,
+    pub render_try_index: bool,
+    pub enable_cors: bool,
     pub tls: Option<(Vec<Certificate>, PrivateKey)>,
 }
 
@@ -140,11 +142,12 @@ impl Args {
     pub fn parse(matches: ArgMatches) -> BoxResult<Args> {
         let port = matches.value_of_t::<u16>("port")?;
         let addrs = matches
-            .values_of("address")
+            .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_is_file = path.metadata()?.is_file();
         let path_prefix = matches
             .value_of("path-prefix")
             .map(|v| v.trim_matches('/').to_owned())
@@ -154,16 +157,17 @@ impl Args {
         } else {
             format!("/{}/", &path_prefix)
         };
-        let cors = matches.is_present("cors");
+        let enable_cors = matches.is_present("enable-cors");
-        let auth = match matches.value_of("auth") {
+        let auth: Vec<&str> = matches
-            Some(auth) => Some(parse_auth(auth)?),
+            .values_of("auth")
-            None => None,
+            .map(|v| v.collect())
-        };
+            .unwrap_or_default();
-        let no_auth_access = matches.is_present("no-auth-access");
+        let auth = AccessControl::new(&auth, &uri_prefix)?;
         let allow_upload = matches.is_present("allow-all") || matches.is_present("allow-upload");
         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)) => {
@@ -178,15 +182,16 @@ impl Args {
             addrs,
             port,
             path,
+            path_is_file,
             path_prefix,
             uri_prefix,
             auth,
-            no_auth_access,
+            enable_cors,
-            cors,
             allow_delete,
             allow_upload,
             allow_symlink,
             render_index,
+            render_try_index,
             render_spa,
             tls,
         })

src/auth.rs

@@ -1,4 +1,5 @@
 use headers::HeaderValue;
+use hyper::Method;
 use lazy_static::lazy_static;
 use md5::Context;
 use std::{
@@ -7,9 +8,10 @@ use std::{
 };
 use uuid::Uuid;
 
+use crate::utils::encode_uri;
 use crate::BoxResult;
 
-const REALM: &str = "DUF";
+const REALM: &str = "DUFS";
 
 lazy_static! {
     static ref NONCESTARTHASH: Context = {
@@ -20,6 +22,151 @@ lazy_static! {
     };
 }
 
+#[derive(Debug, Clone)]
+pub struct AccessControl {
+    rules: HashMap<String, PathControl>,
+}
+
+#[derive(Debug, Clone)]
+pub struct PathControl {
+    readwrite: Account,
+    readonly: Option<Account>,
+    share: bool,
+}
+
+impl AccessControl {
+    pub fn new(raw_rules: &[&str], uri_prefix: &str) -> BoxResult<Self> {
+        let mut rules = HashMap::default();
+        if raw_rules.is_empty() {
+            return Ok(Self { rules });
+        }
+        for rule in raw_rules {
+            let parts: Vec<&str> = rule.split('@').collect();
+            let create_err = || format!("Invalid auth `{}`", rule).into();
+            match parts.as_slice() {
+                [path, readwrite] => {
+                    let control = PathControl {
+                        readwrite: Account::new(readwrite).ok_or_else(create_err)?,
+                        readonly: None,
+                        share: false,
+                    };
+                    rules.insert(sanitize_path(path, uri_prefix), control);
+                }
+                [path, readwrite, readonly] => {
+                    let (readonly, share) = if *readonly == "*" {
+                        (None, true)
+                    } else {
+                        (Some(Account::new(readonly).ok_or_else(create_err)?), false)
+                    };
+                    let control = PathControl {
+                        readwrite: Account::new(readwrite).ok_or_else(create_err)?,
+                        readonly,
+                        share,
+                    };
+                    rules.insert(sanitize_path(path, uri_prefix), control);
+                }
+                _ => return Err(create_err()),
+            }
+        }
+        Ok(Self { rules })
+    }
+
+    pub fn guard(
+        &self,
+        path: &str,
+        method: &Method,
+        authorization: Option<&HeaderValue>,
+    ) -> GuardType {
+        if self.rules.is_empty() {
+            return GuardType::ReadWrite;
+        }
+        let mut controls = vec![];
+        for path in walk_path(path) {
+            if let Some(control) = self.rules.get(path) {
+                controls.push(control);
+                if let Some(authorization) = authorization {
+                    let Account { user, pass } = &control.readwrite;
+                    if valid_digest(authorization, method.as_str(), user, pass).is_some() {
+                        return GuardType::ReadWrite;
+                    }
+                }
+            }
+        }
+        if is_readonly_method(method) {
+            for control in controls.into_iter() {
+                if control.share {
+                    return GuardType::ReadOnly;
+                }
+                if let Some(authorization) = authorization {
+                    if let Some(Account { user, pass }) = &control.readonly {
+                        if valid_digest(authorization, method.as_str(), user, pass).is_some() {
+                            return GuardType::ReadOnly;
+                        }
+                    }
+                }
+            }
+        }
+        GuardType::Reject
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub enum GuardType {
+    Reject,
+    ReadWrite,
+    ReadOnly,
+}
+
+impl GuardType {
+    pub fn is_reject(&self) -> bool {
+        *self == GuardType::Reject
+    }
+}
+
+fn sanitize_path(path: &str, uri_prefix: &str) -> String {
+    encode_uri(&format!("{}{}", uri_prefix, path.trim_matches('/')))
+}
+
+fn walk_path(path: &str) -> impl Iterator<Item = &str> {
+    let mut idx = 0;
+    path.split('/').enumerate().map(move |(i, part)| {
+        let end = if i == 0 { 1 } else { idx + part.len() + i };
+        let value = &path[..end];
+        idx += part.len();
+        value
+    })
+}
+
+fn is_readonly_method(method: &Method) -> bool {
+    method == Method::GET
+        || method == Method::OPTIONS
+        || method == Method::HEAD
+        || method.as_str() == "PROPFIND"
+}
+
+#[derive(Debug, Clone)]
+struct Account {
+    user: String,
+    pass: String,
+}
+
+impl Account {
+    fn new(data: &str) -> Option<Self> {
+        let p: Vec<&str> = data.trim().split(':').collect();
+        if p.len() != 2 {
+            return None;
+        }
+        let user = p[0];
+        let pass = p[1];
+        let mut h = Context::new();
+        h.consume(format!("{}:{}:{}", user, REALM, pass).as_bytes());
+        Some(Account {
+            user: user.to_owned(),
+            pass: format!("{:x}", h.compute()),
+        })
+    }
+}
+
 pub fn generate_www_auth(stale: bool) -> String {
     let str_stale = if stale { "stale=true," } else { "" };
     format!(
@@ -30,26 +177,13 @@ pub fn generate_www_auth(stale: bool) -> String {
     )
 }
 
-pub fn parse_auth(auth: &str) -> BoxResult<(String, String)> {
-    let p: Vec<&str> = auth.trim().split(':').collect();
-    let err = "Invalid auth value";
-    if p.len() != 2 {
-        return Err(err.into());
-    }
-    let user = p[0];
-    let pass = p[1];
-    let mut h = Context::new();
-    h.consume(format!("{}:{}:{}", user, REALM, pass).as_bytes());
-    Ok((user.to_owned(), format!("{:x}", h.compute())))
-}
-
 pub fn valid_digest(
-    header_value: &HeaderValue,
+    authorization: &HeaderValue,
     method: &str,
     auth_user: &str,
     auth_pass: &str,
 ) -> Option<()> {
-    let digest_value = strip_prefix(header_value.as_bytes(), b"Digest ")?;
+    let digest_value = strip_prefix(authorization.as_bytes(), b"Digest ")?;
     let user_vals = to_headermap(digest_value).ok()?;
     if let (Some(username), Some(nonce), Some(user_response)) = (
         user_vals

src/main.rs

@@ -3,6 +3,7 @@ mod auth;
 mod server;
 mod streamer;
 mod tls;
+mod utils;
 
 #[macro_use]
 extern crate log;

src/server.rs

@@ -1,5 +1,6 @@
-use crate::auth::{generate_www_auth, valid_digest};
+use crate::auth::generate_www_auth;
 use crate::streamer::Streamer;
+use crate::utils::{decode_uri, encode_uri};
 use crate::{Args, BoxResult};
 use xml::escape::escape_str_pcdata;
 
@@ -19,7 +20,6 @@ use hyper::header::{
     CONTENT_TYPE, ORIGIN, RANGE, WWW_AUTHENTICATE,
 };
 use hyper::{Body, Method, StatusCode, Uri};
-use percent_encoding::percent_decode;
 use serde::Serialize;
 use std::fs::Metadata;
 use std::io::SeekFrom;
@@ -59,7 +59,7 @@ impl Server {
     ) -> Result<Response, hyper::Error> {
         let method = req.method().clone();
         let uri = req.uri().clone();
-        let cors = self.args.cors;
+        let enable_cors = self.args.enable_cors;
 
         let mut res = match self.handle(req).await {
             Ok(res) => {
@@ -77,7 +77,7 @@ impl Server {
             }
         };
 
-        if cors {
+        if enable_cors {
             add_cors(&mut res);
         }
         Ok(res)
@@ -86,16 +86,27 @@ impl Server {
     pub async fn handle(self: Arc<Self>, req: Request) -> BoxResult<Response> {
         let mut res = Response::default();
 
-        if !self.auth_guard(&req, &mut res) {
-            return Ok(res);
-        }
-
         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?;
+            self.handle_send_favicon(headers, &mut res).await?;
+            return Ok(res);
+        }
+
+        let authorization = headers.get(AUTHORIZATION);
+        let guard_type = self.args.auth.guard(req_path, &method, authorization);
+        if guard_type.is_reject() {
+            self.auth_reject(&mut res);
+            return Ok(res);
+        }
+
+        let head_only = method == Method::HEAD;
+
+        if self.args.path_is_file {
+            self.handle_send_file(&self.args.path, headers, head_only, &mut res)
+                .await?;
             return Ok(res);
         }
 
@@ -106,6 +117,7 @@ impl Server {
                 return Ok(res);
             }
         };
+
         let path = path.as_path();
 
         let query = req.uri().query().unwrap_or_default();
@@ -119,6 +131,7 @@ impl Server {
         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_not_found(&mut res);
@@ -127,9 +140,10 @@ impl Server {
 
         match method {
             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" {
@@ -215,7 +229,8 @@ impl Server {
                 "LOCK" => {
                     // Fake lock
                     if is_file {
-                        self.handle_lock(req_path, &mut res).await?;
+                        let has_auth = authorization.is_some();
+                        self.handle_lock(req_path, has_auth, &mut res).await?;
                     } else {
                         status_not_found(&mut res);
                     }
@@ -331,10 +346,7 @@ impl Server {
         res: &mut Response,
     ) -> BoxResult<()> {
         let (mut writer, reader) = tokio::io::duplex(BUF_SIZE);
-        let filename = path
+        let filename = get_file_name(path)?;
-            .file_name()
-            .and_then(|v| v.to_str())
-            .ok_or_else(|| format!("Failed to get name of `{}`", path.display()))?;
         res.headers_mut().insert(
             CONTENT_DISPOSITION,
             HeaderValue::from_str(&format!(
@@ -366,15 +378,17 @@ impl Server {
         head_only: bool,
         res: &mut Response,
     ) -> BoxResult<()> {
-        let path = path.join(INDEX_NAME);
+        let index_path = path.join(INDEX_NAME);
-        if fs::metadata(&path)
+        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_not_found(res)
         }
@@ -471,6 +485,13 @@ impl Server {
             );
         }
 
+        let filename = get_file_name(path)?;
+        res.headers_mut().insert(
+            CONTENT_DISPOSITION,
+            HeaderValue::from_str(&format!("inline; filename=\"{}\"", encode_uri(filename),))
+                .unwrap(),
+        );
+
         res.headers_mut().typed_insert(AcceptRanges::bytes());
 
         let size = meta.len();
@@ -613,11 +634,11 @@ impl Server {
         Ok(())
     }
 
-    async fn handle_lock(&self, req_path: &str, res: &mut Response) -> BoxResult<()> {
+    async fn handle_lock(&self, req_path: &str, auth: bool, res: &mut Response) -> BoxResult<()> {
-        let token = if self.args.auth.is_none() {
+        let token = if auth {
-            Utc::now().timestamp().to_string()
-        } else {
             format!("opaquelocktoken:{}", Uuid::new_v4())
+        } else {
+            Utc::now().timestamp().to_string()
         };
 
         res.headers_mut().insert(
@@ -663,12 +684,10 @@ impl Server {
         res: &mut Response,
     ) -> BoxResult<()> {
         paths.sort_unstable();
-        let rel_path = match self.args.path.parent() {
+        let href = format!("/{}", normalize_path(path.strip_prefix(&self.args.path)?));
-            Some(p) => path.strip_prefix(p).unwrap(),
-            None => path,
-        };
         let data = IndexData {
-            breadcrumb: normalize_path(rel_path),
+            href: href.clone(),
+            uri_prefix: self.args.uri_prefix.clone(),
             paths,
             allow_upload: self.args.allow_upload,
             allow_delete: self.args.allow_delete,
@@ -679,17 +698,14 @@ impl Server {
             "__SLOT__",
             &format!(
                 r#"
-<title>Files in {}/ - Duf</title>
+<title>Index of {} - Dufs</title>
 <style>{}</style>
 <script>
 const DATA = 
 {}
 {}</script>
 "#,
-                rel_path.display(),
+                href, INDEX_CSS, data, INDEX_JS
-                INDEX_CSS,
-                data,
-                INDEX_JS
             ),
         );
         res.headers_mut()
@@ -703,34 +719,13 @@ const DATA =
         Ok(())
     }
 
-    fn auth_guard(&self, req: &Request, res: &mut Response) -> bool {
+    fn auth_reject(&self, res: &mut Response) {
-        let method = req.method();
-        let pass = {
-            match &self.args.auth {
-                None => true,
-                Some((user, pass)) => match req.headers().get(AUTHORIZATION) {
-                    Some(value) => {
-                        valid_digest(value, method.as_str(), user.as_str(), pass.as_str()).is_some()
-                    }
-                    None => {
-                        self.args.no_auth_access
-                            && (method == Method::GET
-                                || method == Method::OPTIONS
-                                || method == Method::HEAD
-                                || method.as_str() == "PROPFIND")
-                    }
-                },
-            }
-        };
-        if !pass {
         let value = generate_www_auth(false);
         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());
-        }
+        *res.status_mut() = StatusCode::UNAUTHORIZED;
-        pass
     }
 
     async fn is_root_contained(&self, path: &Path) -> bool {
@@ -748,7 +743,7 @@ const DATA =
     }
 
     fn extract_path(&self, path: &str) -> Option<PathBuf> {
-        let decoded_path = percent_decode(path[1..].as_bytes()).decode_utf8().ok()?;
+        let decoded_path = decode_uri(&path[1..])?;
         let slashes_switched = if cfg!(windows) {
             decoded_path.replace('/', "\\")
         } else {
@@ -819,7 +814,8 @@ const DATA =
 
 #[derive(Debug, Serialize)]
 struct IndexData {
-    breadcrumb: String,
+    href: String,
+    uri_prefix: String,
     paths: Vec<PathItem>,
     allow_upload: bool,
     allow_delete: bool,
@@ -1018,23 +1014,26 @@ fn parse_range(headers: &HeaderMap<HeaderValue>) -> Option<RangeValue> {
     }
 }
 
-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;
+    *res.body_mut() = Body::from("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 get_file_name(path: &Path) -> BoxResult<&str> {
+    path.file_name()
+        .and_then(|v| v.to_str())
+        .ok_or_else(|| format!("Failed to get file name of `{}`", path.display()).into())
+}
+
 fn set_webdav_headers(res: &mut Response) {
     res.headers_mut().insert(
         "Allow",

src/utils.rs

@@ -0,0 +1,12 @@
+use std::borrow::Cow;
+
+pub fn encode_uri(v: &str) -> String {
+    let parts: Vec<_> = v.split('/').map(urlencoding::encode).collect();
+    parts.join("/")
+}
+
+pub fn decode_uri(v: &str) -> Option<Cow<str>> {
+    percent_encoding::percent_decode(v.as_bytes())
+        .decode_utf8()
+        .ok()
+}

tests/args.rs

@@ -1,8 +1,11 @@
 mod fixtures;
 mod utils;
 
-use fixtures::{server, Error, TestServer};
+use assert_cmd::prelude::*;
+use assert_fs::fixture::TempDir;
+use fixtures::{port, server, tmpdir, wait_for_port, Error, TestServer};
 use rstest::rstest;
+use std::process::{Command, Stdio};
 
 #[rstest]
 fn path_prefix_index(#[with(&["--path-prefix", "xyz"])] server: TestServer) -> Result<(), Error> {
@@ -28,3 +31,23 @@ fn path_prefix_propfind(
     assert!(text.contains("<D:href>/xyz/</D:href>"));
     Ok(())
 }
+
+#[rstest]
+#[case("index.html")]
+fn serve_single_file(tmpdir: TempDir, port: u16, #[case] file: &str) -> Result<(), Error> {
+    let mut child = Command::cargo_bin("dufs")?
+        .env("RUST_LOG", "false")
+        .arg(tmpdir.path().join(file))
+        .arg("-p")
+        .arg(port.to_string())
+        .stdout(Stdio::piped())
+        .spawn()?;
+
+    wait_for_port(port);
+
+    let resp = reqwest::blocking::get(format!("http://localhost:{}/index.html", port))?;
+    assert_eq!(resp.text()?, "This is index.html");
+
+    child.kill()?;
+    Ok(())
+}

tests/auth.rs

@@ -6,7 +6,7 @@ use fixtures::{server, Error, TestServer};
 use rstest::rstest;
 
 #[rstest]
-fn no_auth(#[with(&["--auth", "user:pass", "-A"])] server: TestServer) -> Result<(), Error> {
+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"));
@@ -17,7 +17,7 @@ fn no_auth(#[with(&["--auth", "user:pass", "-A"])] server: TestServer) -> Result
 }
 
 #[rstest]
-fn auth(#[with(&["--auth", "user:pass", "-A"])] server: TestServer) -> Result<(), Error> {
+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);
@@ -29,10 +29,54 @@ fn auth(#[with(&["--auth", "user:pass", "-A"])] server: TestServer) -> Result<()
 }
 
 #[rstest]
-fn auth_skip_access(
+fn auth_skip(#[with(&["--auth", "/@user:pass@*"])] server: TestServer) -> Result<(), Error> {
-    #[with(&["--auth", "user:pass", "--no-auth-access"])] server: TestServer,
-) -> Result<(), Error> {
     let resp = reqwest::blocking::get(server.url())?;
     assert_eq!(resp.status(), 200);
     Ok(())
 }
+
+#[rstest]
+fn auth_readonly(
+    #[with(&["--auth", "/@user:pass@user2:pass2", "-A"])] server: TestServer,
+) -> Result<(), Error> {
+    let url = format!("{}index.html", server.url());
+    let resp = fetch!(b"GET", &url).send()?;
+    assert_eq!(resp.status(), 401);
+    let resp = fetch!(b"GET", &url).send_with_digest_auth("user2", "pass2")?;
+    assert_eq!(resp.status(), 200);
+    let url = format!("{}file1", server.url());
+    let resp = fetch!(b"PUT", &url)
+        .body(b"abc".to_vec())
+        .send_with_digest_auth("user2", "pass2")?;
+    assert_eq!(resp.status(), 401);
+    Ok(())
+}
+
+#[rstest]
+fn auth_nest(
+    #[with(&["--auth", "/@user:pass@user2:pass2", "--auth", "/dira@user3:pass3", "-A"])]
+    server: TestServer,
+) -> Result<(), Error> {
+    let url = format!("{}dira/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("user3", "pass3")?;
+    assert_eq!(resp.status(), 201);
+    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_nest_share(
+    #[with(&["--auth", "/@user:pass@*", "--auth", "/dira@user3:pass3", "-A"])] server: TestServer,
+) -> Result<(), Error> {
+    let url = format!("{}index.html", server.url());
+    let resp = fetch!(b"GET", &url).send()?;
+    assert_eq!(resp.status(), 200);
+    Ok(())
+}

tests/bind.rs

@@ -1,6 +1,6 @@
 mod fixtures;
 
-use fixtures::{port, server, tmpdir, Error, TestServer};
+use fixtures::{port, server, tmpdir, wait_for_port, Error, TestServer};
 
 use assert_cmd::prelude::*;
 use assert_fs::fixture::TempDir;
@@ -12,7 +12,7 @@ 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")?
+    Command::cargo_bin("dufs")?
         .env("RUST_LOG", "false")
         .arg(tmpdir.path())
         .arg("-p")
@@ -50,7 +50,7 @@ fn bind_ipv4_ipv6(
 #[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")?
+    let mut child = Command::cargo_bin("dufs")?
         .env("RUST_LOG", "false")
         .arg(tmpdir.path())
         .arg("-p")
@@ -59,6 +59,8 @@ fn validate_printed_urls(tmpdir: TempDir, port: u16, #[case] args: &[&str]) -> R
         .stdout(Stdio::piped())
         .spawn()?;
 
+    wait_for_port(port);
+
     // WARN assumes urls list is terminated by an empty line
     let url_lines = BufReader::new(child.stdout.take().unwrap())
         .lines()

tests/cors.rs

@@ -5,7 +5,7 @@ use fixtures::{server, Error, TestServer};
 use rstest::rstest;
 
 #[rstest]
-fn cors(#[with(&["--cors"])] server: TestServer) -> Result<(), Error> {
+fn cors(#[with(&["--enable-cors"])] server: TestServer) -> Result<(), Error> {
     let resp = reqwest::blocking::get(server.url())?;
 
     assert_eq!(
@@ -21,7 +21,7 @@ fn cors(#[with(&["--cors"])] server: TestServer) -> Result<(), Error> {
 }
 
 #[rstest]
-fn cors_options(#[with(&["--cors"])] server: TestServer) -> Result<(), Error> {
+fn cors_options(#[with(&["--enable-cors"])] server: TestServer) -> Result<(), Error> {
     let resp = fetch!(b"OPTIONS", server.url()).send()?;
 
     assert_eq!(

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 duf as a server; Start with a temporary directory, a free port and some
+/// Run dufs 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)]
@@ -90,7 +94,7 @@ where
 {
     let port = port();
     let tmpdir = tmpdir();
-    let child = Command::cargo_bin("duf")
+    let child = Command::cargo_bin("dufs")
         .expect("Couldn't find test binary")
         .env("RUST_LOG", "false")
         .arg(tmpdir.path())
@@ -118,7 +122,7 @@ where
 {
     let port = port();
     let tmpdir = tmpdir();
-    let child = Command::cargo_bin("duf")
+    let child = Command::cargo_bin("dufs")
         .expect("Couldn't find test binary")
         .env("RUST_LOG", "false")
         .arg(tmpdir.path())
@@ -138,7 +142,7 @@ where
 }
 
 /// Wait a max of 1s for the port to become available.
-fn wait_for_port(port: u16) {
+pub fn wait_for_port(port: u16) {
     let start_wait = Instant::now();
 
     while !port_check::is_port_reachable(format!("localhost:{}", port)) {

tests/http.rs

@@ -105,6 +105,7 @@ fn head_file(server: TestServer) -> Result<(), Error> {
     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("content-disposition"));
     assert!(resp.headers().contains_key("etag"));
     assert!(resp.headers().contains_key("last-modified"));
     assert!(resp.headers().contains_key("content-length"));

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> {
+fn render_index2(#[with(&["--render-index"])] server: TestServer) -> Result<(), Error> {
-    let resp = reqwest::blocking::get(format!("{}/{}", server.url(), DIR_NO_INDEX))?;
+    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> {
+fn render_spa2(#[with(&["--render-spa"])] server: TestServer) -> Result<(), Error> {
-    let resp = reqwest::blocking::get(format!("{}/{}", server.url(), DIR_NO_INDEX))?;
+    let resp = reqwest::blocking::get(format!("{}{}", server.url(), DIR_NO_FOUND))?;
     let text = resp.text()?;
     assert_eq!(text, "This is index.html");
     Ok(())

tests/tls.rs

@@ -29,7 +29,7 @@ fn tls_works(#[case] server: TestServer) -> Result<(), Error> {
 /// Wrong path for cert throws error.
 #[rstest]
 fn wrong_path_cert() -> Result<(), Error> {
-    Command::cargo_bin("duf")?
+    Command::cargo_bin("dufs")?
         .args(&["--tls-cert", "wrong", "--tls-key", "tests/data/key.pem"])
         .assert()
         .failure()
@@ -41,7 +41,7 @@ fn wrong_path_cert() -> Result<(), Error> {
 /// Wrong paths for key throws errors.
 #[rstest]
 fn wrong_path_key() -> Result<(), Error> {
-    Command::cargo_bin("duf")?
+    Command::cargo_bin("dufs")?
         .args(&["--tls-cert", "tests/data/cert.pem", "--tls-key", "wrong"])
         .assert()
         .failure()