irondrop: fuck AppleDouble Probe

Author: dev-harsh1998

src/webdav.rs

@@ -255,8 +255,13 @@ fn handle_propfind(
             return Ok(status_response(404, "Not Found"));
         }
         let effective_depth = DavDepth::Zero;
-        let (response, resource_count) =
-            build_propfind_response(base_dir, &target_path, &mode, effective_depth)?;
+        let (response, resource_count) = build_propfind_response(
+            base_dir,
+            &target_path,
+            &mode,
+            effective_depth,
+            context.aggressive_finder_compat_enabled(),
+        )?;
         debug!(
             "WebDAV PROPFIND existing noise path served path={} resolved_target={} mode={} resource_count={}",
             request.path,
@@ -291,8 +296,13 @@ fn handle_propfind(
         effective_depth,
         propfind_mode_name(&mode),
     );
-    let (response, resource_count) =
-        build_propfind_response(base_dir, &target_path, &mode, effective_depth)?;
+    let (response, resource_count) = build_propfind_response(
+        base_dir,
+        &target_path,
+        &mode,
+        effective_depth,
+        context.aggressive_finder_compat_enabled(),
+    )?;
     log_propfind_result(
         context,
         &request.path,
@@ -521,8 +531,9 @@ fn build_propfind_response(
     target_path: &Path,
     mode: &PropfindMode,
     depth: DavDepth,
+    filter_noise: bool,
 ) -> Result<(Response, usize), AppError> {
-    let resources = collect_propfind_resources(target_path, depth)?;
+    let resources = collect_propfind_resources(target_path, depth, filter_noise)?;
     let resource_count = resources.len();
 
     let mut body = String::from(
@@ -558,6 +569,7 @@ fn build_propfind_response(
 fn collect_propfind_resources(
     target_path: &Path,
     depth: DavDepth,
+    filter_noise: bool,
 ) -> Result<Vec<PathBuf>, AppError> {
     let mut resources = vec![target_path.to_path_buf()];
     if target_path.is_dir() {
@@ -567,13 +579,20 @@ fn collect_propfind_resources(
                 let mut entries = Vec::new();
                 for entry in std::fs::read_dir(target_path)? {
                     let entry = entry?;
-                    entries.push(entry.path());
+                    let path = entry.path();
+                    if filter_noise
+                        && let Some(file_name) = path.file_name().and_then(|n| n.to_str())
+                        && crate::utils::is_macos_finder_noise_path(file_name)
+                    {
+                        continue;
+                    }
+                    entries.push(path);
                 }
                 entries.sort_by(|a, b| a.to_string_lossy().cmp(&b.to_string_lossy()));
                 resources.extend(entries);
             }
             DavDepth::Infinity => {
-                collect_recursive_resources(target_path, &mut resources)?;
+                collect_recursive_resources(target_path, &mut resources, filter_noise)?;
             }
         }
     }
@@ -767,13 +786,24 @@ fn parse_prop_name_from_token(
     })
 }
 
-fn collect_recursive_resources(root: &Path, resources: &mut Vec<PathBuf>) -> Result<(), AppError> {
+fn collect_recursive_resources(
+    root: &Path,
+    resources: &mut Vec<PathBuf>,
+    filter_noise: bool,
+) -> Result<(), AppError> {
     let mut stack = vec![root.to_path_buf()];
     while let Some(current_dir) = stack.pop() {
         let mut children = Vec::new();
         for entry in std::fs::read_dir(&current_dir)? {
             let entry = entry?;
-            children.push((entry.path(), entry.file_type()?));
+            let path = entry.path();
+            if filter_noise
+                && let Some(file_name) = path.file_name().and_then(|n| n.to_str())
+                && crate::utils::is_macos_finder_noise_path(file_name)
+            {
+                continue;
+            }
+            children.push((path, entry.file_type()?));
         }
         children.sort_by(|(a, _), (b, _)| a.to_string_lossy().cmp(&b.to_string_lossy()));
 

tests/webdav_options_propfind_test.rs

@@ -541,6 +541,77 @@ fn test_propfind_finder_infinity_depth_is_capped_to_one_in_safe_mode() {
     assert!(!body.contains("<D:href>/dir/nested/deeper/</D:href>"));
 }
 
+#[test]
+fn test_propfind_finder_filters_noise_from_collection_listings_in_aggressive_mode() {
+    let server = setup_test_server_with_finder_mode(
+        |root| {
+            create_dir_all(root.join("dir")).unwrap();
+            let mut f1 = File::create(root.join("dir").join("child.txt")).unwrap();
+            writeln!(f1, "real child").unwrap();
+            let mut f2 = File::create(root.join("dir").join("._child.txt")).unwrap();
+            writeln!(f2, "apple double").unwrap();
+            let mut f3 = File::create(root.join("dir").join(".DS_Store")).unwrap();
+            writeln!(f3, "finder metadata").unwrap();
+        },
+        "aggressive",
+    );
+    let client = Client::new();
+
+    let response = client
+        .request(
+            Method::from_bytes(b"PROPFIND").unwrap(),
+            format!("http://{}/dir/", server.addr),
+        )
+        .header("Depth", "1")
+        .header("User-Agent", FINDER_USER_AGENT)
+        .header("Content-Type", "application/xml")
+        .body(allprop_body().to_string())
+        .send()
+        .unwrap();
+
+    assert_eq!(response.status().as_u16(), 207);
+    let body = response.text().unwrap();
+    assert!(body.contains("<D:href>/dir/</D:href>"));
+    assert!(body.contains("<D:href>/dir/child.txt</D:href>"));
+    // The noisy files should be completely hidden from the listing
+    assert!(!body.contains("._child.txt"));
+    assert!(!body.contains(".DS_Store"));
+}
+
+#[test]
+fn test_propfind_finder_does_not_filter_noise_from_collection_listings_in_safe_mode() {
+    let server = setup_test_server_with_finder_mode(
+        |root| {
+            create_dir_all(root.join("dir")).unwrap();
+            let mut f1 = File::create(root.join("dir").join("child.txt")).unwrap();
+            writeln!(f1, "real child").unwrap();
+            let mut f2 = File::create(root.join("dir").join("._child.txt")).unwrap();
+            writeln!(f2, "apple double").unwrap();
+        },
+        "safe",
+    );
+    let client = Client::new();
+
+    let response = client
+        .request(
+            Method::from_bytes(b"PROPFIND").unwrap(),
+            format!("http://{}/dir/", server.addr),
+        )
+        .header("Depth", "1")
+        .header("User-Agent", FINDER_USER_AGENT)
+        .header("Content-Type", "application/xml")
+        .body(allprop_body().to_string())
+        .send()
+        .unwrap();
+
+    assert_eq!(response.status().as_u16(), 207);
+    let body = response.text().unwrap();
+    assert!(body.contains("<D:href>/dir/</D:href>"));
+    assert!(body.contains("<D:href>/dir/child.txt</D:href>"));
+    // Safe mode preserves literal filesystem layout
+    assert!(body.contains("._child.txt"));
+}
+
 #[test]
 fn test_propfind_finder_missing_depth_defaults_to_one_in_safe_mode() {
     let server = setup_test_server_with_finder_mode(