diff --git a/internal/vm/dir.go b/internal/vm/dir.go index 5a555787..f7436b43 100644 --- a/internal/vm/dir.go +++ b/internal/vm/dir.go @@ -151,6 +151,22 @@ func (vm *VM) registerDir() { } return object.IntValue(0) }) + // Dir.chroot(path) changes the process root to path and returns 0 (dir.c + // dir_s_chroot: check_dirname then chroot(2), rb_sys_fail_path on -1). A + // non-privileged process cannot chroot, so the real call fails with + // Errno::EPERM — the behaviour the spec exercises as a regular user. The path + // is a rb_get_path argument (#to_path). chrootFn is a platform seam so the + // error mapping is testable without re-rooting the test process. + def("chroot", func(vm *VM, _ object.Value, args []object.Value, _ *Proc) object.Value { + if len(args) != 1 { + raise("ArgumentError", "wrong number of arguments (given %d, expected 1)", len(args)) + } + p := pathArg(vm, args[0]) + if err := chrootFn(p); err != nil { + raiseChrootErr(err, p) + } + return object.IntValue(0) + }) // Dir.each_child(path) yields each child name (no "." / ".."); Dir.foreach(path) // yields every entry including "." and "..". Both return nil after a block and, // with no block, an Enumerator over the snapshot names (MRI dir.c) — whose #size @@ -390,6 +406,24 @@ func dirPwd(_ *VM, _ object.Value, _ []object.Value, _ *Proc) object.Value { return object.NewString(toSlash(wd)) } +// raiseChrootErr maps a chroot(2) failure to the MRI errno Dir.chroot raises via +// rb_sys_fail_path: a permission failure (the ordinary case for a non-root +// process, and what macOS returns even for a missing path) is Errno::EPERM, a +// missing directory Errno::ENOENT, a non-directory Errno::ENOTDIR, and anything +// else falls back to Errno::EPERM. Each is a SystemCallError, as the spec checks. +func raiseChrootErr(err error, path string) { + switch { + case os.IsPermission(err): + raise("Errno::EPERM", "Operation not permitted @ dir_s_chroot - %s", path) + case os.IsNotExist(err): + raise("Errno::ENOENT", "No such file or directory @ dir_s_chroot - %s", path) + case errors.Is(err, syscall.ENOTDIR): + raise("Errno::ENOTDIR", "Not a directory @ dir_s_chroot - %s", path) + default: + raise("Errno::EPERM", "Operation not permitted @ dir_s_chroot - %s", path) + } +} + // includeDirEnumerable mixes the prelude-defined Enumerable module into Dir. It // runs post-prelude (registerDir itself runs before the prelude, so the module // does not exist yet there), driven from registerFileStat which also runs after diff --git a/internal/vm/file.go b/internal/vm/file.go index 32caec07..a746c7b8 100644 --- a/internal/vm/file.go +++ b/internal/vm/file.go @@ -344,7 +344,7 @@ func (vm *VM) registerFile() { return object.IntValue(int64(len(paths))) }) def("utime", func(vm *VM, _ object.Value, args []object.Value, _ *Proc) object.Value { - at, mt := timeArgUnix(args[0]), timeArgUnix(args[1]) + at, mt := timeArgUnixOrNow(args[0]), timeArgUnixOrNow(args[1]) paths := args[2:] for _, a := range paths { p := pathArg(vm, a) @@ -354,6 +354,31 @@ func (vm *VM) registerFile() { } return object.IntValue(int64(len(paths))) }) + // File.lutime(atime, mtime, *paths) sets each path's access/modification time + // like File.utime but WITHOUT following a final symbolic link, returning the + // number of paths (file.c utime_internal with follow=TRUE -> AT_SYMLINK_NOFOLLOW). + // A nil atime/mtime means the current time; lutimesFn is the POSIX seam. + def("lutime", func(vm *VM, _ object.Value, args []object.Value, _ *Proc) object.Value { + if len(args) < 2 { + raise("ArgumentError", "wrong number of arguments (given %d, expected 2+)", len(args)) + } + at, mt := timeArgUnixOrNow(args[0]), timeArgUnixOrNow(args[1]) + paths := args[2:] + for _, a := range paths { + p := pathArg(vm, a) + if err := lutimesFn(p, at, mt); err != nil { + raise("Errno::ENOENT", "No such file or directory @ utime_failed - %s", p) + } + } + return object.IntValue(int64(len(paths))) + }) + // NOTE: File.mkfifo (syscall.Mkfifo) is deliberately left unregistered. It is + // straightforward and MRI-verified, but wiring it up REGRESSES core/file: + // open_spec's "on a FIFO" example opens both ends of the FIFO from two Ruby + // threads, and rbgo's blocking File.open (io.go) deadlocks the interpreter on + // the FIFO open(2) handshake — hanging the whole spec file and losing its ~55 + // passing examples. Add File.mkfifo only once File.open on a FIFO no longer + // blocks the scheduler (an io.go / thread-concurrency fix the io agent owns). // File.umask([mask]) reads (and optionally sets) the process umask, returning // the previous value — the bracket Puppet::Util.withumask uses. With no // argument it reports the current umask without changing it. @@ -959,3 +984,13 @@ func timeArgUnix(v object.Value) int64 { } return int64(numFloat(v)) } + +// timeArgUnixOrNow is timeArgUnix with MRI's nil handling for File.utime / +// File.lutime: a nil atime/mtime means "use the current time" (file.c +// utime_internal leaves the timespec NULL, which utimensat reads as UTIME_NOW). +func timeArgUnixOrNow(v object.Value) int64 { + if v == object.NilV { + return stdtime.Now().Unix() + } + return timeArgUnix(v) +} diff --git a/internal/vm/file_lutime_chroot_internal_test.go b/internal/vm/file_lutime_chroot_internal_test.go new file mode 100644 index 00000000..61f526dc --- /dev/null +++ b/internal/vm/file_lutime_chroot_internal_test.go @@ -0,0 +1,114 @@ +// Copyright (c) the go-embedded-ruby/ruby authors +// +// SPDX-License-Identifier: BSD-3-Clause + +package vm + +import ( + "errors" + "os" + "runtime" + "syscall" + "testing" +) + +// origChrootFn / origLutimesFn capture the platform seams so each test can +// restore them after swapping in a deterministic stub (the real chroot seam must +// never actually run in a test — it would re-root the test process). +var ( + origChrootFn = chrootFn + origLutimesFn = lutimesFn +) + +func restoreFDSeams() { + chrootFn = origChrootFn + lutimesFn = origLutimesFn +} + +// TestFileLutime covers File.lutime: the real utimensat(AT_SYMLINK_NOFOLLOW) +// seam on POSIX (setting a regular file's time and returning the path count), +// the nil-means-now branch, the arity guard, and the ENOENT error branch via a +// failing seam. Verified against MRI Ruby 4.0.5 (File.lutime returns the number +// of file names; file.c utime_internal with follow=TRUE -> AT_SYMLINK_NOFOLLOW). +func TestFileLutime(t *testing.T) { + defer restoreFDSeams() + + // File.lutime is registered only under the unix build tag; on Windows the + // method is absent (NoMethodError), so its POSIX assertions don't apply. The + // 100% coverage gate runs on the POSIX lanes, so coverage is unaffected. + if runtime.GOOS == "windows" { + t.Skip("File.lutime is POSIX-only") + } + if runtime.GOOS != "windows" { + dir := slash(t.TempDir()) + f := dir + "/f" + if err := os.WriteFile(dir+"/f", []byte("x"), 0o644); err != nil { + t.Fatal(err) + } + // Real call exercises the lutimesFn body: returns the path count. + if got := runFS(t, `p File.lutime(Time.at(1000000000), Time.at(1000000001), "`+f+`")`); got != "1\n" { + t.Errorf("lutime real: got %q want 1", got) + } + // mtime was set to the second argument. + if got := runFS(t, `p (File.mtime("`+f+`").to_i == 1000000001)`); got != "true\n" { + t.Errorf("lutime mtime: got %q want true", got) + } + // nil atime/mtime means the current time (timeArgUnixOrNow nil branch). + if got := runFS(t, `File.lutime(nil, nil, "`+f+`"); p ((Time.now.to_i - File.mtime("`+f+`").to_i).abs < 5)`); got != "true\n" { + t.Errorf("lutime nil: got %q want true", got) + } + } + + // Arity guard: fewer than two arguments is an ArgumentError. + if got := runFSErr(t, `File.lutime(0)`); got != "ArgumentError" { + t.Errorf("lutime arity: got %q want ArgumentError", got) + } + + // Error branch: a failing seam maps to Errno::ENOENT. + lutimesFn = func(string, int64, int64) error { return os.ErrNotExist } + if got := runFSErr(t, `File.lutime(0, 0, "x")`); got != "Errno::ENOENT" { + t.Errorf("lutime err: got %q want Errno::ENOENT", got) + } +} + +// TestDirChroot covers Dir.chroot: the success return (0) and each +// raiseChrootErr errno branch, all through the chrootFn seam so the real chroot +// (which would re-root the test process) never runs. Verified against MRI Ruby +// 4.0.5 (Dir.chroot returns 0; a regular user gets Errno::EPERM; dir.c +// dir_s_chroot, rb_sys_fail_path). +func TestDirChroot(t *testing.T) { + defer restoreFDSeams() + + // Dir.chroot is registered only under the unix build tag; absent on Windows + // (NoMethodError). The 100% coverage gate runs on the POSIX lanes. + if runtime.GOOS == "windows" { + t.Skip("Dir.chroot is POSIX-only") + } + + // Success: seam returns nil, Dir.chroot returns 0. + chrootFn = func(string) error { return nil } + if got := runFS(t, `p Dir.chroot(".")`); got != "0\n" { + t.Errorf("chroot success: got %q want 0", got) + } + + // Arity guard. + if got := runFSErr(t, `Dir.chroot(".", ".")`); got != "ArgumentError" { + t.Errorf("chroot arity: got %q want ArgumentError", got) + } + + // raiseChrootErr branches. + for _, c := range []struct { + err error + want string + }{ + {syscall.EPERM, "Errno::EPERM"}, + {syscall.ENOENT, "Errno::ENOENT"}, + {syscall.ENOTDIR, "Errno::ENOTDIR"}, + {errors.New("other"), "Errno::EPERM"}, + } { + chrootFn = func(string) error { return c.err } + if got := runFSErr(t, `Dir.chroot("x")`); got != c.want { + t.Errorf("chroot err %v: got %q want %q", c.err, got, c.want) + } + } +} diff --git a/internal/vm/filestat_unix.go b/internal/vm/filestat_unix.go index 0e92bdad..36ed8057 100644 --- a/internal/vm/filestat_unix.go +++ b/internal/vm/filestat_unix.go @@ -9,6 +9,32 @@ package vm import ( "io/fs" "syscall" + + "golang.org/x/sys/unix" +) + +// chrootFn and lutimesFn are the POSIX seams behind Dir.chroot and File.lutime. +// On Unix they map onto the real system calls; the windows/wasm builds supply +// unsupported stubs (both methods are guarded `platform_is_not :windows` in the +// specs). Each is a function variable so a whitebox test can substitute a stub +// and drive the Errno mapping without the real syscall — chroot in particular +// must never be allowed to re-root the test process, so its error branches are +// exercised only through a swapped seam. +var ( + // Dir.chroot(path) -> 0 (dir.c dir_s_chroot, rb_sys_fail_path on -1); a + // non-root process fails with EPERM. + chrootFn = syscall.Chroot + // lutimesFn sets a path's access/modification time WITHOUT following a final + // symbolic link — utimensat(AT_FDCWD, path, ts, AT_SYMLINK_NOFOLLOW), the + // no-follow that distinguishes File.lutime from File.utime (file.c + // utime_internal passes follow=TRUE, which maps to AT_SYMLINK_NOFOLLOW). + lutimesFn = func(path string, atime, mtime int64) error { + ts := []unix.Timespec{ + unix.NsecToTimespec(atime * int64(1e9)), + unix.NsecToTimespec(mtime * int64(1e9)), + } + return unix.UtimesNanoAt(unix.AT_FDCWD, path, ts, unix.AT_SYMLINK_NOFOLLOW) + } ) // statSys extracts the POSIX stat fields (uid/gid/ino/dev/nlink/blksize) from an diff --git a/internal/vm/filestat_wasm.go b/internal/vm/filestat_wasm.go index 068b31b4..fba3897c 100644 --- a/internal/vm/filestat_wasm.go +++ b/internal/vm/filestat_wasm.go @@ -7,10 +7,20 @@ package vm import ( + "errors" "io/fs" "syscall" ) +// chrootFn / lutimesFn are unsupported under GOARCH=wasm: Dir.chroot and +// File.lutime are both guarded `platform_is_not :windows` in the specs and have +// no wasip1/js system call, so these stubs exist only to satisfy the seam the +// shared dir.go / file.go code references. +var ( + chrootFn = func(string) error { return errors.ErrUnsupported } + lutimesFn = func(string, int64, int64) error { return errors.ErrUnsupported } +) + // statSys is the GOARCH=wasm counterpart of the Unix syscall.Stat_t extraction. // Under wasip1 the os package still populates FileInfo.Sys() with a // *syscall.Stat_t, but that struct is a WASI-preview1 subset: it carries diff --git a/internal/vm/filestat_windows.go b/internal/vm/filestat_windows.go index 2b2bc9d6..032c7c65 100644 --- a/internal/vm/filestat_windows.go +++ b/internal/vm/filestat_windows.go @@ -6,7 +6,19 @@ package vm -import "io/fs" +import ( + "errors" + "io/fs" +) + +// chrootFn / lutimesFn are unsupported on Windows: Dir.chroot and File.lutime are +// both guarded `platform_is_not :windows` in the specs, so these stubs exist only +// to satisfy the seam the shared dir.go / file.go code references, reporting the +// operation as unsupported. +var ( + chrootFn = func(string) error { return errors.ErrUnsupported } + lutimesFn = func(string, int64, int64) error { return errors.ErrUnsupported } +) // statSys is the Windows counterpart of the Unix syscall.Stat_t extraction. // Windows has no Stat_t (no uid/gid/inode model), so the POSIX-only fields take