2011-12-13 20:16:27 +01:00
|
|
|
// 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.
|
|
|
|
|
2014-06-07 00:37:27 +02:00
|
|
|
// +build darwin dragonfly freebsd linux netbsd openbsd solaris
|
2011-12-13 20:16:27 +01:00
|
|
|
|
|
|
|
package os_test
|
|
|
|
|
|
|
|
import (
|
|
|
|
. "os"
|
2012-01-25 21:56:26 +01:00
|
|
|
"runtime"
|
2011-12-13 20:16:27 +01:00
|
|
|
"syscall"
|
|
|
|
"testing"
|
|
|
|
)
|
|
|
|
|
2015-10-31 01:59:47 +01:00
|
|
|
func init() {
|
|
|
|
isReadonlyError = func(err error) bool { return err == syscall.EROFS }
|
|
|
|
}
|
|
|
|
|
2011-12-13 20:16:27 +01:00
|
|
|
func checkUidGid(t *testing.T, path string, uid, gid int) {
|
|
|
|
dir, err := Stat(path)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Stat %q (looking for uid/gid %d/%d): %s", path, uid, gid, err)
|
|
|
|
}
|
2012-02-09 09:19:58 +01:00
|
|
|
sys := dir.Sys().(*syscall.Stat_t)
|
2011-12-13 20:16:27 +01:00
|
|
|
if int(sys.Uid) != uid {
|
|
|
|
t.Errorf("Stat %q: uid %d want %d", path, sys.Uid, uid)
|
|
|
|
}
|
|
|
|
if int(sys.Gid) != gid {
|
|
|
|
t.Errorf("Stat %q: gid %d want %d", path, sys.Gid, gid)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestChown(t *testing.T) {
|
2015-10-31 01:59:47 +01:00
|
|
|
// Chown is not supported under windows or Plan 9.
|
2011-12-13 20:16:27 +01:00
|
|
|
// Plan9 provides a native ChownPlan9 version instead.
|
2012-01-25 21:56:26 +01:00
|
|
|
if runtime.GOOS == "windows" || runtime.GOOS == "plan9" {
|
2015-10-31 01:59:47 +01:00
|
|
|
t.Skipf("%s does not support syscall.Chown", runtime.GOOS)
|
2011-12-13 20:16:27 +01:00
|
|
|
}
|
|
|
|
// 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)
|
|
|
|
}
|
2012-02-09 09:19:58 +01:00
|
|
|
sys := dir.Sys().(*syscall.Stat_t)
|
2011-12-13 20:16:27 +01:00
|
|
|
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)
|
|
|
|
}
|
|
|
|
}
|
2015-10-31 01:59:47 +01:00
|
|
|
|
|
|
|
func TestFileChown(t *testing.T) {
|
|
|
|
// Fchown is not supported under windows or Plan 9.
|
|
|
|
if runtime.GOOS == "windows" || runtime.GOOS == "plan9" {
|
|
|
|
t.Skipf("%s does not support syscall.Fchown", runtime.GOOS)
|
|
|
|
}
|
|
|
|
// 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) {
|
|
|
|
// Lchown is not supported under windows or Plan 9.
|
|
|
|
if runtime.GOOS == "windows" || runtime.GOOS == "plan9" {
|
|
|
|
t.Skipf("%s does not support syscall.Lchown", runtime.GOOS)
|
|
|
|
}
|
|
|
|
// 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 := Link(f.Name(), linkname); err != nil {
|
|
|
|
t.Fatalf("link %s -> %s: %v", f.Name(), linkname, err)
|
|
|
|
}
|
|
|
|
defer Remove(linkname)
|
|
|
|
|
|
|
|
f2, err := Open(linkname)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("open %s: %v", linkname, err)
|
|
|
|
}
|
|
|
|
defer f2.Close()
|
|
|
|
|
|
|
|
// 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 {
|
|
|
|
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)
|
|
|
|
|
|
|
|
// change back to gid to test fd.Chown
|
|
|
|
if err = f2.Chown(-1, gid); err != nil {
|
|
|
|
t.Fatalf("fchown %s -1 %d: %s", linkname, gid, err)
|
|
|
|
}
|
|
|
|
checkUidGid(t, linkname, int(sys.Uid), gid)
|
|
|
|
}
|
|
|
|
}
|