Merge branch 'main' into fix-suf-errors

Author: sbentmar

src/uu/cp/src/cp.rs

@@ -2510,11 +2510,13 @@ fn copy_file(
     }
 
     if options.dereference(source_in_command_line) {
-        if let Ok(src) = canonicalize(source, MissingHandling::Normal, ResolveMode::Physical) {
-            if src.exists() {
-                copy_attributes(&src, dest, &options.attributes)?;
-            }
-        }
+        // Try to canonicalize, but if it fails (e.g., due to inaccessible parent directories),
+        // fall back to the original source path
+        let src_for_attrs = canonicalize(source, MissingHandling::Normal, ResolveMode::Physical)
+            .ok()
+            .filter(|p| p.exists())
+            .unwrap_or_else(|| source.to_path_buf());
+        copy_attributes(&src_for_attrs, dest, &options.attributes)?;
     } else if source_is_stream && !source.exists() {
         // Some stream files may not exist after we have copied it,
         // like anonymous pipes. Thus, we can't really copy its

src/uu/du/src/du.rs

@@ -501,10 +501,7 @@ fn safe_du(
 
         // Handle inodes
         if let Some(inode) = this_stat.inode {
-            if seen_inodes.contains(&inode) && (!options.count_links || !options.all) {
-                if options.count_links && !options.all {
-                    my_stat.inodes += 1;
-                }
+            if seen_inodes.contains(&inode) && !options.count_links {
                 continue;
             }
             seen_inodes.insert(inode);
@@ -660,13 +657,7 @@ fn du_regular(
 
                             if let Some(inode) = this_stat.inode {
                                 // Check if the inode has been seen before and if we should skip it
-                                if seen_inodes.contains(&inode)
-                                    && (!options.count_links || !options.all)
-                                {
-                                    // If `count_links` is enabled and `all` is not, increment the inode count
-                                    if options.count_links && !options.all {
-                                        my_stat.inodes += 1;
-                                    }
+                                if seen_inodes.contains(&inode) && !options.count_links {
                                     // Skip further processing for this inode
                                     continue;
                                 }

src/uu/nice/src/nice.rs

@@ -3,13 +3,14 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-// spell-checker:ignore (ToDO) getpriority execvp setpriority nstr PRIO cstrs ENOENT
+// spell-checker:ignore (ToDO) getpriority setpriority nstr PRIO
 
 use clap::{Arg, ArgAction, Command};
-use libc::{PRIO_PROCESS, c_char, c_int, execvp};
-use std::ffi::{CString, OsString};
-use std::io::{Error, Write};
-use std::ptr;
+use libc::PRIO_PROCESS;
+use std::ffi::OsString;
+use std::io::{Error, ErrorKind, Write};
+use std::os::unix::process::CommandExt;
+use std::process;
 
 use uucore::translate;
 use uucore::{
@@ -156,21 +157,15 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         }
     }
 
-    let cstrs: Vec<CString> = matches
-        .get_many::<String>(options::COMMAND)
-        .unwrap()
-        .map(|x| CString::new(x.as_bytes()).unwrap())
-        .collect();
+    let mut cmd_iter = matches.get_many::<String>(options::COMMAND).unwrap();
+    let cmd = cmd_iter.next().unwrap();
+    let args: Vec<&String> = cmd_iter.collect();
 
-    let mut args: Vec<*const c_char> = cstrs.iter().map(|s| s.as_ptr()).collect();
-    args.push(ptr::null::<c_char>());
-    unsafe {
-        execvp(args[0], args.as_mut_ptr());
-    }
+    let err = process::Command::new(cmd).args(args).exec();
 
-    show_error!("execvp: {}", Error::last_os_error());
+    show_error!("{}: {}", cmd, err);
 
-    let exit_code = if Error::last_os_error().raw_os_error().unwrap() as c_int == libc::ENOENT {
+    let exit_code = if err.kind() == ErrorKind::NotFound {
         127
     } else {
         126

tests/by-util/test_du.rs

@@ -804,6 +804,44 @@ fn test_du_inodes_with_count_links_all() {
     assert_eq!(result_seq, ["1\td/d", "1\td/f", "1\td/h", "4\td"]);
 }
 
+#[cfg(not(target_os = "android"))]
+#[test]
+fn test_du_count_links_hardlinks_separately() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+
+    at.mkdir("dir");
+    at.touch("dir/file");
+    at.hard_link("dir/file", "dir/hard_link");
+
+    let result_without_l = ts.ucmd().arg("-b").arg("dir").succeeds();
+    let size_without_l: u64 = result_without_l
+        .stdout_str()
+        .split('\t')
+        .next()
+        .unwrap()
+        .trim()
+        .parse()
+        .unwrap();
+
+    for arg in ["-l", "--count-links"] {
+        let result_with_l = ts.ucmd().arg("-b").arg(arg).arg("dir").succeeds();
+        let size_with_l: u64 = result_with_l
+            .stdout_str()
+            .split('\t')
+            .next()
+            .unwrap()
+            .trim()
+            .parse()
+            .unwrap();
+
+        assert!(
+            size_with_l >= size_without_l,
+            "With {arg}, size ({size_with_l}) should be >= size without -l ({size_without_l})"
+        );
+    }
+}
+
 #[test]
 fn test_du_h_flag_empty_file() {
     new_ucmd!()