// 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) }