src/os/dir_windows.go - go - Git at Google

 // Copyright 2009 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 os

 import (
 	"internal/syscall/windows"
 	"io"
 	"io/fs"
 	"runtime"
 	"sync"
 	"syscall"
 	"unsafe"
 )

 // Auxiliary information if the File describes a directory
 type dirInfo struct {
 	mu sync.Mutex
 	// buf is a slice pointer so the slice header
 	// does not escape to the heap when returning
 	// buf to dirBufPool.
 	buf   *[]byte // buffer for directory I/O
 	bufp  int     // location of next record in buf
 	h     syscall.Handle
 	vol   uint32
 	class uint32 // type of entries in buf
 	path  string // absolute directory path, empty if the file system supports FILE_ID_BOTH_DIR_INFO
 }

 const (
 	// dirBufSize is the size of the dirInfo buffer.
 	// The buffer must be big enough to hold at least a single entry.
 	// The filename alone can be 512 bytes (MAX_PATH*2), and the fixed part of
 	// the FILE_ID_BOTH_DIR_INFO structure is 105 bytes, so dirBufSize
 	// should not be set below 1024 bytes (512+105+safety buffer).
 	// Windows 8.1 and earlier only works with buffer sizes up to 64 kB.
 	dirBufSize = 64 * 1024 // 64kB
 )

 var dirBufPool = sync.Pool{
 	New: func() any {
 		// The buffer must be at least a block long.
 		buf := make([]byte, dirBufSize)
 		return &buf
 	},
 }

 func (d *dirInfo) close() {
 	d.h = 0
 	if d.buf != nil {
 		dirBufPool.Put(d.buf)
 		d.buf = nil
 	}
 }

 // allowReadDirFileID indicates whether File.readdir should try to use FILE_ID_BOTH_DIR_INFO
 // if the underlying file system supports it.
 // Useful for testing purposes.
 var allowReadDirFileID = true

 func (d *dirInfo) init(h syscall.Handle) {
 	d.h = h
 	d.class = windows.FileFullDirectoryRestartInfo
 	// The previous settings are enough to read the directory entries.
 	// The following code is only needed to support os.SameFile.

 	// It is safe to query d.vol once and reuse the value.
 	// Hard links are not allowed to reference files in other volumes.
 	// Junctions and symbolic links can reference files and directories in other volumes,
 	// but the reparse point should still live in the parent volume.
 	var flags uint32
 	err := windows.GetVolumeInformationByHandle(h, nil, 0, &d.vol, nil, &flags, nil, 0)
 	if err != nil {
 		d.vol = 0 // Set to zero in case Windows writes garbage to it.
 		// If we can't get the volume information, we can't use os.SameFile,
 		// but we can still read the directory entries.
 		return
 	}
 	if flags&windows.FILE_SUPPORTS_OBJECT_IDS == 0 {
 		// The file system does not support object IDs, no need to continue.
 		return
 	}
 	if allowReadDirFileID && flags&windows.FILE_SUPPORTS_OPEN_BY_FILE_ID != 0 {
 		// Use FileIdBothDirectoryRestartInfo if available as it returns the file ID
 		// without the need to open the file.
 		d.class = windows.FileIdBothDirectoryRestartInfo
 	} else {
 		// If FileIdBothDirectoryRestartInfo is not available but objects IDs are supported,
 		// get the directory path so that os.SameFile can use it to open the file
 		// and retrieve the file ID.
 		d.path, _ = windows.FinalPath(h, windows.FILE_NAME_OPENED)
 	}
 }

 func (file *File) readdir(n int, mode readdirMode) (names []string, dirents []DirEntry, infos []FileInfo, err error) {
 	// If this file has no dirInfo, create one.
 	var d *dirInfo
 	for {
 		d = file.dirinfo.Load()
 		if d != nil {
 			break
 		}
 		d = new(dirInfo)
 		d.init(file.pfd.Sysfd)
 		if file.dirinfo.CompareAndSwap(nil, d) {
 			break
 		}
 		// We lost the race: try again.
 		d.close()
 	}
 	d.mu.Lock()
 	defer d.mu.Unlock()
 	if d.buf == nil {
 		d.buf = dirBufPool.Get().(*[]byte)
 	}

 	wantAll := n <= 0
 	if wantAll {
 		n = -1
 	}
 	for n != 0 {
 		// Refill the buffer if necessary
 		if d.bufp == 0 {
 			err = windows.GetFileInformationByHandleEx(file.pfd.Sysfd, d.class, (*byte)(unsafe.Pointer(&(*d.buf)[0])), uint32(len(*d.buf)))
 			runtime.KeepAlive(file)
 			if err != nil {
 				if err == syscall.ERROR_NO_MORE_FILES {
 					// Optimization: we can return the buffer to the pool, there is nothing else to read.
 					dirBufPool.Put(d.buf)
 					d.buf = nil
 					break
 				}
 				if err == syscall.ERROR_FILE_NOT_FOUND &&
 					(d.class == windows.FileIdBothDirectoryRestartInfo || d.class == windows.FileFullDirectoryRestartInfo) {
 					// GetFileInformationByHandleEx doesn't document the return error codes when the info class is FileIdBothDirectoryRestartInfo,
 					// but MS-FSA 2.1.5.6.3 [1] specifies that the underlying file system driver should return STATUS_NO_SUCH_FILE when
 					// reading an empty root directory, which is mapped to ERROR_FILE_NOT_FOUND by Windows.
 					// Note that some file system drivers may never return this error code, as the spec allows to return the "." and ".."
 					// entries in such cases, making the directory appear non-empty.
 					// The chances of false positive are very low, as we know that the directory exists, else GetVolumeInformationByHandle
 					// would have failed, and that the handle is still valid, as we haven't closed it.
 					// See go.dev/issue/61159.
 					// [1] https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-fsa/fa8194e0-53ec-413b-8315-e8fa85396fd8
 					break
 				}
 				if s, _ := file.Stat(); s != nil && !s.IsDir() {
 					err = &PathError{Op: "readdir", Path: file.name, Err: syscall.ENOTDIR}
 				} else {
 					err = &PathError{Op: "GetFileInformationByHandleEx", Path: file.name, Err: err}
 				}
 				return
 			}
 			if d.class == windows.FileIdBothDirectoryRestartInfo {
 				d.class = windows.FileIdBothDirectoryInfo
 			} else if d.class == windows.FileFullDirectoryRestartInfo {
 				d.class = windows.FileFullDirectoryInfo
 			}
 		}
 		// Drain the buffer
 		var islast bool
 		for n != 0 && !islast {
 			var nextEntryOffset uint32
 			var nameslice []uint16
 			entry := unsafe.Pointer(&(*d.buf)[d.bufp])
 			if d.class == windows.FileIdBothDirectoryInfo {
 				info := (*windows.FILE_ID_BOTH_DIR_INFO)(entry)
 				nextEntryOffset = info.NextEntryOffset
 				nameslice = unsafe.Slice(&info.FileName[0], info.FileNameLength/2)
 			} else {
 				info := (*windows.FILE_FULL_DIR_INFO)(entry)
 				nextEntryOffset = info.NextEntryOffset
 				nameslice = unsafe.Slice(&info.FileName[0], info.FileNameLength/2)
 			}
 			d.bufp += int(nextEntryOffset)
 			islast = nextEntryOffset == 0
 			if islast {
 				d.bufp = 0
 			}
 			if (len(nameslice) == 1 && nameslice[0] == '.') ||
 				(len(nameslice) == 2 && nameslice[0] == '.' && nameslice[1] == '.') {
 				// Ignore "." and ".." and avoid allocating a string for them.
 				continue
 			}
 			name := syscall.UTF16ToString(nameslice)
 			if mode == readdirName {
 				names = append(names, name)
 			} else {
 				var f *fileStat
 				if d.class == windows.FileIdBothDirectoryInfo {
 					f = newFileStatFromFileIDBothDirInfo((*windows.FILE_ID_BOTH_DIR_INFO)(entry))
 				} else {
 					f = newFileStatFromFileFullDirInfo((*windows.FILE_FULL_DIR_INFO)(entry))
 					if d.path != "" {
 						// Defer appending the entry name to the parent directory path until
 						// it is really needed, to avoid allocating a string that may not be used.
 						// It is currently only used in os.SameFile.
 						f.appendNameToPath = true
 						f.path = d.path
 					}
 				}
 				f.name = name
 				f.vol = d.vol
 				if mode == readdirDirEntry {
 					dirents = append(dirents, dirEntry{f})
 				} else {
 					infos = append(infos, f)
 				}
 			}
 			n--
 		}
 	}
 	if !wantAll && len(names)+len(dirents)+len(infos) == 0 {
 		return nil, nil, nil, io.EOF
 	}
 	return names, dirents, infos, nil
 }

 type dirEntry struct {
 	fs *fileStat
 }

 func (de dirEntry) Name() string            { return de.fs.Name() }
 func (de dirEntry) IsDir() bool             { return de.fs.IsDir() }
 func (de dirEntry) Type() FileMode          { return de.fs.Mode().Type() }
 func (de dirEntry) Info() (FileInfo, error) { return de.fs, nil }

 func (de dirEntry) String() string {
 	return fs.FormatDirEntry(de)
 }
	// Copyright 2009 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 os

	import (
	"internal/syscall/windows"
	"io"
	"io/fs"
	"runtime"
	"sync"
	"syscall"
	"unsafe"
	)

	// Auxiliary information if the File describes a directory
	type dirInfo struct {
	mu sync.Mutex
	// buf is a slice pointer so the slice header
	// does not escape to the heap when returning
	// buf to dirBufPool.
	buf *[]byte // buffer for directory I/O
	bufp int // location of next record in buf
	h syscall.Handle
	vol uint32
	class uint32 // type of entries in buf
	path string // absolute directory path, empty if the file system supports FILE_ID_BOTH_DIR_INFO
	}

	const (
	// dirBufSize is the size of the dirInfo buffer.
	// The buffer must be big enough to hold at least a single entry.
	// The filename alone can be 512 bytes (MAX_PATH*2), and the fixed part of
	// the FILE_ID_BOTH_DIR_INFO structure is 105 bytes, so dirBufSize
	// should not be set below 1024 bytes (512+105+safety buffer).
	// Windows 8.1 and earlier only works with buffer sizes up to 64 kB.
	dirBufSize = 64 * 1024 // 64kB
	)

	var dirBufPool = sync.Pool{
	New: func() any {
	// The buffer must be at least a block long.
	buf := make([]byte, dirBufSize)
	return &buf
	},
	}

	func (d *dirInfo) close() {
	d.h = 0
	if d.buf != nil {
	dirBufPool.Put(d.buf)
	d.buf = nil
	}
	}

	// allowReadDirFileID indicates whether File.readdir should try to use FILE_ID_BOTH_DIR_INFO
	// if the underlying file system supports it.
	// Useful for testing purposes.
	var allowReadDirFileID = true

	func (d *dirInfo) init(h syscall.Handle) {
	d.h = h
	d.class = windows.FileFullDirectoryRestartInfo
	// The previous settings are enough to read the directory entries.
	// The following code is only needed to support os.SameFile.

	// It is safe to query d.vol once and reuse the value.
	// Hard links are not allowed to reference files in other volumes.
	// Junctions and symbolic links can reference files and directories in other volumes,
	// but the reparse point should still live in the parent volume.
	var flags uint32
	err := windows.GetVolumeInformationByHandle(h, nil, 0, &d.vol, nil, &flags, nil, 0)
	if err != nil {
	d.vol = 0 // Set to zero in case Windows writes garbage to it.
	// If we can't get the volume information, we can't use os.SameFile,
	// but we can still read the directory entries.
	return
	}
	if flags&windows.FILE_SUPPORTS_OBJECT_IDS == 0 {
	// The file system does not support object IDs, no need to continue.
	return
	}
	if allowReadDirFileID && flags&windows.FILE_SUPPORTS_OPEN_BY_FILE_ID != 0 {
	// Use FileIdBothDirectoryRestartInfo if available as it returns the file ID
	// without the need to open the file.
	d.class = windows.FileIdBothDirectoryRestartInfo
	} else {
	// If FileIdBothDirectoryRestartInfo is not available but objects IDs are supported,
	// get the directory path so that os.SameFile can use it to open the file
	// and retrieve the file ID.
	d.path, _ = windows.FinalPath(h, windows.FILE_NAME_OPENED)
	}
	}

	func (file *File) readdir(n int, mode readdirMode) (names []string, dirents []DirEntry, infos []FileInfo, err error) {
	// If this file has no dirInfo, create one.
	var d *dirInfo
	for {
	d = file.dirinfo.Load()
	if d != nil {
	break
	}
	d = new(dirInfo)
	d.init(file.pfd.Sysfd)
	if file.dirinfo.CompareAndSwap(nil, d) {
	break
	}
	// We lost the race: try again.
	d.close()
	}
	d.mu.Lock()
	defer d.mu.Unlock()
	if d.buf == nil {
	d.buf = dirBufPool.Get().(*[]byte)
	}

	wantAll := n <= 0
	if wantAll {
	n = -1
	}
	for n != 0 {
	// Refill the buffer if necessary
	if d.bufp == 0 {
	err = windows.GetFileInformationByHandleEx(file.pfd.Sysfd, d.class, (byte)(unsafe.Pointer(&(d.buf)[0])), uint32(len(*d.buf)))
	runtime.KeepAlive(file)
	if err != nil {
	if err == syscall.ERROR_NO_MORE_FILES {
	// Optimization: we can return the buffer to the pool, there is nothing else to read.
	dirBufPool.Put(d.buf)
	d.buf = nil
	break
	}
	if err == syscall.ERROR_FILE_NOT_FOUND &&
	(d.class == windows.FileIdBothDirectoryRestartInfo \|\| d.class == windows.FileFullDirectoryRestartInfo) {
	// GetFileInformationByHandleEx doesn't document the return error codes when the info class is FileIdBothDirectoryRestartInfo,
	// but MS-FSA 2.1.5.6.3 [1] specifies that the underlying file system driver should return STATUS_NO_SUCH_FILE when
	// reading an empty root directory, which is mapped to ERROR_FILE_NOT_FOUND by Windows.
	// Note that some file system drivers may never return this error code, as the spec allows to return the "." and ".."
	// entries in such cases, making the directory appear non-empty.
	// The chances of false positive are very low, as we know that the directory exists, else GetVolumeInformationByHandle
	// would have failed, and that the handle is still valid, as we haven't closed it.
	// See go.dev/issue/61159.
	// [1] https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-fsa/fa8194e0-53ec-413b-8315-e8fa85396fd8
	break
	}
	if s, _ := file.Stat(); s != nil && !s.IsDir() {
	err = &PathError{Op: "readdir", Path: file.name, Err: syscall.ENOTDIR}
	} else {
	err = &PathError{Op: "GetFileInformationByHandleEx", Path: file.name, Err: err}
	}
	return
	}
	if d.class == windows.FileIdBothDirectoryRestartInfo {
	d.class = windows.FileIdBothDirectoryInfo
	} else if d.class == windows.FileFullDirectoryRestartInfo {
	d.class = windows.FileFullDirectoryInfo
	}
	}
	// Drain the buffer
	var islast bool
	for n != 0 && !islast {
	var nextEntryOffset uint32
	var nameslice []uint16
	entry := unsafe.Pointer(&(*d.buf)[d.bufp])
	if d.class == windows.FileIdBothDirectoryInfo {
	info := (*windows.FILE_ID_BOTH_DIR_INFO)(entry)
	nextEntryOffset = info.NextEntryOffset
	nameslice = unsafe.Slice(&info.FileName[0], info.FileNameLength/2)
	} else {
	info := (*windows.FILE_FULL_DIR_INFO)(entry)
	nextEntryOffset = info.NextEntryOffset
	nameslice = unsafe.Slice(&info.FileName[0], info.FileNameLength/2)
	}
	d.bufp += int(nextEntryOffset)
	islast = nextEntryOffset == 0
	if islast {
	d.bufp = 0
	}
	if (len(nameslice) == 1 && nameslice[0] == '.') \|\|
	(len(nameslice) == 2 && nameslice[0] == '.' && nameslice[1] == '.') {
	// Ignore "." and ".." and avoid allocating a string for them.
	continue
	}
	name := syscall.UTF16ToString(nameslice)
	if mode == readdirName {
	names = append(names, name)
	} else {
	var f *fileStat
	if d.class == windows.FileIdBothDirectoryInfo {
	f = newFileStatFromFileIDBothDirInfo((*windows.FILE_ID_BOTH_DIR_INFO)(entry))
	} else {
	f = newFileStatFromFileFullDirInfo((*windows.FILE_FULL_DIR_INFO)(entry))
	if d.path != "" {
	// Defer appending the entry name to the parent directory path until
	// it is really needed, to avoid allocating a string that may not be used.
	// It is currently only used in os.SameFile.
	f.appendNameToPath = true
	f.path = d.path
	}
	}
	f.name = name
	f.vol = d.vol
	if mode == readdirDirEntry {
	dirents = append(dirents, dirEntry{f})
	} else {
	infos = append(infos, f)
	}
	}
	n--
	}
	}
	if !wantAll && len(names)+len(dirents)+len(infos) == 0 {
	return nil, nil, nil, io.EOF
	}
	return names, dirents, infos, nil
	}

	type dirEntry struct {
	fs *fileStat
	}

	func (de dirEntry) Name() string { return de.fs.Name() }
	func (de dirEntry) IsDir() bool { return de.fs.IsDir() }
	func (de dirEntry) Type() FileMode { return de.fs.Mode().Type() }
	func (de dirEntry) Info() (FileInfo, error) { return de.fs, nil }

	func (de dirEntry) String() string {
	return fs.FormatDirEntry(de)
	}