Fix utime() syscall (#16460)

Fix off by factor 1000: ``FS.utime()`` expects mtime and atime in seconds.

``times == NULL`` is now correctly handled. ``utimes(path, NULL)``
updates atime and mtime to current time.

https://nodejs.org/api/fs.html#fsutimespath-atime-mtime-callback

Fixes: #16458
Signed-off-by: Christian Heimes <[email protected]>

Author: tiran

src/library_noderawfs.js

@@ -81,7 +81,7 @@ mergeInto(LibraryManager.library, {
       }
       fs.ftruncateSync.apply(void 0, arguments);
     },
-    utime: function() { fs.utimesSync.apply(void 0, arguments); },
+    utime: function(path, atime, mtime) { fs.utimesSync(path, atime/1000, mtime/1000); },
     open: function(path, flags, mode, suggestFD) {
       if (typeof flags == "string") {
         flags = VFS.modeStringToFlags(flags)

src/library_syscall.js

@@ -1046,13 +1046,18 @@ var SyscallsLibrary = {
     assert(flags === 0);
 #endif
     path = SYSCALLS.calculateAt(dirfd, path, true);
-    var seconds = {{{ makeGetValue('times', C_STRUCTS.timespec.tv_sec, 'i32') }}};
-    var nanoseconds = {{{ makeGetValue('times', C_STRUCTS.timespec.tv_nsec, 'i32') }}};
-    var atime = (seconds*1000) + (nanoseconds/(1000*1000));
-    times += {{{ C_STRUCTS.timespec.__size__ }}};
-    seconds = {{{ makeGetValue('times', C_STRUCTS.timespec.tv_sec, 'i32') }}};
-    nanoseconds = {{{ makeGetValue('times', C_STRUCTS.timespec.tv_nsec, 'i32') }}};
-    var mtime = (seconds*1000) + (nanoseconds/(1000*1000));
+    if (!times) {
+      var atime = Date.now();
+      var mtime = atime;
+    } else {
+      var seconds = {{{ makeGetValue('times', C_STRUCTS.timespec.tv_sec, 'i32') }}};
+      var nanoseconds = {{{ makeGetValue('times', C_STRUCTS.timespec.tv_nsec, 'i32') }}};
+      atime = (seconds*1000) + (nanoseconds/(1000*1000));
+      times += {{{ C_STRUCTS.timespec.__size__ }}};
+      seconds = {{{ makeGetValue('times', C_STRUCTS.timespec.tv_sec, 'i32') }}};
+      nanoseconds = {{{ makeGetValue('times', C_STRUCTS.timespec.tv_nsec, 'i32') }}};
+      mtime = (seconds*1000) + (nanoseconds/(1000*1000));
+    }
     FS.utime(path, atime, mtime);
     return 0;
   },

system/lib/wasmfs/syscalls.cpp

@@ -1006,10 +1006,15 @@ long __syscall_utimensat(int dirFD,
 
   // TODO: Set tv_nsec (nanoseconds) as well.
   // TODO: Handle tv_nsec being UTIME_NOW or UTIME_OMIT.
-  // TODO: Handle NULL times.
   // TODO: Check for write access to the file (see man page for specifics).
-  auto aSeconds = times[0].tv_sec;
-  auto mSeconds = times[1].tv_sec;
+  time_t aSeconds, mSeconds;
+  if (times == NULL) {
+    aSeconds = time(NULL);
+    mSeconds = aSeconds;
+  } else {
+    aSeconds = times[0].tv_sec;
+    mSeconds = times[1].tv_sec;
+  }
 
   auto locked = parsed.getFile()->locked();
   locked.setATime(aSeconds);

tests/utime/test_utime.c

@@ -11,6 +11,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <time.h>
 #include <unistd.h>
 #include <utime.h>
 #include <sys/stat.h>
@@ -32,20 +33,38 @@ void test() {
   // will fail
   struct utimbuf t = {1000000000, 1000000000};
 
-  utime("writeable", &t);
+  errno = 0;
+  int rv = utime("writeable", &t);
+  assert(rv == 0);
   assert(!errno);
   memset(&s, 0, sizeof s);
-  stat("writeable", &s);
+  rv = stat("writeable", &s);
+  assert(rv == 0);
   assert(s.st_atime == t.actime);
   assert(s.st_mtime == t.modtime);
 
+  // NULL sets atime and mtime to current time.
+  long now = time(NULL);
+  rv = utime("writeable", NULL);
+  assert(rv == 0);
+  memset(&s, 0, sizeof s);
+  stat("writeable", &s);
+  assert(s.st_atime == s.st_mtime);
+  long diff = s.st_atime - now;
+  if (abs(diff) > 5) {
+    fprintf(stderr, "st_atime: %li, now: %li, diff: %li\n ", s.st_atime, now, diff);
+    assert(abs(diff) <= 5);
+  }
+
   // write permissions aren't checked when setting node
   // attributes unless the user uid isn't the owner (so
   // therefor, this should work fine)
-  utime("unwriteable", &t);
+  rv = utime("unwriteable", &t);
+  assert(rv == 0);
   assert(!errno);
   memset(&s, 0, sizeof s);
-  stat("unwriteable", &s);
+  rv = stat("unwriteable", &s);
+  assert(rv == 0);
   assert(s.st_atime == t.actime);
   assert(s.st_mtime == t.modtime);