1// Copyright 2012 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 5package filepath 6 7import ( 8 "errors" 9 "internal/syscall/windows" 10 "os" 11 "strings" 12 "syscall" 13) 14 15// normVolumeName is like VolumeName, but makes drive letter upper case. 16// result of EvalSymlinks must be unique, so we have 17// EvalSymlinks(`c:\a`) == EvalSymlinks(`C:\a`). 18func normVolumeName(path string) string { 19 volume := VolumeName(path) 20 21 if len(volume) > 2 { // isUNC 22 return volume 23 } 24 25 return strings.ToUpper(volume) 26} 27 28// normBase returns the last element of path with correct case. 29func normBase(path string) (string, error) { 30 p, err := syscall.UTF16PtrFromString(path) 31 if err != nil { 32 return "", err 33 } 34 35 var data syscall.Win32finddata 36 37 h, err := syscall.FindFirstFile(p, &data) 38 if err != nil { 39 return "", err 40 } 41 syscall.FindClose(h) 42 43 return syscall.UTF16ToString(data.FileName[:]), nil 44} 45 46// baseIsDotDot reports whether the last element of path is "..". 47// The given path should be 'Clean'-ed in advance. 48func baseIsDotDot(path string) bool { 49 i := strings.LastIndexByte(path, Separator) 50 return path[i+1:] == ".." 51} 52 53// toNorm returns the normalized path that is guaranteed to be unique. 54// It should accept the following formats: 55// * UNC paths (e.g \\server\share\foo\bar) 56// * absolute paths (e.g C:\foo\bar) 57// * relative paths begin with drive letter (e.g C:foo\bar, C:..\foo\bar, C:.., C:.) 58// * relative paths begin with '\' (e.g \foo\bar) 59// * relative paths begin without '\' (e.g foo\bar, ..\foo\bar, .., .) 60// The returned normalized path will be in the same form (of 5 listed above) as the input path. 61// If two paths A and B are indicating the same file with the same format, toNorm(A) should be equal to toNorm(B). 62// The normBase parameter should be equal to the normBase func, except for in tests. See docs on the normBase func. 63func toNorm(path string, normBase func(string) (string, error)) (string, error) { 64 if path == "" { 65 return path, nil 66 } 67 68 path = Clean(path) 69 70 volume := normVolumeName(path) 71 path = path[len(volume):] 72 73 // skip special cases 74 if path == "." || path == `\` { 75 return volume + path, nil 76 } 77 78 var normPath string 79 80 for { 81 if baseIsDotDot(path) { 82 normPath = path + `\` + normPath 83 84 break 85 } 86 87 name, err := normBase(volume + path) 88 if err != nil { 89 return "", err 90 } 91 92 normPath = name + `\` + normPath 93 94 i := strings.LastIndexByte(path, Separator) 95 if i == -1 { 96 break 97 } 98 if i == 0 { // `\Go` or `C:\Go` 99 normPath = `\` + normPath 100 101 break 102 } 103 104 path = path[:i] 105 } 106 107 normPath = normPath[:len(normPath)-1] // remove trailing '\' 108 109 return volume + normPath, nil 110} 111 112// evalSymlinksUsingGetFinalPathNameByHandle uses Windows 113// GetFinalPathNameByHandle API to retrieve the final 114// path for the specified file. 115func evalSymlinksUsingGetFinalPathNameByHandle(path string) (string, error) { 116 err := windows.LoadGetFinalPathNameByHandle() 117 if err != nil { 118 // we must be using old version of Windows 119 return "", err 120 } 121 122 if path == "" { 123 return path, nil 124 } 125 126 // Use Windows I/O manager to dereference the symbolic link, as per 127 // https://blogs.msdn.microsoft.com/oldnewthing/20100212-00/?p=14963/ 128 p, err := syscall.UTF16PtrFromString(path) 129 if err != nil { 130 return "", err 131 } 132 h, err := syscall.CreateFile(p, 0, 0, nil, 133 syscall.OPEN_EXISTING, syscall.FILE_FLAG_BACKUP_SEMANTICS, 0) 134 if err != nil { 135 return "", err 136 } 137 defer syscall.CloseHandle(h) 138 139 buf := make([]uint16, 100) 140 for { 141 n, err := windows.GetFinalPathNameByHandle(h, &buf[0], uint32(len(buf)), windows.VOLUME_NAME_DOS) 142 if err != nil { 143 return "", err 144 } 145 if n < uint32(len(buf)) { 146 break 147 } 148 buf = make([]uint16, n) 149 } 150 s := syscall.UTF16ToString(buf) 151 if len(s) > 4 && s[:4] == `\\?\` { 152 s = s[4:] 153 if len(s) > 3 && s[:3] == `UNC` { 154 // return path like \\server\share\... 155 return `\` + s[3:], nil 156 } 157 return s, nil 158 } 159 return "", errors.New("GetFinalPathNameByHandle returned unexpected path=" + s) 160} 161 162func samefile(path1, path2 string) bool { 163 fi1, err := os.Lstat(path1) 164 if err != nil { 165 return false 166 } 167 fi2, err := os.Lstat(path2) 168 if err != nil { 169 return false 170 } 171 return os.SameFile(fi1, fi2) 172} 173 174// walkSymlinks returns slashAfterFilePathError error for paths like 175// //path/to/existing_file/ and /path/to/existing_file/. and /path/to/existing_file/.. 176 177var slashAfterFilePathError = errors.New("attempting to walk past file path.") 178 179func evalSymlinks(path string) (string, error) { 180 newpath, err := walkSymlinks(path) 181 if err == slashAfterFilePathError { 182 return "", syscall.ENOTDIR 183 } 184 if err != nil { 185 newpath2, err2 := evalSymlinksUsingGetFinalPathNameByHandle(path) 186 if err2 == nil { 187 return toNorm(newpath2, normBase) 188 } 189 return "", err 190 } 191 newpath, err = toNorm(newpath, normBase) 192 if err != nil { 193 newpath2, err2 := evalSymlinksUsingGetFinalPathNameByHandle(path) 194 if err2 == nil { 195 return toNorm(newpath2, normBase) 196 } 197 return "", err 198 } 199 if strings.ToUpper(newpath) == strings.ToUpper(path) { 200 // walkSymlinks did not actually walk any symlinks, 201 // so we don't need to try GetFinalPathNameByHandle. 202 return newpath, nil 203 } 204 newpath2, err2 := evalSymlinksUsingGetFinalPathNameByHandle(path) 205 if err2 != nil { 206 return newpath, nil 207 } 208 newpath2, err2 = toNorm(newpath2, normBase) 209 if err2 != nil { 210 return newpath, nil 211 } 212 if samefile(newpath, newpath2) { 213 return newpath, nil 214 } 215 return newpath2, nil 216} 217