getwd.go

     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  package os
     6  
     7  import (
     8  	"runtime"
     9  	"sync"
    10  	"syscall"
    11  )
    12  
    13  var getwdCache struct {
    14  	sync.Mutex
    15  	dir string
    16  }
    17  
    18  // Getwd returns a rooted path name corresponding to the
    19  // current directory. If the current directory can be
    20  // reached via multiple paths (due to symbolic links),
    21  // Getwd may return any one of them.
    22  func Getwd() (dir string, err error) {
    23  	if runtime.GOOS == "windows" || runtime.GOOS == "plan9" {
    24  		return syscall.Getwd()
    25  	}
    26  
    27  	// Clumsy but widespread kludge:
    28  	// if $PWD is set and matches ".", use it.
    29  	dot, err := statNolog(".")
    30  	if err != nil {
    31  		return "", err
    32  	}
    33  	dir = Getenv("PWD")
    34  	if len(dir) > 0 && dir[0] == '/' {
    35  		d, err := statNolog(dir)
    36  		if err == nil && SameFile(dot, d) {
    37  			return dir, nil
    38  		}
    39  	}
    40  
    41  	// If the operating system provides a Getwd call, use it.
    42  	// Otherwise, we're trying to find our way back to ".".
    43  	if syscall.ImplementsGetwd {
    44  		var (
    45  			s string
    46  			e error
    47  		)
    48  		for {
    49  			s, e = syscall.Getwd()
    50  			if e != syscall.EINTR {
    51  				break
    52  			}
    53  		}
    54  		return s, NewSyscallError("getwd", e)
    55  	}
    56  
    57  	// Apply same kludge but to cached dir instead of $PWD.
    58  	getwdCache.Lock()
    59  	dir = getwdCache.dir
    60  	getwdCache.Unlock()
    61  	if len(dir) > 0 {
    62  		d, err := statNolog(dir)
    63  		if err == nil && SameFile(dot, d) {
    64  			return dir, nil
    65  		}
    66  	}
    67  
    68  	// Root is a special case because it has no parent
    69  	// and ends in a slash.
    70  	root, err := statNolog("/")
    71  	if err != nil {
    72  		// Can't stat root - no hope.
    73  		return "", err
    74  	}
    75  	if SameFile(root, dot) {
    76  		return "/", nil
    77  	}
    78  
    79  	// General algorithm: find name in parent
    80  	// and then find name of parent. Each iteration
    81  	// adds /name to the beginning of dir.
    82  	dir = ""
    83  	for parent := ".."; ; parent = "../" + parent {
    84  		if len(parent) >= 1024 { // Sanity check
    85  			return "", syscall.ENAMETOOLONG
    86  		}
    87  		fd, err := openFileNolog(parent, O_RDONLY, 0)
    88  		if err != nil {
    89  			return "", err
    90  		}
    91  
    92  		for {
    93  			names, err := fd.Readdirnames(100)
    94  			if err != nil {
    95  				fd.Close()
    96  				return "", err
    97  			}
    98  			for _, name := range names {
    99  				d, _ := lstatNolog(parent + "/" + name)
   100  				if SameFile(d, dot) {
   101  					dir = "/" + name + dir
   102  					goto Found
   103  				}
   104  			}
   105  		}
   106  
   107  	Found:
   108  		pd, err := fd.Stat()
   109  		fd.Close()
   110  		if err != nil {
   111  			return "", err
   112  		}
   113  		if SameFile(pd, root) {
   114  			break
   115  		}
   116  		// Set up for next round.
   117  		dot = pd
   118  	}
   119  
   120  	// Save answer as hint to avoid the expensive path next time.
   121  	getwdCache.Lock()
   122  	getwdCache.dir = dir
   123  	getwdCache.Unlock()
   124  
   125  	return dir, nil
   126  }
   127
View as plain text