blob: 1108b3ddff0bd70ddbbc3f95a8676797c03cf64a [file] [log] [blame]
// Copyright 2012 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package filepath
import (
"errors"
"internal/syscall/windows"
"os"
"strings"
"syscall"
)
// normVolumeName is like VolumeName, but makes drive letter upper case.
// result of EvalSymlinks must be unique, so we have
// EvalSymlinks(`c:\a`) == EvalSymlinks(`C:\a`).
func normVolumeName(path string) string {
volume := VolumeName(path)
if len(volume) > 2 { // isUNC
return volume
}
return strings.ToUpper(volume)
}
// normBase returns the last element of path with correct case.
func normBase(path string) (string, error) {
p, err := syscall.UTF16PtrFromString(path)
if err != nil {
return "", err
}
var data syscall.Win32finddata
h, err := syscall.FindFirstFile(p, &data)
if err != nil {
return "", err
}
syscall.FindClose(h)
return syscall.UTF16ToString(data.FileName[:]), nil
}
// baseIsDotDot reports whether the last element of path is "..".
// The given path should be 'Clean'-ed in advance.
func baseIsDotDot(path string) bool {
i := strings.LastIndexByte(path, Separator)
return path[i+1:] == ".."
}
// toNorm returns the normalized path that is guaranteed to be unique.
// It should accept the following formats:
// * UNC paths (e.g \\server\share\foo\bar)
// * absolute paths (e.g C:\foo\bar)
// * relative paths begin with drive letter (e.g C:foo\bar, C:..\foo\bar, C:.., C:.)
// * relative paths begin with '\' (e.g \foo\bar)
// * relative paths begin without '\' (e.g foo\bar, ..\foo\bar, .., .)
// The returned normalized path will be in the same form (of 5 listed above) as the input path.
// If two paths A and B are indicating the same file with the same format, toNorm(A) should be equal to toNorm(B).
// The normBase parameter should be equal to the normBase func, except for in tests. See docs on the normBase func.
func toNorm(path string, normBase func(string) (string, error)) (string, error) {
if path == "" {
return path, nil
}
path = Clean(path)
volume := normVolumeName(path)
path = path[len(volume):]
// skip special cases
if path == "." || path == `\` {
return volume + path, nil
}
var normPath string
for {
if baseIsDotDot(path) {
normPath = path + `\` + normPath
break
}
name, err := normBase(volume + path)
if err != nil {
return "", err
}
normPath = name + `\` + normPath
i := strings.LastIndexByte(path, Separator)
if i == -1 {
break
}
if i == 0 { // `\Go` or `C:\Go`
normPath = `\` + normPath
break
}
path = path[:i]
}
normPath = normPath[:len(normPath)-1] // remove trailing '\'
return volume + normPath, nil
}
// evalSymlinksUsingGetFinalPathNameByHandle uses Windows
// GetFinalPathNameByHandle API to retrieve the final
// path for the specified file.
func evalSymlinksUsingGetFinalPathNameByHandle(path string) (string, error) {
err := windows.LoadGetFinalPathNameByHandle()
if err != nil {
// we must be using old version of Windows
return "", err
}
if path == "" {
return path, nil
}
// Use Windows I/O manager to dereference the symbolic link, as per
// https://blogs.msdn.microsoft.com/oldnewthing/20100212-00/?p=14963/
p, err := syscall.UTF16PtrFromString(path)
if err != nil {
return "", err
}
h, err := syscall.CreateFile(p, 0, 0, nil,
syscall.OPEN_EXISTING, syscall.FILE_FLAG_BACKUP_SEMANTICS, 0)
if err != nil {
return "", err
}
defer syscall.CloseHandle(h)
buf := make([]uint16, 100)
for {
n, err := windows.GetFinalPathNameByHandle(h, &buf[0], uint32(len(buf)), windows.VOLUME_NAME_DOS)
if err != nil {
return "", err
}
if n < uint32(len(buf)) {
break
}
buf = make([]uint16, n)
}
s := syscall.UTF16ToString(buf)
if len(s) > 4 && s[:4] == `\\?\` {
s = s[4:]
if len(s) > 3 && s[:3] == `UNC` {
// return path like \\server\share\...
return `\` + s[3:], nil
}
return s, nil
}
return "", errors.New("GetFinalPathNameByHandle returned unexpected path=" + s)
}
func symlinkOrDir(path string) (string, error) {
fi, err := os.Lstat(path)
if err != nil {
return "", err
}
if fi.Mode()&os.ModeSymlink == 0 && !fi.Mode().IsDir() {
return "", syscall.ENOTDIR
}
return path, nil
}
func samefile(path1, path2 string) bool {
fi1, err := os.Lstat(path1)
if err != nil {
return false
}
fi2, err := os.Lstat(path2)
if err != nil {
return false
}
return os.SameFile(fi1, fi2)
}
func evalSymlinks(path string) (string, error) {
newpath, err := walkSymlinks(path)
if err != nil {
newpath2, err2 := evalSymlinksUsingGetFinalPathNameByHandle(path)
if err2 == nil {
normPath, toNormErr := toNorm(newpath2, normBase)
if toNormErr != nil {
return "", toNormErr
}
return symlinkOrDir(normPath)
}
return "", err
}
newpath, err = toNorm(newpath, normBase)
if err != nil {
newpath2, err2 := evalSymlinksUsingGetFinalPathNameByHandle(path)
if err2 == nil {
return toNorm(newpath2, normBase)
}
return "", err
}
if strings.ToUpper(newpath) == strings.ToUpper(path) {
// walkSymlinks did not actually walk any symlinks,
// so we don't need to try GetFinalPathNameByHandle.
return newpath, nil
}
newpath2, err2 := evalSymlinksUsingGetFinalPathNameByHandle(path)
if err2 != nil {
return newpath, nil
}
newpath2, err2 = toNorm(newpath2, normBase)
if err2 != nil {
return newpath, nil
}
if samefile(newpath, newpath2) {
return newpath, nil
}
return newpath2, nil
}