update deps

Bump regex from 1.5.4 to 1.5.5

.cargo/config.toml

@@ -1,2 +1,5 @@
 [target.x86_64-pc-windows-msvc]
 rustflags = ["-C", "target-feature=+crt-static"]
+
+[target.aarch64-unknown-linux-musl]
+linker = "aarch64-linux-musl-gcc"

.github/workflows/release.yml

@@ -18,8 +18,12 @@ jobs:
     strategy:
       matrix:
         include:
+          - target: aarch64-unknown-linux-musl
+            os: ubuntu-latest
           - target: x86_64-unknown-linux-musl
             os: ubuntu-latest
+          - target: aarch64-apple-darwin
+            os: macos-latest
           - target: x86_64-apple-darwin
             os: macos-latest
           - target: x86_64-pc-windows-msvc
@@ -30,6 +34,7 @@ jobs:
       - uses: taiki-e/upload-rust-binary-action@v1
         with:
           bin: srv
+          archive: $bin-$tag-$target
           target: ${{ matrix.target }}
           tar: unix
           zip: windows

Cargo.toml

@@ -3,27 +3,27 @@ authors = ["Tim_Paik <timpaikc@outlook.com>"]
 description = "simple http server written in rust"
 edition = "2018"
 name = "srv"
-version = "1.0.0-rc"
+version = "1.0.1"
 
 [dependencies]
-actix-files = "0.5"
+actix-files = "0.6"
-actix-http = "2.2"
+actix-web = {version = "4.1", features = ["rustls"]}
-actix-web = {version = "3.3", features = ["rustls"]}
+actix-web-httpauth = "0.6"
-actix-web-httpauth = "0.5"
 chrono = "0.4"
-clap = {version = "3.0.0-beta.4", features = ["wrap_help", "color"]}
+clap = {version = "3.2", features = ["wrap_help", "color", "cargo"]}
 env_logger = "0.9"
 lazy_static = "1.4"
 log = "0.4"
-mime_guess = "2"
+mime_guess = "2.0"
-regex = "1.5"
+rustls = "0.20"
-rustls = "0.18"
+rustls-pemfile = "1.0"
-serde = "1"
+serde = {version = "1.0", features = ["derive"]}
-sha2 = "0.9"
+sha2 = "0.10"
-tera = "1"
+tera = "1.16"
 toml = "0.5"
 urlencoding = "2.1"
 
 [profile.release]
 lto = true
 opt-level = "z"
+strip = true

README.md

@@ -7,7 +7,6 @@ This is a simple HTTP Server for use in a development environment, inspired by [
 
 ### Built With
 
-- ~~[rocket](https://github.com/SergioBenitez/Rocket)~~ Framework used in previous versions
 - [clap](https://github.com/clap-rs/clap) Provide command line parameter analysis
 - [tera](https://github.com/Keats/tera) Provide template support
 - [actix-web](https://github.com/actix/actix-web) Main frame
@@ -51,10 +50,10 @@ yay -S srv-bin
 Download the pre-compiled `srv-x86_64-unknown-linux-musl.tar.gz` on the [releases](https://github.com/Tim-Paik/srv/releases/latest), and copy the srv file in the compressed package to `/usr/bin` as a ROOT user with 755 permissions.
 
 ```shell
-wget https://github.com/Tim-Paik/srv/releases/download/v1.0.0-rc.6/srv-x86_64-unknown-linux-musl.tar.gz
+wget https://github.com/Tim-Paik/srv/releases/download/v1.0.1/srv-v1.0.1-x86_64-unknown-linux-musl.tar.gz
-tar -xzvf srv-x86_64-unknown-linux-musl.tar.gz
+tar -xzvf srv-v1.0.1-x86_64-unknown-linux-musl.tar.gz
 install -Dm0755 -t /usr/bin/ srv
-rm srv srv-x86_64-unknown-linux-musl.tar.gz
+rm srv srv-v1.0.1-x86_64-unknown-linux-musl.tar.gz
 ```
 for reference only
 
@@ -78,7 +77,6 @@ You Need:
 git clone git@github.com:Tim-Paik/srv.git
 cd srv
 cargo build --release
-strip target/release/srv
 ```
 
 Then you can find the compiled executable file named `srv` in the `target/release/` folder.
@@ -89,6 +87,10 @@ Execute `srv --help` to get all the usage methods
 
 Waiting to be added...
 
+## Contributing
+
+All contributions are welcome and I will reply as soon as I see it :)
+
 ## License
 
 ```text

src/main.rs

@@ -2,8 +2,6 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
-#[macro_use]
-extern crate clap;
 #[macro_use]
 extern crate lazy_static;
 
@@ -12,8 +10,10 @@ use actix_web::{
     dev::{self, Service, ServiceResponse},
     http, middleware, App, HttpResponse, HttpServer,
 };
+use clap::Arg;
 use env_logger::fmt::Color;
 use log::{error, info};
+use serde::{Deserialize, Serialize};
 use sha2::Digest;
 use std::{
     env::{set_var, var},
@@ -155,23 +155,23 @@ fn get_file_type(from: &Path) -> String {
     .to_string()
 }
 
-#[derive(serde::Deserialize)]
+#[derive(Deserialize)]
 struct Package {
     name: String,
 }
 
-#[derive(serde::Deserialize)]
+#[derive(Deserialize)]
 struct CargoToml {
     package: Package,
 }
 
-#[derive(Eq, Ord, PartialEq, PartialOrd, serde::Serialize)]
+#[derive(Eq, Ord, PartialEq, PartialOrd, Serialize)]
 struct Dir {
     name: String,
     modified: String,
 }
 
-#[derive(Eq, Ord, PartialEq, PartialOrd, serde::Serialize)]
+#[derive(Eq, Ord, PartialEq, PartialOrd, Serialize)]
 struct File {
     name: String,
     size: u64,
@@ -179,7 +179,7 @@ struct File {
     modified: String,
 }
 
-#[derive(serde::Serialize)]
+#[derive(Serialize)]
 struct IndexContext {
     title: String,
     paths: Vec<String>,
@@ -194,18 +194,14 @@ fn render_index(
     let mut index = dir.path.clone();
     index.push("index.html");
     if index.exists() && index.is_file() {
-        let res = match actix_files::NamedFile::open(index)?
+        let res = actix_files::NamedFile::open(index)?
             .set_content_type(mime_guess::mime::TEXT_HTML_UTF_8)
-            .into_response(req)
+            .into_response(req);
-        {
+        return Ok(ServiceResponse::new(req.to_owned(), res));
-            Ok(res) => res,
-            Err(e) => return Err(Error::new(ErrorKind::Other, e.to_string())),
-        };
-        return Ok(ServiceResponse::new(req.clone(), res));
     }
     if var("NOINDEX").unwrap_or_else(|_| "false".to_string()) == "true" {
         return Ok(ServiceResponse::new(
-            req.clone(),
+            req.to_owned(),
             HttpResponse::NotFound().body(""),
         ));
     }
@@ -296,7 +292,7 @@ fn render_index(
     let res = HttpResponse::Ok()
         .content_type("text/html; charset=utf-8")
         .body(index);
-    Ok(ServiceResponse::new(req.clone(), res))
+    Ok(ServiceResponse::new(req.to_owned(), res))
 }
 
 #[inline]
@@ -342,102 +338,70 @@ async fn validator(
 
 #[actix_web::main]
 async fn main() -> std::io::Result<()> {
-    let matches = clap_app!((crate_name!()) =>
+    let check_does_dir_exits = |path: &str| match std::fs::metadata(path) {
-        (version: crate_version!())
+        Ok(meta) => {
-        (author: crate_authors!())
+            if meta.is_dir() {
-        (about: crate_description!())
+                Ok(())
-        (@arg noindex: --noindex "Disable automatic index page generation")
+            } else {
-        (@arg compress: -c --compress "Enable streaming compression (Content-length/segment download will be disabled)")
+                Err("Parameter is not a directory".to_owned())
-        // (@arg upload: -u --upload "Enable file upload")
-        (@arg nocache: --nocache "Disable HTTP cache")
-        (@arg nocolor: --nocolor "Disable cli colors")
-        (@arg cors: --cors [VALUE] min_values(0) max_values(1) "Enable CORS")
-        (@arg spa: --spa "Enable Single-Page Application mode (always serve /index.html when the file is not found)")
-        (@arg dotfiles: -d --dotfiles "Show dotfiles")
-        (@arg open: -o --open "Open the page in the default browser")
-        (@arg quiet: -q --quiet "Disable access log output")
-        (@arg quietall: --quietall "Disable all output")
-        (@arg ROOT: default_value["."] {
-            |path| match std::fs::metadata(path) {
-                Ok(meta) => {
-                    if meta.is_dir() {
-                        Ok(())
-                    } else {
-                        Err("Parameter is not a directory".to_owned())
-                    }
-                }
-                Err(e) => Err(e.to_string()),
             }
-        } "Root directory")
+        }
-        (@arg address: -a --address +takes_value default_value["0.0.0.0"] {
+        Err(e) => Err(e.to_string()),
-            |s| match IpAddr::from_str(s) {
+    };
-                Ok(_) => Ok(()),
+    let check_does_file_exits = |path: &str| match std::fs::metadata(path) {
-                Err(e) => Err(e.to_string()),
+        Ok(metadata) => {
+            if metadata.is_file() {
+                Ok(())
+            } else {
+                Err("Parameter is not a file".to_owned())
             }
-        } "IP address to serve on")
+        }
-        (@arg port: -p --port +takes_value default_value["8000"] {
+        Err(e) => Err(e.to_string()),
-            |s| match s.parse::<u16>() {
+    };
-                Ok(_) => Ok(()),
+    let check_is_ip_addr = |s: &str| match IpAddr::from_str(s) {
-                Err(e) => Err(e.to_string()),
+        Ok(_) => Ok(()),
-            }
+        Err(e) => Err(e.to_string()),
-        } "Port to serve on")
+    };
-        (@arg auth: --auth +takes_value {
+    let check_is_port_num = |s: &str| match s.parse::<u16>() {
-            |s| {
+        Ok(_) => Ok(()),
-                let parts = s.splitn(2, ':').collect::<Vec<&str>>();
+        Err(e) => Err(e.to_string()),
-                if parts.len() < 2 || parts.len() >= 2 && parts[1].is_empty() {
+    };
-                    Err("Password not found".to_owned())
+    let check_is_auth = |s: &str| {
-                } else if parts[0].is_empty() {
+        let parts = s.splitn(2, ':').collect::<Vec<&str>>();
-                    Err("Username not found".to_owned())
+        if parts.len() < 2 || parts.len() >= 2 && parts[1].is_empty() {
-                } else {
+            Err("Password not found".to_owned())
-                    Ok(())
+        } else if parts[0].is_empty() {
-                }
+            Err("Username not found".to_owned())
-            }
+        } else {
-        } "HTTP Auth (username:password)")
+            Ok(())
-        (@arg cert: --cert +takes_value {
+        }
-            |s| match std::fs::metadata(s) {
+    };
-                Ok(metadata) => {
+    let matches = clap::command!()
-                    if metadata.is_file() {
+        .arg(Arg::new("noindex").long("noindex").help("Disable automatic index page generation"))
-                        Ok(())
+        .arg(Arg::new("nocache").long("nocache").help("Disable HTTP cache"))
-                    } else {
+        .arg(Arg::new("nocolor").long("nocolor").help("Disable cli colors"))
-                        Err("Parameter is not a file".to_owned())
+        .arg(Arg::new("cors").long("cors").takes_value(true).min_values(0).max_values(1).help("Enable CORS [with custom value]"))
-                    }
+        .arg(Arg::new("spa").long("spa").help("Enable Single-Page Application mode (always serve /index.html when the file is not found)"))
-                }
+        .arg(Arg::new("dotfiles").short('d').long("dotfiles").help("Show dotfiles"))
-                Err(e) => Err(e.to_string()),
+        .arg(Arg::new("open").short('o').long("open").help("Open the page in the default browser"))
-            }
+        .arg(Arg::new("quiet").short('q').long("quiet").help("Disable access log output"))
-        } "Path of TLS/SSL public key (certificate)")
+        .arg(Arg::new("quietall").long("quietall").help("Disable all output"))
-        (@arg key: --key +takes_value {
+        .arg(Arg::new("ROOT").default_value(".").validator(check_does_dir_exits).help("Root directory"))
-            |s| match std::fs::metadata(s) {
+        .arg(Arg::new("address").short('a').long("address").default_value("0.0.0.0").takes_value(true).validator(check_is_ip_addr).help("IP address to serve on"))
-                Ok(metadata) => {
+        .arg(Arg::new("port").short('p').long("port").default_value("8000").takes_value(true).validator(check_is_port_num).help("Port to serve on"))
-                    if metadata.is_file() {
+        .arg(Arg::new("auth").long("auth").takes_value(true).validator(check_is_auth).help("HTTP Auth (username:password)"))
-                        Ok(())
+        .arg(Arg::new("cert").long("cert").takes_value(true).validator(check_does_file_exits).help("Path of TLS/SSL public key (certificate)"))
-                    } else {
+        .arg(Arg::new("key").long("key").takes_value(true).validator(check_does_file_exits).help("Path of TLS/SSL private key"))
-                        Err("Parameter is not a file".to_owned())
+        .subcommand(clap::Command::new("doc")
-                    }
+            .about("Open cargo doc via local server (Need cargo installation)")
-                }
+            .arg(Arg::new("nocolor").long("nocolor").help("Disable cli colors"))
-                Err(e) => Err(e.to_string()),
+            .arg(Arg::new("noopen").long("noopen").help("Do not open the page in the default browser"))
-            }
+            .arg(Arg::new("log").long("log").help("Enable access log output [default: disabled]"))
-        } "Path of TLS/SSL private key")
+            .arg(Arg::new("quietall").long("quietall").help("Disable all output"))
-        (@subcommand doc =>
+            .arg(Arg::new("address").short('a').long("address").default_value("0.0.0.0").takes_value(true).validator(check_is_ip_addr).help("IP address to serve on"))
-            (about: "Open cargo doc via local server (Need cargo installation)")
+            .arg(Arg::new("port").short('p').long("port").default_value("8000").takes_value(true).validator(check_is_port_num).help("Port to serve on"))
-            (@arg nocolor: --nocolor "Disable cli colors")
-            (@arg noopen: -no --noopen "Do not open the page in the default browser")
-            (@arg log: --log "Enable access log output [default: false]")
-            (@arg quietall: --quietall "Disable all output")
-            (@arg address: -a --address +takes_value default_value["0.0.0.0"] {
-                |s| match IpAddr::from_str(s) {
-                    Ok(_) => Ok(()),
-                    Err(e) => Err(e.to_string()),
-                }
-            } "IP address to serve on")
-            (@arg port: -p --port +takes_value default_value["8000"] {
-                |s| match s.parse::<u16>() {
-                    Ok(_) => Ok(()),
-                    Err(e) => Err(e.to_string()),
-                }
-            } "Port to serve on")
         )
-    )
+        .get_matches();
-    .get_matches();
 
     set_var(
         "ROOT",
@@ -448,7 +412,6 @@ async fn main() -> std::io::Result<()> {
     set_var("SPA", matches.is_present("spa").to_string());
     set_var("DOTFILES", matches.is_present("dotfiles").to_string());
     set_var("NOCACHE", matches.is_present("nocache").to_string());
-    set_var("COMPRESS", matches.is_present("compress").to_string());
 
     if matches.is_present("quiet") {
         set_var("RUST_LOG", "info,actix_web::middleware::logger=off");
@@ -471,7 +434,7 @@ async fn main() -> std::io::Result<()> {
         set_var("ENABLE_CORS", matches.is_present("cors").to_string());
         match matches.value_of("cors") {
             Some(str) => {
-                set_var("CORS", str.to_string());
+                set_var("CORS", str);
             }
             None => {
                 set_var("CORS", "*");
@@ -484,11 +447,7 @@ async fn main() -> std::io::Result<()> {
         .value_of("address")
         .unwrap_or("127.0.0.1")
         .to_string();
-    let addr = format!(
+    let addr = format!("{}:{}", ip, matches.value_of("port").unwrap_or("8000"));
-        "{}:{}",
-        ip,
-        matches.value_of("port").unwrap_or("8000").to_string()
-    );
     let url = format!(
         "{}{}:{}",
         if enable_tls {
@@ -497,7 +456,7 @@ async fn main() -> std::io::Result<()> {
             "http://".to_string()
         },
         if ip == "0.0.0.0" { "127.0.0.1" } else { &ip },
-        matches.value_of("port").unwrap_or("8000").to_string()
+        matches.value_of("port").unwrap_or("8000")
     );
 
     let open_in_browser = |url: &str| {
@@ -520,76 +479,8 @@ async fn main() -> std::io::Result<()> {
         open_in_browser(&url);
     }
 
-    let addr = if let Some(matches) = matches.subcommand_matches("doc") {
+
-        let mut cargo_toml = match std::fs::File::open("./Cargo.toml") {
+    if let Some(matches) = matches.subcommand_matches("doc") {
-            Ok(file) => file,
-            Err(e) => {
-                error!("[ERROR] {}", e.to_string());
-                return Ok(());
-            }
-        };
-        let mut contents = String::new();
-        match cargo_toml.read_to_string(&mut contents) {
-            Ok(_) => {}
-            Err(e) => {
-                error!("[ERROR] {}", e.to_string());
-                return Ok(());
-            }
-        }
-        let contents: CargoToml = match toml::from_str(&contents) {
-            Ok(t) => t,
-            Err(e) => {
-                error!("[ERROR] {}", e.to_string());
-                return Ok(());
-            }
-        };
-        let crate_name = contents.package.name;
-        info!("[INFO] Generating document (may take a while)");
-        match std::process::Command::new("cargo").arg("doc").output() {
-            Ok(output) => {
-                let output = std::str::from_utf8(&output.stderr).unwrap_or("");
-                if output.starts_with("error: could not find `Cargo.toml` in") {
-                    error!("[ERROR] Cargo.toml Not Found");
-                    return Ok(());
-                } else if output.starts_with("error: ") {
-                    error!(
-                        "[ERROR] {}",
-                        output.strip_prefix("error: ").unwrap_or(output)
-                    );
-                    return Ok(());
-                }
-            }
-            Err(e) => {
-                error!("[ERROR] Cargo Error: {}", e.to_string());
-                return Ok(());
-            }
-        }
-        let path = Path::new("./target/doc/");
-        let mut index_path = path.to_path_buf();
-        index_path.push(crate_name.to_string() + "/index.html");
-        if !index_path.exists() || !index_path.is_file() {
-            error!("[ERROR] Cargo Error: doc path not found");
-            return Ok(());
-        }
-        set_var("ROOT", display_path(path));
-        let ip = matches
-            .value_of("address")
-            .unwrap_or("127.0.0.1")
-            .to_string();
-        let addr = format!(
-            "{}:{}",
-            ip,
-            matches.value_of("port").unwrap_or("8000").to_string()
-        );
-        let url = format!(
-            "http://{}:{}/{}/index.html",
-            if ip == "0.0.0.0" { "127.0.0.1" } else { &ip },
-            matches.value_of("port").unwrap_or("8000").to_string(),
-            crate_name,
-        );
-        if !matches.is_present("noopen") {
-            open_in_browser(&url);
-        }
         if !matches.is_present("log") {
             set_var("RUST_LOG", "info,actix_web::middleware::logger=off");
         }
@@ -599,24 +490,22 @@ async fn main() -> std::io::Result<()> {
         if matches.is_present("nocolor") {
             set_var("RUST_LOG_STYLE", "never");
         }
-        addr
+    }
-    } else {
-        addr
-    };
 
     env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info"))
-        .format(|buf, record| {
+        .format(move |buf, record| {
             let data = record.args().to_string();
             let mut style = buf.style();
-            let blue = style.set_color(Color::Rgb(52, 152, 219));
+            let blue = style.set_color(Color::Cyan);
             let mut style = buf.style();
-            let red = style.set_color(Color::Rgb(231, 76, 60));
+            let red = style.set_color(Color::Red);
             let mut style = buf.style();
-            let green = style.set_color(Color::Rgb(76, 175, 80));
+            let green = style.set_color(Color::Green);
             if record.target() == "actix_web::middleware::logger" {
                 let data: Vec<&str> = data.splitn(5, '^').collect();
                 let time = blue.value(
-                    chrono::NaiveDateTime::from_str(data[0])
+                    data[0]
+                        .parse::<chrono::DateTime<chrono::Utc>>()
                         .unwrap()
                         .format("%Y/%m/%d %H:%M:%S")
                         .to_string(),
@@ -648,30 +537,27 @@ async fn main() -> std::io::Result<()> {
                     time, ipaddr, status_code, process_time, content
                 );
             } else if record.target() == "actix_server::builder" {
-                if data.starts_with("SIGINT received, exiting") {
+                if data.starts_with("Starting ") && data.ends_with(" workers") {
-                    return writeln!(buf, "\r{}", green.value("[INFO] SIGINT received, exiting"));
+                    return Ok(());
-                    // Add '\r' to remove the input ^C
-                } else {
-                    let data = data.replace("actix-web-service-", "");
-                    let re1 = regex::Regex::new("Starting (.*) workers").unwrap();
-                    if re1.is_match(&data) {
-                        return Ok(());
-                    }
-                    let re2 = regex::Regex::new("Starting \"(.*)\" service on (.*)").unwrap();
-                    if re2.is_match(&data) {
-                        let addr = re2
-                            .captures(&data)
-                            .unwrap()
-                            .get(1)
-                            .map_or("", |m| m.as_str());
-                        let data = format!(
-                            "[INFO] Serving {} on {}",
-                            var("ROOT").unwrap_or_else(|_| ".".to_string()),
-                            addr
-                        );
-                        return writeln!(buf, "\r{}", green.value(data));
-                    }
                 }
+            } else if record.target() == "actix_server::server" {
+                if data == "Actix runtime found; starting in Actix runtime" {
+                    let data = format!(
+                        "[INFO] Serving {} on {}",
+                        var("ROOT").unwrap_or_else(|_| ".".to_string()),
+                        var("LISTEN_ADDRESS").unwrap_or_else(|_| "0.0.0.0:8000".to_string())
+                    );
+                    return writeln!(buf, "\r{}", green.value(data));
+                }
+                if data == "SIGINT received; starting forced shutdown" {
+                    return writeln!(buf, "\r{}", green.value("[INFO] SIGINT received; starting forced shutdown"));
+                    // Add '\r' to remove the input ^C
+                }
+                return Ok(());
+            } else if record.target() == "actix_server::worker"
+                || record.target() == "actix_server::accept"
+            {
+                return Ok(());
             }
             if data.starts_with("[ERROR]")
                 || data.starts_with("TLS alert")
@@ -684,12 +570,79 @@ async fn main() -> std::io::Result<()> {
         })
         .init();
 
-    let server = HttpServer::new(move || {
+        let addr = if let Some(matches) = matches.subcommand_matches("doc") {
-        let compress = if var("COMPRESS").unwrap_or_else(|_| "false".to_string()) == "true" {
+            let mut cargo_toml = match std::fs::File::open("./Cargo.toml") {
-            http::header::ContentEncoding::Auto
+                Ok(file) => file,
+                Err(e) => {
+                    error!("[ERROR] {}", e.to_string());
+                    return Ok(());
+                }
+            };
+            let mut contents = String::new();
+            match cargo_toml.read_to_string(&mut contents) {
+                Ok(_) => {}
+                Err(e) => {
+                    error!("[ERROR] {}", e.to_string());
+                    return Ok(());
+                }
+            }
+            let contents: CargoToml = match toml::from_str(&contents) {
+                Ok(t) => t,
+                Err(e) => {
+                    error!("[ERROR] {}", e.to_string());
+                    return Ok(());
+                }
+            };
+            let crate_name = contents.package.name;
+            info!("[INFO] Generating document (may take a while)");
+            match std::process::Command::new("cargo").arg("doc").output() {
+                Ok(output) => {
+                    let output = std::str::from_utf8(&output.stderr).unwrap_or("");
+                    if output.starts_with("error: could not find `Cargo.toml` in") {
+                        error!("[ERROR] Cargo.toml Not Found");
+                        return Ok(());
+                    } else if output.starts_with("error: ") {
+                        error!(
+                            "[ERROR] {}",
+                            output.strip_prefix("error: ").unwrap_or(output)
+                        );
+                        return Ok(());
+                    }
+                }
+                Err(e) => {
+                    error!("[ERROR] Cargo Error: {}", e.to_string());
+                    return Ok(());
+                }
+            }
+            let path = Path::new("./target/doc/");
+            let mut index_path = path.to_path_buf();
+            index_path.push(crate_name.to_string() + "/index.html");
+            if !index_path.exists() || !index_path.is_file() {
+                error!("[ERROR] Cargo Error: doc path not found");
+                return Ok(());
+            }
+            set_var("ROOT", display_path(path));
+            let ip = matches
+                .value_of("address")
+                .unwrap_or("127.0.0.1")
+                .to_string();
+            let addr = format!("{}:{}", ip, matches.value_of("port").unwrap_or("8000"));
+            let url = format!(
+                "http://{}:{}/{}/index.html",
+                if ip == "0.0.0.0" { "127.0.0.1" } else { &ip },
+                matches.value_of("port").unwrap_or("8000"),
+                crate_name,
+            );
+            if !matches.is_present("noopen") {
+                open_in_browser(&url);
+            }
+            addr
         } else {
-            http::header::ContentEncoding::Identity
+            addr
         };
+        set_var("LISTEN_ADDRESS", addr);
+    
+    let server = HttpServer::new(move || {
         let app = App::new()
             .wrap_fn(|req, srv| {
                 let paths = PathBuf::from_str(req.path()).unwrap_or_default();
@@ -705,28 +658,26 @@ async fn main() -> std::io::Result<()> {
                         if var("NOCACHE").unwrap_or_else(|_| "false".to_string()) == "true" {
                             head.headers_mut().insert(
                                 http::header::CACHE_CONTROL,
-                                http::HeaderValue::from_static("no-store"),
+                                http::header::HeaderValue::from_static("no-store"),
                             );
                         }
                         if var("ENABLE_CORS").unwrap_or_else(|_| "false".to_string()) == "true" {
                             let cors = var("CORS").unwrap_or_else(|_| "*".to_string());
-                            let cors = http::HeaderValue::from_str(&cors)
+                            let cors = http::header::HeaderValue::from_str(&cors)
-                                .unwrap_or_else(|_| http::HeaderValue::from_static("*"));
+                                .unwrap_or_else(|_| http::header::HeaderValue::from_static("*"));
                             head.headers_mut()
                                 .insert(http::header::ACCESS_CONTROL_ALLOW_ORIGIN, cors);
                         }
                         if isdotfile
                             && var("DOTFILES").unwrap_or_else(|_| "false".to_string()) != "true"
                         {
-                            head.status = http::StatusCode::FORBIDDEN;
+                            return dev::Response::new(http::StatusCode::FORBIDDEN).into_body();
-                            *head.headers_mut() = http::HeaderMap::new();
-                            return dev::ResponseBody::Other(actix_web::body::Body::None);
                         }
                         body
                     }))
                 }
             })
-            .wrap(middleware::Compress::new(compress))
+            .wrap(middleware::Compress::default())
             .wrap(middleware::Condition::new(
                 var("ENABLE_AUTH").unwrap_or_else(|_| "false".to_string()) == "true",
                 actix_web_httpauth::middleware::HttpAuthentication::basic(validator),
@@ -747,7 +698,7 @@ async fn main() -> std::io::Result<()> {
                         && path.is_file()
                         && var("SPA").unwrap_or_else(|_| "false".to_string()) == "true"
                     {
-                        let res = fs::NamedFile::open(path)?.into_response(&http_req)?;
+                        let res = fs::NamedFile::open(path)?.into_response(&http_req);
                         return Ok(ServiceResponse::new(http_req, res));
                     }
                     Ok(ServiceResponse::new(
@@ -765,13 +716,26 @@ async fn main() -> std::io::Result<()> {
         let key = &mut BufReader::new(
             std::fs::File::open(Path::new(matches.value_of("key").unwrap())).unwrap(),
         );
-        let mut config = rustls::ServerConfig::new(rustls::NoClientAuth::new());
+        let cert = rustls_pemfile::certs(cert)
-        let cert_chain = rustls::internal::pemfile::certs(cert).unwrap();
+            .unwrap()
-        let mut keys = rustls::internal::pemfile::pkcs8_private_keys(key).unwrap();
+            .iter()
-        config.set_single_cert(cert_chain, keys.remove(0)).unwrap();
+            .map(|x| rustls::Certificate(x.to_vec()))
-        server.bind_rustls(addr, config)
+            .collect::<Vec<_>>();
+        let key = rustls::PrivateKey(
+            rustls_pemfile::pkcs8_private_keys(key)
+                .unwrap()
+                .first()
+                .expect("no private key found")
+                .to_owned(),
+        );
+        let config = rustls::ServerConfig::builder()
+            .with_safe_defaults()
+            .with_no_client_auth()
+            .with_single_cert(cert, key)
+            .expect("bad certificate/key");
+        server.bind_rustls(var("LISTEN_ADDRESS").unwrap_or_else(|_| "0.0.0.0:8000".to_string()), config)
     } else {
-        server.bind(addr)
+        server.bind(var("LISTEN_ADDRESS").unwrap_or_else(|_| "0.0.0.0:8000".to_string()))
     };
     server?.run().await
 }