From e0542878862f3805f57ec1c26f30aa50059c7a6f Mon Sep 17 00:00:00 2001
From: Lukas Pieper <30661176+lukaspieper@users.noreply.github.com>
Date: Sun, 11 Jan 2026 18:04:10 +0100
Subject: [PATCH] Add output dir option to backup command

---
 src/api/admin.rs |  2 +-
 src/db/mod.rs    | 18 ++++++++++++++----
 src/main.rs      |  8 +++++---
 3 files changed, 20 insertions(+), 8 deletions(-)

diff --git a/src/api/admin.rs b/src/api/admin.rs
index badfaa3a..7cb78ede 100644
--- a/src/api/admin.rs
+++ b/src/api/admin.rs
@@ -799,7 +799,7 @@ async fn delete_config(_token: AdminToken) -> EmptyResult {
 #[post("/config/backup_db", format = "application/json")]
 fn backup_db(_token: AdminToken) -> ApiResult<String> {
     if *CAN_BACKUP {
-        match backup_sqlite() {
+        match backup_sqlite(None) {
             Ok(f) => Ok(format!("Backup to '{f}' was successful")),
             Err(e) => err!(format!("Backup was unsuccessful {e}")),
         }
diff --git a/src/db/mod.rs b/src/db/mod.rs
index ae2b1221..067a732f 100644
--- a/src/db/mod.rs
+++ b/src/db/mod.rs
@@ -385,7 +385,7 @@ pub mod models;
 /// Creates a back-up of the sqlite database
 /// MySQL/MariaDB and PostgreSQL are not supported.
 #[cfg(sqlite)]
-pub fn backup_sqlite() -> Result<String, Error> {
+pub fn backup_sqlite(output_dir: Option<String>) -> Result<String, Error> {
     use diesel::Connection;
     use std::{fs::File, io::Write};
 
@@ -395,8 +395,18 @@ pub fn backup_sqlite() -> Result<String, Error> {
         // This way we can set a readonly flag on the opening mode without issues.
         let mut conn = diesel::sqlite::SqliteConnection::establish(&format!("sqlite://{db_url}?mode=ro"))?;
 
-        let db_path = std::path::Path::new(&db_url).parent().unwrap();
-        let backup_file = db_path
+        let backup_dir = match &output_dir {
+            Some(dir) => {
+                let output_path = std::path::Path::new(dir);
+                if !output_path.exists() || !output_path.is_dir() {
+                    err!(format!("Backup directory does not exist or is not a directory: {}", dir));
+                }
+                output_path
+            }
+            None => std::path::Path::new(&db_url).parent().unwrap(),
+        };
+
+        let backup_file = backup_dir
             .join(format!("db_{}.sqlite3", chrono::Utc::now().format("%Y%m%d_%H%M%S")))
             .to_string_lossy()
             .into_owned();
@@ -417,7 +427,7 @@ pub fn backup_sqlite() -> Result<String, Error> {
 }
 
 #[cfg(not(sqlite))]
-pub fn backup_sqlite() -> Result<String, Error> {
+pub fn backup_sqlite(_output_dir: Option<String>) -> Result<String, Error> {
     err_silent!("The database type is not SQLite. Backups only works for SQLite databases")
 }
 
diff --git a/src/main.rs b/src/main.rs
index 8eef2e8c..f8f8815b 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -105,7 +105,7 @@ FLAGS:
 
 COMMAND:
     hash [--preset {bitwarden|owasp}]  Generate an Argon2id PHC ADMIN_TOKEN
-    backup                             Create a backup of the SQLite database
+    backup [-o, --output <dir>]        Create a backup of the SQLite database
                                        You can also send the USR1 signal to trigger a backup
 
 PRESETS:                  m=         t=          p=
@@ -187,7 +187,9 @@ fn parse_args() {
                 exit(1);
             }
         } else if command == "backup" {
-            match db::backup_sqlite() {
+            let output_dir: Option<String> = pargs.opt_value_from_str(["-o", "--output"]).unwrap_or_default();
+
+            match db::backup_sqlite(output_dir) {
                 Ok(f) => {
                     println!("Backup to '{f}' was successful");
                     exit(0);
@@ -606,7 +608,7 @@ async fn launch_rocket(pool: db::DbPool, extra_debug: bool) -> Result<(), Error>
                     // If we need more signals to act upon, we might want to use select! here.
                     // With only one item to listen for this is enough.
                     let _ = signal_user1.recv().await;
-                    match db::backup_sqlite() {
+                    match db::backup_sqlite(None) {
                         Ok(f) => info!("Backup to '{f}' was successful"),
                         Err(e) => error!("Backup failed. {e:?}"),
                     }