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	"strings"
9	"syscall"
10)
11
12// normVolumeName is like VolumeName, but makes drive letter upper case.
13// result of EvalSymlinks must be unique, so we have
14// EvalSymlinks(`c:\a`) == EvalSymlinks(`C:\a`).
15func normVolumeName(path string) string {
16	volume := VolumeName(path)
17
18	if len(volume) > 2 { // isUNC
19		return volume
20	}
21
22	return strings.ToUpper(volume)
23}
24
25// normBase returns the last element of path with correct case.
26func normBase(path string) (string, error) {
27	p, err := syscall.UTF16PtrFromString(path)
28	if err != nil {
29		return "", err
30	}
31
32	var data syscall.Win32finddata
33
34	h, err := syscall.FindFirstFile(p, &data)
35	if err != nil {
36		return "", err
37	}
38	syscall.FindClose(h)
39
40	return syscall.UTF16ToString(data.FileName[:]), nil
41}
42
43// baseIsDotDot reports whether the last element of path is "..".
44// The given path should be 'Clean'-ed in advance.
45func baseIsDotDot(path string) bool {
46	i := strings.LastIndexByte(path, Separator)
47	return path[i+1:] == ".."
48}
49
50// toNorm returns the normalized path that is guaranteed to be unique.
51// It should accept the following formats:
52//   * UNC paths                              (e.g \\server\share\foo\bar)
53//   * absolute paths                         (e.g C:\foo\bar)
54//   * relative paths begin with drive letter (e.g C:foo\bar, C:..\foo\bar, C:.., C:.)
55//   * relative paths begin with '\'          (e.g \foo\bar)
56//   * relative paths begin without '\'       (e.g foo\bar, ..\foo\bar, .., .)
57// The returned normalized path will be in the same form (of 5 listed above) as the input path.
58// If two paths A and B are indicating the same file with the same format, toNorm(A) should be equal to toNorm(B).
59// The normBase parameter should be equal to the normBase func, except for in tests.  See docs on the normBase func.
60func toNorm(path string, normBase func(string) (string, error)) (string, error) {
61	if path == "" {
62		return path, nil
63	}
64
65	path = Clean(path)
66
67	volume := normVolumeName(path)
68	path = path[len(volume):]
69
70	// skip special cases
71	if path == "" || path == "." || path == `\` {
72		return volume + path, nil
73	}
74
75	var normPath string
76
77	for {
78		if baseIsDotDot(path) {
79			normPath = path + `\` + normPath
80
81			break
82		}
83
84		name, err := normBase(volume + path)
85		if err != nil {
86			return "", err
87		}
88
89		normPath = name + `\` + normPath
90
91		i := strings.LastIndexByte(path, Separator)
92		if i == -1 {
93			break
94		}
95		if i == 0 { // `\Go` or `C:\Go`
96			normPath = `\` + normPath
97
98			break
99		}
100
101		path = path[:i]
102	}
103
104	normPath = normPath[:len(normPath)-1] // remove trailing '\'
105
106	return volume + normPath, nil
107}
108
109func evalSymlinks(path string) (string, error) {
110	newpath, err := walkSymlinks(path)
111	if err != nil {
112		return "", err
113	}
114	newpath, err = toNorm(newpath, normBase)
115	if err != nil {
116		return "", err
117	}
118	return newpath, nil
119}
120