vendor/github.com/containerd/containerd/sys/filesys_windows.go - third_party/github.com/docker/docker - Git at Google

 // +build windows

 /*
    Copyright The containerd Authors.

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

        http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
 */

 package sys

 import (
 	"os"
 	"path/filepath"
 	"regexp"
 	"strings"
 	"syscall"
 	"unsafe"

 	winio "github.com/Microsoft/go-winio"
 	"github.com/Microsoft/hcsshim"
 )

 const (
 	// SddlAdministratorsLocalSystem is local administrators plus NT AUTHORITY\System
 	SddlAdministratorsLocalSystem = "D:P(A;OICI;GA;;;BA)(A;OICI;GA;;;SY)"
 )

 // MkdirAllWithACL is a wrapper for MkdirAll that creates a directory
 // ACL'd for Builtin Administrators and Local System.
 func MkdirAllWithACL(path string, perm os.FileMode) error {
 	return mkdirall(path, true)
 }

 // MkdirAll implementation that is volume path aware for Windows.
 func MkdirAll(path string, _ os.FileMode) error {
 	return mkdirall(path, false)
 }

 // mkdirall is a custom version of os.MkdirAll modified for use on Windows
 // so that it is both volume path aware, and can create a directory with
 // a DACL.
 func mkdirall(path string, adminAndLocalSystem bool) error {
 	if re := regexp.MustCompile(`^\\\\\?\\Volume{[a-z0-9-]+}$`); re.MatchString(path) {
 		return nil
 	}

 	// The rest of this method is largely copied from os.MkdirAll and should be kept
 	// as-is to ensure compatibility.

 	// Fast path: if we can tell whether path is a directory or file, stop with success or error.
 	dir, err := os.Stat(path)
 	if err == nil {
 		if dir.IsDir() {
 			return nil
 		}
 		return &os.PathError{
 			Op:   "mkdir",
 			Path: path,
 			Err:  syscall.ENOTDIR,
 		}
 	}

 	// Slow path: make sure parent exists and then call Mkdir for path.
 	i := len(path)
 	for i > 0 && os.IsPathSeparator(path[i-1]) { // Skip trailing path separator.
 		i--
 	}

 	j := i
 	for j > 0 && !os.IsPathSeparator(path[j-1]) { // Scan backward over element.
 		j--
 	}

 	if j > 1 {
 		// Create parent
 		err = mkdirall(path[0:j-1], adminAndLocalSystem)
 		if err != nil {
 			return err
 		}
 	}

 	// Parent now exists; invoke os.Mkdir or mkdirWithACL and use its result.
 	if adminAndLocalSystem {
 		err = mkdirWithACL(path)
 	} else {
 		err = os.Mkdir(path, 0)
 	}

 	if err != nil {
 		// Handle arguments like "foo/." by
 		// double-checking that directory doesn't exist.
 		dir, err1 := os.Lstat(path)
 		if err1 == nil && dir.IsDir() {
 			return nil
 		}
 		return err
 	}
 	return nil
 }

 // mkdirWithACL creates a new directory. If there is an error, it will be of
 // type *PathError. .
 //
 // This is a modified and combined version of os.Mkdir and syscall.Mkdir
 // in golang to cater for creating a directory am ACL permitting full
 // access, with inheritance, to any subfolder/file for Built-in Administrators
 // and Local System.
 func mkdirWithACL(name string) error {
 	sa := syscall.SecurityAttributes{Length: 0}
 	sd, err := winio.SddlToSecurityDescriptor(SddlAdministratorsLocalSystem)
 	if err != nil {
 		return &os.PathError{Op: "mkdir", Path: name, Err: err}
 	}
 	sa.Length = uint32(unsafe.Sizeof(sa))
 	sa.InheritHandle = 1
 	sa.SecurityDescriptor = uintptr(unsafe.Pointer(&sd[0]))

 	namep, err := syscall.UTF16PtrFromString(name)
 	if err != nil {
 		return &os.PathError{Op: "mkdir", Path: name, Err: err}
 	}

 	e := syscall.CreateDirectory(namep, &sa)
 	if e != nil {
 		return &os.PathError{Op: "mkdir", Path: name, Err: e}
 	}
 	return nil
 }

 // IsAbs is a platform-specific wrapper for filepath.IsAbs. On Windows,
 // golang filepath.IsAbs does not consider a path \windows\system32 as absolute
 // as it doesn't start with a drive-letter/colon combination. However, in
 // docker we need to verify things such as WORKDIR /windows/system32 in
 // a Dockerfile (which gets translated to \windows\system32 when being processed
 // by the daemon. This SHOULD be treated as absolute from a docker processing
 // perspective.
 func IsAbs(path string) bool {
 	if !filepath.IsAbs(path) {
 		if !strings.HasPrefix(path, string(os.PathSeparator)) {
 			return false
 		}
 	}
 	return true
 }

 // The origin of the functions below here are the golang OS and syscall packages,
 // slightly modified to only cope with files, not directories due to the
 // specific use case.
 //
 // The alteration is to allow a file on Windows to be opened with
 // FILE_FLAG_SEQUENTIAL_SCAN (particular for docker load), to avoid eating
 // the standby list, particularly when accessing large files such as layer.tar.

 // CreateSequential creates the named file with mode 0666 (before umask), truncating
 // it if it already exists. If successful, methods on the returned
 // File can be used for I/O; the associated file descriptor has mode
 // O_RDWR.
 // If there is an error, it will be of type *PathError.
 func CreateSequential(name string) (*os.File, error) {
 	return OpenFileSequential(name, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0)
 }

 // OpenSequential opens the named file for reading. If successful, methods on
 // the returned file can be used for reading; the associated file
 // descriptor has mode O_RDONLY.
 // If there is an error, it will be of type *PathError.
 func OpenSequential(name string) (*os.File, error) {
 	return OpenFileSequential(name, os.O_RDONLY, 0)
 }

 // OpenFileSequential is the generalized open call; most users will use Open
 // or Create instead.
 // If there is an error, it will be of type *PathError.
 func OpenFileSequential(name string, flag int, _ os.FileMode) (*os.File, error) {
 	if name == "" {
 		return nil, &os.PathError{Op: "open", Path: name, Err: syscall.ENOENT}
 	}
 	r, errf := syscallOpenFileSequential(name, flag, 0)
 	if errf == nil {
 		return r, nil
 	}
 	return nil, &os.PathError{Op: "open", Path: name, Err: errf}
 }

 func syscallOpenFileSequential(name string, flag int, _ os.FileMode) (file *os.File, err error) {
 	r, e := syscallOpenSequential(name, flag|syscall.O_CLOEXEC, 0)
 	if e != nil {
 		return nil, e
 	}
 	return os.NewFile(uintptr(r), name), nil
 }

 func makeInheritSa() *syscall.SecurityAttributes {
 	var sa syscall.SecurityAttributes
 	sa.Length = uint32(unsafe.Sizeof(sa))
 	sa.InheritHandle = 1
 	return &sa
 }

 func syscallOpenSequential(path string, mode int, _ uint32) (fd syscall.Handle, err error) {
 	if len(path) == 0 {
 		return syscall.InvalidHandle, syscall.ERROR_FILE_NOT_FOUND
 	}
 	pathp, err := syscall.UTF16PtrFromString(path)
 	if err != nil {
 		return syscall.InvalidHandle, err
 	}
 	var access uint32
 	switch mode & (syscall.O_RDONLY | syscall.O_WRONLY | syscall.O_RDWR) {
 	case syscall.O_RDONLY:
 		access = syscall.GENERIC_READ
 	case syscall.O_WRONLY:
 		access = syscall.GENERIC_WRITE
 	case syscall.O_RDWR:
 		access = syscall.GENERIC_READ | syscall.GENERIC_WRITE
 	}
 	if mode&syscall.O_CREAT != 0 {
 		access |= syscall.GENERIC_WRITE
 	}
 	if mode&syscall.O_APPEND != 0 {
 		access &^= syscall.GENERIC_WRITE
 		access |= syscall.FILE_APPEND_DATA
 	}
 	sharemode := uint32(syscall.FILE_SHARE_READ | syscall.FILE_SHARE_WRITE)
 	var sa *syscall.SecurityAttributes
 	if mode&syscall.O_CLOEXEC == 0 {
 		sa = makeInheritSa()
 	}
 	var createmode uint32
 	switch {
 	case mode&(syscall.O_CREAT|syscall.O_EXCL) == (syscall.O_CREAT | syscall.O_EXCL):
 		createmode = syscall.CREATE_NEW
 	case mode&(syscall.O_CREAT|syscall.O_TRUNC) == (syscall.O_CREAT | syscall.O_TRUNC):
 		createmode = syscall.CREATE_ALWAYS
 	case mode&syscall.O_CREAT == syscall.O_CREAT:
 		createmode = syscall.OPEN_ALWAYS
 	case mode&syscall.O_TRUNC == syscall.O_TRUNC:
 		createmode = syscall.TRUNCATE_EXISTING
 	default:
 		createmode = syscall.OPEN_EXISTING
 	}
 	// Use FILE_FLAG_SEQUENTIAL_SCAN rather than FILE_ATTRIBUTE_NORMAL as implemented in golang.
 	//https://msdn.microsoft.com/en-us/library/windows/desktop/aa363858(v=vs.85).aspx
 	const fileFlagSequentialScan = 0x08000000 // FILE_FLAG_SEQUENTIAL_SCAN
 	h, e := syscall.CreateFile(pathp, access, sharemode, sa, createmode, fileFlagSequentialScan, 0)
 	return h, e
 }

 // ForceRemoveAll is the same as os.RemoveAll, but uses hcsshim.DestroyLayer in order
 // to delete container layers.
 func ForceRemoveAll(path string) error {
 	info := hcsshim.DriverInfo{
 		HomeDir: filepath.Dir(path),
 	}

 	return hcsshim.DestroyLayer(info, filepath.Base(path))
 }
	// +build windows

	/*
	Copyright The containerd Authors.

	Licensed under the Apache License, Version 2.0 (the "License");
	you may not use this file except in compliance with the License.
	You may obtain a copy of the License at

	http://www.apache.org/licenses/LICENSE-2.0

	Unless required by applicable law or agreed to in writing, software
	distributed under the License is distributed on an "AS IS" BASIS,
	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	See the License for the specific language governing permissions and
	limitations under the License.
	*/

	package sys

	import (
	"os"
	"path/filepath"
	"regexp"
	"strings"
	"syscall"
	"unsafe"

	winio "github.com/Microsoft/go-winio"
	"github.com/Microsoft/hcsshim"
	)

	const (
	// SddlAdministratorsLocalSystem is local administrators plus NT AUTHORITY\System
	SddlAdministratorsLocalSystem = "D:P(A;OICI;GA;;;BA)(A;OICI;GA;;;SY)"
	)

	// MkdirAllWithACL is a wrapper for MkdirAll that creates a directory
	// ACL'd for Builtin Administrators and Local System.
	func MkdirAllWithACL(path string, perm os.FileMode) error {
	return mkdirall(path, true)
	}

	// MkdirAll implementation that is volume path aware for Windows.
	func MkdirAll(path string, _ os.FileMode) error {
	return mkdirall(path, false)
	}

	// mkdirall is a custom version of os.MkdirAll modified for use on Windows
	// so that it is both volume path aware, and can create a directory with
	// a DACL.
	func mkdirall(path string, adminAndLocalSystem bool) error {
	if re := regexp.MustCompile(`^\\\\\?\\Volume{[a-z0-9-]+}$`); re.MatchString(path) {
	return nil
	}

	// The rest of this method is largely copied from os.MkdirAll and should be kept
	// as-is to ensure compatibility.

	// Fast path: if we can tell whether path is a directory or file, stop with success or error.
	dir, err := os.Stat(path)
	if err == nil {
	if dir.IsDir() {
	return nil
	}
	return &os.PathError{
	Op: "mkdir",
	Path: path,
	Err: syscall.ENOTDIR,
	}
	}

	// Slow path: make sure parent exists and then call Mkdir for path.
	i := len(path)
	for i > 0 && os.IsPathSeparator(path[i-1]) { // Skip trailing path separator.
	i--
	}

	j := i
	for j > 0 && !os.IsPathSeparator(path[j-1]) { // Scan backward over element.
	j--
	}

	if j > 1 {
	// Create parent
	err = mkdirall(path[0:j-1], adminAndLocalSystem)
	if err != nil {
	return err
	}
	}

	// Parent now exists; invoke os.Mkdir or mkdirWithACL and use its result.
	if adminAndLocalSystem {
	err = mkdirWithACL(path)
	} else {
	err = os.Mkdir(path, 0)
	}

	if err != nil {
	// Handle arguments like "foo/." by
	// double-checking that directory doesn't exist.
	dir, err1 := os.Lstat(path)
	if err1 == nil && dir.IsDir() {
	return nil
	}
	return err
	}
	return nil
	}

	// mkdirWithACL creates a new directory. If there is an error, it will be of
	// type *PathError. .
	//
	// This is a modified and combined version of os.Mkdir and syscall.Mkdir
	// in golang to cater for creating a directory am ACL permitting full
	// access, with inheritance, to any subfolder/file for Built-in Administrators
	// and Local System.
	func mkdirWithACL(name string) error {
	sa := syscall.SecurityAttributes{Length: 0}
	sd, err := winio.SddlToSecurityDescriptor(SddlAdministratorsLocalSystem)
	if err != nil {
	return &os.PathError{Op: "mkdir", Path: name, Err: err}
	}
	sa.Length = uint32(unsafe.Sizeof(sa))
	sa.InheritHandle = 1
	sa.SecurityDescriptor = uintptr(unsafe.Pointer(&sd[0]))

	namep, err := syscall.UTF16PtrFromString(name)
	if err != nil {
	return &os.PathError{Op: "mkdir", Path: name, Err: err}
	}

	e := syscall.CreateDirectory(namep, &sa)
	if e != nil {
	return &os.PathError{Op: "mkdir", Path: name, Err: e}
	}
	return nil
	}

	// IsAbs is a platform-specific wrapper for filepath.IsAbs. On Windows,
	// golang filepath.IsAbs does not consider a path \windows\system32 as absolute
	// as it doesn't start with a drive-letter/colon combination. However, in
	// docker we need to verify things such as WORKDIR /windows/system32 in
	// a Dockerfile (which gets translated to \windows\system32 when being processed
	// by the daemon. This SHOULD be treated as absolute from a docker processing
	// perspective.
	func IsAbs(path string) bool {
	if !filepath.IsAbs(path) {
	if !strings.HasPrefix(path, string(os.PathSeparator)) {
	return false
	}
	}
	return true
	}

	// The origin of the functions below here are the golang OS and syscall packages,
	// slightly modified to only cope with files, not directories due to the
	// specific use case.
	//
	// The alteration is to allow a file on Windows to be opened with
	// FILE_FLAG_SEQUENTIAL_SCAN (particular for docker load), to avoid eating
	// the standby list, particularly when accessing large files such as layer.tar.

	// CreateSequential creates the named file with mode 0666 (before umask), truncating
	// it if it already exists. If successful, methods on the returned
	// File can be used for I/O; the associated file descriptor has mode
	// O_RDWR.
	// If there is an error, it will be of type *PathError.
	func CreateSequential(name string) (*os.File, error) {
	return OpenFileSequential(name, os.O_RDWR\|os.O_CREATE\|os.O_TRUNC, 0)
	}

	// OpenSequential opens the named file for reading. If successful, methods on
	// the returned file can be used for reading; the associated file
	// descriptor has mode O_RDONLY.
	// If there is an error, it will be of type *PathError.
	func OpenSequential(name string) (*os.File, error) {
	return OpenFileSequential(name, os.O_RDONLY, 0)
	}

	// OpenFileSequential is the generalized open call; most users will use Open
	// or Create instead.
	// If there is an error, it will be of type *PathError.
	func OpenFileSequential(name string, flag int, _ os.FileMode) (*os.File, error) {
	if name == "" {
	return nil, &os.PathError{Op: "open", Path: name, Err: syscall.ENOENT}
	}
	r, errf := syscallOpenFileSequential(name, flag, 0)
	if errf == nil {
	return r, nil
	}
	return nil, &os.PathError{Op: "open", Path: name, Err: errf}
	}

	func syscallOpenFileSequential(name string, flag int, _ os.FileMode) (file *os.File, err error) {
	r, e := syscallOpenSequential(name, flag\|syscall.O_CLOEXEC, 0)
	if e != nil {
	return nil, e
	}
	return os.NewFile(uintptr(r), name), nil
	}

	func makeInheritSa() *syscall.SecurityAttributes {
	var sa syscall.SecurityAttributes
	sa.Length = uint32(unsafe.Sizeof(sa))
	sa.InheritHandle = 1
	return &sa
	}

	func syscallOpenSequential(path string, mode int, _ uint32) (fd syscall.Handle, err error) {
	if len(path) == 0 {
	return syscall.InvalidHandle, syscall.ERROR_FILE_NOT_FOUND
	}
	pathp, err := syscall.UTF16PtrFromString(path)
	if err != nil {
	return syscall.InvalidHandle, err
	}
	var access uint32
	switch mode & (syscall.O_RDONLY \| syscall.O_WRONLY \| syscall.O_RDWR) {
	case syscall.O_RDONLY:
	access = syscall.GENERIC_READ
	case syscall.O_WRONLY:
	access = syscall.GENERIC_WRITE
	case syscall.O_RDWR:
	access = syscall.GENERIC_READ \| syscall.GENERIC_WRITE
	}
	if mode&syscall.O_CREAT != 0 {
	access \|= syscall.GENERIC_WRITE
	}
	if mode&syscall.O_APPEND != 0 {
	access &^= syscall.GENERIC_WRITE
	access \|= syscall.FILE_APPEND_DATA
	}
	sharemode := uint32(syscall.FILE_SHARE_READ \| syscall.FILE_SHARE_WRITE)
	var sa *syscall.SecurityAttributes
	if mode&syscall.O_CLOEXEC == 0 {
	sa = makeInheritSa()
	}
	var createmode uint32
	switch {
	case mode&(syscall.O_CREAT\|syscall.O_EXCL) == (syscall.O_CREAT \| syscall.O_EXCL):
	createmode = syscall.CREATE_NEW
	case mode&(syscall.O_CREAT\|syscall.O_TRUNC) == (syscall.O_CREAT \| syscall.O_TRUNC):
	createmode = syscall.CREATE_ALWAYS
	case mode&syscall.O_CREAT == syscall.O_CREAT:
	createmode = syscall.OPEN_ALWAYS
	case mode&syscall.O_TRUNC == syscall.O_TRUNC:
	createmode = syscall.TRUNCATE_EXISTING
	default:
	createmode = syscall.OPEN_EXISTING
	}
	// Use FILE_FLAG_SEQUENTIAL_SCAN rather than FILE_ATTRIBUTE_NORMAL as implemented in golang.
	//https://msdn.microsoft.com/en-us/library/windows/desktop/aa363858(v=vs.85).aspx
	const fileFlagSequentialScan = 0x08000000 // FILE_FLAG_SEQUENTIAL_SCAN
	h, e := syscall.CreateFile(pathp, access, sharemode, sa, createmode, fileFlagSequentialScan, 0)
	return h, e
	}

	// ForceRemoveAll is the same as os.RemoveAll, but uses hcsshim.DestroyLayer in order
	// to delete container layers.
	func ForceRemoveAll(path string) error {
	info := hcsshim.DriverInfo{
	HomeDir: filepath.Dir(path),
	}

	return hcsshim.DestroyLayer(info, filepath.Base(path))
	}