os_unix_test.go

Documentation: os

		 1  // Copyright 2009 The Go Authors. All rights reserved.
		 2  // Use of this source code is governed by a BSD-style
		 3  // license that can be found in the LICENSE file.
		 4  
		 5  //go:build aix || darwin || dragonfly || freebsd || (js && wasm) || linux || netbsd || openbsd || solaris
		 6  // +build aix darwin dragonfly freebsd js,wasm linux netbsd openbsd solaris
		 7  
		 8  package os_test
		 9  
		10  import (
		11  	"io"
		12  	"os"
		13  	. "os"
		14  	"path/filepath"
		15  	"runtime"
		16  	"strings"
		17  	"syscall"
		18  	"testing"
		19  	"time"
		20  )
		21  
		22  func init() {
		23  	isReadonlyError = func(err error) bool { return err == syscall.EROFS }
		24  }
		25  
		26  // For TestRawConnReadWrite.
		27  type syscallDescriptor = int
		28  
		29  func checkUidGid(t *testing.T, path string, uid, gid int) {
		30  	dir, err := Lstat(path)
		31  	if err != nil {
		32  		t.Fatalf("Lstat %q (looking for uid/gid %d/%d): %s", path, uid, gid, err)
		33  	}
		34  	sys := dir.Sys().(*syscall.Stat_t)
		35  	if int(sys.Uid) != uid {
		36  		t.Errorf("Lstat %q: uid %d want %d", path, sys.Uid, uid)
		37  	}
		38  	if int(sys.Gid) != gid {
		39  		t.Errorf("Lstat %q: gid %d want %d", path, sys.Gid, gid)
		40  	}
		41  }
		42  
		43  func TestChown(t *testing.T) {
		44  	// Use TempDir() to make sure we're on a local file system,
		45  	// so that the group ids returned by Getgroups will be allowed
		46  	// on the file. On NFS, the Getgroups groups are
		47  	// basically useless.
		48  	f := newFile("TestChown", t)
		49  	defer Remove(f.Name())
		50  	defer f.Close()
		51  	dir, err := f.Stat()
		52  	if err != nil {
		53  		t.Fatalf("stat %s: %s", f.Name(), err)
		54  	}
		55  
		56  	// Can't change uid unless root, but can try
		57  	// changing the group id. First try our current group.
		58  	gid := Getgid()
		59  	t.Log("gid:", gid)
		60  	if err = Chown(f.Name(), -1, gid); err != nil {
		61  		t.Fatalf("chown %s -1 %d: %s", f.Name(), gid, err)
		62  	}
		63  	sys := dir.Sys().(*syscall.Stat_t)
		64  	checkUidGid(t, f.Name(), int(sys.Uid), gid)
		65  
		66  	// Then try all the auxiliary groups.
		67  	groups, err := Getgroups()
		68  	if err != nil {
		69  		t.Fatalf("getgroups: %s", err)
		70  	}
		71  	t.Log("groups: ", groups)
		72  	for _, g := range groups {
		73  		if err = Chown(f.Name(), -1, g); err != nil {
		74  			t.Fatalf("chown %s -1 %d: %s", f.Name(), g, err)
		75  		}
		76  		checkUidGid(t, f.Name(), int(sys.Uid), g)
		77  
		78  		// change back to gid to test fd.Chown
		79  		if err = f.Chown(-1, gid); err != nil {
		80  			t.Fatalf("fchown %s -1 %d: %s", f.Name(), gid, err)
		81  		}
		82  		checkUidGid(t, f.Name(), int(sys.Uid), gid)
		83  	}
		84  }
		85  
		86  func TestFileChown(t *testing.T) {
		87  	// Use TempDir() to make sure we're on a local file system,
		88  	// so that the group ids returned by Getgroups will be allowed
		89  	// on the file. On NFS, the Getgroups groups are
		90  	// basically useless.
		91  	f := newFile("TestFileChown", t)
		92  	defer Remove(f.Name())
		93  	defer f.Close()
		94  	dir, err := f.Stat()
		95  	if err != nil {
		96  		t.Fatalf("stat %s: %s", f.Name(), err)
		97  	}
		98  
		99  	// Can't change uid unless root, but can try
	 100  	// changing the group id. First try our current group.
	 101  	gid := Getgid()
	 102  	t.Log("gid:", gid)
	 103  	if err = f.Chown(-1, gid); err != nil {
	 104  		t.Fatalf("fchown %s -1 %d: %s", f.Name(), gid, err)
	 105  	}
	 106  	sys := dir.Sys().(*syscall.Stat_t)
	 107  	checkUidGid(t, f.Name(), int(sys.Uid), gid)
	 108  
	 109  	// Then try all the auxiliary groups.
	 110  	groups, err := Getgroups()
	 111  	if err != nil {
	 112  		t.Fatalf("getgroups: %s", err)
	 113  	}
	 114  	t.Log("groups: ", groups)
	 115  	for _, g := range groups {
	 116  		if err = f.Chown(-1, g); err != nil {
	 117  			t.Fatalf("fchown %s -1 %d: %s", f.Name(), g, err)
	 118  		}
	 119  		checkUidGid(t, f.Name(), int(sys.Uid), g)
	 120  
	 121  		// change back to gid to test fd.Chown
	 122  		if err = f.Chown(-1, gid); err != nil {
	 123  			t.Fatalf("fchown %s -1 %d: %s", f.Name(), gid, err)
	 124  		}
	 125  		checkUidGid(t, f.Name(), int(sys.Uid), gid)
	 126  	}
	 127  }
	 128  
	 129  func TestLchown(t *testing.T) {
	 130  	// Use TempDir() to make sure we're on a local file system,
	 131  	// so that the group ids returned by Getgroups will be allowed
	 132  	// on the file. On NFS, the Getgroups groups are
	 133  	// basically useless.
	 134  	f := newFile("TestLchown", t)
	 135  	defer Remove(f.Name())
	 136  	defer f.Close()
	 137  	dir, err := f.Stat()
	 138  	if err != nil {
	 139  		t.Fatalf("stat %s: %s", f.Name(), err)
	 140  	}
	 141  
	 142  	linkname := f.Name() + "2"
	 143  	if err := Symlink(f.Name(), linkname); err != nil {
	 144  		if runtime.GOOS == "android" && IsPermission(err) {
	 145  			t.Skip("skipping test on Android; permission error creating symlink")
	 146  		}
	 147  		t.Fatalf("link %s -> %s: %v", f.Name(), linkname, err)
	 148  	}
	 149  	defer Remove(linkname)
	 150  
	 151  	// Can't change uid unless root, but can try
	 152  	// changing the group id. First try our current group.
	 153  	gid := Getgid()
	 154  	t.Log("gid:", gid)
	 155  	if err = Lchown(linkname, -1, gid); err != nil {
	 156  		if err, ok := err.(*PathError); ok && err.Err == syscall.ENOSYS {
	 157  			t.Skip("lchown is unavailable")
	 158  		}
	 159  		t.Fatalf("lchown %s -1 %d: %s", linkname, gid, err)
	 160  	}
	 161  	sys := dir.Sys().(*syscall.Stat_t)
	 162  	checkUidGid(t, linkname, int(sys.Uid), gid)
	 163  
	 164  	// Then try all the auxiliary groups.
	 165  	groups, err := Getgroups()
	 166  	if err != nil {
	 167  		t.Fatalf("getgroups: %s", err)
	 168  	}
	 169  	t.Log("groups: ", groups)
	 170  	for _, g := range groups {
	 171  		if err = Lchown(linkname, -1, g); err != nil {
	 172  			t.Fatalf("lchown %s -1 %d: %s", linkname, g, err)
	 173  		}
	 174  		checkUidGid(t, linkname, int(sys.Uid), g)
	 175  
	 176  		// Check that link target's gid is unchanged.
	 177  		checkUidGid(t, f.Name(), int(sys.Uid), int(sys.Gid))
	 178  	}
	 179  }
	 180  
	 181  // Issue 16919: Readdir must return a non-empty slice or an error.
	 182  func TestReaddirRemoveRace(t *testing.T) {
	 183  	oldStat := *LstatP
	 184  	defer func() { *LstatP = oldStat }()
	 185  	*LstatP = func(name string) (FileInfo, error) {
	 186  		if strings.HasSuffix(name, "some-file") {
	 187  			// Act like it's been deleted.
	 188  			return nil, ErrNotExist
	 189  		}
	 190  		return oldStat(name)
	 191  	}
	 192  	dir := newDir("TestReaddirRemoveRace", t)
	 193  	defer RemoveAll(dir)
	 194  	if err := os.WriteFile(filepath.Join(dir, "some-file"), []byte("hello"), 0644); err != nil {
	 195  		t.Fatal(err)
	 196  	}
	 197  	d, err := Open(dir)
	 198  	if err != nil {
	 199  		t.Fatal(err)
	 200  	}
	 201  	defer d.Close()
	 202  	fis, err := d.Readdir(2) // notably, greater than zero
	 203  	if len(fis) == 0 && err == nil {
	 204  		// This is what used to happen (Issue 16919)
	 205  		t.Fatal("Readdir = empty slice & err == nil")
	 206  	}
	 207  	if len(fis) != 0 || err != io.EOF {
	 208  		t.Errorf("Readdir = %d entries: %v; want 0, io.EOF", len(fis), err)
	 209  		for i, fi := range fis {
	 210  			t.Errorf("	entry[%d]: %q, %v", i, fi.Name(), fi.Mode())
	 211  		}
	 212  		t.FailNow()
	 213  	}
	 214  }
	 215  
	 216  // Issue 23120: respect umask when doing Mkdir with the sticky bit
	 217  func TestMkdirStickyUmask(t *testing.T) {
	 218  	const umask = 0077
	 219  	dir := newDir("TestMkdirStickyUmask", t)
	 220  	defer RemoveAll(dir)
	 221  	oldUmask := syscall.Umask(umask)
	 222  	defer syscall.Umask(oldUmask)
	 223  	p := filepath.Join(dir, "dir1")
	 224  	if err := Mkdir(p, ModeSticky|0755); err != nil {
	 225  		t.Fatal(err)
	 226  	}
	 227  	fi, err := Stat(p)
	 228  	if err != nil {
	 229  		t.Fatal(err)
	 230  	}
	 231  	if mode := fi.Mode(); (mode&umask) != 0 || (mode&^ModePerm) != (ModeDir|ModeSticky) {
	 232  		t.Errorf("unexpected mode %s", mode)
	 233  	}
	 234  }
	 235  
	 236  // See also issues: 22939, 24331
	 237  func newFileTest(t *testing.T, blocking bool) {
	 238  	if runtime.GOOS == "js" {
	 239  		t.Skipf("syscall.Pipe is not available on %s.", runtime.GOOS)
	 240  	}
	 241  
	 242  	p := make([]int, 2)
	 243  	if err := syscall.Pipe(p); err != nil {
	 244  		t.Fatalf("pipe: %v", err)
	 245  	}
	 246  	defer syscall.Close(p[1])
	 247  
	 248  	// Set the read-side to non-blocking.
	 249  	if !blocking {
	 250  		if err := syscall.SetNonblock(p[0], true); err != nil {
	 251  			syscall.Close(p[0])
	 252  			t.Fatalf("SetNonblock: %v", err)
	 253  		}
	 254  	}
	 255  	// Convert it to a file.
	 256  	file := NewFile(uintptr(p[0]), "notapipe")
	 257  	if file == nil {
	 258  		syscall.Close(p[0])
	 259  		t.Fatalf("failed to convert fd to file!")
	 260  	}
	 261  	defer file.Close()
	 262  
	 263  	timeToWrite := 100 * time.Millisecond
	 264  	timeToDeadline := 1 * time.Millisecond
	 265  	if !blocking {
	 266  		// Use a longer time to avoid flakes.
	 267  		// We won't be waiting this long anyhow.
	 268  		timeToWrite = 1 * time.Second
	 269  	}
	 270  
	 271  	// Try to read with deadline (but don't block forever).
	 272  	b := make([]byte, 1)
	 273  	timer := time.AfterFunc(timeToWrite, func() { syscall.Write(p[1], []byte("a")) })
	 274  	defer timer.Stop()
	 275  	file.SetReadDeadline(time.Now().Add(timeToDeadline))
	 276  	_, err := file.Read(b)
	 277  	if !blocking {
	 278  		// We want it to fail with a timeout.
	 279  		if !isDeadlineExceeded(err) {
	 280  			t.Fatalf("No timeout reading from file: %v", err)
	 281  		}
	 282  	} else {
	 283  		// We want it to succeed after 100ms
	 284  		if err != nil {
	 285  			t.Fatalf("Error reading from file: %v", err)
	 286  		}
	 287  	}
	 288  }
	 289  
	 290  func TestNewFileBlock(t *testing.T) {
	 291  	t.Parallel()
	 292  	newFileTest(t, true)
	 293  }
	 294  
	 295  func TestNewFileNonBlock(t *testing.T) {
	 296  	t.Parallel()
	 297  	newFileTest(t, false)
	 298  }
	 299  
	 300  func TestSplitPath(t *testing.T) {
	 301  	t.Parallel()
	 302  	for _, tt := range []struct{ path, wantDir, wantBase string }{
	 303  		{"a", ".", "a"},
	 304  		{"a/", ".", "a"},
	 305  		{"a//", ".", "a"},
	 306  		{"a/b", "a", "b"},
	 307  		{"a/b/", "a", "b"},
	 308  		{"a/b/c", "a/b", "c"},
	 309  		{"/a", "/", "a"},
	 310  		{"/a/", "/", "a"},
	 311  		{"/a/b", "/a", "b"},
	 312  		{"/a/b/", "/a", "b"},
	 313  		{"/a/b/c", "/a/b", "c"},
	 314  		{"//a", "/", "a"},
	 315  		{"//a/", "/", "a"},
	 316  		{"///a", "/", "a"},
	 317  		{"///a/", "/", "a"},
	 318  	} {
	 319  		if dir, base := SplitPath(tt.path); dir != tt.wantDir || base != tt.wantBase {
	 320  			t.Errorf("splitPath(%q) = %q, %q, want %q, %q", tt.path, dir, base, tt.wantDir, tt.wantBase)
	 321  		}
	 322  	}
	 323  }
	 324
View as plain text