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
11pub 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 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 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 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 transfer_state.set_app_handle(app_handle.clone()).await;
165 transfer_state.add_job(job).await;
166
167 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 transfer_state.set_app_handle(app_handle.clone()).await;
216 transfer_state.add_job(job).await;
217
218 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 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 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 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 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 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}