chore(release): version v0.22.0

chore: update args help message and readme
feat: support hiding folders with --hidden (#73 )
2026-04-09 00:59:02 +03:00 · 2022-06-26 12:43:20 +08:00 · 2022-06-25 09:58:39 +08:00 · 2022-06-25 08:15:16 +08:00 · 2022-06-23 19:34:38 +08:00 · 2022-06-21 23:01:00 +08:00
25 changed files with 710 additions and 355 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,37 @@

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

+## [0.22.0] - 2022-06-25
+
+### Features
+
+- Support hiding folders with --hidden ([#73](https://github.com/sigoden/dufs/issues/73))
+
+## [0.21.0] - 2022-06-23
+
+### Bug Fixes
+
+- Escape name contains html escape code ([#65](https://github.com/sigoden/dufs/issues/65))
+
+### Features
+
+- Use custom logger with timestamp in rfc3339 ([#67](https://github.com/sigoden/dufs/issues/67))
+
+### Refactor
+
+- Split css/js from index.html ([#68](https://github.com/sigoden/dufs/issues/68))
+
+## [0.20.0] - 2022-06-20
+
+### Bug Fixes
+
+- DecodeURI searching string ([#61](https://github.com/sigoden/dufs/issues/61))
+
+### Features
+
+- Added basic auth ([#60](https://github.com/sigoden/dufs/issues/60))
+- Add option --allow-search ([#62](https://github.com/sigoden/dufs/issues/62))
+
 ## [0.19.0] - 2022-06-19

 ### Features
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -423,6 +423,7 @@ dependencies = [
 "bitflags",
 "clap_lex",
 "indexmap",
+ "terminal_size",
 "textwrap",
 ]

@@ -571,7 +572,7 @@ checksum = "fea41bba32d969b513997752735605054bc0dfa92b4c56bf1189f2e174be7a10"

 [[package]]
 name = "dufs"
-version = "0.19.0"
+version = "0.22.0"
 dependencies = [
 "assert_cmd",
 "assert_fs",
@@ -582,7 +583,6 @@ dependencies = [
 "chrono",
 "clap",
 "diqwest",
- "env_logger",
 "futures",
 "get_if_addrs",
 "headers",
@@ -628,16 +628,6 @@ dependencies = [
 "cfg-if",
 ]

-[[package]]
-name = "env_logger"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b2cf0344971ee6c64c31be0d530793fba457d322dfec2810c453d0ef228f9c3"
-dependencies = [
- "humantime",
- "log",
-]
-
 [[package]]
 name = "event-listener"
 version = "2.5.2"
@@ -1032,12 +1022,6 @@ version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c4a1e36c821dbe04574f602848a19f742f4fb3c98d40449f11bcad18d6b17421"

-[[package]]
-name = "humantime"
-version = "2.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"
-
 [[package]]
 name = "hyper"
 version = "0.14.19"
@@ -2146,6 +2130,16 @@ dependencies = [
 "utf-8",
 ]

+[[package]]
+name = "terminal_size"
+version = "0.1.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "633c1a546cee861a1a6d0dc69ebeca693bf4296661ba7852b9d21d159e0506df"
+dependencies = [
+ "libc",
+ "winapi 0.3.9",
+]
+
 [[package]]
 name = "termtree"
 version = "0.2.4"
@@ -2157,6 +2151,9 @@ name = "textwrap"
 version = "0.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b1141d4d61095b28419e22cb0bbf02755f5e54e0526f97f1e3d1d160e60885fb"
+dependencies = [
+ "terminal_size",
+]

 [[package]]
 name = "thiserror"
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,9 +1,9 @@
 [package]
 name = "dufs"
-version = "0.19.0"
+version = "0.22.0"
 edition = "2021"
 authors = ["sigoden <sigoden@gmail.com>"]
-description = "Dufs is a simple file server."
+description = "Dufs is a distinctive utility file server"
 license = "MIT OR Apache-2.0"
 homepage = "https://github.com/sigoden/dufs"
 repository = "https://github.com/sigoden/dufs"
@@ -11,7 +11,7 @@ categories = ["command-line-utilities", "web-programming::http-server"]
 keywords = ["static", "file", "server", "webdav", "cli"]

 [dependencies]
-clap = { version = "3", default-features = false, features = ["std"] }
+clap = { version = "3", default-features = false, features = ["std", "wrap_help"] }
 chrono = "0.4"
 tokio = { version = "1", features = ["rt-multi-thread", "macros", "fs", "io-util", "signal"]}
 tokio-rustls = "0.23"
@@ -34,7 +34,6 @@ lazy_static = "1.4"
 uuid = { version = "1.1", features = ["v4", "fast-rng"] }
 urlencoding = "2.1"
 xml-rs = "0.8"
-env_logger = { version = "0.9", default-features = false, features = ["humantime"] }
 log = "0.4"
 socket2 = "0.4"
 async-stream = "0.3"
--- a/README.md
+++ b/README.md
@@ -1,9 +1,9 @@
-# Dufs (Old Name: Duf)
+# Dufs

 [![CI](https://github.com/sigoden/dufs/actions/workflows/ci.yaml/badge.svg)](https://github.com/sigoden/dufs/actions/workflows/ci.yaml)
 [![Crates](https://img.shields.io/crates/v/dufs.svg)](https://crates.io/crates/dufs)

-Dufs is a simple file server. Support static serve, search, upload, webdav...
+Dufs is a distinctive utility file server that supports static serving, uploading, searching, accessing control, webdav...

 ![demo](https://user-images.githubusercontent.com/4012553/174486522-7af350e6-0195-4f4a-8480-d9464fc6452f.png)

@@ -40,57 +40,96 @@ Download from [Github Releases](https://github.com/sigoden/dufs/releases), unzip
 ## CLI

 ```
-Dufs is a simple file server. - https://github.com/sigoden/dufs
+Dufs is a distinctive utility file server - https://github.com/sigoden/dufs

 USAGE:
    dufs [OPTIONS] [--] [path]

 ARGS:
-    <path>    Path to a root directory for serving files [default: .]
+    <path>    Specific path to serve [default: .]

 OPTIONS:
-    -b, --bind <addr>...        Specify bind address
-    -p, --port <port>           Specify port to listen on [default: 5000]
-        --path-prefix <path>    Specify an url path prefix
-    -a, --auth <rule>...        Add auth for path
-    -A, --allow-all             Allow all operations
-        --allow-upload          Allow upload files/folders
-        --allow-delete          Allow delete files/folders
-        --allow-symlink         Allow symlink to files/folders outside root directory
-        --enable-cors           Enable CORS, sets `Access-Control-Allow-Origin: *`
-        --render-index          Render index.html when requesting a directory
-        --render-try-index      Render index.html if it exists when requesting a directory
-        --render-spa            Render for single-page application
-        --tls-cert <path>       Path to an SSL/TLS certificate to serve with HTTPS
-        --tls-key <path>        Path to the SSL/TLS certificate's private key
-    -h, --help                  Print help information
-    -V, --version               Print version information
+    -b, --bind <addr>...         Specify bind address
+    -p, --port <port>            Specify port to listen on [default: 5000]
+        --path-prefix <path>     Specify an path prefix
+        --hidden <value>         Hide directories from directory listings, separated by `,`
+    -a, --auth <rule>...         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
+        --allow-delete           Allow delete files/folders
+        --allow-search           Allow search files/folders
+        --allow-symlink          Allow symlink to files/folders outside root directory
+        --enable-cors            Enable CORS, sets `Access-Control-Allow-Origin: *`
+        --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)
+        --tls-cert <path>        Path to an SSL/TLS certificate to serve with HTTPS
+        --tls-key <path>         Path to the SSL/TLS certificate's private key
+    -h, --help                   Print help information
+    -V, --version                Print version information
 ```

 ## Examples

-Serve current working directory, no upload/delete
+Serve current working directory

 ```
 dufs
 ```

-Allow upload/delete
+Explicitly allow all operations including upload/delete 

 ```
 dufs -A
 ```

+Only allow upload operation
+
+```
+dufs --allow-upload
+```
+
+Serve a directory
+
+```
+dufs Downloads
+```
+
+Serve a single file
+
+```
+dufs linux-distro.iso
+```
+
+Serve index.html when requesting a directory
+
+```
+dufs --render-index
+```
+
+Serve SPA(Single Page Application)
+
+```
+dufs --render-spa
+```
+
+Require username/password
+
+```
+dufs -a /@admin:123
+```
+
 Listen on a specific port

 ```
 dufs -p 80
 ```

-For a single page application (SPA)
+Hide directories from directory listings

 ```
-dufs --render-spa
+dufs --hidden .git,.DS_Store
 ```

 Use https
@@ -124,63 +163,28 @@ Delete a file/folder
 curl -X DELETE http://127.0.0.1:5000/path-to-file
 ```

-## Details
+## Access Control

-<details>
-<summary>
-
-#### 1. Control render logic
-
-</summary>
-
-
-The default render logic is:
-
-  If request for a folder, rendering the directory listing. 
-  If request for a file, rendering the file.
-  If request target does not exist, returns 404.
-
-The `--render-*` options change the render logic:
-
- `--render-index`: If request for a folder, rendering index.html in the folder. If the index.html file does not exist, return 404.
- `--render-try-index`: Like `--render-index`, rendering the directory listing if the index.html file does not exist, other than return 404.
- `--render-spa`: If request target does not exist, rendering `/index.html`
-
-</details>
-
-<details>
-<summary>
-
-#### 2. Path level access control
-
-</summary>
+Dufs 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>[@<readonly>|@*]
 ```

- `<path>`: Path to protected
- `<readwrite>`: Account with readwrite permission, required
- `<readonly>`: Account with readonly permission, optional
+- `<path>`: Protected url path
+- `<readwrite>`: Account with upload/delete/view/download permission, required
+- `<readonly>`: Account with view/download permission, optional

-> `*` as `<readonly>` means `<path>` is public, everyone can access/download it.
+> `*` means `<path>` is public, everyone can view/download it.

 For example:

 ```
 dufs -a /@admin:pass@* -a /ui@designer:pass1 -A
 ```
- All files/folders are public to access/download.
- Account `admin:pass` can upload/delete/download any files/folders.
- Account `designer:pass1` can upload/delete/download any files/folders in the `ui` folder.
-
-Curl with digest auth:
-
-```
-curl --digest -u designer:pass1 http://127.0.0.1:5000/ui/path-to-file
-```
-
-</details>
+- All files/folders are public to view/download.
+- Account `admin:pass` can upload/delete/view/download any files/folders.
+- Account `designer:pass1` can upload/delete/view/download any files/folders in the `ui` folder.

 ## License

--- a/assets/index.css
+++ b/assets/index.css
@@ -1,11 +1,16 @@
 html {
-  font-family: -apple-system,BlinkMacSystemFont,Helvetica,Arial,sans-serif;
+  font-family: -apple-system,BlinkMacSystemFont,Roboto,Helvetica,Arial,sans-serif;
  line-height: 1.5;
  color: #24292e;
 }

+body {
+  /* prevent premature breadcrumb wrapping on mobile */
+  min-width: 500px;
+}
+
 .hidden {
-  display: none;
+  display: none !important;
 }

 .head {
@@ -49,6 +54,11 @@ html {
  margin-right: 10px;
 }

+.toolbox > div {
+  /* vertically align with breadcrumb text */
+  height: 1.1rem;
+}
+
 .searchbar {
  display: flex;
  flex-wrap: nowrap;
@@ -116,11 +126,6 @@ html {
  white-space: nowrap;
 }

-.uploaders-table .cell-name,
-.paths-table .cell-name {
-  width: 500px;
-}
-
 .uploaders-table .cell-status {
  width: 80px;
  padding-left: 0.6em;
@@ -143,7 +148,6 @@ html {
  padding-left: 0.6em;
 }

-
 .path svg {
  height: 100%;
  fill: rgba(3,47,98,0.5);
@@ -163,7 +167,7 @@ html {
  display: block;
  text-decoration: none;
  max-width: calc(100vw - 375px);
-  min-width: 400px;
+  min-width: 200px;
 }

 .path a:hover {
@@ -182,6 +186,12 @@ html {
  padding-right: 1em;
 }

+@media (min-width: 768px) {
+  .path a {
+    min-width: 400px;
+  }
+}
+
 /* dark theme */
@media (prefers-color-scheme: dark) {
  body {
@@ -200,7 +210,8 @@ html {
  }

  svg,
-  .path svg {
+  .path svg,
+  .breadcrumb svg {
    fill: #fff;
  }

--- a/assets/index.html
+++ b/assets/index.html
@@ -22,7 +22,7 @@
        <input type="file" id="file" name="file" multiple>
      </div>
    </div>
-    <form class="searchbar">
+    <form class="searchbar hidden">
      <div class="icon">
        <svg width="16" height="16" fill="currentColor" viewBox="0 0 16 16"><path d="M11.742 10.344a6.5 6.5 0 1 0-1.397 1.398h-.001c.03.04.062.078.098.115l3.85 3.85a1 1 0 0 0 1.415-1.414l-3.85-3.85a1.007 1.007 0 0 0-.115-.1zM12 6.5a5.5 5.5 0 1 1-11 0 5.5 5.5 0 0 1 11 0z"/></svg>
      </div>
--- a/assets/index.js
+++ b/assets/index.js
@@ -64,14 +64,16 @@ class Uploader {

  upload() {
    const { file, idx, name } = this;
-    let url = getUrl(name);
+    const url = getUrl(name);
+    const encodedUrl = encodedStr(url);
+    const encodedName = encodedStr(name);
    $uploadersTable.insertAdjacentHTML("beforeend", `
  <tr id="upload${idx}" class="uploader">
    <td class="path cell-icon">
      ${getSvg(file.path_type)}
    </td>
    <td class="path cell-name">
-      <a href="${url}">${name}</a>
+      <a href="${encodedUrl}">${encodedName}</a>
    </td>
    <td class="cell-status upload-status" id="uploadStatus${idx}"></td>
  </tr>`);
@@ -141,12 +143,14 @@ function addBreadcrumb(href, uri_prefix) {
      }
      path += encodeURI(name);
    }
+    const encodedPath = encodedStr(path);
+    const encodedName = encodedStr(name);
    if (i === 0) {
-      $breadcrumb.insertAdjacentHTML("beforeend", `<a href="${path}"><svg width="16" height="16" viewBox="0 0 16 16"><path d="M6.5 14.5v-3.505c0-.245.25-.495.5-.495h2c.25 0 .5.25.5.5v3.5a.5.5 0 0 0 .5.5h4a.5.5 0 0 0 .5-.5v-7a.5.5 0 0 0-.146-.354L13 5.793V2.5a.5.5 0 0 0-.5-.5h-1a.5.5 0 0 0-.5.5v1.293L8.354 1.146a.5.5 0 0 0-.708 0l-6 6A.5.5 0 0 0 1.5 7.5v7a.5.5 0 0 0 .5.5h4a.5.5 0 0 0 .5-.5z"/></svg></a>`);
+      $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>`);
    } else if (i === len - 1) {
-      $breadcrumb.insertAdjacentHTML("beforeend", `<b>${name}</b>`);
+      $breadcrumb.insertAdjacentHTML("beforeend", `<b>${encodedName}</b>`);
    } else {
-      $breadcrumb.insertAdjacentHTML("beforeend", `<a href="${path}">${name}</a>`);
+      $breadcrumb.insertAdjacentHTML("beforeend", `<a href="${encodedPath}">${encodedName}</a>`);
    }
    if (i !== len - 1) {
      $breadcrumb.insertAdjacentHTML("beforeend", `<span class="separator">/</span>`);
@@ -160,28 +164,31 @@ function addBreadcrumb(href, uri_prefix) {
 * @param {number} index 
 */
 function addPath(file, index) {
+  const encodedName = encodedStr(file.name);
  let url = getUrl(file.name)
+  let encodedUrl = encodedStr(url);
  let actionDelete = "";
  let actionDownload = "";
  if (file.path_type.endsWith("Dir")) {
    url += "/";
+    encodedUrl += "/";
    actionDownload = `
    <div class="action-btn">
-      <a href="${url}?zip" title="Download folder as a .zip file">
+      <a href="${encodedUrl}?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="${url}" title="Download file" download>
+      <a href="${encodedUrl}" 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>`;
  }
  if (DATA.allow_delete) {
    actionDelete = `
-    <div onclick="deletePath(${index})" class="action-btn" id="deleteBtn${index}" title="Delete ${file.name}">
+    <div onclick="deletePath(${index})" class="action-btn" id="deleteBtn${index}" title="Delete ${encodedName}">
      <svg width="16" height="16" fill="currentColor"viewBox="0 0 16 16"><path d="M6.854 7.146a.5.5 0 1 0-.708.708L7.293 9l-1.147 1.146a.5.5 0 0 0 .708.708L8 9.707l1.146 1.147a.5.5 0 0 0 .708-.708L8.707 9l1.147-1.146a.5.5 0 0 0-.708-.708L8 8.293 6.854 7.146z"/><path d="M14 14V4.5L9.5 0H4a2 2 0 0 0-2 2v12a2 2 0 0 0 2 2h8a2 2 0 0 0 2-2zM9.5 3A1.5 1.5 0 0 0 11 4.5h2V14a1 1 0 0 1-1 1H4a1 1 0 0 1-1-1V2a1 1 0 0 1 1-1h5.5v2z"/></svg>
    </div>`;
  }
@@ -197,7 +204,7 @@ function addPath(file, index) {
    ${getSvg(file.path_type)}
  </td>
  <td class="path cell-name">
-    <a href="${url}" title="${file.name}">${file.name}</a>
+    <a href="${encodedUrl}">${encodedName}</a>
  </td>
  <td class="cell-mtime">${formatMtime(file.mtime)}</td>
  <td class="cell-size">${formatSize(file.size).join(" ")}</td>
@@ -333,16 +340,27 @@ function formatPercent(precent) {
  }
 }

+function encodedStr(rawStr) {
+  return rawStr.replace(/[\u00A0-\u9999<>\&]/g, function(i) {
+    return '&#'+i.charCodeAt(0)+';';
+  });
+}
+
 function ready() {
+  document.title = `Index of ${DATA.href} - Dufs`;
  $pathsTable = document.querySelector(".paths-table")
  $pathsTableBody = document.querySelector(".paths-table tbody");
  $uploadersTable = document.querySelector(".uploaders-table");
  $emptyFolder = document.querySelector(".empty-folder");

-  if (params.q) {
-    document.getElementById('search').value = params.q;
+  if (DATA.allow_search) {
+    document.querySelector(".searchbar").classList.remove("hidden");
+    if (params.q) {
+      document.getElementById('search').value = params.q;
+    }
  }

+
  addBreadcrumb(DATA.href, DATA.uri_prefix);
  if (Array.isArray(DATA.paths)) {
    const len = DATA.paths.length;
--- a/src/args.rs
+++ b/src/args.rs
@@ -5,6 +5,7 @@ use std::net::IpAddr;
 use std::path::{Path, PathBuf};

 use crate::auth::AccessControl;
+use crate::auth::AuthMethod;
 use crate::tls::{load_certs, load_private_key};
 use crate::BoxResult;

@@ -39,13 +40,19 @@ fn app() -> Command<'static> {
            Arg::new("path")
                .default_value(".")
                .allow_invalid_utf8(true)
-                .help("Path to a root directory for serving files"),
+                .help("Specific path to serve"),
        )
        .arg(
            Arg::new("path-prefix")
                .long("path-prefix")
                .value_name("path")
-                .help("Specify an url path prefix"),
+                .help("Specify an path prefix"),
+        )
+        .arg(
+            Arg::new("hidden")
+                .long("hidden")
+                .help("Hide directories from directory listings, separated by `,`")
+                .value_name("value"),
        )
        .arg(
            Arg::new("auth")
@@ -56,6 +63,14 @@ fn app() -> Command<'static> {
                .multiple_occurrences(true)
                .value_name("rule"),
        )
+        .arg(
+            Arg::new("auth-method")
+                .long("auth-method")
+                .help("Select auth method")
+                .possible_values(["basic", "digest"])
+                .default_value("digest")
+                .value_name("value"),
+        )
        .arg(
            Arg::new("allow-all")
                .short('A')
@@ -72,6 +87,11 @@ fn app() -> Command<'static> {
                .long("allow-delete")
                .help("Allow delete files/folders"),
        )
+        .arg(
+            Arg::new("allow-search")
+                .long("allow-search")
+                .help("Allow search files/folders"),
+        )
        .arg(
            Arg::new("allow-symlink")
                .long("allow-symlink")
@@ -85,17 +105,17 @@ fn app() -> Command<'static> {
        .arg(
            Arg::new("render-index")
                .long("render-index")
-                .help("Render index.html when requesting a directory"),
+                .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")
-                .help("Render index.html if it exists when requesting a directory"),
+                .help("Serve index.html when requesting a directory, returns directory listing if not found index.html"),
        )
        .arg(
            Arg::new("render-spa")
                .long("render-spa")
-                .help("Render for single-page application"),
+                .help("Serve SPA(Single Page Application)"),
        )
        .arg(
            Arg::new("tls-cert")
@@ -115,7 +135,7 @@ pub fn matches() -> ArgMatches {
    app().get_matches()
 }

-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct Args {
    pub addrs: Vec<IpAddr>,
    pub port: u16,
@@ -123,9 +143,12 @@ pub struct Args {
    pub path_is_file: bool,
    pub path_prefix: String,
    pub uri_prefix: String,
+    pub hidden: String,
+    pub auth_method: AuthMethod,
    pub auth: AccessControl,
    pub allow_upload: bool,
    pub allow_delete: bool,
+    pub allow_search: bool,
    pub allow_symlink: bool,
    pub render_index: bool,
    pub render_spa: bool,
@@ -157,14 +180,23 @@ impl Args {
        } else {
            format!("/{}/", &path_prefix)
        };
+        let hidden: String = matches
+            .value_of("hidden")
+            .map(|v| format!(",{},", v))
+            .unwrap_or_default();
        let enable_cors = matches.is_present("enable-cors");
        let auth: Vec<&str> = matches
            .values_of("auth")
            .map(|v| v.collect())
            .unwrap_or_default();
+        let auth_method = match matches.value_of("auth-method").unwrap() {
+            "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");
@@ -185,10 +217,13 @@ impl Args {
            path_is_file,
            path_prefix,
            uri_prefix,
+            hidden,
+            auth_method,
            auth,
            enable_cors,
            allow_delete,
            allow_upload,
+            allow_search,
            allow_symlink,
            render_index,
            render_try_index,
--- a/src/auth.rs
+++ b/src/auth.rs
@@ -22,12 +22,12 @@ lazy_static! {
    };
 }

-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct AccessControl {
    rules: HashMap<String, PathControl>,
 }

-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct PathControl {
    readwrite: Account,
    readonly: Option<Account>,
@@ -76,6 +76,7 @@ impl AccessControl {
        path: &str,
        method: &Method,
        authorization: Option<&HeaderValue>,
+        auth_method: AuthMethod,
    ) -> GuardType {
        if self.rules.is_empty() {
            return GuardType::ReadWrite;
@@ -86,7 +87,10 @@ impl AccessControl {
                controls.push(control);
                if let Some(authorization) = authorization {
                    let Account { user, pass } = &control.readwrite;
-                    if valid_digest(authorization, method.as_str(), user, pass).is_some() {
+                    if auth_method
+                        .validate(authorization, method.as_str(), user, pass)
+                        .is_some()
+                    {
                        return GuardType::ReadWrite;
                    }
                }
@@ -99,7 +103,10 @@ impl AccessControl {
                }
                if let Some(authorization) = authorization {
                    if let Some(Account { user, pass }) = &control.readonly {
-                        if valid_digest(authorization, method.as_str(), user, pass).is_some() {
+                        if auth_method
+                            .validate(authorization, method.as_str(), user, pass)
+                            .is_some()
+                        {
                            return GuardType::ReadOnly;
                        }
                    }
@@ -167,87 +174,127 @@ impl Account {
    }
 }

-pub fn generate_www_auth(stale: bool) -> String {
-    let str_stale = if stale { "stale=true," } else { "" };
-    format!(
-        "Digest realm=\"{}\",nonce=\"{}\",{}qop=\"auth\"",
-        REALM,
-        create_nonce(),
-        str_stale
-    )
+#[derive(Debug, Clone)]
+pub enum AuthMethod {
+    Basic,
+    Digest,
 }

-pub fn valid_digest(
-    authorization: &HeaderValue,
-    method: &str,
-    auth_user: &str,
-    auth_pass: &str,
-) -> Option<()> {
-    let digest_value = strip_prefix(authorization.as_bytes(), b"Digest ")?;
-    let user_vals = to_headermap(digest_value).ok()?;
-    if let (Some(username), Some(nonce), Some(user_response)) = (
-        user_vals
-            .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()),
-    ) {
-        match validate_nonce(nonce) {
-            Ok(true) => {}
-            _ => return None,
-        }
-        if auth_user != username {
-            return None;
-        }
-        let mut ha = Context::new();
-        ha.consume(method);
-        ha.consume(b":");
-        if let Some(uri) = user_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 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(b":");
-                    c.consume(nonce);
-                    c.consume(b":");
-                    if let Some(nc) = user_vals.get(b"nc".as_ref()) {
-                        c.consume(nc);
-                    }
-                    c.consume(b":");
-                    if let Some(cnonce) = user_vals.get(b"cnonce".as_ref()) {
-                        c.consume(cnonce);
-                    }
-                    c.consume(b":");
-                    c.consume(qop);
-                    c.consume(b":");
-                    c.consume(&*ha);
-                    format!("{:x}", c.compute())
-                });
+impl AuthMethod {
+    pub fn www_auth(&self, stale: bool) -> String {
+        match self {
+            AuthMethod::Basic => {
+                format!("Basic realm=\"{}\"", REALM)
            }
-        }
-        let correct_response = match correct_response {
-            Some(r) => r,
-            None => {
-                let mut c = Context::new();
-                c.consume(&auth_pass);
-                c.consume(b":");
-                c.consume(nonce);
-                c.consume(b":");
-                c.consume(&*ha);
-                format!("{:x}", c.compute())
+            AuthMethod::Digest => {
+                let str_stale = if stale { "stale=true," } else { "" };
+                format!(
+                    "Digest realm=\"{}\",nonce=\"{}\",{}qop=\"auth\"",
+                    REALM,
+                    create_nonce(),
+                    str_stale
+                )
+            }
+        }
+    }
+    pub fn validate(
+        &self,
+        authorization: &HeaderValue,
+        method: &str,
+        auth_user: &str,
+        auth_pass: &str,
+    ) -> 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();
+
+                if parts[0] != auth_user {
+                    return None;
+                }
+
+                let mut h = Context::new();
+                h.consume(format!("{}:{}:{}", parts[0], REALM, parts[1]).as_bytes());
+
+                let http_pass = format!("{:x}", h.compute());
+
+                if http_pass == auth_pass {
+                    return Some(());
+                }
+
+                None
+            }
+            AuthMethod::Digest => {
+                let digest_value = strip_prefix(authorization.as_bytes(), b"Digest ")?;
+                let user_vals = to_headermap(digest_value).ok()?;
+                if let (Some(username), Some(nonce), Some(user_response)) = (
+                    user_vals
+                        .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()),
+                ) {
+                    match validate_nonce(nonce) {
+                        Ok(true) => {}
+                        _ => return None,
+                    }
+                    if auth_user != username {
+                        return None;
+                    }
+                    let mut ha = Context::new();
+                    ha.consume(method);
+                    ha.consume(b":");
+                    if let Some(uri) = user_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 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(b":");
+                                c.consume(nonce);
+                                c.consume(b":");
+                                if let Some(nc) = user_vals.get(b"nc".as_ref()) {
+                                    c.consume(nc);
+                                }
+                                c.consume(b":");
+                                if let Some(cnonce) = user_vals.get(b"cnonce".as_ref()) {
+                                    c.consume(cnonce);
+                                }
+                                c.consume(b":");
+                                c.consume(qop);
+                                c.consume(b":");
+                                c.consume(&*ha);
+                                format!("{:x}", c.compute())
+                            });
+                        }
+                    }
+                    let correct_response = match correct_response {
+                        Some(r) => r,
+                        None => {
+                            let mut c = Context::new();
+                            c.consume(&auth_pass);
+                            c.consume(b":");
+                            c.consume(nonce);
+                            c.consume(b":");
+                            c.consume(&*ha);
+                            format!("{:x}", c.compute())
+                        }
+                    };
+                    if correct_response.as_bytes() == *user_response {
+                        // grant access
+                        return Some(());
+                    }
+                }
+                None
            }
-        };
-        if correct_response.as_bytes() == *user_response {
-            // grant access
-            return Some(());
        }
    }
-    None
 }

 /// Check if a nonce is still valid.
--- a/src/logger.rs
+++ b/src/logger.rs
@@ -0,0 +1,30 @@
+use chrono::{Local, SecondsFormat};
+use log::{Level, Metadata, Record};
+use log::{LevelFilter, SetLoggerError};
+
+struct SimpleLogger;
+
+impl log::Log for SimpleLogger {
+    fn enabled(&self, metadata: &Metadata) -> bool {
+        metadata.level() <= Level::Info
+    }
+
+    fn log(&self, record: &Record) {
+        if self.enabled(record.metadata()) {
+            let timestamp = Local::now().to_rfc3339_opts(SecondsFormat::Secs, true);
+            if record.level() < Level::Info {
+                eprintln!("{} {} - {}", timestamp, record.level(), record.args());
+            } else {
+                println!("{} {} - {}", timestamp, record.level(), record.args());
+            }
+        }
+    }
+
+    fn flush(&self) {}
+}
+
+static LOGGER: SimpleLogger = SimpleLogger;
+
+pub fn init() -> Result<(), SetLoggerError> {
+    log::set_logger(&LOGGER).map(|()| log::set_max_level(LevelFilter::Info))
+}
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,5 +1,6 @@
 mod args;
 mod auth;
+mod logger;
 mod server;
 mod streamer;
 mod tls;
@@ -12,9 +13,8 @@ use crate::args::{matches, Args};
 use crate::server::{Request, Server};
 use crate::tls::{TlsAcceptor, TlsStream};

-use std::io::Write;
 use std::net::{IpAddr, SocketAddr, TcpListener as StdTcpListener};
-use std::{env, sync::Arc};
+use std::sync::Arc;

 use futures::future::join_all;
 use tokio::net::TcpListener;
@@ -32,16 +32,7 @@ async fn main() {
 }

 async fn run() -> BoxResult<()> {
-    if env::var("RUST_LOG").is_err() {
-        env::set_var("RUST_LOG", "info")
-    }
-    env_logger::builder()
-        .format(|buf, record| {
-            let timestamp = buf.timestamp_millis();
-            writeln!(buf, "[{} {}] {}", timestamp, record.level(), record.args())
-        })
-        .init();
-
+    logger::init().map_err(|e| format!("Failed to init logger, {}", e))?;
    let args = Args::parse(matches())?;
    let args = Arc::new(args);
    let handles = serve(args.clone())?;
--- a/src/server.rs
+++ b/src/server.rs
@@ -1,10 +1,9 @@
-use crate::auth::generate_www_auth;
 use crate::streamer::Streamer;
-use crate::utils::{decode_uri, encode_uri};
+use crate::utils::{decode_uri, encode_uri, get_file_name, try_get_file_name};
 use crate::{Args, BoxResult};
+use async_walkdir::{Filtering, WalkDir};
 use xml::escape::escape_str_pcdata;

-use async_walkdir::WalkDir;
 use async_zip::write::{EntryOptions, ZipFileWriter};
 use async_zip::Compression;
 use chrono::{TimeZone, Utc};
@@ -45,11 +44,16 @@ const BUF_SIZE: usize = 65536;

 pub struct Server {
    args: Arc<Args>,
+    assets_prefix: String,
 }

 impl Server {
    pub fn new(args: Arc<Args>) -> Self {
-        Self { args }
+        let assets_prefix = format!("{}__dufs_v{}_", args.uri_prefix, env!("CARGO_PKG_VERSION"));
+        Self {
+            args,
+            assets_prefix,
+        }
    }

    pub async fn call(
@@ -59,12 +63,15 @@ impl Server {
    ) -> 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 res = match self.handle(req).await {
            Ok(res) => {
                let status = res.status().as_u16();
-                info!(r#"{} "{} {}" - {}"#, addr.ip(), method, uri, status,);
+                if !uri.path().starts_with(&assets_prefix) {
+                    info!(r#"{} "{} {}" - {}"#, addr.ip(), method, uri, status,);
+                }
                res
            }
            Err(err) => {
@@ -90,13 +97,17 @@ impl Server {
        let headers = req.headers();
        let method = req.method().clone();

-        if req_path == "/favicon.ico" && method == Method::GET {
-            self.handle_send_favicon(headers, &mut res).await?;
+        if method == Method::GET && self.handle_embed_assets(req_path, &mut res).await? {
            return Ok(res);
        }

        let authorization = headers.get(AUTHORIZATION);
-        let guard_type = self.args.auth.guard(req_path, &method, authorization);
+        let guard_type = self.args.auth.guard(
+            req_path,
+            &method,
+            authorization,
+            self.args.auth_method.clone(),
+        );
        if guard_type.is_reject() {
            self.auth_reject(&mut res);
            return Ok(res);
@@ -129,6 +140,7 @@ impl Server {

        let allow_upload = self.args.allow_upload;
        let allow_delete = self.args.allow_delete;
+        let allow_search = self.args.allow_search;
        let render_index = self.args.render_index;
        let render_spa = self.args.render_spa;
        let render_try_index = self.args.render_try_index;
@@ -148,8 +160,10 @@ impl Server {
                            .await?;
                    } else if query == "zip" {
                        self.handle_zip_dir(path, head_only, &mut res).await?;
-                    } else if let Some(q) = query.strip_prefix("q=") {
-                        self.handle_query_dir(path, q, 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)
+                            .await?;
                    } else {
                        self.handle_ls_dir(path, true, head_only, &mut res).await?;
                    }
@@ -309,28 +323,39 @@ impl Server {
        self.send_index(path, paths, exist, head_only, res)
    }

-    async fn handle_query_dir(
+    async fn handle_search_dir(
        &self,
        path: &Path,
-        query: &str,
+        search: &str,
        head_only: bool,
        res: &mut Response,
    ) -> BoxResult<()> {
        let mut paths: Vec<PathItem> = vec![];
-        let mut walkdir = WalkDir::new(path);
-        while let Some(entry) = walkdir.next().await {
-            if let Ok(entry) = entry {
-                if !entry
-                    .file_name()
-                    .to_string_lossy()
+        let hidden = self.args.hidden.to_string();
+        let search = search.to_string();
+        let mut walkdir = WalkDir::new(path).filter(move |entry| {
+            let hidden_cloned = hidden.clone();
+            let search_cloned = search.clone();
+            async move {
+                let entry_path = entry.path();
+                let base_name = get_file_name(&entry_path);
+                if is_hidden(&hidden_cloned, base_name) {
+                    return Filtering::IgnoreDir;
+                }
+                if !base_name
                    .to_lowercase()
-                    .contains(&query.to_lowercase())
+                    .contains(&search_cloned.to_lowercase())
                {
-                    continue;
+                    return Filtering::Ignore;
                }
                if fs::symlink_metadata(entry.path()).await.is_err() {
-                    continue;
+                    return Filtering::Ignore;
                }
+                Filtering::Continue
+            }
+        });
+        while let Some(entry) = walkdir.next().await {
+            if let Ok(entry) = entry {
                if let Ok(Some(item)) = self.to_pathitem(entry.path(), path.to_path_buf()).await {
                    paths.push(item);
                }
@@ -346,7 +371,7 @@ impl Server {
        res: &mut Response,
    ) -> BoxResult<()> {
        let (mut writer, reader) = tokio::io::duplex(BUF_SIZE);
-        let filename = get_file_name(path)?;
+        let filename = try_get_file_name(path)?;
        res.headers_mut().insert(
            CONTENT_DISPOSITION,
            HeaderValue::from_str(&format!(
@@ -361,8 +386,9 @@ impl Server {
            return Ok(());
        }
        let path = path.to_owned();
+        let hidden = self.args.hidden.clone();
        tokio::spawn(async move {
-            if let Err(e) = zip_dir(&mut writer, &path).await {
+            if let Err(e) = zip_dir(&mut writer, &path, &hidden).await {
                error!("Failed to zip {}, {}", path.display(), e);
            }
        });
@@ -412,23 +438,38 @@ impl Server {
        Ok(())
    }

-    async fn handle_send_favicon(
-        &self,
-        headers: &HeaderMap<HeaderValue>,
-        res: &mut Response,
-    ) -> BoxResult<()> {
-        let path = self.args.path.join("favicon.ico");
-        let meta = fs::metadata(&path).await.ok();
-        let is_file = meta.map(|v| v.is_file()).unwrap_or_default();
-        if is_file {
-            self.handle_send_file(path.as_path(), headers, false, res)
-                .await?;
+    async fn handle_embed_assets(&self, req_path: &str, res: &mut Response) -> BoxResult<bool> {
+        if let Some(name) = req_path.strip_prefix(&self.assets_prefix) {
+            match name {
+                "index.js" => {
+                    *res.body_mut() = Body::from(INDEX_JS);
+                    res.headers_mut().insert(
+                        "content-type",
+                        HeaderValue::from_static("application/javascript"),
+                    );
+                }
+                "index.css" => {
+                    *res.body_mut() = Body::from(INDEX_CSS);
+                    res.headers_mut()
+                        .insert("content-type", HeaderValue::from_static("text/css"));
+                }
+                "favicon.ico" => {
+                    *res.body_mut() = Body::from(FAVICON_ICO);
+                    res.headers_mut()
+                        .insert("content-type", HeaderValue::from_static("image/x-icon"));
+                }
+                _ => {
+                    return Ok(false);
+                }
+            }
+            res.headers_mut().insert(
+                "cache-control",
+                HeaderValue::from_static("max-age=2592000, public"),
+            );
+            Ok(true)
        } else {
-            *res.body_mut() = Body::from(FAVICON_ICO);
-            res.headers_mut()
-                .insert("content-type", HeaderValue::from_static("image/x-icon"));
+            Ok(false)
        }
-        Ok(())
    }

    async fn handle_send_file(
@@ -485,7 +526,7 @@ impl Server {
            );
        }

-        let filename = get_file_name(path)?;
+        let filename = try_get_file_name(path)?;
        res.headers_mut().insert(
            CONTENT_DISPOSITION,
            HeaderValue::from_str(&format!("inline; filename=\"{}\"", encode_uri(filename),))
@@ -686,26 +727,30 @@ impl Server {
        paths.sort_unstable();
        let href = format!("/{}", normalize_path(path.strip_prefix(&self.args.path)?));
        let data = IndexData {
-            href: href.clone(),
+            href,
            uri_prefix: self.args.uri_prefix.clone(),
            paths,
            allow_upload: self.args.allow_upload,
            allow_delete: self.args.allow_delete,
+            allow_search: self.args.allow_search,
            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#"
-<title>Index of {} - Dufs</title>
-<style>{}</style>
+<link rel="icon" type="image/x-icon" href="{}">
+<link rel="stylesheet" href="{}">
 <script>
-const DATA = 
-{}
-{}</script>
+DATA = {}
+</script>
+<script src="{}"></script>
 "#,
-                href, INDEX_CSS, data, INDEX_JS
+                asset_ico, asset_css, data, asset_js
            ),
        );
        res.headers_mut()
@@ -720,7 +765,7 @@ const DATA =
    }

    fn auth_reject(&self, res: &mut Response) {
-        let value = generate_www_auth(false);
+        let value = self.args.auth_method.www_auth(false);
        set_webdav_headers(res);
        res.headers_mut().typed_insert(Connection::close());
        res.headers_mut()
@@ -770,6 +815,10 @@ const DATA =
        let mut rd = fs::read_dir(entry_path).await?;
        while let Ok(Some(entry)) = rd.next_entry().await {
            let entry_path = entry.path();
+            let base_name = get_file_name(&entry_path);
+            if is_hidden(&self.args.hidden, base_name) {
+                continue;
+            }
            if let Ok(Some(item)) = self.to_pathitem(entry_path.as_path(), base_path).await {
                paths.push(item);
            }
@@ -819,6 +868,7 @@ struct IndexData {
    paths: Vec<PathItem>,
    allow_upload: bool,
    allow_delete: bool,
+    allow_search: bool,
    dir_exists: bool,
 }

@@ -877,11 +927,8 @@ impl PathItem {
            ),
        }
    }
-    fn base_name(&self) -> &str {
-        Path::new(&self.name)
-            .file_name()
-            .and_then(|v| v.to_str())
-            .unwrap_or_default()
+    pub fn base_name(&self) -> &str {
+        self.name.split('/').last().unwrap_or_default()
    }
 }

@@ -945,19 +992,30 @@ fn res_multistatus(res: &mut Response, content: &str) {
    ));
 }

-async fn zip_dir<W: AsyncWrite + Unpin>(writer: &mut W, dir: &Path) -> BoxResult<()> {
+async fn zip_dir<W: AsyncWrite + Unpin>(writer: &mut W, dir: &Path, hidden: &str) -> BoxResult<()> {
    let mut writer = ZipFileWriter::new(writer);
-    let mut walkdir = WalkDir::new(dir);
+    let hidden = hidden.to_string();
+    let mut walkdir = WalkDir::new(dir).filter(move |entry| {
+        let hidden = hidden.clone();
+        async move {
+            let entry_path = entry.path();
+            let base_name = get_file_name(&entry_path);
+            if is_hidden(&hidden, base_name) {
+                return Filtering::IgnoreDir;
+            }
+            let meta = match fs::symlink_metadata(entry.path()).await {
+                Ok(meta) => meta,
+                Err(_) => return Filtering::Ignore,
+            };
+            if !meta.is_file() {
+                return Filtering::Ignore;
+            }
+            Filtering::Continue
+        }
+    });
    while let Some(entry) = walkdir.next().await {
        if let Ok(entry) = entry {
            let entry_path = entry.path();
-            let meta = match fs::symlink_metadata(entry.path()).await {
-                Ok(meta) => meta,
-                Err(_) => continue,
-            };
-            if !meta.is_file() {
-                continue;
-            }
            let filename = match entry_path.strip_prefix(dir).ok().and_then(|v| v.to_str()) {
                Some(v) => v,
                None => continue,
@@ -1028,10 +1086,8 @@ fn status_no_content(res: &mut Response) {
    *res.status_mut() = StatusCode::NO_CONTENT;
 }

-fn get_file_name(path: &Path) -> BoxResult<&str> {
-    path.file_name()
-        .and_then(|v| v.to_str())
-        .ok_or_else(|| format!("Failed to get file name of `{}`", path.display()).into())
+fn is_hidden(hidden: &str, file_name: &str) -> bool {
+    hidden.contains(&format!(",{},", file_name))
 }

 fn set_webdav_headers(res: &mut Response) {
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -1,4 +1,5 @@
-use std::borrow::Cow;
+use crate::BoxResult;
+use std::{borrow::Cow, path::Path};

 pub fn encode_uri(v: &str) -> String {
    let parts: Vec<_> = v.split('/').map(urlencoding::encode).collect();
@@ -10,3 +11,15 @@ pub fn decode_uri(v: &str) -> Option<Cow<str>> {
        .decode_utf8()
        .ok()
 }
+
+pub fn get_file_name(path: &Path) -> &str {
+    path.file_name()
+        .and_then(|v| v.to_str())
+        .unwrap_or_default()
+}
+
+pub fn try_get_file_name(path: &Path) -> BoxResult<&str> {
+    path.file_name()
+        .and_then(|v| v.to_str())
+        .ok_or_else(|| format!("Failed to get file name of `{}`", path.display()).into())
+}
--- a/tests/allow.rs
+++ b/tests/allow.rs
@@ -59,3 +59,15 @@ fn allow_upload_delete_can_override(#[with(&["-A"])] server: TestServer) -> Resu
    assert_eq!(resp.status(), 201);
    Ok(())
 }
+
+#[rstest]
+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()?);
+    assert!(!paths.is_empty());
+    for p in paths {
+        assert!(p.contains("test.html"));
+    }
+    Ok(())
+}
--- a/tests/args.rs
+++ b/tests/args.rs
@@ -10,7 +10,7 @@ use std::process::{Command, Stdio};
 #[rstest]
 fn path_prefix_index(#[with(&["--path-prefix", "xyz"])] server: TestServer) -> Result<(), Error> {
    let resp = reqwest::blocking::get(format!("{}{}", server.url(), "xyz"))?;
-    assert_index_resp!(resp);
+    assert_resp_paths!(resp);
    Ok(())
 }

@@ -36,7 +36,6 @@ fn path_prefix_propfind(
 #[case("index.html")]
 fn serve_single_file(tmpdir: TempDir, port: u16, #[case] file: &str) -> Result<(), Error> {
    let mut child = Command::cargo_bin("dufs")?
-        .env("RUST_LOG", "false")
        .arg(tmpdir.path().join(file))
        .arg("-p")
        .arg(port.to_string())
--- a/tests/assets.rs
+++ b/tests/assets.rs
@@ -0,0 +1,93 @@
+mod fixtures;
+mod utils;
+
+use fixtures::{server, Error, TestServer};
+use rstest::rstest;
+
+#[rstest]
+fn assets(server: TestServer) -> Result<(), Error> {
+    let ver = env!("CARGO_PKG_VERSION");
+    let resp = reqwest::blocking::get(server.url())?;
+    let index_js = format!("/__dufs_v{}_index.js", ver);
+    let index_css = format!("/__dufs_v{}_index.css", ver);
+    let favicon_ico = format!("/__dufs_v{}_favicon.ico", ver);
+    let text = resp.text()?;
+    assert!(text.contains(&format!(r#"href="{}""#, index_css)));
+    assert!(text.contains(&format!(r#"href="{}""#, favicon_ico)));
+    assert!(text.contains(&format!(r#"src="{}""#, index_js)));
+    Ok(())
+}
+
+#[rstest]
+fn asset_js(server: TestServer) -> Result<(), Error> {
+    let url = format!(
+        "{}__dufs_v{}_index.js",
+        server.url(),
+        env!("CARGO_PKG_VERSION")
+    );
+    let resp = reqwest::blocking::get(url)?;
+    assert_eq!(resp.status(), 200);
+    assert_eq!(
+        resp.headers().get("content-type").unwrap(),
+        "application/javascript"
+    );
+    Ok(())
+}
+
+#[rstest]
+fn asset_css(server: TestServer) -> Result<(), Error> {
+    let url = format!(
+        "{}__dufs_v{}_index.css",
+        server.url(),
+        env!("CARGO_PKG_VERSION")
+    );
+    let resp = reqwest::blocking::get(url)?;
+    assert_eq!(resp.status(), 200);
+    assert_eq!(resp.headers().get("content-type").unwrap(), "text/css");
+    Ok(())
+}
+
+#[rstest]
+fn asset_ico(server: TestServer) -> Result<(), Error> {
+    let url = format!(
+        "{}__dufs_v{}_favicon.ico",
+        server.url(),
+        env!("CARGO_PKG_VERSION")
+    );
+    let resp = reqwest::blocking::get(url)?;
+    assert_eq!(resp.status(), 200);
+    assert_eq!(resp.headers().get("content-type").unwrap(), "image/x-icon");
+    Ok(())
+}
+
+#[rstest]
+fn assets_with_prefix(#[with(&["--path-prefix", "xyz"])] server: TestServer) -> Result<(), Error> {
+    let ver = env!("CARGO_PKG_VERSION");
+    let resp = reqwest::blocking::get(format!("{}xyz/", server.url()))?;
+    let index_js = format!("/xyz/__dufs_v{}_index.js", ver);
+    let index_css = format!("/xyz/__dufs_v{}_index.css", ver);
+    let favicon_ico = format!("/xyz/__dufs_v{}_favicon.ico", ver);
+    let text = resp.text()?;
+    assert!(text.contains(&format!(r#"href="{}""#, index_css)));
+    assert!(text.contains(&format!(r#"href="{}""#, favicon_ico)));
+    assert!(text.contains(&format!(r#"src="{}""#, index_js)));
+    Ok(())
+}
+
+#[rstest]
+fn asset_js_with_prefix(
+    #[with(&["--path-prefix", "xyz"])] server: TestServer,
+) -> Result<(), Error> {
+    let url = format!(
+        "{}xyz/__dufs_v{}_index.js",
+        server.url(),
+        env!("CARGO_PKG_VERSION")
+    );
+    let resp = reqwest::blocking::get(url)?;
+    assert_eq!(resp.status(), 200);
+    assert_eq!(
+        resp.headers().get("content-type").unwrap(),
+        "application/javascript"
+    );
+    Ok(())
+}
--- a/tests/auth.rs
+++ b/tests/auth.rs
@@ -80,3 +80,18 @@ fn auth_nest_share(
    assert_eq!(resp.status(), 200);
    Ok(())
 }
+
+#[rstest]
+fn auth_basic(
+    #[with(&["--auth", "/@user:pass", "--auth-method", "basic", "-A"])] server: TestServer,
+) -> Result<(), Error> {
+    let url = format!("{}file1", server.url());
+    let resp = fetch!(b"PUT", &url).body(b"abc".to_vec()).send()?;
+    assert_eq!(resp.status(), 401);
+    let resp = fetch!(b"PUT", &url)
+        .body(b"abc".to_vec())
+        .basic_auth("user", Some("pass"))
+        .send()?;
+    assert_eq!(resp.status(), 201);
+    Ok(())
+}
--- a/tests/bind.rs
+++ b/tests/bind.rs
@@ -6,14 +6,13 @@ use assert_cmd::prelude::*;
 use assert_fs::fixture::TempDir;
 use regex::Regex;
 use rstest::rstest;
-use std::io::{BufRead, BufReader};
+use std::io::Read;
 use std::process::{Command, Stdio};

 #[rstest]
 #[case(&["-b", "20.205.243.166"])]
 fn bind_fails(tmpdir: TempDir, port: u16, #[case] args: &[&str]) -> Result<(), Error> {
    Command::cargo_bin("dufs")?
-        .env("RUST_LOG", "false")
        .arg(tmpdir.path())
        .arg("-p")
        .arg(port.to_string())
@@ -51,7 +50,6 @@ fn bind_ipv4_ipv6(
 #[case(&["--path-prefix", "/prefix"])]
 fn validate_printed_urls(tmpdir: TempDir, port: u16, #[case] args: &[&str]) -> Result<(), Error> {
    let mut child = Command::cargo_bin("dufs")?
-        .env("RUST_LOG", "false")
        .arg(tmpdir.path())
        .arg("-p")
        .arg(port.to_string())
@@ -61,22 +59,23 @@ fn validate_printed_urls(tmpdir: TempDir, port: u16, #[case] args: &[&str]) -> R

    wait_for_port(port);

-    // WARN assumes urls list is terminated by an empty line
-    let url_lines = BufReader::new(child.stdout.take().unwrap())
+    let stdout = child.stdout.as_mut().expect("Failed to get stdout");
+    let mut buf = [0; 1000];
+    let buf_len = stdout.read(&mut buf)?;
+    let output = std::str::from_utf8(&buf[0..buf_len])?;
+    let url_lines = output
        .lines()
-        .map(|line| line.expect("Error reading stdout"))
        .take_while(|line| !line.is_empty()) /* non-empty lines */
-        .collect::<Vec<_>>();
-    let url_lines = url_lines.join("\n");
+        .collect::<Vec<_>>()
+        .join("\n");

    let urls = Regex::new(r"http://[a-zA-Z0-9\.\[\]:/]+")
        .unwrap()
        .captures_iter(url_lines.as_str())
-        .map(|caps| caps.get(0).unwrap().as_str())
+        .filter_map(|caps| caps.get(0).map(|v| v.as_str()))
        .collect::<Vec<_>>();

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

 /// File names for testing purpose
 #[allow(dead_code)]
-pub static FILES: &[&str] = &[
-    "test.txt",
-    "test.html",
-    "index.html",
-    "test.mkv",
-    #[cfg(not(windows))]
-    "test \" \' & < >.csv",
-    "😀.data",
-    "⎙.mp4",
-    "#[]{}()@!$&'`+,;= %20.test",
-    #[cfg(unix)]
-    ":?#[]{}<>()@!$&'`|*+,;= %20.test",
-    #[cfg(not(windows))]
-    "foo\\bar.test",
-];
+pub static FILES: &[&str] = &["test.txt", "test.html", "index.html", "😀.bin"];

 /// Directory names for testing diretory don't exist
 #[allow(dead_code)]
@@ -37,13 +23,13 @@ pub static DIR_NO_FOUND: &str = "dir-no-found/";
 #[allow(dead_code)]
 pub static DIR_NO_INDEX: &str = "dir-no-index/";

+/// Directory names for testing hidden
+#[allow(dead_code)]
+pub static DIR_GIT: &str = ".git/";
+
 /// Directory names for testing purpose
 #[allow(dead_code)]
-pub static DIRECTORIES: &[&str] = &["dira/", "dirb/", "dirc/", DIR_NO_INDEX];
-
-/// Name of a deeply nested file
-#[allow(dead_code)]
-pub static DEEPLY_NESTED_FILE: &str = "very/deeply/nested/test.rs";
+pub static DIRECTORIES: &[&str] = &["dira/", "dirb/", "dirc/", DIR_NO_INDEX, DIR_GIT];

 /// Test fixture which creates a temporary directory with a few files and directories inside.
 /// The directories also contain files.
@@ -69,10 +55,6 @@ pub fn tmpdir() -> TempDir {
        }
    }

-    tmpdir
-        .child(&DEEPLY_NESTED_FILE)
-        .write_str("File in a deeply nested directory.")
-        .expect("Couldn't write to file");
    tmpdir
 }

@@ -96,7 +78,6 @@ where
    let tmpdir = tmpdir();
    let child = Command::cargo_bin("dufs")
        .expect("Couldn't find test binary")
-        .env("RUST_LOG", "false")
        .arg(tmpdir.path())
        .arg("-p")
        .arg(port.to_string())
@@ -124,7 +105,6 @@ where
    let tmpdir = tmpdir();
    let child = Command::cargo_bin("dufs")
        .expect("Couldn't find test binary")
-        .env("RUST_LOG", "false")
        .arg(tmpdir.path())
        .arg("-p")
        .arg(port.to_string())
--- a/tests/hidden.rs
+++ b/tests/hidden.rs
@@ -0,0 +1,42 @@
+mod fixtures;
+mod utils;
+
+use fixtures::{server, Error, TestServer};
+use rstest::rstest;
+
+#[rstest]
+#[case(server(&[] as &[&str]), true)]
+#[case(server(&["--hidden", ".git,index.html"]), false)]
+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()?);
+    assert_eq!(paths.contains(".git/"), exist);
+    assert_eq!(paths.contains("index.html"), exist);
+    Ok(())
+}
+
+#[rstest]
+#[case(server(&[] as &[&str]), true)]
+#[case(server(&["--hidden", ".git,index.html"]), false)]
+fn hidden_propfind_dir(#[case] server: TestServer, #[case] exist: bool) -> Result<(), Error> {
+    let resp = fetch!(b"PROPFIND", server.url()).send()?;
+    assert_eq!(resp.status(), 207);
+    let body = resp.text()?;
+    assert_eq!(body.contains("<D:href>/.git/</D:href>"), exist);
+    assert_eq!(body.contains("<D:href>/index.html</D:href>"), exist);
+    Ok(())
+}
+
+#[rstest]
+#[case(server(&["--allow-search"] as &[&str]), true)]
+#[case(server(&["--allow-search", "--hidden", ".git,test.html"]), false)]
+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()?);
+    for p in paths {
+        assert_eq!(p.contains("test.html"), exist);
+    }
+    Ok(())
+}
--- a/tests/http.rs
+++ b/tests/http.rs
@@ -7,7 +7,7 @@ use rstest::rstest;
 #[rstest]
 fn get_dir(server: TestServer) -> Result<(), Error> {
    let resp = reqwest::blocking::get(server.url())?;
-    assert_index_resp!(resp);
+    assert_resp_paths!(resp);
    Ok(())
 }

@@ -63,19 +63,31 @@ fn head_dir_zip(server: TestServer) -> Result<(), Error> {
 }

 #[rstest]
-fn get_dir_search(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()?);
    assert!(!paths.is_empty());
    for p in paths {
-        assert!(p.contains(&"test.html"));
+        assert!(p.contains("test.html"));
    }
    Ok(())
 }

 #[rstest]
-fn head_dir_search(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()?);
+    assert!(!paths.is_empty());
+    for p in paths {
+        assert!(p.contains("😀.bin"));
+    }
+    Ok(())
+}
+
+#[rstest]
+fn head_dir_search(#[with(&["-A"])] server: TestServer) -> Result<(), Error> {
    let resp = fetch!(b"HEAD", format!("{}?q={}", server.url(), "test.html")).send()?;
    assert_eq!(resp.status(), 200);
    assert_eq!(
--- a/tests/render.rs
+++ b/tests/render.rs
@@ -1,7 +1,7 @@
 mod fixtures;
 mod utils;

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

 #[rstest]
@@ -30,12 +30,12 @@ fn render_try_index(#[with(&["--render-try-index"])] server: TestServer) -> Resu
 #[rstest]
 fn render_try_index2(#[with(&["--render-try-index"])] server: TestServer) -> Result<(), Error> {
    let resp = reqwest::blocking::get(format!("{}{}", server.url(), DIR_NO_INDEX))?;
-    let files: Vec<&str> = self::fixtures::FILES
+    let files: Vec<&str> = FILES
        .iter()
        .filter(|v| **v != "index.html")
        .cloned()
        .collect();
-    assert_index_resp!(resp, files);
+    assert_resp_paths!(resp, files);
    Ok(())
 }

--- a/tests/tls.rs
+++ b/tests/tls.rs
@@ -22,7 +22,7 @@ fn tls_works(#[case] server: TestServer) -> Result<(), Error> {
        .danger_accept_invalid_certs(true)
        .build()?;
    let resp = client.get(server.url()).send()?.error_for_status()?;
-    assert_index_resp!(resp);
+    assert_resp_paths!(resp);
    Ok(())
 }

--- a/tests/utils.rs
+++ b/tests/utils.rs
@@ -2,9 +2,9 @@ use serde_json::Value;
 use std::collections::HashSet;

 #[macro_export]
-macro_rules! assert_index_resp {
+macro_rules! assert_resp_paths {
    ($resp:ident) => {
-        assert_index_resp!($resp, self::fixtures::FILES)
+        assert_resp_paths!($resp, self::fixtures::FILES)
    };
    ($resp:ident, $files:expr) => {
        assert_eq!($resp.status(), 200);
@@ -37,12 +37,8 @@ pub fn encode_uri(v: &str) -> String {

 fn retrive_index_paths_impl(index: &str) -> Option<HashSet<String>> {
    let lines: Vec<&str> = index.lines().collect();
-    let (i, _) = lines
-        .iter()
-        .enumerate()
-        .find(|(_, v)| v.contains("const DATA"))?;
-    let line = lines.get(i + 1)?;
-    let value: Value = line.parse().ok()?;
+    let line = lines.iter().find(|v| v.contains("DATA ="))?;
+    let value: Value = line[7..].parse().ok()?;
    let paths = value
        .get("paths")?
        .as_array()?
Author	SHA1	Message	Date
sigoden	fe71600bd2	chore(release): version v0.22.0	2022-06-26 12:43:20 +08:00
sigoden	9cfeee0df0	chore: update args help message and readme	2022-06-25 09:58:39 +08:00
sigoden	eb7a536a3f	feat: support hiding folders with --hidden (#73 )	2022-06-25 08:15:16 +08:00
sigoden	c1c6dbc356	chore(release): version v0.21.0	2022-06-23 19:34:38 +08:00
sigoden	e29cf4c752	refactor: split css/js from index.html (#68 )	2022-06-21 23:01:00 +08:00
sigoden	7f062b6705	feat: use custom logger with timestamp in rfc3339 (#67 )	2022-06-21 21:19:51 +08:00
sigoden	ea8b9e9cce	fix: escape name contains html escape code (#65 )	2022-06-21 19:23:34 +08:00
sigoden	d2270be8fb	chore: update changelog	2022-06-21 07:56:24 +08:00
sigoden	2d0dfed456	chore(release): version v0.20.0	2022-06-21 07:52:45 +08:00
sigoden	4058a2db72	feat: add option --allow-search (#62 )	2022-06-21 07:23:20 +08:00
sigoden	069cb64889	fix: decodeURI searching string (#61 )	2022-06-20 21:51:41 +08:00
sigoden	c85ea06785	chore: update cli help message and reamde	2022-06-20 19:40:09 +08:00
sigoden	68139c6263	chore: little improves	2022-06-20 15:11:39 +08:00
Joe Koop	deb6365a28	feat: added basic auth (#60 ) * some small css fixes and changes * added basic auth https://stackoverflow.com/a/9534652/3642588 * most tests are passing * fixed all the tests * maybe now CI will pass * implemented sigoden's suggestions * test basic auth * fixed some little things	2022-06-20 11:25:09 +08:00