getwd_unix_test.go

     1  // Copyright 2024 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
     6  
     7  package os_test
     8  
     9  import (
    10  	"errors"
    11  	. "os"
    12  	"path/filepath"
    13  	"runtime"
    14  	"strings"
    15  	"syscall"
    16  	"testing"
    17  )
    18  
    19  func TestGetwdDeep(t *testing.T) {
    20  	testGetwdDeep(t, false)
    21  }
    22  
    23  func TestGetwdDeepWithPWDSet(t *testing.T) {
    24  	testGetwdDeep(t, true)
    25  }
    26  
    27  // testGetwdDeep checks that os.Getwd is able to return paths
    28  // longer than syscall.PathMax (with or without PWD set).
    29  func testGetwdDeep(t *testing.T, setPWD bool) {
    30  	tempDir := t.TempDir()
    31  
    32  	dir := tempDir
    33  	t.Chdir(dir)
    34  
    35  	if setPWD {
    36  		t.Setenv("PWD", dir)
    37  	} else {
    38  		// When testing os.Getwd, setting PWD to empty string
    39  		// is the same as unsetting it, but the latter would
    40  		// be more complicated since we don't have t.Unsetenv.
    41  		t.Setenv("PWD", "")
    42  	}
    43  
    44  	name := strings.Repeat("a", 200)
    45  	for {
    46  		if err := Mkdir(name, 0o700); err != nil {
    47  			t.Fatal(err)
    48  		}
    49  		if err := Chdir(name); err != nil {
    50  			t.Fatal(err)
    51  		}
    52  		if setPWD {
    53  			dir += "/" + name
    54  			if err := Setenv("PWD", dir); err != nil {
    55  				t.Fatal(err)
    56  			}
    57  			t.Logf(" $PWD len: %d", len(dir))
    58  		}
    59  
    60  		wd, err := Getwd()
    61  		t.Logf("Getwd len: %d", len(wd))
    62  		if err != nil {
    63  			// We can get an EACCES error if we can't read up
    64  			// to root, which happens on the Android builders.
    65  			// We can also get EPERM in some sandboxes for the same reason.
    66  			if errors.Is(err, syscall.EACCES) || errors.Is(err, syscall.EPERM) {
    67  				t.Logf("ignoring EACCES/EPERM error: %v", err)
    68  				break
    69  			}
    70  			t.Fatal(err)
    71  		}
    72  		if setPWD && wd != dir {
    73  			// It's possible for the stat of PWD to fail
    74  			// with ENAMETOOLONG, and for getwd to fail for
    75  			// the same reason, and it's possible for $TMPDIR
    76  			// to contain a symlink. In that case the fallback
    77  			// code will not return the same directory.
    78  			if len(dir) > 1000 {
    79  				symDir, err := filepath.EvalSymlinks(tempDir)
    80  				if err == nil && symDir != tempDir {
    81  					t.Logf("EvalSymlinks(%q) = %q", tempDir, symDir)
    82  					if strings.Replace(dir, tempDir, symDir, 1) == wd {
    83  						// Symlink confusion is OK.
    84  						break
    85  					}
    86  				}
    87  			}
    88  
    89  			t.Fatalf("Getwd: got %q, want same value as $PWD: %q", wd, dir)
    90  		}
    91  		// Ideally the success criterion should be len(wd) > syscall.PathMax,
    92  		// but the latter is not public for some platforms, so use Stat(wd).
    93  		// When it fails with ENAMETOOLONG, it means:
    94  		//  - wd is longer than PathMax;
    95  		//  - Getwd have used the slow fallback code.
    96  		//
    97  		// To avoid an endless loop here in case Stat keeps working,
    98  		// check if len(wd) is above the largest known PathMax among
    99  		// all Unix platforms (4096, on Linux).
   100  		if _, err := Stat(wd); err != nil || len(wd) > 4096 {
   101  			t.Logf("Done; len(wd)=%d", len(wd))
   102  			// Most systems return ENAMETOOLONG.
   103  			// Dragonfly returns EFAULT.
   104  			switch {
   105  			case err == nil:
   106  			case errors.Is(err, syscall.ENAMETOOLONG):
   107  			case runtime.GOOS == "dragonfly" && errors.Is(err, syscall.EFAULT):
   108  			default:
   109  				t.Fatalf("unexpected Stat error: %v", err)
   110  			}
   111  			break
   112  		}
   113  	}
   114  }
   115
View as plain text