fix(cp): handle deleted working directory with absolute paths

Fixes issue #9105: cp now works with absolute source/target paths even
when the current working directory has been deleted.

Changes:
- Make current_dir optional, only call env::current_dir() for relative paths
- Replace unsafe unwrap() with safe is_some_and() path handling
- Extract root_parent logic into determine_root_parent() helper method
- Improve code clarity and maintainability

This avoids getcwd() syscall failures and matches GNU cp behavior while
maintaining full backward compatibility.

Author: naoNao89

src/uu/cp/src/copydir.rs

@@ -89,8 +89,8 @@ fn skip_last<T>(mut iter: impl Iterator<Item = T>) -> impl Iterator<Item = T> {
 
 /// Paths that are invariant throughout the traversal when copying a directory.
 struct Context<'a> {
-    /// The current working directory at the time of starting the traversal.
-    current_dir: PathBuf,
+    /// The current working directory at the time of starting the traversal (if root is relative).
+    current_dir: Option<PathBuf>,
 
     /// The path to the parent of the source directory, if any.
     root_parent: Option<PathBuf>,
@@ -107,20 +107,21 @@ struct Context<'a> {
 
 impl<'a> Context<'a> {
     fn new(root: &'a Path, target: &'a Path) -> io::Result<Self> {
-        let current_dir = env::current_dir()?;
-        let root_path = current_dir.join(root);
         let target_is_file = target.is_file();
-        let root_parent = if target.exists() && !root.to_str().unwrap().ends_with("/.") {
-            root_path.parent().map(|p| p.to_path_buf())
-        } else if root == Path::new(".") && target.is_dir() {
-            // Special case: when copying current directory (.) to an existing directory,
-            // we don't want to use the parent path as root_parent because we want to
-            // copy the contents of the current directory directly into the target directory,
-            // not create a subdirectory with the current directory's name.
-            None
+
+        // Only get the current directory if root is a relative path.
+        // This avoids unnecessary getcwd() syscall failures when the current
+        // directory has been deleted (issue #9105), and matches GNU cp behavior.
+        let (current_dir, root_path) = if root.is_absolute() {
+            (None, root.to_path_buf())
         } else {
-            Some(root_path)
+            let cwd = env::current_dir()?;
+            let root_path = cwd.join(root);
+            (Some(cwd), root_path)
         };
+
+        let root_parent = Self::determine_root_parent(root, target, &root_path);
+
         Ok(Self {
             current_dir,
             root_parent,
@@ -129,6 +130,26 @@ impl<'a> Context<'a> {
             root,
         })
     }
+
+    /// Determine root_parent for path resolution during traversal.
+    fn determine_root_parent(root: &Path, target: &Path, root_path: &Path) -> Option<PathBuf> {
+        // Check if root path ends with "/." (e.g., "dir/.")
+        let root_ends_with_dot = root.to_str().is_some_and(|s| s.ends_with("/."));
+
+        if target.exists() && !root_ends_with_dot {
+            // Normal case: use parent of resolved root path
+            root_path.parent().map(|p| p.to_path_buf())
+        } else if root == Path::new(".") && target.is_dir() {
+            // Special case: when copying current directory (.) to an existing directory,
+            // we don't want to use the parent path as root_parent because we want to
+            // copy the contents of the current directory directly into the target directory,
+            // not create a subdirectory with the current directory's name.
+            None
+        } else {
+            // Use the root path itself when target doesn't exist yet
+            Some(root_path.to_path_buf())
+        }
+    }
 }
 
 /// Data needed to perform a single copy operation while traversing a directory.
@@ -188,7 +209,11 @@ impl Entry {
     ) -> Result<Self, StripPrefixError> {
         let source = source.as_ref();
         let source_relative = source.to_path_buf();
-        let source_absolute = context.current_dir.join(&source_relative);
+        let source_absolute = if let Some(ref current_dir) = context.current_dir {
+            current_dir.join(&source_relative)
+        } else {
+            source_relative.clone()
+        };
         let mut descendant =
             get_local_to_root_parent(&source_absolute, context.root_parent.as_deref())?;
         if no_target_dir {
@@ -217,9 +242,11 @@ impl Entry {
             // an extra level of nesting. For example, if we're in /home/user/source_dir
             // and copying . to /home/user/dest_dir, we want to copy source_dir/file.txt
             // to dest_dir/file.txt, not dest_dir/source_dir/file.txt.
-            if let Some(current_dir_name) = context.current_dir.file_name() {
-                if let Ok(stripped) = descendant.strip_prefix(current_dir_name) {
-                    descendant = stripped.to_path_buf();
+            if let Some(current_dir) = &context.current_dir {
+                if let Some(current_dir_name) = current_dir.file_name() {
+                    if let Ok(stripped) = descendant.strip_prefix(current_dir_name) {
+                        descendant = stripped.to_path_buf();
+                    }
                 }
             }
         }

tests/by-util/test_cp.rs

@@ -7227,3 +7227,54 @@ fn test_cp_recurse_verbose_output_with_symlink_already_exists() {
         .no_stderr()
         .stdout_is(output);
 }
+
+#[test]
+#[cfg(unix)]
+fn test_cp_absolute_paths_with_relative_source() {
+    // Test that cp works with absolute target when using relative source path
+    // This tests the path resolution logic in issue #9105
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    at.mkdir("src");
+    at.touch("src/file.txt");
+    at.mkdir("dst");
+
+    ucmd.arg("-r").arg("src").arg("dst").succeeds();
+
+    assert!(at.file_exists("dst/src/file.txt"));
+}
+
+#[test]
+#[cfg(unix)]
+fn test_cp_absolute_source_and_target() {
+    // Test that cp works with both absolute source and target paths
+    // This tests issue #9105 fix: avoiding getcwd() for absolute paths
+    use std::fs;
+    use std::time::{SystemTime, UNIX_EPOCH};
+
+    let temp_dir = std::env::temp_dir();
+    let timestamp = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap()
+        .as_nanos();
+    let src_dir = temp_dir.join(format!("cp_test_src_{}", timestamp));
+    let dst_dir = temp_dir.join(format!("cp_test_dst_{}", timestamp));
+
+    // Create source directory with test files
+    fs::create_dir_all(&src_dir).unwrap();
+    fs::write(src_dir.join("file1.txt"), "content1").unwrap();
+    fs::write(src_dir.join("file2.txt"), "content2").unwrap();
+
+    // Perform copy with absolute paths
+    let (_at, mut ucmd) = at_and_ucmd!();
+    ucmd.arg("-r").arg(&src_dir).arg(&dst_dir).succeeds();
+
+    // Verify files were copied
+    assert!(dst_dir.exists());
+    assert!(dst_dir.join("file1.txt").exists());
+    assert!(dst_dir.join("file2.txt").exists());
+
+    // Clean up
+    let _ = fs::remove_dir_all(&src_dir);
+    let _ = fs::remove_dir_all(&dst_dir);
+}