root_unix_test.go

     1  // Copyright 2025 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 unix || (js && wasm) || wasip1
     6  
     7  package os_test
     8  
     9  import (
    10  	"fmt"
    11  	"os"
    12  	"path/filepath"
    13  	"runtime"
    14  	"syscall"
    15  	"testing"
    16  )
    17  
    18  func TestRootChown(t *testing.T) {
    19  	if runtime.GOOS == "wasip1" {
    20  		t.Skip("Chown not supported on " + runtime.GOOS)
    21  	}
    22  
    23  	// Look up the current default uid/gid.
    24  	f := newFile(t)
    25  	dir, err := f.Stat()
    26  	if err != nil {
    27  		t.Fatal(err)
    28  	}
    29  	sys := dir.Sys().(*syscall.Stat_t)
    30  
    31  	groups, err := os.Getgroups()
    32  	if err != nil {
    33  		t.Fatal(err)
    34  	}
    35  	groups = append(groups, os.Getgid())
    36  	for _, test := range rootTestCases {
    37  		test.run(t, func(t *testing.T, target string, root *os.Root) {
    38  			if target != "" {
    39  				if err := os.WriteFile(target, nil, 0o666); err != nil {
    40  					t.Fatal(err)
    41  				}
    42  			}
    43  			for _, gid := range groups {
    44  				err := root.Chown(test.open, -1, gid)
    45  				if errEndsTest(t, err, test.wantError, "root.Chown(%q, -1, %v)", test.open, gid) {
    46  					return
    47  				}
    48  				checkUidGid(t, target, int(sys.Uid), gid)
    49  			}
    50  		})
    51  	}
    52  }
    53  
    54  func TestRootLchown(t *testing.T) {
    55  	if runtime.GOOS == "wasip1" {
    56  		t.Skip("Lchown not supported on " + runtime.GOOS)
    57  	}
    58  
    59  	// Look up the current default uid/gid.
    60  	f := newFile(t)
    61  	dir, err := f.Stat()
    62  	if err != nil {
    63  		t.Fatal(err)
    64  	}
    65  	sys := dir.Sys().(*syscall.Stat_t)
    66  
    67  	groups, err := os.Getgroups()
    68  	if err != nil {
    69  		t.Fatal(err)
    70  	}
    71  	groups = append(groups, os.Getgid())
    72  	for _, test := range rootTestCases {
    73  		test.run(t, func(t *testing.T, target string, root *os.Root) {
    74  			if test.ltarget != "" {
    75  				test.wantError = false
    76  				target = filepath.Join(root.Name(), test.ltarget)
    77  			} else if target != "" {
    78  				if err := os.WriteFile(target, nil, 0o666); err != nil {
    79  					t.Fatal(err)
    80  				}
    81  			}
    82  			for _, gid := range groups {
    83  				err := root.Lchown(test.open, -1, gid)
    84  				if errEndsTest(t, err, test.wantError, "root.Lchown(%q, -1, %v)", test.open, gid) {
    85  					return
    86  				}
    87  				checkUidGid(t, target, int(sys.Uid), gid)
    88  			}
    89  		})
    90  	}
    91  }
    92  
    93  func TestRootConsistencyChown(t *testing.T) {
    94  	if runtime.GOOS == "wasip1" {
    95  		t.Skip("Chown not supported on " + runtime.GOOS)
    96  	}
    97  	groups, err := os.Getgroups()
    98  	if err != nil {
    99  		t.Fatal(err)
   100  	}
   101  	var gid int
   102  	if len(groups) == 0 {
   103  		gid = os.Getgid()
   104  	} else {
   105  		gid = groups[0]
   106  	}
   107  	for _, test := range rootConsistencyTestCases {
   108  		test.run(t, func(t *testing.T, path string, r *os.Root) (string, error) {
   109  			chown := os.Chown
   110  			lstat := os.Lstat
   111  			if r != nil {
   112  				chown = r.Chown
   113  				lstat = r.Lstat
   114  			}
   115  			err := chown(path, -1, gid)
   116  			if err != nil {
   117  				return "", err
   118  			}
   119  			fi, err := lstat(path)
   120  			if err != nil {
   121  				return "", err
   122  			}
   123  			sys := fi.Sys().(*syscall.Stat_t)
   124  			return fmt.Sprintf("%v %v", sys.Uid, sys.Gid), nil
   125  		})
   126  	}
   127  }
   128  
   129  func TestRootConsistencyLchown(t *testing.T) {
   130  	if runtime.GOOS == "wasip1" {
   131  		t.Skip("Lchown not supported on " + runtime.GOOS)
   132  	}
   133  	groups, err := os.Getgroups()
   134  	if err != nil {
   135  		t.Fatal(err)
   136  	}
   137  	var gid int
   138  	if len(groups) == 0 {
   139  		gid = os.Getgid()
   140  	} else {
   141  		gid = groups[0]
   142  	}
   143  	for _, test := range rootConsistencyTestCases {
   144  		test.run(t, func(t *testing.T, path string, r *os.Root) (string, error) {
   145  			lchown := os.Lchown
   146  			lstat := os.Lstat
   147  			if r != nil {
   148  				lchown = r.Lchown
   149  				lstat = r.Lstat
   150  			}
   151  			err := lchown(path, -1, gid)
   152  			if err != nil {
   153  				return "", err
   154  			}
   155  			fi, err := lstat(path)
   156  			if err != nil {
   157  				return "", err
   158  			}
   159  			sys := fi.Sys().(*syscall.Stat_t)
   160  			return fmt.Sprintf("%v %v", sys.Uid, sys.Gid), nil
   161  		})
   162  	}
   163  }
   164
View as plain text