Skip to main content

brows3_lib/commands/
transfer.rs

1use crate::commands::profiles::ProfileState;
2use crate::credentials::Profile;
3use crate::error::Result;
4use crate::s3::S3State;
5use crate::transfer::download::DownloadDestination;
6use crate::transfer::{TransferJob, TransferManager, TransferType};
7use std::path::PathBuf;
8use std::sync::Arc;
9use tauri::{AppHandle, State};
10
11// We need to store the TransferManager in Tauri state
12pub type TransferState = Arc<TransferManager>;
13
14async fn list_folder_objects(
15    client: &aws_sdk_s3::Client,
16    bucket_name: &str,
17    prefix: &str,
18) -> Result<Vec<(String, u64)>> {
19    Ok(
20        crate::s3::listing::list_recursive(client, bucket_name, prefix)
21            .await?
22            .into_iter()
23            .filter_map(|object| {
24                let key = object.key?;
25                if key.ends_with('/') {
26                    return None;
27                }
28                Some((key, object.size.unwrap_or(0).max(0) as u64))
29            })
30            .collect(),
31    )
32}
33
34fn validate_path(path: &std::path::Path) -> Result<()> {
35    // Basic check for path traversal
36    for component in path.components() {
37        if matches!(component, std::path::Component::ParentDir) {
38            return Err(crate::error::AppError::IoError(
39                "Invalid path: contains parent directory reference".to_string(),
40            ));
41        }
42    }
43    Ok(())
44}
45
46fn safe_relative_download_path(key: &str) -> Result<PathBuf> {
47    let invalid_path = || {
48        crate::error::AppError::IoError(format!(
49            "Invalid object key for folder download: '{}'",
50            key
51        ))
52    };
53
54    if key.is_empty() || key.starts_with('/') || key.contains('\\') {
55        return Err(invalid_path());
56    }
57
58    let mut relative_path = PathBuf::new();
59    for segment in key.split('/') {
60        match segment {
61            "" | "." | ".." => return Err(invalid_path()),
62            _ => {
63                let bytes = segment.as_bytes();
64                let is_windows_drive =
65                    bytes.len() >= 2 && bytes[0].is_ascii_alphabetic() && bytes[1] == b':';
66                if is_windows_drive || segment.contains('\0') {
67                    return Err(invalid_path());
68                }
69                #[cfg(windows)]
70                {
71                    let stem = segment.split('.').next().unwrap_or("").to_ascii_uppercase();
72                    let reserved = matches!(stem.as_str(), "CON" | "PRN" | "AUX" | "NUL")
73                        || ["COM", "LPT"].iter().any(|prefix| {
74                            stem.strip_prefix(prefix).is_some_and(|suffix| {
75                                matches!(
76                                    suffix,
77                                    "1" | "2"
78                                        | "3"
79                                        | "4"
80                                        | "5"
81                                        | "6"
82                                        | "7"
83                                        | "8"
84                                        | "9"
85                                        | "¹"
86                                        | "²"
87                                        | "³"
88                                )
89                            })
90                        });
91                    if reserved
92                        || segment.ends_with(['.', ' '])
93                        || segment
94                            .chars()
95                            .any(|c| c.is_control() || "<>:\"|?*".contains(c))
96                    {
97                        return Err(invalid_path());
98                    }
99                }
100                relative_path.push(segment);
101            }
102        }
103    }
104
105    if relative_path.as_os_str().is_empty() {
106        return Err(invalid_path());
107    }
108
109    Ok(relative_path)
110}
111
112async fn require_active_profile(profile_state: &ProfileState, expected: &str) -> Result<Profile> {
113    let profile_manager = profile_state.read().await;
114    let profile = profile_manager
115        .get_active_profile()
116        .await?
117        .ok_or_else(|| crate::error::AppError::ConfigError("No active profile".to_string()))?;
118    super::operations::validate_operation_profile(Some(expected), &profile.id)?;
119    Ok(profile)
120}
121
122#[allow(clippy::too_many_arguments)]
123#[tauri::command]
124pub async fn queue_upload(
125    bucket_name: String,
126    bucket_region: Option<String>,
127    key: String,
128    local_path: String,
129    total_bytes: u64,
130    expected_profile_id: String,
131    app_handle: AppHandle,
132    profile_state: State<'_, ProfileState>,
133    s3_state: State<'_, S3State>,
134    transfer_state: State<'_, TransferState>,
135) -> Result<String> {
136    // Basic validation
137    let path = PathBuf::from(&local_path);
138    validate_path(&path)?;
139    let profile_id = require_active_profile(profile_state.inner(), &expected_profile_id)
140        .await?
141        .id;
142
143    // Fallback for 0 bytes: try to get size from filesystem
144    let mut actual_size = total_bytes;
145    if actual_size == 0 {
146        if let Ok(metadata) = std::fs::metadata(&path) {
147            actual_size = metadata.len();
148        }
149    }
150
151    let job = TransferJob::new(
152        TransferType::Upload,
153        profile_id,
154        bucket_name,
155        bucket_region,
156        key,
157        path,
158        actual_size,
159    );
160
161    let job_id = job.id.clone();
162
163    // Add to manager
164    transfer_state.set_app_handle(app_handle.clone()).await;
165    transfer_state.add_job(job).await;
166
167    // Trigger processing (async)
168    let t_state = transfer_state.inner().clone();
169    let p_state = profile_state.inner().clone();
170    let s_state = s3_state.inner().clone();
171
172    tauri::async_runtime::spawn(async move {
173        t_state.process_queue(s_state, p_state).await;
174    });
175
176    Ok(job_id)
177}
178
179#[allow(clippy::too_many_arguments)]
180#[tauri::command]
181pub async fn queue_download(
182    bucket_name: String,
183    bucket_region: Option<String>,
184    key: String,
185    local_path: String,
186    total_bytes: u64,
187    overwrite: Option<bool>,
188    expected_profile_id: String,
189    app_handle: AppHandle,
190    profile_state: State<'_, ProfileState>,
191    s3_state: State<'_, S3State>,
192    transfer_state: State<'_, TransferState>,
193) -> Result<String> {
194    let path = PathBuf::from(&local_path);
195    validate_path(&path)?;
196    let profile_id = require_active_profile(profile_state.inner(), &expected_profile_id)
197        .await?
198        .id;
199
200    let destination = DownloadDestination::from_path(&path, overwrite.unwrap_or(false))?;
201    let mut job = TransferJob::new(
202        TransferType::Download,
203        profile_id,
204        bucket_name,
205        bucket_region,
206        key,
207        path,
208        total_bytes,
209    );
210
211    job.download_destination = Some(Arc::new(destination));
212    let job_id = job.id.clone();
213
214    // Add to manager
215    transfer_state.set_app_handle(app_handle.clone()).await;
216    transfer_state.add_job(job).await;
217
218    // Trigger processing
219    let t_state = transfer_state.inner().clone();
220    let p_state = profile_state.inner().clone();
221    let s_state = s3_state.inner().clone();
222
223    tauri::async_runtime::spawn(async move {
224        t_state.process_queue(s_state, p_state).await;
225    });
226
227    Ok(job_id)
228}
229
230#[tauri::command]
231pub async fn list_transfers(transfer_state: State<'_, TransferState>) -> Result<Vec<TransferJob>> {
232    Ok(transfer_state.list_jobs().await)
233}
234
235#[allow(clippy::too_many_arguments)]
236fn collect_upload_files(
237    root: &std::path::Path,
238    prefix: &str,
239) -> Result<Vec<(PathBuf, u64, String)>> {
240    let parent = root
241        .parent()
242        .ok_or_else(|| crate::error::AppError::ConfigError("Choose a folder".into()))?;
243    let mut files = Vec::new();
244    let mut keys = std::collections::HashSet::new();
245    for entry in walkdir::WalkDir::new(root).follow_links(false) {
246        let entry = entry.map_err(|error| {
247            crate::error::AppError::IoError(format!("Folder upload was not queued: {error}"))
248        })?;
249        if entry.path_is_symlink() {
250            return Err(crate::error::AppError::IoError(format!(
251                "Folder upload contains a symbolic link: {}. Select its target explicitly instead.",
252                entry.path().display()
253            )));
254        }
255        if !entry.file_type().is_file() {
256            continue;
257        }
258        let relative = entry
259            .path()
260            .strip_prefix(parent)
261            .map_err(|e| crate::error::AppError::IoError(e.to_string()))?;
262        let parts: Option<Vec<_>> = relative
263            .components()
264            .map(|part| part.as_os_str().to_str())
265            .collect();
266        let key = format!(
267            "{}{}",
268            prefix,
269            parts
270                .ok_or_else(|| crate::error::AppError::IoError(format!(
271                    "Filename is not valid Unicode: {}",
272                    entry.path().display()
273                )))?
274                .join("/")
275        );
276        if !keys.insert(key.clone()) {
277            return Err(crate::error::AppError::IoError(format!(
278                "Multiple files map to {key}"
279            )));
280        }
281        let size = entry
282            .metadata()
283            .map_err(|e| crate::error::AppError::IoError(e.to_string()))?
284            .len();
285        files.push((entry.path().to_path_buf(), size, key));
286        if files.len() > 100_000 {
287            return Err(crate::error::AppError::ConfigError(
288                "Folder upload exceeds 100,000 files. Select smaller folders.".into(),
289            ));
290        }
291    }
292    Ok(files)
293}
294
295#[tauri::command]
296#[allow(clippy::too_many_arguments)]
297pub async fn queue_folder_upload(
298    bucket_name: String,
299    bucket_region: Option<String>,
300    prefix: String,
301    local_path: String,
302    expected_profile_id: String,
303    app_handle: AppHandle,
304    profile_state: State<'_, ProfileState>,
305    s3_state: State<'_, S3State>,
306    transfer_state: State<'_, TransferState>,
307) -> Result<u32> {
308    let root = PathBuf::from(&local_path);
309    validate_path(&root)?;
310    let profile_id = require_active_profile(profile_state.inner(), &expected_profile_id)
311        .await?
312        .id;
313    let upload_prefix = prefix.clone();
314    let jobs_data =
315        tauri::async_runtime::spawn_blocking(move || collect_upload_files(&root, &upload_prefix))
316            .await
317            .map_err(|e| crate::error::AppError::IoError(e.to_string()))??;
318
319    let current_manager = transfer_state.clone();
320    current_manager.set_app_handle(app_handle.clone()).await;
321
322    let count = jobs_data.len() as u32;
323    let group_id = uuid::Uuid::new_v4().to_string();
324    let group_name = format!("s3://{}/{}", bucket_name, prefix);
325
326    let mut queued = Vec::with_capacity(jobs_data.len());
327    for (path, size, key) in jobs_data {
328        let job = TransferJob::new(
329            TransferType::Upload,
330            profile_id.clone(),
331            bucket_name.clone(),
332            bucket_region.clone(),
333            key,
334            path,
335            size,
336        )
337        .with_group(group_id.clone(), group_name.clone());
338
339        queued.push(job);
340    }
341    current_manager.add_jobs(queued).await;
342
343    // Trigger processing
344    let t_state = transfer_state.inner().clone();
345    let p_state = profile_state.inner().clone();
346    let s_state = s3_state.inner().clone();
347
348    tauri::async_runtime::spawn(async move {
349        t_state.process_queue(s_state, p_state).await;
350    });
351
352    Ok(count)
353}
354
355#[allow(clippy::too_many_arguments)]
356#[tauri::command]
357pub async fn queue_folder_download(
358    bucket_name: String,
359    bucket_region: Option<String>,
360    prefix: String,
361    local_path: String,
362    expected_profile_id: String,
363    app_handle: AppHandle,
364    profile_state: State<'_, ProfileState>,
365    s3_state: State<'_, S3State>,
366    transfer_state: State<'_, TransferState>,
367) -> Result<u32> {
368    let root_path = PathBuf::from(&local_path);
369    validate_path(&root_path)?;
370
371    // 1. List all objects in the prefix
372    let profile = require_active_profile(profile_state.inner(), &expected_profile_id).await?;
373
374    let objects = {
375        let resolved_region = {
376            let s3 = s3_state.read().await;
377            s3.get_bucket_region(&profile, &bucket_name)
378        }
379        .or(bucket_region.clone());
380
381        let client = {
382            let mut s3 = s3_state.write().await;
383            if let Some(ref region) = resolved_region {
384                s3.get_client_for_region(&profile, region).await?.clone()
385            } else {
386                s3.get_client(&profile).await?.clone()
387            }
388        };
389
390        match list_folder_objects(&client, &bucket_name, &prefix).await {
391            Ok(objects) => objects,
392            Err(err) => {
393                log::warn!(
394                    "queue_folder_download listing failed, attempting region discovery: {}",
395                    err
396                );
397                let retry_client = {
398                    let mut s3 = s3_state.write().await;
399                    s3.get_client(&profile).await?.clone()
400                };
401
402                if let Ok(new_region) =
403                    crate::s3::get_bucket_region(&retry_client, &bucket_name).await
404                {
405                    {
406                        let mut s3 = s3_state.write().await;
407                        s3.set_bucket_region(&profile, &bucket_name, new_region.clone());
408                    }
409
410                    let retry_client = {
411                        let mut s3 = s3_state.write().await;
412                        s3.get_client_for_region(&profile, &new_region)
413                            .await?
414                            .clone()
415                    };
416
417                    list_folder_objects(&retry_client, &bucket_name, &prefix)
418                        .await
419                        .map_err(|e| {
420                            crate::error::AppError::S3Error(format!(
421                                "Retry folder listing failed: {}",
422                                e
423                            ))
424                        })?
425                } else {
426                    return Err(err);
427                }
428            }
429        }
430    };
431
432    let group_id = uuid::Uuid::new_v4().to_string();
433    let group_name = format!("s3://{}/{}", bucket_name, prefix);
434    let root_path = PathBuf::from(&local_path);
435    let selected_root = root_path.parent().ok_or_else(|| {
436        crate::error::AppError::IoError("Choose a download directory".to_string())
437    })?;
438    let download_root = DownloadDestination::open_root(selected_root)?;
439
440    // Validate every object key before adding any jobs, so a malicious key cannot
441    // leave a partially queued folder download behind.
442    let mut jobs_data = Vec::with_capacity(objects.len());
443    let mut destinations = std::collections::HashSet::new();
444    for (key, size) in objects {
445        let relative_key = key.strip_prefix(&prefix).unwrap_or(&key);
446        if relative_key.is_empty() {
447            continue;
448        }
449
450        let relative_path = safe_relative_download_path(relative_key)?;
451        let file_path = root_path.join(relative_path);
452        validate_path(&file_path)?;
453        if !destinations.insert(file_path.clone()) {
454            return Err(crate::error::AppError::IoError(format!(
455                "Multiple objects would download to {}",
456                file_path.display()
457            )));
458        }
459        jobs_data.push((key, size, file_path));
460    }
461
462    let count = jobs_data.len() as u32;
463
464    transfer_state.set_app_handle(app_handle.clone()).await;
465
466    let mut queued = Vec::with_capacity(jobs_data.len());
467    for (key, size, file_path) in jobs_data {
468        let relative_path = file_path
469            .strip_prefix(selected_root)
470            .map_err(|error| crate::error::AppError::IoError(error.to_string()))?
471            .to_path_buf();
472        let destination = DownloadDestination::new(download_root.clone(), relative_path, false)?;
473        let mut job = TransferJob::new(
474            TransferType::Download,
475            profile.id.clone(),
476            bucket_name.clone(),
477            bucket_region.clone(),
478            key,
479            file_path,
480            size,
481        )
482        .with_group(group_id.clone(), group_name.clone());
483        job.download_destination = Some(Arc::new(destination));
484
485        queued.push(job);
486    }
487    transfer_state.add_jobs(queued).await;
488
489    // Trigger processing
490    let t_state = transfer_state.inner().clone();
491    let p_state = profile_state.inner().clone();
492    let s_state = s3_state.inner().clone();
493
494    tauri::async_runtime::spawn(async move {
495        t_state.process_queue(s_state, p_state).await;
496    });
497
498    Ok(count)
499}
500
501#[tauri::command]
502pub async fn cancel_transfer(
503    job_id: String,
504    transfer_state: State<'_, TransferState>,
505) -> Result<bool> {
506    Ok(transfer_state.cancel_job(&job_id).await)
507}
508
509#[tauri::command]
510pub async fn retry_transfer(
511    job_id: String,
512    _app_handle: AppHandle,
513    profile_state: State<'_, ProfileState>,
514    s3_state: State<'_, S3State>,
515    transfer_state: State<'_, TransferState>,
516) -> Result<Option<String>> {
517    if transfer_state.get_job(&job_id).await.is_some_and(|job| {
518        matches!(job.transfer_type, TransferType::Download) && job.download_destination.is_none()
519    }) {
520        return Err(crate::error::AppError::ConfigError(
521            "Queue this download again to choose its destination after restarting.".into(),
522        ));
523    }
524    let new_id = transfer_state.retry_job(&job_id).await;
525
526    // If retry created a new job, trigger processing
527    if let Some(_id) = &new_id {
528        let t_state = transfer_state.inner().clone();
529        let p_state = profile_state.inner().clone();
530        let s_state = s3_state.inner().clone();
531
532        tauri::async_runtime::spawn(async move {
533            t_state.process_queue(s_state, p_state).await;
534        });
535    }
536
537    Ok(new_id)
538}
539
540#[cfg(test)]
541mod tests {
542    use super::safe_relative_download_path;
543
544    #[test]
545    fn missing_upload_folder_fails_instead_of_queuing_zero_files() {
546        let root = tempfile::tempdir().unwrap();
547        assert!(super::collect_upload_files(&root.path().join("missing"), "").is_err());
548    }
549
550    #[cfg(unix)]
551    #[test]
552    fn upload_preflight_rejects_symlinks_and_preserves_literal_backslashes() {
553        let root = tempfile::tempdir().unwrap();
554        let folder = root.path().join("folder");
555        std::fs::create_dir(&folder).unwrap();
556        std::fs::write(folder.join("a\\b"), "content").unwrap();
557        let files = super::collect_upload_files(&folder, "").unwrap();
558        assert_eq!(files[0].2, "folder/a\\b");
559        std::os::unix::fs::symlink(folder.join("a\\b"), folder.join("link")).unwrap();
560        assert!(super::collect_upload_files(&folder, "").is_err());
561    }
562
563    #[test]
564    fn folder_download_rejects_keys_that_would_be_normalized() {
565        for key in ["a//b.txt", "a/./b.txt", "a\\b.txt", "a/"] {
566            assert!(safe_relative_download_path(key).is_err(), "{key}");
567        }
568        assert!(safe_relative_download_path("a/b.txt").is_ok());
569    }
570    use std::path::PathBuf;
571
572    #[test]
573    fn folder_download_path_accepts_nested_object_keys() {
574        assert_eq!(
575            safe_relative_download_path("reports/2026/result.csv").unwrap(),
576            PathBuf::from("reports/2026/result.csv")
577        );
578    }
579
580    #[test]
581    fn folder_download_path_rejects_parent_traversal() {
582        assert!(safe_relative_download_path("reports/../../secret.txt").is_err());
583        assert!(safe_relative_download_path("..\\secret.txt").is_err());
584    }
585
586    #[test]
587    fn folder_download_path_rejects_absolute_paths() {
588        assert!(safe_relative_download_path("/tmp/escaped.txt").is_err());
589        assert!(safe_relative_download_path("\\\\server\\share\\escaped.txt").is_err());
590        assert!(safe_relative_download_path("C:\\temp\\escaped.txt").is_err());
591        assert!(safe_relative_download_path("safe/C:\\temp\\escaped.txt").is_err());
592    }
593}
594
595#[tauri::command]
596pub async fn remove_transfer(
597    job_id: String,
598    transfer_state: State<'_, TransferState>,
599) -> Result<bool> {
600    Ok(transfer_state.remove_job(&job_id).await)
601}
602
603#[tauri::command]
604pub async fn clear_completed_transfers(transfer_state: State<'_, TransferState>) -> Result<usize> {
605    Ok(transfer_state.clear_completed().await)
606}
607
608#[tauri::command]
609pub async fn set_transfer_concurrency(
610    max_concurrency: u32,
611    transfer_state: State<'_, TransferState>,
612) -> Result<()> {
613    transfer_state.set_max_concurrency(max_concurrency as usize);
614    Ok(())
615}