| // Copyright 2009 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| // +build aix darwin dragonfly freebsd hurd js,wasm linux netbsd openbsd solaris |
| |
| package os_test |
| |
| import ( |
| "io" |
| "os" |
| . "os" |
| "path/filepath" |
| "runtime" |
| "strings" |
| "syscall" |
| "testing" |
| "time" |
| ) |
| |
| func init() { |
| isReadonlyError = func(err error) bool { return err == syscall.EROFS } |
| } |
| |
| // For TestRawConnReadWrite. |
| type syscallDescriptor = int |
| |
| func checkUidGid(t *testing.T, path string, uid, gid int) { |
| dir, err := Lstat(path) |
| if err != nil { |
| t.Fatalf("Lstat %q (looking for uid/gid %d/%d): %s", path, uid, gid, err) |
| } |
| sys := dir.Sys().(*syscall.Stat_t) |
| if int(sys.Uid) != uid { |
| t.Errorf("Lstat %q: uid %d want %d", path, sys.Uid, uid) |
| } |
| if int(sys.Gid) != gid { |
| t.Errorf("Lstat %q: gid %d want %d", path, sys.Gid, gid) |
| } |
| } |
| |
| func TestChown(t *testing.T) { |
| // Use TempDir() to make sure we're on a local file system, |
| // so that the group ids returned by Getgroups will be allowed |
| // on the file. On NFS, the Getgroups groups are |
| // basically useless. |
| f := newFile("TestChown", t) |
| defer Remove(f.Name()) |
| defer f.Close() |
| dir, err := f.Stat() |
| if err != nil { |
| t.Fatalf("stat %s: %s", f.Name(), err) |
| } |
| |
| // Can't change uid unless root, but can try |
| // changing the group id. First try our current group. |
| gid := Getgid() |
| t.Log("gid:", gid) |
| if err = Chown(f.Name(), -1, gid); err != nil { |
| t.Fatalf("chown %s -1 %d: %s", f.Name(), gid, err) |
| } |
| sys := dir.Sys().(*syscall.Stat_t) |
| checkUidGid(t, f.Name(), int(sys.Uid), gid) |
| |
| // Then try all the auxiliary groups. |
| groups, err := Getgroups() |
| if err != nil { |
| t.Fatalf("getgroups: %s", err) |
| } |
| t.Log("groups: ", groups) |
| for _, g := range groups { |
| if err = Chown(f.Name(), -1, g); err != nil { |
| t.Fatalf("chown %s -1 %d: %s", f.Name(), g, err) |
| } |
| checkUidGid(t, f.Name(), int(sys.Uid), g) |
| |
| // change back to gid to test fd.Chown |
| if err = f.Chown(-1, gid); err != nil { |
| t.Fatalf("fchown %s -1 %d: %s", f.Name(), gid, err) |
| } |
| checkUidGid(t, f.Name(), int(sys.Uid), gid) |
| } |
| } |
| |
| func TestFileChown(t *testing.T) { |
| // Use TempDir() to make sure we're on a local file system, |
| // so that the group ids returned by Getgroups will be allowed |
| // on the file. On NFS, the Getgroups groups are |
| // basically useless. |
| f := newFile("TestFileChown", t) |
| defer Remove(f.Name()) |
| defer f.Close() |
| dir, err := f.Stat() |
| if err != nil { |
| t.Fatalf("stat %s: %s", f.Name(), err) |
| } |
| |
| // Can't change uid unless root, but can try |
| // changing the group id. First try our current group. |
| gid := Getgid() |
| t.Log("gid:", gid) |
| if err = f.Chown(-1, gid); err != nil { |
| t.Fatalf("fchown %s -1 %d: %s", f.Name(), gid, err) |
| } |
| sys := dir.Sys().(*syscall.Stat_t) |
| checkUidGid(t, f.Name(), int(sys.Uid), gid) |
| |
| // Then try all the auxiliary groups. |
| groups, err := Getgroups() |
| if err != nil { |
| t.Fatalf("getgroups: %s", err) |
| } |
| t.Log("groups: ", groups) |
| for _, g := range groups { |
| if err = f.Chown(-1, g); err != nil { |
| t.Fatalf("fchown %s -1 %d: %s", f.Name(), g, err) |
| } |
| checkUidGid(t, f.Name(), int(sys.Uid), g) |
| |
| // change back to gid to test fd.Chown |
| if err = f.Chown(-1, gid); err != nil { |
| t.Fatalf("fchown %s -1 %d: %s", f.Name(), gid, err) |
| } |
| checkUidGid(t, f.Name(), int(sys.Uid), gid) |
| } |
| } |
| |
| func TestLchown(t *testing.T) { |
| // Use TempDir() to make sure we're on a local file system, |
| // so that the group ids returned by Getgroups will be allowed |
| // on the file. On NFS, the Getgroups groups are |
| // basically useless. |
| f := newFile("TestLchown", t) |
| defer Remove(f.Name()) |
| defer f.Close() |
| dir, err := f.Stat() |
| if err != nil { |
| t.Fatalf("stat %s: %s", f.Name(), err) |
| } |
| |
| linkname := f.Name() + "2" |
| if err := Symlink(f.Name(), linkname); err != nil { |
| if runtime.GOOS == "android" && IsPermission(err) { |
| t.Skip("skipping test on Android; permission error creating symlink") |
| } |
| t.Fatalf("link %s -> %s: %v", f.Name(), linkname, err) |
| } |
| defer Remove(linkname) |
| |
| // Can't change uid unless root, but can try |
| // changing the group id. First try our current group. |
| gid := Getgid() |
| t.Log("gid:", gid) |
| if err = Lchown(linkname, -1, gid); err != nil { |
| if err, ok := err.(*PathError); ok && err.Err == syscall.ENOSYS { |
| t.Skip("lchown is unavailable") |
| } |
| t.Fatalf("lchown %s -1 %d: %s", linkname, gid, err) |
| } |
| sys := dir.Sys().(*syscall.Stat_t) |
| checkUidGid(t, linkname, int(sys.Uid), gid) |
| |
| // Then try all the auxiliary groups. |
| groups, err := Getgroups() |
| if err != nil { |
| t.Fatalf("getgroups: %s", err) |
| } |
| t.Log("groups: ", groups) |
| for _, g := range groups { |
| if err = Lchown(linkname, -1, g); err != nil { |
| t.Fatalf("lchown %s -1 %d: %s", linkname, g, err) |
| } |
| checkUidGid(t, linkname, int(sys.Uid), g) |
| |
| // Check that link target's gid is unchanged. |
| checkUidGid(t, f.Name(), int(sys.Uid), int(sys.Gid)) |
| } |
| } |
| |
| // Issue 16919: Readdir must return a non-empty slice or an error. |
| func TestReaddirRemoveRace(t *testing.T) { |
| oldStat := *LstatP |
| defer func() { *LstatP = oldStat }() |
| *LstatP = func(name string) (FileInfo, error) { |
| if strings.HasSuffix(name, "some-file") { |
| // Act like it's been deleted. |
| return nil, ErrNotExist |
| } |
| return oldStat(name) |
| } |
| dir := newDir("TestReaddirRemoveRace", t) |
| defer RemoveAll(dir) |
| if err := os.WriteFile(filepath.Join(dir, "some-file"), []byte("hello"), 0644); err != nil { |
| t.Fatal(err) |
| } |
| d, err := Open(dir) |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer d.Close() |
| fis, err := d.Readdir(2) // notably, greater than zero |
| if len(fis) == 0 && err == nil { |
| // This is what used to happen (Issue 16919) |
| t.Fatal("Readdir = empty slice & err == nil") |
| } |
| if len(fis) != 0 || err != io.EOF { |
| t.Errorf("Readdir = %d entries: %v; want 0, io.EOF", len(fis), err) |
| for i, fi := range fis { |
| t.Errorf(" entry[%d]: %q, %v", i, fi.Name(), fi.Mode()) |
| } |
| t.FailNow() |
| } |
| } |
| |
| // Issue 23120: respect umask when doing Mkdir with the sticky bit |
| func TestMkdirStickyUmask(t *testing.T) { |
| const umask = 0077 |
| dir := newDir("TestMkdirStickyUmask", t) |
| defer RemoveAll(dir) |
| oldUmask := syscall.Umask(umask) |
| defer syscall.Umask(oldUmask) |
| p := filepath.Join(dir, "dir1") |
| if err := Mkdir(p, ModeSticky|0755); err != nil { |
| t.Fatal(err) |
| } |
| fi, err := Stat(p) |
| if err != nil { |
| t.Fatal(err) |
| } |
| if mode := fi.Mode(); (mode&umask) != 0 || (mode&^ModePerm) != (ModeDir|ModeSticky) { |
| t.Errorf("unexpected mode %s", mode) |
| } |
| } |
| |
| // See also issues: 22939, 24331 |
| func newFileTest(t *testing.T, blocking bool) { |
| if runtime.GOOS == "js" { |
| t.Skipf("syscall.Pipe is not available on %s.", runtime.GOOS) |
| } |
| |
| p := make([]int, 2) |
| if err := syscall.Pipe(p); err != nil { |
| t.Fatalf("pipe: %v", err) |
| } |
| defer syscall.Close(p[1]) |
| |
| // Set the read-side to non-blocking. |
| if !blocking { |
| if err := syscall.SetNonblock(p[0], true); err != nil { |
| syscall.Close(p[0]) |
| t.Fatalf("SetNonblock: %v", err) |
| } |
| } |
| // Convert it to a file. |
| file := NewFile(uintptr(p[0]), "notapipe") |
| if file == nil { |
| syscall.Close(p[0]) |
| t.Fatalf("failed to convert fd to file!") |
| } |
| defer file.Close() |
| |
| timeToWrite := 100 * time.Millisecond |
| timeToDeadline := 1 * time.Millisecond |
| if !blocking { |
| // Use a longer time to avoid flakes. |
| // We won't be waiting this long anyhow. |
| timeToWrite = 1 * time.Second |
| } |
| |
| // Try to read with deadline (but don't block forever). |
| b := make([]byte, 1) |
| timer := time.AfterFunc(timeToWrite, func() { syscall.Write(p[1], []byte("a")) }) |
| defer timer.Stop() |
| file.SetReadDeadline(time.Now().Add(timeToDeadline)) |
| _, err := file.Read(b) |
| if !blocking { |
| // We want it to fail with a timeout. |
| if !isDeadlineExceeded(err) { |
| t.Fatalf("No timeout reading from file: %v", err) |
| } |
| } else { |
| // We want it to succeed after 100ms |
| if err != nil { |
| t.Fatalf("Error reading from file: %v", err) |
| } |
| } |
| } |
| |
| func TestNewFileBlock(t *testing.T) { |
| t.Parallel() |
| newFileTest(t, true) |
| } |
| |
| func TestNewFileNonBlock(t *testing.T) { |
| t.Parallel() |
| newFileTest(t, false) |
| } |
| |
| func TestSplitPath(t *testing.T) { |
| t.Parallel() |
| for _, tt := range []struct{ path, wantDir, wantBase string }{ |
| {"a", ".", "a"}, |
| {"a/", ".", "a"}, |
| {"a//", ".", "a"}, |
| {"a/b", "a", "b"}, |
| {"a/b/", "a", "b"}, |
| {"a/b/c", "a/b", "c"}, |
| {"/a", "/", "a"}, |
| {"/a/", "/", "a"}, |
| {"/a/b", "/a", "b"}, |
| {"/a/b/", "/a", "b"}, |
| {"/a/b/c", "/a/b", "c"}, |
| {"//a", "/", "a"}, |
| {"//a/", "/", "a"}, |
| {"///a", "/", "a"}, |
| {"///a/", "/", "a"}, |
| } { |
| if dir, base := SplitPath(tt.path); dir != tt.wantDir || base != tt.wantBase { |
| t.Errorf("splitPath(%q) = %q, %q, want %q, %q", tt.path, dir, base, tt.wantDir, tt.wantBase) |
| } |
| } |
| } |