dufs/src/server.rs

use crate::{Args, BoxResult};

use async_walkdir::WalkDir;
use async_zip::read::seek::ZipFileReader;
use async_zip::write::{EntryOptions, ZipFileWriter};
use async_zip::Compression;
use futures::stream::StreamExt;
use futures::TryStreamExt;
use headers::{
    AccessControlAllowHeaders, AccessControlAllowOrigin, ContentType, ETag, HeaderMapExt,
    IfModifiedSince, IfNoneMatch, LastModified,
};
use hyper::header::{HeaderValue, ACCEPT, CONTENT_TYPE, ORIGIN, RANGE, WWW_AUTHENTICATE};
use hyper::service::{make_service_fn, service_fn};
use hyper::{Body, Method, StatusCode};
use percent_encoding::percent_decode;
use serde::Serialize;
use std::convert::Infallible;
use std::path::{Path, PathBuf};
use std::sync::Arc;
use std::time::SystemTime;
use tokio::fs::File;
use tokio::io::AsyncWrite;
use tokio::{fs, io};
use tokio_util::codec::{BytesCodec, FramedRead};
use tokio_util::io::{ReaderStream, StreamReader};

type Request = hyper::Request<Body>;
type Response = hyper::Response<Body>;

macro_rules! status_code {
    ($status:expr) => {
        hyper::Response::builder()
            .status($status)
            .body($status.canonical_reason().unwrap_or_default().into())
            .unwrap()
    };
}

const INDEX_HTML: &str = include_str!("assets/index.html");
const INDEX_CSS: &str = include_str!("assets/index.css");
const INDEX_JS: &str = include_str!("assets/index.js");
const BUF_SIZE: usize = 1024 * 16;

pub async fn serve(args: Args) -> BoxResult<()> {
    let address = args.address()?;
    let inner = Arc::new(InnerService::new(args));
    let make_svc = make_service_fn(move |_| {
        let inner = inner.clone();
        async {
            Ok::<_, Infallible>(service_fn(move |req| {
                let inner = inner.clone();
                inner.call(req)
            }))
        }
    });

    let server = hyper::Server::try_bind(&address)?.serve(make_svc);
    let address = server.local_addr();
    eprintln!("Files served on http://{}", address);
    server.await?;

    Ok(())
}

struct InnerService {
    args: Args,
}

impl InnerService {
    pub fn new(args: Args) -> Self {
        Self { args }
    }

    pub async fn call(self: Arc<Self>, req: Request) -> Result<Response, hyper::Error> {
        let method = req.method().clone();
        let uri = req.uri().clone();
        let cors = self.args.cors;
        let mut res = self
            .handle(req)
            .await
            .unwrap_or_else(|_| status_code!(StatusCode::INTERNAL_SERVER_ERROR));
        info!(r#""{} {}" - {}"#, method, uri, res.status());
        if cors {
            add_cors(&mut res);
        }
        Ok(res)
    }

    pub async fn handle(self: Arc<Self>, req: Request) -> BoxResult<Response> {
        if !self.auth_guard(&req).unwrap_or_default() {
            let mut res = status_code!(StatusCode::UNAUTHORIZED);
            res.headers_mut()
                .insert(WWW_AUTHENTICATE, HeaderValue::from_static("Basic"));
            return Ok(res);
        }
        match *req.method() {
            Method::GET => self.handle_static(req).await,
            Method::PUT => {
                if self.args.readonly {
                    return Ok(status_code!(StatusCode::FORBIDDEN));
                }
                self.handle_upload(req).await
            }
            Method::OPTIONS => Ok(status_code!(StatusCode::NO_CONTENT)),
            Method::DELETE => self.handle_delete(req).await,
            _ => Ok(status_code!(StatusCode::NOT_FOUND)),
        }
    }

    async fn handle_static(&self, req: Request) -> BoxResult<Response> {
        let req_path = req.uri().path();
        let path = match self.get_file_path(req_path)? {
            Some(path) => path,
            None => return Ok(status_code!(StatusCode::FORBIDDEN)),
        };
        match fs::metadata(&path).await {
            Ok(meta) => {
                if meta.is_dir() {
                    let req_query = req.uri().query().unwrap_or_default();
                    if req_query == "zip" {
                        return self.handle_send_dir_zip(path.as_path()).await;
                    }
                    if let Some(q) = req_query.strip_prefix("q=") {
                        return self.handle_query_dir(path.as_path(), q).await;
                    }
                    self.handle_ls_dir(path.as_path(), true).await
                } else {
                    self.handle_send_file(&req, path.as_path()).await
                }
            }
            Err(_) => {
                if req_path.ends_with('/') {
                    self.handle_ls_dir(path.as_path(), false).await
                } else {
                    Ok(status_code!(StatusCode::NOT_FOUND))
                }
            }
        }
    }

    async fn handle_upload(&self, mut req: Request) -> BoxResult<Response> {
        let forbidden = status_code!(StatusCode::FORBIDDEN);
        let path = match self.get_file_path(req.uri().path())? {
            Some(path) => path,
            None => return Ok(forbidden),
        };

        match path.parent() {
            Some(parent) => match fs::metadata(parent).await {
                Ok(meta) => {
                    if !meta.is_dir() {
                        return Ok(forbidden);
                    }
                }
                Err(_) => fs::create_dir_all(parent).await?,
            },
            None => return Ok(forbidden),
        }

        let mut file = fs::File::create(&path).await?;

        let body_with_io_error = req
            .body_mut()
            .map_err(|err| io::Error::new(io::ErrorKind::Other, err));

        let body_reader = StreamReader::new(body_with_io_error);

        futures::pin_mut!(body_reader);

        io::copy(&mut body_reader, &mut file).await?;

        let req_query = req.uri().query().unwrap_or_default();
        if req_query == "unzip" {
            let root = path.parent().unwrap();
            let mut zip = ZipFileReader::new(File::open(&path).await?).await?;
            for i in 0..zip.entries().len() {
                let entry = &zip.entries()[i];
                let entry_name = entry.name();
                let entry_path = root.join(entry_name);
                if entry_name.ends_with('/') {
                    fs::create_dir_all(entry_path).await?;
                } else {
                    if let Some(parent) = entry_path.parent() {
                        if fs::symlink_metadata(parent).await.is_err() {
                            fs::create_dir_all(&parent).await?;
                        }
                    }
                    let mut outfile = fs::File::create(&entry_path).await?;
                    let mut reader = zip.entry_reader(i).await?;
                    io::copy(&mut reader, &mut outfile).await?;
                }
            }
            fs::remove_file(&path).await?;
        }

        return Ok(status_code!(StatusCode::OK));
    }

    async fn handle_delete(&self, req: Request) -> BoxResult<Response> {
        let path = match self.get_file_path(req.uri().path())? {
            Some(path) => path,
            None => return Ok(status_code!(StatusCode::FORBIDDEN)),
        };

        let meta = fs::metadata(&path).await?;
        if meta.is_file() {
            fs::remove_file(path).await?;
        } else {
            fs::remove_dir_all(path).await?;
        }
        Ok(status_code!(StatusCode::OK))
    }

    async fn handle_ls_dir(&self, path: &Path, exist: bool) -> BoxResult<Response> {
        let mut paths: Vec<PathItem> = vec![];
        if exist {
            let mut rd = fs::read_dir(path).await?;
            while let Some(entry) = rd.next_entry().await? {
                let entry_path = entry.path();
                if let Ok(item) = get_path_item(entry_path, path.to_path_buf()).await {
                    paths.push(item);
                }
            }
        }
        self.send_index(path, paths)
    }

    async fn handle_query_dir(&self, path: &Path, q: &str) -> BoxResult<Response> {
        let mut paths: Vec<PathItem> = vec![];
        let mut walkdir = WalkDir::new(path);
        while let Some(entry) = walkdir.next().await {
            if let Ok(entry) = entry {
                if !entry
                    .file_name()
                    .to_string_lossy()
                    .to_lowercase()
                    .contains(&q.to_lowercase())
                {
                    continue;
                }
                if fs::symlink_metadata(entry.path()).await.is_err() {
                    continue;
                }
                if let Ok(item) = get_path_item(entry.path(), path.to_path_buf()).await {
                    paths.push(item);
                }
            }
        }
        self.send_index(path, paths)
    }

    async fn handle_send_dir_zip(&self, path: &Path) -> BoxResult<Response> {
        let (mut writer, reader) = tokio::io::duplex(BUF_SIZE);
        let path = path.to_owned();
        tokio::spawn(async move {
            if let Err(e) = dir_zip(&mut writer, &path).await {
                error!("Fail to zip {}, {}", path.display(), e.to_string());
            }
        });
        let stream = ReaderStream::new(reader);
        let body = Body::wrap_stream(stream);
        Ok(Response::new(body))
    }

    async fn handle_send_file(&self, req: &Request, path: &Path) -> BoxResult<Response> {
        let (file, meta) = tokio::join!(fs::File::open(path), fs::metadata(path),);
        let (file, meta) = (file?, meta?);
        let mut res = Response::default();
        if let Ok(mtime) = meta.modified() {
            let timestamp = get_timestamp(&mtime);
            let size = meta.len();
            let etag = format!(r#""{}-{}""#, timestamp, size)
                .parse::<ETag>()
                .unwrap();
            let last_modified = LastModified::from(mtime);
            let fresh = {
                // `If-None-Match` takes presedence over `If-Modified-Since`.
                if let Some(if_none_match) = req.headers().typed_get::<IfNoneMatch>() {
                    !if_none_match.precondition_passes(&etag)
                } else if let Some(if_modified_since) = req.headers().typed_get::<IfModifiedSince>()
                {
                    !if_modified_since.is_modified(mtime)
                } else {
                    false
                }
            };
            res.headers_mut().typed_insert(last_modified);
            res.headers_mut().typed_insert(etag);
            if fresh {
                *res.status_mut() = StatusCode::NOT_MODIFIED;
                return Ok(res);
            }
        }
        if let Some(mime) = mime_guess::from_path(&path).first() {
            res.headers_mut().typed_insert(ContentType::from(mime));
        }
        let stream = FramedRead::new(file, BytesCodec::new());
        let body = Body::wrap_stream(stream);
        *res.body_mut() = body;
        Ok(res)
    }

    fn send_index(&self, path: &Path, mut paths: Vec<PathItem>) -> BoxResult<Response> {
        paths.sort_unstable();
        let rel_path = match self.args.path.parent() {
            Some(p) => path.strip_prefix(p).unwrap(),
            None => path,
        };
        let data = IndexData {
            breadcrumb: normalize_path(rel_path),
            paths,
            readonly: self.args.readonly,
        };
        let data = serde_json::to_string(&data).unwrap();
        let output = INDEX_HTML.replace(
            "__SLOB__",
            &format!(
                r#"
<title>Files in {} - Duf/</title>
<style>{}</style>
<script>var DATA = {}; {}</script>
"#,
                rel_path.display(),
                INDEX_CSS,
                data,
                INDEX_JS
            ),
        );

        Ok(Response::new(output.into()))
    }

    fn auth_guard(&self, req: &Request) -> BoxResult<bool> {
        if let Some(auth) = &self.args.auth {
            if let Some(value) = req.headers().get("Authorization") {
                let value = value.to_str()?;
                let value = if value.contains("Basic ") {
                    &value[6..]
                } else {
                    return Ok(false);
                };
                let value = base64::decode(value)?;
                let value = std::str::from_utf8(&value)?;
                return Ok(value == auth);
            } else {
                if self.args.no_auth_read && req.method() == Method::GET {
                    return Ok(true);
                }
                return Ok(false);
            }
        }
        Ok(true)
    }

    fn get_file_path(&self, path: &str) -> BoxResult<Option<PathBuf>> {
        let decoded_path = percent_decode(path[1..].as_bytes()).decode_utf8()?;
        let slashes_switched = if cfg!(windows) {
            decoded_path.replace('/', "\\")
        } else {
            decoded_path.into_owned()
        };
        let path = self.args.path.join(&slashes_switched);
        if path.starts_with(&self.args.path) {
            Ok(Some(path))
        } else {
            Ok(None)
        }
    }
}

#[derive(Debug, Serialize, Eq, PartialEq, Ord, PartialOrd)]
struct IndexData {
    breadcrumb: String,
    paths: Vec<PathItem>,
    readonly: bool,
}

#[derive(Debug, Serialize, Eq, PartialEq, Ord, PartialOrd)]
struct PathItem {
    path_type: PathType,
    name: String,
    mtime: u64,
    size: Option<u64>,
}

#[derive(Debug, Serialize, Eq, PartialEq, Ord, PartialOrd)]
enum PathType {
    Dir,
    SymlinkDir,
    File,
    SymlinkFile,
}

async fn get_path_item<P: AsRef<Path>>(path: P, base_path: P) -> BoxResult<PathItem> {
    let path = path.as_ref();
    let rel_path = path.strip_prefix(base_path).unwrap();
    let (meta, meta2) = tokio::join!(fs::metadata(&path), fs::symlink_metadata(&path));
    let (meta, meta2) = (meta?, meta2?);
    let is_dir = meta.is_dir();
    let is_symlink = meta2.file_type().is_symlink();
    let path_type = match (is_symlink, is_dir) {
        (true, true) => PathType::SymlinkDir,
        (false, true) => PathType::Dir,
        (true, false) => PathType::SymlinkFile,
        (false, false) => PathType::File,
    };
    let mtime = get_timestamp(&meta.modified()?);
    let size = match path_type {
        PathType::Dir | PathType::SymlinkDir => None,
        PathType::File | PathType::SymlinkFile => Some(meta.len()),
    };
    let name = normalize_path(rel_path);
    Ok(PathItem {
        path_type,
        name,
        mtime,
        size,
    })
}

fn get_timestamp(time: &SystemTime) -> u64 {
    time.duration_since(SystemTime::UNIX_EPOCH)
        .unwrap()
        .as_millis() as u64
}

fn normalize_path<P: AsRef<Path>>(path: P) -> String {
    let path = path.as_ref().to_str().unwrap_or_default();
    if cfg!(windows) {
        path.replace('\\', "/")
    } else {
        path.to_string()
    }
}

fn add_cors(res: &mut Response) {
    res.headers_mut()
        .typed_insert(AccessControlAllowOrigin::ANY);
    res.headers_mut().typed_insert(
        vec![RANGE, CONTENT_TYPE, ACCEPT, ORIGIN, WWW_AUTHENTICATE]
            .into_iter()
            .collect::<AccessControlAllowHeaders>(),
    );
}

async fn dir_zip<W: AsyncWrite + Unpin>(writer: &mut W, dir: &Path) -> BoxResult<()> {
    let mut writer = ZipFileWriter::new(writer);
    let mut walkdir = WalkDir::new(dir);
    while let Some(entry) = walkdir.next().await {
        if let Ok(entry) = entry {
            let meta = match fs::symlink_metadata(entry.path()).await {
                Ok(meta) => meta,
                Err(_) => continue,
            };
            if meta.is_file() {
                let filepath = entry.path();
                let filename = match filepath.strip_prefix(dir).ok().and_then(|v| v.to_str()) {
                    Some(v) => v,
                    None => continue,
                };
                let entry_options = EntryOptions::new(filename.to_owned(), Compression::Deflate);
                let mut file = File::open(&filepath).await?;
                let mut file_writer = writer.write_entry_stream(entry_options).await?;
                io::copy(&mut file, &mut file_writer).await?;
                file_writer.close().await?;
            }
        }
    }
    writer.close().await?;
    Ok(())
}
init commit 2022-05-26 11:17:55 +03:00			`use crate::{Args, BoxResult};`

feat: download folder as zip file 2022-05-28 13:58:43 +03:00			`use async_walkdir::WalkDir;`
feat: unzip zip file when unload 2022-05-30 09:22:35 +03:00			`use async_zip::read::seek::ZipFileReader;`
feat: download folder as zip file 2022-05-28 13:58:43 +03:00			`use async_zip::write::{EntryOptions, ZipFileWriter};`
			`use async_zip::Compression;`
			`use futures::stream::StreamExt;`
init commit 2022-05-26 11:17:55 +03:00			`use futures::TryStreamExt;`
feat: add mime and cache headers to response 2022-05-30 06:22:28 +03:00			`use headers::{`
			`AccessControlAllowHeaders, AccessControlAllowOrigin, ContentType, ETag, HeaderMapExt,`
			`IfModifiedSince, IfNoneMatch, LastModified,`
			`};`
feat: add cors 2022-05-29 12:33:21 +03:00			`use hyper::header::{HeaderValue, ACCEPT, CONTENT_TYPE, ORIGIN, RANGE, WWW_AUTHENTICATE};`
init commit 2022-05-26 11:17:55 +03:00			`use hyper::service::{make_service_fn, service_fn};`
			`use hyper::{Body, Method, StatusCode};`
			`use percent_encoding::percent_decode;`
			`use serde::Serialize;`
			`use std::convert::Infallible;`
			`use std::path::{Path, PathBuf};`
			`use std::sync::Arc;`
			`use std::time::SystemTime;`
feat: download folder as zip file 2022-05-28 13:58:43 +03:00			`use tokio::fs::File;`
refactor: handler zip 2022-05-29 01:57:16 +03:00			`use tokio::io::AsyncWrite;`
init commit 2022-05-26 11:17:55 +03:00			`use tokio::{fs, io};`
			`use tokio_util::codec::{BytesCodec, FramedRead};`
refactor: handler zip 2022-05-29 01:57:16 +03:00			`use tokio_util::io::{ReaderStream, StreamReader};`
init commit 2022-05-26 11:17:55 +03:00
			`type Request = hyper::Request<Body>;`
			`type Response = hyper::Response<Body>;`

			`macro_rules! status_code {`
			`($status:expr) => {`
			`hyper::Response::builder()`
			`.status($status)`
			`.body($status.canonical_reason().unwrap_or_default().into())`
			`.unwrap()`
			`};`
			`}`

chore: rename src/static to src/assets 2022-05-30 09:32:41 +03:00			`const INDEX_HTML: &str = include_str!("assets/index.html");`
			`const INDEX_CSS: &str = include_str!("assets/index.css");`
			`const INDEX_JS: &str = include_str!("assets/index.js");`
fix: optimize download zip 2022-05-28 17:27:28 +03:00			`const BUF_SIZE: usize = 1024 * 16;`
init commit 2022-05-26 11:17:55 +03:00
			`pub async fn serve(args: Args) -> BoxResult<()> {`
			`let address = args.address()?;`
			`let inner = Arc::new(InnerService::new(args));`
			`let make_svc = make_service_fn(move \|_\| {`
			`let inner = inner.clone();`
			`async {`
			`Ok::<_, Infallible>(service_fn(move \|req\| {`
			`let inner = inner.clone();`
feat: add logger 2022-05-27 04:01:16 +03:00			`inner.call(req)`
init commit 2022-05-26 11:17:55 +03:00			`}))`
			`}`
			`});`

			`let server = hyper::Server::try_bind(&address)?.serve(make_svc);`
			`let address = server.local_addr();`
			`eprintln!("Files served on http://{}", address);`
			`server.await?;`

			`Ok(())`
			`}`

			`struct InnerService {`
			`args: Args,`
			`}`

			`impl InnerService {`
			`pub fn new(args: Args) -> Self {`
			`Self { args }`
			`}`

feat: add logger 2022-05-27 04:01:16 +03:00			`pub async fn call(self: Arc<Self>, req: Request) -> Result<Response, hyper::Error> {`
			`let method = req.method().clone();`
			`let uri = req.uri().clone();`
feat: add cors 2022-05-29 12:33:21 +03:00			`let cors = self.args.cors;`
			`let mut res = self`
feat: add logger 2022-05-27 04:01:16 +03:00			`.handle(req)`
			`.await`
			`.unwrap_or_else(\|_\| status_code!(StatusCode::INTERNAL_SERVER_ERROR));`
			`info!(r#""{} {}" - {}"#, method, uri, res.status());`
feat: add cors 2022-05-29 12:33:21 +03:00			`if cors {`
			`add_cors(&mut res);`
			`}`
feat: add logger 2022-05-27 04:01:16 +03:00			`Ok(res)`
			`}`

			`pub async fn handle(self: Arc<Self>, req: Request) -> BoxResult<Response> {`
feat: support delete operation 2022-05-26 14:52:54 +03:00			`if !self.auth_guard(&req).unwrap_or_default() {`
			`let mut res = status_code!(StatusCode::UNAUTHORIZED);`
style: cargo fmt 2022-05-26 15:14:18 +03:00			`res.headers_mut()`
feat: add cors 2022-05-29 12:33:21 +03:00			`.insert(WWW_AUTHENTICATE, HeaderValue::from_static("Basic"));`
style: cargo fmt 2022-05-26 15:14:18 +03:00			`return Ok(res);`
feat: support delete operation 2022-05-26 14:52:54 +03:00			`}`
feat: add cors 2022-05-29 12:33:21 +03:00			`match *req.method() {`
			`Method::GET => self.handle_static(req).await,`
			`Method::PUT => {`
			`if self.args.readonly {`
			`return Ok(status_code!(StatusCode::FORBIDDEN));`
			`}`
			`self.handle_upload(req).await`
feat: add basic auth and readonly mode 2022-05-26 13:06:52 +03:00			`}`
feat: add cors 2022-05-29 12:33:21 +03:00			`Method::OPTIONS => Ok(status_code!(StatusCode::NO_CONTENT)),`
			`Method::DELETE => self.handle_delete(req).await,`
			`_ => Ok(status_code!(StatusCode::NOT_FOUND)),`
feat: add logger 2022-05-27 04:01:16 +03:00			`}`
init commit 2022-05-26 11:17:55 +03:00			`}`

			`async fn handle_static(&self, req: Request) -> BoxResult<Response> {`
feat: Automatically create dir while uploading 2022-05-29 05:53:19 +03:00			`let req_path = req.uri().path();`
			`let path = match self.get_file_path(req_path)? {`
init commit 2022-05-26 11:17:55 +03:00			`Some(path) => path,`
			`None => return Ok(status_code!(StatusCode::FORBIDDEN)),`
			`};`
			`match fs::metadata(&path).await {`
			`Ok(meta) => {`
			`if meta.is_dir() {`
feat: support searching 2022-05-29 07:43:40 +03:00			`let req_query = req.uri().query().unwrap_or_default();`
			`if req_query == "zip" {`
			`return self.handle_send_dir_zip(path.as_path()).await;`
feat: download folder as zip file 2022-05-28 13:58:43 +03:00			`}`
feat: support searching 2022-05-29 07:43:40 +03:00			`if let Some(q) = req_query.strip_prefix("q=") {`
			`return self.handle_query_dir(path.as_path(), q).await;`
			`}`
			`self.handle_ls_dir(path.as_path(), true).await`
init commit 2022-05-26 11:17:55 +03:00			`} else {`
feat: add mime and cache headers to response 2022-05-30 06:22:28 +03:00			`self.handle_send_file(&req, path.as_path()).await`
init commit 2022-05-26 11:17:55 +03:00			`}`
			`}`
feat: Automatically create dir while uploading 2022-05-29 05:53:19 +03:00			`Err(_) => {`
			`if req_path.ends_with('/') {`
feat: support searching 2022-05-29 07:43:40 +03:00			`self.handle_ls_dir(path.as_path(), false).await`
feat: Automatically create dir while uploading 2022-05-29 05:53:19 +03:00			`} else {`
			`Ok(status_code!(StatusCode::NOT_FOUND))`
			`}`
			`}`
init commit 2022-05-26 11:17:55 +03:00			`}`
			`}`

			`async fn handle_upload(&self, mut req: Request) -> BoxResult<Response> {`
feat: Automatically create dir while uploading 2022-05-29 05:53:19 +03:00			`let forbidden = status_code!(StatusCode::FORBIDDEN);`
init commit 2022-05-26 11:17:55 +03:00			`let path = match self.get_file_path(req.uri().path())? {`
			`Some(path) => path,`
feat: Automatically create dir while uploading 2022-05-29 05:53:19 +03:00			`None => return Ok(forbidden),`
init commit 2022-05-26 11:17:55 +03:00			`};`

feat: Automatically create dir while uploading 2022-05-29 05:53:19 +03:00			`match path.parent() {`
			`Some(parent) => match fs::metadata(parent).await {`
			`Ok(meta) => {`
			`if !meta.is_dir() {`
			`return Ok(forbidden);`
			`}`
			`}`
			`Err(_) => fs::create_dir_all(parent).await?,`
			`},`
			`None => return Ok(forbidden),`
init commit 2022-05-26 11:17:55 +03:00			`}`

feat: unzip zip file when unload 2022-05-30 09:22:35 +03:00			`let mut file = fs::File::create(&path).await?;`
init commit 2022-05-26 11:17:55 +03:00
			`let body_with_io_error = req`
			`.body_mut()`
			`.map_err(\|err\| io::Error::new(io::ErrorKind::Other, err));`

			`let body_reader = StreamReader::new(body_with_io_error);`

			`futures::pin_mut!(body_reader);`

			`io::copy(&mut body_reader, &mut file).await?;`

feat: unzip zip file when unload 2022-05-30 09:22:35 +03:00			`let req_query = req.uri().query().unwrap_or_default();`
			`if req_query == "unzip" {`
			`let root = path.parent().unwrap();`
			`let mut zip = ZipFileReader::new(File::open(&path).await?).await?;`
			`for i in 0..zip.entries().len() {`
			`let entry = &zip.entries()[i];`
			`let entry_name = entry.name();`
			`let entry_path = root.join(entry_name);`
			`if entry_name.ends_with('/') {`
			`fs::create_dir_all(entry_path).await?;`
			`} else {`
			`if let Some(parent) = entry_path.parent() {`
			`if fs::symlink_metadata(parent).await.is_err() {`
			`fs::create_dir_all(&parent).await?;`
			`}`
			`}`
			`let mut outfile = fs::File::create(&entry_path).await?;`
			`let mut reader = zip.entry_reader(i).await?;`
			`io::copy(&mut reader, &mut outfile).await?;`
			`}`
			`}`
			`fs::remove_file(&path).await?;`
			`}`

init commit 2022-05-26 11:17:55 +03:00			`return Ok(status_code!(StatusCode::OK));`
			`}`

feat: support delete operation 2022-05-26 14:52:54 +03:00			`async fn handle_delete(&self, req: Request) -> BoxResult<Response> {`
			`let path = match self.get_file_path(req.uri().path())? {`
			`Some(path) => path,`
			`None => return Ok(status_code!(StatusCode::FORBIDDEN)),`
			`};`

			`let meta = fs::metadata(&path).await?;`
			`if meta.is_file() {`
			`fs::remove_file(path).await?;`
			`} else {`
			`fs::remove_dir_all(path).await?;`
			`}`
			`Ok(status_code!(StatusCode::OK))`
			`}`

feat: support searching 2022-05-29 07:43:40 +03:00			`async fn handle_ls_dir(&self, path: &Path, exist: bool) -> BoxResult<Response> {`
init commit 2022-05-26 11:17:55 +03:00			`let mut paths: Vec<PathItem> = vec![];`
feat: Automatically create dir while uploading 2022-05-29 05:53:19 +03:00			`if exist {`
			`let mut rd = fs::read_dir(path).await?;`
			`while let Some(entry) = rd.next_entry().await? {`
			`let entry_path = entry.path();`
feat: support searching 2022-05-29 07:43:40 +03:00			`if let Ok(item) = get_path_item(entry_path, path.to_path_buf()).await {`
feat: Automatically create dir while uploading 2022-05-29 05:53:19 +03:00			`paths.push(item);`
			`}`
fix: caught server error when symlink broken 2022-05-26 15:42:33 +03:00			`}`
init commit 2022-05-26 11:17:55 +03:00			`}`
feat: support searching 2022-05-29 07:43:40 +03:00			`self.send_index(path, paths)`
			`}`
init commit 2022-05-26 11:17:55 +03:00
feat: support searching 2022-05-29 07:43:40 +03:00			`async fn handle_query_dir(&self, path: &Path, q: &str) -> BoxResult<Response> {`
			`let mut paths: Vec<PathItem> = vec![];`
			`let mut walkdir = WalkDir::new(path);`
			`while let Some(entry) = walkdir.next().await {`
			`if let Ok(entry) = entry {`
			`if !entry`
			`.file_name()`
			`.to_string_lossy()`
			`.to_lowercase()`
			`.contains(&q.to_lowercase())`
			`{`
			`continue;`
			`}`
			`if fs::symlink_metadata(entry.path()).await.is_err() {`
			`continue;`
			`}`
			`if let Ok(item) = get_path_item(entry.path(), path.to_path_buf()).await {`
			`paths.push(item);`
			`}`
			`}`
			`}`
			`self.send_index(path, paths)`
init commit 2022-05-26 11:17:55 +03:00			`}`

feat: download folder as zip file 2022-05-28 13:58:43 +03:00			`async fn handle_send_dir_zip(&self, path: &Path) -> BoxResult<Response> {`
refactor: handler zip 2022-05-29 01:57:16 +03:00			`let (mut writer, reader) = tokio::io::duplex(BUF_SIZE);`
fix: optimize download zip 2022-05-28 17:27:28 +03:00			`let path = path.to_owned();`
			`tokio::spawn(async move {`
			`if let Err(e) = dir_zip(&mut writer, &path).await {`
			`error!("Fail to zip {}, {}", path.display(), e.to_string());`
			`}`
			`});`
refactor: handler zip 2022-05-29 01:57:16 +03:00			`let stream = ReaderStream::new(reader);`
			`let body = Body::wrap_stream(stream);`
feat: download folder as zip file 2022-05-28 13:58:43 +03:00			`Ok(Response::new(body))`
			`}`

feat: add mime and cache headers to response 2022-05-30 06:22:28 +03:00			`async fn handle_send_file(&self, req: &Request, path: &Path) -> BoxResult<Response> {`
			`let (file, meta) = tokio::join!(fs::File::open(path), fs::metadata(path),);`
			`let (file, meta) = (file?, meta?);`
			`let mut res = Response::default();`
			`if let Ok(mtime) = meta.modified() {`
chore: upgrade version 2022-05-30 11:06:10 +03:00			`let timestamp = get_timestamp(&mtime);`
feat: add mime and cache headers to response 2022-05-30 06:22:28 +03:00			`let size = meta.len();`
chore: upgrade version 2022-05-30 11:06:10 +03:00			`let etag = format!(r#""{}-{}""#, timestamp, size)`
feat: add mime and cache headers to response 2022-05-30 06:22:28 +03:00			`.parse::<ETag>()`
			`.unwrap();`
			`let last_modified = LastModified::from(mtime);`
			`let fresh = {`
			// `If-None-Match` takes presedence over `If-Modified-Since`.
			`if let Some(if_none_match) = req.headers().typed_get::<IfNoneMatch>() {`
			`!if_none_match.precondition_passes(&etag)`
			`} else if let Some(if_modified_since) = req.headers().typed_get::<IfModifiedSince>()`
			`{`
			`!if_modified_since.is_modified(mtime)`
			`} else {`
			`false`
			`}`
			`};`
			`res.headers_mut().typed_insert(last_modified);`
			`res.headers_mut().typed_insert(etag);`
			`if fresh {`
			`*res.status_mut() = StatusCode::NOT_MODIFIED;`
			`return Ok(res);`
			`}`
			`}`
			`if let Some(mime) = mime_guess::from_path(&path).first() {`
			`res.headers_mut().typed_insert(ContentType::from(mime));`
			`}`
init commit 2022-05-26 11:17:55 +03:00			`let stream = FramedRead::new(file, BytesCodec::new());`
			`let body = Body::wrap_stream(stream);`
feat: add mime and cache headers to response 2022-05-30 06:22:28 +03:00			`*res.body_mut() = body;`
			`Ok(res)`
init commit 2022-05-26 11:17:55 +03:00			`}`

feat: support searching 2022-05-29 07:43:40 +03:00			`fn send_index(&self, path: &Path, mut paths: Vec<PathItem>) -> BoxResult<Response> {`
			`paths.sort_unstable();`
chore: reorganize web static files 2022-05-30 06:47:57 +03:00			`let rel_path = match self.args.path.parent() {`
			`Some(p) => path.strip_prefix(p).unwrap(),`
			`None => path,`
			`};`
feat: support searching 2022-05-29 07:43:40 +03:00			`let data = IndexData {`
chore: reorganize web static files 2022-05-30 06:47:57 +03:00			`breadcrumb: normalize_path(rel_path),`
feat: support searching 2022-05-29 07:43:40 +03:00			`paths,`
			`readonly: self.args.readonly,`
			`};`
			`let data = serde_json::to_string(&data).unwrap();`
chore: reorganize web static files 2022-05-30 06:47:57 +03:00			`let output = INDEX_HTML.replace(`
			`"__SLOB__",`
			`&format!(`
			`r#"`
			`<title>Files in {} - Duf/</title>`
			`<style>{}</style>`
			`<script>var DATA = {}; {}</script>`
			`"#,`
			`rel_path.display(),`
			`INDEX_CSS,`
			`data,`
			`INDEX_JS`
			`),`
			`);`
feat: support searching 2022-05-29 07:43:40 +03:00
feat: add mime and cache headers to response 2022-05-30 06:22:28 +03:00			`Ok(Response::new(output.into()))`
feat: support searching 2022-05-29 07:43:40 +03:00			`}`

feat: add basic auth and readonly mode 2022-05-26 13:06:52 +03:00			`fn auth_guard(&self, req: &Request) -> BoxResult<bool> {`
			`if let Some(auth) = &self.args.auth {`
			`if let Some(value) = req.headers().get("Authorization") {`
			`let value = value.to_str()?;`
			`let value = if value.contains("Basic ") {`
			`&value[6..]`
			`} else {`
			`return Ok(false);`
			`};`
			`let value = base64::decode(value)?;`
			`let value = std::str::from_utf8(&value)?;`
			`return Ok(value == auth);`
			`} else {`
feat: add no-auth-read options 2022-05-30 07:40:57 +03:00			`if self.args.no_auth_read && req.method() == Method::GET {`
			`return Ok(true);`
			`}`
feat: add basic auth and readonly mode 2022-05-26 13:06:52 +03:00			`return Ok(false);`
			`}`
			`}`
			`Ok(true)`
			`}`

init commit 2022-05-26 11:17:55 +03:00			`fn get_file_path(&self, path: &str) -> BoxResult<Option<PathBuf>> {`
			`let decoded_path = percent_decode(path[1..].as_bytes()).decode_utf8()?;`
			`let slashes_switched = if cfg!(windows) {`
			`decoded_path.replace('/', "\\")`
			`} else {`
			`decoded_path.into_owned()`
			`};`
			`let path = self.args.path.join(&slashes_switched);`
			`if path.starts_with(&self.args.path) {`
			`Ok(Some(path))`
			`} else {`
			`Ok(None)`
			`}`
			`}`
			`}`

			`#[derive(Debug, Serialize, Eq, PartialEq, Ord, PartialOrd)]`
feat: support searching 2022-05-29 07:43:40 +03:00			`struct IndexData {`
init commit 2022-05-26 11:17:55 +03:00			`breadcrumb: String,`
			`paths: Vec<PathItem>,`
feat: add basic auth and readonly mode 2022-05-26 13:06:52 +03:00			`readonly: bool,`
init commit 2022-05-26 11:17:55 +03:00			`}`

			`#[derive(Debug, Serialize, Eq, PartialEq, Ord, PartialOrd)]`
			`struct PathItem {`
			`path_type: PathType,`
			`name: String,`
feat: add mime and cache headers to response 2022-05-30 06:22:28 +03:00			`mtime: u64,`
init commit 2022-05-26 11:17:55 +03:00			`size: Option<u64>,`
			`}`

			`#[derive(Debug, Serialize, Eq, PartialEq, Ord, PartialOrd)]`
			`enum PathType {`
			`Dir,`
			`SymlinkDir,`
			`File,`
			`SymlinkFile,`
			`}`

feat: support searching 2022-05-29 07:43:40 +03:00			`async fn get_path_item<P: AsRef<Path>>(path: P, base_path: P) -> BoxResult<PathItem> {`
			`let path = path.as_ref();`
			`let rel_path = path.strip_prefix(base_path).unwrap();`
chore: upgrade version 2022-05-30 11:06:10 +03:00			`let (meta, meta2) = tokio::join!(fs::metadata(&path), fs::symlink_metadata(&path));`
			`let (meta, meta2) = (meta?, meta2?);`
feat: support searching 2022-05-29 07:43:40 +03:00			`let is_dir = meta.is_dir();`
chore: upgrade version 2022-05-30 11:06:10 +03:00			`let is_symlink = meta2.file_type().is_symlink();`
feat: support searching 2022-05-29 07:43:40 +03:00			`let path_type = match (is_symlink, is_dir) {`
			`(true, true) => PathType::SymlinkDir,`
			`(false, true) => PathType::Dir,`
			`(true, false) => PathType::SymlinkFile,`
			`(false, false) => PathType::File,`
			`};`
feat: add mime and cache headers to response 2022-05-30 06:22:28 +03:00			`let mtime = get_timestamp(&meta.modified()?);`
feat: support searching 2022-05-29 07:43:40 +03:00			`let size = match path_type {`
			`PathType::Dir \| PathType::SymlinkDir => None,`
			`PathType::File \| PathType::SymlinkFile => Some(meta.len()),`
			`};`
			`let name = normalize_path(rel_path);`
			`Ok(PathItem {`
			`path_type,`
			`name,`
			`mtime,`
			`size,`
			`})`
			`}`

feat: add mime and cache headers to response 2022-05-30 06:22:28 +03:00			`fn get_timestamp(time: &SystemTime) -> u64 {`
			`time.duration_since(SystemTime::UNIX_EPOCH)`
			`.unwrap()`
			`.as_millis() as u64`
			`}`

init commit 2022-05-26 11:17:55 +03:00			`fn normalize_path<P: AsRef<Path>>(path: P) -> String {`
			`let path = path.as_ref().to_str().unwrap_or_default();`
			`if cfg!(windows) {`
			`path.replace('\\', "/")`
			`} else {`
			`path.to_string()`
			`}`
			`}`
feat: download folder as zip file 2022-05-28 13:58:43 +03:00
feat: add cors 2022-05-29 12:33:21 +03:00			`fn add_cors(res: &mut Response) {`
			`res.headers_mut()`
			`.typed_insert(AccessControlAllowOrigin::ANY);`
			`res.headers_mut().typed_insert(`
			`vec![RANGE, CONTENT_TYPE, ACCEPT, ORIGIN, WWW_AUTHENTICATE]`
			`.into_iter()`
			`.collect::<AccessControlAllowHeaders>(),`
			`);`
			`}`

feat: download folder as zip file 2022-05-28 13:58:43 +03:00			`async fn dir_zip<W: AsyncWrite + Unpin>(writer: &mut W, dir: &Path) -> BoxResult<()> {`
			`let mut writer = ZipFileWriter::new(writer);`
			`let mut walkdir = WalkDir::new(dir);`
			`while let Some(entry) = walkdir.next().await {`
			`if let Ok(entry) = entry {`
feat: support searching 2022-05-29 07:43:40 +03:00			`let meta = match fs::symlink_metadata(entry.path()).await {`
			`Ok(meta) => meta,`
			`Err(_) => continue,`
			`};`
feat: download folder as zip file 2022-05-28 13:58:43 +03:00			`if meta.is_file() {`
			`let filepath = entry.path();`
			`let filename = match filepath.strip_prefix(dir).ok().and_then(\|v\| v.to_str()) {`
			`Some(v) => v,`
			`None => continue,`
			`};`
			`let entry_options = EntryOptions::new(filename.to_owned(), Compression::Deflate);`
			`let mut file = File::open(&filepath).await?;`
			`let mut file_writer = writer.write_entry_stream(entry_options).await?;`
			`io::copy(&mut file, &mut file_writer).await?;`
			`file_writer.close().await?;`
			`}`
			`}`
			`}`
			`writer.close().await?;`
			`Ok(())`
			`}`