chore: fix build errors

Author: eduardomourar

.vscode/cspell.dictionaries/workspace.wordlist.txt

@@ -198,8 +198,10 @@ addrlen
 blocksize
 canonname
 chroot
+cmdline
 dlsym
 execvp
+fchmod
 fdatasync
 freeaddrinfo
 getaddrinfo
@@ -219,6 +221,7 @@ inodes
 isatty
 lchown
 pathlen
+reflink
 setgid
 setgroups
 settime
@@ -232,6 +235,8 @@ strcmp
 strerror
 strlen
 syncfs
+unflushed
+utimensat
 umask
 waitpid
 

src/uu/sort/src/sort.rs

@@ -2015,7 +2015,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         for (line_num, line_res) in buf_reader.split(b'\0').enumerate() {
             let line = line_res.map_err(|error| SortError::ReadFailed {
                 path: files0_from.clone(),
-                error,
+                error: uucore::error::wasi_normalize_read_error(error),
             })?;
             if line.as_slice() == STDIN_FILE.as_bytes() {
                 return Err(SortError::MinusInStdIn.into());

src/uu/touch/src/touch.rs

@@ -11,7 +11,7 @@ pub mod error;
 use clap::builder::{PossibleValue, ValueParser};
 use clap::{Arg, ArgAction, ArgGroup, ArgMatches, Command};
 use filetime::FileTime;
-#[cfg(any(not(unix), target_os = "redox"))]
+#[cfg(any(all(not(unix), not(target_os = "wasi")), target_os = "redox"))]
 use filetime::set_file_times;
 #[cfg(not(target_os = "wasi"))]
 use filetime::set_symlink_file_times;
@@ -649,14 +649,53 @@ fn update_times(
         set_times_by_path(path, atime, mtime)
     }
 
-    #[cfg(not(unix))]
+    #[cfg(target_os = "wasi")]
+    {
+        set_times_by_path_wasi(path, atime, mtime)
+    }
+
+    #[cfg(not(any(unix, target_os = "wasi")))]
     {
         set_file_times(path, atime, mtime).map_err_context(
             || translate!("touch-error-setting-times-of-path", "path" => path.quote()),
         )
     }
 }
 
+#[cfg(target_os = "wasi")]
+/// Set file times by path on WASI.
+///
+/// wasmtime's `utimensat` implementation refuses to set times on a
+/// follow-symlink path if it cannot `open()` the target (it returns
+/// `ENOTSUP`, since honoring the symlink race-freely would otherwise require
+/// an FD), even for files the caller owns but cannot open (e.g. mode 0).
+/// Native Unix `utimensat` has no such restriction. When the follow variant
+/// fails and the path is not itself a symlink, retry with
+/// `SYMLINK_NOFOLLOW`, which resolves the same file without opening it.
+fn set_times_by_path_wasi(path: &Path, atime: FileTime, mtime: FileTime) -> UResult<()> {
+    let timestamps = build_timestamps(atime, mtime);
+    let result = rustix::fs::utimensat(
+        rustix::fs::CWD,
+        path,
+        &timestamps,
+        rustix::fs::AtFlags::empty(),
+    );
+    let result = match result {
+        Err(_) if !fs::symlink_metadata(path).is_ok_and(|m| m.file_type().is_symlink()) => {
+            rustix::fs::utimensat(
+                rustix::fs::CWD,
+                path,
+                &timestamps,
+                rustix::fs::AtFlags::SYMLINK_NOFOLLOW,
+            )
+        }
+        other => other,
+    };
+    result
+        .map_err(|e| Error::from_raw_os_error(e.raw_os_error()))
+        .map_err_context(|| translate!("touch-error-setting-times-of-path", "path" => path.quote()))
+}
+
 #[cfg(any(unix, target_os = "wasi"))]
 /// Build a rustix `Timestamps` from the access and modification `FileTime`s,
 /// preserving the `UTIME_NOW`/`UTIME_OMIT` sentinels in the nanoseconds field.

src/uu/wc/src/wc.rs

@@ -820,7 +820,7 @@ fn files0_iter<'a>(
                     }
                 }
                 Err(e) => {
-                    let e = uucore::error::wasi_normalize_open_error(e);
+                    let e = uucore::error::wasi_normalize_read_error(e);
                     Err(e.map_err_context(
                         || translate!("wc-error-read-error", "path" => escape_name_wrapper(&err_path)),
                     ) as Box<dyn UError>)

src/uucore/src/lib/mods/error.rs

@@ -524,19 +524,23 @@ pub fn wasi_normalize_open_error(err: std::io::Error) -> std::io::Error {
 /// directory file descriptor (e.g. stdin redirected from a directory, or a
 /// raw `read()` on an fd already open on a directory).
 ///
-/// This is a distinct case from [`wasi_normalize_open_error`]: WASI reports
-/// `EISDIR` here (unlike the `EBADF` it reports for filesystem operations
-/// like `open` or `remove_file` on a directory), but under a different
-/// errno per preview version: `31` on preview 1, `29` on preview 2.
+/// This covers two distinct WASI error shapes for the same underlying
+/// condition: reading a directory fd that was already open when handed to
+/// us (e.g. stdin redirected from a directory) surfaces `EISDIR`, under a
+/// different errno per preview version (`31` on preview 1, `29` on preview
+/// 2); reading a directory fd that we opened ourselves via
+/// `std::fs::File::open` surfaces the same `EBADF` (errno `8`) that
+/// [`wasi_normalize_open_error`] handles for `open()`-time failures, because
+/// on WASI the directory check is deferred from `open` to the first `read`.
 ///
 /// This is a no-op on non-WASI targets.
 pub fn wasi_normalize_read_error(err: std::io::Error) -> std::io::Error {
     #[cfg(all(target_os = "wasi", target_env = "p1"))]
-    if err.raw_os_error() == Some(31) {
+    if matches!(err.raw_os_error(), Some(31) | Some(8)) {
         return std::io::Error::new(std::io::ErrorKind::IsADirectory, "Is a directory");
     }
     #[cfg(all(target_os = "wasi", target_env = "p2"))]
-    if err.raw_os_error() == Some(29) {
+    if matches!(err.raw_os_error(), Some(29) | Some(8)) {
         return std::io::Error::new(std::io::ErrorKind::IsADirectory, "Is a directory");
     }
     err

tests/by-util/test_du.rs

@@ -2391,7 +2391,7 @@ fn test_du_long_path_from_unreadable() {
 }
 
 #[test]
-#[cfg(unix)]
+#[cfg(all(unix, not(target_os = "android")))]
 fn test_du_hard_links_multiple_dirs_in_args() {
     let ts = TestScenario::new(util_name!());
     let at = &ts.fixtures;
@@ -2408,7 +2408,7 @@ fn test_du_hard_links_multiple_dirs_in_args() {
 }
 
 #[test]
-#[cfg(unix)]
+#[cfg(all(unix, not(target_os = "android")))]
 fn test_du_hard_links_multiple_links_in_args() {
     let ts = TestScenario::new(util_name!());
     let at = &ts.fixtures;

tests/by-util/test_install.rs

@@ -792,8 +792,12 @@ fn strip_source_file() -> PathBuf {
     BINARY
         .get_or_init(|| {
             let dir = std::env::temp_dir();
-            let source = dir.join("hello.rs");
-            let binary = dir.join("hello_bin");
+            // Include the PID so concurrent test processes (e.g. under `cargo
+            // nextest`, which runs each test in its own process) don't race
+            // on the same source/binary path.
+            let pid = process::id();
+            let source = dir.join(format!("hello-{pid}.rs"));
+            let binary = dir.join(format!("hello_bin-{pid}"));
             let mut file = File::create(&source).unwrap();
             file.write_all(b"fn main() {}").unwrap();
             process::Command::new("rustc")

tests/by-util/test_ls.rs

@@ -1498,7 +1498,7 @@ fn test_ls_long_dangling_symlink_color() {
     // Ensure dangling link name uses `or=` and target uses `mi=`.
     let name_regex =
         Regex::new(r"(?:\x1b\[[0-9;]*m)*\x1b\[([0-9;]*)mdir1/dangling_symlink\x1b\[0m").unwrap();
-    let target_path = regex::escape("../foo");
+    let target_path = regex::escape(&format!("..{}foo", std::path::MAIN_SEPARATOR));
     let target_pattern = format!(r"(?:\x1b\[[0-9;]*m)*\x1b\[([0-9;]*)m{target_path}\x1b\[0m");
     let target_regex = Regex::new(&target_pattern).unwrap();
 

tests/by-util/test_realpath.rs

@@ -176,9 +176,8 @@ fn test_realpath_logical_mode() {
 fn test_realpath_dangling() {
     let (at, mut ucmd) = at_and_ucmd!();
     at.symlink_file("nonexistent-file", "link");
-    ucmd.arg("link")
-        .succeeds()
-        .stdout_contains(at.plus_as_string("nonexistent-file\n"));
+    let expect = path_concat!(at.root_dir_resolved(), "nonexistent-file") + "\n";
+    ucmd.arg("link").succeeds().stdout_contains(expect);
 }
 
 #[test]

tests/by-util/test_sort.rs

@@ -1463,7 +1463,7 @@ fn test_batch_size_too_large() {
             "--batch-size argument '{large_batch_size}' too large"
         ));
 
-    #[cfg(target_os = "linux")]
+    #[cfg(all(target_os = "linux", not(wasi_runner)))]
     new_ucmd!()
         .arg(format!("--batch-size={large_batch_size}"))
         .fails_with_code(2)