app option to control if upload is enabled

Author: Maneren

README.md

@@ -28,30 +28,33 @@ Usage: file-share [OPTIONS] [TARGET_DIR]
 Arguments:
   [TARGET_DIR]
           Path to the directory to share
-          
+
           [default: .]
 
 Options:
   -p, --port <PORT>
           Port to listen on
-          
+
           [default: 3000]
 
   -q, --qr
           Show QR codes that link to the site
 
   -i, --interfaces <INTERFACES>...
           IP address(es) of interfaces on which file-share will be available
-          
+
           Accepts comma separated list of both IPv4 and IPv6 addresses
-          
+
           [default: 0.0.0.0,::]
 
   -P, --picker
           Open a GUI file picker to choose the target directory
-          
+
           Overrides `TARGET_DIR`
 
+  -u, --upload
+          Allow client to upload files
+
   -h, --help
           Print help (see a summary with '-h')
 

app/src/components/loading.rs

@@ -0,0 +1,7 @@
+use leptos::prelude::*;
+
+pub fn Loading() -> impl IntoView {
+    view! {
+        <p>"Loading..."</p>
+    }
+}

app/src/components/mod.rs

@@ -1,11 +1,13 @@
 mod breadcrumbs;
 mod file_entries;
 mod folder_download;
+mod loading;
 mod new_folder;
 mod upload;
 
 pub use breadcrumbs::Breadcrumbs;
 pub use file_entries::FileEntries;
 pub use folder_download::FolderDownloads;
+pub use loading::Loading;
 pub use new_folder::NewFolderButton;
 pub use upload::FileUpload;

app/src/components/upload.rs

@@ -23,6 +23,8 @@ pub async fn upload_file(data: MultipartData) -> Result<(), ServerFnError> {
     use server_fn::ServerFnError::ServerError;
     use tokio::{fs::OpenOptions, io::AsyncWriteExt};
 
+    use crate::AppConfig;
+
     async fn collect_field_with_name(
         data: &mut multer::Multipart<'static>,
         name: &str,
@@ -44,14 +46,19 @@ pub async fn upload_file(data: MultipartData) -> Result<(), ServerFnError> {
         Ok(buffer)
     }
 
+    let app_config = expect_context::<AppConfig>();
+
+    if !app_config.allow_upload {
+        return Err(ServerError("Uploads are disabled".into()));
+    }
+
     let Some(mut data) = data.into_inner() else {
         unreachable!("should always return Some on the server side");
     };
 
     let base_req_path = {
-        let base_path = expect_context::<PathBuf>().clone();
         let req_path = collect_field_with_name(&mut data, "path").await?;
-        base_path.join(req_path.trim())
+        app_config.target_dir.join(req_path.trim())
     };
 
     let id = collect_field_with_name(&mut data, "id").await?;

app/src/config.rs

@@ -0,0 +1,7 @@
+use std::path::PathBuf;
+
+#[derive(Debug, Clone)]
+pub struct AppConfig {
+    pub target_dir: PathBuf,
+    pub allow_upload: bool,
+}

app/src/lib.rs

@@ -4,6 +4,7 @@
 use std::path::PathBuf;
 
 mod components;
+mod config;
 mod error_template;
 mod server;
 #[cfg(feature = "ssr")]
@@ -16,6 +17,7 @@ use leptos_router::{components::*, hooks::use_params, params::*};
 use leptos_router_macro::path;
 use urlencoding::decode;
 
+pub use crate::config::AppConfig;
 #[cfg(feature = "ssr")]
 pub use crate::state::AppState;
 use crate::{
@@ -50,15 +52,25 @@ pub fn FilesPage() -> impl IntoView {
 
     let path_signal = Signal::from(path);
 
+    let upload_bar = move |allow_upload: bool| {
+        allow_upload.then(|| {
+            view! {
+              <div class="flex flex-wrap gap-2 justify-center items-start pt-2 w-full">
+                <FileUpload path=path_signal on_upload=move || listing.refetch() />
+                <div class="flex gap-2 grow">
+                  <NewFolderButton path=path_signal action=create_folder_action />
+                  <FolderDownloads path=path_signal />
+                </div>
+              </div>
+            }
+        })
+    };
+
     view! {
-      <div class="App p-3">
-        <div class="w-full pt-2 flex flex-wrap items-start justify-center gap-2">
-          <FileUpload path=path_signal on_upload=move || listing.refetch() />
-          <div class="flex grow gap-2">
-            <NewFolderButton path=path_signal action=create_folder_action />
-            <FolderDownloads path=path_signal />
-          </div>
-        </div>
+      <div class="p-3 App">
+        <Transition fallback=Loading>
+          {move || Suspend::new(async move { upload_allowed().await.ok().and_then(upload_bar) })}
+        </Transition>
 
         <Breadcrumbs path=path_signal />
 
@@ -69,9 +81,7 @@ pub fn FilesPage() -> impl IntoView {
           <span class="hidden md:inline">Last Modified</span>
         </div>
 
-        <Transition fallback=move || {
-          view! { <p>"Loading..."</p> }
-        }>
+        <Transition fallback=Loading>
           {move || Suspend::new(async move {
             match listing.await {
               Ok(entries) => {
@@ -104,7 +114,7 @@ pub fn shell(options: LeptosOptions) -> impl IntoView {
     }
 }
 
-#[allow(non_snake_case)]
+#[component]
 pub fn App() -> impl IntoView {
     provide_meta_context();
 

app/src/server.rs

@@ -1,12 +1,23 @@
 use std::path::PathBuf;
 
+cfg_if! { if #[cfg(feature = "ssr")] {
+    use leptos::logging::warn;
+    use tokio::fs;
+
+    use crate::config::AppConfig;
+}}
+
+use cfg_if::cfg_if;
 use leptos::prelude::*;
 use serde::{Deserialize, Serialize};
-#[cfg(feature = "ssr")]
-use tokio::fs;
 
 use crate::utils::SystemTime;
 
+#[server(name = UploadAllowed, prefix = "/api", endpoint = "upload_allowed")]
+pub async fn upload_allowed() -> Result<bool, ServerFnError> {
+    Ok(expect_context::<AppConfig>().allow_upload)
+}
+
 pub type Entries = Vec<ServerEntry>;
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, PartialOrd, Ord, Eq)]
@@ -34,11 +45,12 @@ pub async fn list_dir(path: PathBuf) -> Result<Entries, ServerFnError> {
         ));
     }
 
-    let base_path = expect_context::<PathBuf>().clone();
+    let base_path = expect_context::<AppConfig>().target_dir;
 
-    let Ok(path) = base_path.join(path).canonicalize() else {
+    let Ok(path) = base_path.join(&path).canonicalize() else {
+        warn!("Attempt to access invalid path: {path:?}");
         return Err(ServerFnError::ServerError(
-            "Path must be inside target_dir".into(),
+            "Requested path not found".into(),
         ));
     };
 
@@ -70,9 +82,13 @@ pub async fn list_dir(path: PathBuf) -> Result<Entries, ServerFnError> {
 
 #[server(name = NewFolder, prefix = "/api", endpoint = "new_folder")]
 pub async fn new_folder(name: String, path: PathBuf) -> Result<(), ServerFnError> {
-    let base_path = expect_context::<PathBuf>().clone();
+    let app_config = expect_context::<AppConfig>();
+
+    if !app_config.allow_upload {
+        return Err(ServerFnError::ServerError("Uploads are disabled".into()));
+    }
 
-    let path = base_path.join(path).join(name);
+    let path = app_config.target_dir.join(path).join(name);
 
     fs::create_dir(path).await?;
 

app/src/state.rs

@@ -1,10 +1,10 @@
-use std::path::PathBuf;
-
 use axum::extract::FromRef;
 use leptos::prelude::LeptosOptions;
 
+use crate::AppConfig;
+
 #[derive(FromRef, Clone, Debug)]
 pub struct AppState {
-    pub target_dir: PathBuf,
+    pub app_config: AppConfig,
     pub leptos_options: LeptosOptions,
 }

server/src/config.rs

@@ -29,11 +29,16 @@ pub struct Cli {
     /// Overrides `TARGET_DIR`
     #[arg(short = 'P', long, default_value = "false")]
     pub picker: bool,
+
+    /// Allow client to upload files
+    #[arg(short, long, default_value = "false")]
+    pub upload: bool,
 }
 
 #[derive(Debug, Clone)]
 pub struct Config {
     pub target_dir: PathBuf,
+    pub allow_upload: bool,
     pub port: u16,
     pub qr: bool,
     pub interfaces: Vec<IpAddr>,
@@ -64,8 +69,10 @@ pub async fn get_config() -> Result<Config, String> {
           IpAddr::V6(Ipv6Addr::UNSPECIFIED),
           IpAddr::V4(Ipv4Addr::UNSPECIFIED),
         ];
+
+        let upload = true;
       } else {
-        let Cli { target_dir, port, qr, interfaces, picker } = Cli::parse();
+        let Cli { target_dir, port, qr, interfaces, picker, upload } = Cli::parse();
         let target_dir = if picker {
           rfd::AsyncFileDialog::new()
             .set_title("Select directory to share")
@@ -87,6 +94,7 @@ pub async fn get_config() -> Result<Config, String> {
 
     Ok(Config {
         target_dir,
+        allow_upload: upload,
         port,
         qr,
         interfaces,

server/src/fileserv.rs

@@ -1,15 +1,19 @@
 mod archive;
 
-use std::{collections::HashMap, path::PathBuf};
+use std::{
+    collections::HashMap,
+    os,
+    path::{self, PathBuf},
+};
 
 pub use archive::Method;
 use axum::{
     body::Body,
     extract::{Multipart, Path, Query, State},
-    http::{header, HeaderValue, Request, StatusCode, Uri},
+    http::{HeaderValue, Request, StatusCode, Uri, header},
     response::IntoResponse,
 };
-use file_share_app::{shell, utils::format_bytes, AppState};
+use file_share_app::{AppConfig, AppState, shell, utils::format_bytes};
 use leptos::{logging, prelude::provide_context};
 use rust_embed::RustEmbed;
 use tokio::io::AsyncWriteExt;
@@ -42,8 +46,7 @@ pub async fn file_and_error_handler(
     }
 
     let handler = leptos_axum::render_app_to_stream_with_context(
-        // app_state.leptos_options.clone(),
-        move || provide_context(app_state.target_dir.clone()),
+        move || provide_context(app_state.app_config.clone()),
         move || shell(app_state.leptos_options.clone()),
     );
     handler(request).await.into_response()
@@ -52,22 +55,22 @@ pub async fn file_and_error_handler(
 /// Handles archive requests.
 #[allow(clippy::implicit_hasher)]
 pub async fn handle_archive_with_path<'a>(
-    State(base_dir): State<PathBuf>,
+    State(AppConfig { target_dir, .. }): State<AppConfig>,
     Path(path): Path<String>,
     Query(params): Query<HashMap<String, String>>,
 ) -> impl IntoResponse + use<'a> {
     logging::log!("Handling archive with path '{path:?}' and params '{params:?}'");
-    handle_archive(base_dir, params.get("method"), path).await
+    handle_archive(target_dir, params.get("method"), path).await
 }
 
 /// Handles archive requests.
 #[allow(clippy::implicit_hasher)]
 pub async fn handle_archive_without_path(
-    State(base_dir): State<PathBuf>,
+    State(AppConfig { target_dir, .. }): State<AppConfig>,
     Query(params): Query<HashMap<String, String>>,
 ) -> impl IntoResponse + use<> {
     logging::log!("Handling archive without path and with params '{params:?}'");
-    handle_archive(base_dir, params.get("method"), String::new()).await
+    handle_archive(target_dir, params.get("method"), String::new()).await
 }
 
 #[allow(clippy::unused_async)] // has to be in an async context, but doesn't await directly
@@ -124,19 +127,32 @@ async fn handle_archive(
     (headers, Body::from_stream(stream)).into_response()
 }
 
+const UPLOAD_DISABLED: (StatusCode, &'static str) =
+    (StatusCode::FORBIDDEN, "Upload is not enabled");
+
 pub async fn file_upload_with_path(
-    State(base_dir): State<PathBuf>,
+    State(AppState { app_config, .. }): State<AppState>,
     Path(path): Path<String>,
     multipart: Multipart,
 ) -> impl IntoResponse {
-    file_upload(base_dir, path, multipart).await
+    if !app_config.allow_upload {
+        return UPLOAD_DISABLED.into_response();
+    }
+    file_upload(app_config.target_dir, path, multipart)
+        .await
+        .into_response()
 }
 
 pub async fn file_upload_without_path(
-    State(base_dir): State<PathBuf>,
+    State(AppState { app_config, .. }): State<AppState>,
     multipart: Multipart,
 ) -> impl IntoResponse {
-    file_upload(base_dir, String::new(), multipart).await
+    if !app_config.allow_upload {
+        return UPLOAD_DISABLED.into_response();
+    }
+    file_upload(app_config.target_dir, String::new(), multipart)
+        .await
+        .into_response()
 }
 
 pub async fn file_upload(