Add integration tests for cat/sort/tail/touch + underlying fixes

Author: DePasqualeOrg

.github/workflows/wasi.yml

@@ -50,18 +50,17 @@ jobs:
         # Tests incompatible with WASI are annotated with
         # #[cfg_attr(wasi_runner, ignore)] in the test source files.
         # TODO: add integration tests for these tools as WASI support is extended:
-        #   arch b2sum cat cksum cp csplit date dir dircolors fmt join ln
+        #   arch b2sum cksum cp csplit date dir dircolors fmt join ln
         #   ls md5sum mkdir mv nproc pathchk pr printenv ptx pwd readlink
         #   realpath rm rmdir seq sha1sum sha224sum sha256sum sha384sum
-        #   sha512sum shred sleep sort split tail touch tsort uname uniq
-        #   vdir yes
+        #   sha512sum shred sleep split tsort uname uniq vdir yes
         UUTESTS_BINARY_PATH="$(pwd)/target/wasm32-wasip1/debug/coreutils.wasm" \
         UUTESTS_WASM_RUNNER=wasmtime \
         cargo test --test tests -- \
           test_base32:: test_base64:: test_basenc:: test_basename:: \
-          test_comm:: test_cut:: test_dirname:: test_echo:: \
+          test_cat:: test_comm:: test_cut:: test_dirname:: test_echo:: \
           test_expand:: test_factor:: test_false:: test_fold:: \
           test_head:: test_link:: test_nl:: test_numfmt:: \
-          test_od:: test_paste:: test_printf:: test_shuf:: test_sum:: \
-          test_tee:: test_tr:: test_true:: test_truncate:: \
-          test_unexpand:: test_unlink:: test_wc::
+          test_od:: test_paste:: test_printf:: test_shuf:: test_sort:: \
+          test_sum:: test_tail:: test_tee:: test_touch:: test_tr:: \
+          test_true:: test_truncate:: test_unexpand:: test_unlink:: test_wc::

Cargo.lock

@@ -6,7 +6,7 @@ To find all annotated tests: `grep -rn 'wasi_runner, ignore' tests/`
 
 ## Tools not yet covered by integration tests
 
-arch, b2sum, cat, cksum, cp, csplit, date, dir, dircolors, fmt, join, ln, ls, md5sum, mkdir, mv, nproc, pathchk, pr, printenv, ptx, pwd, readlink, realpath, rm, rmdir, seq, sha1sum, sha224sum, sha256sum, sha384sum, sha512sum, shred, sleep, sort, split, tail, touch, tsort, uname, uniq, vdir, yes
+arch, b2sum, cksum, cp, csplit, date, dir, dircolors, fmt, join, ln, ls, md5sum, mkdir, mv, nproc, pathchk, pr, printenv, ptx, pwd, readlink, realpath, rm, rmdir, seq, sha1sum, sha224sum, sha256sum, sha384sum, sha512sum, shred, sleep, split, tsort, uname, uniq, vdir, yes
 
 ## WASI sandbox: host paths not visible
 
@@ -31,3 +31,51 @@ WASI does not support spawning child processes. Tests that shell out to other co
 ## WASI: stdin file position not preserved through wasmtime
 
 When stdin is a seekable file, wasmtime does not preserve the file position between the host and guest. Tests that validate stdin offset behavior after `head` reads are skipped.
+
+## WASI: read_link fails under wasmtime via spawned test harness
+
+When the WASI binary is spawned via `std::process::Command` from the cargo-test harness, `fs::read_link` (and operations that follow symlinks, such as opening a symlink to a FIFO or traversing a symlink loop) can return `EPERM` on absolute paths — paths that work when wasmtime is invoked directly. Individual symptom tests skipped under this umbrella are annotated with narrower reasons describing the observed errno mismatch.
+
+## WASI: no Unix domain socket support
+
+WASI does not support Unix domain sockets. Tests that create or read from `AF_UNIX` sockets are skipped.
+
+## WASI: no locale data
+
+The WASI sandbox does not ship locale data, so `setlocale`/`LC_ALL` have no effect and sorting falls back to byte comparison. Tests that depend on locale-aware collation or month-name translation are skipped.
+
+## WASI: tail follow mode disabled
+
+`tail -f` / `tail -F` (follow mode) requires change-notification mechanisms (`inotify`, `kqueue`) and signal handling that WASI does not provide, so follow is disabled on WASI and a warning is emitted. Tests that exercise follow behaviour are skipped.
+
+## WASI: cannot detect unsafe overwrite
+
+`is_unsafe_overwrite` (used by `cat` to detect input-is-output situations) is stubbed to return `false` on WASI because the required `stat` / device-and-inode comparison is not available. Tests that assert this error path are skipped.
+
+## WASI: pre-epoch timestamps not representable
+
+WASI Preview 1 `Timestamp` is a `u64` nanosecond count since the Unix epoch, so `path_filestat_set_times` (and therefore `touch -t` with a two-digit year ≥ 69) cannot express dates before 1970. Tests that set pre-epoch timestamps are skipped.
+
+## WASI: no timezone database
+
+wasi-libc does not ship tzdata, so `TZ` is not honoured and timezone-dependent validation (e.g. `touch -t` rejecting a nonexistent local time during a DST transition) does not happen. Tests that rely on this are skipped.
+
+## WASI: guest root is a writable preopen
+
+The test harness maps the per-test working directory as the guest's `/`. That makes `/` writable inside the guest, so GNU-style protections against operating on the system root (e.g. `touch /` failing) cannot be exercised. Tests that assert these protections are skipped.
+
+## WASI: `touch -` (stdout) unsupported
+
+On WASI, `touch -` returns `UnsupportedPlatformFeature` because the guest cannot reliably locate the host file backing stdout. Tests that exercise `touch -` are skipped.
+
+## WASI: errno/error-message mismatches
+
+Several error paths surface different errno values (and therefore different error messages) through wasmtime than on POSIX. Observed cases:
+
+- Opening a directory as a file returns `EBADF` rather than `EISDIR`.
+- Redirecting a directory into stdin returns `ENOENT` rather than `EISDIR`.
+- Filesystem permission errors surface as `ENOENT` rather than `EACCES`.
+- Symlink-loop traversal does not reliably surface `ELOOP` ("Too many levels of symbolic links").
+- Opening a symlink-to-directory does not reliably surface `EISDIR`.
+
+Tests that assert specific error text for these paths are skipped.

docs/src/wasi-test-gaps.md

@@ -9,7 +9,11 @@ pub use self::unix::is_unsafe_overwrite;
 #[cfg(windows)]
 pub use self::windows::is_unsafe_overwrite;
 
-// WASI: no fstat-based device/inode checks available; assume safe.
+// WASI: when stdout is inherited from a host file descriptor, wasmtime
+// reports its fstat as all-zero (st_dev == st_ino == 0), so the dev/inode
+// comparison against any input file descriptor can never match. There is
+// no reliable way to detect unsafe overwrite here; assume safe rather than
+// risk a spurious error.
 #[cfg(target_os = "wasi")]
 pub fn is_unsafe_overwrite<I, O>(_input: &I, _output: &O) -> bool {
     false

src/uu/cat/src/platform/mod.rs

@@ -43,6 +43,9 @@ fluent = { workspace = true }
 exacl = { workspace = true, optional = true }
 nix = { workspace = true, features = ["fs"] }
 
+[target.'cfg(target_os = "wasi")'.dependencies]
+rustix = { workspace = true, features = ["fs"] }
+
 [[bin]]
 name = "cp"
 path = "src/main.rs"

src/uu/cp/Cargo.toml

@@ -897,12 +897,7 @@ impl Attributes {
         #[cfg(unix)]
         ownership: Preserve::Yes { required: true },
         mode: Preserve::Yes { required: true },
-        // WASI: filetime panics in from_last_{access,modification}_time,
-        // so timestamps cannot be preserved. Mark as optional so -a works.
-        #[cfg(not(target_os = "wasi"))]
         timestamps: Preserve::Yes { required: true },
-        #[cfg(target_os = "wasi")]
-        timestamps: Preserve::Yes { required: false },
         context: {
             #[cfg(feature = "feat_selinux")]
             {
@@ -1843,11 +1838,37 @@ pub(crate) fn copy_attributes(
     })?;
 
     handle_preserve(attributes.timestamps, || -> CopyResult<()> {
-        // filetime's WASI backend panics in from_last_{access,modification}_time,
-        // so return ENOTSUP. handle_preserve silently suppresses ENOTSUP for
-        // optional preservation (-a) and reports it for required (--preserve=timestamps).
         #[cfg(target_os = "wasi")]
-        return Err(io::Error::from_raw_os_error(libc::EOPNOTSUPP).into());
+        {
+            // `filetime`'s WASI backend panics in
+            // `from_last_{access,modification}_time`. Reach `utimensat` directly
+            // through `rustix`, converting `SystemTime` → `Timespec` via
+            // `UNIX_EPOCH` (which matches the `path_filestat_set_times` contract).
+            use std::time::UNIX_EPOCH;
+            let to_timespec = |t: std::time::SystemTime| -> io::Result<rustix::fs::Timespec> {
+                // Pre-epoch source times can't be represented by WASI's
+                // `path_filestat_set_times` (unsigned nanosecond count).
+                let d = t
+                    .duration_since(UNIX_EPOCH)
+                    .map_err(|e| io::Error::new(io::ErrorKind::Unsupported, e))?;
+                Ok(rustix::fs::Timespec {
+                    tv_sec: d.as_secs() as _,
+                    tv_nsec: d.subsec_nanos() as _,
+                })
+            };
+            let timestamps = rustix::fs::Timestamps {
+                last_access: to_timespec(source_metadata.accessed()?)?,
+                last_modification: to_timespec(source_metadata.modified()?)?,
+            };
+            let flags = if dest.is_symlink() {
+                rustix::fs::AtFlags::SYMLINK_NOFOLLOW
+            } else {
+                rustix::fs::AtFlags::empty()
+            };
+            rustix::fs::utimensat(rustix::fs::CWD, dest, &timestamps, flags)
+                .map_err(io::Error::from)?;
+            Ok(())
+        }
 
         #[cfg(not(target_os = "wasi"))]
         {
@@ -1937,20 +1958,14 @@ fn symlink_file(
     }
     #[cfg(target_os = "wasi")]
     {
-        use std::ffi::CString;
-        use std::os::wasi::ffi::OsStrExt;
-        let src_c = CString::new(source.as_os_str().as_bytes())
-            .map_err(|e| CpError::Error(e.to_string()))?;
-        let dst_c =
-            CString::new(dest.as_os_str().as_bytes()).map_err(|e| CpError::Error(e.to_string()))?;
-        if unsafe { libc::symlink(src_c.as_ptr(), dst_c.as_ptr()) } != 0 {
-            return Err(CpError::IoErrContext(
-                io::Error::last_os_error(),
+        rustix::fs::symlink(source, dest).map_err(|e| {
+            CpError::IoErrContext(
+                io::Error::from(e),
                 translate!("cp-error-cannot-create-symlink",
                            "dest" => get_filename(dest).unwrap_or("?").quote(),
                            "source" => get_filename(source).unwrap_or("?").quote()),
-            ));
-        }
+            )
+        })?;
     }
     if let Ok(file_info) = FileInformation::from_path(dest, false) {
         symlinked_files.insert(file_info);

src/uu/cp/src/cp.rs

@@ -2154,11 +2154,14 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
             .map(PathBuf::from)
             .or_else(|| env::var_os("TMPDIR").map(PathBuf::from))
             .unwrap_or_else(|| {
-                // env::temp_dir() panics on WASI; default to /tmp
                 #[cfg(target_os = "wasi")]
-                return PathBuf::from("/tmp");
+                {
+                    uucore::fs::wasi_default_tmp_dir()
+                }
                 #[cfg(not(target_os = "wasi"))]
-                env::temp_dir()
+                {
+                    env::temp_dir()
+                }
             }),
     );
 

src/uu/sort/src/sort.rs

@@ -30,6 +30,8 @@ fluent = { workspace = true }
 
 [target.'cfg(unix)'.dependencies]
 libc = { workspace = true }
+
+[target.'cfg(any(unix, target_os = "wasi"))'.dependencies]
 rustix = { workspace = true, features = ["fs"] }
 
 [dev-dependencies]

src/uu/touch/Cargo.toml

@@ -10,7 +10,9 @@ pub mod error;
 
 use clap::builder::{PossibleValue, ValueParser};
 use clap::{Arg, ArgAction, ArgGroup, ArgMatches, Command};
-use filetime::{FileTime, set_file_times, set_symlink_file_times};
+use filetime::FileTime;
+#[cfg(not(target_os = "wasi"))]
+use filetime::{set_file_times, set_symlink_file_times};
 use jiff::civil::Time;
 use jiff::fmt::strtime;
 use jiff::tz::TimeZone;
@@ -631,6 +633,47 @@ fn try_futimens_via_write_fd(path: &Path, atime: FileTime, mtime: FileTime) -> s
     futimens(&file, &timestamps).map_err(|e| Error::from_raw_os_error(e.raw_os_error()))
 }
 
+/// WASI replacement for `filetime::set_file_times`.
+///
+/// The `filetime` crate has an unimplemented stub on `wasm32-wasi`. WASI
+/// supports setting both atime and mtime via `utimensat`, which we reach
+/// through `rustix`.
+#[cfg(target_os = "wasi")]
+fn set_file_times(path: &Path, atime: FileTime, mtime: FileTime) -> std::io::Result<()> {
+    wasi_utimensat(path, atime, mtime, false)
+}
+
+/// WASI replacement for `filetime::set_symlink_file_times`.
+#[cfg(target_os = "wasi")]
+fn set_symlink_file_times(path: &Path, atime: FileTime, mtime: FileTime) -> std::io::Result<()> {
+    wasi_utimensat(path, atime, mtime, true)
+}
+
+#[cfg(target_os = "wasi")]
+fn wasi_utimensat(
+    path: &Path,
+    atime: FileTime,
+    mtime: FileTime,
+    no_follow: bool,
+) -> std::io::Result<()> {
+    let timestamps = rustix::fs::Timestamps {
+        last_access: rustix::fs::Timespec {
+            tv_sec: atime.unix_seconds(),
+            tv_nsec: atime.nanoseconds() as _,
+        },
+        last_modification: rustix::fs::Timespec {
+            tv_sec: mtime.unix_seconds(),
+            tv_nsec: mtime.nanoseconds() as _,
+        },
+    };
+    let flags = if no_follow {
+        rustix::fs::AtFlags::SYMLINK_NOFOLLOW
+    } else {
+        rustix::fs::AtFlags::empty()
+    };
+    rustix::fs::utimensat(rustix::fs::CWD, path, &timestamps, flags).map_err(Error::from)
+}
+
 /// Get metadata of the provided path
 /// If `follow` is `true`, the function will try to follow symlinks. Errors if the symlink is dangling, otherwise defaults to symlink metadata.
 /// If `follow` is `false`, the function will return metadata of the symlink itself
@@ -648,6 +691,19 @@ fn stat(path: &Path, follow: bool) -> std::io::Result<(FileTime, FileTime)> {
         fs::symlink_metadata(path)?
     };
 
+    // `FileTime::from_last_{access,modification}_time` is unimplemented on
+    // `wasm32-wasi`, so go through `Metadata::{accessed, modified}` (which
+    // return `SystemTime`) and convert via `FileTime::from_system_time`.
+    #[cfg(target_os = "wasi")]
+    {
+        let atime = metadata.accessed()?;
+        let mtime = metadata.modified()?;
+        Ok((
+            FileTime::from_system_time(atime),
+            FileTime::from_system_time(mtime),
+        ))
+    }
+    #[cfg(not(target_os = "wasi"))]
     Ok((
         FileTime::from_last_access_time(&metadata),
         FileTime::from_last_modification_time(&metadata),