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 5 package filepath 6 7 import ( 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`). 18 func 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. 29 func 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 returns whether the last element of path is "..". 47 // The given path should be 'Clean'-ed in advance. 48 func 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. 63 func 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. 115 func 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 162 func 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 func evalSymlinks(path string) (string, error) { 175 newpath, err := walkSymlinks(path) 176 if err != nil { 177 newpath2, err2 := evalSymlinksUsingGetFinalPathNameByHandle(path) 178 if err2 == nil { 179 return toNorm(newpath2, normBase) 180 } 181 return "", err 182 } 183 newpath, err = toNorm(newpath, normBase) 184 if err != nil { 185 newpath2, err2 := evalSymlinksUsingGetFinalPathNameByHandle(path) 186 if err2 == nil { 187 return toNorm(newpath2, normBase) 188 } 189 return "", err 190 } 191 if strings.ToUpper(newpath) == strings.ToUpper(path) { 192 // walkSymlinks did not actually walk any symlinks, 193 // so we don't need to try GetFinalPathNameByHandle. 194 return newpath, nil 195 } 196 newpath2, err2 := evalSymlinksUsingGetFinalPathNameByHandle(path) 197 if err2 != nil { 198 return newpath, nil 199 } 200 newpath2, err2 = toNorm(newpath2, normBase) 201 if err2 != nil { 202 return newpath, nil 203 } 204 if samefile(newpath, newpath2) { 205 return newpath, nil 206 } 207 return newpath2, nil 208 } 209
