path_windows.go

     1  // Copyright 2011 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  	"internal/filepathlite"
     9  	"internal/syscall/windows"
    10  	"syscall"
    11  )
    12  
    13  const (
    14  	PathSeparator     = '\\' // OS-specific path separator
    15  	PathListSeparator = ';'  // OS-specific path list separator
    16  )
    17  
    18  // IsPathSeparator reports whether c is a directory separator character.
    19  func IsPathSeparator(c uint8) bool {
    20  	// NOTE: Windows accepts / as path separator.
    21  	return c == '\\' || c == '/'
    22  }
    23  
    24  // splitPath returns the base name and parent directory.
    25  func splitPath(path string) (string, string) {
    26  	dirname, basename := filepathlite.Split(path)
    27  	volnamelen := filepathlite.VolumeNameLen(dirname)
    28  	for len(dirname) > volnamelen && IsPathSeparator(dirname[len(dirname)-1]) {
    29  		dirname = dirname[:len(dirname)-1]
    30  	}
    31  	return dirname, basename
    32  }
    33  
    34  func dirname(path string) string {
    35  	vol := filepathlite.VolumeName(path)
    36  	i := len(path) - 1
    37  	for i >= len(vol) && !IsPathSeparator(path[i]) {
    38  		i--
    39  	}
    40  	dir := path[len(vol) : i+1]
    41  	last := len(dir) - 1
    42  	if last > 0 && IsPathSeparator(dir[last]) {
    43  		dir = dir[:last]
    44  	}
    45  	if dir == "" {
    46  		dir = "."
    47  	}
    48  	return vol + dir
    49  }
    50  
    51  // fixLongPath returns the extended-length (\\?\-prefixed) form of
    52  // path when needed, in order to avoid the default 260 character file
    53  // path limit imposed by Windows. If the path is short enough or already
    54  // has the extended-length prefix, fixLongPath returns path unmodified.
    55  // If the path is relative and joining it with the current working
    56  // directory results in a path that is too long, fixLongPath returns
    57  // the absolute path with the extended-length prefix.
    58  //
    59  // See https://learn.microsoft.com/en-us/windows/win32/fileio/naming-a-file#maximum-path-length-limitation
    60  func fixLongPath(path string) string {
    61  	if windows.CanUseLongPaths {
    62  		return path
    63  	}
    64  	return addExtendedPrefix(path)
    65  }
    66  
    67  // addExtendedPrefix adds the extended path prefix (\\?\) to path.
    68  func addExtendedPrefix(path string) string {
    69  	if len(path) >= 4 {
    70  		if path[:4] == `\??\` {
    71  			// Already extended with \??\
    72  			return path
    73  		}
    74  		if IsPathSeparator(path[0]) && IsPathSeparator(path[1]) && path[2] == '?' && IsPathSeparator(path[3]) {
    75  			// Already extended with \\?\ or any combination of directory separators.
    76  			return path
    77  		}
    78  	}
    79  
    80  	// Do nothing (and don't allocate) if the path is "short".
    81  	// Empirically (at least on the Windows Server 2013 builder),
    82  	// the kernel is arbitrarily okay with < 248 bytes. That
    83  	// matches what the docs above say:
    84  	// "When using an API to create a directory, the specified
    85  	// path cannot be so long that you cannot append an 8.3 file
    86  	// name (that is, the directory name cannot exceed MAX_PATH
    87  	// minus 12)." Since MAX_PATH is 260, 260 - 12 = 248.
    88  	//
    89  	// The MSDN docs appear to say that a normal path that is 248 bytes long
    90  	// will work; empirically the path must be less then 248 bytes long.
    91  	pathLength := len(path)
    92  	if !filepathlite.IsAbs(path) {
    93  		// If the path is relative, we need to prepend the working directory
    94  		// plus a separator to the path before we can determine if it's too long.
    95  		// We don't want to call syscall.Getwd here, as that call is expensive to do
    96  		// every time fixLongPath is called with a relative path, so we use a cache.
    97  		// Note that getwdCache might be outdated if the working directory has been
    98  		// changed without using os.Chdir, i.e. using syscall.Chdir directly or cgo.
    99  		// This is fine, as the worst that can happen is that we fail to fix the path.
   100  		getwdCache.Lock()
   101  		if getwdCache.dir == "" {
   102  			// Init the working directory cache.
   103  			getwdCache.dir, _ = syscall.Getwd()
   104  		}
   105  		pathLength += len(getwdCache.dir) + 1
   106  		getwdCache.Unlock()
   107  	}
   108  
   109  	if pathLength < 248 {
   110  		// Don't fix. (This is how Go 1.7 and earlier worked,
   111  		// not automatically generating the \\?\ form)
   112  		return path
   113  	}
   114  
   115  	var isUNC, isDevice bool
   116  	if len(path) >= 2 && IsPathSeparator(path[0]) && IsPathSeparator(path[1]) {
   117  		if len(path) >= 4 && path[2] == '.' && IsPathSeparator(path[3]) {
   118  			// Starts with //./
   119  			isDevice = true
   120  		} else {
   121  			// Starts with //
   122  			isUNC = true
   123  		}
   124  	}
   125  	var prefix []uint16
   126  	if isUNC {
   127  		// UNC path, prepend the \\?\UNC\ prefix.
   128  		prefix = []uint16{'\\', '\\', '?', '\\', 'U', 'N', 'C', '\\'}
   129  	} else if isDevice {
   130  		// Don't add the extended prefix to device paths, as it would
   131  		// change its meaning.
   132  	} else {
   133  		prefix = []uint16{'\\', '\\', '?', '\\'}
   134  	}
   135  
   136  	p, err := syscall.UTF16FromString(path)
   137  	if err != nil {
   138  		return path
   139  	}
   140  	// Estimate the required buffer size using the path length plus the null terminator.
   141  	// pathLength includes the working directory. This should be accurate unless
   142  	// the working directory has changed without using os.Chdir.
   143  	n := uint32(pathLength) + 1
   144  	var buf []uint16
   145  	for {
   146  		buf = make([]uint16, n+uint32(len(prefix)))
   147  		n, err = syscall.GetFullPathName(&p[0], n, &buf[len(prefix)], nil)
   148  		if err != nil {
   149  			return path
   150  		}
   151  		if n <= uint32(len(buf)-len(prefix)) {
   152  			buf = buf[:n+uint32(len(prefix))]
   153  			break
   154  		}
   155  	}
   156  	if isUNC {
   157  		// Remove leading \\.
   158  		buf = buf[2:]
   159  	}
   160  	copy(buf, prefix)
   161  	return syscall.UTF16ToString(buf)
   162  }
   163
View as plain text