chore(release): version 0.31.0

* Fix status code for MKCOL on existing resource

Per https://datatracker.ietf.org/doc/html/rfc4918#section-9.3.1,
MKCOL should return a 405 if the resource already exists.

Impetus for this change:
I am using dufs as a webdav server for [Joplin](https://joplinapp.org/)
which interpreted the previous behavior of returning a 403 as an error,
preventing syncing from working.

* add test

Co-authored-by: sigoden <sigoden@gmail.com>

.github/dependabot.yml

@@ -1,6 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: "cargo" # See documentation for possible values
-    directory: "/" # Location of package manifests
-    schedule:
-      interval: "monthly"

CHANGELOG.md

@@ -2,7 +2,59 @@
 
 All notable changes to this project will be documented in this file.
 
-## [0.26.0] - 2022-07-08
+## [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
+
+- Hide path by ext name ([#126](https://github.com/sigoden/dufs/issues/126))
+
+### Features
+
+- Support sort by name, mtime, size ([#128](https://github.com/sigoden/dufs/issues/128))
+- Add --assets options to override assets ([#134](https://github.com/sigoden/dufs/issues/134))
+
+## [0.29.0] - 2022-08-03
+
+### Bug Fixes
+
+- Table row hover highlighting in dark mode ([#122](https://github.com/sigoden/dufs/issues/122))
+
+### Features
+
+- Support ecdsa tls cert ([#119](https://github.com/sigoden/dufs/issues/119))
+
+## [0.28.0] - 2022-08-01
+
+### Bug Fixes
+
+- File path contains special charactors ([#114](https://github.com/sigoden/dufs/issues/114))
+
+### Features
+
+- Add table row hover ([#115](https://github.com/sigoden/dufs/issues/115))
+- Support customize http log format ([#116](https://github.com/sigoden/dufs/issues/116))
+
+## [0.27.0] - 2022-07-25
+
+### Features
+
+- Improve hidden to support glob ([#108](https://github.com/sigoden/dufs/issues/108))
+- Adjust digest auth timeout to 1day ([#110](https://github.com/sigoden/dufs/issues/110))
+
+## [0.26.0] - 2022-07-11
 
 ### Bug Fixes
 

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "dufs"
-version = "0.26.0"
+version = "0.31.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_complete = "3"
+clap = { version = "4", features = ["wrap_help"] }
+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"] }
@@ -38,6 +38,8 @@ log = "0.4"
 socket2 = "0.4"
 async-stream = "0.3"
 walkdir = "2.3"
+form_urlencoded = "1.0"
+alphanumeric-sort = "1.4"
 
 [features]
 default = ["tls"]
@@ -47,14 +49,13 @@ tls = ["rustls", "rustls-pemfile", "tokio-rustls"]
 assert_cmd = "2"
 reqwest = { version = "0.11", features = ["blocking", "multipart", "rustls-tls"], default-features = false }
 assert_fs = "1"
-select = "0.5"
 port_check = "0.1"
 rstest = "0.15"
 regex = "1"
-pretty_assertions = "1.2"
 url = "2"
 diqwest = { version = "1", features = ["blocking"] }
 predicates = "2"
+indexmap = "1.9"
 
 [profile.release]
 lto = true

README.md

@@ -5,7 +5,7 @@
 
 Dufs is a distinctive utility file server that supports static serving, uploading, searching, accessing control, webdav...
 
-![demo](https://user-images.githubusercontent.com/4012553/177549931-130383ef-0480-4911-b9c2-0d9534a624b7.png)
+![demo](https://user-images.githubusercontent.com/4012553/189362357-b2f7aa6b-9df0-4438-a57c-c8f92850fc4f.png)
 
 ## Features
 
@@ -42,18 +42,17 @@ Download from [Github Releases](https://github.com/sigoden/dufs/releases), unzip
 ```
 Dufs is a distinctive utility file server - https://github.com/sigoden/dufs
 
-USAGE:
-    dufs [OPTIONS] [--] [path]
+Usage: dufs [OPTIONS] [root]
 
-ARGS:
-    <path>    Specific path to serve [default: .]
+Arguments:
+  [root]  Specific path to serve [default: .]
 
-OPTIONS:
-    -b, --bind <addr>...         Specify bind address
+Options:
+  -b, --bind <addrs>         Specify bind address or unix socket
   -p, --port <port>          Specify port to listen on [default: 5000]
       --path-prefix <path>   Specify a path prefix
-        --hidden <value>         Hide directories from directory listings, separated by `,`
-    -a, --auth <rule>...         Add auth for path
+      --hidden <value>       Hide paths from directory listings, separated by `,`
+  -a, --auth <rules>         Add auth for path
       --auth-method <value>  Select auth method [default: digest] [possible values: basic, digest]
   -A, --allow-all            Allow all operations
       --allow-upload         Allow upload files/folders
@@ -64,9 +63,11 @@ OPTIONS:
       --render-index         Serve index.html when requesting a directory, returns 404 if not found index.html
       --render-try-index     Serve index.html when requesting a directory, returns directory listing if not found index.html
       --render-spa           Serve SPA(Single Page Application)
-        --completions <shell>    Print shell completion script for <shell> [possible values: bash, elvish, fish, powershell, zsh]
+      --assets <path>        Use custom assets to override builtin assets
       --tls-cert <path>      Path to an SSL/TLS certificate to serve with HTTPS
       --tls-key <path>       Path to the SSL/TLS certificate's private key
+      --log-format <format>  Customize http log format
+      --completions <shell>  Print shell completion script for <shell> [possible values: bash, elvish, fish, powershell, zsh]
   -h, --help                 Print help information
   -V, --version              Print version information
 ```
@@ -121,16 +122,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
 ```
 
-Hide directories from directory listings
-
+Listen on unix socket
 ```
-dufs --hidden .git,.DS_Store
+dufs -b /tmp/dufs.socket
 ```
 
 Use https
@@ -164,28 +164,125 @@ Delete a file/folder
 curl -X DELETE http://127.0.0.1:5000/path-to-file-or-folder
 ```
 
-## Access Control
+<details>
+<summary><h2>Advanced topics</h2></summary>
+
+### Access Control
 
 Dufs supports path level access control. You can control who can do what on which path with `--auth`/`-a`.
 
 ```
-dufs -a <path>@<readwrite>[@<readonly>|@*]
+dufs -a <path>@<readwrite>
+dufs -a <path>@<readwrite>@<readonly>
+dufs -a <path>@<readwrite>@*
 ```
 
 - `<path>`: Protected url path
-- `<readwrite>`: Account with upload/delete/view/download permission, required
-- `<readonly>`: Account with view/download permission, optional
-
-> `*` means `<path>` is public, everyone can view/download it.
-
-For example:
+- `<readwrite>`: Account with readwrite permissions. If dufs is run with `dufs --allow-all`, the permissions are upload/delete/search/view/download. If dufs is run with `dufs --allow-upload`, the permissions are upload/view/download.
+- `<readonly>`: Account with readonly permissions. The permissions are search/view/download if dufs allow search, otherwise view/download..
 
 ```
-dufs -a /@admin:pass1@* -a /ui@designer:pass2 -A
+dufs -A -a /@admin:admin
 ```
-- All files/folders are public to view/download.
-- Account `admin:pass1` can upload/delete/view/download any files/folders.
-- Account `designer:pass2` can upload/delete/view/download any files/folders in the `ui` folder.
+`admin` has all permissions for all paths.
+
+```
+dufs -A -a /@admin:admin@guest:guest
+```
+`guest` has readonly permissions for all paths.
+
+```
+dufs -A -a /@admin:admin@*
+```
+All paths is public, everyone can view/download it.
+
+```
+dufs -A -a /@admin:admin -a /user1@user1:pass1 -a /user2@pass2:user2
+```
+`user1` has all permissions for `/user1*` path.
+`user2` has all permissions for `/user2*` path.
+
+```
+dufs -a /@admin:admin
+```
+Since dufs only allows viewing/downloading, `admin` can only view/download files.
+
+### Hide Paths
+
+Dufs supports hiding paths from directory listings via option `--hidden`.
+
+```
+dufs --hidden .git,.DS_Store,tmp
+```
+
+`--hidden` also supports a variant glob:
+
+- `?` matches any single character
+- `*` matches any (possibly empty) sequence of characters
+- `**`, `[..]`, `[!..]` is not supported
+
+```sh
+dufs --hidden '.*'
+dufs --hidden '*.log,*.lock'
+```
+
+### Log Format
+
+Dufs supports customize http log format with option `--log-format`.
+
+The log format can use following variables.
+
+| variable     | description                                                               |
+| ------------ | ------------------------------------------------------------------------- |
+| $remote_addr | client address                                                            |
+| $remote_user | user name supplied with authentication                                    |
+| $request     | full original request line                                                |
+| $status      | response status                                                           |
+| $http_       | arbitrary request header field. examples: $http_user_agent, $http_referer |
+
+
+The default log format is `'$remote_addr "$request" $status'`.
+```
+2022-08-06T06:59:31+08:00 INFO - 127.0.0.1 "GET /" 200
+```
+
+Disable http log
+```
+dufs --log-format=''
+```
+
+Log user-agent
+```
+dufs --log-format '$remote_addr "$request" $status $http_user_agent'
+```
+```
+2022-08-06T06:53:55+08:00 INFO - 127.0.0.1 "GET /" 200 Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/104.0.0.0 Safari/537.36
+```
+
+Log remote-user
+```
+dufs --log-format '$remote_addr $remote_user "$request" $status' -a /@admin:admin -a /folder1@user1:pass1
+```
+```
+2022-08-06T07:04:37+08:00 INFO - 127.0.0.1 admin "GET /" 200
+```
+
+### Customize UI
+
+Dufs allows users to customize the UI with your own assets.
+
+```
+dufs --assets my-assets-dir/
+```
+
+Your assets folder must contains a `index.html` file.
+
+`index.html` can use the following placeholder variables to retrieve internal data.
+
+- `__INDEX_DATA__`: directory listing data
+- `__ASSERTS_PREFIX__`: assets url prefix
+
+</details>
 
 ## License
 

assets/index.css

@@ -131,6 +131,19 @@ body {
   padding-left: 0.6em;
 }
 
+.paths-table thead a {
+  color: unset;
+  text-decoration: none;
+}
+
+.paths-table thead a > span {
+  padding-left: 2px;
+}
+
+.paths-table tbody tr:hover {
+  background-color: #fafafa;
+}
+
 .paths-table .cell-actions {
   width: 75px;
   display: flex;
@@ -227,4 +240,8 @@ body {
   .path a {
     color: #3191ff;
   }
+
+  .paths-table tbody tr:hover {
+    background-color: #1a1a1a;
+  }
 } 

assets/index.html

@@ -4,7 +4,12 @@
 <head>
   <meta charset="utf-8" />
   <meta name="viewport" content="width=device-width" />
-  __SLOT__
+  <link rel="icon" type="image/x-icon" href="__ASSERTS_PREFIX__favicon.ico">
+  <link rel="stylesheet" href="__ASSERTS_PREFIX__index.css">
+  <script>
+  DATA = __INDEX_DATA__
+  </script>
+  <script src="__ASSERTS_PREFIX__index.js"></script>
 </head>
 <body>
   <div class="head">
@@ -32,7 +37,7 @@
       <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>
       </div>
-      <input id="search" name="q" type="text" maxlength="128" autocomplete="off" tabindex="1">
+      <input id="search" name="q" type="text" maxlength="128" autocomplete="off" tabindex="1" required>
       <input type="submit" hidden />
     </form>
   </div>
@@ -48,12 +53,6 @@
     </table>
     <table class="paths-table hidden">
       <thead>
-        <tr>
-          <th class="cell-name" colspan="2">Name</th>
-          <th class="cell-mtime">Last modified</th>
-          <th class="cell-size">Size</th>
-          <th class="cell-actions">Actions</th>
-        </tr>
       </thead>
       <tbody>
       </tbody>

assets/index.js

@@ -6,17 +6,41 @@
  * @property {number} size
  */
 
-// https://stackoverflow.com/a/901144/3642588
-const params = new Proxy(new URLSearchParams(window.location.search), {
-  get: (searchParams, prop) => searchParams.get(prop),
-});
+/**
+ * @typedef {object} DATA
+ * @property {string} href
+ * @property {string} uri_prefix
+ * @property {PathItem[]} paths
+ * @property {boolean} allow_upload
+ * @property {boolean} allow_delete
+ * @property {boolean} allow_search
+ * @property {boolean} dir_exists
+ */
 
-const dirEmptyNote = params.q ? 'No results' : DATA.dir_exists ? 'Empty folder' : 'Folder will be created when a file is uploaded';
+/**
+ * @type {DATA} DATA
+ */
+var DATA;
+
+/**
+ * @type {PARAMS}
+ * @typedef {object} PARAMS
+ * @property {string} q
+ * @property {string} sort
+ * @property {string} order
+ */
+const PARAMS = Object.fromEntries(new URLSearchParams(window.location.search).entries());
+
+const dirEmptyNote = PARAMS.q ? 'No results' : DATA.dir_exists ? 'Empty folder' : 'Folder will be created when a file is uploaded';
 
 /**
  * @type Element
  */
 let $pathsTable;
+/**
+ * @type Element
+ */
+let $pathsTableHead;
 /**
  * @type Element
  */
@@ -55,7 +79,6 @@ class Uploader {
   upload() {
     const { idx, name } = this;
     const url = getUrl(name);
-    const encodedUrl = encodedStr(url);
     const encodedName = encodedStr(name);
     $uploadersTable.insertAdjacentHTML("beforeend", `
   <tr id="upload${idx}" class="uploader">
@@ -63,7 +86,7 @@ class Uploader {
       ${getSvg()}
     </td>
     <td class="path cell-name">
-      <a href="${encodedUrl}">${encodedName}</a>
+      <a href="${url}">${encodedName}</a>
     </td>
     <td class="cell-status upload-status" id="uploadStatus${idx}"></td>
   </tr>`);
@@ -76,7 +99,7 @@ class Uploader {
   }
 
   ajax() {
-    Uploader.runings += 1;
+    Uploader.runnings += 1;
     const url = getUrl(this.name);
     this.lastUptime = Date.now();
     const ajax = new XMLHttpRequest();
@@ -111,20 +134,20 @@ class Uploader {
 
   complete() {
     this.$uploadStatus.innerHTML = `✓`;
-    Uploader.runings -= 1;
+    Uploader.runnings -= 1;
     Uploader.runQueue();
   }
 
   fail() {
     this.$uploadStatus.innerHTML = `✗`;
-    Uploader.runings -= 1;
+    Uploader.runnings -= 1;
     Uploader.runQueue();
   }
 }
 
 Uploader.globalIdx = 0;
 
-Uploader.runings = 0;
+Uploader.runnings = 0;
 
 /**
  * @type Uploader[]
@@ -133,7 +156,7 @@ Uploader.queues = [];
 
 
 Uploader.runQueue = () => {
-  if (Uploader.runings > 2) return;
+  if (Uploader.runnings > 2) return;
   let uploader = Uploader.queues.shift();
   if (!uploader) return;
   uploader.ajax();
@@ -160,16 +183,15 @@ function addBreadcrumb(href, uri_prefix) {
       if (!path.endsWith("/")) {
         path  += "/";
       }
-      path += encodeURI(name);
+      path += encodeURIComponent(name);
     }
-    const encodedPath = encodedStr(path);
     const encodedName = encodedStr(name);
     if (i === 0) {
-      $breadcrumb.insertAdjacentHTML("beforeend", `<a href="${encodedPath}"><svg width="16" height="16" viewBox="0 0 16 16"><path d="M6.5 14.5v-3.505c0-.245.25-.495.5-.495h2c.25 0 .5.25.5.5v3.5a.5.5 0 0 0 .5.5h4a.5.5 0 0 0 .5-.5v-7a.5.5 0 0 0-.146-.354L13 5.793V2.5a.5.5 0 0 0-.5-.5h-1a.5.5 0 0 0-.5.5v1.293L8.354 1.146a.5.5 0 0 0-.708 0l-6 6A.5.5 0 0 0 1.5 7.5v7a.5.5 0 0 0 .5.5h4a.5.5 0 0 0 .5-.5z"/></svg></a>`);
+      $breadcrumb.insertAdjacentHTML("beforeend", `<a href="${path}"><svg width="16" height="16" viewBox="0 0 16 16"><path d="M6.5 14.5v-3.505c0-.245.25-.495.5-.495h2c.25 0 .5.25.5.5v3.5a.5.5 0 0 0 .5.5h4a.5.5 0 0 0 .5-.5v-7a.5.5 0 0 0-.146-.354L13 5.793V2.5a.5.5 0 0 0-.5-.5h-1a.5.5 0 0 0-.5.5v1.293L8.354 1.146a.5.5 0 0 0-.708 0l-6 6A.5.5 0 0 0 1.5 7.5v7a.5.5 0 0 0 .5.5h4a.5.5 0 0 0 .5-.5z"/></svg></a>`);
     } else if (i === len - 1) {
       $breadcrumb.insertAdjacentHTML("beforeend", `<b>${encodedName}</b>`);
     } else {
-      $breadcrumb.insertAdjacentHTML("beforeend", `<a href="${encodedPath}">${encodedName}</a>`);
+      $breadcrumb.insertAdjacentHTML("beforeend", `<a href="${path}">${encodedName}</a>`);
     }
     if (i !== len - 1) {
       $breadcrumb.insertAdjacentHTML("beforeend", `<span class="separator">/</span>`);
@@ -177,6 +199,67 @@ function addBreadcrumb(href, uri_prefix) {
   }
 }
 
+/**
+ * Render path table thead
+ */
+function renderPathsTableHead() {
+  const headerItems = [
+    {
+      name: "name",
+      props: `colspan="2"`,
+      text: "Name",
+    },
+    {
+      name: "mtime",
+      props: ``,
+      text: "Last Modified",
+    },
+    {
+      name: "size",
+      props: ``,
+      text: "Size",
+    }
+  ];
+  $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 order = "asc";
+        if (PARAMS.sort === item.name) {
+          if (PARAMS.order === "asc") {
+            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>`
+          } 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>`
+          }
+        }
+        const qs = new URLSearchParams({...PARAMS, order, sort: item.name }).toString();
+        const icon = `<span>${svg}</span>`
+        return `<th class="cell-${item.name}" ${item.props}><a href="?${qs}">${item.text}${icon}</a></th>`
+      }).join("\n")}
+      <th class="cell-actions">Actions</th>
+    </tr>
+  `);
+}
+
+/**
+ * Render path table tbody
+ */
+function renderPathsTableBody() {
+  if (DATA.paths && DATA.paths.length > 0) {
+    const len = DATA.paths.length;
+    if (len > 0) {
+      $pathsTable.classList.remove("hidden");
+    }
+    for (let i = 0; i < len; i++) {
+      addPath(DATA.paths[i], i);
+    }
+  } else {
+    $emptyFolder.textContent = dirEmptyNote;
+    $emptyFolder.classList.remove("hidden");
+  }
+}
+
 /**
  * Add pathitem
  * @param {PathItem} file 
@@ -185,23 +268,21 @@ function addBreadcrumb(href, uri_prefix) {
 function addPath(file, index) {
   const encodedName = encodedStr(file.name);
   let url = getUrl(file.name)
-  let encodedUrl = encodedStr(url);
   let actionDelete = "";
   let actionDownload = "";
   let actionMove = "";
   if (file.path_type.endsWith("Dir")) {
     url += "/";
-    encodedUrl += "/";
     actionDownload = `
     <div class="action-btn">
-      <a href="${encodedUrl}?zip" title="Download folder as a .zip file">
+      <a href="${url}?zip" title="Download folder as a .zip 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 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>`;
   } else {
     actionDownload = `
     <div class="action-btn" >
-      <a href="${encodedUrl}" title="Download file" download>
+      <a href="${url}" title="Download file" 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>
       </a>
     </div>`;
@@ -231,7 +312,7 @@ function addPath(file, index) {
     ${getSvg(file.path_type)}
   </td>
   <td class="path cell-name">
-    <a href="${encodedUrl}">${encodedName}</a>
+    <a href="${url}">${encodedName}</a>
   </td>
   <td class="cell-mtime">${formatMtime(file.mtime)}</td>
   <td class="cell-size">${formatSize(file.size).join(" ")}</td>
@@ -287,12 +368,14 @@ async function movePath(index) {
     
   const filePath = decodeURIComponent(fileUrlObj.pathname.slice(prefix.length));
 
-  const newPath = prompt("Enter new path", filePath)
-  if (!newPath || filePath === newPath) return;
-  const newFileUrl = fileUrlObj.origin + prefix + encodeURI(newPath);
+  let newPath = prompt("Enter new path", filePath)
+  if (!newPath) return;
+  if (!newPath.startsWith("/")) newPath = "/" + newPath;
+  if (filePath === newPath) return;
+  const newFileUrl = fileUrlObj.origin + prefix + newPath.split("/").map(encodeURIComponent).join("/");
 
   try {
-    const res = await fetch(getUrl(file.name), {
+    const res = await fetch(fileUrl, {
       method: "MOVE",
       headers: {
         "Destination": newFileUrl,
@@ -367,7 +450,7 @@ async function addFileEntries(entries, dirs) {
 function getUrl(name) {
     let url = location.href.split('?')[0];
     if (!url.endsWith("/")) url += "/";
-    url += encodeURI(name);
+    url += name.split("/").map(encodeURIComponent).join("/");
     return url;
 }
 
@@ -432,6 +515,7 @@ function encodedStr(rawStr) {
 function ready() {
   document.title = `Index of ${DATA.href} - Dufs`;
   $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");
@@ -439,26 +523,15 @@ function ready() {
 
   if (DATA.allow_search) {
     document.querySelector(".searchbar").classList.remove("hidden");
-    if (params.q) {
-      document.getElementById('search').value = params.q;
+    if (PARAMS.q) {
+      document.getElementById('search').value = PARAMS.q;
     }
   }
 
-
   addBreadcrumb(DATA.href, DATA.uri_prefix);
-  if (Array.isArray(DATA.paths)) {
-    const len = DATA.paths.length;
-    if (len > 0) {
-      $pathsTable.classList.remove("hidden");
-    }
-    for (let i = 0; i < len; i++) {
-      addPath(DATA.paths[i], i);
-    }
-    if (len == 0) {
-      $emptyFolder.textContent = dirEmptyNote;
-      $emptyFolder.classList.remove("hidden");
-    }
-  }
+  renderPathsTableHead();
+  renderPathsTableBody();
+
   if (DATA.allow_upload) {
     dropzone();
     if (DATA.allow_delete) {

src/args.rs

@@ -1,4 +1,5 @@
-use clap::{value_parser, AppSettings, Arg, ArgMatches, Command};
+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};
@@ -8,12 +9,13 @@ use std::path::{Path, PathBuf};
 
 use crate::auth::AccessControl;
 use crate::auth::AuthMethod;
+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"))
@@ -22,30 +24,30 @@ pub fn build_cli() -> Command<'static> {
             " - ",
             env!("CARGO_PKG_REPOSITORY")
         ))
-        .global_setting(AppSettings::DeriveDisplayOrder)
+        .arg(
+            Arg::new("root")
+                .default_value(".")
+                .value_parser(value_parser!(PathBuf))
+                .help("Specific path to serve"),
+        )
         .arg(
             Arg::new("bind")
                 .short('b')
                 .long("bind")
-                .help("Specify bind address")
-                .multiple_values(true)
-                .multiple_occurrences(true)
-                .value_name("addr"),
+                .help("Specify bind address or unix socket")
+                .action(ArgAction::Append)
+                .value_delimiter(',')
+                .value_name("addrs"),
         )
         .arg(
             Arg::new("port")
                 .short('p')
                 .long("port")
                 .default_value("5000")
+                .value_parser(value_parser!(u16))
                 .help("Specify port to listen on")
                 .value_name("port"),
         )
-        .arg(
-            Arg::new("path")
-                .default_value(".")
-                .allow_invalid_utf8(true)
-                .help("Specific path to serve"),
-        )
         .arg(
             Arg::new("path-prefix")
                 .long("path-prefix")
@@ -55,7 +57,7 @@ pub fn build_cli() -> Command<'static> {
         .arg(
             Arg::new("hidden")
                 .long("hidden")
-                .help("Hide directories from directory listings, separated by `,`")
+                .help("Hide paths from directory listings, separated by `,`")
                 .value_name("value"),
         )
         .arg(
@@ -63,15 +65,15 @@ pub fn build_cli() -> Command<'static> {
                 .short('a')
                 .long("auth")
                 .help("Add auth for path")
-                .multiple_values(true)
-                .multiple_occurrences(true)
-                .value_name("rule"),
+                .action(ArgAction::Append)
+                .value_delimiter(',')
+                .value_name("rules"),
         )
         .arg(
             Arg::new("auth-method")
                 .long("auth-method")
                 .help("Select auth method")
-                .possible_values(["basic", "digest"])
+                .value_parser(PossibleValuesParser::new(["basic", "digest"]))
                 .default_value("digest")
                 .value_name("value"),
         )
@@ -79,54 +81,63 @@ pub fn build_cli() -> Command<'static> {
             Arg::new("allow-all")
                 .short('A')
                 .long("allow-all")
+                .action(ArgAction::SetTrue)
                 .help("Allow all operations"),
         )
         .arg(
             Arg::new("allow-upload")
                 .long("allow-upload")
+                .action(ArgAction::SetTrue)
                 .help("Allow upload files/folders"),
         )
         .arg(
             Arg::new("allow-delete")
                 .long("allow-delete")
+                .action(ArgAction::SetTrue)
                 .help("Allow delete files/folders"),
         )
         .arg(
             Arg::new("allow-search")
                 .long("allow-search")
+                .action(ArgAction::SetTrue)
                 .help("Allow search files/folders"),
         )
         .arg(
             Arg::new("allow-symlink")
                 .long("allow-symlink")
+                .action(ArgAction::SetTrue)
                 .help("Allow symlink to files/folders outside root directory"),
         )
         .arg(
             Arg::new("enable-cors")
                 .long("enable-cors")
+                .action(ArgAction::SetTrue)
                 .help("Enable CORS, sets `Access-Control-Allow-Origin: *`"),
         )
         .arg(
             Arg::new("render-index")
                 .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")
                 .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")
                 .long("render-spa")
+                .action(ArgAction::SetTrue)
                 .help("Serve SPA(Single Page Application)"),
         )
         .arg(
-            Arg::new("completions")
-                .long("completions")
-                .value_name("shell")
-                .value_parser(value_parser!(Shell))
-                .help("Print shell completion script for <shell>"),
+            Arg::new("assets")
+                .long("assets")
+                .help("Use custom assets to override builtin assets")
+                .value_parser(value_parser!(PathBuf))
+                .value_name("path")
         );
 
     #[cfg(feature = "tls")]
@@ -135,16 +146,30 @@ pub fn build_cli() -> Command<'static> {
             Arg::new("tls-cert")
                 .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")
                 .long("tls-key")
                 .value_name("path")
+                .value_parser(value_parser!(PathBuf))
                 .help("Path to the SSL/TLS certificate's private key"),
         );
 
-    app
+    app.arg(
+        Arg::new("log-format")
+            .long("log-format")
+            .value_name("format")
+            .help("Customize http log format"),
+    )
+    .arg(
+        Arg::new("completions")
+            .long("completions")
+            .value_name("shell")
+            .value_parser(value_parser!(Shell))
+            .help("Print shell completion script for <shell>"),
+    )
 }
 
 pub fn print_completions<G: Generator>(gen: G, cmd: &mut Command) {
@@ -153,13 +178,13 @@ 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,
     pub path_prefix: String,
     pub uri_prefix: String,
-    pub hidden: String,
+    pub hidden: Vec<String>,
     pub auth_method: AuthMethod,
     pub auth: AccessControl,
     pub allow_upload: bool,
@@ -170,6 +195,8 @@ pub struct Args {
     pub render_spa: bool,
     pub render_try_index: bool,
     pub enable_cors: bool,
+    pub assets_path: Option<PathBuf>,
+    pub log_http: LogHttp,
     #[cfg(feature = "tls")]
     pub tls: Option<(Vec<Certificate>, PrivateKey)>,
     #[cfg(not(feature = "tls"))]
@@ -182,16 +209,16 @@ impl Args {
     /// If a parsing error ocurred, exit the process and print out informative
     /// error message to user.
     pub fn parse(matches: ArgMatches) -> BoxResult<Args> {
-        let port = matches.value_of_t::<u16>("port")?;
+        let port = *matches.get_one::<u16>("port").unwrap();
         let addrs = matches
-            .values_of("bind")
-            .map(|v| v.collect())
+            .get_many::<String>("bind")
+            .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 path = Args::parse_path(matches.value_of_os("path").unwrap_or_default())?;
+        let addrs: Vec<BindAddr> = Args::parse_addrs(&addrs)?;
+        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() {
@@ -199,29 +226,32 @@ impl Args {
         } else {
             format!("/{}/", &encode_uri(&path_prefix))
         };
-        let hidden: String = matches
-            .value_of("hidden")
-            .map(|v| format!(",{},", v))
+        let hidden: Vec<String> = matches
+            .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")
-            .map(|v| v.collect())
+            .get_many::<String>("auth")
+            .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_delete = matches.is_present("allow-all") || matches.is_present("allow-delete");
-        let allow_search = matches.is_present("allow-all") || matches.is_present("allow-search");
-        let allow_symlink = matches.is_present("allow-all") || matches.is_present("allow-symlink");
-        let render_index = matches.is_present("render-index");
-        let render_try_index = matches.is_present("render-try-index");
-        let render_spa = matches.is_present("render-spa");
+        let allow_upload = matches.get_flag("allow-all") || matches.get_flag("allow-upload");
+        let allow_delete = matches.get_flag("allow-all") || matches.get_flag("allow-delete");
+        let allow_search = matches.get_flag("allow-all") || matches.get_flag("allow-search");
+        let allow_symlink = matches.get_flag("allow-all") || matches.get_flag("allow-symlink");
+        let render_index = matches.get_flag("render-index");
+        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)?;
@@ -231,6 +261,15 @@ impl Args {
         };
         #[cfg(not(feature = "tls"))]
         let tls = None;
+        let log_http: LogHttp = matches
+            .get_one::<String>("log-format")
+            .map(|v| v.as_str())
+            .unwrap_or(DEFAULT_LOG_FORMAT)
+            .parse()?;
+        let assets_path = match matches.get_one::<PathBuf>("assets") {
+            Some(v) => Some(Args::parse_assets_path(v)?),
+            None => None,
+        };
 
         Ok(Args {
             addrs,
@@ -251,26 +290,32 @@ impl Args {
             render_try_index,
             render_spa,
             tls,
+            log_http,
+            assets_path,
         })
     }
 
-    fn parse_addrs(addrs: &[&str]) -> BoxResult<Vec<IpAddr>> {
-        let mut ip_addrs = vec![];
+    fn parse_addrs(addrs: &[&str]) -> BoxResult<Vec<BindAddr>> {
+        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(_) => {
+                    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());
         }
-        Ok(ip_addrs)
+        Ok(bind_addrs)
     }
 
     fn parse_path<P: AsRef<Path>>(path: P) -> BoxResult<PathBuf> {
@@ -286,4 +331,18 @@ impl Args {
             })
             .map_err(|err| format!("Failed to access path `{}`: {}", path.display(), err,).into())
     }
+
+    fn parse_assets_path<P: AsRef<Path>>(path: P) -> BoxResult<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());
+        }
+        Ok(path)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub enum BindAddr {
+    Address(IpAddr),
+    Path(PathBuf),
 }

src/auth.rs

@@ -12,6 +12,7 @@ use crate::utils::encode_uri;
 use crate::BoxResult;
 
 const REALM: &str = "DUFS";
+const DIGEST_AUTH_TIMEOUT: u32 = 86400;
 
 lazy_static! {
     static ref NONCESTARTHASH: Context = {
@@ -131,7 +132,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> {
@@ -197,6 +203,24 @@ impl AuthMethod {
             }
         }
     }
+    pub fn get_user(&self, authorization: &HeaderValue) -> Option<String> {
+        match self {
+            AuthMethod::Basic => {
+                let value: Vec<u8> =
+                    base64::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()?;
+                digest_vals
+                    .get(b"username".as_ref())
+                    .and_then(|b| std::str::from_utf8(b).ok())
+                    .map(|v| v.to_string())
+            }
+        }
+    }
     pub fn validate(
         &self,
         authorization: &HeaderValue,
@@ -206,10 +230,9 @@ impl AuthMethod {
     ) -> Option<()> {
         match self {
             AuthMethod::Basic => {
-                let value: Vec<u8> =
-                    base64::decode(strip_prefix(authorization.as_bytes(), b"Basic ").unwrap())
-                        .unwrap();
-                let parts: Vec<&str> = std::str::from_utf8(&value).unwrap().split(':').collect();
+                let basic_value: Vec<u8> =
+                    base64::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 {
                     return None;
@@ -228,13 +251,13 @@ impl AuthMethod {
             }
             AuthMethod::Digest => {
                 let digest_value = strip_prefix(authorization.as_bytes(), b"Digest ")?;
-                let user_vals = to_headermap(digest_value).ok()?;
+                let digest_vals = to_headermap(digest_value).ok()?;
                 if let (Some(username), Some(nonce), Some(user_response)) = (
-                    user_vals
+                    digest_vals
                         .get(b"username".as_ref())
-                        .and_then(|b| std::str::from_utf8(*b).ok()),
-                    user_vals.get(b"nonce".as_ref()),
-                    user_vals.get(b"response".as_ref()),
+                        .and_then(|b| std::str::from_utf8(b).ok()),
+                    digest_vals.get(b"nonce".as_ref()),
+                    digest_vals.get(b"response".as_ref()),
                 ) {
                     match validate_nonce(nonce) {
                         Ok(true) => {}
@@ -246,24 +269,24 @@ impl AuthMethod {
                     let mut ha = Context::new();
                     ha.consume(method);
                     ha.consume(b":");
-                    if let Some(uri) = user_vals.get(b"uri".as_ref()) {
+                    if let Some(uri) = digest_vals.get(b"uri".as_ref()) {
                         ha.consume(uri);
                     }
                     let ha = format!("{:x}", ha.compute());
                     let mut correct_response = None;
-                    if let Some(qop) = user_vals.get(b"qop".as_ref()) {
+                    if let Some(qop) = digest_vals.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) = user_vals.get(b"nc".as_ref()) {
+                                if let Some(nc) = digest_vals.get(b"nc".as_ref()) {
                                     c.consume(nc);
                                 }
                                 c.consume(b":");
-                                if let Some(cnonce) = user_vals.get(b"cnonce".as_ref()) {
+                                if let Some(cnonce) = digest_vals.get(b"cnonce".as_ref()) {
                                     c.consume(cnonce);
                                 }
                                 c.consume(b":");
@@ -278,7 +301,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,8 +340,7 @@ fn validate_nonce(nonce: &[u8]) -> Result<bool, ()> {
                 h.consume(secs_nonce.to_be_bytes());
                 let h = format!("{:x}", h.compute());
                 if h[..26] == n[8..34] {
-                    return Ok(dur < 300); // from the last 5min
-                                          //Authentication-Info ?
+                    return Ok(dur < DIGEST_AUTH_TIMEOUT);
                 }
             }
         }
@@ -340,12 +362,12 @@ fn strip_prefix<'a>(search: &'a [u8], prefix: &[u8]) -> Option<&'a [u8]> {
 
 fn to_headermap(header: &[u8]) -> Result<HashMap<&[u8], &[u8]>, ()> {
     let mut sep = Vec::new();
-    let mut asign = Vec::new();
+    let mut assign = Vec::new();
     let mut i: usize = 0;
     let mut esc = false;
     for c in header {
         match (c, esc) {
-            (b'=', false) => asign.push(i),
+            (b'=', false) => assign.push(i),
             (b',', false) => sep.push(i),
             (b'"', false) => esc = true,
             (b'"', true) => esc = false,
@@ -357,7 +379,7 @@ fn to_headermap(header: &[u8]) -> Result<HashMap<&[u8], &[u8]>, ()> {
 
     i = 0;
     let mut ret = HashMap::new();
-    for (&k, &a) in sep.iter().zip(asign.iter()) {
+    for (&k, &a) in sep.iter().zip(assign.iter()) {
         while header[i] == b' ' {
             i += 1;
         }

src/log_http.rs

@@ -0,0 +1,99 @@
+use std::{collections::HashMap, str::FromStr, sync::Arc};
+
+use crate::{args::Args, server::Request};
+
+pub const DEFAULT_LOG_FORMAT: &str = r#"$remote_addr "$request" $status"#;
+
+#[derive(Debug)]
+pub struct LogHttp {
+    elems: Vec<LogElement>,
+}
+
+#[derive(Debug)]
+enum LogElement {
+    Variable(String),
+    Header(String),
+    Literal(String),
+}
+
+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() {
+            match elem {
+                LogElement::Variable(name) => match name.as_str() {
+                    "request" => {
+                        data.insert(name.to_string(), format!("{} {}", req.method(), req.uri()));
+                    }
+                    "remote_user" => {
+                        if let Some(user) = req
+                            .headers()
+                            .get("authorization")
+                            .and_then(|v| args.auth_method.get_user(v))
+                        {
+                            data.insert(name.to_string(), user);
+                        }
+                    }
+                    _ => {}
+                },
+                LogElement::Header(name) => {
+                    if let Some(value) = req.headers().get(name).and_then(|v| v.to_str().ok()) {
+                        data.insert(name.to_string(), value.to_string());
+                    }
+                }
+                LogElement::Literal(_) => {}
+            }
+        }
+        data
+    }
+    pub fn log(&self, data: &HashMap<String, String>, err: Option<String>) {
+        if self.elems.is_empty() {
+            return;
+        }
+        let mut output = String::new();
+        for elem in self.elems.iter() {
+            match elem {
+                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("-"))
+                }
+            }
+        }
+        match err {
+            Some(err) => error!("{} {}", output, err),
+            None => info!("{}", output),
+        }
+    }
+}
+
+impl FromStr for LogHttp {
+    type Err = Box<dyn std::error::Error>;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let mut elems = vec![];
+        let mut is_var = false;
+        let mut cache = String::new();
+        for c in format!("{} ", s).chars() {
+            if c == '$' {
+                if !cache.is_empty() {
+                    elems.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()));
+                } else if let Some(value) = cache.strip_prefix('$') {
+                    elems.push(LogElement::Variable(value.to_string()));
+                }
+                cache.clear();
+                is_var = false;
+            }
+            cache.push(c);
+        }
+        let cache = cache.trim();
+        if !cache.is_empty() {
+            elems.push(LogElement::Literal(cache.to_string()));
+        }
+        Ok(Self { elems })
+    }
+}

src/main.rs

@@ -1,10 +1,13 @@
 mod args;
 mod auth;
+mod log_http;
 mod logger;
 mod server;
 mod streamer;
 #[cfg(feature = "tls")]
 mod tls;
+#[cfg(unix)]
+mod unix;
 mod utils;
 
 #[macro_use]
@@ -19,6 +22,7 @@ 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;
@@ -74,11 +78,9 @@ fn serve(
     let inner = Arc::new(Server::new(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))
-            .map_err(|e| format!("Failed to bind `{}:{}`, {}", ip, port, e))?;
-        let serv_func = move |remote_addr: SocketAddr| {
+        let serve_func = move |remote_addr: Option<SocketAddr>| {
             let inner = inner.clone();
             async move {
                 Ok::<_, hyper::Error>(service_fn(move |req: Request| {
@@ -87,6 +89,10 @@ fn serve(
                 }))
             }
         };
+        match bind_addr {
+            BindAddr::Address(ip) => {
+                let incoming = create_addr_incoming(SocketAddr::new(*ip, port))
+                    .map_err(|e| format!("Failed to bind `{}:{}`, {}", ip, port, e))?;
                 match args.tls.as_ref() {
                     #[cfg(feature = "tls")]
                     Some((certs, key)) => {
@@ -98,9 +104,10 @@ fn serve(
                         let accepter = TlsAcceptor::new(config.clone(), incoming);
                         let new_service = make_service_fn(move |socket: &TlsStream| {
                             let remote_addr = socket.remote_addr();
-                    serv_func(remote_addr)
+                            serve_func(Some(remote_addr))
                         });
-                let server = tokio::spawn(hyper::Server::builder(accepter).serve(new_service));
+                        let server =
+                            tokio::spawn(hyper::Server::builder(accepter).serve(new_service));
                         handles.push(server);
                     }
                     #[cfg(not(feature = "tls"))]
@@ -110,13 +117,30 @@ fn serve(
                     None => {
                         let new_service = make_service_fn(move |socket: &AddrStream| {
                             let remote_addr = socket.remote_addr();
-                    serv_func(remote_addr)
+                            serve_func(Some(remote_addr))
                         });
-                let server = tokio::spawn(hyper::Server::builder(incoming).serve(new_service));
+                        let server =
+                            tokio::spawn(hyper::Server::builder(incoming).serve(new_service));
                         handles.push(server);
                     }
                 };
             }
+            BindAddr::Path(path) => {
+                if path.exists() {
+                    std::fs::remove_file(path)?;
+                }
+                #[cfg(unix)]
+                {
+                    let listener = tokio::net::UnixListener::bind(path)
+                        .map_err(|e| format!("Failed to bind `{}`, {}", path.display(), e))?;
+                    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);
+                }
+            }
+        }
+    }
     Ok(handles)
 }
 
@@ -136,9 +160,11 @@ fn create_addr_incoming(addr: SocketAddr) -> BoxResult<AddrIncoming> {
 }
 
 fn print_listening(args: Arc<Args>) -> BoxResult<()> {
-    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() {
+        match bind_addr {
+            BindAddr::Address(ip) => {
                 if ip.is_unspecified() {
                     if ip.is_ipv6() {
                         ipv6 = true;
@@ -146,7 +172,10 @@ fn print_listening(args: Arc<Args>) -> BoxResult<()> {
                         ipv4 = true;
                     }
                 } else {
-            addrs.push(*ip);
+                    bind_addrs.push(bind_addr.clone());
+                }
+            }
+            _ => bind_addrs.push(bind_addr.clone()),
         }
     }
     if ipv4 || ipv6 {
@@ -155,25 +184,27 @@ fn print_listening(args: Arc<Args>) -> BoxResult<()> {
         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();
-    let urls = addrs
+    bind_addrs.sort_unstable();
+    let urls = bind_addrs
         .into_iter()
-        .map(|addr| match addr {
+        .map(|bind_addr| match bind_addr {
+            BindAddr::Address(addr) => {
+                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 {

src/server.rs

@@ -1,5 +1,5 @@
 use crate::streamer::Streamer;
-use crate::utils::{decode_uri, encode_uri, get_file_name, try_get_file_name};
+use crate::utils::{decode_uri, encode_uri, get_file_name, glob, try_get_file_name};
 use crate::{Args, BoxResult};
 use walkdir::WalkDir;
 use xml::escape::escape_str_pcdata;
@@ -19,6 +19,8 @@ use hyper::header::{
 };
 use hyper::{Body, Method, StatusCode, Uri};
 use serde::Serialize;
+use std::borrow::Cow;
+use std::collections::HashMap;
 use std::fs::Metadata;
 use std::io::SeekFrom;
 use std::net::SocketAddr;
@@ -45,6 +47,7 @@ const BUF_SIZE: usize = 65536;
 pub struct Server {
     args: Arc<Args>,
     assets_prefix: String,
+    html: Cow<'static, str>,
     single_file_req_paths: Vec<String>,
     running: Arc<AtomicBool>,
 }
@@ -65,29 +68,37 @@ impl Server {
         } else {
             vec![]
         };
+        let html = match args.assets_path.as_ref() {
+            Some(path) => Cow::Owned(std::fs::read_to_string(path.join("index.html")).unwrap()),
+            None => Cow::Borrowed(INDEX_HTML),
+        };
         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 method = req.method().clone();
         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);
+        if let Some(addr) = addr {
+            http_log_data.insert("remote_addr".to_string(), addr.ip().to_string());
+        }
 
-        let mut res = match self.handle(req).await {
+        let mut res = match self.clone().handle(req).await {
             Ok(res) => {
-                let status = res.status().as_u16();
+                http_log_data.insert("status".to_string(), res.status().as_u16().to_string());
                 if !uri.path().starts_with(&assets_prefix) {
-                    info!(r#"{} "{} {}" - {}"#, addr.ip(), method, uri, status,);
+                    self.args.log_http.log(&http_log_data, None);
                 }
                 res
             }
@@ -95,8 +106,10 @@ impl Server {
                 let mut res = Response::default();
                 let status = StatusCode::INTERNAL_SERVER_ERROR;
                 *res.status_mut() = status;
-                let status = status.as_u16();
-                error!(r#"{} "{} {}" - {} {}"#, addr.ip(), method, uri, status, err);
+                http_log_data.insert("status".to_string(), status.as_u16().to_string());
+                self.args
+                    .log_http
+                    .log(&http_log_data, Some(err.to_string()));
                 res
             }
         };
@@ -114,7 +127,7 @@ impl Server {
         let headers = req.headers();
         let method = req.method().clone();
 
-        if method == Method::GET && self.handle_embed_assets(req_path, &mut res).await? {
+        if method == Method::GET && self.handle_assets(req_path, headers, &mut res).await? {
             return Ok(res);
         }
 
@@ -157,6 +170,9 @@ 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()),
@@ -179,27 +195,32 @@ impl Server {
             Method::GET | Method::HEAD => {
                 if is_dir {
                     if render_try_index {
-                        if query == "zip" {
+                        if query_params.contains_key("zip") {
                             self.handle_zip_dir(path, head_only, &mut res).await?;
-                        } else if allow_search && query.starts_with("q=") {
-                            let q = decode_uri(&query[2..]).unwrap_or_default();
-                            self.handle_search_dir(path, &q, head_only, &mut res)
+                        } else if allow_search && query_params.contains_key("q") {
+                            self.handle_search_dir(path, &query_params, head_only, &mut res)
                                 .await?;
                         } else {
-                            self.handle_render_index(path, headers, head_only, &mut res)
+                            self.handle_render_index(
+                                path,
+                                &query_params,
+                                headers,
+                                head_only,
+                                &mut res,
+                            )
                             .await?;
                         }
                     } else if render_index || render_spa {
-                        self.handle_render_index(path, headers, head_only, &mut res)
+                        self.handle_render_index(path, &query_params, headers, head_only, &mut res)
                             .await?;
-                    } else if query == "zip" {
+                    } else if query_params.contains_key("zip") {
                         self.handle_zip_dir(path, head_only, &mut res).await?;
-                    } else if allow_search && query.starts_with("q=") {
-                        let q = decode_uri(&query[2..]).unwrap_or_default();
-                        self.handle_search_dir(path, &q, head_only, &mut res)
+                    } else if allow_search && query_params.contains_key("q") {
+                        self.handle_search_dir(path, &query_params, head_only, &mut res)
                             .await?;
                     } else {
-                        self.handle_ls_dir(path, true, head_only, &mut res).await?;
+                        self.handle_ls_dir(path, true, &query_params, head_only, &mut res)
+                            .await?;
                     }
                 } else if is_file {
                     self.handle_send_file(path, headers, head_only, &mut res)
@@ -208,7 +229,8 @@ impl Server {
                     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, head_only, &mut res).await?;
+                    self.handle_ls_dir(path, false, &query_params, head_only, &mut res)
+                        .await?;
                 } else {
                     status_not_found(&mut res);
                 }
@@ -250,8 +272,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?;
                     }
@@ -341,6 +366,7 @@ impl Server {
         &self,
         path: &Path,
         exist: bool,
+        query_params: &HashMap<String, String>,
         head_only: bool,
         res: &mut Response,
     ) -> BoxResult<()> {
@@ -354,21 +380,23 @@ impl Server {
                 }
             }
         };
-        self.send_index(path, paths, exist, head_only, res)
+        self.send_index(path, paths, exist, query_params, head_only, res)
     }
 
     async fn handle_search_dir(
         &self,
         path: &Path,
-        search: &str,
+        query_params: &HashMap<String, String>,
         head_only: bool,
         res: &mut Response,
     ) -> BoxResult<()> {
         let mut paths: Vec<PathItem> = vec![];
+        let search = query_params.get("q").unwrap().to_lowercase();
+        if !search.is_empty() {
             let path_buf = path.to_path_buf();
-        let hidden = self.args.hidden.to_string();
+            let hidden = Arc::new(self.args.hidden.to_vec());
+            let hidden = hidden.clone();
             let running = self.running.clone();
-        let search = search.to_lowercase();
             let search_paths = tokio::task::spawn_blocking(move || {
                 let mut it = WalkDir::new(&path_buf).into_iter();
                 let mut paths: Vec<PathBuf> = vec![];
@@ -401,7 +429,8 @@ impl Server {
                     paths.push(item);
                 }
             }
-        self.send_index(path, paths, true, head_only, res)
+        }
+        self.send_index(path, paths, true, query_params, head_only, res)
     }
 
     async fn handle_zip_dir(
@@ -441,6 +470,7 @@ impl Server {
     async fn handle_render_index(
         &self,
         path: &Path,
+        query_params: &HashMap<String, String>,
         headers: &HeaderMap<HeaderValue>,
         head_only: bool,
         res: &mut Response,
@@ -455,7 +485,8 @@ 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, head_only, res).await?;
+            self.handle_ls_dir(path, true, query_params, head_only, res)
+                .await?;
         } else {
             status_not_found(res)
         }
@@ -479,9 +510,19 @@ impl Server {
         Ok(())
     }
 
-    async fn handle_embed_assets(&self, req_path: &str, res: &mut Response) -> BoxResult<bool> {
+    async fn handle_assets(
+        &self,
+        req_path: &str,
+        headers: &HeaderMap<HeaderValue>,
+        res: &mut Response,
+    ) -> BoxResult<bool> {
         if let Some(name) = req_path.strip_prefix(&self.assets_prefix) {
-            match name {
+            match self.args.assets_path.as_ref() {
+                Some(assets_path) => {
+                    let path = assets_path.join(name);
+                    self.handle_send_file(&path, headers, false, res).await?;
+                }
+                None => match name {
                     "index.js" => {
                         *res.body_mut() = Body::from(INDEX_JS);
                         res.headers_mut().insert(
@@ -500,8 +541,9 @@ impl Server {
                             .insert("content-type", HeaderValue::from_static("image/x-icon"));
                     }
                     _ => {
-                    return Ok(false);
+                        status_not_found(res);
                     }
+                },
             }
             res.headers_mut().insert(
                 "cache-control",
@@ -558,7 +600,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(
@@ -750,10 +792,30 @@ impl Server {
         path: &Path,
         mut paths: Vec<PathItem>,
         exist: bool,
+        query_params: &HashMap<String, String>,
         head_only: bool,
         res: &mut Response,
     ) -> BoxResult<()> {
+        if let Some(sort) = query_params.get("sort") {
+            if sort == "name" {
+                paths.sort_by(|v1, v2| {
+                    alphanumeric_sort::compare_str(v1.name.to_lowercase(), v2.name.to_lowercase())
+                })
+            } else if sort == "mtime" {
+                paths.sort_by(|v1, v2| v1.mtime.cmp(&v2.mtime))
+            } else if sort == "size" {
+                paths.sort_by(|v1, v2| v1.size.unwrap_or(0).cmp(&v2.size.unwrap_or(0)))
+            }
+            if query_params
+                .get("order")
+                .map(|v| v == "desc")
+                .unwrap_or_default()
+            {
+                paths.reverse()
+            }
+        } else {
             paths.sort_unstable();
+        }
         let href = format!("/{}", normalize_path(path.strip_prefix(&self.args.path)?));
         let data = IndexData {
             href,
@@ -765,23 +827,10 @@ impl Server {
             dir_exists: exist,
         };
         let data = serde_json::to_string(&data).unwrap();
-        let asset_js = format!("{}index.js", self.assets_prefix);
-        let asset_css = format!("{}index.css", self.assets_prefix);
-        let asset_ico = format!("{}favicon.ico", self.assets_prefix);
-        let output = INDEX_HTML.replace(
-            "__SLOT__",
-            &format!(
-                r#"
-<link rel="icon" type="image/x-icon" href="{}">
-<link rel="stylesheet" href="{}">
-<script>
-DATA = {}
-</script>
-<script src="{}"></script>
-"#,
-                asset_ico, asset_css, data, asset_js
-            ),
-        );
+        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()
@@ -850,7 +899,11 @@ DATA = {}
     }
 
     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 {
@@ -860,7 +913,7 @@ DATA = {}
             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> {
@@ -1065,12 +1118,12 @@ fn res_multistatus(res: &mut Response, content: &str) {
 async fn zip_dir<W: AsyncWrite + Unpin>(
     writer: &mut W,
     dir: &Path,
-    hidden: &str,
+    hidden: &[String],
     running: Arc<AtomicBool>,
 ) -> BoxResult<()> {
     let mut writer = ZipFileWriter::new(writer);
-    let hidden = Arc::new(hidden.to_string());
-    let hidden = hidden.to_string();
+    let hidden = Arc::new(hidden.to_vec());
+    let hidden = hidden.clone();
     let dir_path_buf = dir.to_path_buf();
     let zip_paths = tokio::task::spawn_blocking(move || {
         let mut it = WalkDir::new(&dir_path_buf).into_iter();
@@ -1170,8 +1223,8 @@ fn status_no_content(res: &mut Response) {
     *res.status_mut() = StatusCode::NO_CONTENT;
 }
 
-fn is_hidden(hidden: &str, file_name: &str) -> bool {
-    hidden.contains(&format!(",{},", file_name))
+fn is_hidden(hidden: &[String], file_name: &str) -> bool {
+    hidden.iter().any(|v| glob(v, file_name))
 }
 
 fn set_webdav_headers(res: &mut Response) {

src/tls.rs

@@ -5,6 +5,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,11 +124,13 @@ 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>, Box<dyn std::error::Error>> {
     // Open certificate file.
-    let certfile = fs::File::open(&filename)
-        .map_err(|e| format!("Failed to access `{}`, {}", &filename, e))?;
-    let mut reader = io::BufReader::new(certfile);
+    let cert_file = fs::File::open(filename.as_ref())
+        .map_err(|e| format!("Failed to access `{}`, {}", filename.as_ref().display(), e))?;
+    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")?;
@@ -138,18 +141,21 @@ pub fn load_certs(filename: &str) -> Result<Vec<Certificate>, Box<dyn std::error
 }
 
 // Load private key from file.
-pub fn load_private_key(filename: &str) -> Result<PrivateKey, Box<dyn std::error::Error>> {
-    // Open keyfile.
-    let keyfile = fs::File::open(&filename)
-        .map_err(|e| format!("Failed to access `{}`, {}", &filename, e))?;
-    let mut reader = io::BufReader::new(keyfile);
+pub fn load_private_key<T: AsRef<Path>>(
+    filename: T,
+) -> Result<PrivateKey, Box<dyn std::error::Error>> {
+    let key_file = fs::File::open(filename.as_ref())
+        .map_err(|e| format!("Failed to access `{}`, {}", filename.as_ref().display(), e))?;
+    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))?
         .into_iter()
         .find_map(|item| match item {
-            rustls_pemfile::Item::RSAKey(key) | rustls_pemfile::Item::PKCS8Key(key) => Some(key),
+            rustls_pemfile::Item::RSAKey(key)
+            | rustls_pemfile::Item::PKCS8Key(key)
+            | rustls_pemfile::Item::ECKey(key) => Some(key),
             _ => None,
         })
         .ok_or("No supported private key in file")?;

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

@@ -23,3 +23,64 @@ pub fn try_get_file_name(path: &Path) -> BoxResult<&str> {
         .and_then(|v| v.to_str())
         .ok_or_else(|| format!("Failed to get file name of `{}`", path.display()).into())
 }
+
+pub fn glob(source: &str, target: &str) -> bool {
+    let ss: Vec<char> = source.chars().collect();
+    let mut iter = target.chars();
+    let mut i = 0;
+    'outer: while i < ss.len() {
+        let s = ss[i];
+        match s {
+            '*' => match ss.get(i + 1) {
+                Some(s_next) => {
+                    for t in iter.by_ref() {
+                        if t == *s_next {
+                            i += 2;
+                            continue 'outer;
+                        }
+                    }
+                    return false;
+                }
+                None => return true,
+            },
+            '?' => match iter.next() {
+                Some(_) => {
+                    i += 1;
+                    continue;
+                }
+                None => return false,
+            },
+            _ => match iter.next() {
+                Some(t) => {
+                    if s == t {
+                        i += 1;
+                        continue;
+                    }
+                    return false;
+                }
+                None => return false,
+            },
+        }
+    }
+    iter.next().is_none()
+}
+
+#[test]
+fn test_glob_key() {
+    assert!(glob("", ""));
+    assert!(glob(".*", ".git"));
+    assert!(glob("abc", "abc"));
+    assert!(glob("a*c", "abc"));
+    assert!(glob("a?c", "abc"));
+    assert!(glob("a*c", "abbc"));
+    assert!(glob("*c", "abc"));
+    assert!(glob("a*", "abc"));
+    assert!(glob("?c", "bc"));
+    assert!(glob("a?", "ab"));
+    assert!(!glob("abc", "adc"));
+    assert!(!glob("abc", "abcd"));
+    assert!(!glob("a?c", "abbc"));
+    assert!(!glob("*.log", "log"));
+    assert!(glob("*.log", ".log"));
+    assert!(glob("*.log", "a.log"));
+}

tests/allow.rs

@@ -64,7 +64,7 @@ fn allow_upload_delete_can_override(#[with(&["-A"])] server: TestServer) -> Resu
 fn allow_search(#[with(&["--allow-search"])] server: TestServer) -> Result<(), Error> {
     let resp = reqwest::blocking::get(format!("{}?q={}", server.url(), "test.html"))?;
     assert_eq!(resp.status(), 200);
-    let paths = utils::retrive_index_paths(&resp.text()?);
+    let paths = utils::retrieve_index_paths(&resp.text()?);
     assert!(!paths.is_empty());
     for p in paths {
         assert!(p.contains("test.html"));

tests/assets.rs

@@ -1,8 +1,11 @@
 mod fixtures;
 mod utils;
 
-use fixtures::{server, Error, TestServer};
+use assert_cmd::prelude::*;
+use assert_fs::fixture::TempDir;
+use fixtures::{port, server, tmpdir, wait_for_port, Error, TestServer, DIR_ASSETS};
 use rstest::rstest;
+use std::process::{Command, Stdio};
 
 #[rstest]
 fn assets(server: TestServer) -> Result<(), Error> {
@@ -91,3 +94,29 @@ fn asset_js_with_prefix(
     );
     Ok(())
 }
+
+#[rstest]
+fn assets_override(tmpdir: TempDir, port: u16) -> Result<(), Error> {
+    let mut child = Command::cargo_bin("dufs")?
+        .arg(tmpdir.path())
+        .arg("-p")
+        .arg(port.to_string())
+        .arg("--assets")
+        .arg(tmpdir.join(DIR_ASSETS))
+        .stdout(Stdio::piped())
+        .spawn()?;
+
+    wait_for_port(port);
+
+    let url = format!("http://localhost:{}", port);
+    let resp = reqwest::blocking::get(&url)?;
+    assert!(resp.text()?.starts_with(&format!(
+        "/__dufs_v{}_index.js;DATA",
+        env!("CARGO_PKG_VERSION")
+    )));
+    let resp = reqwest::blocking::get(&url)?;
+    assert_resp_paths!(resp);
+
+    child.kill()?;
+    Ok(())
+}

tests/auth.rs

@@ -121,3 +121,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/data/cert_ecdsa.pem

@@ -0,0 +1,11 @@
+-----BEGIN CERTIFICATE-----
+MIIBfTCCASOgAwIBAgIUfrAUHXIfeM54OLnTIUD9xT6FIwkwCgYIKoZIzj0EAwIw
+FDESMBAGA1UEAwwJbG9jYWxob3N0MB4XDTIyMDgwMjAxMjQ1NFoXDTMyMDczMDAx
+MjQ1NFowFDESMBAGA1UEAwwJbG9jYWxob3N0MFkwEwYHKoZIzj0CAQYIKoZIzj0D
+AQcDQgAEW4tBe0jF2wYSLCvdreb0izR/8sgKNKkbe4xPyA9uNEbtTk58eoO3944R
+JPT6S5wRTHFpF0BJhQRfiuW4K2EUcaNTMFEwHQYDVR0OBBYEFEebUDkiMJoV2d5W
+8o+6p4DauHFFMB8GA1UdIwQYMBaAFEebUDkiMJoV2d5W8o+6p4DauHFFMA8GA1Ud
+EwEB/wQFMAMBAf8wCgYIKoZIzj0EAwIDSAAwRQIhAPJvmzqaq/S5yYxeB4se8k2z
+6pnVNxrTT2CqdPD8Z+7rAiBZAyU+5+KbQq3aZsmuNUx+YOqTDMkaUR/nd/tjnnOX
+gA==
+-----END CERTIFICATE-----

tests/data/generate_tls_certs.sh

@@ -1,3 +1,5 @@
 #!/usr/bin/env bash
 openssl req -subj '/CN=localhost' -x509 -newkey rsa:4096 -keyout key_pkcs8.pem -out cert.pem -nodes -days 3650
 openssl rsa -in key_pkcs8.pem -out key_pkcs1.pem
+openssl ecparam -name prime256v1 -genkey -noout -out key_ecdsa.pem
+openssl req -subj '/CN=localhost' -x509 -key key_ecdsa.pem -out cert_ecdsa.pem -nodes -days 3650

tests/data/key_ecdsa.pem

@@ -0,0 +1,5 @@
+-----BEGIN EC PRIVATE KEY-----
+MHcCAQEEILOQ44lHqD4w12HJKlZJ+Y3u91eUKjabu3UKPSahhC89oAoGCCqGSM49
+AwEHoUQDQgAEW4tBe0jF2wYSLCvdreb0izR/8sgKNKkbe4xPyA9uNEbtTk58eoO3
+944RJPT6S5wRTHFpF0BJhQRfiuW4K2EUcQ==
+-----END EC PRIVATE KEY-----

tests/fixtures.rs

@@ -15,11 +15,11 @@ pub type Error = Box<dyn std::error::Error>;
 #[allow(dead_code)]
 pub static FILES: &[&str] = &["test.txt", "test.html", "index.html", "😀.bin"];
 
-/// Directory names for testing diretory don't exist
+/// Directory names for testing directory don't exist
 #[allow(dead_code)]
 pub static DIR_NO_FOUND: &str = "dir-no-found/";
 
-/// Directory names for testing diretory don't have index.html
+/// Directory names for testing directory don't have index.html
 #[allow(dead_code)]
 pub static DIR_NO_INDEX: &str = "dir-no-index/";
 
@@ -27,9 +27,13 @@ pub static DIR_NO_INDEX: &str = "dir-no-index/";
 #[allow(dead_code)]
 pub static DIR_GIT: &str = ".git/";
 
+/// Directory names for testings assets override
+#[allow(dead_code)]
+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];
+pub static DIRECTORIES: &[&str] = &["dira/", "dirb/", "dirc/", 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.
@@ -44,6 +48,12 @@ pub fn tmpdir() -> TempDir {
             .expect("Couldn't write to file");
     }
     for directory in DIRECTORIES {
+        if *directory == DIR_ASSETS {
+            tmpdir
+                .child(format!("{}{}", directory, "index.html"))
+                .write_str("__ASSERTS_PREFIX__index.js;DATA = __INDEX_DATA__")
+                .expect("Couldn't write to file");
+        } else {
             for file in FILES {
                 if *directory == DIR_NO_INDEX && *file == "index.html" {
                     continue;
@@ -54,6 +64,7 @@ pub fn tmpdir() -> TempDir {
                     .expect("Couldn't write to file");
             }
         }
+    }
 
     tmpdir
 }
@@ -93,34 +104,6 @@ where
     TestServer::new(port, tmpdir, child, is_tls)
 }
 
-/// Same as `server()` but ignore stderr
-#[fixture]
-#[allow(dead_code)]
-pub fn server_no_stderr<I>(#[default(&[] as &[&str])] args: I) -> TestServer
-where
-    I: IntoIterator + Clone,
-    I::Item: AsRef<std::ffi::OsStr>,
-{
-    let port = port();
-    let tmpdir = tmpdir();
-    let child = Command::cargo_bin("dufs")
-        .expect("Couldn't find test binary")
-        .arg(tmpdir.path())
-        .arg("-p")
-        .arg(port.to_string())
-        .args(args.clone())
-        .stdout(Stdio::null())
-        .stderr(Stdio::null())
-        .spawn()
-        .expect("Couldn't run test binary");
-    let is_tls = args
-        .into_iter()
-        .any(|x| x.as_ref().to_str().unwrap().contains("tls"));
-
-    wait_for_port(port);
-    TestServer::new(port, tmpdir, child, is_tls)
-}
-
 /// Wait a max of 1s for the port to become available.
 pub fn wait_for_port(port: u16) {
     let start_wait = Instant::now();

tests/hidden.rs

@@ -10,12 +10,26 @@ use rstest::rstest;
 fn hidden_get_dir(#[case] server: TestServer, #[case] exist: bool) -> Result<(), Error> {
     let resp = reqwest::blocking::get(server.url())?;
     assert_eq!(resp.status(), 200);
-    let paths = utils::retrive_index_paths(&resp.text()?);
+    let paths = utils::retrieve_index_paths(&resp.text()?);
+    assert!(paths.contains("dira/"));
     assert_eq!(paths.contains(".git/"), exist);
     assert_eq!(paths.contains("index.html"), exist);
     Ok(())
 }
 
+#[rstest]
+#[case(server(&[] as &[&str]), true)]
+#[case(server(&["--hidden", "*.html"]), false)]
+fn hidden_get_dir2(#[case] server: TestServer, #[case] exist: bool) -> Result<(), Error> {
+    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_eq!(paths.contains("index.html"), exist);
+    assert_eq!(paths.contains("test.html"), exist);
+    Ok(())
+}
+
 #[rstest]
 #[case(server(&[] as &[&str]), true)]
 #[case(server(&["--hidden", ".git,index.html"]), false)]
@@ -23,6 +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_eq!(body.contains("<D:href>/.git/</D:href>"), exist);
     assert_eq!(body.contains("<D:href>/index.html</D:href>"), exist);
     Ok(())
@@ -34,7 +49,7 @@ fn hidden_propfind_dir(#[case] server: TestServer, #[case] exist: bool) -> Resul
 fn hidden_search_dir(#[case] server: TestServer, #[case] exist: bool) -> Result<(), Error> {
     let resp = reqwest::blocking::get(format!("{}?q={}", server.url(), "test.html"))?;
     assert_eq!(resp.status(), 200);
-    let paths = utils::retrive_index_paths(&resp.text()?);
+    let paths = utils::retrieve_index_paths(&resp.text()?);
     for p in paths {
         assert_eq!(p.contains("test.html"), exist);
     }

tests/http.rs

@@ -66,7 +66,7 @@ fn head_dir_zip(server: TestServer) -> Result<(), Error> {
 fn get_dir_search(#[with(&["-A"])] server: TestServer) -> Result<(), Error> {
     let resp = reqwest::blocking::get(format!("{}?q={}", server.url(), "test.html"))?;
     assert_eq!(resp.status(), 200);
-    let paths = utils::retrive_index_paths(&resp.text()?);
+    let paths = utils::retrieve_index_paths(&resp.text()?);
     assert!(!paths.is_empty());
     for p in paths {
         assert!(p.contains("test.html"));
@@ -78,7 +78,7 @@ fn get_dir_search(#[with(&["-A"])] server: TestServer) -> Result<(), Error> {
 fn get_dir_search2(#[with(&["-A"])] server: TestServer) -> Result<(), Error> {
     let resp = reqwest::blocking::get(format!("{}?q={}", server.url(), "😀.bin"))?;
     assert_eq!(resp.status(), 200);
-    let paths = utils::retrive_index_paths(&resp.text()?);
+    let paths = utils::retrieve_index_paths(&resp.text()?);
     assert!(!paths.is_empty());
     for p in paths {
         assert!(p.contains("😀.bin"));
@@ -98,6 +98,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()))?;

tests/log_http.rs

@@ -0,0 +1,78 @@
+mod fixtures;
+mod utils;
+
+use diqwest::blocking::WithDigestAuth;
+use fixtures::{port, tmpdir, wait_for_port, Error};
+
+use assert_cmd::prelude::*;
+use assert_fs::fixture::TempDir;
+use rstest::rstest;
+use std::io::Read;
+use std::process::{Command, Stdio};
+
+#[rstest]
+#[case(&["-a", "/@user:pass", "--log-format", "$remote_user"], false)]
+#[case(&["-a", "/@user:pass", "--log-format", "$remote_user", "--auth-method", "basic"], true)]
+fn log_remote_user(
+    tmpdir: TempDir,
+    port: u16,
+    #[case] args: &[&str],
+    #[case] is_basic: bool,
+) -> Result<(), Error> {
+    let mut child = Command::cargo_bin("dufs")?
+        .arg(tmpdir.path())
+        .arg("-p")
+        .arg(port.to_string())
+        .args(args)
+        .stdout(Stdio::piped())
+        .spawn()?;
+
+    wait_for_port(port);
+
+    let stdout = child.stdout.as_mut().expect("Failed to get stdout");
+
+    let req = fetch!(b"GET", &format!("http://localhost:{}", port));
+
+    let resp = if is_basic {
+        req.basic_auth("user", Some("pass")).send()?
+    } else {
+        req.send_with_digest_auth("user", "pass")?
+    };
+
+    assert_eq!(resp.status(), 200);
+
+    let mut buf = [0; 1000];
+    let buf_len = stdout.read(&mut buf)?;
+    let output = std::str::from_utf8(&buf[0..buf_len])?;
+
+    assert!(output.lines().last().unwrap().ends_with("user"));
+
+    child.kill()?;
+    Ok(())
+}
+
+#[rstest]
+#[case(&["--log-format", ""])]
+fn no_log(tmpdir: TempDir, port: u16, #[case] args: &[&str]) -> Result<(), Error> {
+    let mut child = Command::cargo_bin("dufs")?
+        .arg(tmpdir.path())
+        .arg("-p")
+        .arg(port.to_string())
+        .args(args)
+        .stdout(Stdio::piped())
+        .spawn()?;
+
+    wait_for_port(port);
+
+    let stdout = child.stdout.as_mut().expect("Failed to get stdout");
+
+    let resp = fetch!(b"GET", &format!("http://localhost:{}", port)).send()?;
+    assert_eq!(resp.status(), 200);
+
+    let mut buf = [0; 1000];
+    let buf_len = stdout.read(&mut buf)?;
+    let output = std::str::from_utf8(&buf[0..buf_len])?;
+
+    assert_eq!(output.lines().last().unwrap(), "");
+    Ok(())
+}

tests/render.rs

@@ -56,7 +56,7 @@ fn render_try_index3(#[with(&["--render-try-index"])] server: TestServer) -> Res
 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"))?;
     assert_eq!(resp.status(), 200);
-    let paths = utils::retrive_index_paths(&resp.text()?);
+    let paths = utils::retrieve_index_paths(&resp.text()?);
     assert!(!paths.is_empty());
     assert_eq!(paths.iter().all(|v| v.contains("😀.bin")), searched);
     Ok(())

tests/sort.rs

@@ -0,0 +1,29 @@
+mod fixtures;
+mod utils;
+
+use fixtures::{server, Error, TestServer};
+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 paths1 = self::utils::retrieve_index_paths(&resp.text()?);
+    let resp = reqwest::blocking::get(format!("{}?sort=name&order=desc", url))?;
+    let mut paths2 = self::utils::retrieve_index_paths(&resp.text()?);
+    paths2.reverse();
+    assert_eq!(paths1, paths2);
+    Ok(())
+}
+
+#[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 paths1 = self::utils::retrieve_index_paths(&resp.text()?);
+    let resp = reqwest::blocking::get(format!("{}?q={}&sort=name&order=desc", url, "test.html"))?;
+    let mut paths2 = self::utils::retrieve_index_paths(&resp.text()?);
+    paths2.reverse();
+    assert_eq!(paths1, paths2);
+    Ok(())
+}

tests/symlink.rs

@@ -20,7 +20,7 @@ fn default_not_allow_symlink(server: TestServer, tmpdir: TempDir) -> Result<(),
     let resp = reqwest::blocking::get(format!("{}{}/index.html", server.url(), dir))?;
     assert_eq!(resp.status(), 404);
     let resp = reqwest::blocking::get(server.url())?;
-    let paths = utils::retrive_index_paths(&resp.text()?);
+    let paths = utils::retrieve_index_paths(&resp.text()?);
     assert!(!paths.is_empty());
     assert!(!paths.contains(&format!("{}/", dir)));
     Ok(())
@@ -39,7 +39,7 @@ fn allow_symlink(
     let resp = reqwest::blocking::get(format!("{}{}/index.html", server.url(), dir))?;
     assert_eq!(resp.status(), 200);
     let resp = reqwest::blocking::get(server.url())?;
-    let paths = utils::retrive_index_paths(&resp.text()?);
+    let paths = utils::retrieve_index_paths(&resp.text()?);
     assert!(!paths.is_empty());
     assert!(paths.contains(&format!("{}/", dir)));
     Ok(())

tests/tls.rs

@@ -17,6 +17,10 @@ use rstest::rstest;
         "--tls-cert", "tests/data/cert.pem",
         "--tls-key", "tests/data/key_pkcs1.pem",
 ]))]
+#[case(server(&[
+        "--tls-cert", "tests/data/cert_ecdsa.pem",
+        "--tls-key", "tests/data/key_ecdsa.pem",
+]))]
 fn tls_works(#[case] server: TestServer) -> Result<(), Error> {
     let client = ClientBuilder::new()
         .danger_accept_invalid_certs(true)
@@ -30,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`"));
@@ -42,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

@@ -1,5 +1,5 @@
+use indexmap::IndexSet;
 use serde_json::Value;
-use std::collections::HashSet;
 
 #[macro_export]
 macro_rules! assert_resp_paths {
@@ -9,7 +9,7 @@ macro_rules! assert_resp_paths {
     ($resp:ident, $files:expr) => {
         assert_eq!($resp.status(), 200);
         let body = $resp.text()?;
-        let paths = self::utils::retrive_index_paths(&body);
+        let paths = self::utils::retrieve_index_paths(&body);
         assert!(!paths.is_empty());
         for file in $files {
             assert!(paths.contains(&file.to_string()));
@@ -25,8 +25,8 @@ macro_rules! fetch {
 }
 
 #[allow(dead_code)]
-pub fn retrive_index_paths(index: &str) -> HashSet<String> {
-    retrive_index_paths_impl(index).unwrap_or_default()
+pub fn retrieve_index_paths(index: &str) -> IndexSet<String> {
+    retrieve_index_paths_impl(index).unwrap_or_default()
 }
 
 #[allow(dead_code)]
@@ -35,10 +35,11 @@ pub fn encode_uri(v: &str) -> String {
     parts.join("/")
 }
 
-fn retrive_index_paths_impl(index: &str) -> Option<HashSet<String>> {
+fn retrieve_index_paths_impl(index: &str) -> Option<IndexSet<String>> {
     let lines: Vec<&str> = index.lines().collect();
     let line = lines.iter().find(|v| v.contains("DATA ="))?;
-    let value: Value = line[7..].parse().ok()?;
+    let line_col = line.find("DATA =").unwrap() + 6;
+    let value: Value = line[line_col..].parse().ok()?;
     let paths = value
         .get("paths")?
         .as_array()?

tests/webdav.rs

@@ -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!("{}dira", 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());