From fe637416e9e5a0ee6ed25dd9cfc4a13a40ae7631 Mon Sep 17 00:00:00 2001 From: "Stefan J. Wernli" Date: Mon, 24 Aug 2015 14:07:22 -0700 Subject: [PATCH] Windows: Fix long path handling for docker build Signed-off-by: Stefan J. Wernli --- archive/archive_windows.go | 7 +- chrootarchive/archive_windows.go | 3 +- chrootarchive/diff_windows.go | 6 +- directory/directory_windows.go | 8 ++ longpath/longpath.go | 21 +++++ symlink/README.md | 3 +- symlink/fs.go | 9 ++ symlink/fs_unix.go | 11 +++ symlink/fs_windows.go | 156 +++++++++++++++++++++++++++++++ 9 files changed, 214 insertions(+), 10 deletions(-) create mode 100644 longpath/longpath.go create mode 100644 symlink/fs_unix.go create mode 100644 symlink/fs_windows.go diff --git a/archive/archive_windows.go b/archive/archive_windows.go index ea93160..7d52105 100644 --- a/archive/archive_windows.go +++ b/archive/archive_windows.go @@ -8,15 +8,14 @@ import ( "os" "path/filepath" "strings" + + "github.com/docker/docker/pkg/longpath" ) // fixVolumePathPrefix does platform specific processing to ensure that if // the path being passed in is not in a volume path format, convert it to one. func fixVolumePathPrefix(srcPath string) string { - if !strings.HasPrefix(srcPath, `\\?\`) { - srcPath = `\\?\` + srcPath - } - return srcPath + return longpath.AddPrefix(srcPath) } // getWalkRoot calculates the root path when performing a TarWithOptions. diff --git a/chrootarchive/archive_windows.go b/chrootarchive/archive_windows.go index c44556c..0a500ed 100644 --- a/chrootarchive/archive_windows.go +++ b/chrootarchive/archive_windows.go @@ -4,6 +4,7 @@ import ( "io" "github.com/docker/docker/pkg/archive" + "github.com/docker/docker/pkg/longpath" ) // chroot is not supported by Windows @@ -17,5 +18,5 @@ func invokeUnpack(decompressedArchive io.ReadCloser, // Windows is different to Linux here because Windows does not support // chroot. Hence there is no point sandboxing a chrooted process to // do the unpack. We call inline instead within the daemon process. - return archive.Unpack(decompressedArchive, dest, options) + return archive.Unpack(decompressedArchive, longpath.AddPrefix(dest), options) } diff --git a/chrootarchive/diff_windows.go b/chrootarchive/diff_windows.go index a21bfe2..dcff5ac 100644 --- a/chrootarchive/diff_windows.go +++ b/chrootarchive/diff_windows.go @@ -5,9 +5,9 @@ import ( "io/ioutil" "os" "path/filepath" - "strings" "github.com/docker/docker/pkg/archive" + "github.com/docker/docker/pkg/longpath" ) // applyLayerHandler parses a diff in the standard layer format from `layer`, and @@ -17,9 +17,7 @@ func applyLayerHandler(dest string, layer archive.Reader, decompress bool) (size dest = filepath.Clean(dest) // Ensure it is a Windows-style volume path - if !strings.HasPrefix(dest, `\\?\`) { - dest = `\\?\` + dest - } + dest = longpath.AddPrefix(dest) if decompress { decompressed, err := archive.DecompressStream(layer) diff --git a/directory/directory_windows.go b/directory/directory_windows.go index 7a9f8cb..a0fc048 100644 --- a/directory/directory_windows.go +++ b/directory/directory_windows.go @@ -5,10 +5,18 @@ package directory import ( "os" "path/filepath" + "strings" + + "github.com/docker/docker/pkg/longpath" ) // Size walks a directory tree and returns its total size in bytes. func Size(dir string) (size int64, err error) { + fixedPath, err := filepath.Abs(dir) + if err != nil { + return + } + fixedPath = longpath.AddPrefix(fixedPath) err = filepath.Walk(dir, func(d string, fileInfo os.FileInfo, e error) error { // Ignore directory sizes if fileInfo == nil { diff --git a/longpath/longpath.go b/longpath/longpath.go new file mode 100644 index 0000000..1dcc10a --- /dev/null +++ b/longpath/longpath.go @@ -0,0 +1,21 @@ +// longpath introduces some constants and helper functions for handling long paths +// in Windows, which are expected to be prepended with `\\?\` and followed by either +// a drive letter, a UNC server\share, or a volume identifier. + +package longpath + +import ( + "strings" +) + +// Prefix is the longpath prefix for Windows file paths. +const Prefix = `\\?\` + +// AddPrefix will add the Windows long path prefix to the path provided if +// it does not already have it. +func AddPrefix(path string) string { + if !strings.HasPrefix(path, Prefix) { + path = Prefix + path + } + return path +} diff --git a/symlink/README.md b/symlink/README.md index 0d1dbb7..8dba54f 100644 --- a/symlink/README.md +++ b/symlink/README.md @@ -1,4 +1,5 @@ -Package symlink implements EvalSymlinksInScope which is an extension of filepath.EvalSymlinks +Package symlink implements EvalSymlinksInScope which is an extension of filepath.EvalSymlinks, +as well as a Windows long-path aware version of filepath.EvalSymlinks from the [Go standard library](https://golang.org/pkg/path/filepath). The code from filepath.EvalSymlinks has been adapted in fs.go. diff --git a/symlink/fs.go b/symlink/fs.go index d305500..dcf707f 100644 --- a/symlink/fs.go +++ b/symlink/fs.go @@ -132,3 +132,12 @@ func evalSymlinksInScope(path, root string) (string, error) { // what's happening here return filepath.Clean(root + filepath.Clean(string(filepath.Separator)+b.String())), nil } + +// EvalSymlinks returns the path name after the evaluation of any symbolic +// links. +// If path is relative the result will be relative to the current directory, +// unless one of the components is an absolute symbolic link. +// This version has been updated to support long paths prepended with `\\?\`. +func EvalSymlinks(path string) (string, error) { + return evalSymlinks(path) +} diff --git a/symlink/fs_unix.go b/symlink/fs_unix.go new file mode 100644 index 0000000..818004f --- /dev/null +++ b/symlink/fs_unix.go @@ -0,0 +1,11 @@ +// +build !windows + +package symlink + +import ( + "path/filepath" +) + +func evalSymlinks(path string) (string, error) { + return filepath.EvalSymlinks(path) +} diff --git a/symlink/fs_windows.go b/symlink/fs_windows.go new file mode 100644 index 0000000..29bd456 --- /dev/null +++ b/symlink/fs_windows.go @@ -0,0 +1,156 @@ +package symlink + +import ( + "bytes" + "errors" + "os" + "path/filepath" + "strings" + "syscall" + + "github.com/docker/docker/pkg/longpath" +) + +func toShort(path string) (string, error) { + p, err := syscall.UTF16FromString(path) + if err != nil { + return "", err + } + b := p // GetShortPathName says we can reuse buffer + n, err := syscall.GetShortPathName(&p[0], &b[0], uint32(len(b))) + if err != nil { + return "", err + } + if n > uint32(len(b)) { + b = make([]uint16, n) + n, err = syscall.GetShortPathName(&p[0], &b[0], uint32(len(b))) + if err != nil { + return "", err + } + } + return syscall.UTF16ToString(b), nil +} + +func toLong(path string) (string, error) { + p, err := syscall.UTF16FromString(path) + if err != nil { + return "", err + } + b := p // GetLongPathName says we can reuse buffer + n, err := syscall.GetLongPathName(&p[0], &b[0], uint32(len(b))) + if err != nil { + return "", err + } + if n > uint32(len(b)) { + b = make([]uint16, n) + n, err = syscall.GetLongPathName(&p[0], &b[0], uint32(len(b))) + if err != nil { + return "", err + } + } + b = b[:n] + return syscall.UTF16ToString(b), nil +} + +func evalSymlinks(path string) (string, error) { + path, err := walkSymlinks(path) + if err != nil { + return "", err + } + + p, err := toShort(path) + if err != nil { + return "", err + } + p, err = toLong(p) + if err != nil { + return "", err + } + // syscall.GetLongPathName does not change the case of the drive letter, + // but the result of EvalSymlinks must be unique, so we have + // EvalSymlinks(`c:\a`) == EvalSymlinks(`C:\a`). + // Make drive letter upper case. + if len(p) >= 2 && p[1] == ':' && 'a' <= p[0] && p[0] <= 'z' { + p = string(p[0]+'A'-'a') + p[1:] + } else if len(p) >= 6 && p[5] == ':' && 'a' <= p[4] && p[4] <= 'z' { + p = p[:3] + string(p[4]+'A'-'a') + p[5:] + } + return filepath.Clean(p), nil +} + +const utf8RuneSelf = 0x80 + +func walkSymlinks(path string) (string, error) { + const maxIter = 255 + originalPath := path + // consume path by taking each frontmost path element, + // expanding it if it's a symlink, and appending it to b + var b bytes.Buffer + for n := 0; path != ""; n++ { + if n > maxIter { + return "", errors.New("EvalSymlinks: too many links in " + originalPath) + } + + // A path beginnging with `\\?\` represents the root, so automatically + // skip that part and begin processing the next segment. + if strings.HasPrefix(path, longpath.Prefix) { + b.WriteString(longpath.Prefix) + path = path[4:] + continue + } + + // find next path component, p + var i = -1 + for j, c := range path { + if c < utf8RuneSelf && os.IsPathSeparator(uint8(c)) { + i = j + break + } + } + var p string + if i == -1 { + p, path = path, "" + } else { + p, path = path[:i], path[i+1:] + } + + if p == "" { + if b.Len() == 0 { + // must be absolute path + b.WriteRune(filepath.Separator) + } + continue + } + + // If this is the first segment after the long path prefix, accept the + // current segment as a volume root or UNC share and move on to the next. + if b.String() == longpath.Prefix { + b.WriteString(p) + b.WriteRune(filepath.Separator) + continue + } + + fi, err := os.Lstat(b.String() + p) + if err != nil { + return "", err + } + if fi.Mode()&os.ModeSymlink == 0 { + b.WriteString(p) + if path != "" || (b.Len() == 2 && len(p) == 2 && p[1] == ':') { + b.WriteRune(filepath.Separator) + } + continue + } + + // it's a symlink, put it at the front of path + dest, err := os.Readlink(b.String() + p) + if err != nil { + return "", err + } + if filepath.IsAbs(dest) || os.IsPathSeparator(dest[0]) { + b.Reset() + } + path = dest + string(filepath.Separator) + path + } + return filepath.Clean(b.String()), nil +}