fixes and functions

src/config/mod.rs

@@ -55,6 +55,8 @@ pub struct Config {
     pub files_dir: String,
     pub storage: crate::storage::StorageConfig,
     pub upload_max_size_bytes: usize,
+    pub guest_upload_enabled: bool,
+    pub guest_upload_max_size_bytes: usize,
     pub asset_version: String,
     pub asset_cache_max_age_seconds: u64,
     pub file_cache_max_age_seconds: u64,
@@ -77,7 +79,9 @@ impl Config {
         let host = values.get("APP_HOST", "127.0.0.1").parse()?;
         let port = values.get("APP_PORT", "3000").parse()?;
         let database_max_connections = values.get("DATABASE_MAX_CONNECTIONS", "8").parse()?;
-        let upload_max_size_mb: usize = values.get("UPLOAD_MAX_SIZE_MB", "20").parse()?;
+        let upload_max_size_mb = values.positive_u64("UPLOAD_MAX_SIZE_MB", 20)?;
+        let guest_upload_enabled = values.bool("GUEST_UPLOAD_ENABLED", false)?;
+        let guest_upload_max_size_mb = values.positive_u64("GUEST_UPLOAD_MAX_SIZE_MB", 5)?;
         let anonymous_access_token_ttl_days =
             values.positive_i64("ANONYMOUS_ACCESS_TOKEN_TTL_DAYS", 7)?;
         let user_session_ttl_days = values.positive_i64("USER_SESSION_TTL_DAYS", 3)?;
@@ -107,10 +111,6 @@ impl Config {
             _ => return Err("STORAGE_DRIVER must be local or s3".into()),
         };
 
-        if upload_max_size_mb == 0 {
-            return Err("UPLOAD_MAX_SIZE_MB must be greater than 0".into());
-        }
-
         let authorization_type = AuthorizationType::from_values(&values)?;
         let ldap = match authorization_type {
             AuthorizationType::Local => None,
@@ -167,9 +167,12 @@ impl Config {
             static_dir: values.get("STATIC_DIR", "static"),
             files_dir,
             storage,
-            upload_max_size_bytes: upload_max_size_mb
-                .checked_mul(1024 * 1024)
-                .ok_or("UPLOAD_MAX_SIZE_MB is too large")?,
+            upload_max_size_bytes: megabytes_to_bytes("UPLOAD_MAX_SIZE_MB", upload_max_size_mb)?,
+            guest_upload_enabled,
+            guest_upload_max_size_bytes: megabytes_to_bytes(
+                "GUEST_UPLOAD_MAX_SIZE_MB",
+                guest_upload_max_size_mb,
+            )?,
             asset_version: env!("CARGO_PKG_VERSION").to_owned(),
             asset_cache_max_age_seconds: values
                 .nonnegative_u64("ASSET_CACHE_MAX_AGE_SECONDS", 600)?,
@@ -213,4 +216,66 @@ impl Config {
         }
         Ok(())
     }
+
+    pub fn upload_body_limit_bytes(&self) -> usize {
+        multipart_body_limit_bytes(
+            self.upload_max_size_bytes,
+            self.guest_upload_enabled,
+            self.guest_upload_max_size_bytes,
+        )
+    }
+}
+
+fn multipart_body_limit_bytes(
+    user_limit_bytes: usize,
+    guest_upload_enabled: bool,
+    guest_limit_bytes: usize,
+) -> usize {
+    let file_limit = if guest_upload_enabled {
+        user_limit_bytes.max(guest_limit_bytes)
+    } else {
+        user_limit_bytes
+    };
+    file_limit.saturating_add(1024 * 1024)
+}
+
+fn megabytes_to_bytes(
+    name: &str,
+    megabytes: u64,
+) -> Result<usize, Box<dyn std::error::Error>> {
+    let bytes = megabytes
+        .checked_mul(1024 * 1024)
+        .ok_or_else(|| format!("{name} is too large"))?;
+    usize::try_from(bytes).map_err(|_| format!("{name} is too large").into())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{megabytes_to_bytes, multipart_body_limit_bytes};
+
+    #[test]
+    fn converts_upload_megabytes_to_bytes() {
+        assert_eq!(megabytes_to_bytes("LIMIT", 5).unwrap(), 5 * 1024 * 1024);
+    }
+
+    #[test]
+    fn rejects_overflowing_upload_limit() {
+        assert!(megabytes_to_bytes("LIMIT", u64::MAX).is_err());
+    }
+
+    #[test]
+    fn multipart_limit_uses_user_limit_when_guest_uploads_are_disabled() {
+        assert_eq!(
+            multipart_body_limit_bytes(20 * 1024 * 1024, false, 50 * 1024 * 1024),
+            21 * 1024 * 1024
+        );
+    }
+
+    #[test]
+    fn multipart_limit_uses_larger_enabled_guest_limit() {
+        assert_eq!(
+            multipart_body_limit_bytes(20 * 1024 * 1024, true, 50 * 1024 * 1024),
+            51 * 1024 * 1024
+        );
+    }
 }