cp: preserve file timestamps on WASI

Author: DePasqualeOrg

.github/workflows/wasi.yml

@@ -70,6 +70,8 @@ jobs:
         cargo test --test tests -- \
           test_base32:: test_base64:: test_basenc:: test_basename:: \
           test_cp::test_cp_arg_symlink \
+          test_cp::test_cp_wasi_preserve_file_timestamps \
+          test_cp::test_cp_wasi_preserve_timestamps_through_destination_symlink \
           test_comm:: test_cut:: test_dirname:: test_echo:: \
           test_expand:: test_factor:: test_false:: test_fold:: \
           test_head:: test_link:: test_ln:: test_nl:: test_numfmt:: \

src/uu/cp/src/cp.rs

@@ -28,6 +28,8 @@ use nix::sys::stat::{Mode, SFlag, dev_t, mknod as nix_mknod, mode_t};
 use thiserror::Error;
 
 use platform::copy_on_write;
+#[cfg(target_os = "wasi")]
+use platform::{SourceTimestamps, set_timestamps};
 use uucore::backup_control::backup_would_destroy_source;
 use uucore::display::Quotable;
 use uucore::error::{UError, UResult, UUsageError, set_exit_code, strip_errno};
@@ -2653,6 +2655,17 @@ fn copy_file(
         })?
     };
 
+    #[cfg(target_os = "wasi")]
+    let source_timestamps = if !source_is_symlink
+        && source_metadata.file_type().is_file()
+        && options.copy_mode != CopyMode::SymLink
+        && matches!(options.attributes.timestamps, Preserve::Yes { .. })
+    {
+        Some(SourceTimestamps::from_metadata(&source_metadata)?)
+    } else {
+        None
+    };
+
     let dest_metadata = dest.symlink_metadata().ok();
 
     let dest_permissions = calculate_dest_permissions(
@@ -2704,9 +2717,11 @@ fn copy_file(
             .ok()
             .filter(|p| p.exists())
             .unwrap_or_else(|| source.to_path_buf());
-        copy_attributes(
+        copy_attributes_after_copy(
             &src_for_attrs,
             dest,
+            #[cfg(target_os = "wasi")]
+            source_timestamps,
             &options.attributes,
             false,
             options.set_selinux_context,
@@ -2718,9 +2733,11 @@ fn copy_file(
         // copy function (see `copy_stream` under platform/linux.rs).
         Ok(())
     } else {
-        copy_attributes(
+        copy_attributes_after_copy(
             source,
             dest,
+            #[cfg(target_os = "wasi")]
+            source_timestamps,
             &options.attributes,
             false,
             options.set_selinux_context,
@@ -2753,6 +2770,40 @@ fn copy_file(
     Ok(())
 }
 
+fn copy_attributes_after_copy(
+    source: &Path,
+    dest: &Path,
+    #[cfg(target_os = "wasi")] source_timestamps: Option<SourceTimestamps>,
+    attributes: &Attributes,
+    dest_is_freshly_created_dir: bool,
+    skip_selinux_xattr: bool,
+) -> CopyResult<()> {
+    #[cfg(target_os = "wasi")]
+    if let Some(source_timestamps) = source_timestamps {
+        let timestamps = attributes.timestamps;
+        let mut remaining_attributes = *attributes;
+        remaining_attributes.timestamps = Preserve::No { explicit: false };
+        copy_attributes(
+            source,
+            dest,
+            &remaining_attributes,
+            dest_is_freshly_created_dir,
+            skip_selinux_xattr,
+        )?;
+        return handle_preserve(timestamps, || {
+            set_timestamps(source_timestamps, dest).map_err(CpError::from)
+        });
+    }
+
+    copy_attributes(
+        source,
+        dest,
+        attributes,
+        dest_is_freshly_created_dir,
+        skip_selinux_xattr,
+    )
+}
+
 fn is_stream(metadata: &Metadata) -> bool {
     #[cfg(unix)]
     {

src/uu/cp/src/platform/mod.rs

@@ -37,4 +37,4 @@ pub(crate) use self::other::copy_on_write;
 #[cfg(target_os = "wasi")]
 mod wasi;
 #[cfg(target_os = "wasi")]
-pub(crate) use self::wasi::create_symlink;
+pub(crate) use self::wasi::{SourceTimestamps, create_symlink, set_timestamps};

src/uu/cp/src/platform/wasi.rs

@@ -3,9 +3,46 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
+use std::fs::Metadata;
 use std::io;
 use std::path::Path;
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use rustix::fs::{AtFlags, CWD, Timespec, Timestamps, utimensat};
+
+#[derive(Clone, Copy)]
+pub(crate) struct SourceTimestamps {
+    accessed: SystemTime,
+    modified: SystemTime,
+}
+
+impl SourceTimestamps {
+    pub(crate) fn from_metadata(metadata: &Metadata) -> io::Result<Self> {
+        Ok(Self {
+            accessed: metadata.accessed()?,
+            modified: metadata.modified()?,
+        })
+    }
+}
 
 pub(crate) fn create_symlink(source: &Path, dest: &Path) -> io::Result<()> {
     rustix::fs::symlink(source, dest).map_err(io::Error::from)
 }
+
+pub(crate) fn set_timestamps(source_timestamps: SourceTimestamps, dest: &Path) -> io::Result<()> {
+    let timestamps = Timestamps {
+        last_access: to_timespec(source_timestamps.accessed)?,
+        last_modification: to_timespec(source_timestamps.modified)?,
+    };
+    utimensat(CWD, dest, &timestamps, AtFlags::empty()).map_err(io::Error::from)
+}
+
+fn to_timespec(time: SystemTime) -> io::Result<Timespec> {
+    let duration = time
+        .duration_since(UNIX_EPOCH)
+        .map_err(|error| io::Error::new(io::ErrorKind::Unsupported, error))?;
+    Ok(Timespec {
+        tv_sec: duration.as_secs() as i64,
+        tv_nsec: duration.subsec_nanos() as i32,
+    })
+}

tests/by-util/test_cp.rs

@@ -2576,6 +2576,62 @@ fn test_cp_preserve_timestamps() {
     assert_eq!(creation, creation2);
 }
 
+#[test]
+#[cfg(wasi_runner)]
+fn test_cp_wasi_preserve_file_timestamps() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let ts = time::OffsetDateTime::now_utc();
+    let previous_atime = FileTime::from_unix_time(ts.unix_timestamp() - 7200, ts.nanosecond());
+    let previous_mtime = FileTime::from_unix_time(ts.unix_timestamp() - 3600, ts.nanosecond());
+    filetime::set_file_times(
+        at.plus_as_string(TEST_HELLO_WORLD_SOURCE),
+        previous_atime,
+        previous_mtime,
+    )
+    .unwrap();
+
+    ucmd.arg(TEST_HELLO_WORLD_SOURCE)
+        .arg("--preserve=timestamps")
+        .arg(TEST_HOW_ARE_YOU_SOURCE)
+        .succeeds();
+
+    let metadata = std_fs::metadata(at.plus(TEST_HOW_ARE_YOU_SOURCE)).unwrap();
+    assert_eq!(FileTime::from_last_access_time(&metadata), previous_atime);
+    assert_eq!(
+        FileTime::from_last_modification_time(&metadata),
+        previous_mtime
+    );
+}
+
+#[test]
+#[cfg(wasi_runner)]
+fn test_cp_wasi_preserve_timestamps_through_destination_symlink() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let ts = time::OffsetDateTime::now_utc();
+    let source_atime = FileTime::from_unix_time(ts.unix_timestamp() - 7200, ts.nanosecond());
+    let source_mtime = FileTime::from_unix_time(ts.unix_timestamp() - 3600, ts.nanosecond());
+
+    at.write("source", "new contents");
+    at.write("target", "old contents");
+    at.relative_symlink_file("target", "destination");
+    filetime::set_file_times(at.plus("source"), source_atime, source_mtime).unwrap();
+
+    ucmd.args(&["--preserve=timestamps", "source", "destination"])
+        .succeeds();
+
+    assert!(at.is_symlink("destination"));
+    let target_metadata = std_fs::metadata(at.plus("target")).unwrap();
+    assert_eq!(
+        FileTime::from_last_access_time(&target_metadata),
+        source_atime
+    );
+    assert_eq!(
+        FileTime::from_last_modification_time(&target_metadata),
+        source_mtime
+    );
+    assert_eq!(at.read("target"), "new contents");
+}
+
 #[test]
 #[cfg(any(target_os = "linux", target_os = "android"))]
 fn test_cp_no_preserve_timestamps() {