chore(release): version 0.32.0 (#183)

close #157 #158

.github/workflows/release.yaml

@@ -7,7 +7,9 @@ on:
 
 jobs:
   release:
-    name: Publish to Github Relases
+    name: Publish to Github Releases
+    permissions:
+      contents: write
     outputs:
       rc: ${{ steps.check-tag.outputs.rc }}
 

CHANGELOG.md

@@ -2,7 +2,38 @@
 
 All notable changes to this project will be documented in this file.
 
-## [0.30.0] - 2022-09-05
+## [0.32.0] - 2023-02-22
+
+### Bug Fixes
+
+- Set the STOPSIGNAL to SIGINT for Dockerfile
+- Remove Method::Options auth check ([#168](https://github.com/sigoden/dufs/issues/168))
+- Clear search input also clear query ([#178](https://github.com/sigoden/dufs/issues/178))
+
+### Features
+
+- [**breaking**] Add option --allow-archive ([#152](https://github.com/sigoden/dufs/issues/152))
+- Use env var for args ([#170](https://github.com/sigoden/dufs/issues/170))
+- Hiding only directories instead of files ([#175](https://github.com/sigoden/dufs/issues/175))
+- API to search and list directories ([#177](https://github.com/sigoden/dufs/issues/177))
+- Support edit files ([#179](https://github.com/sigoden/dufs/issues/179))
+- Support new file ([#180](https://github.com/sigoden/dufs/issues/180))
+- Ui improves the login experience ([#182](https://github.com/sigoden/dufs/issues/182))
+
+## [0.31.0] - 2022-11-11
+
+### Bug Fixes
+
+- Auth not works with --path-prefix ([#138](https://github.com/sigoden/dufs/issues/138))
+- Don't search on empty query string ([#140](https://github.com/sigoden/dufs/issues/140))
+- Status code for MKCOL on existing resource ([#142](https://github.com/sigoden/dufs/issues/142))
+- Panic on PROPFIND // ([#144](https://github.com/sigoden/dufs/issues/144))
+
+### Features
+
+- Support unix sockets ([#145](https://github.com/sigoden/dufs/issues/145))
+
+## [0.30.0] - 2022-09-09
 
 ### Bug Fixes
 
@@ -27,7 +58,7 @@ All notable changes to this project will be documented in this file.
 
 ### Bug Fixes
 
-- File path contains special charactors ([#114](https://github.com/sigoden/dufs/issues/114))
+- File path contains special characters ([#114](https://github.com/sigoden/dufs/issues/114))
 
 ### Features
 
@@ -65,7 +96,7 @@ All notable changes to this project will be documented in this file.
 
 ### Bug Fixes
 
-- Unexpect stack overflow when searching a lot ([#87](https://github.com/sigoden/dufs/issues/87))
+- Unexpected stack overflow when searching a lot ([#87](https://github.com/sigoden/dufs/issues/87))
 
 ### Features
 
@@ -158,7 +189,7 @@ All notable changes to this project will be documented in this file.
 
 ### Refactor
 
-- Trival changes ([#41](https://github.com/sigoden/dufs/issues/41))
+- Trivial changes ([#41](https://github.com/sigoden/dufs/issues/41))
 
 ## [0.16.0] - 2022-06-12
 

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "dufs"
-version = "0.30.0"
+version = "0.32.0"
 edition = "2021"
 authors = ["sigoden <sigoden@gmail.com>"]
 description = "Dufs is a distinctive utility file server"
@@ -11,8 +11,8 @@ categories = ["command-line-utilities", "web-programming::http-server"]
 keywords = ["static", "file", "server", "webdav", "cli"]
 
 [dependencies]
-clap = { version = "3", default-features = false, features = ["std", "wrap_help"] }
+clap = { version = "4", features = ["wrap_help", "env"] }
-clap_complete = "3"
+clap_complete = "4"
 chrono = "0.4"
 tokio = { version = "1", features = ["rt-multi-thread", "macros", "fs", "io-util", "signal"]}
 tokio-util = { version = "0.7",  features = ["io-util"] }
@@ -21,11 +21,11 @@ percent-encoding = "2.1"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 futures = "0.3"
-base64 = "0.13"
+base64 = "0.21"
-async_zip = { version = "0.0.8", default-features = false, features = ["deflate"] }
+async_zip = { version = "0.0.12", default-features = false, features = ["deflate"] }
 headers = "0.3"
 mime_guess = "2.0"
-if-addrs = "0.7"
+if-addrs = "0.8"
 rustls = { version = "0.20", default-features = false, features = ["tls12"], optional = true }
 rustls-pemfile = { version = "1", optional = true }
 tokio-rustls = { version = "0.23", optional = true }
@@ -40,6 +40,8 @@ async-stream = "0.3"
 walkdir = "2.3"
 form_urlencoded = "1.0"
 alphanumeric-sort = "1.4"
+content_inspector = "0.2"
+anyhow = "1.0"
 
 [features]
 default = ["tls"]
@@ -50,7 +52,7 @@ assert_cmd = "2"
 reqwest = { version = "0.11", features = ["blocking", "multipart", "rustls-tls"], default-features = false }
 assert_fs = "1"
 port_check = "0.1"
-rstest = "0.15"
+rstest = "0.16"
 regex = "1"
 url = "2"
 diqwest = { version = "1", features = ["blocking"] }

Dockerfile

@@ -15,4 +15,5 @@ RUN if [ "$TARGETPLATFORM" = "linux/amd64" ]; then \
 
 FROM scratch
 COPY --from=builder /bin/dufs /bin/dufs
+STOPSIGNAL SIGINT
 ENTRYPOINT ["/bin/dufs"]

README.md

@@ -5,14 +5,14 @@
 
 Dufs is a distinctive utility file server that supports static serving, uploading, searching, accessing control, webdav...
 
-![demo](https://user-images.githubusercontent.com/4012553/189362357-b2f7aa6b-9df0-4438-a57c-c8f92850fc4f.png)
+![demo](https://user-images.githubusercontent.com/4012553/220513063-ff0f186b-ac54-4682-9af4-47a9781dee0d.png)
 
 ## Features
 
 - Serve static files
 - Download folder as zip file
 - Upload files and folders (Drag & Drop)
-- Search files
+- Create/Edit/Search files
 - Partial responses (Parallel/Resume download)
 - Path level access control
 - Support https
@@ -33,6 +33,12 @@ cargo install dufs
 docker run -v `pwd`:/data -p 5000:5000 --rm -it sigoden/dufs /data -A
 ```
 
+### With [Homebrew](https://brew.sh)
+
+```
+brew install dufs
+```
+
 ### Binaries on macOS, Linux, Windows
 
 Download from [Github Releases](https://github.com/sigoden/dufs/releases), unzip and add dufs to your $PATH.
@@ -42,46 +48,46 @@ Download from [Github Releases](https://github.com/sigoden/dufs/releases), unzip
 ```
 Dufs is a distinctive utility file server - https://github.com/sigoden/dufs
 
-USAGE:
+Usage: dufs [OPTIONS] [root]
-    dufs [OPTIONS] [--] [root]
 
-ARGS:
+Arguments:
-    <root>    Specific path to serve [default: .]
+  [root]  Specific path to serve [default: .]
 
-OPTIONS:
+Options:
-    -b, --bind <addr>...         Specify bind address
+  -b, --bind <addrs>         Specify bind address or unix socket
-    -p, --port <port>            Specify port to listen on [default: 5000]
+  -p, --port <port>          Specify port to listen on [default: 5000]
-        --path-prefix <path>     Specify a path prefix
+      --path-prefix <path>   Specify a path prefix
-        --hidden <value>         Hide paths from directory listings, separated by `,`
+      --hidden <value>       Hide paths from directory listings, separated by `,`
-    -a, --auth <rule>...         Add auth for path
+  -a, --auth <rules>         Add auth for path
-        --auth-method <value>    Select auth method [default: digest] [possible values: basic, digest]
+      --auth-method <value>  Select auth method [default: digest] [possible values: basic, digest]
-    -A, --allow-all              Allow all operations
+  -A, --allow-all            Allow all operations
-        --allow-upload           Allow upload files/folders
+      --allow-upload         Allow upload files/folders
-        --allow-delete           Allow delete files/folders
+      --allow-delete         Allow delete files/folders
-        --allow-search           Allow search files/folders
+      --allow-search         Allow search files/folders
-        --allow-symlink          Allow symlink to files/folders outside root directory
+      --allow-symlink        Allow symlink to files/folders outside root directory
-        --enable-cors            Enable CORS, sets `Access-Control-Allow-Origin: *`
+      --allow-archive        Allow zip archive generation
-        --render-index           Serve index.html when requesting a directory, returns 404 if not found index.html
+      --enable-cors          Enable CORS, sets `Access-Control-Allow-Origin: *`
-        --render-try-index       Serve index.html when requesting a directory, returns directory listing if not found index.html
+      --render-index         Serve index.html when requesting a directory, returns 404 if not found index.html
-        --render-spa             Serve SPA(Single Page Application)
+      --render-try-index     Serve index.html when requesting a directory, returns directory listing if not found index.html
-        --assets <path>          Use custom assets to override builtin assets
+      --render-spa           Serve SPA(Single Page Application)
-        --tls-cert <path>        Path to an SSL/TLS certificate to serve with HTTPS
+      --assets <path>        Use custom assets to override builtin assets
-        --tls-key <path>         Path to the SSL/TLS certificate's private key
+      --tls-cert <path>      Path to an SSL/TLS certificate to serve with HTTPS
-        --log-format <format>    Customize http log format
+      --tls-key <path>       Path to the SSL/TLS certificate's private key
-        --completions <shell>    Print shell completion script for <shell> [possible values: bash, elvish, fish, powershell, zsh]
+      --log-format <format>  Customize http log format
-    -h, --help                   Print help information
+      --completions <shell>  Print shell completion script for <shell> [possible values: bash, elvish, fish, powershell, zsh]
-    -V, --version                Print version information
+  -h, --help                 Print help information
+  -V, --version              Print version information
 ```
 
 ## Examples
 
-Serve current working directory
+Serve current working directory in readonly mode
 
 ```
 dufs
 ```
 
-Allow all operations like upload/delete/search...
+Allow all operations like upload/delete/search/create/edit...
 
 ```
 dufs -A
@@ -123,10 +129,15 @@ Require username/password
 dufs -a /@admin:123
 ```
 
-Listen on a specific port
+Listen on specific host:ip 
 
 ```
-dufs -p 80
+dufs -b 127.0.0.1 -p 80
+```
+
+Listen on unix socket
+```
+dufs -b /tmp/dufs.socket
 ```
 
 Use https
@@ -160,6 +171,33 @@ Delete a file/folder
 curl -X DELETE http://127.0.0.1:5000/path-to-file-or-folder
 ```
 
+Create a directory
+
+```
+curl -X MKCOL https://127.0.0.1:5000/path-to-folder
+```
+
+Move the file/folder to the new path
+
+```
+curl -X MOVE https://127.0.0.1:5000/path -H "Destination: https://127.0.0.1:5000/new-path"
+```
+
+List/search directory contents
+
+```
+curl http://127.0.0.1:5000?simple                 # output names only, just like `ls -1`
+curl http://127.0.0.1:5000?json                   # output paths in json format
+curl http://127.0.0.1:5000?q=Dockerfile&simple    # search for files, just like `find -name Dockerfile`
+```
+
+With authorization
+
+```
+curl --user user:pass --digest http://192.168.8.10:5000/file  # digest auth
+curl --user user:pass http://192.168.8.10:5000/file           # basic auth
+```
+
 <details>
 <summary><h2>Advanced topics</h2></summary>
 
@@ -263,6 +301,12 @@ dufs --log-format '$remote_addr $remote_user "$request" $status' -a /@admin:admi
 2022-08-06T07:04:37+08:00 INFO - 127.0.0.1 admin "GET /" 200
 ```
 
+## Environment variables
+
+All options can be set using environment variables prefixed with `DUFS_`.
+
+`dufs --port 8080 --allow-all`  is equal to `DUFS_PORT=8080 DUFS_ALLOW_ALL=true dufs`.
+
 ### Customize UI
 
 Dufs allows users to customize the UI with your own assets.

assets/index.css

@@ -1,5 +1,5 @@
 html {
-  font-family: -apple-system,BlinkMacSystemFont,Roboto,Helvetica,Arial,sans-serif;
+  font-family: -apple-system, BlinkMacSystemFont, Roboto, Helvetica, Arial, sans-serif;
   line-height: 1.5;
   color: #24292e;
 }
@@ -7,6 +7,7 @@ html {
 body {
   /* prevent premature breadcrumb wrapping on mobile */
   min-width: 500px;
+  margin: 0;
 }
 
 .hidden {
@@ -17,7 +18,10 @@ body {
   display: flex;
   flex-wrap: wrap;
   align-items: center;
-  padding: 1em 1em 0;
+  padding: 0.6em 1em;
+  position: fixed;
+  width: 100%;
+  background-color: white;
 }
 
 .breadcrumb {
@@ -25,28 +29,28 @@ body {
   padding-right: 0.6em;
 }
 
-.breadcrumb > a {
+.breadcrumb>a {
   color: #0366d6;
   text-decoration: none;
 }
 
-.breadcrumb > a:hover {
+.breadcrumb>a:hover {
   text-decoration: underline;
 }
 
 /* final breadcrumb */
-.breadcrumb > b {
+.breadcrumb>b {
   color: #24292e;
 }
 
-.breadcrumb > .separator {
+.breadcrumb>.separator {
   color: #586069;
   padding: 0 0.25em;
 }
 
 .breadcrumb svg {
   height: 100%;
-  fill: rgba(3,47,98,0.5);
+  fill: rgba(3, 47, 98, 0.5);
 }
 
 .toolbox {
@@ -54,7 +58,8 @@ body {
   margin-right: 10px;
 }
 
-.toolbox > div {
+.toolbox>a,
+.toolbox>div {
   /* vertically align with breadcrumb text */
   height: 1.1rem;
 }
@@ -87,7 +92,6 @@ body {
   font-size: 16px;
   line-height: 16px;
   padding: 1px;
-  font-family: helvetica neue,luxi sans,Tahoma,hiragino sans gb,STHeiti,sans-serif;
   background-color: transparent;
   border: none;
   outline: none;
@@ -105,11 +109,10 @@ body {
 }
 
 .main {
-  padding: 0 1em;
+  padding: 3.3em 1em 0;
 }
 
 .empty-folder {
-  padding-top: 1rem;
   font-style: italic;
 }
 
@@ -136,7 +139,7 @@ body {
   text-decoration: none;
 }
 
-.paths-table thead a > span {
+.paths-table thead a>span {
   padding-left: 2px;
 }
 
@@ -163,7 +166,7 @@ body {
 
 .path svg {
   height: 16px;
-  fill: rgba(3,47,98,0.5);
+  fill: rgba(3, 47, 98, 0.5);
   padding-right: 0.5em;
   vertical-align: text-top;
 }
@@ -189,6 +192,7 @@ body {
 
 .action-btn {
   padding-right: 0.3em;
+  cursor: pointer;
 }
 
 .uploaders-table {
@@ -199,6 +203,27 @@ body {
   padding-right: 1em;
 }
 
+.editor {
+  width: 100%;
+  height: calc(100vh - 5rem);
+  border: 1px solid #ced4da;
+  outline: none;
+}
+
+.toolbox2 {
+  margin-left: auto;
+  margin-right: 2em;
+}
+
+.save-btn {
+  cursor: pointer;
+  user-select: none;
+}
+
+.not-editable {
+  font-style: italic;
+}
+
 @media (min-width: 768px) {
   .path a {
     min-width: 400px;
@@ -228,6 +253,10 @@ body {
     fill: #fff;
   }
 
+  .head {
+    background-color: #111;
+  }
+
   .searchbar {
     background-color: #111;
     border-color: #fff6;
@@ -244,4 +273,9 @@ body {
   .paths-table tbody tr:hover {
     background-color: #1a1a1a;
   }
-} 
+
+  .editor {
+    background: black;
+    color: white;
+  }
+}

assets/index.html

@@ -7,59 +7,126 @@
   <link rel="icon" type="image/x-icon" href="__ASSERTS_PREFIX__favicon.ico">
   <link rel="stylesheet" href="__ASSERTS_PREFIX__index.css">
   <script>
-  DATA = __INDEX_DATA__
+    DATA = __INDEX_DATA__
   </script>
   <script src="__ASSERTS_PREFIX__index.js"></script>
 </head>
+
 <body>
   <div class="head">
     <div class="breadcrumb"></div>
     <div class="toolbox">
-      <div>
+      <a href="" class="control download hidden" title="Download file" download="">
-        <a href="?zip" title="Download folder as a .zip file">
+        <svg width="16" height="16" viewBox="0 0 16 16">
-          <svg width="16" height="16" viewBox="0 0 16 16"><path d="M.5 9.9a.5.5 0 0 1 .5.5v2.5a1 1 0 0 0 1 1h12a1 1 0 0 0 1-1v-2.5a.5.5 0 0 1 1 0v2.5a2 2 0 0 1-2 2H2a2 2 0 0 1-2-2v-2.5a.5.5 0 0 1 .5-.5z"/><path d="M7.646 11.854a.5.5 0 0 0 .708 0l3-3a.5.5 0 0 0-.708-.708L8.5 10.293V1.5a.5.5 0 0 0-1 0v8.793L5.354 8.146a.5.5 0 1 0-.708.708l3 3z"/></svg>
+          <path
-        </a>
+            d="M.5 9.9a.5.5 0 0 1 .5.5v2.5a1 1 0 0 0 1 1h12a1 1 0 0 0 1-1v-2.5a.5.5 0 0 1 1 0v2.5a2 2 0 0 1-2 2H2a2 2 0 0 1-2-2v-2.5a.5.5 0 0 1 .5-.5z" />
+          <path
+            d="M7.646 11.854a.5.5 0 0 0 .708 0l3-3a.5.5 0 0 0-.708-.708L8.5 10.293V1.5a.5.5 0 0 0-1 0v8.793L5.354 8.146a.5.5 0 1 0-.708.708l3 3z" />
+        </svg>
+      </a>
+      <div class="control move-file hidden" title="Move to new path">
+        <svg class="icon-move" width="16" height="16" viewBox="0 0 16 16">
+          <path fill-rule="evenodd"
+            d="M1.5 1.5A.5.5 0 0 0 1 2v4.8a2.5 2.5 0 0 0 2.5 2.5h9.793l-3.347 3.346a.5.5 0 0 0 .708.708l4.2-4.2a.5.5 0 0 0 0-.708l-4-4a.5.5 0 0 0-.708.708L13.293 8.3H3.5A1.5 1.5 0 0 1 2 6.8V2a.5.5 0 0 0-.5-.5z">
+          </path>
+        </svg>
+      </div>
+      <div class="control delete-file hidden" title="Delete">
+        <svg class="icon-delete" width="16" height="16" fill="currentColor" viewBox="0 0 16 16">
+          <path
+            d="M6.854 7.146a.5.5 0 1 0-.708.708L7.293 9l-1.147 1.146a.5.5 0 0 0 .708.708L8 9.707l1.146 1.147a.5.5 0 0 0 .708-.708L8.707 9l1.147-1.146a.5.5 0 0 0-.708-.708L8 8.293 6.854 7.146z" />
+          <path
+            d="M14 14V4.5L9.5 0H4a2 2 0 0 0-2 2v12a2 2 0 0 0 2 2h8a2 2 0 0 0 2-2zM9.5 3A1.5 1.5 0 0 0 11 4.5h2V14a1 1 0 0 1-1 1H4a1 1 0 0 1-1-1V2a1 1 0 0 1 1-1h5.5v2z" />
+        </svg>
       </div>
       <div class="control upload-file hidden" title="Upload files">
         <label for="file">
-          <svg width="16" height="16" viewBox="0 0 16 16"><path d="M.5 9.9a.5.5 0 0 1 .5.5v2.5a1 1 0 0 0 1 1h12a1 1 0 0 0 1-1v-2.5a.5.5 0 0 1 1 0v2.5a2 2 0 0 1-2 2H2a2 2 0 0 1-2-2v-2.5a.5.5 0 0 1 .5-.5z"/><path d="M7.646 1.146a.5.5 0 0 1 .708 0l3 3a.5.5 0 0 1-.708.708L8.5 2.707V11.5a.5.5 0 0 1-1 0V2.707L5.354 4.854a.5.5 0 1 1-.708-.708l3-3z"/></svg>
+          <svg width="16" height="16" viewBox="0 0 16 16">
+            <path
+              d="M.5 9.9a.5.5 0 0 1 .5.5v2.5a1 1 0 0 0 1 1h12a1 1 0 0 0 1-1v-2.5a.5.5 0 0 1 1 0v2.5a2 2 0 0 1-2 2H2a2 2 0 0 1-2-2v-2.5a.5.5 0 0 1 .5-.5z" />
+            <path
+              d="M7.646 1.146a.5.5 0 0 1 .708 0l3 3a.5.5 0 0 1-.708.708L8.5 2.707V11.5a.5.5 0 0 1-1 0V2.707L5.354 4.854a.5.5 0 1 1-.708-.708l3-3z" />
+          </svg>
         </label>
         <input type="file" id="file" name="file" multiple>
       </div>
       <div class="control new-folder hidden" title="New folder">
         <svg width="16" height="16" viewBox="0 0 16 16">
-          <path d="m.5 3 .04.87a1.99 1.99 0 0 0-.342 1.311l.637 7A2 2 0 0 0 2.826 14H9v-1H2.826a1 1 0 0 1-.995-.91l-.637-7A1 1 0 0 1 2.19 4h11.62a1 1 0 0 1 .996 1.09L14.54 8h1.005l.256-2.819A2 2 0 0 0 13.81 3H9.828a2 2 0 0 1-1.414-.586l-.828-.828A2 2 0 0 0 6.172 1H2.5a2 2 0 0 0-2 2zm5.672-1a1 1 0 0 1 .707.293L7.586 3H2.19c-.24 0-.47.042-.683.12L1.5 2.98a1 1 0 0 1 1-.98h3.672z"/>
+          <path
-          <path d="M13.5 10a.5.5 0 0 1 .5.5V12h1.5a.5.5 0 1 1 0 1H14v1.5a.5.5 0 1 1-1 0V13h-1.5a.5.5 0 0 1 0-1H13v-1.5a.5.5 0 0 1 .5-.5z"/>
+            d="m.5 3 .04.87a1.99 1.99 0 0 0-.342 1.311l.637 7A2 2 0 0 0 2.826 14H9v-1H2.826a1 1 0 0 1-.995-.91l-.637-7A1 1 0 0 1 2.19 4h11.62a1 1 0 0 1 .996 1.09L14.54 8h1.005l.256-2.819A2 2 0 0 0 13.81 3H9.828a2 2 0 0 1-1.414-.586l-.828-.828A2 2 0 0 0 6.172 1H2.5a2 2 0 0 0-2 2zm5.672-1a1 1 0 0 1 .707.293L7.586 3H2.19c-.24 0-.47.042-.683.12L1.5 2.98a1 1 0 0 1 1-.98h3.672z" />
+          <path
+            d="M13.5 10a.5.5 0 0 1 .5.5V12h1.5a.5.5 0 1 1 0 1H14v1.5a.5.5 0 1 1-1 0V13h-1.5a.5.5 0 0 1 0-1H13v-1.5a.5.5 0 0 1 .5-.5z" />
+        </svg>
+      </div>
+      <div class="control new-file hidden" title="New File">
+        <svg width="16" height="16" viewBox="0 0 16 16">
+          <path
+            d="M8 6.5a.5.5 0 0 1 .5.5v1.5H10a.5.5 0 0 1 0 1H8.5V11a.5.5 0 0 1-1 0V9.5H6a.5.5 0 0 1 0-1h1.5V7a.5.5 0 0 1 .5-.5z" />
+          <path
+            d="M14 4.5V14a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V2a2 2 0 0 1 2-2h5.5L14 4.5zm-3 0A1.5 1.5 0 0 1 9.5 3V1H4a1 1 0 0 0-1 1v12a1 1 0 0 0 1 1h8a1 1 0 0 0 1-1V4.5h-2z" />
         </svg>
       </div>
     </div>
     <form class="searchbar hidden">
       <div class="icon">
-        <svg width="16" height="16" fill="currentColor" viewBox="0 0 16 16"><path d="M11.742 10.344a6.5 6.5 0 1 0-1.397 1.398h-.001c.03.04.062.078.098.115l3.85 3.85a1 1 0 0 0 1.415-1.414l-3.85-3.85a1.007 1.007 0 0 0-.115-.1zM12 6.5a5.5 5.5 0 1 1-11 0 5.5 5.5 0 0 1 11 0z"/></svg>
+        <svg width="16" height="16" viewBox="0 0 16 16">
+          <path
+            d="M11.742 10.344a6.5 6.5 0 1 0-1.397 1.398h-.001c.03.04.062.078.098.115l3.85 3.85a1 1 0 0 0 1.415-1.414l-3.85-3.85a1.007 1.007 0 0 0-.115-.1zM12 6.5a5.5 5.5 0 1 1-11 0 5.5 5.5 0 0 1 11 0z" />
+        </svg>
       </div>
       <input id="search" name="q" type="text" maxlength="128" autocomplete="off" tabindex="1">
       <input type="submit" hidden />
     </form>
+    <div class="toolbox2">
+      <div class="login-btn hidden" title="Login for upload/move/delete/edit permissions">
+        <svg width="16" height="16" viewBox="0 0 16 16">
+          <path fill-rule="evenodd"
+            d="M6 3.5a.5.5 0 0 1 .5-.5h8a.5.5 0 0 1 .5.5v9a.5.5 0 0 1-.5.5h-8a.5.5 0 0 1-.5-.5v-2a.5.5 0 0 0-1 0v2A1.5 1.5 0 0 0 6.5 14h8a1.5 1.5 0 0 0 1.5-1.5v-9A1.5 1.5 0 0 0 14.5 2h-8A1.5 1.5 0 0 0 5 3.5v2a.5.5 0 0 0 1 0v-2z" />
+          <path fill-rule="evenodd"
+            d="M11.854 8.354a.5.5 0 0 0 0-.708l-3-3a.5.5 0 1 0-.708.708L10.293 7.5H1.5a.5.5 0 0 0 0 1h8.793l-2.147 2.146a.5.5 0 0 0 .708.708l3-3z" />
+        </svg>
+      </div>
+      <div class="user-btn hidden">
+        <svg width="16" height="16" viewBox="0 0 16 16">
+          <path
+            d="M8 8a3 3 0 1 0 0-6 3 3 0 0 0 0 6Zm2-3a2 2 0 1 1-4 0 2 2 0 0 1 4 0Zm4 8c0 1-1 1-1 1H3s-1 0-1-1 1-4 6-4 6 3 6 4Zm-1-.004c-.001-.246-.154-.986-.832-1.664C11.516 10.68 10.289 10 8 10c-2.29 0-3.516.68-4.168 1.332-.678.678-.83 1.418-.832 1.664h10Z" />
+        </svg>
+      </div>
+      <div class="save-btn hidden" title="Save file">
+        <svg viewBox="0 0 1024 1024" width="24" height="24">
+          <path
+            d="M426.666667 682.666667v42.666666h170.666666v-42.666666h-170.666666z m-42.666667-85.333334h298.666667v128h42.666666V418.133333L605.866667 298.666667H298.666667v426.666666h42.666666v-128h42.666667z m260.266667-384L810.666667 379.733333V810.666667H213.333333V213.333333h430.933334zM341.333333 341.333333h85.333334v170.666667H341.333333V341.333333z"
+            fill="#444444" p-id="8311"></path>
+        </svg>
+      </div>
+    </div>
   </div>
   <div class="main">
-    <div class="empty-folder hidden"></div>
+    <div class="index-page hidden">
-    <table class="uploaders-table hidden">
+      <div class="empty-folder hidden"></div>
-      <thead>
+      <table class="uploaders-table hidden">
-        <tr>
+        <thead>
-          <th class="cell-name" colspan="2">Name</th>
+          <tr>
-          <th class="cell-status">Progress</th>
+            <th class="cell-name" colspan="2">Name</th>
-        </tr>
+            <th class="cell-status">Progress</th>
-      </thead>
+          </tr>
-    </table>
+        </thead>
-    <table class="paths-table hidden">
+      </table>
-      <thead>
+      <table class="paths-table hidden">
-      </thead>
+        <thead>
-      <tbody>
+        </thead>
-      </tbody>
+        <tbody>
-    </table>
+        </tbody>
+      </table>
+    </div>
+    <div class="editor-page hidden">
+      <div class="not-editable hidden"></div>
+      <textarea class="editor hidden" cols="10"></textarea>
+    </div>
   </div>
   <script>
     window.addEventListener("DOMContentLoaded", ready);
   </script>
 </body>
+
 </html>

assets/index.js

@@ -10,11 +10,16 @@
  * @typedef {object} DATA
  * @property {string} href
  * @property {string} uri_prefix
+ * @property {"Index" | "Edit"} kind
  * @property {PathItem[]} paths
  * @property {boolean} allow_upload
  * @property {boolean} allow_delete
  * @property {boolean} allow_search
+ * @property {boolean} allow_archive
+ * @property {boolean} auth
+ * @property {string} user
  * @property {boolean} dir_exists
+ * @property {string} editable
  */
 
 /**
@@ -31,8 +36,26 @@ var DATA;
  */
 const PARAMS = Object.fromEntries(new URLSearchParams(window.location.search).entries());
 
+const IFRAME_FORMATS = [
+  ".pdf",
+  ".jpg", ".jpeg", ".png", ".gif", ".bmp", ".svg",
+  ".mp4", ".mov", ".avi", ".wmv", ".flv", ".webm",
+  ".mp3", ".ogg", ".wav", ".m4a",
+];
+
 const dirEmptyNote = PARAMS.q ? 'No results' : DATA.dir_exists ? 'Empty folder' : 'Folder will be created when a file is uploaded';
 
+const ICONS = {
+  dir: `<svg height="16" viewBox="0 0 14 16" width="14"><path fill-rule="evenodd" d="M13 4H7V3c0-.66-.31-1-1-1H1c-.55 0-1 .45-1 1v10c0 .55.45 1 1 1h12c.55 0 1-.45 1-1V5c0-.55-.45-1-1-1zM6 4H1V3h5v1z"></path></svg>`,
+  symlinkFile: `<svg height="16" viewBox="0 0 12 16" width="12"><path fill-rule="evenodd" d="M8.5 1H1c-.55 0-1 .45-1 1v12c0 .55.45 1 1 1h10c.55 0 1-.45 1-1V4.5L8.5 1zM11 14H1V2h7l3 3v9zM6 4.5l4 3-4 3v-2c-.98-.02-1.84.22-2.55.7-.71.48-1.19 1.25-1.45 2.3.02-1.64.39-2.88 1.13-3.73.73-.84 1.69-1.27 2.88-1.27v-2H6z"></path></svg>`,
+  symlinkDir: `<svg height="16" viewBox="0 0 14 16" width="14"><path fill-rule="evenodd" d="M13 4H7V3c0-.66-.31-1-1-1H1c-.55 0-1 .45-1 1v10c0 .55.45 1 1 1h12c.55 0 1-.45 1-1V5c0-.55-.45-1-1-1zM1 3h5v1H1V3zm6 9v-2c-.98-.02-1.84.22-2.55.7-.71.48-1.19 1.25-1.45 2.3.02-1.64.39-2.88 1.13-3.73C4.86 8.43 5.82 8 7.01 8V6l4 3-4 3H7z"></path></svg>`,
+  file: `<svg height="16" viewBox="0 0 12 16" width="12"><path fill-rule="evenodd" d="M6 5H2V4h4v1zM2 8h7V7H2v1zm0 2h7V9H2v1zm0 2h7v-1H2v1zm10-7.5V14c0 .55-.45 1-1 1H1c-.55 0-1-.45-1-1V2c0-.55.45-1 1-1h7.5L12 4.5zM11 5L8 2H1v12h10V5z"></path></svg>`,
+  download: `<svg width="16" height="16" viewBox="0 0 16 16"><path d="M.5 9.9a.5.5 0 0 1 .5.5v2.5a1 1 0 0 0 1 1h12a1 1 0 0 0 1-1v-2.5a.5.5 0 0 1 1 0v2.5a2 2 0 0 1-2 2H2a2 2 0 0 1-2-2v-2.5a.5.5 0 0 1 .5-.5z"/><path d="M7.646 11.854a.5.5 0 0 0 .708 0l3-3a.5.5 0 0 0-.708-.708L8.5 10.293V1.5a.5.5 0 0 0-1 0v8.793L5.354 8.146a.5.5 0 1 0-.708.708l3 3z"/></svg>`,
+  move: `<svg width="16" height="16" viewBox="0 0 16 16"><path fill-rule="evenodd" d="M1.5 1.5A.5.5 0 0 0 1 2v4.8a2.5 2.5 0 0 0 2.5 2.5h9.793l-3.347 3.346a.5.5 0 0 0 .708.708l4.2-4.2a.5.5 0 0 0 0-.708l-4-4a.5.5 0 0 0-.708.708L13.293 8.3H3.5A1.5 1.5 0 0 1 2 6.8V2a.5.5 0 0 0-.5-.5z"/></svg>`,
+  edit: `<svg width="16" height="16" viewBox="0 0 16 16"><path d="M12.146.146a.5.5 0 0 1 .708 0l3 3a.5.5 0 0 1 0 .708l-10 10a.5.5 0 0 1-.168.11l-5 2a.5.5 0 0 1-.65-.65l2-5a.5.5 0 0 1 .11-.168l10-10zM11.207 2.5 13.5 4.793 14.793 3.5 12.5 1.207 11.207 2.5zm1.586 3L10.5 3.207 4 9.707V10h.5a.5.5 0 0 1 .5.5v.5h.5a.5.5 0 0 1 .5.5v.5h.293l6.5-6.5zm-9.761 5.175-.106.106-1.528 3.821 3.821-1.528.106-.106A.5.5 0 0 1 5 12.5V12h-.5a.5.5 0 0 1-.5-.5V11h-.5a.5.5 0 0 1-.468-.325z"/></svg>`,
+  delete: `<svg width="16" height="16" fill="currentColor"viewBox="0 0 16 16"><path d="M6.854 7.146a.5.5 0 1 0-.708.708L7.293 9l-1.147 1.146a.5.5 0 0 0 .708.708L8 9.707l1.146 1.147a.5.5 0 0 0 .708-.708L8.707 9l1.147-1.146a.5.5 0 0 0-.708-.708L8 8.293 6.854 7.146z"/><path d="M14 14V4.5L9.5 0H4a2 2 0 0 0-2 2v12a2 2 0 0 0 2 2h8a2 2 0 0 0 2-2zM9.5 3A1.5 1.5 0 0 0 11 4.5h2V14a1 1 0 0 1-1 1H4a1 1 0 0 1-1-1V2a1 1 0 0 1 1-1h5.5v2z"/></svg>`,
+}
+
 /**
  * @type Element
  */
@@ -56,7 +79,37 @@ let $emptyFolder;
 /**
  * @type Element
  */
-let $newFolder;
+let $editor;
+/**
+ * @type Element
+ */
+let $userBtn;
+
+function ready() {
+  $pathsTable = document.querySelector(".paths-table")
+  $pathsTableHead = document.querySelector(".paths-table thead");
+  $pathsTableBody = document.querySelector(".paths-table tbody");
+  $uploadersTable = document.querySelector(".uploaders-table");
+  $emptyFolder = document.querySelector(".empty-folder");
+  $editor = document.querySelector(".editor");
+  $userBtn = document.querySelector(".user-btn");
+
+  addBreadcrumb(DATA.href, DATA.uri_prefix);
+
+  if (DATA.kind == "Index") {
+    document.title = `Index of ${DATA.href} - Dufs`;
+    document.querySelector(".index-page").classList.remove("hidden");
+
+    setupIndexPage();
+
+  } else if (DATA.kind == "Edit") {
+    document.title = `Edit of ${DATA.href} - Dufs`;
+    document.querySelector(".editor-page").classList.remove("hidden");;
+
+    setupEditPage();
+  }
+}
+
 
 class Uploader {
   /**
@@ -78,12 +131,12 @@ class Uploader {
 
   upload() {
     const { idx, name } = this;
-    const url = getUrl(name);
+    const url = newUrl(name);
     const encodedName = encodedStr(name);
     $uploadersTable.insertAdjacentHTML("beforeend", `
   <tr id="upload${idx}" class="uploader">
     <td class="path cell-icon">
-      ${getSvg()}
+      ${getPathSvg()}
     </td>
     <td class="path cell-name">
       <a href="${url}">${encodedName}</a>
@@ -100,12 +153,12 @@ class Uploader {
 
   ajax() {
     Uploader.runnings += 1;
-    const url = getUrl(this.name);
+    const url = newUrl(this.name);
     this.lastUptime = Date.now();
     const ajax = new XMLHttpRequest();
     ajax.upload.addEventListener("progress", e => this.progress(e), false);
     ajax.addEventListener("readystatechange", () => {
-      if(ajax.readyState === 4) {
+      if (ajax.readyState === 4) {
         if (ajax.status >= 200 && ajax.status < 300) {
           this.complete();
         } else {
@@ -118,7 +171,7 @@ class Uploader {
     ajax.open("PUT", url);
     ajax.send(this.file);
   }
-  
+
 
   progress(event) {
     const now = Date.now();
@@ -149,16 +202,22 @@ Uploader.globalIdx = 0;
 
 Uploader.runnings = 0;
 
+Uploader.auth = false;
+
 /**
  * @type Uploader[]
  */
 Uploader.queues = [];
 
 
-Uploader.runQueue = () => {
+Uploader.runQueue = async () => {
   if (Uploader.runnings > 2) return;
   let uploader = Uploader.queues.shift();
   if (!uploader) return;
+  if (!Uploader.auth) {
+    Uploader.auth = true;
+    await login();
+  }
   uploader.ajax();
 }
 
@@ -181,7 +240,7 @@ function addBreadcrumb(href, uri_prefix) {
     const name = parts[i];
     if (i > 0) {
       if (!path.endsWith("/")) {
-        path  += "/";
+        path += "/";
       }
       path += encodeURIComponent(name);
     }
@@ -199,6 +258,33 @@ function addBreadcrumb(href, uri_prefix) {
   }
 }
 
+function setupIndexPage() {
+  if (DATA.allow_archive) {
+    const $download = document.querySelector(".download");
+    $download.href = baseUrl() + "?zip";
+    $download.title = "Download folder as div .zip file";
+    $download.classList.remove("hidden");
+  }
+
+  if (DATA.allow_upload) {
+    setupDropzone();
+    setupUploadFile();
+    setupNewFolder();
+    setupNewFile();
+  }
+
+  if (DATA.auth) {
+    setupAuth();
+  }
+
+  if (DATA.allow_search) {
+    setupSearch()
+  }
+
+  renderPathsTableHead();
+  renderPathsTableBody();
+}
+
 /**
  * Render path table thead
  */
@@ -223,20 +309,20 @@ function renderPathsTableHead() {
   $pathsTableHead.insertAdjacentHTML("beforeend", `
     <tr>
       ${headerItems.map(item => {
-        let svg = `<svg width="12" height="12" viewBox="0 0 16 16"><path fill-rule="evenodd" d="M11.5 15a.5.5 0 0 0 .5-.5V2.707l3.146 3.147a.5.5 0 0 0 .708-.708l-4-4a.5.5 0 0 0-.708 0l-4 4a.5.5 0 1 0 .708.708L11 2.707V14.5a.5.5 0 0 0 .5.5zm-7-14a.5.5 0 0 1 .5.5v11.793l3.146-3.147a.5.5 0 0 1 .708.708l-4 4a.5.5 0 0 1-.708 0l-4-4a.5.5 0 0 1 .708-.708L4 13.293V1.5a.5.5 0 0 1 .5-.5z"/></svg>`;
+    let svg = `<svg width="12" height="12" viewBox="0 0 16 16"><path fill-rule="evenodd" d="M11.5 15a.5.5 0 0 0 .5-.5V2.707l3.146 3.147a.5.5 0 0 0 .708-.708l-4-4a.5.5 0 0 0-.708 0l-4 4a.5.5 0 1 0 .708.708L11 2.707V14.5a.5.5 0 0 0 .5.5zm-7-14a.5.5 0 0 1 .5.5v11.793l3.146-3.147a.5.5 0 0 1 .708.708l-4 4a.5.5 0 0 1-.708 0l-4-4a.5.5 0 0 1 .708-.708L4 13.293V1.5a.5.5 0 0 1 .5-.5z"/></svg>`;
-        let order = "asc";
+    let order = "asc";
-        if (PARAMS.sort === item.name) {
+    if (PARAMS.sort === item.name) {
-          if (PARAMS.order === "asc") {
+      if (PARAMS.order === "asc") {
-            order = "desc";
+        order = "desc";
-            svg = `<svg width="12" height="12" viewBox="0 0 16 16"><path fill-rule="evenodd" d="M8 15a.5.5 0 0 0 .5-.5V2.707l3.146 3.147a.5.5 0 0 0 .708-.708l-4-4a.5.5 0 0 0-.708 0l-4 4a.5.5 0 1 0 .708.708L7.5 2.707V14.5a.5.5 0 0 0 .5.5z"/></svg>`
+        svg = `<svg width="12" height="12" viewBox="0 0 16 16"><path fill-rule="evenodd" d="M8 15a.5.5 0 0 0 .5-.5V2.707l3.146 3.147a.5.5 0 0 0 .708-.708l-4-4a.5.5 0 0 0-.708 0l-4 4a.5.5 0 1 0 .708.708L7.5 2.707V14.5a.5.5 0 0 0 .5.5z"/></svg>`
-          } else {
+      } else {
-            svg = `<svg width="12" height="12" viewBox="0 0 16 16"><path fill-rule="evenodd" d="M8 1a.5.5 0 0 1 .5.5v11.793l3.146-3.147a.5.5 0 0 1 .708.708l-4 4a.5.5 0 0 1-.708 0l-4-4a.5.5 0 0 1 .708-.708L7.5 13.293V1.5A.5.5 0 0 1 8 1z"/></svg>`
+        svg = `<svg width="12" height="12" viewBox="0 0 16 16"><path fill-rule="evenodd" d="M8 1a.5.5 0 0 1 .5.5v11.793l3.146-3.147a.5.5 0 0 1 .708.708l-4 4a.5.5 0 0 1-.708 0l-4-4a.5.5 0 0 1 .708-.708L7.5 13.293V1.5A.5.5 0 0 1 8 1z"/></svg>`
-          }
+      }
-        }
+    }
-        const qs = new URLSearchParams({...PARAMS, order, sort: item.name }).toString();
+    const qs = new URLSearchParams({ ...PARAMS, order, sort: item.name }).toString();
-        const icon = `<span>${svg}</span>`
+    const icon = `<span>${svg}</span>`
-        return `<th class="cell-${item.name}" ${item.props}><a href="?${qs}">${item.text}${icon}</a></th>`
+    return `<th class="cell-${item.name}" ${item.props}><a href="?${qs}">${item.text}${icon}</a></th>`
-      }).join("\n")}
+  }).join("\n")}
       <th class="cell-actions">Actions</th>
     </tr>
   `);
@@ -267,52 +353,52 @@ function renderPathsTableBody() {
  */
 function addPath(file, index) {
   const encodedName = encodedStr(file.name);
-  let url = getUrl(file.name)
+  let url = newUrl(file.name)
   let actionDelete = "";
   let actionDownload = "";
   let actionMove = "";
-  if (file.path_type.endsWith("Dir")) {
+  let actionEdit = "";
+  let isDir = file.path_type.endsWith("Dir");
+  if (isDir) {
     url += "/";
-    actionDownload = `
+    if (DATA.allow_archive) {
-    <div class="action-btn">
+      actionDownload = `
-      <a href="${url}?zip" title="Download folder as a .zip file">
+      <div class="action-btn">
-        <svg width="16" height="16" viewBox="0 0 16 16"><path d="M.5 9.9a.5.5 0 0 1 .5.5v2.5a1 1 0 0 0 1 1h12a1 1 0 0 0 1-1v-2.5a.5.5 0 0 1 1 0v2.5a2 2 0 0 1-2 2H2a2 2 0 0 1-2-2v-2.5a.5.5 0 0 1 .5-.5z"/><path d="M7.646 11.854a.5.5 0 0 0 .708 0l3-3a.5.5 0 0 0-.708-.708L8.5 10.293V1.5a.5.5 0 0 0-1 0v8.793L5.354 8.146a.5.5 0 1 0-.708.708l3 3z"/></svg>
+        <a href="${url}?zip" title="Download folder as a .zip file">${ICONS.download}</a>
-      </a>
+      </div>`;
-    </div>`;
+    }
   } else {
     actionDownload = `
     <div class="action-btn" >
-      <a href="${url}" title="Download file" download>
+      <a href="${url}" title="Download file" download>${ICONS.download}</a>
-        <svg width="16" height="16" viewBox="0 0 16 16"><path d="M.5 9.9a.5.5 0 0 1 .5.5v2.5a1 1 0 0 0 1 1h12a1 1 0 0 0 1-1v-2.5a.5.5 0 0 1 1 0v2.5a2 2 0 0 1-2 2H2a2 2 0 0 1-2-2v-2.5a.5.5 0 0 1 .5-.5z"/><path d="M7.646 11.854a.5.5 0 0 0 .708 0l3-3a.5.5 0 0 0-.708-.708L8.5 10.293V1.5a.5.5 0 0 0-1 0v8.793L5.354 8.146a.5.5 0 1 0-.708.708l3 3z"/></svg>
-      </a>
     </div>`;
   }
   if (DATA.allow_delete) {
     if (DATA.allow_upload) {
-      actionMove = `
+      if (isDir) {
-      <div onclick="movePath(${index})" class="action-btn" id="moveBtn${index}" title="Move to new path">
+        actionMove = `<div onclick="movePath(${index})" class="action-btn" id="moveBtn${index}" title="Move to new path">${ICONS.move}</div>`;
-        <svg width="16" height="16" viewBox="0 0 16 16"><path fill-rule="evenodd" d="M1.5 1.5A.5.5 0 0 0 1 2v4.8a2.5 2.5 0 0 0 2.5 2.5h9.793l-3.347 3.346a.5.5 0 0 0 .708.708l4.2-4.2a.5.5 0 0 0 0-.708l-4-4a.5.5 0 0 0-.708.708L13.293 8.3H3.5A1.5 1.5 0 0 1 2 6.8V2a.5.5 0 0 0-.5-.5z"/></svg>
+      } else {
-      </div>`;
+        actionEdit = `<a class="action-btn" title="Edit file" target="_blank" href="${url}?edit">${ICONS.edit}</a>`;
+      }
     }
     actionDelete = `
-    <div onclick="deletePath(${index})" class="action-btn" id="deleteBtn${index}" title="Delete">
+    <div onclick="deletePath(${index})" class="action-btn" id="deleteBtn${index}" title="Delete">${ICONS.delete}</div>`;
-      <svg width="16" height="16" fill="currentColor"viewBox="0 0 16 16"><path d="M6.854 7.146a.5.5 0 1 0-.708.708L7.293 9l-1.147 1.146a.5.5 0 0 0 .708.708L8 9.707l1.146 1.147a.5.5 0 0 0 .708-.708L8.707 9l1.147-1.146a.5.5 0 0 0-.708-.708L8 8.293 6.854 7.146z"/><path d="M14 14V4.5L9.5 0H4a2 2 0 0 0-2 2v12a2 2 0 0 0 2 2h8a2 2 0 0 0 2-2zM9.5 3A1.5 1.5 0 0 0 11 4.5h2V14a1 1 0 0 1-1 1H4a1 1 0 0 1-1-1V2a1 1 0 0 1 1-1h5.5v2z"/></svg>
-    </div>`;
   }
   let actionCell = `
   <td class="cell-actions">
     ${actionDownload}
     ${actionMove}
+    ${actionEdit}
     ${actionDelete}
   </td>`
 
   $pathsTableBody.insertAdjacentHTML("beforeend", `
 <tr id="addPath${index}">
   <td class="path cell-icon">
-    ${getSvg(file.path_type)}
+    ${getPathSvg(file.path_type)}
   </td>
   <td class="path cell-name">
-    <a href="${url}">${encodedName}</a>
+    <a href="${url}" ${isDir ? "" : `target="_blank"`}>${encodedName}</a>
   </td>
   <td class="cell-mtime">${formatMtime(file.mtime)}</td>
   <td class="cell-size">${formatSize(file.size).join(" ")}</td>
@@ -320,6 +406,142 @@ function addPath(file, index) {
 </tr>`)
 }
 
+function setupDropzone() {
+  ["drag", "dragstart", "dragend", "dragover", "dragenter", "dragleave", "drop"].forEach(name => {
+    document.addEventListener(name, e => {
+      e.preventDefault();
+      e.stopPropagation();
+    });
+  });
+  document.addEventListener("drop", async e => {
+    if (!e.dataTransfer.items[0].webkitGetAsEntry) {
+      const files = e.dataTransfer.files.filter(v => v.size > 0);
+      for (const file of files) {
+        new Uploader(file, []).upload();
+      }
+    } else {
+      const entries = [];
+      const len = e.dataTransfer.items.length;
+      for (let i = 0; i < len; i++) {
+        entries.push(e.dataTransfer.items[i].webkitGetAsEntry());
+      }
+      addFileEntries(entries, [])
+    }
+  });
+}
+
+function setupAuth() {
+  if (DATA.user) {
+    $userBtn.classList.remove("hidden");
+    $userBtn.title = DATA.user;
+  } else {
+    const $loginBtn = document.querySelector(".login-btn");
+    $loginBtn.classList.remove("hidden");
+    $loginBtn.addEventListener("click", () => login(true));
+  }
+}
+
+function setupSearch() {
+  const $searchbar = document.querySelector(".searchbar");
+  $searchbar.classList.remove("hidden");
+  $searchbar.addEventListener("submit", event => {
+    event.preventDefault();
+    const formData = new FormData($searchbar);
+    const q = formData.get("q");
+    let href = baseUrl();
+    if (q) {
+      href += "?q=" + q;
+    }
+    location.href = href;
+  });
+  if (PARAMS.q) {
+    document.getElementById('search').value = PARAMS.q;
+  }
+}
+
+function setupUploadFile() {
+  document.querySelector(".upload-file").classList.remove("hidden");
+  document.getElementById("file").addEventListener("change", async e => {
+    const files = e.target.files;
+    for (let file of files) {
+      new Uploader(file, []).upload();
+    }
+  });
+}
+
+function setupNewFolder() {
+  const $newFolder = document.querySelector(".new-folder");
+  $newFolder.classList.remove("hidden");
+  $newFolder.addEventListener("click", () => {
+    const name = prompt("Enter folder name");
+    if (name) createFolder(name);
+  });
+}
+
+function setupNewFile() {
+  const $newFile = document.querySelector(".new-file");
+  $newFile.classList.remove("hidden");
+  $newFile.addEventListener("click", () => {
+    const name = prompt("Enter file name");
+    if (name) createFile(name);
+  });
+}
+
+async function setupEditPage() {
+  const url = baseUrl();
+
+  const $download = document.querySelector(".download");
+  $download.classList.remove("hidden");
+  $download.href = url;
+
+  const $moveFile = document.querySelector(".move-file");
+  $moveFile.classList.remove("hidden");
+  $moveFile.addEventListener("click", async () => {
+    const query = location.href.slice(url.length);
+    const newFileUrl = await doMovePath(url);
+    if (newFileUrl) {
+      location.href = newFileUrl + query;
+    }
+  });
+
+  const $deleteFile = document.querySelector(".delete-file");
+  $deleteFile.classList.remove("hidden");
+  $deleteFile.addEventListener("click", async () => {
+    const url = baseUrl();
+    const name = baseName(url);
+    await doDeletePath(name, url, () => {
+      location.href = location.href.split("/").slice(0, -1).join("/");
+    });
+  })
+
+  if (!DATA.editable) {
+    const $notEditable = document.querySelector(".not-editable");
+    const url = baseUrl();
+    const ext = extName(baseName(url));
+    if (IFRAME_FORMATS.find(v => v === ext)) {
+      $notEditable.insertAdjacentHTML("afterend", `<iframe src="${url}" sandbox width="100%" height="${window.innerHeight - 100}px"></iframe>`)
+    } else {
+      $notEditable.classList.remove("hidden");
+      $notEditable.textContent = "Cannot edit because it is too large or binary.";
+    }
+    return;
+  }
+
+  const $saveBtn = document.querySelector(".save-btn");
+  $saveBtn.classList.remove("hidden");
+  $saveBtn.addEventListener("click", saveChange);
+
+  $editor.classList.remove("hidden");
+  try {
+    const res = await fetch(baseUrl());
+    await assertResOK(res);
+    const text = await res.text();
+    $editor.value = text;
+  } catch (err) {
+    alert(`Failed get file, ${err.message}`);
+  }
+}
+
 /**
  * Delete path
  * @param {number} index 
@@ -328,30 +550,31 @@ function addPath(file, index) {
 async function deletePath(index) {
   const file = DATA.paths[index];
   if (!file) return;
+  await doDeletePath(file.name, newUrl(file.name), () => {
+    document.getElementById(`addPath${index}`)?.remove();
+    DATA.paths[index] = null;
+    if (!DATA.paths.find(v => !!v)) {
+      $pathsTable.classList.add("hidden");
+      $emptyFolder.textContent = dirEmptyNote;
+      $emptyFolder.classList.remove("hidden");
+    }
+  })
+}
 
-  if (!confirm(`Delete \`${file.name}\`?`)) return;
+async function doDeletePath(name, url, cb) {
-
+  if (!confirm(`Delete \`${name}\`?`)) return;
   try {
-    const res = await fetch(getUrl(file.name), {
+    await login();
+    const res = await fetch(url, {
       method: "DELETE",
     });
-    if (res.status >= 200 && res.status < 300) {
+    await assertResOK(res);
-        document.getElementById(`addPath${index}`).remove();
+    cb();
-        DATA.paths[index] = null;
-        if (!DATA.paths.find(v => !!v)) {
-          $pathsTable.classList.add("hidden");
-          $emptyFolder.textContent = dirEmptyNote;
-          $emptyFolder.classList.remove("hidden");
-        }
-    } else {
-      throw new Error(await res.text())
-    }
   } catch (err) {
     alert(`Cannot delete \`${file.name}\`, ${err.message}`);
   }
 }
 
-
 /**
  * Move path
  * @param {number} index 
@@ -360,12 +583,18 @@ async function deletePath(index) {
 async function movePath(index) {
   const file = DATA.paths[index];
   if (!file) return;
+  const fileUrl = newUrl(file.name);
+  const newFileUrl = await doMovePath(fileUrl);
+  if (newFileUrl) {
+    location.href = newFileUrl.split("/").slice(0, -1).join("/");
+  }
+}
 
-  const fileUrl = getUrl(file.name);
+async function doMovePath(fileUrl) {
   const fileUrlObj = new URL(fileUrl)
 
   const prefix = DATA.uri_prefix.slice(0, -1);
-    
+
   const filePath = decodeURIComponent(fileUrlObj.pathname.slice(prefix.length));
 
   let newPath = prompt("Enter new path", filePath)
@@ -375,44 +604,61 @@ async function movePath(index) {
   const newFileUrl = fileUrlObj.origin + prefix + newPath.split("/").map(encodeURIComponent).join("/");
 
   try {
-    const res = await fetch(fileUrl, {
+    await login();
+    const res1 = await fetch(newFileUrl, {
+      method: "HEAD",
+    });
+    if (res1.status === 200) {
+      if (!confirm("Override exsis file?")) {
+        return;
+      }
+    }
+    const res2 = await fetch(fileUrl, {
       method: "MOVE",
       headers: {
         "Destination": newFileUrl,
       }
     });
-    if (res.status >= 200 && res.status < 300) {
+    await assertResOK(res2);
-      location.href = newFileUrl.split("/").slice(0, -1).join("/")
+    return newFileUrl;
-    } else {
-      throw new Error(await res.text())
-    }
   } catch (err) {
     alert(`Cannot move \`${filePath}\` to \`${newPath}\`, ${err.message}`);
   }
 }
 
-function dropzone() {
+
-    ["drag", "dragstart", "dragend", "dragover", "dragenter", "dragleave", "drop"].forEach(name => {
+/**
-      document.addEventListener(name, e => {
+ * Save editor change
-          e.preventDefault();
+ */
-          e.stopPropagation();
+async function saveChange() {
-      });
+  try {
+    await fetch(baseUrl(), {
+      method: "PUT",
+      body: $editor.value,
     });
-    document.addEventListener("drop", e => {
+  } catch (err) {
-      if (!e.dataTransfer.items[0].webkitGetAsEntry) {
+    alert(`Failed to save file, ${err.message}`);
-        const files = e.dataTransfer.files.filter(v => v.size > 0);
+  }
-        for (const file of files) {
+}
-          new Uploader(file, []).upload();
+
-        }
+async function login(alert = false) {
-      } else {
+  if (!DATA.auth) return;
-        const entries = [];
+  try {
-        const len = e.dataTransfer.items.length;
+    const res = await fetch(baseUrl(), {
-        for (let i = 0; i < len; i++) {
+      method: "WRITEABLE",
-          entries.push(e.dataTransfer.items[i].webkitGetAsEntry());
-        }
-        addFileEntries(entries, [])
-      }
     });
+    await assertResOK(res);
+    document.querySelector(".login-btn").classList.add("hidden");
+    $userBtn.classList.remove("hidden");
+    $userBtn.title = "";
+  } catch (err) {
+    let message = `Cannot login, ${err.message}`;
+    if (alert) {
+      alert(message);
+    } else {
+      throw new Error(message);
+    }
+  }
 }
 
 /**
@@ -420,19 +666,34 @@ function dropzone() {
  * @param {string} name 
  */
 async function createFolder(name) {
-  const url = getUrl(name);
+  const url = newUrl(name);
   try {
+    await login();
     const res = await fetch(url, {
       method: "MKCOL",
     });
-    if (res.status >= 200 && res.status < 300) {
+    await assertResOK(res);
-      location.href = url;
+    location.href = url;
-    }
   } catch (err) {
     alert(`Cannot create folder \`${name}\`, ${err.message}`);
   }
 }
 
+async function createFile(name) {
+  const url = newUrl(name);
+  try {
+    await login();
+    const res = await fetch(url, {
+      method: "PUT",
+      body: "",
+    });
+    await assertResOK(res);
+    location.href = url + "?edit";
+  } catch (err) {
+    alert(`Cannot create file \`${name}\`, ${err.message}`);
+  }
+}
+
 async function addFileEntries(entries, dirs) {
   for (const entry of entries) {
     if (entry.isFile) {
@@ -447,23 +708,41 @@ async function addFileEntries(entries, dirs) {
 }
 
 
-function getUrl(name) {
+function newUrl(name) {
-    let url = location.href.split('?')[0];
+  let url = baseUrl();
-    if (!url.endsWith("/")) url += "/";
+  if (!url.endsWith("/")) url += "/";
-    url += name.split("/").map(encodeURIComponent).join("/");
+  url += name.split("/").map(encodeURIComponent).join("/");
-    return url;
+  return url;
 }
 
-function getSvg(path_type) {
+function baseUrl() {
+  return location.href.split('?')[0];
+}
+
+function baseName(url) {
+  return decodeURIComponent(url.split("/").filter(v => v.length > 0).slice(-1)[0])
+}
+
+function extName(filename) {
+  const dotIndex = filename.lastIndexOf('.');
+
+  if (dotIndex === -1 || dotIndex === 0 || dotIndex === filename.length - 1) {
+    return '';
+  }
+
+  return filename.substring(dotIndex);
+}
+
+function getPathSvg(path_type) {
   switch (path_type) {
     case "Dir":
-      return `<svg height="16" viewBox="0 0 14 16" width="14"><path fill-rule="evenodd" d="M13 4H7V3c0-.66-.31-1-1-1H1c-.55 0-1 .45-1 1v10c0 .55.45 1 1 1h12c.55 0 1-.45 1-1V5c0-.55-.45-1-1-1zM6 4H1V3h5v1z"></path></svg>`;
+      return ICONS.dir;
     case "SymlinkFile":
-      return `<svg height="16" viewBox="0 0 12 16" width="12"><path fill-rule="evenodd" d="M8.5 1H1c-.55 0-1 .45-1 1v12c0 .55.45 1 1 1h10c.55 0 1-.45 1-1V4.5L8.5 1zM11 14H1V2h7l3 3v9zM6 4.5l4 3-4 3v-2c-.98-.02-1.84.22-2.55.7-.71.48-1.19 1.25-1.45 2.3.02-1.64.39-2.88 1.13-3.73.73-.84 1.69-1.27 2.88-1.27v-2H6z"></path></svg>`;
+      return ICONS.symlinkFile;
     case "SymlinkDir":
-      return `<svg height="16" viewBox="0 0 14 16" width="14"><path fill-rule="evenodd" d="M13 4H7V3c0-.66-.31-1-1-1H1c-.55 0-1 .45-1 1v10c0 .55.45 1 1 1h12c.55 0 1-.45 1-1V5c0-.55-.45-1-1-1zM1 3h5v1H1V3zm6 9v-2c-.98-.02-1.84.22-2.55.7-.71.48-1.19 1.25-1.45 2.3.02-1.64.39-2.88 1.13-3.73C4.86 8.43 5.82 8 7.01 8V6l4 3-4 3H7z"></path></svg>`;
+      return ICONS.symlinkDir;
     default:
-      return `<svg height="16" viewBox="0 0 12 16" width="12"><path fill-rule="evenodd" d="M6 5H2V4h4v1zM2 8h7V7H2v1zm0 2h7V9H2v1zm0 2h7v-1H2v1zm10-7.5V14c0 .55-.45 1-1 1H1c-.55 0-1-.45-1-1V2c0-.55.45-1 1-1h7.5L12 4.5zM11 5L8 2H1v12h10V5z"></path></svg>`;
+      return ICONS.file;
   }
 }
 
@@ -483,9 +762,9 @@ function padZero(value, size) {
 }
 
 function formatSize(size) {
-  if (!size) return []
+  if (size == null) return []
   const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
-  if (size == 0) return [0, "Byte"];
+  if (size == 0) return [0, "B"];
   const i = parseInt(Math.floor(Math.log(size) / Math.log(1024)));
   return [Math.round(size / Math.pow(1024, i), 2), sizes[i]];
 }
@@ -498,55 +777,22 @@ function formatDuration(seconds) {
   return `${padZero(h, 2)}:${padZero(m, 2)}:${padZero(s, 2)}`;
 }
 
-function formatPercent(precent) {
+function formatPercent(percent) {
-  if (precent > 10) {
+  if (percent > 10) {
-    return precent.toFixed(1) + "%";
+    return percent.toFixed(1) + "%";
   } else {
-    return precent.toFixed(2) + "%";
+    return percent.toFixed(2) + "%";
   }
 }
 
 function encodedStr(rawStr) {
-  return rawStr.replace(/[\u00A0-\u9999<>\&]/g, function(i) {
+  return rawStr.replace(/[\u00A0-\u9999<>\&]/g, function (i) {
-    return '&#'+i.charCodeAt(0)+';';
+    return '&#' + i.charCodeAt(0) + ';';
   });
 }
 
-function ready() {
+async function assertResOK(res) {
-  document.title = `Index of ${DATA.href} - Dufs`;
+  if (!(res.status >= 200 && res.status < 300)) {
-  $pathsTable = document.querySelector(".paths-table")
+    throw new Error(await res.text())
-  $pathsTableHead = document.querySelector(".paths-table thead");
-  $pathsTableBody = document.querySelector(".paths-table tbody");
-  $uploadersTable = document.querySelector(".uploaders-table");
-  $emptyFolder = document.querySelector(".empty-folder");
-  $newFolder = document.querySelector(".new-folder");
-
-  if (DATA.allow_search) {
-    document.querySelector(".searchbar").classList.remove("hidden");
-    if (PARAMS.q) {
-      document.getElementById('search').value = PARAMS.q;
-    }
-  }
-
-  addBreadcrumb(DATA.href, DATA.uri_prefix);
-  renderPathsTableHead();
-  renderPathsTableBody();
-
-  if (DATA.allow_upload) {
-    dropzone();
-    if (DATA.allow_delete) {
-      $newFolder.classList.remove("hidden");
-      $newFolder.addEventListener("click", () => {
-        const name = prompt("Enter name of new folder");
-        if (name) createFolder(name);
-      });
-    }
-    document.querySelector(".upload-file").classList.remove("hidden");
-    document.getElementById("file").addEventListener("change", e => {
-      const files = e.target.files;
-      for (let file of files) {
-        new Uploader(file, []).upload();
-      }
-    });
   }
 }

src/args.rs

@@ -1,4 +1,6 @@
-use clap::{value_parser, AppSettings, Arg, ArgAction, ArgMatches, Command};
+use anyhow::{anyhow, bail, Result};
+use clap::builder::PossibleValuesParser;
+use clap::{value_parser, Arg, ArgAction, ArgMatches, Command};
 use clap_complete::{generate, Generator, Shell};
 #[cfg(feature = "tls")]
 use rustls::{Certificate, PrivateKey};
@@ -12,9 +14,8 @@ use crate::log_http::{LogHttp, DEFAULT_LOG_FORMAT};
 #[cfg(feature = "tls")]
 use crate::tls::{load_certs, load_private_key};
 use crate::utils::encode_uri;
-use crate::BoxResult;
 
-pub fn build_cli() -> Command<'static> {
+pub fn build_cli() -> Command {
     let app = Command::new(env!("CARGO_CRATE_NAME"))
         .version(env!("CARGO_PKG_VERSION"))
         .author(env!("CARGO_PKG_AUTHORS"))
@@ -23,112 +24,161 @@ pub fn build_cli() -> Command<'static> {
             " - ",
             env!("CARGO_PKG_REPOSITORY")
         ))
-        .global_setting(AppSettings::DeriveDisplayOrder)
+        .arg(
+            Arg::new("root")
+                .env("DUFS_ROOT")
+				.hide_env(true)
+                .default_value(".")
+                .value_parser(value_parser!(PathBuf))
+                .help("Specific path to serve"),
+        )
         .arg(
             Arg::new("bind")
+                .env("DUFS_BIND")
+				.hide_env(true)
                 .short('b')
                 .long("bind")
-                .help("Specify bind address")
+                .help("Specify bind address or unix socket")
-                .multiple_values(true)
-                .value_delimiter(',')
                 .action(ArgAction::Append)
-                .value_name("addr"),
+                .value_delimiter(',')
+                .value_name("addrs"),
         )
         .arg(
             Arg::new("port")
+                .env("DUFS_PORT")
+				.hide_env(true)
                 .short('p')
                 .long("port")
                 .default_value("5000")
+                .value_parser(value_parser!(u16))
                 .help("Specify port to listen on")
                 .value_name("port"),
         )
-        .arg(
-            Arg::new("root")
-                .default_value(".")
-                .allow_invalid_utf8(true)
-                .help("Specific path to serve"),
-        )
         .arg(
             Arg::new("path-prefix")
+                .env("DUFS_PATH_PREFIX")
+				.hide_env(true)
                 .long("path-prefix")
                 .value_name("path")
                 .help("Specify a path prefix"),
         )
         .arg(
             Arg::new("hidden")
+                .env("DUFS_HIDDEN")
+				.hide_env(true)
                 .long("hidden")
                 .help("Hide paths from directory listings, separated by `,`")
                 .value_name("value"),
         )
         .arg(
             Arg::new("auth")
+                .env("DUFS_AUTH")
+				.hide_env(true)
                 .short('a')
                 .long("auth")
                 .help("Add auth for path")
                 .action(ArgAction::Append)
-                .multiple_values(true)
                 .value_delimiter(',')
-                .value_name("rule"),
+                .value_name("rules"),
         )
         .arg(
             Arg::new("auth-method")
+                .env("DUFS_AUTH_METHOD")
+				.hide_env(true)
                 .long("auth-method")
                 .help("Select auth method")
-                .possible_values(["basic", "digest"])
+                .value_parser(PossibleValuesParser::new(["basic", "digest"]))
                 .default_value("digest")
                 .value_name("value"),
         )
         .arg(
             Arg::new("allow-all")
+                .env("DUFS_ALLOW_ALL")
+				.hide_env(true)
                 .short('A')
                 .long("allow-all")
+                .action(ArgAction::SetTrue)
                 .help("Allow all operations"),
         )
         .arg(
             Arg::new("allow-upload")
+                .env("DUFS_ALLOW_UPLOAD")
+				.hide_env(true)
                 .long("allow-upload")
+                .action(ArgAction::SetTrue)
                 .help("Allow upload files/folders"),
         )
         .arg(
             Arg::new("allow-delete")
+                .env("DUFS_ALLOW_DELETE")
+				.hide_env(true)
                 .long("allow-delete")
+                .action(ArgAction::SetTrue)
                 .help("Allow delete files/folders"),
         )
         .arg(
             Arg::new("allow-search")
+                .env("DUFS_ALLOW_SEARCH")
+				.hide_env(true)
                 .long("allow-search")
+                .action(ArgAction::SetTrue)
                 .help("Allow search files/folders"),
         )
         .arg(
             Arg::new("allow-symlink")
+                .env("DUFS_ALLOW_SYMLINK")
+				.hide_env(true)
                 .long("allow-symlink")
+                .action(ArgAction::SetTrue)
                 .help("Allow symlink to files/folders outside root directory"),
         )
+        .arg(
+            Arg::new("allow-archive")
+                .env("DUFS_ALLOW_ARCHIVE")
+				.hide_env(true)
+                .long("allow-archive")
+                .action(ArgAction::SetTrue)
+                .help("Allow zip archive generation"),
+        )
         .arg(
             Arg::new("enable-cors")
+                .env("DUFS_ENABLE_CORS")
+				.hide_env(true)
                 .long("enable-cors")
+                .action(ArgAction::SetTrue)
                 .help("Enable CORS, sets `Access-Control-Allow-Origin: *`"),
         )
         .arg(
             Arg::new("render-index")
+                .env("DUFS_RENDER_INDEX")
+				.hide_env(true)
                 .long("render-index")
+                .action(ArgAction::SetTrue)
                 .help("Serve index.html when requesting a directory, returns 404 if not found index.html"),
         )
         .arg(
             Arg::new("render-try-index")
+                .env("DUFS_RENDER_TRY_INDEX")
+				.hide_env(true)
                 .long("render-try-index")
+                .action(ArgAction::SetTrue)
                 .help("Serve index.html when requesting a directory, returns directory listing if not found index.html"),
         )
         .arg(
             Arg::new("render-spa")
+                .env("DUFS_RENDER_SPA")
+				.hide_env(true)
                 .long("render-spa")
+                .action(ArgAction::SetTrue)
                 .help("Serve SPA(Single Page Application)"),
         )
         .arg(
             Arg::new("assets")
+                .env("DUFS_ASSETS")
+				.hide_env(true)
                 .long("assets")
                 .help("Use custom assets to override builtin assets")
-                .allow_invalid_utf8(true)
+                .value_parser(value_parser!(PathBuf))
                 .value_name("path")
         );
 
@@ -136,19 +186,27 @@ pub fn build_cli() -> Command<'static> {
     let app = app
         .arg(
             Arg::new("tls-cert")
+                .env("DUFS_TLS_CERT")
+                .hide_env(true)
                 .long("tls-cert")
                 .value_name("path")
+                .value_parser(value_parser!(PathBuf))
                 .help("Path to an SSL/TLS certificate to serve with HTTPS"),
         )
         .arg(
             Arg::new("tls-key")
+                .env("DUFS_TLS_KEY")
+                .hide_env(true)
                 .long("tls-key")
                 .value_name("path")
+                .value_parser(value_parser!(PathBuf))
                 .help("Path to the SSL/TLS certificate's private key"),
         );
 
     app.arg(
         Arg::new("log-format")
+            .env("DUFS_LOG_FORMAT")
+            .hide_env(true)
             .long("log-format")
             .value_name("format")
             .help("Customize http log format"),
@@ -168,7 +226,7 @@ pub fn print_completions<G: Generator>(gen: G, cmd: &mut Command) {
 
 #[derive(Debug)]
 pub struct Args {
-    pub addrs: Vec<IpAddr>,
+    pub addrs: Vec<BindAddr>,
     pub port: u16,
     pub path: PathBuf,
     pub path_is_file: bool,
@@ -181,6 +239,7 @@ pub struct Args {
     pub allow_delete: bool,
     pub allow_search: bool,
     pub allow_symlink: bool,
+    pub allow_archive: bool,
     pub render_index: bool,
     pub render_spa: bool,
     pub render_try_index: bool,
@@ -196,19 +255,19 @@ pub struct Args {
 impl Args {
     /// Parse command-line arguments.
     ///
-    /// If a parsing error ocurred, exit the process and print out informative
+    /// If a parsing error occurred, exit the process and print out informative
     /// error message to user.
-    pub fn parse(matches: ArgMatches) -> BoxResult<Args> {
+    pub fn parse(matches: ArgMatches) -> Result<Args> {
-        let port = matches.value_of_t::<u16>("port")?;
+        let port = *matches.get_one::<u16>("port").unwrap();
         let addrs = matches
-            .values_of("bind")
+            .get_many::<String>("bind")
-            .map(|v| v.collect())
+            .map(|bind| bind.map(|v| v.as_str()).collect())
             .unwrap_or_else(|| vec!["0.0.0.0", "::"]);
-        let addrs: Vec<IpAddr> = Args::parse_addrs(&addrs)?;
+        let addrs: Vec<BindAddr> = Args::parse_addrs(&addrs)?;
-        let path = Args::parse_path(matches.value_of_os("root").unwrap_or_default())?;
+        let path = Args::parse_path(matches.get_one::<PathBuf>("root").unwrap())?;
         let path_is_file = path.metadata()?.is_file();
         let path_prefix = matches
-            .value_of("path-prefix")
+            .get_one::<String>("path-prefix")
             .map(|v| v.trim_matches('/').to_owned())
             .unwrap_or_default();
         let uri_prefix = if path_prefix.is_empty() {
@@ -217,28 +276,32 @@ impl Args {
             format!("/{}/", &encode_uri(&path_prefix))
         };
         let hidden: Vec<String> = matches
-            .value_of("hidden")
+            .get_one::<String>("hidden")
             .map(|v| v.split(',').map(|x| x.to_string()).collect())
             .unwrap_or_default();
-        let enable_cors = matches.is_present("enable-cors");
+        let enable_cors = matches.get_flag("enable-cors");
         let auth: Vec<&str> = matches
-            .values_of("auth")
+            .get_many::<String>("auth")
-            .map(|v| v.collect())
+            .map(|auth| auth.map(|v| v.as_str()).collect())
             .unwrap_or_default();
-        let auth_method = match matches.value_of("auth-method").unwrap() {
+        let auth_method = match matches.get_one::<String>("auth-method").unwrap().as_str() {
             "basic" => AuthMethod::Basic,
             _ => AuthMethod::Digest,
         };
         let auth = AccessControl::new(&auth, &uri_prefix)?;
-        let allow_upload = matches.is_present("allow-all") || matches.is_present("allow-upload");
+        let allow_upload = matches.get_flag("allow-all") || matches.get_flag("allow-upload");
-        let allow_delete = matches.is_present("allow-all") || matches.is_present("allow-delete");
+        let allow_delete = matches.get_flag("allow-all") || matches.get_flag("allow-delete");
-        let allow_search = matches.is_present("allow-all") || matches.is_present("allow-search");
+        let allow_search = matches.get_flag("allow-all") || matches.get_flag("allow-search");
-        let allow_symlink = matches.is_present("allow-all") || matches.is_present("allow-symlink");
+        let allow_symlink = matches.get_flag("allow-all") || matches.get_flag("allow-symlink");
-        let render_index = matches.is_present("render-index");
+        let allow_archive = matches.get_flag("allow-all") || matches.get_flag("allow-archive");
-        let render_try_index = matches.is_present("render-try-index");
+        let render_index = matches.get_flag("render-index");
-        let render_spa = matches.is_present("render-spa");
+        let render_try_index = matches.get_flag("render-try-index");
+        let render_spa = matches.get_flag("render-spa");
         #[cfg(feature = "tls")]
-        let tls = match (matches.value_of("tls-cert"), matches.value_of("tls-key")) {
+        let tls = match (
+            matches.get_one::<PathBuf>("tls-cert"),
+            matches.get_one::<PathBuf>("tls-key"),
+        ) {
             (Some(certs_file), Some(key_file)) => {
                 let certs = load_certs(certs_file)?;
                 let key = load_private_key(key_file)?;
@@ -249,10 +312,11 @@ impl Args {
         #[cfg(not(feature = "tls"))]
         let tls = None;
         let log_http: LogHttp = matches
-            .value_of("log-format")
+            .get_one::<String>("log-format")
+            .map(|v| v.as_str())
             .unwrap_or(DEFAULT_LOG_FORMAT)
             .parse()?;
-        let assets_path = match matches.value_of_os("assets") {
+        let assets_path = match matches.get_one::<PathBuf>("assets") {
             Some(v) => Some(Args::parse_assets_path(v)?),
             None => None,
         };
@@ -272,6 +336,7 @@ impl Args {
             allow_upload,
             allow_search,
             allow_symlink,
+            allow_archive,
             render_index,
             render_try_index,
             render_spa,
@@ -281,29 +346,33 @@ impl Args {
         })
     }
 
-    fn parse_addrs(addrs: &[&str]) -> BoxResult<Vec<IpAddr>> {
+    fn parse_addrs(addrs: &[&str]) -> Result<Vec<BindAddr>> {
-        let mut ip_addrs = vec![];
+        let mut bind_addrs = vec![];
         let mut invalid_addrs = vec![];
         for addr in addrs {
             match addr.parse::<IpAddr>() {
                 Ok(v) => {
-                    ip_addrs.push(v);
+                    bind_addrs.push(BindAddr::Address(v));
                 }
                 Err(_) => {
-                    invalid_addrs.push(*addr);
+                    if cfg!(unix) {
+                        bind_addrs.push(BindAddr::Path(PathBuf::from(addr)));
+                    } else {
+                        invalid_addrs.push(*addr);
+                    }
                 }
             }
         }
         if !invalid_addrs.is_empty() {
-            return Err(format!("Invalid bind address `{}`", invalid_addrs.join(",")).into());
+            bail!("Invalid bind address `{}`", invalid_addrs.join(","));
         }
-        Ok(ip_addrs)
+        Ok(bind_addrs)
     }
 
-    fn parse_path<P: AsRef<Path>>(path: P) -> BoxResult<PathBuf> {
+    fn parse_path<P: AsRef<Path>>(path: P) -> Result<PathBuf> {
         let path = path.as_ref();
         if !path.exists() {
-            return Err(format!("Path `{}` doesn't exist", path.display()).into());
+            bail!("Path `{}` doesn't exist", path.display());
         }
 
         env::current_dir()
@@ -311,14 +380,20 @@ impl Args {
                 p.push(path); // If path is absolute, it replaces the current path.
                 std::fs::canonicalize(p)
             })
-            .map_err(|err| format!("Failed to access path `{}`: {}", path.display(), err,).into())
+            .map_err(|err| anyhow!("Failed to access path `{}`: {}", path.display(), err,))
     }
 
-    fn parse_assets_path<P: AsRef<Path>>(path: P) -> BoxResult<PathBuf> {
+    fn parse_assets_path<P: AsRef<Path>>(path: P) -> Result<PathBuf> {
         let path = Self::parse_path(path)?;
         if !path.join("index.html").exists() {
-            return Err(format!("Path `{}` doesn't contains index.html", path.display()).into());
+            bail!("Path `{}` doesn't contains index.html", path.display());
         }
         Ok(path)
     }
 }
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub enum BindAddr {
+    Address(IpAddr),
+    Path(PathBuf),
+}

src/auth.rs

@@ -1,15 +1,13 @@
+use anyhow::{anyhow, bail, Result};
+use base64::{engine::general_purpose, Engine as _};
 use headers::HeaderValue;
 use hyper::Method;
 use lazy_static::lazy_static;
 use md5::Context;
-use std::{
+use std::collections::HashMap;
-    collections::HashMap,
-    time::{SystemTime, UNIX_EPOCH},
-};
 use uuid::Uuid;
 
-use crate::utils::encode_uri;
+use crate::utils::{encode_uri, unix_now};
-use crate::BoxResult;
 
 const REALM: &str = "DUFS";
 const DIGEST_AUTH_TIMEOUT: u32 = 86400;
@@ -36,14 +34,14 @@ pub struct PathControl {
 }
 
 impl AccessControl {
-    pub fn new(raw_rules: &[&str], uri_prefix: &str) -> BoxResult<Self> {
+    pub fn new(raw_rules: &[&str], uri_prefix: &str) -> Result<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();
+            let create_err = || anyhow!("Invalid auth `{rule}`");
             match parts.as_slice() {
                 [path, readwrite] => {
                     let control = PathControl {
@@ -72,6 +70,10 @@ impl AccessControl {
         Ok(Self { rules })
     }
 
+    pub fn valid(&self) -> bool {
+        !self.rules.is_empty()
+    }
+
     pub fn guard(
         &self,
         path: &str,
@@ -82,6 +84,11 @@ impl AccessControl {
         if self.rules.is_empty() {
             return GuardType::ReadWrite;
         }
+
+        if method == Method::OPTIONS {
+            return GuardType::ReadOnly;
+        }
+
         let mut controls = vec![];
         for path in walk_path(path) {
             if let Some(control) = self.rules.get(path) {
@@ -132,7 +139,12 @@ impl GuardType {
 }
 
 fn sanitize_path(path: &str, uri_prefix: &str) -> String {
-    encode_uri(&format!("{}{}", uri_prefix, path.trim_matches('/')))
+    let new_path = match (uri_prefix, path) {
+        ("/", "/") => "/".into(),
+        (_, "/") => uri_prefix.trim_end_matches('/').into(),
+        _ => format!("{}{}", uri_prefix, path.trim_matches('/')),
+    };
+    encode_uri(&new_path)
 }
 
 fn walk_path(path: &str) -> impl Iterator<Item = &str> {
@@ -167,7 +179,7 @@ impl Account {
         let user = p[0];
         let pass = p[1];
         let mut h = Context::new();
-        h.consume(format!("{}:{}:{}", user, REALM, pass).as_bytes());
+        h.consume(format!("{user}:{REALM}:{pass}").as_bytes());
         Some(Account {
             user: user.to_owned(),
             pass: format!("{:x}", h.compute()),
@@ -182,36 +194,35 @@ pub enum AuthMethod {
 }
 
 impl AuthMethod {
-    pub fn www_auth(&self, stale: bool) -> String {
+    pub fn www_auth(&self, stale: bool) -> Result<String> {
         match self {
-            AuthMethod::Basic => {
+            AuthMethod::Basic => Ok(format!("Basic realm=\"{REALM}\"")),
-                format!("Basic realm=\"{}\"", REALM)
-            }
             AuthMethod::Digest => {
                 let str_stale = if stale { "stale=true," } else { "" };
-                format!(
+                Ok(format!(
                     "Digest realm=\"{}\",nonce=\"{}\",{}qop=\"auth\"",
                     REALM,
-                    create_nonce(),
+                    create_nonce()?,
                     str_stale
-                )
+                ))
             }
         }
     }
     pub fn get_user(&self, authorization: &HeaderValue) -> Option<String> {
         match self {
             AuthMethod::Basic => {
-                let value: Vec<u8> =
+                let value: Vec<u8> = general_purpose::STANDARD_NO_PAD
-                    base64::decode(strip_prefix(authorization.as_bytes(), b"Basic ")?).ok()?;
+                    .decode(strip_prefix(authorization.as_bytes(), b"Basic ")?)
+                    .ok()?;
                 let parts: Vec<&str> = std::str::from_utf8(&value).ok()?.split(':').collect();
                 Some(parts[0].to_string())
             }
             AuthMethod::Digest => {
                 let digest_value = strip_prefix(authorization.as_bytes(), b"Digest ")?;
-                let digest_vals = to_headermap(digest_value).ok()?;
+                let digest_map = to_headermap(digest_value).ok()?;
-                digest_vals
+                digest_map
                     .get(b"username".as_ref())
-                    .and_then(|b| std::str::from_utf8(*b).ok())
+                    .and_then(|b| std::str::from_utf8(b).ok())
                     .map(|v| v.to_string())
             }
         }
@@ -225,8 +236,9 @@ impl AuthMethod {
     ) -> Option<()> {
         match self {
             AuthMethod::Basic => {
-                let basic_value: Vec<u8> =
+                let basic_value: Vec<u8> = general_purpose::STANDARD_NO_PAD
-                    base64::decode(strip_prefix(authorization.as_bytes(), b"Basic ")?).ok()?;
+                    .decode(strip_prefix(authorization.as_bytes(), b"Basic ")?)
+                    .ok()?;
                 let parts: Vec<&str> = std::str::from_utf8(&basic_value).ok()?.split(':').collect();
 
                 if parts[0] != auth_user {
@@ -246,13 +258,13 @@ impl AuthMethod {
             }
             AuthMethod::Digest => {
                 let digest_value = strip_prefix(authorization.as_bytes(), b"Digest ")?;
-                let digest_vals = to_headermap(digest_value).ok()?;
+                let digest_map = to_headermap(digest_value).ok()?;
                 if let (Some(username), Some(nonce), Some(user_response)) = (
-                    digest_vals
+                    digest_map
                         .get(b"username".as_ref())
-                        .and_then(|b| std::str::from_utf8(*b).ok()),
+                        .and_then(|b| std::str::from_utf8(b).ok()),
-                    digest_vals.get(b"nonce".as_ref()),
+                    digest_map.get(b"nonce".as_ref()),
-                    digest_vals.get(b"response".as_ref()),
+                    digest_map.get(b"response".as_ref()),
                 ) {
                     match validate_nonce(nonce) {
                         Ok(true) => {}
@@ -264,24 +276,24 @@ impl AuthMethod {
                     let mut ha = Context::new();
                     ha.consume(method);
                     ha.consume(b":");
-                    if let Some(uri) = digest_vals.get(b"uri".as_ref()) {
+                    if let Some(uri) = digest_map.get(b"uri".as_ref()) {
                         ha.consume(uri);
                     }
                     let ha = format!("{:x}", ha.compute());
                     let mut correct_response = None;
-                    if let Some(qop) = digest_vals.get(b"qop".as_ref()) {
+                    if let Some(qop) = digest_map.get(b"qop".as_ref()) {
                         if qop == &b"auth".as_ref() || qop == &b"auth-int".as_ref() {
                             correct_response = Some({
                                 let mut c = Context::new();
-                                c.consume(&auth_pass);
+                                c.consume(auth_pass);
                                 c.consume(b":");
                                 c.consume(nonce);
                                 c.consume(b":");
-                                if let Some(nc) = digest_vals.get(b"nc".as_ref()) {
+                                if let Some(nc) = digest_map.get(b"nc".as_ref()) {
                                     c.consume(nc);
                                 }
                                 c.consume(b":");
-                                if let Some(cnonce) = digest_vals.get(b"cnonce".as_ref()) {
+                                if let Some(cnonce) = digest_map.get(b"cnonce".as_ref()) {
                                     c.consume(cnonce);
                                 }
                                 c.consume(b":");
@@ -296,7 +308,7 @@ impl AuthMethod {
                         Some(r) => r,
                         None => {
                             let mut c = Context::new();
-                            c.consume(&auth_pass);
+                            c.consume(auth_pass);
                             c.consume(b":");
                             c.consume(nonce);
                             c.consume(b":");
@@ -317,16 +329,16 @@ impl AuthMethod {
 
 /// Check if a nonce is still valid.
 /// Return an error if it was never valid
-fn validate_nonce(nonce: &[u8]) -> Result<bool, ()> {
+fn validate_nonce(nonce: &[u8]) -> Result<bool> {
     if nonce.len() != 34 {
-        return Err(());
+        bail!("invalid nonce");
     }
     //parse hex
     if let Ok(n) = std::str::from_utf8(nonce) {
         //get time
         if let Ok(secs_nonce) = u32::from_str_radix(&n[..8], 16) {
             //check time
-            let now = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
+            let now = unix_now()?;
             let secs_now = now.as_secs() as u32;
 
             if let Some(dur) = secs_now.checked_sub(secs_nonce) {
@@ -340,7 +352,7 @@ fn validate_nonce(nonce: &[u8]) -> Result<bool, ()> {
             }
         }
     }
-    Err(())
+    bail!("invalid nonce");
 }
 
 fn strip_prefix<'a>(search: &'a [u8], prefix: &[u8]) -> Option<&'a [u8]> {
@@ -370,7 +382,7 @@ fn to_headermap(header: &[u8]) -> Result<HashMap<&[u8], &[u8]>, ()> {
         }
         i += 1;
     }
-    sep.push(i); // same len for both Vecs
+    sep.push(i);
 
     i = 0;
     let mut ret = HashMap::new();
@@ -379,7 +391,7 @@ fn to_headermap(header: &[u8]) -> Result<HashMap<&[u8], &[u8]>, ()> {
             i += 1;
         }
         if a <= i || k <= 1 + a {
-            //keys and vals must contain one char
+            //keys and values must contain one char
             return Err(());
         }
         let key = &header[i..a];
@@ -396,12 +408,12 @@ fn to_headermap(header: &[u8]) -> Result<HashMap<&[u8], &[u8]>, ()> {
     Ok(ret)
 }
 
-fn create_nonce() -> String {
+fn create_nonce() -> Result<String> {
-    let now = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
+    let now = unix_now()?;
     let secs = now.as_secs() as u32;
     let mut h = NONCESTARTHASH.clone();
     h.consume(secs.to_be_bytes());
 
     let n = format!("{:08x}{:032x}", secs, h.compute());
-    n[..34].to_string()
+    Ok(n[..34].to_string())
 }

src/log_http.rs

@@ -6,7 +6,7 @@ pub const DEFAULT_LOG_FORMAT: &str = r#"$remote_addr "$request" $status"#;
 
 #[derive(Debug)]
 pub struct LogHttp {
-    elems: Vec<LogElement>,
+    elements: Vec<LogElement>,
 }
 
 #[derive(Debug)]
@@ -19,8 +19,8 @@ enum LogElement {
 impl LogHttp {
     pub fn data(&self, req: &Request, args: &Arc<Args>) -> HashMap<String, String> {
         let mut data = HashMap::default();
-        for elem in self.elems.iter() {
+        for element in self.elements.iter() {
-            match elem {
+            match element {
                 LogElement::Variable(name) => match name.as_str() {
                     "request" => {
                         data.insert(name.to_string(), format!("{} {}", req.method(), req.uri()));
@@ -47,12 +47,12 @@ impl LogHttp {
         data
     }
     pub fn log(&self, data: &HashMap<String, String>, err: Option<String>) {
-        if self.elems.is_empty() {
+        if self.elements.is_empty() {
             return;
         }
         let mut output = String::new();
-        for elem in self.elems.iter() {
+        for element in self.elements.iter() {
-            match elem {
+            match element {
                 LogElement::Literal(value) => output.push_str(value.as_str()),
                 LogElement::Header(name) | LogElement::Variable(name) => {
                     output.push_str(data.get(name).map(|v| v.as_str()).unwrap_or("-"))
@@ -67,23 +67,23 @@ impl LogHttp {
 }
 
 impl FromStr for LogHttp {
-    type Err = Box<dyn std::error::Error>;
+    type Err = anyhow::Error;
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let mut elems = vec![];
+        let mut elements = vec![];
         let mut is_var = false;
         let mut cache = String::new();
-        for c in format!("{} ", s).chars() {
+        for c in format!("{s} ").chars() {
             if c == '$' {
                 if !cache.is_empty() {
-                    elems.push(LogElement::Literal(cache.to_string()));
+                    elements.push(LogElement::Literal(cache.to_string()));
                 }
                 cache.clear();
                 is_var = true;
             } else if is_var && !(c.is_alphanumeric() || c == '_') {
                 if let Some(value) = cache.strip_prefix("$http_") {
-                    elems.push(LogElement::Header(value.replace('_', "-").to_string()));
+                    elements.push(LogElement::Header(value.replace('_', "-").to_string()));
                 } else if let Some(value) = cache.strip_prefix('$') {
-                    elems.push(LogElement::Variable(value.to_string()));
+                    elements.push(LogElement::Variable(value.to_string()));
                 }
                 cache.clear();
                 is_var = false;
@@ -92,8 +92,8 @@ impl FromStr for LogHttp {
         }
         let cache = cache.trim();
         if !cache.is_empty() {
-            elems.push(LogElement::Literal(cache.to_string()));
+            elements.push(LogElement::Literal(cache.to_string()));
         }
-        Ok(Self { elems })
+        Ok(Self { elements })
     }
 }

src/main.rs

@@ -6,6 +6,8 @@ mod server;
 mod streamer;
 #[cfg(feature = "tls")]
 mod tls;
+#[cfg(unix)]
+mod unix;
 mod utils;
 
 #[macro_use]
@@ -16,10 +18,12 @@ use crate::server::{Request, Server};
 #[cfg(feature = "tls")]
 use crate::tls::{TlsAcceptor, TlsStream};
 
+use anyhow::{anyhow, Result};
 use std::net::{IpAddr, SocketAddr, TcpListener as StdTcpListener};
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
 
+use args::BindAddr;
 use clap_complete::Shell;
 use futures::future::join_all;
 use tokio::net::TcpListener;
@@ -30,15 +34,16 @@ use hyper::service::{make_service_fn, service_fn};
 #[cfg(feature = "tls")]
 use rustls::ServerConfig;
 
-pub type BoxResult<T> = Result<T, Box<dyn std::error::Error>>;
-
 #[tokio::main]
 async fn main() {
-    run().await.unwrap_or_else(handle_err)
+    run().await.unwrap_or_else(|err| {
+        eprintln!("error: {err}");
+        std::process::exit(1);
+    })
 }
 
-async fn run() -> BoxResult<()> {
+async fn run() -> Result<()> {
-    logger::init().map_err(|e| format!("Failed to init logger, {}", e))?;
+    logger::init().map_err(|e| anyhow!("Failed to init logger, {e}"))?;
     let cmd = build_cli();
     let matches = cmd.get_matches();
     if let Some(generator) = matches.get_one::<Shell>("completions") {
@@ -71,15 +76,13 @@ async fn run() -> BoxResult<()> {
 fn serve(
     args: Arc<Args>,
     running: Arc<AtomicBool>,
-) -> BoxResult<Vec<JoinHandle<Result<(), hyper::Error>>>> {
+) -> Result<Vec<JoinHandle<Result<(), hyper::Error>>>> {
-    let inner = Arc::new(Server::new(args.clone(), running));
+    let inner = Arc::new(Server::init(args.clone(), running)?);
     let mut handles = vec![];
     let port = args.port;
-    for ip in args.addrs.iter() {
+    for bind_addr in args.addrs.iter() {
         let inner = inner.clone();
-        let incoming = create_addr_incoming(SocketAddr::new(*ip, port))
+        let serve_func = move |remote_addr: Option<SocketAddr>| {
-            .map_err(|e| format!("Failed to bind `{}:{}`, {}", ip, port, e))?;
-        let serve_func = move |remote_addr: SocketAddr| {
             let inner = inner.clone();
             async move {
                 Ok::<_, hyper::Error>(service_fn(move |req: Request| {
@@ -88,40 +91,62 @@ fn serve(
                 }))
             }
         };
-        match args.tls.as_ref() {
+        match bind_addr {
-            #[cfg(feature = "tls")]
+            BindAddr::Address(ip) => {
-            Some((certs, key)) => {
+                let incoming = create_addr_incoming(SocketAddr::new(*ip, port))
-                let config = ServerConfig::builder()
+                    .map_err(|e| anyhow!("Failed to bind `{ip}:{port}`, {e}"))?;
-                    .with_safe_defaults()
+                match args.tls.as_ref() {
-                    .with_no_client_auth()
+                    #[cfg(feature = "tls")]
-                    .with_single_cert(certs.clone(), key.clone())?;
+                    Some((certs, key)) => {
-                let config = Arc::new(config);
+                        let config = ServerConfig::builder()
-                let accepter = TlsAcceptor::new(config.clone(), incoming);
+                            .with_safe_defaults()
-                let new_service = make_service_fn(move |socket: &TlsStream| {
+                            .with_no_client_auth()
-                    let remote_addr = socket.remote_addr();
+                            .with_single_cert(certs.clone(), key.clone())?;
-                    serve_func(remote_addr)
+                        let config = Arc::new(config);
-                });
+                        let accepter = TlsAcceptor::new(config.clone(), incoming);
-                let server = tokio::spawn(hyper::Server::builder(accepter).serve(new_service));
+                        let new_service = make_service_fn(move |socket: &TlsStream| {
-                handles.push(server);
+                            let remote_addr = socket.remote_addr();
+                            serve_func(Some(remote_addr))
+                        });
+                        let server =
+                            tokio::spawn(hyper::Server::builder(accepter).serve(new_service));
+                        handles.push(server);
+                    }
+                    #[cfg(not(feature = "tls"))]
+                    Some(_) => {
+                        unreachable!()
+                    }
+                    None => {
+                        let new_service = make_service_fn(move |socket: &AddrStream| {
+                            let remote_addr = socket.remote_addr();
+                            serve_func(Some(remote_addr))
+                        });
+                        let server =
+                            tokio::spawn(hyper::Server::builder(incoming).serve(new_service));
+                        handles.push(server);
+                    }
+                };
             }
-            #[cfg(not(feature = "tls"))]
+            BindAddr::Path(path) => {
-            Some(_) => {
+                if path.exists() {
-                unreachable!()
+                    std::fs::remove_file(path)?;
+                }
+                #[cfg(unix)]
+                {
+                    let listener = tokio::net::UnixListener::bind(path)
+                        .map_err(|e| anyhow!("Failed to bind `{}`, {e}", path.display()))?;
+                    let acceptor = unix::UnixAcceptor::from_listener(listener);
+                    let new_service = make_service_fn(move |_| serve_func(None));
+                    let server = tokio::spawn(hyper::Server::builder(acceptor).serve(new_service));
+                    handles.push(server);
+                }
             }
-            None => {
+        }
-                let new_service = make_service_fn(move |socket: &AddrStream| {
-                    let remote_addr = socket.remote_addr();
-                    serve_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> {
+fn create_addr_incoming(addr: SocketAddr) -> Result<AddrIncoming> {
     use socket2::{Domain, Protocol, Socket, Type};
     let socket = Socket::new(Domain::for_address(addr), Type::STREAM, Some(Protocol::TCP))?;
     if addr.is_ipv6() {
@@ -136,45 +161,52 @@ fn create_addr_incoming(addr: SocketAddr) -> BoxResult<AddrIncoming> {
     Ok(incoming)
 }
 
-fn print_listening(args: Arc<Args>) -> BoxResult<()> {
+fn print_listening(args: Arc<Args>) -> Result<()> {
-    let mut addrs = vec![];
+    let mut bind_addrs = vec![];
     let (mut ipv4, mut ipv6) = (false, false);
-    for ip in args.addrs.iter() {
+    for bind_addr in args.addrs.iter() {
-        if ip.is_unspecified() {
+        match bind_addr {
-            if ip.is_ipv6() {
+            BindAddr::Address(ip) => {
-                ipv6 = true;
+                if ip.is_unspecified() {
-            } else {
+                    if ip.is_ipv6() {
-                ipv4 = true;
+                        ipv6 = true;
+                    } else {
+                        ipv4 = true;
+                    }
+                } else {
+                    bind_addrs.push(bind_addr.clone());
+                }
             }
-        } else {
+            _ => bind_addrs.push(bind_addr.clone()),
-            addrs.push(*ip);
         }
     }
     if ipv4 || ipv6 {
         let ifaces = if_addrs::get_if_addrs()
-            .map_err(|e| format!("Failed to get local interface addresses: {}", e))?;
+            .map_err(|e| anyhow!("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)
+                bind_addrs.push(BindAddr::Address(local_ip))
             }
             if ipv6 && local_ip.is_ipv6() {
-                addrs.push(local_ip)
+                bind_addrs.push(BindAddr::Address(local_ip))
             }
         }
     }
-    addrs.sort_unstable();
+    bind_addrs.sort_unstable();
-    let urls = addrs
+    let urls = bind_addrs
         .into_iter()
-        .map(|addr| match addr {
+        .map(|bind_addr| match bind_addr {
-            IpAddr::V4(_) => format!("{}:{}", addr, args.port),
+            BindAddr::Address(addr) => {
-            IpAddr::V6(_) => format!("[{}]:{}", addr, args.port),
+                let addr = match addr {
+                    IpAddr::V4(_) => format!("{}:{}", addr, args.port),
+                    IpAddr::V6(_) => format!("[{}]:{}", addr, args.port),
+                };
+                let protocol = if args.tls.is_some() { "https" } else { "http" };
+                format!("{}://{}{}", protocol, addr, args.uri_prefix)
+            }
+            BindAddr::Path(path) => path.display().to_string(),
         })
-        .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 {
@@ -182,20 +214,15 @@ fn print_listening(args: Arc<Args>) -> BoxResult<()> {
     } else {
         let info = urls
             .iter()
-            .map(|v| format!("  {}", v))
+            .map(|v| format!("  {v}"))
             .collect::<Vec<String>>()
             .join("\n");
-        println!("Listening on:\n{}\n", info);
+        println!("Listening on:\n{info}\n");
     }
 
     Ok(())
 }
 
-fn handle_err<T>(err: Box<dyn std::error::Error>) -> T {
-    eprintln!("error: {}", err);
-    std::process::exit(1);
-}
-
 async fn shutdown_signal() {
     tokio::signal::ctrl_c()
         .await

src/server.rs

@@ -1,12 +1,13 @@
 use crate::streamer::Streamer;
 use crate::utils::{decode_uri, encode_uri, get_file_name, glob, try_get_file_name};
-use crate::{Args, BoxResult};
+use crate::Args;
+use anyhow::{anyhow, Result};
 use walkdir::WalkDir;
 use xml::escape::escape_str_pcdata;
 
-use async_zip::write::{EntryOptions, ZipFileWriter};
+use async_zip::write::ZipFileWriter;
-use async_zip::Compression;
+use async_zip::{Compression, ZipEntryBuilder};
-use chrono::{TimeZone, Utc};
+use chrono::{LocalResult, TimeZone, Utc};
 use futures::TryStreamExt;
 use headers::{
     AcceptRanges, AccessControlAllowCredentials, AccessControlAllowOrigin, Connection,
@@ -29,7 +30,7 @@ use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
 use std::time::SystemTime;
 use tokio::fs::File;
-use tokio::io::{AsyncSeekExt, AsyncWrite};
+use tokio::io::{AsyncReadExt, AsyncSeekExt, AsyncWrite};
 use tokio::{fs, io};
 use tokio_util::io::StreamReader;
 use uuid::Uuid;
@@ -43,6 +44,7 @@ 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 = 65536;
+const TEXT_MAX_SIZE: u64 = 4194304; // 4M
 
 pub struct Server {
     args: Arc<Args>,
@@ -53,7 +55,7 @@ pub struct Server {
 }
 
 impl Server {
-    pub fn new(args: Arc<Args>, running: Arc<AtomicBool>) -> Self {
+    pub fn init(args: Arc<Args>, running: Arc<AtomicBool>) -> Result<Self> {
         let assets_prefix = format!("{}__dufs_v{}_", args.uri_prefix, env!("CARGO_PKG_VERSION"));
         let single_file_req_paths = if args.path_is_file {
             vec![
@@ -69,28 +71,30 @@ impl Server {
             vec![]
         };
         let html = match args.assets_path.as_ref() {
-            Some(path) => Cow::Owned(std::fs::read_to_string(path.join("index.html")).unwrap()),
+            Some(path) => Cow::Owned(std::fs::read_to_string(path.join("index.html"))?),
             None => Cow::Borrowed(INDEX_HTML),
         };
-        Self {
+        Ok(Self {
             args,
             running,
             single_file_req_paths,
             assets_prefix,
             html,
-        }
+        })
     }
 
     pub async fn call(
         self: Arc<Self>,
         req: Request,
-        addr: SocketAddr,
+        addr: Option<SocketAddr>,
     ) -> Result<Response, hyper::Error> {
         let uri = req.uri().clone();
         let assets_prefix = self.assets_prefix.clone();
         let enable_cors = self.args.enable_cors;
         let mut http_log_data = self.args.log_http.data(&req, &self.args);
-        http_log_data.insert("remote_addr".to_string(), addr.ip().to_string());
+        if let Some(addr) = addr {
+            http_log_data.insert("remote_addr".to_string(), addr.ip().to_string());
+        }
 
         let mut res = match self.clone().handle(req).await {
             Ok(res) => {
@@ -118,7 +122,7 @@ impl Server {
         Ok(res)
     }
 
-    pub async fn handle(self: Arc<Self>, req: Request) -> BoxResult<Response> {
+    pub async fn handle(self: Arc<Self>, req: Request) -> Result<Response> {
         let mut res = Response::default();
 
         let req_path = req.uri().path();
@@ -137,7 +141,16 @@ impl Server {
             self.args.auth_method.clone(),
         );
         if guard_type.is_reject() {
-            self.auth_reject(&mut res);
+            self.auth_reject(&mut res)?;
+            return Ok(res);
+        }
+
+        let query = req.uri().query().unwrap_or_default();
+        let query_params: HashMap<String, String> = form_urlencoded::parse(query.as_bytes())
+            .map(|(k, v)| (k.to_string(), v.to_string()))
+            .collect();
+
+        if method.as_str() == "WRITEABLE" {
             return Ok(res);
         }
 
@@ -167,11 +180,6 @@ impl Server {
 
         let path = path.as_path();
 
-        let query = req.uri().query().unwrap_or_default();
-        let query_params: HashMap<String, String> = form_urlencoded::parse(query.as_bytes())
-            .map(|(k, v)| (k.to_string(), v.to_string()))
-            .collect();
-
         let (is_miss, is_dir, is_file, size) = match fs::metadata(path).await.ok() {
             Some(meta) => (false, meta.is_dir(), meta.is_file(), meta.len()),
             None => (true, false, false, 0),
@@ -180,6 +188,7 @@ impl Server {
         let allow_upload = self.args.allow_upload;
         let allow_delete = self.args.allow_delete;
         let allow_search = self.args.allow_search;
+        let allow_archive = self.args.allow_archive;
         let render_index = self.args.render_index;
         let render_spa = self.args.render_spa;
         let render_try_index = self.args.render_try_index;
@@ -193,41 +202,69 @@ impl Server {
             Method::GET | Method::HEAD => {
                 if is_dir {
                     if render_try_index {
-                        if query_params.contains_key("zip") {
+                        if allow_archive && query_params.contains_key("zip") {
+                            if !allow_archive {
+                                status_not_found(&mut res);
+                                return Ok(res);
+                            }
                             self.handle_zip_dir(path, head_only, &mut res).await?;
                         } else if allow_search && query_params.contains_key("q") {
-                            self.handle_search_dir(path, &query_params, head_only, &mut res)
+                            let user = self.retrieve_user(authorization);
+                            self.handle_search_dir(path, &query_params, head_only, user, &mut res)
                                 .await?;
                         } else {
+                            let user = self.retrieve_user(authorization);
                             self.handle_render_index(
                                 path,
                                 &query_params,
                                 headers,
                                 head_only,
+                                user,
                                 &mut res,
                             )
                             .await?;
                         }
                     } else if render_index || render_spa {
-                        self.handle_render_index(path, &query_params, headers, head_only, &mut res)
+                        let user = self.retrieve_user(authorization);
-                            .await?;
+                        self.handle_render_index(
+                            path,
+                            &query_params,
+                            headers,
+                            head_only,
+                            user,
+                            &mut res,
+                        )
+                        .await?;
                     } else if query_params.contains_key("zip") {
+                        if !allow_archive {
+                            status_not_found(&mut res);
+                            return Ok(res);
+                        }
                         self.handle_zip_dir(path, head_only, &mut res).await?;
                     } else if allow_search && query_params.contains_key("q") {
-                        self.handle_search_dir(path, &query_params, head_only, &mut res)
+                        let user = self.retrieve_user(authorization);
+                        self.handle_search_dir(path, &query_params, head_only, user, &mut res)
                             .await?;
                     } else {
-                        self.handle_ls_dir(path, true, &query_params, head_only, &mut res)
+                        let user = self.retrieve_user(authorization);
+                        self.handle_ls_dir(path, true, &query_params, head_only, user, &mut res)
                             .await?;
                     }
                 } else if is_file {
-                    self.handle_send_file(path, headers, head_only, &mut res)
+                    if query_params.contains_key("edit") {
-                        .await?;
+                        let user = self.retrieve_user(authorization);
+                        self.handle_edit_file(path, head_only, user, &mut res)
+                            .await?;
+                    } else {
+                        self.handle_send_file(path, headers, head_only, &mut res)
+                            .await?;
+                    }
                 } else if render_spa {
                     self.handle_render_spa(path, headers, head_only, &mut res)
                         .await?;
                 } else if allow_upload && req_path.ends_with('/') {
-                    self.handle_ls_dir(path, false, &query_params, head_only, &mut res)
+                    let user = self.retrieve_user(authorization);
+                    self.handle_ls_dir(path, false, &query_params, head_only, user, &mut res)
                         .await?;
                 } else {
                     status_not_found(&mut res);
@@ -270,8 +307,11 @@ impl Server {
                     }
                 }
                 "MKCOL" => {
-                    if !allow_upload || !is_miss {
+                    if !allow_upload {
                         status_forbid(&mut res);
+                    } else if !is_miss {
+                        *res.status_mut() = StatusCode::METHOD_NOT_ALLOWED;
+                        *res.body_mut() = Body::from("Already exists");
                     } else {
                         self.handle_mkcol(path, &mut res).await?;
                     }
@@ -317,12 +357,7 @@ impl Server {
         Ok(res)
     }
 
-    async fn handle_upload(
+    async fn handle_upload(&self, path: &Path, mut req: Request, res: &mut Response) -> Result<()> {
-        &self,
-        path: &Path,
-        mut req: Request,
-        res: &mut Response,
-    ) -> BoxResult<()> {
         ensure_path_parent(path).await?;
 
         let mut file = match fs::File::create(&path).await {
@@ -347,7 +382,7 @@ impl Server {
         Ok(())
     }
 
-    async fn handle_delete(&self, path: &Path, is_dir: bool, res: &mut Response) -> BoxResult<()> {
+    async fn handle_delete(&self, path: &Path, is_dir: bool, res: &mut Response) -> Result<()> {
         match is_dir {
             true => fs::remove_dir_all(path).await?,
             false => fs::remove_file(path).await?,
@@ -363,8 +398,9 @@ impl Server {
         exist: bool,
         query_params: &HashMap<String, String>,
         head_only: bool,
+        user: Option<String>,
         res: &mut Response,
-    ) -> BoxResult<()> {
+    ) -> Result<()> {
         let mut paths = vec![];
         if exist {
             paths = match self.list_dir(path, path).await {
@@ -375,7 +411,7 @@ impl Server {
                 }
             }
         };
-        self.send_index(path, paths, exist, query_params, head_only, res)
+        self.send_index(path, paths, exist, query_params, head_only, user, res)
     }
 
     async fn handle_search_dir(
@@ -383,55 +419,64 @@ impl Server {
         path: &Path,
         query_params: &HashMap<String, String>,
         head_only: bool,
+        user: Option<String>,
         res: &mut Response,
-    ) -> BoxResult<()> {
+    ) -> Result<()> {
         let mut paths: Vec<PathItem> = vec![];
-        let path_buf = path.to_path_buf();
+        let search = query_params
-        let hidden = Arc::new(self.args.hidden.to_vec());
+            .get("q")
-        let hidden = hidden.clone();
+            .ok_or_else(|| anyhow!("invalid q"))?
-        let running = self.running.clone();
+            .to_lowercase();
-        let search = query_params.get("q").unwrap().to_lowercase();
+        if !search.is_empty() {
-        let search_paths = tokio::task::spawn_blocking(move || {
+            let path_buf = path.to_path_buf();
-            let mut it = WalkDir::new(&path_buf).into_iter();
+            let hidden = Arc::new(self.args.hidden.to_vec());
-            let mut paths: Vec<PathBuf> = vec![];
+            let hidden = hidden.clone();
-            while let Some(Ok(entry)) = it.next() {
+            let running = self.running.clone();
-                if !running.load(Ordering::SeqCst) {
+            let search_paths = tokio::task::spawn_blocking(move || {
-                    break;
+                let mut it = WalkDir::new(&path_buf).into_iter();
-                }
+                let mut paths: Vec<PathBuf> = vec![];
-                let entry_path = entry.path();
+                while let Some(Ok(entry)) = it.next() {
-                let base_name = get_file_name(entry_path);
+                    if !running.load(Ordering::SeqCst) {
-                let file_type = entry.file_type();
+                        break;
-                if is_hidden(&hidden, base_name) {
-                    if file_type.is_dir() {
-                        it.skip_current_dir();
                     }
-                    continue;
+                    let entry_path = entry.path();
+                    let base_name = get_file_name(entry_path);
+                    let file_type = entry.file_type();
+                    let mut is_dir_type: bool = file_type.is_dir();
+                    if file_type.is_symlink() {
+                        match std::fs::symlink_metadata(entry_path) {
+                            Ok(meta) => {
+                                is_dir_type = meta.is_dir();
+                            }
+                            Err(_) => {
+                                continue;
+                            }
+                        }
+                    }
+                    if is_hidden(&hidden, base_name, is_dir_type) {
+                        if file_type.is_dir() {
+                            it.skip_current_dir();
+                        }
+                        continue;
+                    }
+                    if !base_name.to_lowercase().contains(&search) {
+                        continue;
+                    }
+                    paths.push(entry_path.to_path_buf());
                 }
-                if !base_name.to_lowercase().contains(&search) {
+                paths
-                    continue;
+            })
+            .await?;
+            for search_path in search_paths.into_iter() {
+                if let Ok(Some(item)) = self.to_pathitem(search_path, path.to_path_buf()).await {
+                    paths.push(item);
                 }
-                if entry.path().symlink_metadata().is_err() {
-                    continue;
-                }
-                paths.push(entry_path.to_path_buf());
-            }
-            paths
-        })
-        .await?;
-        for search_path in search_paths.into_iter() {
-            if let Ok(Some(item)) = self.to_pathitem(search_path, path.to_path_buf()).await {
-                paths.push(item);
             }
         }
-        self.send_index(path, paths, true, query_params, head_only, res)
+        self.send_index(path, paths, true, query_params, head_only, user, res)
     }
 
-    async fn handle_zip_dir(
+    async fn handle_zip_dir(&self, path: &Path, head_only: bool, res: &mut Response) -> Result<()> {
-        &self,
-        path: &Path,
-        head_only: bool,
-        res: &mut Response,
-    ) -> BoxResult<()> {
         let (mut writer, reader) = tokio::io::duplex(BUF_SIZE);
         let filename = try_get_file_name(path)?;
         res.headers_mut().insert(
@@ -439,8 +484,7 @@ impl Server {
             HeaderValue::from_str(&format!(
                 "attachment; filename=\"{}.zip\"",
                 encode_uri(filename),
-            ))
+            ))?,
-            .unwrap(),
         );
         res.headers_mut()
             .insert("content-type", HeaderValue::from_static("application/zip"));
@@ -466,8 +510,9 @@ impl Server {
         query_params: &HashMap<String, String>,
         headers: &HeaderMap<HeaderValue>,
         head_only: bool,
+        user: Option<String>,
         res: &mut Response,
-    ) -> BoxResult<()> {
+    ) -> Result<()> {
         let index_path = path.join(INDEX_NAME);
         if fs::metadata(&index_path)
             .await
@@ -478,7 +523,7 @@ impl Server {
             self.handle_send_file(&index_path, headers, head_only, res)
                 .await?;
         } else if self.args.render_try_index {
-            self.handle_ls_dir(path, true, query_params, head_only, res)
+            self.handle_ls_dir(path, true, query_params, head_only, user, res)
                 .await?;
         } else {
             status_not_found(res)
@@ -492,7 +537,7 @@ impl Server {
         headers: &HeaderMap<HeaderValue>,
         head_only: bool,
         res: &mut Response,
-    ) -> BoxResult<()> {
+    ) -> Result<()> {
         if path.extension().is_none() {
             let path = self.args.path.join(INDEX_NAME);
             self.handle_send_file(&path, headers, head_only, res)
@@ -508,7 +553,7 @@ impl Server {
         req_path: &str,
         headers: &HeaderMap<HeaderValue>,
         res: &mut Response,
-    ) -> BoxResult<bool> {
+    ) -> Result<bool> {
         if let Some(name) = req_path.strip_prefix(&self.assets_prefix) {
             match self.args.assets_path.as_ref() {
                 Some(assets_path) => {
@@ -554,7 +599,7 @@ impl Server {
         headers: &HeaderMap<HeaderValue>,
         head_only: bool,
         res: &mut Response,
-    ) -> BoxResult<()> {
+    ) -> Result<()> {
         let (file, meta) = tokio::join!(fs::File::open(path), fs::metadata(path),);
         let (mut file, meta) = (file?, meta?);
         let mut use_range = true;
@@ -593,7 +638,7 @@ impl Server {
             None
         };
 
-        if let Some(mime) = mime_guess::from_path(&path).first() {
+        if let Some(mime) = mime_guess::from_path(path).first() {
             res.headers_mut().typed_insert(ContentType::from(mime));
         } else {
             res.headers_mut().insert(
@@ -605,8 +650,7 @@ impl Server {
         let filename = try_get_file_name(path)?;
         res.headers_mut().insert(
             CONTENT_DISPOSITION,
-            HeaderValue::from_str(&format!("inline; filename=\"{}\"", encode_uri(filename),))
+            HeaderValue::from_str(&format!("inline; filename=\"{}\"", encode_uri(filename),))?,
-                .unwrap(),
         );
 
         res.headers_mut().typed_insert(AcceptRanges::bytes());
@@ -625,9 +669,9 @@ impl Server {
                 *res.status_mut() = StatusCode::PARTIAL_CONTENT;
                 let content_range = format!("bytes {}-{}/{}", range.start, end, size);
                 res.headers_mut()
-                    .insert(CONTENT_RANGE, content_range.parse().unwrap());
+                    .insert(CONTENT_RANGE, content_range.parse()?);
                 res.headers_mut()
-                    .insert(CONTENT_LENGTH, format!("{}", part_size).parse().unwrap());
+                    .insert(CONTENT_LENGTH, format!("{part_size}").parse()?);
                 if head_only {
                     return Ok(());
                 }
@@ -635,11 +679,11 @@ impl Server {
             } else {
                 *res.status_mut() = StatusCode::RANGE_NOT_SATISFIABLE;
                 res.headers_mut()
-                    .insert(CONTENT_RANGE, format!("bytes */{}", size).parse().unwrap());
+                    .insert(CONTENT_RANGE, format!("bytes */{size}").parse()?);
             }
         } else {
             res.headers_mut()
-                .insert(CONTENT_LENGTH, format!("{}", size).parse().unwrap());
+                .insert(CONTENT_LENGTH, format!("{size}").parse()?);
             if head_only {
                 return Ok(());
             }
@@ -649,12 +693,50 @@ impl Server {
         Ok(())
     }
 
+    async fn handle_edit_file(
+        &self,
+        path: &Path,
+        head_only: bool,
+        user: Option<String>,
+        res: &mut Response,
+    ) -> Result<()> {
+        let (file, meta) = tokio::join!(fs::File::open(path), fs::metadata(path),);
+        let (file, meta) = (file?, meta?);
+        let href = format!("/{}", normalize_path(path.strip_prefix(&self.args.path)?));
+        let mut buffer: Vec<u8> = vec![];
+        file.take(1024).read_to_end(&mut buffer).await?;
+        let editable = meta.len() <= TEXT_MAX_SIZE && content_inspector::inspect(&buffer).is_text();
+        let data = EditData {
+            href,
+            kind: DataKind::Edit,
+            uri_prefix: self.args.uri_prefix.clone(),
+            allow_upload: self.args.allow_upload,
+            allow_delete: self.args.allow_delete,
+            auth: self.args.auth.valid(),
+            user,
+            editable,
+        };
+        res.headers_mut()
+            .typed_insert(ContentType::from(mime_guess::mime::TEXT_HTML_UTF_8));
+        let output = self
+            .html
+            .replace("__ASSERTS_PREFIX__", &self.assets_prefix)
+            .replace("__INDEX_DATA__", &serde_json::to_string(&data)?);
+        res.headers_mut()
+            .typed_insert(ContentLength(output.as_bytes().len() as u64));
+        if head_only {
+            return Ok(());
+        }
+        *res.body_mut() = output.into();
+        Ok(())
+    }
+
     async fn handle_propfind_dir(
         &self,
         path: &Path,
         headers: &HeaderMap<HeaderValue>,
         res: &mut Response,
-    ) -> BoxResult<()> {
+    ) -> Result<()> {
         let depth: u32 = match headers.get("depth") {
             Some(v) => match v.to_str().ok().and_then(|v| v.parse().ok()) {
                 Some(v) => v,
@@ -665,7 +747,10 @@ impl Server {
             },
             None => 1,
         };
-        let mut paths = vec![self.to_pathitem(path, &self.args.path).await?.unwrap()];
+        let mut paths = match self.to_pathitem(path, &self.args.path).await? {
+            Some(v) => vec![v],
+            None => vec![],
+        };
         if depth != 0 {
             match self.list_dir(path, &self.args.path).await {
                 Ok(child) => paths.extend(child),
@@ -686,7 +771,7 @@ impl Server {
         Ok(())
     }
 
-    async fn handle_propfind_file(&self, path: &Path, res: &mut Response) -> BoxResult<()> {
+    async fn handle_propfind_file(&self, path: &Path, res: &mut Response) -> Result<()> {
         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 {
@@ -695,13 +780,13 @@ impl Server {
         Ok(())
     }
 
-    async fn handle_mkcol(&self, path: &Path, res: &mut Response) -> BoxResult<()> {
+    async fn handle_mkcol(&self, path: &Path, res: &mut Response) -> Result<()> {
         fs::create_dir_all(path).await?;
         *res.status_mut() = StatusCode::CREATED;
         Ok(())
     }
 
-    async fn handle_copy(&self, path: &Path, req: &Request, res: &mut Response) -> BoxResult<()> {
+    async fn handle_copy(&self, path: &Path, req: &Request, res: &mut Response) -> Result<()> {
         let dest = match self.extract_dest(req, res) {
             Some(dest) => dest,
             None => {
@@ -723,7 +808,7 @@ impl Server {
         Ok(())
     }
 
-    async fn handle_move(&self, path: &Path, req: &Request, res: &mut Response) -> BoxResult<()> {
+    async fn handle_move(&self, path: &Path, req: &Request, res: &mut Response) -> Result<()> {
         let dest = match self.extract_dest(req, res) {
             Some(dest) => dest,
             None => {
@@ -739,7 +824,7 @@ impl Server {
         Ok(())
     }
 
-    async fn handle_lock(&self, req_path: &str, auth: bool, res: &mut Response) -> BoxResult<()> {
+    async fn handle_lock(&self, req_path: &str, auth: bool, res: &mut Response) -> Result<()> {
         let token = if auth {
             format!("opaquelocktoken:{}", Uuid::new_v4())
         } else {
@@ -751,35 +836,34 @@ impl Server {
             HeaderValue::from_static("application/xml; charset=utf-8"),
         );
         res.headers_mut()
-            .insert("lock-token", format!("<{}>", token).parse().unwrap());
+            .insert("lock-token", format!("<{token}>").parse()?);
 
         *res.body_mut() = Body::from(format!(
             r#"<?xml version="1.0" encoding="utf-8"?>
 <D:prop xmlns:D="DAV:"><D:lockdiscovery><D:activelock>
-<D:locktoken><D:href>{}</D:href></D:locktoken>
+<D:locktoken><D:href>{token}</D:href></D:locktoken>
-<D:lockroot><D:href>{}</D:href></D:lockroot>
+<D:lockroot><D:href>{req_path}</D:href></D:lockroot>
-</D:activelock></D:lockdiscovery></D:prop>"#,
+</D:activelock></D:lockdiscovery></D:prop>"#
-            token, req_path
         ));
         Ok(())
     }
 
-    async fn handle_proppatch(&self, req_path: &str, res: &mut Response) -> BoxResult<()> {
+    async fn handle_proppatch(&self, req_path: &str, res: &mut Response) -> Result<()> {
         let output = format!(
             r#"<D:response>
-<D:href>{}</D:href>
+<D:href>{req_path}</D:href>
 <D:propstat>
 <D:prop>
 </D:prop>
 <D:status>HTTP/1.1 403 Forbidden</D:status>
 </D:propstat>
-</D:response>"#,
+</D:response>"#
-            req_path
         );
         res_multistatus(res, &output);
         Ok(())
     }
 
+    #[allow(clippy::too_many_arguments)]
     fn send_index(
         &self,
         path: &Path,
@@ -787,8 +871,9 @@ impl Server {
         exist: bool,
         query_params: &HashMap<String, String>,
         head_only: bool,
+        user: Option<String>,
         res: &mut Response,
-    ) -> BoxResult<()> {
+    ) -> Result<()> {
         if let Some(sort) = query_params.get("sort") {
             if sort == "name" {
                 paths.sort_by(|v1, v2| {
@@ -809,23 +894,53 @@ impl Server {
         } else {
             paths.sort_unstable();
         }
+        if query_params.contains_key("simple") {
+            let output = paths
+                .into_iter()
+                .map(|v| {
+                    if v.is_dir() {
+                        format!("{}/\n", v.name)
+                    } else {
+                        format!("{}\n", v.name)
+                    }
+                })
+                .collect::<Vec<String>>()
+                .join("");
+            res.headers_mut()
+                .typed_insert(ContentType::from(mime_guess::mime::TEXT_HTML_UTF_8));
+            res.headers_mut()
+                .typed_insert(ContentLength(output.as_bytes().len() as u64));
+            *res.body_mut() = output.into();
+            if head_only {
+                return Ok(());
+            }
+            return Ok(());
+        }
         let href = format!("/{}", normalize_path(path.strip_prefix(&self.args.path)?));
         let data = IndexData {
+            kind: DataKind::Index,
             href,
             uri_prefix: self.args.uri_prefix.clone(),
-            paths,
             allow_upload: self.args.allow_upload,
             allow_delete: self.args.allow_delete,
             allow_search: self.args.allow_search,
+            allow_archive: self.args.allow_archive,
             dir_exists: exist,
+            auth: self.args.auth.valid(),
+            user,
+            paths,
+        };
+        let output = if query_params.contains_key("json") {
+            res.headers_mut()
+                .typed_insert(ContentType::from(mime_guess::mime::APPLICATION_JSON));
+            serde_json::to_string_pretty(&data)?
+        } else {
+            res.headers_mut()
+                .typed_insert(ContentType::from(mime_guess::mime::TEXT_HTML_UTF_8));
+            self.html
+                .replace("__ASSERTS_PREFIX__", &self.assets_prefix)
+                .replace("__INDEX_DATA__", &serde_json::to_string(&data)?)
         };
-        let data = serde_json::to_string(&data).unwrap();
-        let output = self
-            .html
-            .replace("__ASSERTS_PREFIX__", &self.assets_prefix)
-            .replace("__INDEX_DATA__", &data);
-        res.headers_mut()
-            .typed_insert(ContentType::from(mime_guess::mime::TEXT_HTML_UTF_8));
         res.headers_mut()
             .typed_insert(ContentLength(output.as_bytes().len() as u64));
         if head_only {
@@ -835,13 +950,13 @@ impl Server {
         Ok(())
     }
 
-    fn auth_reject(&self, res: &mut Response) {
+    fn auth_reject(&self, res: &mut Response) -> Result<()> {
-        let value = self.args.auth_method.www_auth(false);
+        let value = self.args.auth_method.www_auth(false)?;
         set_webdav_headers(res);
         res.headers_mut().typed_insert(Connection::close());
-        res.headers_mut()
+        res.headers_mut().insert(WWW_AUTHENTICATE, value.parse()?);
-            .insert(WWW_AUTHENTICATE, value.parse().unwrap());
         *res.status_mut() = StatusCode::UNAUTHORIZED;
+        Ok(())
     }
 
     async fn is_root_contained(&self, path: &Path) -> bool {
@@ -892,7 +1007,11 @@ impl Server {
     }
 
     fn extract_path(&self, path: &str) -> Option<PathBuf> {
-        let decoded_path = decode_uri(&path[1..])?;
+        let mut slash_stripped_path = path;
+        while let Some(p) = slash_stripped_path.strip_prefix('/') {
+            slash_stripped_path = p
+        }
+        let decoded_path = decode_uri(slash_stripped_path)?;
         let slashes_switched = if cfg!(windows) {
             decoded_path.replace('/', "\\")
         } else {
@@ -902,7 +1021,7 @@ impl Server {
             Some(path) => path,
             None => return None,
         };
-        Some(self.args.path.join(&stripped_path))
+        Some(self.args.path.join(stripped_path))
     }
 
     fn strip_path_prefix<'a, P: AsRef<Path>>(&self, path: &'a P) -> Option<&'a Path> {
@@ -914,29 +1033,24 @@ impl Server {
         }
     }
 
-    async fn list_dir(&self, entry_path: &Path, base_path: &Path) -> BoxResult<Vec<PathItem>> {
+    async fn list_dir(&self, entry_path: &Path, base_path: &Path) -> Result<Vec<PathItem>> {
         let mut paths: Vec<PathItem> = vec![];
         let mut rd = fs::read_dir(entry_path).await?;
         while let Ok(Some(entry)) = rd.next_entry().await {
             let entry_path = entry.path();
             let base_name = get_file_name(&entry_path);
-            if is_hidden(&self.args.hidden, base_name) {
-                continue;
-            }
             if let Ok(Some(item)) = self.to_pathitem(entry_path.as_path(), base_path).await {
+                if is_hidden(&self.args.hidden, base_name, item.is_dir()) {
+                    continue;
+                }
                 paths.push(item);
             }
         }
         Ok(paths)
     }
 
-    async fn to_pathitem<P: AsRef<Path>>(
+    async fn to_pathitem<P: AsRef<Path>>(&self, path: P, base_path: P) -> Result<Option<PathItem>> {
-        &self,
-        path: P,
-        base_path: P,
-    ) -> BoxResult<Option<PathItem>> {
         let path = path.as_ref();
-        let rel_path = path.strip_prefix(base_path).unwrap();
         let (meta, meta2) = tokio::join!(fs::metadata(&path), fs::symlink_metadata(&path));
         let (meta, meta2) = (meta?, meta2?);
         let is_symlink = meta2.is_symlink();
@@ -955,6 +1069,7 @@ impl Server {
             PathType::Dir | PathType::SymlinkDir => None,
             PathType::File | PathType::SymlinkFile => Some(meta.len()),
         };
+        let rel_path = path.strip_prefix(base_path)?;
         let name = normalize_path(rel_path);
         Ok(Some(PathItem {
             path_type,
@@ -963,17 +1078,43 @@ impl Server {
             size,
         }))
     }
+
+    fn retrieve_user(&self, authorization: Option<&HeaderValue>) -> Option<String> {
+        self.args.auth_method.get_user(authorization?)
+    }
+}
+
+#[derive(Debug, Serialize)]
+enum DataKind {
+    Index,
+    Edit,
 }
 
 #[derive(Debug, Serialize)]
 struct IndexData {
     href: String,
+    kind: DataKind,
     uri_prefix: String,
-    paths: Vec<PathItem>,
     allow_upload: bool,
     allow_delete: bool,
     allow_search: bool,
+    allow_archive: bool,
     dir_exists: bool,
+    auth: bool,
+    user: Option<String>,
+    paths: Vec<PathItem>,
+}
+
+#[derive(Debug, Serialize)]
+struct EditData {
+    href: String,
+    kind: DataKind,
+    uri_prefix: String,
+    allow_upload: bool,
+    allow_delete: bool,
+    auth: bool,
+    user: Option<String>,
+    editable: bool,
 }
 
 #[derive(Debug, Serialize, Eq, PartialEq, Ord, PartialOrd)]
@@ -990,7 +1131,10 @@ impl PathItem {
     }
 
     pub fn to_dav_xml(&self, prefix: &str) -> String {
-        let mtime = Utc.timestamp_millis(self.mtime as i64).to_rfc2822();
+        let mtime = match Utc.timestamp_millis_opt(self.mtime as i64) {
+            LocalResult::Single(v) => v.to_rfc2822(),
+            _ => String::new(),
+        };
         let mut href = encode_uri(&format!("{}{}", prefix, &self.name));
         if self.is_dir() && !href.ends_with('/') {
             href.push('/');
@@ -999,17 +1143,16 @@ impl PathItem {
         match self.path_type {
             PathType::Dir | PathType::SymlinkDir => format!(
                 r#"<D:response>
-<D:href>{}</D:href>
+<D:href>{href}</D:href>
 <D:propstat>
 <D:prop>
-<D:displayname>{}</D:displayname>
+<D:displayname>{displayname}</D:displayname>
-<D:getlastmodified>{}</D:getlastmodified>
+<D:getlastmodified>{mtime}</D:getlastmodified>
 <D:resourcetype><D:collection/></D:resourcetype>
 </D:prop>
 <D:status>HTTP/1.1 200 OK</D:status>
 </D:propstat>
-</D:response>"#,
+</D:response>"#
-                href, displayname, mtime
             ),
             PathType::File | PathType::SymlinkFile => format!(
                 r#"<D:response>
@@ -1046,7 +1189,7 @@ enum PathType {
 
 fn to_timestamp(time: &SystemTime) -> u64 {
     time.duration_since(SystemTime::UNIX_EPOCH)
-        .unwrap()
+        .unwrap_or_default()
         .as_millis() as u64
 }
 
@@ -1059,7 +1202,7 @@ fn normalize_path<P: AsRef<Path>>(path: P) -> String {
     }
 }
 
-async fn ensure_path_parent(path: &Path) -> BoxResult<()> {
+async fn ensure_path_parent(path: &Path) -> Result<()> {
     if let Some(parent) = path.parent() {
         if fs::symlink_metadata(parent).await.is_err() {
             fs::create_dir_all(&parent).await?;
@@ -1098,9 +1241,8 @@ fn res_multistatus(res: &mut Response, content: &str) {
     *res.body_mut() = Body::from(format!(
         r#"<?xml version="1.0" encoding="utf-8" ?>
 <D:multistatus xmlns:D="DAV:">
-{}
+{content}
 </D:multistatus>"#,
-        content,
     ));
 }
 
@@ -1109,7 +1251,7 @@ async fn zip_dir<W: AsyncWrite + Unpin>(
     dir: &Path,
     hidden: &[String],
     running: Arc<AtomicBool>,
-) -> BoxResult<()> {
+) -> Result<()> {
     let mut writer = ZipFileWriter::new(writer);
     let hidden = Arc::new(hidden.to_vec());
     let hidden = hidden.clone();
@@ -1124,7 +1266,18 @@ async fn zip_dir<W: AsyncWrite + Unpin>(
             let entry_path = entry.path();
             let base_name = get_file_name(entry_path);
             let file_type = entry.file_type();
-            if is_hidden(&hidden, base_name) {
+            let mut is_dir_type: bool = file_type.is_dir();
+            if file_type.is_symlink() {
+                match std::fs::symlink_metadata(entry_path) {
+                    Ok(meta) => {
+                        is_dir_type = meta.is_dir();
+                    }
+                    Err(_) => {
+                        continue;
+                    }
+                }
+            }
+            if is_hidden(&hidden, base_name, is_dir_type) {
                 if file_type.is_dir() {
                     it.skip_current_dir();
                 }
@@ -1146,10 +1299,10 @@ async fn zip_dir<W: AsyncWrite + Unpin>(
             Some(v) => v,
             None => continue,
         };
-        let entry_options =
+        let builder =
-            EntryOptions::new(filename.to_owned(), Compression::Deflate).unix_permissions(0o644);
+            ZipEntryBuilder::new(filename.into(), Compression::Deflate).unix_permissions(0o644);
         let mut file = File::open(&zip_path).await?;
-        let mut file_writer = writer.write_entry_stream(entry_options).await?;
+        let mut file_writer = writer.write_entry_stream(builder).await?;
         io::copy(&mut file, &mut file_writer).await?;
         file_writer.close().await?;
     }
@@ -1161,9 +1314,7 @@ fn extract_cache_headers(meta: &Metadata) -> Option<(ETag, LastModified)> {
     let mtime = meta.modified().ok()?;
     let timestamp = to_timestamp(&mtime);
     let size = meta.len();
-    let etag = format!(r#""{}-{}""#, timestamp, size)
+    let etag = format!(r#""{timestamp}-{size}""#).parse::<ETag>().ok()?;
-        .parse::<ETag>()
-        .unwrap();
     let last_modified = LastModified::from(mtime);
     Some((etag, last_modified))
 }
@@ -1178,11 +1329,11 @@ 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();
+    let units = sp.next()?;
     if units == "bytes" {
         let range = sp.next()?;
         let mut sp_range = range.splitn(2, '-');
-        let start: u64 = sp_range.next().unwrap().parse().ok()?;
+        let start: u64 = sp_range.next()?.parse().ok()?;
         let end: Option<u64> = if let Some(end) = sp_range.next() {
             if end.is_empty() {
                 None
@@ -1212,8 +1363,15 @@ fn status_no_content(res: &mut Response) {
     *res.status_mut() = StatusCode::NO_CONTENT;
 }
 
-fn is_hidden(hidden: &[String], file_name: &str) -> bool {
+fn is_hidden(hidden: &[String], file_name: &str, is_dir_type: bool) -> bool {
-    hidden.iter().any(|v| glob(v, file_name))
+    hidden.iter().any(|v| {
+        if is_dir_type {
+            if let Some(x) = v.strip_suffix('/') {
+                return glob(x, file_name);
+            }
+        }
+        glob(v, file_name)
+    })
 }
 
 fn set_webdav_headers(res: &mut Response) {

src/tls.rs

@@ -1,3 +1,4 @@
+use anyhow::{anyhow, bail, Result};
 use core::task::{Context, Poll};
 use futures::ready;
 use hyper::server::accept::Accept;
@@ -5,6 +6,7 @@ use hyper::server::conn::{AddrIncoming, AddrStream};
 use rustls::{Certificate, PrivateKey};
 use std::future::Future;
 use std::net::SocketAddr;
+use std::path::Path;
 use std::pin::Pin;
 use std::sync::Arc;
 use std::{fs, io};
@@ -123,29 +125,30 @@ impl Accept for TlsAcceptor {
 }
 
 // Load public certificate from file.
-pub fn load_certs(filename: &str) -> Result<Vec<Certificate>, Box<dyn std::error::Error>> {
+pub fn load_certs<T: AsRef<Path>>(filename: T) -> Result<Vec<Certificate>> {
     // Open certificate file.
-    let cert_file = fs::File::open(&filename)
+    let cert_file = fs::File::open(filename.as_ref())
-        .map_err(|e| format!("Failed to access `{}`, {}", &filename, e))?;
+        .map_err(|e| anyhow!("Failed to access `{}`, {e}", filename.as_ref().display()))?;
     let mut reader = io::BufReader::new(cert_file);
 
     // Load and return certificate.
-    let certs = rustls_pemfile::certs(&mut reader).map_err(|_| "Failed to load certificate")?;
+    let certs =
+        rustls_pemfile::certs(&mut reader).map_err(|_| anyhow!("Failed to load certificate"))?;
     if certs.is_empty() {
-        return Err("No supported certificate in file".into());
+        bail!("No supported certificate in file");
     }
     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>> {
+pub fn load_private_key<T: AsRef<Path>>(filename: T) -> Result<PrivateKey> {
-    let key_file = fs::File::open(&filename)
+    let key_file = fs::File::open(filename.as_ref())
-        .map_err(|e| format!("Failed to access `{}`, {}", &filename, e))?;
+        .map_err(|e| anyhow!("Failed to access `{}`, {e}", filename.as_ref().display()))?;
     let mut reader = io::BufReader::new(key_file);
 
     // 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))?
+        .map_err(|e| anyhow!("There was a problem with reading private key: {e}"))?
         .into_iter()
         .find_map(|item| match item {
             rustls_pemfile::Item::RSAKey(key)
@@ -153,7 +156,7 @@ pub fn load_private_key(filename: &str) -> Result<PrivateKey, Box<dyn std::error
             | rustls_pemfile::Item::ECKey(key) => Some(key),
             _ => None,
         })
-        .ok_or("No supported private key in file")?;
+        .ok_or_else(|| anyhow!("No supported private key in file"))?;
 
     Ok(PrivateKey(keys))
 }

src/unix.rs

@@ -0,0 +1,31 @@
+use hyper::server::accept::Accept;
+use tokio::net::UnixListener;
+
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+pub struct UnixAcceptor {
+    inner: UnixListener,
+}
+
+impl UnixAcceptor {
+    pub fn from_listener(listener: UnixListener) -> Self {
+        Self { inner: listener }
+    }
+}
+
+impl Accept for UnixAcceptor {
+    type Conn = tokio::net::UnixStream;
+    type Error = std::io::Error;
+
+    fn poll_accept(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<Self::Conn, Self::Error>>> {
+        match self.inner.poll_accept(cx) {
+            Poll::Pending => Poll::Pending,
+            Poll::Ready(Ok((socket, _addr))) => Poll::Ready(Some(Ok(socket))),
+            Poll::Ready(Err(err)) => Poll::Ready(Some(Err(err))),
+        }
+    }
+}

src/utils.rs

@@ -1,5 +1,15 @@
-use crate::BoxResult;
+use anyhow::{anyhow, Result};
-use std::{borrow::Cow, path::Path};
+use std::{
+    borrow::Cow,
+    path::Path,
+    time::{Duration, SystemTime, UNIX_EPOCH},
+};
+
+pub fn unix_now() -> Result<Duration> {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map_err(|err| anyhow!("Invalid system time, {err}"))
+}
 
 pub fn encode_uri(v: &str) -> String {
     let parts: Vec<_> = v.split('/').map(urlencoding::encode).collect();
@@ -18,10 +28,10 @@ pub fn get_file_name(path: &Path) -> &str {
         .unwrap_or_default()
 }
 
-pub fn try_get_file_name(path: &Path) -> BoxResult<&str> {
+pub fn try_get_file_name(path: &Path) -> Result<&str> {
     path.file_name()
         .and_then(|v| v.to_str())
-        .ok_or_else(|| format!("Failed to get file name of `{}`", path.display()).into())
+        .ok_or_else(|| anyhow!("Failed to get file name of `{}`", path.display()))
 }
 
 pub fn glob(source: &str, target: &str) -> bool {

tests/allow.rs

@@ -20,6 +20,13 @@ fn default_not_allow_delete(server: TestServer) -> Result<(), Error> {
     Ok(())
 }
 
+#[rstest]
+fn default_not_allow_archive(server: TestServer) -> Result<(), Error> {
+    let resp = reqwest::blocking::get(format!("{}?zip", server.url()))?;
+    assert_eq!(resp.status(), 404);
+    Ok(())
+}
+
 #[rstest]
 fn default_not_exist_dir(server: TestServer) -> Result<(), Error> {
     let resp = reqwest::blocking::get(format!("{}404/", server.url()))?;
@@ -71,3 +78,15 @@ fn allow_search(#[with(&["--allow-search"])] server: TestServer) -> Result<(), E
     }
     Ok(())
 }
+
+#[rstest]
+fn allow_archive(#[with(&["--allow-archive"])] server: TestServer) -> Result<(), Error> {
+    let resp = reqwest::blocking::get(format!("{}?zip", server.url()))?;
+    assert_eq!(resp.status(), 200);
+    assert_eq!(
+        resp.headers().get("content-type").unwrap(),
+        "application/zip"
+    );
+    assert!(resp.headers().contains_key("content-disposition"));
+    Ok(())
+}

tests/assets.rs

@@ -11,13 +11,13 @@ use std::process::{Command, Stdio};
 fn assets(server: TestServer) -> Result<(), Error> {
     let ver = env!("CARGO_PKG_VERSION");
     let resp = reqwest::blocking::get(server.url())?;
-    let index_js = format!("/__dufs_v{}_index.js", ver);
+    let index_js = format!("/__dufs_v{ver}_index.js");
-    let index_css = format!("/__dufs_v{}_index.css", ver);
+    let index_css = format!("/__dufs_v{ver}_index.css");
-    let favicon_ico = format!("/__dufs_v{}_favicon.ico", ver);
+    let favicon_ico = format!("/__dufs_v{ver}_favicon.ico");
     let text = resp.text()?;
-    assert!(text.contains(&format!(r#"href="{}""#, index_css)));
+    assert!(text.contains(&format!(r#"href="{index_css}""#)));
-    assert!(text.contains(&format!(r#"href="{}""#, favicon_ico)));
+    assert!(text.contains(&format!(r#"href="{favicon_ico}""#)));
-    assert!(text.contains(&format!(r#"src="{}""#, index_js)));
+    assert!(text.contains(&format!(r#"src="{index_js}""#)));
     Ok(())
 }
 
@@ -67,13 +67,13 @@ fn asset_ico(server: TestServer) -> Result<(), Error> {
 fn assets_with_prefix(#[with(&["--path-prefix", "xyz"])] server: TestServer) -> Result<(), Error> {
     let ver = env!("CARGO_PKG_VERSION");
     let resp = reqwest::blocking::get(format!("{}xyz/", server.url()))?;
-    let index_js = format!("/xyz/__dufs_v{}_index.js", ver);
+    let index_js = format!("/xyz/__dufs_v{ver}_index.js");
-    let index_css = format!("/xyz/__dufs_v{}_index.css", ver);
+    let index_css = format!("/xyz/__dufs_v{ver}_index.css");
-    let favicon_ico = format!("/xyz/__dufs_v{}_favicon.ico", ver);
+    let favicon_ico = format!("/xyz/__dufs_v{ver}_favicon.ico");
     let text = resp.text()?;
-    assert!(text.contains(&format!(r#"href="{}""#, index_css)));
+    assert!(text.contains(&format!(r#"href="{index_css}""#)));
-    assert!(text.contains(&format!(r#"href="{}""#, favicon_ico)));
+    assert!(text.contains(&format!(r#"href="{favicon_ico}""#)));
-    assert!(text.contains(&format!(r#"src="{}""#, index_js)));
+    assert!(text.contains(&format!(r#"src="{index_js}""#)));
     Ok(())
 }
 
@@ -108,7 +108,7 @@ fn assets_override(tmpdir: TempDir, port: u16) -> Result<(), Error> {
 
     wait_for_port(port);
 
-    let url = format!("http://localhost:{}", port);
+    let url = format!("http://localhost:{port}");
     let resp = reqwest::blocking::get(&url)?;
     assert!(resp.text()?.starts_with(&format!(
         "/__dufs_v{}_index.js;DATA",

tests/auth.rs

@@ -35,6 +35,30 @@ fn auth_skip(#[with(&["--auth", "/@user:pass@*"])] server: TestServer) -> Result
     Ok(())
 }
 
+#[rstest]
+fn auth_skip_on_options_method(
+    #[with(&["--auth", "/@user:pass"])] server: TestServer,
+) -> Result<(), Error> {
+    let url = format!("{}index.html", server.url());
+    let resp = fetch!(b"OPTIONS", &url).send()?;
+    assert_eq!(resp.status(), 200);
+    Ok(())
+}
+
+#[rstest]
+fn auth_check(
+    #[with(&["--auth", "/@user:pass@user2:pass2", "-A"])] server: TestServer,
+) -> Result<(), Error> {
+    let url = format!("{}index.html", server.url());
+    let resp = fetch!(b"WRITEABLE", &url).send()?;
+    assert_eq!(resp.status(), 401);
+    let resp = fetch!(b"WRITEABLE", &url).send_with_digest_auth("user2", "pass2")?;
+    assert_eq!(resp.status(), 401);
+    let resp = fetch!(b"WRITEABLE", &url).send_with_digest_auth("user", "pass")?;
+    assert_eq!(resp.status(), 200);
+    Ok(())
+}
+
 #[rstest]
 fn auth_readonly(
     #[with(&["--auth", "/@user:pass@user2:pass2", "-A"])] server: TestServer,
@@ -54,10 +78,10 @@ fn auth_readonly(
 
 #[rstest]
 fn auth_nest(
-    #[with(&["--auth", "/@user:pass@user2:pass2", "--auth", "/dira@user3:pass3", "-A"])]
+    #[with(&["--auth", "/@user:pass@user2:pass2", "--auth", "/dir1@user3:pass3", "-A"])]
     server: TestServer,
 ) -> Result<(), Error> {
-    let url = format!("{}dira/file1", server.url());
+    let url = format!("{}dir1/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)
@@ -73,7 +97,7 @@ fn auth_nest(
 
 #[rstest]
 fn auth_nest_share(
-    #[with(&["--auth", "/@user:pass@*", "--auth", "/dira@user3:pass3", "-A"])] server: TestServer,
+    #[with(&["--auth", "/@user:pass@*", "--auth", "/dir1@user3:pass3", "-A"])] server: TestServer,
 ) -> Result<(), Error> {
     let url = format!("{}index.html", server.url());
     let resp = fetch!(b"GET", &url).send()?;
@@ -98,9 +122,9 @@ fn auth_basic(
 
 #[rstest]
 fn auth_webdav_move(
-    #[with(&["--auth", "/@user:pass@*", "--auth", "/dira@user3:pass3", "-A"])] server: TestServer,
+    #[with(&["--auth", "/@user:pass@*", "--auth", "/dir1@user3:pass3", "-A"])] server: TestServer,
 ) -> Result<(), Error> {
-    let origin_url = format!("{}dira/test.html", server.url());
+    let origin_url = format!("{}dir1/test.html", server.url());
     let new_url = format!("{}test2.html", server.url());
     let resp = fetch!(b"MOVE", &origin_url)
         .header("Destination", &new_url)
@@ -111,9 +135,9 @@ fn auth_webdav_move(
 
 #[rstest]
 fn auth_webdav_copy(
-    #[with(&["--auth", "/@user:pass@*", "--auth", "/dira@user3:pass3", "-A"])] server: TestServer,
+    #[with(&["--auth", "/@user:pass@*", "--auth", "/dir1@user3:pass3", "-A"])] server: TestServer,
 ) -> Result<(), Error> {
-    let origin_url = format!("{}dira/test.html", server.url());
+    let origin_url = format!("{}dir1/test.html", server.url());
     let new_url = format!("{}test2.html", server.url());
     let resp = fetch!(b"COPY", &origin_url)
         .header("Destination", &new_url)
@@ -121,3 +145,15 @@ fn auth_webdav_copy(
     assert_eq!(resp.status(), 403);
     Ok(())
 }
+
+#[rstest]
+fn auth_path_prefix(
+    #[with(&["--auth", "/@user:pass", "--path-prefix", "xyz", "-A"])] server: TestServer,
+) -> Result<(), Error> {
+    let url = format!("{}xyz/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("user", "pass")?;
+    assert_eq!(resp.status(), 200);
+    Ok(())
+}

tests/fixtures.rs

@@ -11,9 +11,12 @@ use std::time::{Duration, Instant};
 #[allow(dead_code)]
 pub type Error = Box<dyn std::error::Error>;
 
+#[allow(dead_code)]
+pub const BIN_FILE: &str = "😀.bin";
+
 /// File names for testing purpose
 #[allow(dead_code)]
-pub static FILES: &[&str] = &["test.txt", "test.html", "index.html", "😀.bin"];
+pub static FILES: &[&str] = &["test.txt", "test.html", "index.html", BIN_FILE];
 
 /// Directory names for testing directory don't exist
 #[allow(dead_code)]
@@ -33,7 +36,7 @@ pub static DIR_ASSETS: &str = "dir-assets/";
 
 /// Directory names for testing purpose
 #[allow(dead_code)]
-pub static DIRECTORIES: &[&str] = &["dira/", "dirb/", "dirc/", DIR_NO_INDEX, DIR_GIT, DIR_ASSETS];
+pub static DIRECTORIES: &[&str] = &["dir1/", "dir2/", "dir3/", DIR_NO_INDEX, DIR_GIT, DIR_ASSETS];
 
 /// Test fixture which creates a temporary directory with a few files and directories inside.
 /// The directories also contain files.
@@ -42,10 +45,17 @@ pub static DIRECTORIES: &[&str] = &["dira/", "dirb/", "dirc/", DIR_NO_INDEX, DIR
 pub fn tmpdir() -> TempDir {
     let tmpdir = assert_fs::TempDir::new().expect("Couldn't create a temp dir for tests");
     for file in FILES {
-        tmpdir
+        if *file == BIN_FILE {
-            .child(file)
+            tmpdir
-            .write_str(&format!("This is {}", file))
+                .child(file)
-            .expect("Couldn't write to file");
+                .write_binary(b"bin\0\0123")
+                .expect("Couldn't write to file");
+        } else {
+            tmpdir
+                .child(file)
+                .write_str(&format!("This is {file}"))
+                .expect("Couldn't write to file");
+        }
     }
     for directory in DIRECTORIES {
         if *directory == DIR_ASSETS {
@@ -58,13 +68,21 @@ pub fn tmpdir() -> TempDir {
                 if *directory == DIR_NO_INDEX && *file == "index.html" {
                     continue;
                 }
-                tmpdir
+                if *file == BIN_FILE {
-                    .child(format!("{}{}", directory, file))
+                    tmpdir
-                    .write_str(&format!("This is {}{}", directory, file))
+                        .child(format!("{directory}{file}"))
-                    .expect("Couldn't write to file");
+                        .write_binary(b"bin\0\0123")
+                        .expect("Couldn't write to file");
+                } else {
+                    tmpdir
+                        .child(format!("{directory}{file}"))
+                        .write_str(&format!("This is {directory}{file}"))
+                        .expect("Couldn't write to file");
+                }
             }
         }
     }
+    tmpdir.child("dir4/hidden").touch().unwrap();
 
     tmpdir
 }
@@ -108,11 +126,11 @@ where
 pub fn wait_for_port(port: u16) {
     let start_wait = Instant::now();
 
-    while !port_check::is_port_reachable(format!("localhost:{}", port)) {
+    while !port_check::is_port_reachable(format!("localhost:{port}")) {
         sleep(Duration::from_millis(100));
 
         if start_wait.elapsed().as_secs() > 1 {
-            panic!("timeout waiting for port {}", port);
+            panic!("timeout waiting for port {port}");
         }
     }
 }

tests/hidden.rs

@@ -11,7 +11,7 @@ fn hidden_get_dir(#[case] server: TestServer, #[case] exist: bool) -> Result<(),
     let resp = reqwest::blocking::get(server.url())?;
     assert_eq!(resp.status(), 200);
     let paths = utils::retrieve_index_paths(&resp.text()?);
-    assert!(paths.contains("dira/"));
+    assert!(paths.contains("dir1/"));
     assert_eq!(paths.contains(".git/"), exist);
     assert_eq!(paths.contains("index.html"), exist);
     Ok(())
@@ -24,7 +24,7 @@ fn hidden_get_dir2(#[case] server: TestServer, #[case] exist: bool) -> Result<()
     let resp = reqwest::blocking::get(server.url())?;
     assert_eq!(resp.status(), 200);
     let paths = utils::retrieve_index_paths(&resp.text()?);
-    assert!(paths.contains("dira/"));
+    assert!(paths.contains("dir1/"));
     assert_eq!(paths.contains("index.html"), exist);
     assert_eq!(paths.contains("test.html"), exist);
     Ok(())
@@ -37,7 +37,7 @@ fn hidden_propfind_dir(#[case] server: TestServer, #[case] exist: bool) -> Resul
     let resp = fetch!(b"PROPFIND", 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>/dir1/</D:href>"));
     assert_eq!(body.contains("<D:href>/.git/</D:href>"), exist);
     assert_eq!(body.contains("<D:href>/index.html</D:href>"), exist);
     Ok(())
@@ -55,3 +55,18 @@ fn hidden_search_dir(#[case] server: TestServer, #[case] exist: bool) -> Result<
     }
     Ok(())
 }
+
+#[rstest]
+#[case(server(&["--hidden", "hidden/"]), "dir4/", 1)]
+#[case(server(&["--hidden", "hidden"]), "dir4/", 0)]
+fn hidden_dir_noly(
+    #[case] server: TestServer,
+    #[case] dir: &str,
+    #[case] count: usize,
+) -> Result<(), Error> {
+    let resp = reqwest::blocking::get(format!("{}{}", server.url(), dir))?;
+    assert_eq!(resp.status(), 200);
+    let paths = utils::retrieve_index_paths(&resp.text()?);
+    assert_eq!(paths.len(), count);
+    Ok(())
+}

tests/http.rs

@@ -1,8 +1,10 @@
 mod fixtures;
 mod utils;
 
-use fixtures::{server, Error, TestServer};
+use fixtures::{server, Error, TestServer, BIN_FILE};
 use rstest::rstest;
+use serde_json::Value;
+use utils::retrive_edit_file;
 
 #[rstest]
 fn get_dir(server: TestServer) -> Result<(), Error> {
@@ -38,7 +40,7 @@ fn head_dir_404(server: TestServer) -> Result<(), Error> {
 }
 
 #[rstest]
-fn get_dir_zip(server: TestServer) -> Result<(), Error> {
+fn get_dir_zip(#[with(&["-A"])] server: TestServer) -> Result<(), Error> {
     let resp = reqwest::blocking::get(format!("{}?zip", server.url()))?;
     assert_eq!(resp.status(), 200);
     assert_eq!(
@@ -50,7 +52,33 @@ fn get_dir_zip(server: TestServer) -> Result<(), Error> {
 }
 
 #[rstest]
-fn head_dir_zip(server: TestServer) -> Result<(), Error> {
+fn get_dir_json(#[with(&["-A"])] server: TestServer) -> Result<(), Error> {
+    let resp = reqwest::blocking::get(format!("{}?json", server.url()))?;
+    assert_eq!(resp.status(), 200);
+    assert_eq!(
+        resp.headers().get("content-type").unwrap(),
+        "application/json"
+    );
+    let json: Value = serde_json::from_str(&resp.text().unwrap()).unwrap();
+    assert!(json["paths"].as_array().is_some());
+    Ok(())
+}
+
+#[rstest]
+fn get_dir_simple(#[with(&["-A"])] server: TestServer) -> Result<(), Error> {
+    let resp = reqwest::blocking::get(format!("{}?simple", server.url()))?;
+    assert_eq!(resp.status(), 200);
+    assert_eq!(
+        resp.headers().get("content-type").unwrap(),
+        "text/html; charset=utf-8"
+    );
+    let text = resp.text().unwrap();
+    assert!(text.split('\n').any(|v| v == "index.html"));
+    Ok(())
+}
+
+#[rstest]
+fn head_dir_zip(#[with(&["-A"])] server: TestServer) -> Result<(), Error> {
     let resp = fetch!(b"HEAD", format!("{}?zip", server.url())).send()?;
     assert_eq!(resp.status(), 200);
     assert_eq!(
@@ -76,16 +104,25 @@ fn get_dir_search(#[with(&["-A"])] server: TestServer) -> Result<(), Error> {
 
 #[rstest]
 fn get_dir_search2(#[with(&["-A"])] server: TestServer) -> Result<(), Error> {
-    let resp = reqwest::blocking::get(format!("{}?q={}", server.url(), "😀.bin"))?;
+    let resp = reqwest::blocking::get(format!("{}?q={BIN_FILE}", server.url()))?;
     assert_eq!(resp.status(), 200);
     let paths = utils::retrieve_index_paths(&resp.text()?);
     assert!(!paths.is_empty());
     for p in paths {
-        assert!(p.contains("😀.bin"));
+        assert!(p.contains(BIN_FILE));
     }
     Ok(())
 }
 
+#[rstest]
+fn get_dir_search3(#[with(&["-A"])] server: TestServer) -> Result<(), Error> {
+    let resp = reqwest::blocking::get(format!("{}?q={}&simple", server.url(), "test.html"))?;
+    assert_eq!(resp.status(), 200);
+    let text = resp.text().unwrap();
+    assert!(text.split('\n').any(|v| v == "test.html"));
+    Ok(())
+}
+
 #[rstest]
 fn head_dir_search(#[with(&["-A"])] server: TestServer) -> Result<(), Error> {
     let resp = fetch!(b"HEAD", format!("{}?q={}", server.url(), "test.html")).send()?;
@@ -98,6 +135,15 @@ fn head_dir_search(#[with(&["-A"])] server: TestServer) -> Result<(), Error> {
     Ok(())
 }
 
+#[rstest]
+fn empty_search(#[with(&["-A"])] server: TestServer) -> Result<(), Error> {
+    let resp = reqwest::blocking::get(format!("{}?q=", server.url()))?;
+    assert_eq!(resp.status(), 200);
+    let paths = utils::retrieve_index_paths(&resp.text()?);
+    assert!(paths.is_empty());
+    Ok(())
+}
+
 #[rstest]
 fn get_file(server: TestServer) -> Result<(), Error> {
     let resp = reqwest::blocking::get(format!("{}index.html", server.url()))?;
@@ -132,6 +178,24 @@ fn get_file_404(server: TestServer) -> Result<(), Error> {
     Ok(())
 }
 
+#[rstest]
+fn get_file_edit(server: TestServer) -> Result<(), Error> {
+    let resp = fetch!(b"GET", format!("{}index.html?edit", server.url())).send()?;
+    assert_eq!(resp.status(), 200);
+    let editable = retrive_edit_file(&resp.text().unwrap()).unwrap();
+    assert!(editable);
+    Ok(())
+}
+
+#[rstest]
+fn get_file_edit_bin(server: TestServer) -> Result<(), Error> {
+    let resp = fetch!(b"GET", format!("{}{BIN_FILE}?edit", server.url())).send()?;
+    assert_eq!(resp.status(), 200);
+    let editable = retrive_edit_file(&resp.text().unwrap()).unwrap();
+    assert!(!editable);
+    Ok(())
+}
+
 #[rstest]
 fn head_file_404(server: TestServer) -> Result<(), Error> {
     let resp = fetch!(b"HEAD", format!("{}404", server.url())).send()?;
@@ -173,7 +237,7 @@ fn put_file_create_dir(#[with(&["-A"])] server: TestServer) -> Result<(), Error>
 
 #[rstest]
 fn put_file_conflict_dir(#[with(&["-A"])] server: TestServer) -> Result<(), Error> {
-    let url = format!("{}dira", server.url());
+    let url = format!("{}dir1", server.url());
     let resp = fetch!(b"PUT", &url).body(b"abc".to_vec()).send()?;
     assert_eq!(resp.status(), 403);
     Ok(())

tests/log_http.rs

@@ -31,7 +31,7 @@ fn log_remote_user(
 
     let stdout = child.stdout.as_mut().expect("Failed to get stdout");
 
-    let req = fetch!(b"GET", &format!("http://localhost:{}", port));
+    let req = fetch!(b"GET", &format!("http://localhost:{port}"));
 
     let resp = if is_basic {
         req.basic_auth("user", Some("pass")).send()?
@@ -66,7 +66,7 @@ fn no_log(tmpdir: TempDir, port: u16, #[case] args: &[&str]) -> Result<(), Error
 
     let stdout = child.stdout.as_mut().expect("Failed to get stdout");
 
-    let resp = fetch!(b"GET", &format!("http://localhost:{}", port)).send()?;
+    let resp = fetch!(b"GET", &format!("http://localhost:{port}")).send()?;
     assert_eq!(resp.status(), 200);
 
     let mut buf = [0; 1000];

tests/render.rs

@@ -1,7 +1,7 @@
 mod fixtures;
 mod utils;
 
-use fixtures::{server, Error, TestServer, DIR_NO_FOUND, DIR_NO_INDEX, FILES};
+use fixtures::{server, Error, TestServer, BIN_FILE, DIR_NO_FOUND, DIR_NO_INDEX, FILES};
 use rstest::rstest;
 
 #[rstest]
@@ -40,7 +40,9 @@ fn render_try_index2(#[with(&["--render-try-index"])] server: TestServer) -> Res
 }
 
 #[rstest]
-fn render_try_index3(#[with(&["--render-try-index"])] server: TestServer) -> Result<(), Error> {
+fn render_try_index3(
+    #[with(&["--render-try-index", "--allow-archive"])] server: TestServer,
+) -> Result<(), Error> {
     let resp = reqwest::blocking::get(format!("{}{}?zip", server.url(), DIR_NO_INDEX))?;
     assert_eq!(resp.status(), 200);
     assert_eq!(
@@ -54,11 +56,10 @@ fn render_try_index3(#[with(&["--render-try-index"])] server: TestServer) -> Res
 #[case(server(&["--render-try-index"] as &[&str]), false)]
 #[case(server(&["--render-try-index", "--allow-search"] as &[&str]), true)]
 fn render_try_index4(#[case] server: TestServer, #[case] searched: bool) -> Result<(), Error> {
-    let resp = reqwest::blocking::get(format!("{}{}?q={}", server.url(), DIR_NO_INDEX, "😀.bin"))?;
+    let resp = reqwest::blocking::get(format!("{}{}?q={}", server.url(), DIR_NO_INDEX, BIN_FILE))?;
     assert_eq!(resp.status(), 200);
     let paths = utils::retrieve_index_paths(&resp.text()?);
-    assert!(!paths.is_empty());
+    assert_eq!(paths.iter().all(|v| v.contains(BIN_FILE)), searched);
-    assert_eq!(paths.iter().all(|v| v.contains("😀.bin")), searched);
     Ok(())
 }
 

tests/single_file.rs

@@ -21,11 +21,11 @@ fn single_file(tmpdir: TempDir, port: u16, #[case] file: &str) -> Result<(), Err
 
     wait_for_port(port);
 
-    let resp = reqwest::blocking::get(format!("http://localhost:{}", port))?;
+    let resp = reqwest::blocking::get(format!("http://localhost:{port}"))?;
     assert_eq!(resp.text()?, "This is index.html");
-    let resp = reqwest::blocking::get(format!("http://localhost:{}/", port))?;
+    let resp = reqwest::blocking::get(format!("http://localhost:{port}/"))?;
     assert_eq!(resp.text()?, "This is index.html");
-    let resp = reqwest::blocking::get(format!("http://localhost:{}/index.html", port))?;
+    let resp = reqwest::blocking::get(format!("http://localhost:{port}/index.html"))?;
     assert_eq!(resp.text()?, "This is index.html");
 
     child.kill()?;
@@ -46,13 +46,13 @@ fn path_prefix_single_file(tmpdir: TempDir, port: u16, #[case] file: &str) -> Re
 
     wait_for_port(port);
 
-    let resp = reqwest::blocking::get(format!("http://localhost:{}/xyz", port))?;
+    let resp = reqwest::blocking::get(format!("http://localhost:{port}/xyz"))?;
     assert_eq!(resp.text()?, "This is index.html");
-    let resp = reqwest::blocking::get(format!("http://localhost:{}/xyz/", port))?;
+    let resp = reqwest::blocking::get(format!("http://localhost:{port}/xyz/"))?;
     assert_eq!(resp.text()?, "This is index.html");
-    let resp = reqwest::blocking::get(format!("http://localhost:{}/xyz/index.html", port))?;
+    let resp = reqwest::blocking::get(format!("http://localhost:{port}/xyz/index.html"))?;
     assert_eq!(resp.text()?, "This is index.html");
-    let resp = reqwest::blocking::get(format!("http://localhost:{}", port))?;
+    let resp = reqwest::blocking::get(format!("http://localhost:{port}"))?;
     assert_eq!(resp.status(), 404);
 
     child.kill()?;

tests/sort.rs

@@ -7,9 +7,9 @@ use rstest::rstest;
 #[rstest]
 fn ls_dir_sort_by_name(server: TestServer) -> Result<(), Error> {
     let url = server.url();
-    let resp = reqwest::blocking::get(format!("{}?sort=name&order=asc", url))?;
+    let resp = reqwest::blocking::get(format!("{url}?sort=name&order=asc"))?;
     let paths1 = self::utils::retrieve_index_paths(&resp.text()?);
-    let resp = reqwest::blocking::get(format!("{}?sort=name&order=desc", url))?;
+    let resp = reqwest::blocking::get(format!("{url}?sort=name&order=desc"))?;
     let mut paths2 = self::utils::retrieve_index_paths(&resp.text()?);
     paths2.reverse();
     assert_eq!(paths1, paths2);
@@ -19,9 +19,9 @@ fn ls_dir_sort_by_name(server: TestServer) -> Result<(), Error> {
 #[rstest]
 fn search_dir_sort_by_name(server: TestServer) -> Result<(), Error> {
     let url = server.url();
-    let resp = reqwest::blocking::get(format!("{}?q={}&sort=name&order=asc", url, "test.html"))?;
+    let resp = reqwest::blocking::get(format!("{url}?q=test.html&sort=name&order=asc"))?;
     let paths1 = self::utils::retrieve_index_paths(&resp.text()?);
-    let resp = reqwest::blocking::get(format!("{}?q={}&sort=name&order=desc", url, "test.html"))?;
+    let resp = reqwest::blocking::get(format!("{url}?q=test.html&sort=name&order=desc"))?;
     let mut paths2 = self::utils::retrieve_index_paths(&resp.text()?);
     paths2.reverse();
     assert_eq!(paths1, paths2);

tests/symlink.rs

@@ -22,7 +22,7 @@ fn default_not_allow_symlink(server: TestServer, tmpdir: TempDir) -> Result<(),
     let resp = reqwest::blocking::get(server.url())?;
     let paths = utils::retrieve_index_paths(&resp.text()?);
     assert!(!paths.is_empty());
-    assert!(!paths.contains(&format!("{}/", dir)));
+    assert!(!paths.contains(&format!("{dir}/")));
     Ok(())
 }
 
@@ -41,6 +41,6 @@ fn allow_symlink(
     let resp = reqwest::blocking::get(server.url())?;
     let paths = utils::retrieve_index_paths(&resp.text()?);
     assert!(!paths.is_empty());
-    assert!(paths.contains(&format!("{}/", dir)));
+    assert!(paths.contains(&format!("{dir}/")));
     Ok(())
 }

tests/tls.rs

@@ -34,7 +34,7 @@ fn tls_works(#[case] server: TestServer) -> Result<(), Error> {
 #[rstest]
 fn wrong_path_cert() -> Result<(), Error> {
     Command::cargo_bin("dufs")?
-        .args(&["--tls-cert", "wrong", "--tls-key", "tests/data/key.pem"])
+        .args(["--tls-cert", "wrong", "--tls-key", "tests/data/key.pem"])
         .assert()
         .failure()
         .stderr(contains("error: Failed to access `wrong`"));
@@ -46,7 +46,7 @@ fn wrong_path_cert() -> Result<(), Error> {
 #[rstest]
 fn wrong_path_key() -> Result<(), Error> {
     Command::cargo_bin("dufs")?
-        .args(&["--tls-cert", "tests/data/cert.pem", "--tls-key", "wrong"])
+        .args(["--tls-cert", "tests/data/cert.pem", "--tls-key", "wrong"])
         .assert()
         .failure()
         .stderr(contains("error: Failed to access `wrong`"));

tests/utils.rs

@@ -25,8 +25,32 @@ macro_rules! fetch {
 }
 
 #[allow(dead_code)]
-pub fn retrieve_index_paths(index: &str) -> IndexSet<String> {
+pub fn retrieve_index_paths(content: &str) -> IndexSet<String> {
-    retrieve_index_paths_impl(index).unwrap_or_default()
+    let value = retrive_json(content).unwrap();
+    let paths = value
+        .get("paths")
+        .unwrap()
+        .as_array()
+        .unwrap()
+        .iter()
+        .flat_map(|v| {
+            let name = v.get("name")?.as_str()?;
+            let path_type = v.get("path_type")?.as_str()?;
+            if path_type.ends_with("Dir") {
+                Some(format!("{name}/"))
+            } else {
+                Some(name.to_owned())
+            }
+        })
+        .collect();
+    paths
+}
+
+#[allow(dead_code)]
+pub fn retrive_edit_file(content: &str) -> Option<bool> {
+    let value = retrive_json(content)?;
+    let value = value.get("editable").unwrap();
+    Some(value.as_bool().unwrap())
 }
 
 #[allow(dead_code)]
@@ -35,24 +59,10 @@ pub fn encode_uri(v: &str) -> String {
     parts.join("/")
 }
 
-fn retrieve_index_paths_impl(index: &str) -> Option<IndexSet<String>> {
+fn retrive_json(content: &str) -> Option<Value> {
-    let lines: Vec<&str> = index.lines().collect();
+    let lines: Vec<&str> = content.lines().collect();
     let line = lines.iter().find(|v| v.contains("DATA ="))?;
     let line_col = line.find("DATA =").unwrap() + 6;
-    let value: Value = line[line_col..].parse().ok()?;
+    let value: Value = line[line_col..].parse().unwrap();
-    let paths = value
+    Some(value)
-        .get("paths")?
-        .as_array()?
-        .iter()
-        .flat_map(|v| {
-            let name = v.get("name")?.as_str()?;
-            let path_type = v.get("path_type")?.as_str()?;
-            if path_type.ends_with("Dir") {
-                Some(format!("{}/", name))
-            } else {
-                Some(name.to_owned())
-            }
-        })
-        .collect();
-    Some(paths)
 }

tests/webdav.rs

@@ -7,13 +7,13 @@ use xml::escape::escape_str_pcdata;
 
 #[rstest]
 fn propfind_dir(server: TestServer) -> Result<(), Error> {
-    let resp = fetch!(b"PROPFIND", format!("{}dira", server.url())).send()?;
+    let resp = fetch!(b"PROPFIND", format!("{}dir1", 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>/dir1/</D:href>"));
-    assert!(body.contains("<D:displayname>dira</D:displayname>"));
+    assert!(body.contains("<D:displayname>dir1</D:displayname>"));
     for f in FILES {
-        assert!(body.contains(&format!("<D:href>/dira/{}</D:href>", utils::encode_uri(f))));
+        assert!(body.contains(&format!("<D:href>/dir1/{}</D:href>", utils::encode_uri(f))));
         assert!(body.contains(&format!(
             "<D:displayname>{}</D:displayname>",
             escape_str_pcdata(f)
@@ -24,13 +24,13 @@ fn propfind_dir(server: TestServer) -> Result<(), Error> {
 
 #[rstest]
 fn propfind_dir_depth0(server: TestServer) -> Result<(), Error> {
-    let resp = fetch!(b"PROPFIND", format!("{}dira", server.url()))
+    let resp = fetch!(b"PROPFIND", format!("{}dir1", server.url()))
         .header("depth", "0")
         .send()?;
     assert_eq!(resp.status(), 207);
     let body = resp.text()?;
-    assert!(body.contains("<D:href>/dira/</D:href>"));
+    assert!(body.contains("<D:href>/dir1/</D:href>"));
-    assert!(body.contains("<D:displayname>dira</D:displayname>"));
+    assert!(body.contains("<D:displayname>dir1</D:displayname>"));
     assert_eq!(
         body.lines()
             .filter(|v| *v == "<D:status>HTTP/1.1 200 OK</D:status>")
@@ -47,6 +47,13 @@ fn propfind_404(server: TestServer) -> Result<(), Error> {
     Ok(())
 }
 
+#[rstest]
+fn propfind_double_slash(server: TestServer) -> Result<(), Error> {
+    let resp = fetch!(b"PROPFIND", format!("{}/", server.url())).send()?;
+    assert_eq!(resp.status(), 207);
+    Ok(())
+}
+
 #[rstest]
 fn propfind_file(server: TestServer) -> Result<(), Error> {
     let resp = fetch!(b"PROPFIND", format!("{}test.html", server.url())).send()?;
@@ -93,6 +100,13 @@ fn mkcol_not_allow_upload(server: TestServer) -> Result<(), Error> {
     Ok(())
 }
 
+#[rstest]
+fn mkcol_already_exists(#[with(&["-A"])] server: TestServer) -> Result<(), Error> {
+    let resp = fetch!(b"MKCOL", format!("{}dir1", server.url())).send()?;
+    assert_eq!(resp.status(), 405);
+    Ok(())
+}
+
 #[rstest]
 fn copy_file(#[with(&["-A"])] server: TestServer) -> Result<(), Error> {
     let new_url = format!("{}test2.html", server.url());