From 8440d59dd69594d8f09e640a02f0494544385d61 Mon Sep 17 00:00:00 2001
From: boastful-squirrel <boastful.squirrel@gmail.com>
Date: Fri, 26 Apr 2019 19:05:59 +0200
Subject: Cargo fmt

---
 src/args.rs   | 21 +++++++++++++--------
 src/auth.rs   |  9 +++++++--
 src/errors.rs |  5 ++++-
 3 files changed, 24 insertions(+), 11 deletions(-)

(limited to 'src')

diff --git a/src/args.rs b/src/args.rs
index 4077f35..b769a9b 100644
--- a/src/args.rs
+++ b/src/args.rs
@@ -80,9 +80,7 @@ fn parse_interface(src: &str) -> Result<IpAddr, std::net::AddrParseError> {
 /// Checks wether the auth string is valid, i.e. it follows the syntax username:password
 fn parse_auth(src: &str) -> Result<auth::RequiredAuth, ContextualError> {
     let mut split = src.splitn(3, ':');
-    let invalid_auth_format = Err(
-        ContextualError::new(ContextualErrorKind::InvalidAuthFormat)
-    );
+    let invalid_auth_format = Err(ContextualError::new(ContextualErrorKind::InvalidAuthFormat));
 
     let username = match split.next() {
         Some(username) => username,
@@ -100,7 +98,9 @@ fn parse_auth(src: &str) -> Result<auth::RequiredAuth, ContextualError> {
         let hash_bin = if let Ok(hash_bin) = hex::decode(hash_hex) {
             hash_bin
         } else {
-            return Err(ContextualError::new(ContextualErrorKind::InvalidPasswordHash))
+            return Err(ContextualError::new(
+                ContextualErrorKind::InvalidPasswordHash,
+            ));
         };
 
         match second_part {
@@ -108,16 +108,18 @@ fn parse_auth(src: &str) -> Result<auth::RequiredAuth, ContextualError> {
             "sha512" => auth::RequiredAuthPassword::Sha512(hash_bin.to_owned()),
             _ => {
                 return Err(ContextualError::new(
-                    ContextualErrorKind::InvalidHashMethod(second_part.to_owned())
+                    ContextualErrorKind::InvalidHashMethod(second_part.to_owned()),
                 ))
-            },
+            }
         }
     } else {
         // To make it Windows-compatible, the password needs to be shorter than 255 characters.
         // After 255 characters, Windows will truncate the value.
         // As for the username, the spec does not mention a limit in length
         if second_part.len() > 255 {
-            return Err(ContextualError::new(ContextualErrorKind::PasswordTooLongError));
+            return Err(ContextualError::new(
+                ContextualErrorKind::PasswordTooLongError,
+            ));
         }
 
         auth::RequiredAuthPassword::Plain(second_part.to_owned())
@@ -189,7 +191,10 @@ mod tests {
     }
 
     #[rstest_parametrize(
-        auth_string, username, password, encrypt,
+        auth_string,
+        username,
+        password,
+        encrypt,
         case("username:password", "username", "password", "plain"),
         case("username:sha256:abcd", "username", "abcd", "sha256"),
         case("username:sha512:abcd", "username", "abcd", "sha512")
diff --git a/src/auth.rs b/src/auth.rs
index e75f498..d8de30e 100644
--- a/src/auth.rs
+++ b/src/auth.rs
@@ -165,13 +165,18 @@ mod tests {
     }
 
     #[rstest_parametrize(
-        should_pass, param_username, param_password, required_username, required_password, encrypt,
+        should_pass,
+        param_username,
+        param_password,
+        required_username,
+        required_password,
+        encrypt,
         case(true, "obi", "hello there", "obi", "hello there", "plain"),
         case(false, "obi", "hello there", "obi", "hi!", "plain"),
         case(true, "obi", "hello there", "obi", "hello there", "sha256"),
         case(false, "obi", "hello there", "obi", "hi!", "sha256"),
         case(true, "obi", "hello there", "obi", "hello there", "sha512"),
-        case(false, "obi", "hello there", "obi", "hi!", "sha512"),
+        case(false, "obi", "hello there", "obi", "hi!", "sha512")
     )]
     fn test_auth(
         should_pass: bool,
diff --git a/src/errors.rs b/src/errors.rs
index 833e9c4..9f0a418 100644
--- a/src/errors.rs
+++ b/src/errors.rs
@@ -33,7 +33,10 @@ pub enum ContextualErrorKind {
     InvalidAuthFormat,
 
     /// This error might occure if the hash method is neither sha256 nor sha512
-    #[fail(display = "{} is not a valid hashing method. Expected sha256 or sha512", _0)]
+    #[fail(
+        display = "{} is not a valid hashing method. Expected sha256 or sha512",
+        _0
+    )]
     InvalidHashMethod(String),
 
     /// This error might occur if the HTTP auth hash password is not a valid hex code
-- 
cgit v1.2.3


From 111a3dc44730e0e24a5aa4218e8e385b236a619d Mon Sep 17 00:00:00 2001
From: boastful-squirrel <boastful.squirrel@gmail.com>
Date: Fri, 26 Apr 2019 19:09:17 +0200
Subject: Merged query parameter structs + improved file upload errors

---
 src/errors.rs      |  4 ++++
 src/file_upload.rs | 54 +++++++++++++++++++++++++++++++++---------------------
 src/listing.rs     |  5 +++--
 3 files changed, 40 insertions(+), 23 deletions(-)

(limited to 'src')

diff --git a/src/errors.rs b/src/errors.rs
index 9f0a418..d34b447 100644
--- a/src/errors.rs
+++ b/src/errors.rs
@@ -68,6 +68,10 @@ pub enum ContextualErrorKind {
         _0
     )]
     HTTPAuthenticationError(Box<ContextualError>),
+
+    /// This error might occur when an HTTP request is invalid
+    #[fail(display = "Invalid HTTP request\ncaused by: {}", _0)]
+    InvalidHTTPRequestError(String),
 }
 
 pub fn log_error_chain(description: String) {
diff --git a/src/file_upload.rs b/src/file_upload.rs
index 1618617..f444396 100644
--- a/src/file_upload.rs
+++ b/src/file_upload.rs
@@ -3,22 +3,16 @@ use actix_web::{
     HttpResponse, Query,
 };
 use futures::{future, future::FutureResult, Future, Stream};
-use serde::Deserialize;
 use std::{
     fs,
     io::Write,
     path::{Component, PathBuf},
 };
 
-use crate::errors::{self, ContextualErrorKind};
+use crate::errors::{self, ContextualError, ContextualErrorKind};
+use crate::listing::QueryParameters;
 use crate::renderer;
 
-/// Query parameters
-#[derive(Debug, Deserialize)]
-struct QueryParameters {
-    path: PathBuf,
-}
-
 /// Create future to save file.
 fn save_file(
     field: multipart::Field<dev::Payload>,
@@ -127,31 +121,49 @@ pub fn upload_file(req: &HttpRequest<crate::MiniserveConfig>) -> FutureResponse<
     } else {
         "/".to_string()
     };
-    let app_root_dir = if let Ok(dir) = req.state().path.canonicalize() {
-        dir
-    } else {
-        return Box::new(create_error_response("Internal server error", &return_path));
+
+    let app_root_dir = match req.state().path.canonicalize() {
+        Ok(dir) => dir,
+        Err(e) => {
+            let err = ContextualError::new(ContextualErrorKind::IOError(
+                "Failed to resolve path served by miniserve".to_string(),
+                e,
+            ));
+            return Box::new(create_error_response(&err.to_string(), &return_path));
+        }
     };
+
     let path = match Query::<QueryParameters>::extract(req) {
         Ok(query) => {
-            if let Ok(stripped_path) = query.path.strip_prefix(Component::RootDir) {
-                stripped_path.to_owned()
+            if let Some(path) = query.path.clone() {
+                if let Ok(stripped_path) = path.strip_prefix(Component::RootDir) {
+                    stripped_path.to_owned()
+                } else {
+                    path.clone()
+                }
             } else {
-                query.path.clone()
+                let err = ContextualError::new(ContextualErrorKind::InvalidHTTPRequestError(
+                    "Missing query parameter 'path'".to_string(),
+                ));
+                return Box::new(create_error_response(&err.to_string(), &return_path));
             }
         }
-        Err(_) => {
-            return Box::new(create_error_response(
-                "Unspecified parameter path",
-                &return_path,
-            ))
+        Err(e) => {
+            let err =
+                ContextualError::new(ContextualErrorKind::InvalidHTTPRequestError(e.to_string()));
+            return Box::new(create_error_response(&err.to_string(), &return_path));
         }
     };
 
     // If the target path is under the app root directory, save the file.
     let target_dir = match &app_root_dir.clone().join(path).canonicalize() {
         Ok(path) if path.starts_with(&app_root_dir) => path.clone(),
-        _ => return Box::new(create_error_response("Invalid path", &return_path)),
+        _ => {
+            let err = ContextualError::new(ContextualErrorKind::InvalidHTTPRequestError(
+                "Invalid value for 'path' parameter".to_string(),
+            ));
+            return Box::new(create_error_response(&err.to_string(), &return_path));
+        }
     };
     let overwrite_files = req.state().overwrite_files;
     Box::new(
diff --git a/src/listing.rs b/src/listing.rs
index a030feb..e718702 100644
--- a/src/listing.rs
+++ b/src/listing.rs
@@ -5,7 +5,7 @@ use htmlescape::encode_minimal as escape_html_entity;
 use percent_encoding::{utf8_percent_encode, DEFAULT_ENCODE_SET};
 use serde::Deserialize;
 use std::io;
-use std::path::Path;
+use std::path::{Path, PathBuf};
 use std::time::SystemTime;
 use strum_macros::{Display, EnumString};
 
@@ -16,7 +16,8 @@ use crate::themes;
 
 /// Query parameters
 #[derive(Deserialize)]
-struct QueryParameters {
+pub struct QueryParameters {
+    pub path: Option<PathBuf>,
     sort: Option<SortingMethod>,
     order: Option<SortingOrder>,
     download: Option<archive::CompressionMethod>,
-- 
cgit v1.2.3


From 4a9711b71674c6b62512dd6286869690d4497bcc Mon Sep 17 00:00:00 2001
From: boastful-squirrel <boastful.squirrel@gmail.com>
Date: Fri, 26 Apr 2019 20:08:16 +0200
Subject: Made ColorScheme, SortingMethod and SortingOrder enums derive Copy

---
 src/listing.rs  | 16 ++++++------
 src/main.rs     |  4 +--
 src/renderer.rs | 80 ++++++++++++++++++++++++++++-----------------------------
 src/themes.rs   | 10 ++++----
 4 files changed, 55 insertions(+), 55 deletions(-)

(limited to 'src')

diff --git a/src/listing.rs b/src/listing.rs
index e718702..7cc125d 100644
--- a/src/listing.rs
+++ b/src/listing.rs
@@ -25,7 +25,7 @@ pub struct QueryParameters {
 }
 
 /// Available sorting methods
-#[derive(Deserialize, Clone, EnumString, Display)]
+#[derive(Deserialize, Clone, EnumString, Display, Copy)]
 #[serde(rename_all = "snake_case")]
 #[strum(serialize_all = "snake_case")]
 pub enum SortingMethod {
@@ -40,7 +40,7 @@ pub enum SortingMethod {
 }
 
 /// Available sorting orders
-#[derive(Deserialize, Clone, EnumString, Display)]
+#[derive(Deserialize, Clone, EnumString, Display, Copy)]
 pub enum SortingOrder {
     /// Ascending order
     #[serde(alias = "asc")]
@@ -146,10 +146,10 @@ pub fn directory_listing<S>(
     let (sort_method, sort_order, download, color_scheme) =
         if let Ok(query) = Query::<QueryParameters>::extract(req) {
             (
-                query.sort.clone(),
-                query.order.clone(),
+                query.sort,
+                query.order,
                 query.download.clone(),
-                query.theme.clone(),
+                query.theme,
             )
         } else {
             (None, None, None, None)
@@ -211,7 +211,7 @@ pub fn directory_listing<S>(
         }
     }
 
-    if let Some(sorting_method) = &sort_method {
+    if let Some(sorting_method) = sort_method {
         match sorting_method {
             SortingMethod::Name => entries
                 .sort_by(|e1, e2| alphanumeric_sort::compare_str(e1.name.clone(), e2.name.clone())),
@@ -235,13 +235,13 @@ pub fn directory_listing<S>(
         entries.sort_by(|e1, e2| alphanumeric_sort::compare_str(e1.name.clone(), e2.name.clone()))
     }
 
-    if let Some(sorting_order) = &sort_order {
+    if let Some(sorting_order) = sort_order {
         if let SortingOrder::Descending = sorting_order {
             entries.reverse()
         }
     }
 
-    let color_scheme = color_scheme.unwrap_or_else(|| default_color_scheme.clone());
+    let color_scheme = color_scheme.unwrap_or_else(|| default_color_scheme);
 
     if let Some(compression_method) = &download {
         log::info!(
diff --git a/src/main.rs b/src/main.rs
index bc8f3f0..a9d44df 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -239,7 +239,7 @@ fn configure_app(app: App<MiniserveConfig>) -> App<MiniserveConfig> {
         let path = &app.state().path;
         let no_symlinks = app.state().no_symlinks;
         let random_route = app.state().random_route.clone();
-        let default_color_scheme = app.state().default_color_scheme.clone();
+        let default_color_scheme = app.state().default_color_scheme;
         let file_upload = app.state().file_upload;
         upload_route = if let Some(random_route) = app.state().random_route.clone() {
             format!("/{}/upload", random_route)
@@ -261,7 +261,7 @@ fn configure_app(app: App<MiniserveConfig>) -> App<MiniserveConfig> {
                             no_symlinks,
                             file_upload,
                             random_route.clone(),
-                            default_color_scheme.clone(),
+                            default_color_scheme,
                             u_r.clone(),
                         )
                     }),
diff --git a/src/renderer.rs b/src/renderer.rs
index b292e70..76990de 100644
--- a/src/renderer.rs
+++ b/src/renderer.rs
@@ -23,7 +23,7 @@ pub fn page(
     current_dir: &str,
 ) -> Markup {
     html! {
-        (page_header(serve_path, &color_scheme, file_upload))
+        (page_header(serve_path, color_scheme, file_upload))
         body#drop-container {
             @if file_upload {
                 div.drag-form {
@@ -32,7 +32,7 @@ pub fn page(
                     }
                 }
             }
-            (color_scheme_selector(&sort_method, &sort_order, &color_scheme, &default_color_scheme, serve_path))
+            (color_scheme_selector(sort_method, sort_order, color_scheme, default_color_scheme, serve_path))
             div.container {
                 span#top { }
                 h1.title { "Index of " (serve_path) }
@@ -56,9 +56,9 @@ pub fn page(
                 }
                 table {
                     thead {
-                        th { (build_link("name", "Name", &sort_method, &sort_order, &color_scheme, &default_color_scheme)) }
-                        th { (build_link("size", "Size", &sort_method, &sort_order, &color_scheme, &default_color_scheme)) }
-                        th { (build_link("date", "Last modification", &sort_method, &sort_order, &color_scheme, &default_color_scheme)) }
+                        th { (build_link("name", "Name", sort_method, sort_order, color_scheme, default_color_scheme)) }
+                        th { (build_link("size", "Size", sort_method, sort_order, color_scheme, default_color_scheme)) }
+                        th { (build_link("date", "Last modification", sort_method, sort_order, color_scheme, default_color_scheme)) }
                     }
                     tbody {
                         @if !is_root {
@@ -66,7 +66,7 @@ pub fn page(
                                 tr {
                                     td colspan="3" {
                                         span.root-chevron { (chevron_left()) }
-                                        a.root href=(parametrized_link(&parent, &sort_method, &sort_order, &color_scheme, &default_color_scheme)) {
+                                        a.root href=(parametrized_link(&parent, sort_method, sort_order, color_scheme, default_color_scheme)) {
                                             "Parent directory"
                                         }
                                     }
@@ -74,7 +74,7 @@ pub fn page(
                             }
                         }
                         @for entry in entries {
-                            (entry_row(entry, &sort_method, &sort_order, &color_scheme, &default_color_scheme))
+                            (entry_row(entry, sort_method, sort_order, color_scheme, default_color_scheme))
                         }
                     }
                 }
@@ -88,10 +88,10 @@ pub fn page(
 
 /// Partial: color scheme selector
 fn color_scheme_selector(
-    sort_method: &Option<SortingMethod>,
-    sort_order: &Option<SortingOrder>,
-    active_color_scheme: &ColorScheme,
-    default_color_scheme: &ColorScheme,
+    sort_method: Option<SortingMethod>,
+    sort_order: Option<SortingOrder>,
+    active_color_scheme: ColorScheme,
+    default_color_scheme: ColorScheme,
     serve_path: &str,
 ) -> Markup {
     html! {
@@ -103,13 +103,13 @@ fn color_scheme_selector(
                     }
                     ul {
                         @for color_scheme in ColorScheme::iter() {
-                            @if active_color_scheme == &color_scheme {
+                            @if active_color_scheme == color_scheme {
                                 li.active {
-                                    (color_scheme_link(&sort_method, &sort_order, &color_scheme, &default_color_scheme, serve_path))
+                                    (color_scheme_link(sort_method, sort_order, color_scheme, default_color_scheme, serve_path))
                                 }
                             } @else {
                                 li {
-                                    (color_scheme_link(&sort_method, &sort_order, &color_scheme, &default_color_scheme, serve_path))
+                                    (color_scheme_link(sort_method, sort_order, color_scheme, default_color_scheme, serve_path))
                                 }
                             }
                         }
@@ -122,18 +122,18 @@ fn color_scheme_selector(
 
 /// Partial: color scheme link
 fn color_scheme_link(
-    sort_method: &Option<SortingMethod>,
-    sort_order: &Option<SortingOrder>,
-    color_scheme: &ColorScheme,
-    default_color_scheme: &ColorScheme,
+    sort_method: Option<SortingMethod>,
+    sort_order: Option<SortingOrder>,
+    color_scheme: ColorScheme,
+    default_color_scheme: ColorScheme,
     serve_path: &str,
 ) -> Markup {
     let link = parametrized_link(
         serve_path,
-        &sort_method,
-        &sort_order,
-        &color_scheme,
-        &default_color_scheme,
+        sort_method,
+        sort_order,
+        color_scheme,
+        default_color_scheme,
     );
     let title = format!("Switch to {} theme", color_scheme);
 
@@ -165,10 +165,10 @@ fn archive_button(compress_method: CompressionMethod) -> Markup {
 /// If they are set, adds query parameters to links to keep them across pages
 fn parametrized_link(
     link: &str,
-    sort_method: &Option<SortingMethod>,
-    sort_order: &Option<SortingOrder>,
-    color_scheme: &ColorScheme,
-    default_color_scheme: &ColorScheme,
+    sort_method: Option<SortingMethod>,
+    sort_order: Option<SortingOrder>,
+    color_scheme: ColorScheme,
+    default_color_scheme: ColorScheme,
 ) -> String {
     if let Some(method) = sort_method {
         if let Some(order) = sort_order {
@@ -193,10 +193,10 @@ fn parametrized_link(
 fn build_link(
     name: &str,
     title: &str,
-    sort_method: &Option<SortingMethod>,
-    sort_order: &Option<SortingOrder>,
-    color_scheme: &ColorScheme,
-    default_color_scheme: &ColorScheme,
+    sort_method: Option<SortingMethod>,
+    sort_order: Option<SortingOrder>,
+    color_scheme: ColorScheme,
+    default_color_scheme: ColorScheme,
 ) -> Markup {
     let mut link = format!("?sort={}&order=asc", name);
     let mut help = format!("Sort by {} in ascending order", name);
@@ -231,17 +231,17 @@ fn build_link(
 /// Partial: row for an entry
 fn entry_row(
     entry: Entry,
-    sort_method: &Option<SortingMethod>,
-    sort_order: &Option<SortingOrder>,
-    color_scheme: &ColorScheme,
-    default_color_scheme: &ColorScheme,
+    sort_method: Option<SortingMethod>,
+    sort_order: Option<SortingOrder>,
+    color_scheme: ColorScheme,
+    default_color_scheme: ColorScheme,
 ) -> Markup {
     html! {
         tr {
             td {
                 p {
                     @if entry.is_dir() {
-                        a.directory href=(parametrized_link(&entry.link, &sort_method, &sort_order, &color_scheme, &default_color_scheme)) {
+                        a.directory href=(parametrized_link(&entry.link, sort_method, sort_order, color_scheme, default_color_scheme)) {
                             (entry.name) "/"
                         }
                     } @else if entry.is_file() {
@@ -256,7 +256,7 @@ fn entry_row(
                             }
                         }
                     } @else if entry.is_symlink() {
-                        a.symlink href=(parametrized_link(&entry.link, &sort_method, &sort_order, &color_scheme, &default_color_scheme)) {
+                        a.symlink href=(parametrized_link(&entry.link, sort_method, sort_order, color_scheme, default_color_scheme)) {
                            (entry.name)  span.symlink-symbol { "⇢" }
                         }
                     }
@@ -286,8 +286,8 @@ fn entry_row(
 }
 
 /// Partial: CSS
-fn css(color_scheme: &ColorScheme) -> Markup {
-    let theme = color_scheme.clone().get_theme();
+fn css(color_scheme: ColorScheme) -> Markup {
+    let theme = color_scheme.get_theme();
 
     let css = format!("
      html {{
@@ -686,7 +686,7 @@ fn chevron_down() -> Markup {
 }
 
 /// Partial: page header
-fn page_header(serve_path: &str, color_scheme: &ColorScheme, file_upload: bool) -> Markup {
+fn page_header(serve_path: &str, color_scheme: ColorScheme, file_upload: bool) -> Markup {
     html! {
         (DOCTYPE)
         html {
@@ -694,7 +694,7 @@ fn page_header(serve_path: &str, color_scheme: &ColorScheme, file_upload: bool)
             meta http-equiv="X-UA-Compatible" content="IE=edge";
             meta name="viewport" content="width=device-width, initial-scale=1";
             title { "Index of " (serve_path) }
-            style { (css(&color_scheme)) }
+            style { (css(color_scheme)) }
             @if file_upload {
                 (PreEscaped(r#"
                 <script>
diff --git a/src/themes.rs b/src/themes.rs
index a7b619e..49a1ad3 100644
--- a/src/themes.rs
+++ b/src/themes.rs
@@ -3,7 +3,7 @@ use structopt::clap::arg_enum;
 use strum_macros::EnumIter;
 
 arg_enum! {
-    #[derive(PartialEq, Deserialize, Clone, EnumIter)]
+    #[derive(PartialEq, Deserialize, Clone, EnumIter, Copy)]
     #[serde(rename_all = "lowercase")]
     pub enum ColorScheme {
         Archlinux,
@@ -17,8 +17,8 @@ impl ColorScheme {
     /// Returns the URL-compatible name of a color scheme
     /// This must correspond to the name of the variant, in lowercase
     /// See https://github.com/svenstaro/miniserve/pull/55 for explanations
-    pub fn to_slug(&self) -> String {
-        match &self {
+    pub fn to_slug(self) -> String {
+        match self {
             ColorScheme::Archlinux => "archlinux",
             ColorScheme::Zenburn => "zenburn",
             ColorScheme::Monokai => "monokai",
@@ -28,8 +28,8 @@ impl ColorScheme {
     }
 
     /// Returns wether a color scheme is dark
-    pub fn is_dark(&self) -> bool {
-        match &self {
+    pub fn is_dark(self) -> bool {
+        match self {
             ColorScheme::Archlinux => true,
             ColorScheme::Zenburn => true,
             ColorScheme::Monokai => true,
-- 
cgit v1.2.3


From fd3392636ce013cf8193a0881fa08680a8239698 Mon Sep 17 00:00:00 2001
From: boastful-squirrel <boastful.squirrel@gmail.com>
Date: Sat, 27 Apr 2019 12:12:42 +0200
Subject: Themed errors

---
 src/file_upload.rs | 108 +++++++++++++++++++++++++++++++++++++----------
 src/listing.rs     |  28 ++++++++-----
 src/main.rs        |   6 ++-
 src/renderer.rs    | 120 ++++++++++++++++++++++++++++++++++++++++++++++++-----
 src/themes.rs      |   5 +++
 5 files changed, 222 insertions(+), 45 deletions(-)

(limited to 'src')

diff --git a/src/file_upload.rs b/src/file_upload.rs
index f444396..88a4649 100644
--- a/src/file_upload.rs
+++ b/src/file_upload.rs
@@ -10,8 +10,9 @@ use std::{
 };
 
 use crate::errors::{self, ContextualError, ContextualErrorKind};
-use crate::listing::QueryParameters;
+use crate::listing::{QueryParameters, SortingMethod, SortingOrder};
 use crate::renderer;
+use crate::themes::ColorScheme;
 
 /// Create future to save file.
 fn save_file(
@@ -29,7 +30,7 @@ fn save_file(
         Ok(file) => file,
         Err(e) => {
             return Box::new(future::err(ContextualErrorKind::IOError(
-                format!("Failed to create file in {}", file_path.display()),
+                format!("Failed to create file {}", file_path.display()),
                 e,
             )));
         }
@@ -115,43 +116,77 @@ fn handle_multipart(
 /// server root directory. Any path which will go outside of this directory is considered
 /// invalid.
 /// This method returns future.
-pub fn upload_file(req: &HttpRequest<crate::MiniserveConfig>) -> FutureResponse<HttpResponse> {
+pub fn upload_file(
+    req: &HttpRequest<crate::MiniserveConfig>,
+    default_color_scheme: ColorScheme,
+) -> FutureResponse<HttpResponse> {
     let return_path = if let Some(header) = req.headers().get(header::REFERER) {
         header.to_str().unwrap_or("/").to_owned()
     } else {
         "/".to_string()
     };
 
-    let app_root_dir = match req.state().path.canonicalize() {
-        Ok(dir) => dir,
-        Err(e) => {
-            let err = ContextualError::new(ContextualErrorKind::IOError(
-                "Failed to resolve path served by miniserve".to_string(),
-                e,
-            ));
-            return Box::new(create_error_response(&err.to_string(), &return_path));
-        }
-    };
-
-    let path = match Query::<QueryParameters>::extract(req) {
+    let (path, sort_method, sort_order, color_scheme) = match Query::<QueryParameters>::extract(req)
+    {
         Ok(query) => {
+            let sort_param = query.sort;
+            let order_param = query.order;
+            let theme_param = query.theme.unwrap_or(default_color_scheme);
+
             if let Some(path) = query.path.clone() {
                 if let Ok(stripped_path) = path.strip_prefix(Component::RootDir) {
-                    stripped_path.to_owned()
+                    (
+                        stripped_path.to_owned(),
+                        sort_param,
+                        order_param,
+                        theme_param,
+                    )
                 } else {
-                    path.clone()
+                    (path.clone(), sort_param, order_param, theme_param)
                 }
             } else {
                 let err = ContextualError::new(ContextualErrorKind::InvalidHTTPRequestError(
                     "Missing query parameter 'path'".to_string(),
                 ));
-                return Box::new(create_error_response(&err.to_string(), &return_path));
+                return Box::new(create_error_response(
+                    &err.to_string(),
+                    &return_path,
+                    sort_param,
+                    order_param,
+                    theme_param,
+                    default_color_scheme,
+                ));
             }
         }
         Err(e) => {
             let err =
                 ContextualError::new(ContextualErrorKind::InvalidHTTPRequestError(e.to_string()));
-            return Box::new(create_error_response(&err.to_string(), &return_path));
+            return Box::new(create_error_response(
+                &err.to_string(),
+                &return_path,
+                None,
+                None,
+                default_color_scheme,
+                default_color_scheme,
+            ));
+        }
+    };
+
+    let app_root_dir = match req.state().path.canonicalize() {
+        Ok(dir) => dir,
+        Err(e) => {
+            let err = ContextualError::new(ContextualErrorKind::IOError(
+                "Failed to resolve path served by miniserve".to_string(),
+                e,
+            ));
+            return Box::new(create_error_response(
+                &err.to_string(),
+                &return_path,
+                sort_method,
+                sort_order,
+                color_scheme,
+                default_color_scheme,
+            ));
         }
     };
 
@@ -162,7 +197,14 @@ pub fn upload_file(req: &HttpRequest<crate::MiniserveConfig>) -> FutureResponse<
             let err = ContextualError::new(ContextualErrorKind::InvalidHTTPRequestError(
                 "Invalid value for 'path' parameter".to_string(),
             ));
-            return Box::new(create_error_response(&err.to_string(), &return_path));
+            return Box::new(create_error_response(
+                &err.to_string(),
+                &return_path,
+                sort_method,
+                sort_order,
+                color_scheme,
+                default_color_scheme,
+            ));
         }
     };
     let overwrite_files = req.state().overwrite_files;
@@ -178,7 +220,14 @@ pub fn upload_file(req: &HttpRequest<crate::MiniserveConfig>) -> FutureResponse<
                         .header(header::LOCATION, return_path.to_string())
                         .finish(),
                 ),
-                Err(e) => create_error_response(&e.to_string(), &return_path),
+                Err(e) => create_error_response(
+                    &e.to_string(),
+                    &return_path,
+                    sort_method,
+                    sort_order,
+                    color_scheme,
+                    default_color_scheme,
+                ),
             }),
     )
 }
@@ -187,11 +236,26 @@ pub fn upload_file(req: &HttpRequest<crate::MiniserveConfig>) -> FutureResponse<
 fn create_error_response(
     description: &str,
     return_path: &str,
+    sorting_method: Option<SortingMethod>,
+    sorting_order: Option<SortingOrder>,
+    color_scheme: ColorScheme,
+    default_color_scheme: ColorScheme,
 ) -> FutureResult<HttpResponse, actix_web::error::Error> {
     errors::log_error_chain(description.to_string());
     future::ok(
         HttpResponse::BadRequest()
             .content_type("text/html; charset=utf-8")
-            .body(renderer::render_error(description, return_path).into_string()),
+            .body(
+                renderer::render_error(
+                    description,
+                    return_path,
+                    sorting_method,
+                    sorting_order,
+                    color_scheme,
+                    default_color_scheme,
+                    true,
+                )
+                .into_string(),
+            ),
     )
 }
diff --git a/src/listing.rs b/src/listing.rs
index 7cc125d..cadbb99 100644
--- a/src/listing.rs
+++ b/src/listing.rs
@@ -18,10 +18,10 @@ use crate::themes;
 #[derive(Deserialize)]
 pub struct QueryParameters {
     pub path: Option<PathBuf>,
-    sort: Option<SortingMethod>,
-    order: Option<SortingOrder>,
+    pub sort: Option<SortingMethod>,
+    pub order: Option<SortingOrder>,
+    pub theme: Option<themes::ColorScheme>,
     download: Option<archive::CompressionMethod>,
-    theme: Option<themes::ColorScheme>,
 }
 
 /// Available sorting methods
@@ -145,12 +145,7 @@ pub fn directory_listing<S>(
 
     let (sort_method, sort_order, download, color_scheme) =
         if let Ok(query) = Query::<QueryParameters>::extract(req) {
-            (
-                query.sort,
-                query.order,
-                query.download.clone(),
-                query.theme,
-            )
+            (query.sort, query.order, query.download.clone(), query.theme)
         } else {
             (None, None, None, None)
         };
@@ -159,7 +154,7 @@ pub fn directory_listing<S>(
 
     for entry in dir.path.read_dir()? {
         if dir.is_visible(&entry) {
-            let entry = entry.unwrap();
+            let entry = entry?;
             let p = match entry.path().strip_prefix(&dir.path) {
                 Ok(p) => base.join(p),
                 Err(_) => continue,
@@ -267,7 +262,18 @@ pub fn directory_listing<S>(
                 errors::log_error_chain(err.to_string());
                 Ok(HttpResponse::Ok()
                     .status(http::StatusCode::INTERNAL_SERVER_ERROR)
-                    .body(renderer::render_error(&err.to_string(), serve_path).into_string()))
+                    .body(
+                        renderer::render_error(
+                            &err.to_string(),
+                            serve_path,
+                            sort_method,
+                            sort_order,
+                            color_scheme,
+                            default_color_scheme,
+                            false,
+                        )
+                        .into_string(),
+                    ))
             }
         }
     } else {
diff --git a/src/main.rs b/src/main.rs
index a9d44df..bd71763 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -274,9 +274,11 @@ fn configure_app(app: App<MiniserveConfig>) -> App<MiniserveConfig> {
 
     if let Some(s) = s {
         if app.state().file_upload {
+            let default_color_scheme = app.state().default_color_scheme;
             // Allow file upload
-            app.resource(&upload_route, |r| {
-                r.method(Method::POST).f(file_upload::upload_file)
+            app.resource(&upload_route, move |r| {
+                r.method(Method::POST)
+                    .f(move |file| file_upload::upload_file(file, default_color_scheme))
             })
             // Handle directories
             .handler(&full_route, s)
diff --git a/src/renderer.rs b/src/renderer.rs
index 76990de..2ed69d0 100644
--- a/src/renderer.rs
+++ b/src/renderer.rs
@@ -22,6 +22,15 @@ pub fn page(
     upload_route: &str,
     current_dir: &str,
 ) -> Markup {
+    let upload_action = build_upload_action(
+        upload_route,
+        current_dir,
+        sort_method,
+        sort_order,
+        color_scheme,
+        default_color_scheme,
+    );
+
     html! {
         (page_header(serve_path, color_scheme, file_upload))
         body#drop-container {
@@ -39,12 +48,12 @@ pub fn page(
                 div.toolbar {
                     div.download {
                         @for compression_method in CompressionMethod::iter() {
-                            (archive_button(compression_method))
+                            (archive_button(compression_method, sort_method, sort_order, color_scheme, default_color_scheme))
                         }
                     }
                     @if file_upload {
                         div.upload {
-                            form id="file_submit" action={(upload_route) "?path=" (current_dir)} method="POST" enctype="multipart/form-data" {
+                            form id="file_submit" action=(upload_action) method="POST" enctype="multipart/form-data" {
                                 p { "Select a file to upload or drag it anywhere into the window" }
                                 div {
                                     input#file-input type="file" name="file_to_upload" required="" {}
@@ -86,6 +95,29 @@ pub fn page(
     }
 }
 
+/// Build the action of the upload form
+fn build_upload_action(
+    upload_route: &str,
+    current_dir: &str,
+    sort_method: Option<SortingMethod>,
+    sort_order: Option<SortingOrder>,
+    color_scheme: ColorScheme,
+    default_color_scheme: ColorScheme,
+) -> String {
+    let mut upload_action = format!("{}?path={}", upload_route, current_dir);
+    if let Some(sorting_method) = sort_method {
+        upload_action = format!("{}&sort={}", upload_action, &sorting_method);
+    }
+    if let Some(sorting_order) = sort_order {
+        upload_action = format!("{}&order={}", upload_action, &sorting_order);
+    }
+    if color_scheme != default_color_scheme {
+        upload_action = format!("{}&theme={}", upload_action, color_scheme.to_slug());
+    }
+
+    upload_action
+}
+
 /// Partial: color scheme selector
 fn color_scheme_selector(
     sort_method: Option<SortingMethod>,
@@ -151,8 +183,30 @@ fn color_scheme_link(
 }
 
 /// Partial: archive button
-fn archive_button(compress_method: CompressionMethod) -> Markup {
-    let link = format!("?download={}", compress_method);
+fn archive_button(
+    compress_method: CompressionMethod,
+    sort_method: Option<SortingMethod>,
+    sort_order: Option<SortingOrder>,
+    color_scheme: ColorScheme,
+    default_color_scheme: ColorScheme,
+) -> Markup {
+    let link =
+        if sort_method.is_none() && sort_order.is_none() && color_scheme == default_color_scheme {
+            format!("?download={}", compress_method)
+        } else {
+            format!(
+                "{}&download={}",
+                parametrized_link(
+                    "",
+                    sort_method,
+                    sort_order,
+                    color_scheme,
+                    default_color_scheme
+                ),
+                compress_method
+            )
+        };
+
     let text = format!("Download .{}", compress_method.extension());
 
     html! {
@@ -325,7 +379,7 @@ fn css(color_scheme: ColorScheme) -> Markup {
         font-weight: bold;
         color: {directory_link_color};
     }}
-    a.file, a.file:visited {{
+    a.file, a.file:visited, .error-back, .error-back:visited {{
         color: {file_link_color};
     }}
     a.symlink, a.symlink:visited {{
@@ -581,6 +635,22 @@ fn css(color_scheme: ColorScheme) -> Markup {
         width: 100%;
         text-align: center;
     }}
+    .error {{
+        margin: 2rem;
+    }}
+    .error p {{
+        margin: 1rem 0;
+        font-size: 0.9rem;
+        word-break: break-all;
+    }}
+    .error p:first-of-type {{
+        font-size: 1.25rem;
+        color: {error_color};
+        margin-bottom: 2rem;
+    }}
+    .error-nav {{
+        margin-top: 4rem;
+    }}
     @media (max-width: 760px) {{
         nav {{
             padding: 0 2.5rem;
@@ -661,7 +731,8 @@ fn css(color_scheme: ColorScheme) -> Markup {
         drag_border_color = theme.drag_border_color,
         drag_text_color = theme.drag_text_color,
         size_background_color = theme.size_background_color,
-        size_text_color = theme.size_text_color);
+        size_text_color = theme.size_text_color,
+        error_color = theme.error_color);
     (PreEscaped(css))
 }
 
@@ -761,11 +832,40 @@ fn humanize_systemtime(src_time: Option<SystemTime>) -> Option<String> {
 }
 
 /// Renders an error on the webpage
-pub fn render_error(error_description: &str, return_address: &str) -> Markup {
+pub fn render_error(
+    error_description: &str,
+    return_address: &str,
+    sort_method: Option<SortingMethod>,
+    sort_order: Option<SortingOrder>,
+    color_scheme: ColorScheme,
+    default_color_scheme: ColorScheme,
+    has_referer: bool,
+) -> Markup {
+    let link = if has_referer {
+        return_address.to_string()
+    } else {
+        parametrized_link(
+            return_address,
+            sort_method,
+            sort_order,
+            color_scheme,
+            default_color_scheme,
+        )
+    };
+
     html! {
-        pre { (error_description) }
-        a href=(return_address) {
-            "Go back to file listing"
+        body {
+            (page_header("Error", color_scheme, false))
+            div.error {
+                @for error in error_description.lines() {
+                    p { (error) }
+                }
+                div.error-nav {
+                    a.error-back href=(link) {
+                        "Go back to file listing"
+                    }
+                }
+            }
         }
     }
 }
diff --git a/src/themes.rs b/src/themes.rs
index 49a1ad3..65e9ab2 100644
--- a/src/themes.rs
+++ b/src/themes.rs
@@ -81,6 +81,7 @@ impl ColorScheme {
                 drag_text_color: "#fefefe".to_string(),
                 size_background_color: "#5294e2".to_string(),
                 size_text_color: "#fefefe".to_string(),
+                error_color: "#e44b4b".to_string(),
             },
             ColorScheme::Zenburn => Theme {
                 background: "#3f3f3f".to_string(),
@@ -123,6 +124,7 @@ impl ColorScheme {
                 drag_text_color: "#efefef".to_string(),
                 size_background_color: "#7f9f7f".to_string(),
                 size_text_color: "#efefef".to_string(),
+                error_color: "#d06565".to_string(),
             },
             ColorScheme::Monokai => Theme {
                 background: "#272822".to_string(),
@@ -165,6 +167,7 @@ impl ColorScheme {
                 drag_text_color: "#F8F8F2".to_string(),
                 size_background_color: "#75715E".to_string(),
                 size_text_color: "#F8F8F2".to_string(),
+                error_color: "#d02929".to_string(),
             },
             ColorScheme::Squirrel => Theme {
                 background: "#FFFFFF".to_string(),
@@ -207,6 +210,7 @@ impl ColorScheme {
                 drag_text_color: "#ffffff".to_string(),
                 size_background_color: "#323232".to_string(),
                 size_text_color: "#FFFFFF".to_string(),
+                error_color: "#d02424".to_string(),
             },
         }
     }
@@ -254,4 +258,5 @@ pub struct Theme {
     pub drag_text_color: String,
     pub size_background_color: String,
     pub size_text_color: String,
+    pub error_color: String,
 }
-- 
cgit v1.2.3


From 211250a71d9b2df27f85beb35b89d23346c6fa5e Mon Sep 17 00:00:00 2001
From: boastful-squirrel <boastful.squirrel@gmail.com>
Date: Sat, 27 Apr 2019 12:25:11 +0200
Subject: Improved some errors

---
 src/errors.rs      | 2 +-
 src/file_upload.rs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'src')

diff --git a/src/errors.rs b/src/errors.rs
index d34b447..bf45b73 100644
--- a/src/errors.rs
+++ b/src/errors.rs
@@ -34,7 +34,7 @@ pub enum ContextualErrorKind {
 
     /// This error might occure if the hash method is neither sha256 nor sha512
     #[fail(
-        display = "{} is not a valid hashing method. Expected sha256 or sha512",
+        display = "Invalid hashing method {}. Expected sha256 or sha512",
         _0
     )]
     InvalidHashMethod(String),
diff --git a/src/file_upload.rs b/src/file_upload.rs
index 88a4649..f8c5019 100644
--- a/src/file_upload.rs
+++ b/src/file_upload.rs
@@ -30,7 +30,7 @@ fn save_file(
         Ok(file) => file,
         Err(e) => {
             return Box::new(future::err(ContextualErrorKind::IOError(
-                format!("Failed to create file {}", file_path.display()),
+                format!("Failed to create {}", file_path.display()),
                 e,
             )));
         }
-- 
cgit v1.2.3


From c2ce5295eb27610734ed539d47979c7bc0f0953b Mon Sep 17 00:00:00 2001
From: boastful-squirrel <boastful.squirrel@gmail.com>
Date: Sat, 27 Apr 2019 12:31:14 +0200
Subject: Fixed test + fixed clippy warning

---
 src/args.rs | 2 +-
 src/auth.rs | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

(limited to 'src')

diff --git a/src/args.rs b/src/args.rs
index b769a9b..9ccb7a6 100644
--- a/src/args.rs
+++ b/src/args.rs
@@ -214,7 +214,7 @@ mod tests {
         ),
         case(
             "username:blahblah:abcd",
-            "blahblah is not a valid hashing method. Expected sha256 or sha512"
+            "Invalid hashing method blahblah. Expected sha256 or sha512"
         ),
         case(
             "username:sha256:invalid",
diff --git a/src/auth.rs b/src/auth.rs
index d8de30e..a42bb53 100644
--- a/src/auth.rs
+++ b/src/auth.rs
@@ -75,8 +75,8 @@ pub fn match_auth(basic_auth: BasicAuthParams, required_auth: &RequiredAuth) ->
 }
 
 /// Return `true` if hashing of `password` by `T` algorithm equals to `hash`
-pub fn compare_hash<T: Digest>(password: String, hash: &Vec<u8>) -> bool {
-    get_hash::<T>(password) == *hash
+pub fn compare_hash<T: Digest>(password: String, hash: &[u8]) -> bool {
+    get_hash::<T>(password) == hash
 }
 
 /// Get hash of a `text`
-- 
cgit v1.2.3


From 9b0a09649eba0950d1682d366eeb0166f80f2823 Mon Sep 17 00:00:00 2001
From: boastful-squirrel <boastful.squirrel@gmail.com>
Date: Mon, 29 Apr 2019 21:07:45 +0200
Subject: Make error page uniform

---
 src/renderer.rs | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'src')

diff --git a/src/renderer.rs b/src/renderer.rs
index 2ed69d0..ecc6bfe 100644
--- a/src/renderer.rs
+++ b/src/renderer.rs
@@ -648,6 +648,9 @@ fn css(color_scheme: ColorScheme) -> Markup {
         color: {error_color};
         margin-bottom: 2rem;
     }}
+    .error p:nth-of-type(2) {{
+        font-weight: bold;
+    }}
     .error-nav {{
         margin-top: 4rem;
     }}
@@ -857,6 +860,7 @@ pub fn render_error(
         body {
             (page_header("Error", color_scheme, false))
             div.error {
+                p { "Error" }
                 @for error in error_description.lines() {
                     p { (error) }
                 }
-- 
cgit v1.2.3


From f53a09b8d79c85b86b161c1ec7ca6f7cff5e169f Mon Sep 17 00:00:00 2001
From: boastful-squirrel <boastful.squirrel@gmail.com>
Date: Wed, 1 May 2019 13:17:13 +0200
Subject: Display HTTP authentication errors

---
 src/auth.rs     | 43 ++++++++++++++++++++++++++++++++++++++-----
 src/errors.rs   |  4 ++++
 src/renderer.rs | 17 +++++++++++++----
 3 files changed, 55 insertions(+), 9 deletions(-)

(limited to 'src')

diff --git a/src/auth.rs b/src/auth.rs
index c786d4b..b5a9867 100644
--- a/src/auth.rs
+++ b/src/auth.rs
@@ -3,7 +3,8 @@ use actix_web::middleware::{Middleware, Response};
 use actix_web::{HttpRequest, HttpResponse, Result};
 use sha2::{Digest, Sha256, Sha512};
 
-use crate::errors::ContextualError;
+use crate::errors::{self, ContextualError};
+use crate::renderer;
 
 pub struct Auth;
 
@@ -96,13 +97,19 @@ impl Middleware<crate::MiniserveConfig> for Auth {
                     Err(err) => {
                         let auth_err = ContextualError::HTTPAuthenticationError(Box::new(err));
                         return Ok(Response::Done(
-                            HttpResponse::BadRequest().body(auth_err.to_string()),
+                            HttpResponse::BadRequest()
+                                .body(build_unauthorized_response(&req, auth_err, true)),
                         ));
                     }
                 };
                 if !match_auth(auth_req, required_auth) {
-                    let new_resp = HttpResponse::Unauthorized().finish();
-                    return Ok(Response::Done(new_resp));
+                    return Ok(Response::Done(HttpResponse::Unauthorized().body(
+                        build_unauthorized_response(
+                            &req,
+                            ContextualError::InvalidHTTPCredentials,
+                            true,
+                        ),
+                    )));
                 }
             } else {
                 let new_resp = HttpResponse::Unauthorized()
@@ -110,7 +117,11 @@ impl Middleware<crate::MiniserveConfig> for Auth {
                         header::WWW_AUTHENTICATE,
                         header::HeaderValue::from_static("Basic realm=\"miniserve\""),
                     )
-                    .finish();
+                    .body(build_unauthorized_response(
+                        &req,
+                        ContextualError::InvalidHTTPCredentials,
+                        false,
+                    ));
                 return Ok(Response::Done(new_resp));
             }
         }
@@ -118,6 +129,28 @@ impl Middleware<crate::MiniserveConfig> for Auth {
     }
 }
 
+fn build_unauthorized_response(
+    req: &HttpRequest<crate::MiniserveConfig>,
+    error: ContextualError,
+    log_error_chain: bool,
+) -> String {
+    let error = ContextualError::HTTPAuthenticationError(Box::new(error));
+
+    if log_error_chain {
+        errors::log_error_chain(error.to_string());
+    }
+    renderer::render_error(
+        &error.to_string(),
+        req.path(),
+        None,
+        None,
+        req.state().default_color_scheme,
+        req.state().default_color_scheme,
+        false,
+    )
+    .into_string()
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/src/errors.rs b/src/errors.rs
index 8264de0..a22127e 100644
--- a/src/errors.rs
+++ b/src/errors.rs
@@ -65,6 +65,10 @@ pub enum ContextualError {
     )]
     HTTPAuthenticationError(Box<ContextualError>),
 
+    /// This error might occur when the HTTP credentials are not correct
+    #[fail(display = "Invalid credentials for HTTP authentication")]
+    InvalidHTTPCredentials,
+
     /// This error might occur when an HTTP request is invalid
     #[fail(display = "Invalid HTTP request\ncaused by: {}", _0)]
     InvalidHTTPRequestError(String),
diff --git a/src/renderer.rs b/src/renderer.rs
index ecc6bfe..03c46d8 100644
--- a/src/renderer.rs
+++ b/src/renderer.rs
@@ -32,7 +32,7 @@ pub fn page(
     );
 
     html! {
-        (page_header(serve_path, color_scheme, file_upload))
+        (page_header(serve_path, color_scheme, file_upload, false))
         body#drop-container {
             @if file_upload {
                 div.drag-form {
@@ -760,14 +760,23 @@ fn chevron_down() -> Markup {
 }
 
 /// Partial: page header
-fn page_header(serve_path: &str, color_scheme: ColorScheme, file_upload: bool) -> Markup {
+fn page_header(
+    serve_path: &str,
+    color_scheme: ColorScheme,
+    file_upload: bool,
+    is_error: bool,
+) -> Markup {
     html! {
         (DOCTYPE)
         html {
             meta charset="utf-8";
             meta http-equiv="X-UA-Compatible" content="IE=edge";
             meta name="viewport" content="width=device-width, initial-scale=1";
-            title { "Index of " (serve_path) }
+            @if is_error {
+                title { (serve_path) }
+            } else {
+                title { "Index of " (serve_path) }
+            }
             style { (css(color_scheme)) }
             @if file_upload {
                 (PreEscaped(r#"
@@ -858,7 +867,7 @@ pub fn render_error(
 
     html! {
         body {
-            (page_header("Error", color_scheme, false))
+            (page_header("Error", color_scheme, false, true))
             div.error {
                 p { "Error" }
                 @for error in error_description.lines() {
-- 
cgit v1.2.3


From e4bb38b17db665a8167feab9347494445385ebb3 Mon Sep 17 00:00:00 2001
From: boastful-squirrel <boastful.squirrel@gmail.com>
Date: Wed, 1 May 2019 17:01:41 +0200
Subject: Display 404 error

---
 src/errors.rs |  4 ++++
 src/main.rs   | 25 +++++++++++++++++++++++--
 2 files changed, 27 insertions(+), 2 deletions(-)

(limited to 'src')

diff --git a/src/errors.rs b/src/errors.rs
index a22127e..e5d2e41 100644
--- a/src/errors.rs
+++ b/src/errors.rs
@@ -72,6 +72,10 @@ pub enum ContextualError {
     /// This error might occur when an HTTP request is invalid
     #[fail(display = "Invalid HTTP request\ncaused by: {}", _0)]
     InvalidHTTPRequestError(String),
+
+    /// This error might occur when trying to access a page that does not exist
+    #[fail(display = "Route {} could not be found", _0)]
+    RouteNotFoundError(String),
 }
 
 pub fn log_error_chain(description: String) {
diff --git a/src/main.rs b/src/main.rs
index c5c81f2..4b2118c 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,7 +1,7 @@
 #![feature(proc_macro_hygiene)]
 
 use actix_web::http::Method;
-use actix_web::{fs, middleware, server, App};
+use actix_web::{fs, middleware, server, App, HttpRequest, HttpResponse};
 use clap::crate_version;
 use simplelog::{Config, LevelFilter, TermLogger};
 use std::io::{self, Write};
@@ -247,7 +247,8 @@ fn configure_app(app: App<MiniserveConfig>) -> App<MiniserveConfig> {
                             default_color_scheme,
                             u_r.clone(),
                         )
-                    }),
+                    })
+                    .default_handler(p404),
             )
         }
     };
@@ -274,3 +275,23 @@ fn configure_app(app: App<MiniserveConfig>) -> App<MiniserveConfig> {
         app.resource(&full_route, |r| r.f(listing::file_handler))
     }
 }
+
+fn p404(req: &HttpRequest<crate::MiniserveConfig>) -> Result<HttpResponse, io::Error> {
+    let err_404 = ContextualError::RouteNotFoundError(req.uri().to_string());
+    let default_color_scheme = req.state().default_color_scheme;
+
+    errors::log_error_chain(err_404.to_string());
+
+    Ok(actix_web::HttpResponse::NotFound().body(
+        renderer::render_error(
+            &err_404.to_string(),
+            "/",
+            None,
+            None,
+            default_color_scheme,
+            default_color_scheme,
+            false,
+        )
+        .into_string(),
+    ))
+}
-- 
cgit v1.2.3


From 5c5b0c75509364f64c9af48595fc2dc95b0ba849 Mon Sep 17 00:00:00 2001
From: boastful-squirrel <boastful.squirrel@gmail.com>
Date: Wed, 1 May 2019 17:08:15 +0200
Subject: Added doc

---
 src/auth.rs | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'src')

diff --git a/src/auth.rs b/src/auth.rs
index b5a9867..23ea668 100644
--- a/src/auth.rs
+++ b/src/auth.rs
@@ -129,6 +129,9 @@ impl Middleware<crate::MiniserveConfig> for Auth {
     }
 }
 
+/// Builds the unauthorized response body
+/// The reason why log_error_chain is optional is to handle cases where the auth pop-up appears and when the user clicks Cancel.
+/// In those case, we do not log the error to the terminal since it does not really matter.
 fn build_unauthorized_response(
     req: &HttpRequest<crate::MiniserveConfig>,
     error: ContextualError,
-- 
cgit v1.2.3


From 506a95319c35c5d744ca29726bafe2bff1b70221 Mon Sep 17 00:00:00 2001
From: boastful-squirrel <boastful.squirrel@gmail.com>
Date: Wed, 1 May 2019 17:54:28 +0200
Subject: Fix return link when random_route is set

---
 src/auth.rs | 7 ++++++-
 src/main.rs | 9 ++++++++-
 2 files changed, 14 insertions(+), 2 deletions(-)

(limited to 'src')

diff --git a/src/auth.rs b/src/auth.rs
index 23ea668..889498e 100644
--- a/src/auth.rs
+++ b/src/auth.rs
@@ -142,9 +142,14 @@ fn build_unauthorized_response(
     if log_error_chain {
         errors::log_error_chain(error.to_string());
     }
+    let return_path = match &req.state().random_route {
+        Some(random_route) => format!("/{}", random_route),
+        None => req.path().to_string(),
+    };
+
     renderer::render_error(
         &error.to_string(),
-        req.path(),
+        &return_path,
         None,
         None,
         req.state().default_color_scheme,
diff --git a/src/main.rs b/src/main.rs
index 4b2118c..f0c23cc 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -266,26 +266,33 @@ fn configure_app(app: App<MiniserveConfig>) -> App<MiniserveConfig> {
             })
             // Handle directories
             .handler(&full_route, s)
+            .default_resource(|r| r.method(Method::GET).f(p404))
         } else {
             // Handle directories
             app.handler(&full_route, s)
+                .default_resource(|r| r.method(Method::GET).f(p404))
         }
     } else {
         // Handle single files
         app.resource(&full_route, |r| r.f(listing::file_handler))
+            .default_resource(|r| r.method(Method::GET).f(p404))
     }
 }
 
 fn p404(req: &HttpRequest<crate::MiniserveConfig>) -> Result<HttpResponse, io::Error> {
     let err_404 = ContextualError::RouteNotFoundError(req.uri().to_string());
     let default_color_scheme = req.state().default_color_scheme;
+    let return_address = match &req.state().random_route {
+        Some(random_route) => format!("/{}", random_route),
+        None => req.path().to_string(),
+    };
 
     errors::log_error_chain(err_404.to_string());
 
     Ok(actix_web::HttpResponse::NotFound().body(
         renderer::render_error(
             &err_404.to_string(),
-            "/",
+            &return_address,
             None,
             None,
             default_color_scheme,
-- 
cgit v1.2.3


From fa0c2865366b1bb65a2977c4b9608c9a92fc5889 Mon Sep 17 00:00:00 2001
From: boastful-squirrel <boastful.squirrel@gmail.com>
Date: Wed, 1 May 2019 18:23:29 +0200
Subject: Use HTTP StatusCode for error title

---
 src/auth.rs        | 8 ++++++--
 src/file_upload.rs | 9 ++++++++-
 src/listing.rs     | 2 ++
 src/main.rs        | 5 +++--
 src/renderer.rs    | 6 ++++--
 5 files changed, 23 insertions(+), 7 deletions(-)

(limited to 'src')

diff --git a/src/auth.rs b/src/auth.rs
index 889498e..dbb501d 100644
--- a/src/auth.rs
+++ b/src/auth.rs
@@ -1,4 +1,4 @@
-use actix_web::http::header;
+use actix_web::http::{header, StatusCode};
 use actix_web::middleware::{Middleware, Response};
 use actix_web::{HttpRequest, HttpResponse, Result};
 use sha2::{Digest, Sha256, Sha512};
@@ -98,7 +98,7 @@ impl Middleware<crate::MiniserveConfig> for Auth {
                         let auth_err = ContextualError::HTTPAuthenticationError(Box::new(err));
                         return Ok(Response::Done(
                             HttpResponse::BadRequest()
-                                .body(build_unauthorized_response(&req, auth_err, true)),
+                                .body(build_unauthorized_response(&req, auth_err, true, StatusCode::BAD_REQUEST)),
                         ));
                     }
                 };
@@ -108,6 +108,7 @@ impl Middleware<crate::MiniserveConfig> for Auth {
                             &req,
                             ContextualError::InvalidHTTPCredentials,
                             true,
+                            StatusCode::UNAUTHORIZED,
                         ),
                     )));
                 }
@@ -121,6 +122,7 @@ impl Middleware<crate::MiniserveConfig> for Auth {
                         &req,
                         ContextualError::InvalidHTTPCredentials,
                         false,
+                        StatusCode::UNAUTHORIZED,
                     ));
                 return Ok(Response::Done(new_resp));
             }
@@ -136,6 +138,7 @@ fn build_unauthorized_response(
     req: &HttpRequest<crate::MiniserveConfig>,
     error: ContextualError,
     log_error_chain: bool,
+    error_code: StatusCode,
 ) -> String {
     let error = ContextualError::HTTPAuthenticationError(Box::new(error));
 
@@ -149,6 +152,7 @@ fn build_unauthorized_response(
 
     renderer::render_error(
         &error.to_string(),
+        error_code,
         &return_path,
         None,
         None,
diff --git a/src/file_upload.rs b/src/file_upload.rs
index 46a3a1f..1d854bf 100644
--- a/src/file_upload.rs
+++ b/src/file_upload.rs
@@ -1,5 +1,5 @@
 use actix_web::{
-    dev, http::header, multipart, FromRequest, FutureResponse, HttpMessage, HttpRequest,
+    dev, http::{header, StatusCode}, multipart, FromRequest, FutureResponse, HttpMessage, HttpRequest,
     HttpResponse, Query,
 };
 use futures::{future, future::FutureResult, Future, Stream};
@@ -150,6 +150,7 @@ pub fn upload_file(
                 );
                 return Box::new(create_error_response(
                     &err.to_string(),
+                    StatusCode::BAD_REQUEST,
                     &return_path,
                     sort_param,
                     order_param,
@@ -162,6 +163,7 @@ pub fn upload_file(
             let err = ContextualError::InvalidHTTPRequestError(e.to_string());
             return Box::new(create_error_response(
                 &err.to_string(),
+                StatusCode::BAD_REQUEST,
                 &return_path,
                 None,
                 None,
@@ -180,6 +182,7 @@ pub fn upload_file(
             );
             return Box::new(create_error_response(
                 &err.to_string(),
+                StatusCode::INTERNAL_SERVER_ERROR,
                 &return_path,
                 sort_method,
                 sort_order,
@@ -198,6 +201,7 @@ pub fn upload_file(
             );
             return Box::new(create_error_response(
                 &err.to_string(),
+                StatusCode::BAD_REQUEST,
                 &return_path,
                 sort_method,
                 sort_order,
@@ -221,6 +225,7 @@ pub fn upload_file(
                 ),
                 Err(e) => create_error_response(
                     &e.to_string(),
+                    StatusCode::INTERNAL_SERVER_ERROR,
                     &return_path,
                     sort_method,
                     sort_order,
@@ -234,6 +239,7 @@ pub fn upload_file(
 /// Convenience method for creating response errors, if file upload fails.
 fn create_error_response(
     description: &str,
+    error_code: StatusCode,
     return_path: &str,
     sorting_method: Option<SortingMethod>,
     sorting_order: Option<SortingOrder>,
@@ -247,6 +253,7 @@ fn create_error_response(
             .body(
                 renderer::render_error(
                     description,
+                    error_code,
                     return_path,
                     sorting_method,
                     sorting_order,
diff --git a/src/listing.rs b/src/listing.rs
index cadbb99..a37563b 100644
--- a/src/listing.rs
+++ b/src/listing.rs
@@ -1,4 +1,5 @@
 use actix_web::{fs, http, Body, FromRequest, HttpRequest, HttpResponse, Query, Result};
+use actix_web::http::StatusCode;
 use bytesize::ByteSize;
 use futures::stream::once;
 use htmlescape::encode_minimal as escape_html_entity;
@@ -265,6 +266,7 @@ pub fn directory_listing<S>(
                     .body(
                         renderer::render_error(
                             &err.to_string(),
+                            StatusCode::INTERNAL_SERVER_ERROR,
                             serve_path,
                             sort_method,
                             sort_order,
diff --git a/src/main.rs b/src/main.rs
index f0c23cc..46f22c5 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,6 +1,6 @@
 #![feature(proc_macro_hygiene)]
 
-use actix_web::http::Method;
+use actix_web::http::{Method, StatusCode};
 use actix_web::{fs, middleware, server, App, HttpRequest, HttpResponse};
 use clap::crate_version;
 use simplelog::{Config, LevelFilter, TermLogger};
@@ -284,7 +284,7 @@ fn p404(req: &HttpRequest<crate::MiniserveConfig>) -> Result<HttpResponse, io::E
     let default_color_scheme = req.state().default_color_scheme;
     let return_address = match &req.state().random_route {
         Some(random_route) => format!("/{}", random_route),
-        None => req.path().to_string(),
+        None => "/".to_string(),
     };
 
     errors::log_error_chain(err_404.to_string());
@@ -292,6 +292,7 @@ fn p404(req: &HttpRequest<crate::MiniserveConfig>) -> Result<HttpResponse, io::E
     Ok(actix_web::HttpResponse::NotFound().body(
         renderer::render_error(
             &err_404.to_string(),
+            StatusCode::NOT_FOUND,
             &return_address,
             None,
             None,
diff --git a/src/renderer.rs b/src/renderer.rs
index 03c46d8..acef208 100644
--- a/src/renderer.rs
+++ b/src/renderer.rs
@@ -1,3 +1,4 @@
+use actix_web::http::StatusCode;
 use chrono::{DateTime, Duration, Utc};
 use chrono_humanize::{Accuracy, HumanTime, Tense};
 use maud::{html, Markup, PreEscaped, DOCTYPE};
@@ -846,6 +847,7 @@ fn humanize_systemtime(src_time: Option<SystemTime>) -> Option<String> {
 /// Renders an error on the webpage
 pub fn render_error(
     error_description: &str,
+    error_code: StatusCode,
     return_address: &str,
     sort_method: Option<SortingMethod>,
     sort_order: Option<SortingOrder>,
@@ -867,9 +869,9 @@ pub fn render_error(
 
     html! {
         body {
-            (page_header("Error", color_scheme, false, true))
+            (page_header(&error_code.to_string(), color_scheme, false, true))
             div.error {
-                p { "Error" }
+                p { (error_code.to_string()) }
                 @for error in error_description.lines() {
                     p { (error) }
                 }
-- 
cgit v1.2.3


From 07870487c4ffb11865d7485c8fc826c1247fac34 Mon Sep 17 00:00:00 2001
From: boastful-squirrel <boastful.squirrel@gmail.com>
Date: Wed, 1 May 2019 18:29:16 +0200
Subject: Return to root when auth succeeds

---
 src/auth.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src')

diff --git a/src/auth.rs b/src/auth.rs
index dbb501d..faf967c 100644
--- a/src/auth.rs
+++ b/src/auth.rs
@@ -147,7 +147,7 @@ fn build_unauthorized_response(
     }
     let return_path = match &req.state().random_route {
         Some(random_route) => format!("/{}", random_route),
-        None => req.path().to_string(),
+        None => "/".to_string(),
     };
 
     renderer::render_error(
-- 
cgit v1.2.3


From f5764b05970178db8504d6eeb857d082c81c291c Mon Sep 17 00:00:00 2001
From: boastful-squirrel <boastful.squirrel@gmail.com>
Date: Thu, 2 May 2019 07:18:03 +0200
Subject: Rename p404

---
 src/main.rs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'src')

diff --git a/src/main.rs b/src/main.rs
index 46f22c5..22b91cb 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -248,7 +248,7 @@ fn configure_app(app: App<MiniserveConfig>) -> App<MiniserveConfig> {
                             u_r.clone(),
                         )
                     })
-                    .default_handler(p404),
+                    .default_handler(error_404),
             )
         }
     };
@@ -266,20 +266,20 @@ fn configure_app(app: App<MiniserveConfig>) -> App<MiniserveConfig> {
             })
             // Handle directories
             .handler(&full_route, s)
-            .default_resource(|r| r.method(Method::GET).f(p404))
+            .default_resource(|r| r.method(Method::GET).f(error_404))
         } else {
             // Handle directories
             app.handler(&full_route, s)
-                .default_resource(|r| r.method(Method::GET).f(p404))
+                .default_resource(|r| r.method(Method::GET).f(error_404))
         }
     } else {
         // Handle single files
         app.resource(&full_route, |r| r.f(listing::file_handler))
-            .default_resource(|r| r.method(Method::GET).f(p404))
+            .default_resource(|r| r.method(Method::GET).f(error_404))
     }
 }
 
-fn p404(req: &HttpRequest<crate::MiniserveConfig>) -> Result<HttpResponse, io::Error> {
+fn error_404(req: &HttpRequest<crate::MiniserveConfig>) -> Result<HttpResponse, io::Error> {
     let err_404 = ContextualError::RouteNotFoundError(req.uri().to_string());
     let default_color_scheme = req.state().default_color_scheme;
     let return_address = match &req.state().random_route {
-- 
cgit v1.2.3


From 2011cdc6f140122735d2ec0b67cf70776588067c Mon Sep 17 00:00:00 2001
From: boastful-squirrel <boastful.squirrel@gmail.com>
Date: Thu, 2 May 2019 07:23:18 +0200
Subject: Added rustfmt_skip directive on tests

---
 src/args.rs | 6 ++----
 src/auth.rs | 8 ++------
 2 files changed, 4 insertions(+), 10 deletions(-)

(limited to 'src')

diff --git a/src/args.rs b/src/args.rs
index d37e429..5671425 100644
--- a/src/args.rs
+++ b/src/args.rs
@@ -161,6 +161,7 @@ pub fn parse_args() -> crate::MiniserveConfig {
     }
 }
 
+#[cfg_attr(rustfmt, rustfmt_skip)]
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -183,10 +184,7 @@ mod tests {
     }
 
     #[rstest_parametrize(
-        auth_string,
-        username,
-        password,
-        encrypt,
+        auth_string, username, password, encrypt,
         case("username:password", "username", "password", "plain"),
         case("username:sha256:abcd", "username", "abcd", "sha256"),
         case("username:sha512:abcd", "username", "abcd", "sha512")
diff --git a/src/auth.rs b/src/auth.rs
index faf967c..502c9cb 100644
--- a/src/auth.rs
+++ b/src/auth.rs
@@ -163,6 +163,7 @@ fn build_unauthorized_response(
     .into_string()
 }
 
+#[cfg_attr(rustfmt, rustfmt_skip)]
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -205,12 +206,7 @@ mod tests {
     }
 
     #[rstest_parametrize(
-        should_pass,
-        param_username,
-        param_password,
-        required_username,
-        required_password,
-        encrypt,
+        should_pass, param_username, param_password, required_username, required_password, encrypt,
         case(true, "obi", "hello there", "obi", "hello there", "plain"),
         case(false, "obi", "hello there", "obi", "hi!", "plain"),
         case(true, "obi", "hello there", "obi", "hello there", "sha256"),
-- 
cgit v1.2.3


From 321b0ce7a693780830780f19de1cdec31657d2db Mon Sep 17 00:00:00 2001
From: boastful-squirrel <boastful.squirrel@gmail.com>
Date: Thu, 2 May 2019 07:23:38 +0200
Subject: Cargo fmt

---
 src/auth.rs        | 12 ++++++++----
 src/file_upload.rs |  5 +++--
 src/listing.rs     |  2 +-
 3 files changed, 12 insertions(+), 7 deletions(-)

(limited to 'src')

diff --git a/src/auth.rs b/src/auth.rs
index 502c9cb..3989ab4 100644
--- a/src/auth.rs
+++ b/src/auth.rs
@@ -96,10 +96,14 @@ impl Middleware<crate::MiniserveConfig> for Auth {
                     Ok(auth_req) => auth_req,
                     Err(err) => {
                         let auth_err = ContextualError::HTTPAuthenticationError(Box::new(err));
-                        return Ok(Response::Done(
-                            HttpResponse::BadRequest()
-                                .body(build_unauthorized_response(&req, auth_err, true, StatusCode::BAD_REQUEST)),
-                        ));
+                        return Ok(Response::Done(HttpResponse::BadRequest().body(
+                            build_unauthorized_response(
+                                &req,
+                                auth_err,
+                                true,
+                                StatusCode::BAD_REQUEST,
+                            ),
+                        )));
                     }
                 };
                 if !match_auth(auth_req, required_auth) {
diff --git a/src/file_upload.rs b/src/file_upload.rs
index 1d854bf..9344e8b 100644
--- a/src/file_upload.rs
+++ b/src/file_upload.rs
@@ -1,6 +1,7 @@
 use actix_web::{
-    dev, http::{header, StatusCode}, multipart, FromRequest, FutureResponse, HttpMessage, HttpRequest,
-    HttpResponse, Query,
+    dev,
+    http::{header, StatusCode},
+    multipart, FromRequest, FutureResponse, HttpMessage, HttpRequest, HttpResponse, Query,
 };
 use futures::{future, future::FutureResult, Future, Stream};
 use std::{
diff --git a/src/listing.rs b/src/listing.rs
index a37563b..22e43f0 100644
--- a/src/listing.rs
+++ b/src/listing.rs
@@ -1,5 +1,5 @@
-use actix_web::{fs, http, Body, FromRequest, HttpRequest, HttpResponse, Query, Result};
 use actix_web::http::StatusCode;
+use actix_web::{fs, http, Body, FromRequest, HttpRequest, HttpResponse, Query, Result};
 use bytesize::ByteSize;
 use futures::stream::once;
 use htmlescape::encode_minimal as escape_html_entity;
-- 
cgit v1.2.3


From dd8d11c698435217c370b940b41d060a614892c1 Mon Sep 17 00:00:00 2001
From: boastful-squirrel <boastful.squirrel@gmail.com>
Date: Thu, 2 May 2019 21:36:47 +0200
Subject: Read query params to handle error back link

---
 src/auth.rs        |  1 +
 src/file_upload.rs | 59 +++++++++++++++++-------------------------------------
 src/listing.rs     | 40 ++++++++++++++++++++++++++----------
 src/main.rs        | 10 ++++++---
 src/renderer.rs    |  9 ++++++---
 5 files changed, 61 insertions(+), 58 deletions(-)

(limited to 'src')

diff --git a/src/auth.rs b/src/auth.rs
index 3989ab4..c3cbd54 100644
--- a/src/auth.rs
+++ b/src/auth.rs
@@ -163,6 +163,7 @@ fn build_unauthorized_response(
         req.state().default_color_scheme,
         req.state().default_color_scheme,
         false,
+        false,
     )
     .into_string()
 }
diff --git a/src/file_upload.rs b/src/file_upload.rs
index 9344e8b..36b2401 100644
--- a/src/file_upload.rs
+++ b/src/file_upload.rs
@@ -1,7 +1,7 @@
 use actix_web::{
     dev,
     http::{header, StatusCode},
-    multipart, FromRequest, FutureResponse, HttpMessage, HttpRequest, HttpResponse, Query,
+    multipart, FutureResponse, HttpMessage, HttpRequest, HttpResponse,
 };
 use futures::{future, future::FutureResult, Future, Stream};
 use std::{
@@ -11,7 +11,7 @@ use std::{
 };
 
 use crate::errors::{self, ContextualError};
-use crate::listing::{QueryParameters, SortingMethod, SortingOrder};
+use crate::listing::{self, SortingMethod, SortingOrder};
 use crate::renderer;
 use crate::themes::ColorScheme;
 
@@ -127,48 +127,24 @@ pub fn upload_file(
         "/".to_string()
     };
 
-    let (path, sort_method, sort_order, color_scheme) = match Query::<QueryParameters>::extract(req)
-    {
-        Ok(query) => {
-            let sort_param = query.sort;
-            let order_param = query.order;
-            let theme_param = query.theme.unwrap_or(default_color_scheme);
-
-            if let Some(path) = query.path.clone() {
-                if let Ok(stripped_path) = path.strip_prefix(Component::RootDir) {
-                    (
-                        stripped_path.to_owned(),
-                        sort_param,
-                        order_param,
-                        theme_param,
-                    )
-                } else {
-                    (path.clone(), sort_param, order_param, theme_param)
-                }
-            } else {
-                let err = ContextualError::InvalidHTTPRequestError(
-                    "Missing query parameter 'path'".to_string(),
-                );
-                return Box::new(create_error_response(
-                    &err.to_string(),
-                    StatusCode::BAD_REQUEST,
-                    &return_path,
-                    sort_param,
-                    order_param,
-                    theme_param,
-                    default_color_scheme,
-                ));
-            }
-        }
-        Err(e) => {
-            let err = ContextualError::InvalidHTTPRequestError(e.to_string());
+    let (sort_method, sort_order, _, color_scheme, path) = listing::extract_query_parameters(req);
+    let color_scheme = color_scheme.unwrap_or(default_color_scheme);
+    let upload_path = match path {
+        Some(path) => match path.strip_prefix(Component::RootDir) {
+            Ok(stripped_path) => stripped_path.to_owned(),
+            Err(_) => path.clone(),
+        },
+        None => {
+            let err = ContextualError::InvalidHTTPRequestError(
+                "Missing query parameter 'path'".to_string(),
+            );
             return Box::new(create_error_response(
                 &err.to_string(),
                 StatusCode::BAD_REQUEST,
                 &return_path,
-                None,
-                None,
-                default_color_scheme,
+                sort_method,
+                sort_order,
+                color_scheme,
                 default_color_scheme,
             ));
         }
@@ -194,7 +170,7 @@ pub fn upload_file(
     };
 
     // If the target path is under the app root directory, save the file.
-    let target_dir = match &app_root_dir.clone().join(path).canonicalize() {
+    let target_dir = match &app_root_dir.clone().join(upload_path).canonicalize() {
         Ok(path) if path.starts_with(&app_root_dir) => path.clone(),
         _ => {
             let err = ContextualError::InvalidHTTPRequestError(
@@ -261,6 +237,7 @@ fn create_error_response(
                     color_scheme,
                     default_color_scheme,
                     true,
+                    true,
                 )
                 .into_string(),
             ),
diff --git a/src/listing.rs b/src/listing.rs
index 22e43f0..2e3093d 100644
--- a/src/listing.rs
+++ b/src/listing.rs
@@ -10,10 +10,10 @@ use std::path::{Path, PathBuf};
 use std::time::SystemTime;
 use strum_macros::{Display, EnumString};
 
-use crate::archive;
+use crate::archive::{self, CompressionMethod};
 use crate::errors;
 use crate::renderer;
-use crate::themes;
+use crate::themes::ColorScheme;
 
 /// Query parameters
 #[derive(Deserialize)]
@@ -21,8 +21,8 @@ pub struct QueryParameters {
     pub path: Option<PathBuf>,
     pub sort: Option<SortingMethod>,
     pub order: Option<SortingOrder>,
-    pub theme: Option<themes::ColorScheme>,
-    download: Option<archive::CompressionMethod>,
+    pub theme: Option<ColorScheme>,
+    download: Option<CompressionMethod>,
 }
 
 /// Available sorting methods
@@ -131,7 +131,7 @@ pub fn directory_listing<S>(
     skip_symlinks: bool,
     file_upload: bool,
     random_route: Option<String>,
-    default_color_scheme: themes::ColorScheme,
+    default_color_scheme: ColorScheme,
     upload_route: String,
 ) -> Result<HttpResponse, io::Error> {
     let serve_path = req.path();
@@ -144,12 +144,7 @@ pub fn directory_listing<S>(
         Err(_) => base.to_path_buf(),
     };
 
-    let (sort_method, sort_order, download, color_scheme) =
-        if let Ok(query) = Query::<QueryParameters>::extract(req) {
-            (query.sort, query.order, query.download.clone(), query.theme)
-        } else {
-            (None, None, None, None)
-        };
+    let (sort_method, sort_order, download, color_scheme, _) = extract_query_parameters(req);
 
     let mut entries: Vec<Entry> = Vec::new();
 
@@ -273,6 +268,7 @@ pub fn directory_listing<S>(
                             color_scheme,
                             default_color_scheme,
                             false,
+                            true,
                         )
                         .into_string(),
                     ))
@@ -299,3 +295,25 @@ pub fn directory_listing<S>(
             ))
     }
 }
+
+pub fn extract_query_parameters<S>(
+    req: &HttpRequest<S>,
+) -> (
+    Option<SortingMethod>,
+    Option<SortingOrder>,
+    Option<CompressionMethod>,
+    Option<ColorScheme>,
+    Option<PathBuf>,
+) {
+    if let Ok(query) = Query::<QueryParameters>::extract(req) {
+        (
+            query.sort,
+            query.order,
+            query.download.clone(),
+            query.theme,
+            query.path.clone(),
+        )
+    } else {
+        (None, None, None, None, None)
+    }
+}
diff --git a/src/main.rs b/src/main.rs
index 22b91cb..3bac14d 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -287,6 +287,9 @@ fn error_404(req: &HttpRequest<crate::MiniserveConfig>) -> Result<HttpResponse,
         None => "/".to_string(),
     };
 
+    let (sort_method, sort_order, _, color_scheme, _) = listing::extract_query_parameters(req);
+    let color_scheme = color_scheme.unwrap_or(default_color_scheme);
+
     errors::log_error_chain(err_404.to_string());
 
     Ok(actix_web::HttpResponse::NotFound().body(
@@ -294,11 +297,12 @@ fn error_404(req: &HttpRequest<crate::MiniserveConfig>) -> Result<HttpResponse,
             &err_404.to_string(),
             StatusCode::NOT_FOUND,
             &return_address,
-            None,
-            None,
-            default_color_scheme,
+            sort_method,
+            sort_order,
+            color_scheme,
             default_color_scheme,
             false,
+            true,
         )
         .into_string(),
     ))
diff --git a/src/renderer.rs b/src/renderer.rs
index acef208..cdcec94 100644
--- a/src/renderer.rs
+++ b/src/renderer.rs
@@ -854,6 +854,7 @@ pub fn render_error(
     color_scheme: ColorScheme,
     default_color_scheme: ColorScheme,
     has_referer: bool,
+    display_back_link: bool,
 ) -> Markup {
     let link = if has_referer {
         return_address.to_string()
@@ -875,9 +876,11 @@ pub fn render_error(
                 @for error in error_description.lines() {
                     p { (error) }
                 }
-                div.error-nav {
-                    a.error-back href=(link) {
-                        "Go back to file listing"
+                @if display_back_link {
+                    div.error-nav {
+                        a.error-back href=(link) {
+                            "Go back to file listing"
+                        }
                     }
                 }
             }
-- 
cgit v1.2.3


From c461a1d0149317e7086e2fb6b128618fcec11262 Mon Sep 17 00:00:00 2001
From: boastful-squirrel <boastful.squirrel@gmail.com>
Date: Thu, 2 May 2019 21:44:06 +0200
Subject: Display path instead of uri in 404 error

---
 src/main.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src')

diff --git a/src/main.rs b/src/main.rs
index 3bac14d..5c0edb7 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -280,7 +280,7 @@ fn configure_app(app: App<MiniserveConfig>) -> App<MiniserveConfig> {
 }
 
 fn error_404(req: &HttpRequest<crate::MiniserveConfig>) -> Result<HttpResponse, io::Error> {
-    let err_404 = ContextualError::RouteNotFoundError(req.uri().to_string());
+    let err_404 = ContextualError::RouteNotFoundError(req.path().to_string());
     let default_color_scheme = req.state().default_color_scheme;
     let return_address = match &req.state().random_route {
         Some(random_route) => format!("/{}", random_route),
-- 
cgit v1.2.3


From 74b95a37ee569e5d06577d80703fbb246a254bf5 Mon Sep 17 00:00:00 2001
From: boastful-squirrel <boastful.squirrel@gmail.com>
Date: Thu, 2 May 2019 22:00:44 +0200
Subject: Print error when parsing query parameters fail

---
 src/listing.rs | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

(limited to 'src')

diff --git a/src/listing.rs b/src/listing.rs
index 2e3093d..2d00836 100644
--- a/src/listing.rs
+++ b/src/listing.rs
@@ -11,7 +11,7 @@ use std::time::SystemTime;
 use strum_macros::{Display, EnumString};
 
 use crate::archive::{self, CompressionMethod};
-use crate::errors;
+use crate::errors::{self, ContextualError};
 use crate::renderer;
 use crate::themes::ColorScheme;
 
@@ -305,15 +305,18 @@ pub fn extract_query_parameters<S>(
     Option<ColorScheme>,
     Option<PathBuf>,
 ) {
-    if let Ok(query) = Query::<QueryParameters>::extract(req) {
-        (
+    match Query::<QueryParameters>::extract(req) {
+        Ok(query) => (
             query.sort,
             query.order,
             query.download.clone(),
             query.theme,
             query.path.clone(),
-        )
-    } else {
-        (None, None, None, None, None)
+        ),
+        Err(e) => {
+            let err = ContextualError::ParseError("query parameters".to_string(), e.to_string());
+            errors::log_error_chain(err.to_string());
+            (None, None, None, None, None)
+        }
     }
 }
-- 
cgit v1.2.3


From a73a74283f64986ff6a0b6da4c234a828bc52522 Mon Sep 17 00:00:00 2001
From: boastful-squirrel <boastful.squirrel@gmail.com>
Date: Fri, 3 May 2019 19:32:51 +0200
Subject: Return QueryParameters struct instead of tuple

---
 src/args.rs        |  2 +-
 src/auth.rs        |  2 +-
 src/file_upload.rs | 22 +++++++++++-----------
 src/listing.rs     | 50 ++++++++++++++++++++++++--------------------------
 src/main.rs        | 12 +++++++-----
 5 files changed, 44 insertions(+), 44 deletions(-)

(limited to 'src')

diff --git a/src/args.rs b/src/args.rs
index 5671425..6a9bf83 100644
--- a/src/args.rs
+++ b/src/args.rs
@@ -161,7 +161,7 @@ pub fn parse_args() -> crate::MiniserveConfig {
     }
 }
 
-#[cfg_attr(rustfmt, rustfmt_skip)]
+#[rustfmt::skip]
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/src/auth.rs b/src/auth.rs
index c3cbd54..f2e5fcf 100644
--- a/src/auth.rs
+++ b/src/auth.rs
@@ -168,7 +168,7 @@ fn build_unauthorized_response(
     .into_string()
 }
 
-#[cfg_attr(rustfmt, rustfmt_skip)]
+#[rustfmt::skip]
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/src/file_upload.rs b/src/file_upload.rs
index 36b2401..537c90c 100644
--- a/src/file_upload.rs
+++ b/src/file_upload.rs
@@ -127,9 +127,9 @@ pub fn upload_file(
         "/".to_string()
     };
 
-    let (sort_method, sort_order, _, color_scheme, path) = listing::extract_query_parameters(req);
-    let color_scheme = color_scheme.unwrap_or(default_color_scheme);
-    let upload_path = match path {
+    let query_params = listing::extract_query_parameters(req);
+    let color_scheme = query_params.theme.unwrap_or(default_color_scheme);
+    let upload_path = match query_params.path.clone() {
         Some(path) => match path.strip_prefix(Component::RootDir) {
             Ok(stripped_path) => stripped_path.to_owned(),
             Err(_) => path.clone(),
@@ -142,8 +142,8 @@ pub fn upload_file(
                 &err.to_string(),
                 StatusCode::BAD_REQUEST,
                 &return_path,
-                sort_method,
-                sort_order,
+                query_params.sort,
+                query_params.order,
                 color_scheme,
                 default_color_scheme,
             ));
@@ -161,8 +161,8 @@ pub fn upload_file(
                 &err.to_string(),
                 StatusCode::INTERNAL_SERVER_ERROR,
                 &return_path,
-                sort_method,
-                sort_order,
+                query_params.sort,
+                query_params.order,
                 color_scheme,
                 default_color_scheme,
             ));
@@ -180,8 +180,8 @@ pub fn upload_file(
                 &err.to_string(),
                 StatusCode::BAD_REQUEST,
                 &return_path,
-                sort_method,
-                sort_order,
+                query_params.sort,
+                query_params.order,
                 color_scheme,
                 default_color_scheme,
             ));
@@ -204,8 +204,8 @@ pub fn upload_file(
                     &e.to_string(),
                     StatusCode::INTERNAL_SERVER_ERROR,
                     &return_path,
-                    sort_method,
-                    sort_order,
+                    query_params.sort,
+                    query_params.order,
                     color_scheme,
                     default_color_scheme,
                 ),
diff --git a/src/listing.rs b/src/listing.rs
index b3c21ae..49802bc 100644
--- a/src/listing.rs
+++ b/src/listing.rs
@@ -145,7 +145,7 @@ pub fn directory_listing<S>(
         Err(_) => base.to_path_buf(),
     };
 
-    let (sort_method, sort_order, download, color_scheme, _) = extract_query_parameters(req);
+    let query_params = extract_query_parameters(req);
 
     let mut entries: Vec<Entry> = Vec::new();
 
@@ -203,7 +203,7 @@ pub fn directory_listing<S>(
         }
     }
 
-    if let Some(sorting_method) = sort_method {
+    if let Some(sorting_method) = query_params.sort {
         match sorting_method {
             SortingMethod::Name => entries
                 .sort_by(|e1, e2| alphanumeric_sort::compare_str(e1.name.clone(), e2.name.clone())),
@@ -227,15 +227,15 @@ pub fn directory_listing<S>(
         entries.sort_by(|e1, e2| alphanumeric_sort::compare_str(e1.name.clone(), e2.name.clone()))
     }
 
-    if let Some(sorting_order) = sort_order {
+    if let Some(sorting_order) = query_params.order {
         if let SortingOrder::Descending = sorting_order {
             entries.reverse()
         }
     }
 
-    let color_scheme = color_scheme.unwrap_or_else(|| default_color_scheme);
+    let color_scheme = query_params.theme.unwrap_or(default_color_scheme);
 
-    if let Some(compression_method) = &download {
+    if let Some(compression_method) = &query_params.download {
         log::info!(
             "Creating an archive ({extension}) of {path}...",
             extension = compression_method.extension(),
@@ -264,8 +264,8 @@ pub fn directory_listing<S>(
                             &err.to_string(),
                             StatusCode::INTERNAL_SERVER_ERROR,
                             serve_path,
-                            sort_method,
-                            sort_order,
+                            query_params.sort,
+                            query_params.order,
                             color_scheme,
                             default_color_scheme,
                             false,
@@ -284,8 +284,8 @@ pub fn directory_listing<S>(
                     entries,
                     is_root,
                     page_parent,
-                    sort_method,
-                    sort_order,
+                    query_params.sort,
+                    query_params.order,
                     default_color_scheme,
                     color_scheme,
                     file_upload,
@@ -297,27 +297,25 @@ pub fn directory_listing<S>(
     }
 }
 
-pub fn extract_query_parameters<S>(
-    req: &HttpRequest<S>,
-) -> (
-    Option<SortingMethod>,
-    Option<SortingOrder>,
-    Option<CompressionMethod>,
-    Option<ColorScheme>,
-    Option<PathBuf>,
-) {
+pub fn extract_query_parameters<S>(req: &HttpRequest<S>) -> QueryParameters {
     match Query::<QueryParameters>::extract(req) {
-        Ok(query) => (
-            query.sort,
-            query.order,
-            query.download.clone(),
-            query.theme,
-            query.path.clone(),
-        ),
+        Ok(query) => QueryParameters {
+            sort: query.sort,
+            order: query.order,
+            download: query.download.clone(),
+            theme: query.theme,
+            path: query.path.clone(),
+        },
         Err(e) => {
             let err = ContextualError::ParseError("query parameters".to_string(), e.to_string());
             errors::log_error_chain(err.to_string());
-            (None, None, None, None, None)
+            QueryParameters {
+                sort: None,
+                order: None,
+                download: None,
+                theme: None,
+                path: None,
+            }
         }
     }
 }
diff --git a/src/main.rs b/src/main.rs
index 07827c0..bcfda09 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -83,7 +83,9 @@ fn run() -> Result<(), ContextualError> {
         && miniserve_config
             .path
             .symlink_metadata()
-            .map_err(|e| ContextualError::IOError("Failed to retrieve symlink's metadata".to_string(), e))?
+            .map_err(|e| {
+                ContextualError::IOError("Failed to retrieve symlink's metadata".to_string(), e)
+            })?
             .file_type()
             .is_symlink()
     {
@@ -285,8 +287,8 @@ fn error_404(req: &HttpRequest<crate::MiniserveConfig>) -> Result<HttpResponse,
         None => "/".to_string(),
     };
 
-    let (sort_method, sort_order, _, color_scheme, _) = listing::extract_query_parameters(req);
-    let color_scheme = color_scheme.unwrap_or(default_color_scheme);
+    let query_params = listing::extract_query_parameters(req);
+    let color_scheme = query_params.theme.unwrap_or(default_color_scheme);
 
     errors::log_error_chain(err_404.to_string());
 
@@ -295,8 +297,8 @@ fn error_404(req: &HttpRequest<crate::MiniserveConfig>) -> Result<HttpResponse,
             &err_404.to_string(),
             StatusCode::NOT_FOUND,
             &return_address,
-            sort_method,
-            sort_order,
+            query_params.sort,
+            query_params.order,
             color_scheme,
             default_color_scheme,
             false,
-- 
cgit v1.2.3


From 8bcf7ba0376c0ab54938624a8798cb4e7e156448 Mon Sep 17 00:00:00 2001
From: khai96_ <hvksmr1996@gmail.com>
Date: Mon, 6 May 2019 21:13:42 +0700
Subject: Add example for --auth formatting

---
 src/args.rs | 1 +
 1 file changed, 1 insertion(+)

(limited to 'src')

diff --git a/src/args.rs b/src/args.rs
index 63799a0..a67583a 100644
--- a/src/args.rs
+++ b/src/args.rs
@@ -40,6 +40,7 @@ struct CLIArgs {
 
     /// Set authentication. Currently supported formats:
     /// username:password, username:sha256:hash, username:sha512:hash
+    /// (e.g. joe:123, joe:sha256:a665a45920422f9d417e4867efdc4fb8a04a1f3fff1fa07e998e86f7f7a27ae3)
     #[structopt(short = "a", long = "auth", parse(try_from_str = "parse_auth"))]
     auth: Option<auth::RequiredAuth>,
 
-- 
cgit v1.2.3


From 3d8d4eebe9d291c695705b875381aa129313401b Mon Sep 17 00:00:00 2001
From: boastful-squirrel <boastful.squirrel@gmail.com>
Date: Mon, 6 May 2019 18:46:03 +0200
Subject: Undo changes on src/archive.rs

---
 src/archive.rs | 43 +++++++++++++++++++++++++++++++------------
 1 file changed, 31 insertions(+), 12 deletions(-)

(limited to 'src')

diff --git a/src/archive.rs b/src/archive.rs
index 02300c5..a76446a 100644
--- a/src/archive.rs
+++ b/src/archive.rs
@@ -7,7 +7,7 @@ use std::path::PathBuf;
 use strum_macros::{Display, EnumIter, EnumString};
 use tar::Builder;
 
-use crate::errors::ContextualError;
+use crate::errors::{ContextualError};
 
 /// Available compression methods
 #[derive(Deserialize, Clone, EnumIter, EnumString, Display)]
@@ -62,11 +62,17 @@ fn tgz_compress(dir: &PathBuf, skip_symlinks: bool) -> Result<(String, Bytes), C
             let mut tgz_data = Bytes::new();
 
             let tar_data = tar(src_dir, directory.to_string(), skip_symlinks).map_err(|e| {
-                ContextualError::ArchiveCreationError("tarball".to_string(), Box::new(e))
+                ContextualError::ArchiveCreationError(
+                    "tarball".to_string(),
+                    Box::new(e),
+                )
             })?;
 
             let gz_data = gzip(&tar_data).map_err(|e| {
-                ContextualError::ArchiveCreationError("GZIP archive".to_string(), Box::new(e))
+                ContextualError::ArchiveCreationError(
+                    "GZIP archive".to_string(),
+                    Box::new(e),
+                )
             })?;
 
             tgz_data.extend_from_slice(&gz_data);
@@ -109,7 +115,10 @@ fn tar(
         })?;
 
     let tar_content = tar_builder.into_inner().map_err(|e| {
-        ContextualError::IOError("Failed to finish writing the TAR archive".to_string(), e)
+        ContextualError::IOError(
+            "Failed to finish writing the TAR archive".to_string(),
+            e,
+        )
     })?;
 
     Ok(tar_content)
@@ -117,14 +126,24 @@ fn tar(
 
 /// Compresses a stream of bytes using the GZIP algorithm, and returns the resulting stream
 fn gzip(mut data: &[u8]) -> Result<Vec<u8>, ContextualError> {
-    let mut encoder = Encoder::new(Vec::new())
-        .map_err(|e| ContextualError::IOError("Failed to create GZIP encoder".to_string(), e))?;
-    io::copy(&mut data, &mut encoder)
-        .map_err(|e| ContextualError::IOError("Failed to write GZIP data".to_string(), e))?;
-    let data = encoder
-        .finish()
-        .into_result()
-        .map_err(|e| ContextualError::IOError("Failed to write GZIP trailer".to_string(), e))?;
+    let mut encoder = Encoder::new(Vec::new()).map_err(|e| {
+        ContextualError::IOError(
+            "Failed to create GZIP encoder".to_string(),
+            e,
+        )
+    })?;
+    io::copy(&mut data, &mut encoder).map_err(|e| {
+        ContextualError::IOError(
+            "Failed to write GZIP data".to_string(),
+            e,
+        )
+    })?;
+    let data = encoder.finish().into_result().map_err(|e| {
+        ContextualError::IOError(
+            "Failed to write GZIP trailer".to_string(),
+            e,
+        )
+    })?;
 
     Ok(data)
 }
-- 
cgit v1.2.3


From 5b43a629a8592c1a3f49a3e42d62713a96dee0c8 Mon Sep 17 00:00:00 2001
From: boastful-squirrel <boastful.squirrel@gmail.com>
Date: Mon, 6 May 2019 18:54:14 +0200
Subject: Undo changes on InvalidHashMethod error

---
 src/args.rs   | 2 +-
 src/errors.rs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'src')

diff --git a/src/args.rs b/src/args.rs
index bbf6ad1..ea0a4ac 100644
--- a/src/args.rs
+++ b/src/args.rs
@@ -205,7 +205,7 @@ mod tests {
         ),
         case(
             "username:blahblah:abcd",
-            "Invalid hashing method blahblah. Expected sha256 or sha512"
+            "blahblah is not a valid hashing method. Expected sha256 or sha512"
         ),
         case(
             "username:sha256:invalid",
diff --git a/src/errors.rs b/src/errors.rs
index e5d2e41..68f6d7d 100644
--- a/src/errors.rs
+++ b/src/errors.rs
@@ -32,7 +32,7 @@ pub enum ContextualError {
     InvalidAuthFormat,
 
     /// This error might occure if the hash method is neither sha256 nor sha512
-    #[fail(display = "Invalid hashing method {}. Expected sha256 or sha512", _0)]
+    #[fail(display = "{} is not a valid hashing method. Expected sha256 or sha512", _0)]
     InvalidHashMethod(String),
 
     /// This error might occur if the HTTP auth hash password is not a valid hex code
-- 
cgit v1.2.3


From 26ae6d973468eb80a71199d80c0db210e6883968 Mon Sep 17 00:00:00 2001
From: boastful-squirrel <boastful.squirrel@gmail.com>
Date: Mon, 6 May 2019 18:56:32 +0200
Subject: Undo changes on args.rs

---
 src/args.rs | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

(limited to 'src')

diff --git a/src/args.rs b/src/args.rs
index ea0a4ac..d291bb9 100644
--- a/src/args.rs
+++ b/src/args.rs
@@ -3,7 +3,7 @@ use std::path::PathBuf;
 use structopt::StructOpt;
 
 use crate::auth;
-use crate::errors::ContextualError;
+use crate::errors::{ContextualError};
 use crate::themes;
 
 /// Possible characters for random routes
@@ -99,13 +99,15 @@ fn parse_auth(src: &str) -> Result<auth::RequiredAuth, ContextualError> {
         let hash_bin = if let Ok(hash_bin) = hex::decode(hash_hex) {
             hash_bin
         } else {
-            return Err(ContextualError::InvalidPasswordHash);
+            return Err(ContextualError::InvalidPasswordHash)
         };
 
         match second_part {
             "sha256" => auth::RequiredAuthPassword::Sha256(hash_bin.to_owned()),
             "sha512" => auth::RequiredAuthPassword::Sha512(hash_bin.to_owned()),
-            _ => return Err(ContextualError::InvalidHashMethod(second_part.to_owned())),
+            _ => {
+                return Err(ContextualError::InvalidHashMethod(second_part.to_owned()))
+            },
         }
     } else {
         // To make it Windows-compatible, the password needs to be shorter than 255 characters.
-- 
cgit v1.2.3


From 09105cf479b25171cbe89d7ff3ed4f3feee16c01 Mon Sep 17 00:00:00 2001
From: boastful-squirrel <boastful.squirrel@gmail.com>
Date: Fri, 10 May 2019 18:18:21 +0200
Subject: cargo fmt

---
 src/archive.rs | 43 ++++++++++++-------------------------------
 src/args.rs    |  8 +++-----
 src/errors.rs  |  5 ++++-
 3 files changed, 19 insertions(+), 37 deletions(-)

(limited to 'src')

diff --git a/src/archive.rs b/src/archive.rs
index a76446a..02300c5 100644
--- a/src/archive.rs
+++ b/src/archive.rs
@@ -7,7 +7,7 @@ use std::path::PathBuf;
 use strum_macros::{Display, EnumIter, EnumString};
 use tar::Builder;
 
-use crate::errors::{ContextualError};
+use crate::errors::ContextualError;
 
 /// Available compression methods
 #[derive(Deserialize, Clone, EnumIter, EnumString, Display)]
@@ -62,17 +62,11 @@ fn tgz_compress(dir: &PathBuf, skip_symlinks: bool) -> Result<(String, Bytes), C
             let mut tgz_data = Bytes::new();
 
             let tar_data = tar(src_dir, directory.to_string(), skip_symlinks).map_err(|e| {
-                ContextualError::ArchiveCreationError(
-                    "tarball".to_string(),
-                    Box::new(e),
-                )
+                ContextualError::ArchiveCreationError("tarball".to_string(), Box::new(e))
             })?;
 
             let gz_data = gzip(&tar_data).map_err(|e| {
-                ContextualError::ArchiveCreationError(
-                    "GZIP archive".to_string(),
-                    Box::new(e),
-                )
+                ContextualError::ArchiveCreationError("GZIP archive".to_string(), Box::new(e))
             })?;
 
             tgz_data.extend_from_slice(&gz_data);
@@ -115,10 +109,7 @@ fn tar(
         })?;
 
     let tar_content = tar_builder.into_inner().map_err(|e| {
-        ContextualError::IOError(
-            "Failed to finish writing the TAR archive".to_string(),
-            e,
-        )
+        ContextualError::IOError("Failed to finish writing the TAR archive".to_string(), e)
     })?;
 
     Ok(tar_content)
@@ -126,24 +117,14 @@ fn tar(
 
 /// Compresses a stream of bytes using the GZIP algorithm, and returns the resulting stream
 fn gzip(mut data: &[u8]) -> Result<Vec<u8>, ContextualError> {
-    let mut encoder = Encoder::new(Vec::new()).map_err(|e| {
-        ContextualError::IOError(
-            "Failed to create GZIP encoder".to_string(),
-            e,
-        )
-    })?;
-    io::copy(&mut data, &mut encoder).map_err(|e| {
-        ContextualError::IOError(
-            "Failed to write GZIP data".to_string(),
-            e,
-        )
-    })?;
-    let data = encoder.finish().into_result().map_err(|e| {
-        ContextualError::IOError(
-            "Failed to write GZIP trailer".to_string(),
-            e,
-        )
-    })?;
+    let mut encoder = Encoder::new(Vec::new())
+        .map_err(|e| ContextualError::IOError("Failed to create GZIP encoder".to_string(), e))?;
+    io::copy(&mut data, &mut encoder)
+        .map_err(|e| ContextualError::IOError("Failed to write GZIP data".to_string(), e))?;
+    let data = encoder
+        .finish()
+        .into_result()
+        .map_err(|e| ContextualError::IOError("Failed to write GZIP trailer".to_string(), e))?;
 
     Ok(data)
 }
diff --git a/src/args.rs b/src/args.rs
index d291bb9..ea0a4ac 100644
--- a/src/args.rs
+++ b/src/args.rs
@@ -3,7 +3,7 @@ use std::path::PathBuf;
 use structopt::StructOpt;
 
 use crate::auth;
-use crate::errors::{ContextualError};
+use crate::errors::ContextualError;
 use crate::themes;
 
 /// Possible characters for random routes
@@ -99,15 +99,13 @@ fn parse_auth(src: &str) -> Result<auth::RequiredAuth, ContextualError> {
         let hash_bin = if let Ok(hash_bin) = hex::decode(hash_hex) {
             hash_bin
         } else {
-            return Err(ContextualError::InvalidPasswordHash)
+            return Err(ContextualError::InvalidPasswordHash);
         };
 
         match second_part {
             "sha256" => auth::RequiredAuthPassword::Sha256(hash_bin.to_owned()),
             "sha512" => auth::RequiredAuthPassword::Sha512(hash_bin.to_owned()),
-            _ => {
-                return Err(ContextualError::InvalidHashMethod(second_part.to_owned()))
-            },
+            _ => return Err(ContextualError::InvalidHashMethod(second_part.to_owned())),
         }
     } else {
         // To make it Windows-compatible, the password needs to be shorter than 255 characters.
diff --git a/src/errors.rs b/src/errors.rs
index 68f6d7d..2878e37 100644
--- a/src/errors.rs
+++ b/src/errors.rs
@@ -32,7 +32,10 @@ pub enum ContextualError {
     InvalidAuthFormat,
 
     /// This error might occure if the hash method is neither sha256 nor sha512
-    #[fail(display = "{} is not a valid hashing method. Expected sha256 or sha512", _0)]
+    #[fail(
+        display = "{} is not a valid hashing method. Expected sha256 or sha512",
+        _0
+    )]
     InvalidHashMethod(String),
 
     /// This error might occur if the HTTP auth hash password is not a valid hex code
-- 
cgit v1.2.3


From 6b708b432648cf5e62e8d61609eff942f885f538 Mon Sep 17 00:00:00 2001
From: boastful-squirrel <boastful.squirrel@gmail.com>
Date: Fri, 10 May 2019 18:38:23 +0200
Subject: Fix clippy

---
 src/main.rs     | 4 +---
 src/renderer.rs | 1 +
 2 files changed, 2 insertions(+), 3 deletions(-)

(limited to 'src')

diff --git a/src/main.rs b/src/main.rs
index bcfda09..bb61edc 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -83,9 +83,7 @@ fn run() -> Result<(), ContextualError> {
         && miniserve_config
             .path
             .symlink_metadata()
-            .map_err(|e| {
-                ContextualError::IOError("Failed to retrieve symlink's metadata".to_string(), e)
-            })?
+            .map_err(|e| ContextualError::IOError("Failed to retrieve symlink's metadata".to_string(), e))?
             .file_type()
             .is_symlink()
     {
diff --git a/src/renderer.rs b/src/renderer.rs
index 098cf91..d1e16ea 100644
--- a/src/renderer.rs
+++ b/src/renderer.rs
@@ -846,6 +846,7 @@ fn humanize_systemtime(src_time: Option<SystemTime>) -> Option<String> {
 }
 
 /// Renders an error on the webpage
+#[allow(clippy::too_many_arguments)]
 pub fn render_error(
     error_description: &str,
     error_code: StatusCode,
-- 
cgit v1.2.3