FileManager+Win32.swift

// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2019 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//

import CoreFoundation

#if os(Windows)
internal func joinPath(prefix: String, suffix: String) -> String {
    var pszPath: PWSTR?
    _ = prefix.withCString(encodedAs: UTF16.self) { prefix in
        _ = suffix.withCString(encodedAs: UTF16.self) { suffix in
            PathAllocCombine(prefix, suffix, ULONG(PATHCCH_ALLOW_LONG_PATHS.rawValue), &pszPath)
        }
    }

    let path: String = String(decodingCString: pszPath!, as: UTF16.self)
    LocalFree(pszPath)
    return path
}

extension FileManager {
    internal func _mountedVolumeURLs(includingResourceValuesForKeys propertyKeys: [URLResourceKey]?, options: VolumeEnumerationOptions = []) -> [URL]? {
        var urls: [URL] = []

        var wszVolumeName: [WCHAR] = Array<WCHAR>(repeating: 0, count: Int(MAX_PATH))

        var hVolumes: HANDLE = FindFirstVolumeW(&wszVolumeName, DWORD(wszVolumeName.count))
        guard hVolumes != INVALID_HANDLE_VALUE else { return nil }
        defer { FindVolumeClose(hVolumes) }

        repeat {
            var dwCChReturnLength: DWORD = 0
            GetVolumePathNamesForVolumeNameW(&wszVolumeName, nil, 0, &dwCChReturnLength)

            var wszPathNames: [WCHAR] = Array<WCHAR>(repeating: 0, count: Int(dwCChReturnLength + 1))
            if !GetVolumePathNamesForVolumeNameW(&wszVolumeName, &wszPathNames, DWORD(wszPathNames.count), &dwCChReturnLength) {
                // TODO(compnerd) handle error
                continue
            }

            var pPath: DWORD = 0
            repeat {
                let path: String = String(decodingCString: &wszPathNames[Int(pPath)], as: UTF16.self)
                if path.length == 0 {
                    break
                }
                urls.append(URL(fileURLWithPath: path, isDirectory: true))
                pPath += DWORD(path.length + 1)
            } while pPath < dwCChReturnLength
        } while FindNextVolumeW(hVolumes, &wszVolumeName, DWORD(wszVolumeName.count))

        return urls
    }
    internal func _urls(for directory: SearchPathDirectory, in domainMask: SearchPathDomainMask) -> [URL] {
        let domains = _SearchPathDomain.allInSearchOrder(from: domainMask)

        var urls: [URL] = []

        for domain in domains {
            urls.append(contentsOf: windowsURLs(for: directory, in: domain))
        }

        return urls
    }

    private class func url(for id: KNOWNFOLDERID) -> URL {
        var pszPath: PWSTR?
        let hResult: HRESULT = withUnsafePointer(to: id) { id in
            SHGetKnownFolderPath(id, DWORD(KF_FLAG_DEFAULT.rawValue), nil, &pszPath)
        }
        precondition(hResult >= 0, "SHGetKnownFolderpath failed \(GetLastError())")
        let url: URL = URL(fileURLWithPath: String(decodingCString: pszPath!, as: UTF16.self), isDirectory: true)
        CoTaskMemFree(pszPath)
        return url
    }

    private func windowsURLs(for directory: SearchPathDirectory, in domain: _SearchPathDomain) -> [URL] {
        switch directory {
        case .autosavedInformationDirectory:
            // FIXME(compnerd) where should this go?
            return []

        case .desktopDirectory:
            guard domain == .user else { return [] }
            return [FileManager.url(for: FOLDERID_Desktop)]

        case .documentDirectory:
            guard domain == .user else { return [] }
            return [FileManager.url(for: FOLDERID_Documents)]

        case .cachesDirectory:
            guard domain == .user else { return [] }
            return [URL(fileURLWithPath: NSTemporaryDirectory())]

        case .applicationSupportDirectory:
            switch domain {
            case .local:
                return [FileManager.url(for: FOLDERID_ProgramData)]
            case .user:
                return [FileManager.url(for: FOLDERID_LocalAppData)]
            default:
                return []
            }

            case .downloadsDirectory:
                guard domain == .user else { return [] }
                return [FileManager.url(for: FOLDERID_Downloads)]

            case .userDirectory:
                guard domain == .user else { return [] }
                return [FileManager.url(for: FOLDERID_UserProfiles)]

            case .moviesDirectory:
                guard domain == .user else { return [] }
                return [FileManager.url(for: FOLDERID_Videos)]

            case .musicDirectory:
                guard domain == .user else { return [] }
                return [FileManager.url(for: FOLDERID_Music)]

            case .picturesDirectory:
                guard domain == .user else { return [] }
                return [FileManager.url(for: FOLDERID_PicturesLibrary)]

            case .sharedPublicDirectory:
                guard domain == .user else { return [] }
                return [FileManager.url(for: FOLDERID_Public)]

            case .trashDirectory:
                guard domain == .user else { return [] }
                return [FileManager.url(for: FOLDERID_RecycleBinFolder)]

                // None of these are supported outside of Darwin:
            case .applicationDirectory,
                 .demoApplicationDirectory,
                 .developerApplicationDirectory,
                 .adminApplicationDirectory,
                 .libraryDirectory,
                 .developerDirectory,
                 .documentationDirectory,
                 .coreServiceDirectory,
                 .inputMethodsDirectory,
                 .preferencePanesDirectory,
                 .applicationScriptsDirectory,
                 .allApplicationsDirectory,
                 .allLibrariesDirectory,
                 .printerDescriptionDirectory,
                 .itemReplacementDirectory:
                return []
        }
    }

    internal func _createDirectory(atPath path: String, withIntermediateDirectories createIntermediates: Bool, attributes: [FileAttributeKey : Any]? = [:]) throws {
        if createIntermediates {
            var isDir: ObjCBool = false
            if fileExists(atPath: path, isDirectory: &isDir) {
                guard isDir.boolValue else { throw _NSErrorWithErrno(EEXIST, reading: false, path: path) }
                return
            }

            let parent = path._nsObject.deletingLastPathComponent
            if !parent.isEmpty && !fileExists(atPath: parent, isDirectory: &isDir) {
                try createDirectory(atPath: parent, withIntermediateDirectories: true, attributes: attributes)
            }
        }

        var saAttributes: SECURITY_ATTRIBUTES =
          SECURITY_ATTRIBUTES(nLength: DWORD(MemoryLayout<SECURITY_ATTRIBUTES>.size),
                              lpSecurityDescriptor: nil,
                              bInheritHandle: false)
        let psaAttributes: UnsafeMutablePointer<SECURITY_ATTRIBUTES> =
          UnsafeMutablePointer<SECURITY_ATTRIBUTES>(&saAttributes)


        try path.withCString(encodedAs: UTF16.self) {
            if !CreateDirectoryW($0, psaAttributes) {
                // FIXME(compnerd) pass along path
                throw _NSErrorWithWindowsError(GetLastError(), reading: false, paths: [path])
            }
        }
        if let attr = attributes {
            try self.setAttributes(attr, ofItemAtPath: path)
        }
    }

    internal func _contentsOfDir(atPath path: String, _ closure: (String, Int32) throws -> () ) throws {
        guard path != "" else {
            throw NSError(domain: NSCocoaErrorDomain, code: CocoaError.fileReadInvalidFileName.rawValue, userInfo: [NSFilePathErrorKey : NSString(path)])
        }
        try (path + "\\*").withCString(encodedAs: UTF16.self) {
            var ffd: WIN32_FIND_DATAW = WIN32_FIND_DATAW()

            let hDirectory: HANDLE = FindFirstFileW($0, &ffd)
            if hDirectory == INVALID_HANDLE_VALUE {
                throw _NSErrorWithWindowsError(GetLastError(), reading: true, paths: [path])
            }
            defer { FindClose(hDirectory) }

            repeat {
                let path: String = withUnsafePointer(to: &ffd.cFileName) {
                    $0.withMemoryRebound(to: UInt16.self, capacity: MemoryLayout.size(ofValue: $0) / MemoryLayout<WCHAR>.size) {
                        String(decodingCString: $0, as: UTF16.self)
                    }
                }
                if path != "." && path != ".." {
                    try closure(path.standardizingPath, Int32(ffd.dwFileAttributes))
                }
            } while FindNextFileW(hDirectory, &ffd)
        }
    }

    internal func _subpathsOfDirectory(atPath path: String) throws -> [String] {
        var contents: [String] = []

        try _contentsOfDir(atPath: path, { (entryName, entryType) throws in
            contents.append(entryName)
            if entryType & FILE_ATTRIBUTE_DIRECTORY == FILE_ATTRIBUTE_DIRECTORY
                 && entryType & FILE_ATTRIBUTE_REPARSE_POINT != FILE_ATTRIBUTE_REPARSE_POINT {
                let subPath: String = joinPath(prefix: path, suffix: entryName)
                let entries = try subpathsOfDirectory(atPath: subPath)
                contents.append(contentsOf: entries.map { joinPath(prefix: entryName, suffix: $0).standardizingPath })
            }
        })
        return contents
    }

    internal func windowsFileAttributes(atPath path: String) throws -> WIN32_FILE_ATTRIBUTE_DATA {
        var faAttributes: WIN32_FILE_ATTRIBUTE_DATA = WIN32_FILE_ATTRIBUTE_DATA()
        return try path.withCString(encodedAs: UTF16.self) {
            if !GetFileAttributesExW($0, GetFileExInfoStandard, &faAttributes) {
                throw _NSErrorWithWindowsError(GetLastError(), reading: true, paths: [path])
            }
            return faAttributes
        }
    }
    
    internal func _attributesOfFileSystemIncludingBlockSize(forPath path: String) throws -> (attributes: [FileAttributeKey : Any], blockSize: UInt64?) {
        return (attributes: try _attributesOfFileSystem(forPath: path), blockSize: nil)
    }

    internal func _attributesOfFileSystem(forPath path: String) throws -> [FileAttributeKey : Any] {
        var result: [FileAttributeKey:Any] = [:]

        try path.withCString(encodedAs: UTF16.self) {
            let dwLength: DWORD = GetFullPathNameW($0, 0, nil, nil)
            guard dwLength != 0 else {
                throw _NSErrorWithWindowsError(GetLastError(), reading: true, paths: [path])
            }
            var szVolumePath: [WCHAR] = Array<WCHAR>(repeating: 0, count: Int(dwLength + 1))

            guard GetVolumePathNameW($0, &szVolumePath, dwLength) else {
                throw _NSErrorWithWindowsError(GetLastError(), reading: true, paths: [path])
            }

            var liTotal: ULARGE_INTEGER = ULARGE_INTEGER()
            var liFree: ULARGE_INTEGER = ULARGE_INTEGER()

            guard GetDiskFreeSpaceExW(&szVolumePath, nil, &liTotal, &liFree) else {
                throw _NSErrorWithWindowsError(GetLastError(), reading: true, paths: [path])
            }

            var volumeSerialNumber: DWORD = 0
            guard GetVolumeInformationW(&szVolumePath, nil, 0, &volumeSerialNumber, nil, nil, nil, 0) else {
                throw _NSErrorWithWindowsError(GetLastError(), reading: true, paths: [path])
            }

            result[.systemSize] = NSNumber(value: liTotal.QuadPart)
            result[.systemFreeSize] = NSNumber(value: liFree.QuadPart)
            result[.systemNumber] = NSNumber(value: volumeSerialNumber)
            // FIXME(compnerd): what about .systemNodes, .systemFreeNodes?
        }
        return result
    }

    internal func _createSymbolicLink(atPath path: String, withDestinationPath destPath: String, isDirectory: Bool? = nil) throws {
        var dwFlags = DWORD(SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE)
        // If destPath is relative, we should look for it relative to `path`, not our current working directory
        switch isDirectory {
            case .some(true):
                dwFlags |= DWORD(SYMBOLIC_LINK_FLAG_DIRECTORY)
            case .some(false):
                break;
            case .none:
                let resolvedDest = destPath.isAbsolutePath
                    ? destPath
                    : try joinPath(prefix: path.deletingLastPathComponent, suffix: destPath)
                guard let faAttributes = try? windowsFileAttributes(atPath: resolvedDest) else {
                    // Note: windowsfileAttributes will throw if the destPath is not found.
                    // Since on Windows, you are required to know the type of the symlink
                    // target (file or directory) during creation, and assuming one or the
                    // other doesn't make a lot of sense, we allow it to throw, thus
                    // disallowing the creation of broken symlinks on Windows is the target
                    // is of unknown type.
                    throw _NSErrorWithWindowsError(GetLastError(), reading: true, paths: [path, resolvedDest])
                }
                if faAttributes.dwFileAttributes & DWORD(FILE_ATTRIBUTE_DIRECTORY) == DWORD(FILE_ATTRIBUTE_DIRECTORY) {
                    dwFlags |= DWORD(SYMBOLIC_LINK_FLAG_DIRECTORY)
                }
        }

        try path.withCString(encodedAs: UTF16.self) { name in
            try destPath.withCString(encodedAs: UTF16.self) { dest in
                guard CreateSymbolicLinkW(name, dest, dwFlags) != 0 else {
                    throw _NSErrorWithWindowsError(GetLastError(), reading: true, paths: [path, destPath])
                }
            }
        }
    }

    internal func _destinationOfSymbolicLink(atPath path: String) throws -> String {
        let faAttributes = try windowsFileAttributes(atPath: path)
        guard faAttributes.dwFileAttributes & DWORD(FILE_ATTRIBUTE_REPARSE_POINT) == DWORD(FILE_ATTRIBUTE_REPARSE_POINT) else {
            throw _NSErrorWithWindowsError(DWORD(ERROR_BAD_ARGUMENTS), reading: false)
        }

        let handle = path.withCString(encodedAs: UTF16.self) { symlink in
            CreateFileW(symlink, GENERIC_READ, DWORD(FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE),
                        nil, DWORD(OPEN_EXISTING), DWORD(FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS),
                        nil)
        }

        guard handle != INVALID_HANDLE_VALUE else {
            throw _NSErrorWithWindowsError(GetLastError(), reading: true)
        }
        defer { CloseHandle(handle) }

        // Since REPARSE_DATA_BUFFER ends with an arbitrarily long buffer, we
        // have to manually get the path buffer out of it since binding it to a
        // type will truncate the path buffer.
        //
        // 20 is the sum of the offsets of:
        // ULONG ReparseTag
        // USHORT ReparseDataLength
        // USHORT Reserved
        // USHORT SubstituteNameOffset
        // USHORT SubstituteNameLength
        // USHORT PrintNameOffset
        // USHORT PrintNameLength
        // ULONG Flags (Symlink only)
        let symLinkPathBufferOffset = 20 // 4 + 2 + 2 + 2 + 2 + 2 + 2 + 4
        let mountPointPathBufferOffset = 16 // 4 + 2 + 2 + 2 + 2 + 2 + 2
        let buff = UnsafeMutableRawBufferPointer.allocate(byteCount: Int(MAXIMUM_REPARSE_DATA_BUFFER_SIZE),
                                                          alignment: 8)

        guard let buffBase = buff.baseAddress else {
            throw _NSErrorWithWindowsError(DWORD(ERROR_INVALID_DATA), reading: false)
        }

        var bytesWritten: DWORD = 0
        guard DeviceIoControl(handle, FSCTL_GET_REPARSE_POINT, nil, 0,
                              buffBase, DWORD(MAXIMUM_REPARSE_DATA_BUFFER_SIZE),
                              &bytesWritten, nil) else {
            throw _NSErrorWithWindowsError(GetLastError(), reading: true)
        }

        guard bytesWritten >= MemoryLayout<REPARSE_DATA_BUFFER>.size else {
            throw _NSErrorWithWindowsError(DWORD(ERROR_INVALID_DATA), reading: false)
        }

        let bound = buff.bindMemory(to: REPARSE_DATA_BUFFER.self)
        guard let reparseDataBuffer = bound.first else {
            throw _NSErrorWithWindowsError(DWORD(ERROR_INVALID_DATA), reading: false)
        }

        guard reparseDataBuffer.ReparseTag == IO_REPARSE_TAG_SYMLINK
                || reparseDataBuffer.ReparseTag == IO_REPARSE_TAG_MOUNT_POINT else {
            throw _NSErrorWithWindowsError(DWORD(ERROR_BAD_ARGUMENTS), reading: false)
        }

        let pathBufferPtr: UnsafeMutableRawPointer
        let substituteNameBytes: Int
        let substituteNameOffset: Int
        switch reparseDataBuffer.ReparseTag {
            case IO_REPARSE_TAG_SYMLINK:
                pathBufferPtr = buffBase + symLinkPathBufferOffset
                substituteNameBytes = Int(reparseDataBuffer.SymbolicLinkReparseBuffer.SubstituteNameLength)
                substituteNameOffset = Int(reparseDataBuffer.SymbolicLinkReparseBuffer.SubstituteNameOffset)
            case IO_REPARSE_TAG_MOUNT_POINT:
                pathBufferPtr = buffBase + mountPointPathBufferOffset
                substituteNameBytes = Int(reparseDataBuffer.MountPointReparseBuffer.SubstituteNameLength)
                substituteNameOffset = Int(reparseDataBuffer.MountPointReparseBuffer.SubstituteNameOffset)
            default:
                throw _NSErrorWithWindowsError(DWORD(ERROR_BAD_ARGUMENTS), reading: false)
        }

        guard substituteNameBytes + substituteNameOffset <= bytesWritten else {
            throw _NSErrorWithWindowsError(DWORD(ERROR_INVALID_DATA), reading: false)
        }

        let substituteNameBuff = Data(bytes: pathBufferPtr + substituteNameOffset, count: substituteNameBytes)
        guard let substitutePath = String(data: substituteNameBuff, encoding: .utf16LittleEndian) else {
            throw _NSErrorWithWindowsError(DWORD(ERROR_INVALID_DATA), reading: false)
        }
        return substitutePath
    }

    internal func _canonicalizedPath(toFileAtPath path: String) throws -> String {
        var hFile: HANDLE = INVALID_HANDLE_VALUE
        path.withCString(encodedAs: UTF16.self) { link in
          // BACKUP_SEMANTICS are (confusingly) required in order to receive a
          // handle to a directory
          hFile = CreateFileW(link, 0, DWORD(FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE),
                              nil, DWORD(OPEN_EXISTING), DWORD(FILE_FLAG_BACKUP_SEMANTICS),
                              nil)
        }
        guard hFile != INVALID_HANDLE_VALUE else {
            return try path.withCString(encodedAs: UTF16.self) {
                var dwLength = GetFullPathNameW($0, 0, nil, nil)
                var szPath = Array<WCHAR>(repeating: 0, count: Int(dwLength + 1))
                dwLength = GetFullPathNameW($0, DWORD(szPath.count), &szPath, nil)
                guard dwLength > 0 && dwLength <= szPath.count else {
                    throw _NSErrorWithWindowsError(GetLastError(), reading: true, paths: [path])
                }
                return String(decodingCString: szPath, as: UTF16.self)
            }
        }
        defer { CloseHandle(hFile) }

        let dwLength: DWORD = GetFinalPathNameByHandleW(hFile, nil, 0, DWORD(FILE_NAME_NORMALIZED))
        var szPath: [WCHAR] = Array<WCHAR>(repeating: 0, count: Int(dwLength + 1))

        GetFinalPathNameByHandleW(hFile, &szPath, dwLength, DWORD(FILE_NAME_NORMALIZED))
        return String(decodingCString: &szPath, as: UTF16.self)
    }

    internal func _copyRegularFile(atPath srcPath: String, toPath dstPath: String, variant: String = "Copy") throws {
        try srcPath.withCString(encodedAs: UTF16.self) { src in
            try dstPath.withCString(encodedAs: UTF16.self) { dst in
                if !CopyFileW(src, dst, false) {
                    throw _NSErrorWithWindowsError(GetLastError(), reading: true, paths: [srcPath, dstPath])
                }
            }
        }
    }

    internal func _copySymlink(atPath srcPath: String, toPath dstPath: String, variant: String = "Copy") throws {
        let faAttributes: WIN32_FILE_ATTRIBUTE_DATA = try windowsFileAttributes(atPath: srcPath)
        guard faAttributes.dwFileAttributes & DWORD(FILE_ATTRIBUTE_REPARSE_POINT) == DWORD(FILE_ATTRIBUTE_REPARSE_POINT) else {
            throw _NSErrorWithErrno(EINVAL, reading: true, path: srcPath, extraUserInfo: extraErrorInfo(srcPath: srcPath, dstPath: dstPath, userVariant: variant))
        }

        let destination = try destinationOfSymbolicLink(atPath: srcPath)
        let isDir = try windowsFileAttributes(atPath: srcPath).dwFileAttributes & DWORD(FILE_ATTRIBUTE_DIRECTORY) == DWORD(FILE_ATTRIBUTE_DIRECTORY)
        if fileExists(atPath: dstPath) {
            try removeItem(atPath: dstPath)
        }
        try _createSymbolicLink(atPath: dstPath, withDestinationPath: destination, isDirectory: isDir)
    }

    internal func _copyOrLinkDirectoryHelper(atPath srcPath: String, toPath dstPath: String, variant: String = "Copy", _ body: (String, String, FileAttributeType) throws -> ()) throws {
        let faAttributes = try windowsFileAttributes(atPath: srcPath)

        var fileType = FileAttributeType(attributes: faAttributes, atPath: srcPath)
        if fileType == .typeDirectory {
          try createDirectory(atPath: dstPath, withIntermediateDirectories: false, attributes: nil)
          guard let enumerator = enumerator(atPath: srcPath) else {
            throw _NSErrorWithErrno(ENOENT, reading: true, path: srcPath)
          }

          while let item = enumerator.nextObject() as? String {
            let src = joinPath(prefix: srcPath, suffix: item)
            let dst = joinPath(prefix: dstPath, suffix: item)

            let faAttributes = try windowsFileAttributes(atPath: src)
            fileType = FileAttributeType(attributes: faAttributes, atPath: srcPath)
            if fileType == .typeDirectory {
              try createDirectory(atPath: dst, withIntermediateDirectories: false, attributes: nil)
            } else {
              try body(src, dst, fileType)
            }
          }
        } else {
          try body(srcPath, dstPath, fileType)
        }
    }

    internal func _moveItem(atPath srcPath: String, toPath dstPath: String, isURL: Bool) throws {
        guard shouldMoveItemAtPath(srcPath, toPath: dstPath, isURL: isURL) else {
            return
        }

        guard !self.fileExists(atPath: dstPath) else {
            throw NSError(domain: NSCocoaErrorDomain, code: CocoaError.fileWriteFileExists.rawValue, userInfo: [NSFilePathErrorKey : NSString(dstPath)])
        }

        try srcPath.withCString(encodedAs: UTF16.self) { src in
            try dstPath.withCString(encodedAs: UTF16.self) { dst in
                if !MoveFileExW(src, dst, DWORD(MOVEFILE_COPY_ALLOWED | MOVEFILE_WRITE_THROUGH)) {
                    throw _NSErrorWithWindowsError(GetLastError(), reading: false, paths: [srcPath, dstPath])
                }
            }
        }
    }

    internal func _linkItem(atPath srcPath: String, toPath dstPath: String, isURL: Bool) throws {
        try _copyOrLinkDirectoryHelper(atPath: srcPath, toPath: dstPath) { (srcPath, dstPath, fileType) in
            guard shouldLinkItemAtPath(srcPath, toPath: dstPath, isURL: isURL) else {
                return
            }

            do {
                switch fileType {
                case .typeRegular:
                    try srcPath.withCString(encodedAs: UTF16.self) { src in
                        try dstPath.withCString(encodedAs: UTF16.self) { dst in
                            if !CreateHardLinkW(dst, src, nil) {
                                throw _NSErrorWithWindowsError(GetLastError(), reading: false, paths: [srcPath, dstPath])
                            }
                        }
                    }
                case .typeSymbolicLink:
                    try _copySymlink(atPath: srcPath, toPath: dstPath)
                default:
                    break
                }
            } catch {
                if !shouldProceedAfterError(error, linkingItemAtPath: srcPath, toPath: dstPath, isURL: isURL) {
                    throw error
                }
            }
        }
    }

    internal func _removeItem(atPath path: String, isURL: Bool, alreadyConfirmed: Bool = false) throws {
        guard alreadyConfirmed || shouldRemoveItemAtPath(path, isURL: isURL) else {
            return
        }

        guard path != "" else {
            throw NSError(domain: NSCocoaErrorDomain, code: CocoaError.fileReadInvalidFileName.rawValue, userInfo: [NSFilePathErrorKey : NSString(path)])
        }

        let url = URL(fileURLWithPath: path)
        var fsrBuf: [WCHAR] = Array<WCHAR>(repeating: 0, count: Int(MAX_PATH))
        _CFURLGetWideFileSystemRepresentation(url._cfObject, false, &fsrBuf, Int(MAX_PATH))
        let length = wcsnlen_s(&fsrBuf, fsrBuf.count)
        let fsrPath = String(utf16CodeUnits: &fsrBuf, count: length)

        let faAttributes: WIN32_FILE_ATTRIBUTE_DATA
        do {
            faAttributes = try windowsFileAttributes(atPath: fsrPath)
        } catch {
            // removeItem on POSIX throws fileNoSuchFile rather than
            // fileReadNoSuchFile that windowsFileAttributes will
            // throw if it doesn't find the file.
            if (error as NSError).code == CocoaError.fileReadNoSuchFile.rawValue {
                throw _NSErrorWithWindowsError(GetLastError(), reading: false, paths: [path])
            } else {
                throw error
            }
        }
        if faAttributes.dwFileAttributes & DWORD(FILE_ATTRIBUTE_READONLY) == FILE_ATTRIBUTE_READONLY {
        let readableAttributes = faAttributes.dwFileAttributes & DWORD(bitPattern: ~FILE_ATTRIBUTE_READONLY)
            guard fsrPath.withCString(encodedAs: UTF16.self, { SetFileAttributesW($0, readableAttributes) }) else {
                throw _NSErrorWithWindowsError(GetLastError(), reading: false, paths: [path])
            }
        }

        if faAttributes.dwFileAttributes & DWORD(FILE_ATTRIBUTE_DIRECTORY) == 0 {
            if !fsrPath.withCString(encodedAs: UTF16.self, DeleteFileW) {
                throw _NSErrorWithWindowsError(GetLastError(), reading: false, paths: [path])
            }
            return
        }
        var dirStack = [fsrPath]
        var itemPath = ""
        while let currentDir = dirStack.popLast() {
            do {
                itemPath = currentDir
                guard alreadyConfirmed || shouldRemoveItemAtPath(itemPath, isURL: isURL) else {
                    continue
                }
                guard !itemPath.withCString(encodedAs: UTF16.self, RemoveDirectoryW) else {
                    continue
                }
                guard GetLastError() == ERROR_DIR_NOT_EMPTY else {
                    throw _NSErrorWithWindowsError(GetLastError(), reading: false, paths: [itemPath])
                }
                dirStack.append(itemPath)
                var ffd: WIN32_FIND_DATAW = WIN32_FIND_DATAW()
                let h: HANDLE = (itemPath + "\\*").withCString(encodedAs: UTF16.self, {
                    FindFirstFileW($0, &ffd)
                })
                guard h != INVALID_HANDLE_VALUE else {
                    throw _NSErrorWithWindowsError(GetLastError(), reading: false, paths: [itemPath])
                }
                defer { FindClose(h) }

                repeat {
                    let fileArr = Array<WCHAR>(
                        UnsafeBufferPointer(start: &ffd.cFileName.0,
                                            count: MemoryLayout.size(ofValue: ffd.cFileName)))
                    let file = String(decodingCString: fileArr, as: UTF16.self)
                    itemPath = "\(currentDir)\\\(file)"

                    if ffd.dwFileAttributes & DWORD(FILE_ATTRIBUTE_READONLY) == FILE_ATTRIBUTE_READONLY {
                        let readableAttributes = ffd.dwFileAttributes & DWORD(bitPattern: ~FILE_ATTRIBUTE_READONLY)
                        guard itemPath.withCString(encodedAs: UTF16.self, { SetFileAttributesW($0, readableAttributes) }) else {
                            throw _NSErrorWithWindowsError(GetLastError(), reading: false, paths: [file])
                        }
                    }

                    if (ffd.dwFileAttributes & DWORD(FILE_ATTRIBUTE_DIRECTORY) != 0) {
                        if file != "." && file != ".." {
                            dirStack.append(itemPath)
                        }
                    } else {
                        guard alreadyConfirmed || shouldRemoveItemAtPath(itemPath, isURL: isURL) else {
                            continue
                        }
                        if !itemPath.withCString(encodedAs: UTF16.self, DeleteFileW) {
                            throw _NSErrorWithWindowsError(GetLastError(), reading: false, paths: [file])
                        }
                    }
                } while FindNextFileW(h, &ffd)
            } catch {
                if !shouldProceedAfterError(error, removingItemAtPath: itemPath, isURL: isURL) {
                    throw error
                }
            }
        }
    }

    internal func _currentDirectoryPath() -> String {
        let dwLength: DWORD = GetCurrentDirectoryW(0, nil)
        var szDirectory: [WCHAR] = Array<WCHAR>(repeating: 0, count: Int(dwLength + 1))

        GetCurrentDirectoryW(dwLength, &szDirectory)
        return String(decodingCString: &szDirectory, as: UTF16.self)
    }

    @discardableResult
    internal func _changeCurrentDirectoryPath(_ path: String) -> Bool {
        return path.withCString(encodedAs: UTF16.self) { SetCurrentDirectoryW($0) }
    }

    internal func _fileExists(atPath path: String, isDirectory: UnsafeMutablePointer<ObjCBool>?) -> Bool {
        var faAttributes: WIN32_FILE_ATTRIBUTE_DATA = WIN32_FILE_ATTRIBUTE_DATA()
        do { faAttributes = try windowsFileAttributes(atPath: path) } catch { return false }
        if faAttributes.dwFileAttributes & DWORD(FILE_ATTRIBUTE_REPARSE_POINT) == DWORD(FILE_ATTRIBUTE_REPARSE_POINT) {
            do {
                let contents = try destinationOfSymbolicLink(atPath: path)
                let resolvedPath = contents.isAbsolutePath
                    ? contents
                    : joinPath(prefix: path.deletingLastPathComponent, suffix: contents)
                try faAttributes = windowsFileAttributes(atPath: resolvedPath)
            } catch {
                return false
            }
        }
        if let isDirectory = isDirectory {
            isDirectory.pointee = ObjCBool(faAttributes.dwFileAttributes & DWORD(FILE_ATTRIBUTE_DIRECTORY) == DWORD(FILE_ATTRIBUTE_DIRECTORY))
        }
        return true
    }


    internal func _isReadableFile(atPath path: String) -> Bool {
        do { let _ = try windowsFileAttributes(atPath: path) } catch { return false }
        return true
    }

    internal func _isWritableFile(atPath path: String) -> Bool {
        guard let faAttributes: WIN32_FILE_ATTRIBUTE_DATA = try? windowsFileAttributes(atPath: path) else { return false }
        return faAttributes.dwFileAttributes & DWORD(FILE_ATTRIBUTE_READONLY) != DWORD(FILE_ATTRIBUTE_READONLY)
    }

    internal func _isExecutableFile(atPath path: String) -> Bool {
        var isDirectory: ObjCBool = false
        guard fileExists(atPath: path, isDirectory: &isDirectory) else { return false }
        return !isDirectory.boolValue && _isReadableFile(atPath: path)
    }

    internal func _isDeletableFile(atPath path: String) -> Bool {
        guard path != "" else { return true }

        // Get the parent directory of supplied path
        let parent = path._nsObject.deletingLastPathComponent
        var faAttributes: WIN32_FILE_ATTRIBUTE_DATA = WIN32_FILE_ATTRIBUTE_DATA()
        do { faAttributes = try windowsFileAttributes(atPath: parent) } catch { return false }
        if faAttributes.dwFileAttributes & DWORD(FILE_ATTRIBUTE_READONLY) == DWORD(FILE_ATTRIBUTE_READONLY) {
            return false
        }

        do { faAttributes = try windowsFileAttributes(atPath: path) } catch { return false }
        if faAttributes.dwFileAttributes & DWORD(FILE_ATTRIBUTE_READONLY) == DWORD(FILE_ATTRIBUTE_READONLY) {
            return false
        }

        return true
    }

    internal func _lstatFile(atPath path: String, withFileSystemRepresentation fsRep: UnsafePointer<Int8>? = nil) throws -> stat {
        let _fsRep: UnsafePointer<Int8>
        if fsRep == nil {
            _fsRep = try __fileSystemRepresentation(withPath: path)
        } else {
            _fsRep = fsRep!
        }

        defer {
            if fsRep == nil { _fsRep.deallocate() }
        }

        var statInfo = stat()
        let h = path.withCString(encodedAs: UTF16.self) {
            CreateFileW(/*lpFileName=*/$0,
                        /*dwDesiredAccess=*/DWORD(0),
                        /*dwShareMode=*/DWORD(FILE_SHARE_READ),
                        /*lpSecurityAttributes=*/nil,
                        /*dwCreationDisposition=*/DWORD(OPEN_EXISTING),
                        /*dwFlagsAndAttributes=*/DWORD(FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS),
                        /*hTemplateFile=*/nil)
        }
        if h == INVALID_HANDLE_VALUE {
            throw _NSErrorWithWindowsError(GetLastError(), reading: false, paths: [path])
        }
        var info: BY_HANDLE_FILE_INFORMATION = BY_HANDLE_FILE_INFORMATION()
        GetFileInformationByHandle(h, &info)
        // Group id is always 0 on Windows
        statInfo.st_gid = 0
        statInfo.st_atime = info.ftLastAccessTime.time_t
        statInfo.st_ctime = info.ftCreationTime.time_t
        statInfo.st_dev = info.dwVolumeSerialNumber
        // inodes have meaning on FAT/HPFS/NTFS
        statInfo.st_ino = 0
        statInfo.st_rdev = info.dwVolumeSerialNumber

        let isReparsePoint = info.dwFileAttributes & DWORD(FILE_ATTRIBUTE_REPARSE_POINT) != 0
        let isDir = info.dwFileAttributes & DWORD(FILE_ATTRIBUTE_DIRECTORY) != 0
        let fileMode = isDir ? _S_IFDIR : _S_IFREG
        // On a symlink to a directory, Windows sets both the REPARSE_POINT and
        // DIRECTORY attributes. Since Windows doesn't provide S_IFLNK and we
        // want unix style "symlinks to directories are not directories
        // themselves, we say symlinks are regular files
        statInfo.st_mode = UInt16(isReparsePoint ? _S_IFREG : fileMode)
        let isReadOnly = info.dwFileAttributes & DWORD(FILE_ATTRIBUTE_READONLY) != 0
        statInfo.st_mode |= UInt16(isReadOnly ? _S_IREAD : (_S_IREAD | _S_IWRITE))
        statInfo.st_mode |= UInt16(_S_IEXEC)

        statInfo.st_mtime = info.ftLastWriteTime.time_t
        statInfo.st_nlink = Int16(info.nNumberOfLinks)
        if info.nFileSizeHigh != 0 {
            throw _NSErrorWithErrno(EOVERFLOW, reading: true, path: path)
        }
        statInfo.st_size = Int32(info.nFileSizeLow)
        // Uid is always 0 on Windows systems
        statInfo.st_uid = 0
        CloseHandle(h)
        return statInfo
    }

    internal func _contentsEqual(atPath path1: String, andPath path2: String) -> Bool {
        guard let path1Handle = path1.withCString(encodedAs: UTF16.self, {
            CreateFileW($0, GENERIC_READ, DWORD(FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE), nil,
                        DWORD(OPEN_EXISTING), DWORD(FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS), nil)
        }), path1Handle != INVALID_HANDLE_VALUE else {
            return false
        }

        defer { CloseHandle(path1Handle) }

        guard let path2Handle = path2.withCString(encodedAs: UTF16.self, {
            CreateFileW($0, GENERIC_READ, DWORD(FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE), nil,
                        DWORD(OPEN_EXISTING), DWORD(FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS), nil)
        }), path2Handle != INVALID_HANDLE_VALUE else {
            return false
        }
        defer { CloseHandle(path2Handle) }

        let file1Type = GetFileType(path1Handle)
        guard GetLastError() == NO_ERROR else {
            return false
        }
        let file2Type = GetFileType(path2Handle)
        guard GetLastError() == NO_ERROR else {
            return false
        }

        guard file1Type == FILE_TYPE_DISK, file2Type == FILE_TYPE_DISK else {
            return false
        }

        var path1FileInfo = BY_HANDLE_FILE_INFORMATION()
        var path2FileInfo = BY_HANDLE_FILE_INFORMATION()
        guard GetFileInformationByHandle(path1Handle, &path1FileInfo),
              GetFileInformationByHandle(path2Handle, &path2FileInfo) else {
            return false
        }

        // If both paths point to the same volume/filenumber or they are both zero length
        // then they are considered equal
        if path1FileInfo.nFileIndexHigh == path2FileInfo.nFileIndexHigh
              && path1FileInfo.nFileIndexLow == path2FileInfo.nFileIndexLow
              && path1FileInfo.dwVolumeSerialNumber == path2FileInfo.dwVolumeSerialNumber {
            return true
        }

        let path1Attrs = path1FileInfo.dwFileAttributes
        let path2Attrs = path2FileInfo.dwFileAttributes
        if path1Attrs & DWORD(FILE_ATTRIBUTE_REPARSE_POINT) == FILE_ATTRIBUTE_REPARSE_POINT
             || path2Attrs & DWORD(FILE_ATTRIBUTE_REPARSE_POINT) == FILE_ATTRIBUTE_REPARSE_POINT {
            guard path1Attrs & DWORD(FILE_ATTRIBUTE_REPARSE_POINT) == FILE_ATTRIBUTE_REPARSE_POINT
                    && path2Attrs & DWORD(FILE_ATTRIBUTE_REPARSE_POINT) == FILE_ATTRIBUTE_REPARSE_POINT else {
                return false
            }
            guard let pathDest1 = try? _destinationOfSymbolicLink(atPath: path1),
                  let pathDest2 = try? _destinationOfSymbolicLink(atPath: path2) else {
                return false
            }
            return pathDest1 == pathDest2
        } else if DWORD(FILE_ATTRIBUTE_DIRECTORY) & path1Attrs == DWORD(FILE_ATTRIBUTE_DIRECTORY)
                    || DWORD(FILE_ATTRIBUTE_DIRECTORY) & path2Attrs == DWORD(FILE_ATTRIBUTE_DIRECTORY) {
            guard DWORD(FILE_ATTRIBUTE_DIRECTORY) & path1Attrs == DWORD(FILE_ATTRIBUTE_DIRECTORY)
                    && DWORD(FILE_ATTRIBUTE_DIRECTORY) & path2Attrs == FILE_ATTRIBUTE_DIRECTORY else {
                return false
            }
            return _compareDirectories(atPath: path1, andPath: path2)
        } else {
            if path1FileInfo.nFileSizeHigh == 0 && path1FileInfo.nFileSizeLow == 0
              && path2FileInfo.nFileSizeHigh == 0 && path2FileInfo.nFileSizeLow == 0 {
                return true
            }

            let path1Fsr = fileSystemRepresentation(withPath: path1)
            defer { path1Fsr.deallocate() }
            let path2Fsr = fileSystemRepresentation(withPath: path2)
            defer { path2Fsr.deallocate() }
            return _compareFiles(withFileSystemRepresentation: path1Fsr,
                                 andFileSystemRepresentation: path2Fsr,
                                 size: (Int64(path1FileInfo.nFileSizeHigh) << 32) | Int64(path1FileInfo.nFileSizeLow),
                                 bufSize: 0x1000)
        }
    }

    internal func _appendSymlinkDestination(_ dest: String, toPath: String) -> String {
        var isAbsolutePath: Bool = false
        dest.withCString(encodedAs: UTF16.self) {
            isAbsolutePath = !PathIsRelativeW($0)
        }

        if isAbsolutePath {
            return dest
        }
        let temp = toPath._bridgeToObjectiveC().deletingLastPathComponent
        return temp._bridgeToObjectiveC().appendingPathComponent(dest)
    }

    internal func _updateTimes(atPath path: String,
                               withFileSystemRepresentation fsr: UnsafePointer<Int8>,
                               creationTime: Date? = nil,
                               accessTime: Date? = nil,
                               modificationTime: Date? = nil) throws {
      let stat = try _lstatFile(atPath: path, withFileSystemRepresentation: fsr)

      var atime: FILETIME =
          FILETIME(from: time_t((accessTime ?? stat.lastAccessDate).timeIntervalSince1970))
      var mtime: FILETIME =
          FILETIME(from: time_t((modificationTime ?? stat.lastModificationDate).timeIntervalSince1970))

      let hFile: HANDLE = String(utf8String: fsr)!.withCString(encodedAs: UTF16.self) {
        CreateFileW($0, DWORD(GENERIC_WRITE), DWORD(FILE_SHARE_WRITE),
                    nil, DWORD(OPEN_EXISTING), 0, nil)
      }
      if hFile == INVALID_HANDLE_VALUE {
          throw _NSErrorWithWindowsError(GetLastError(), reading: true, paths: [path])
      }
      defer { CloseHandle(hFile) }

      if !SetFileTime(hFile, nil, &atime, &mtime) {
          throw _NSErrorWithWindowsError(GetLastError(), reading: false, paths: [path])
      }

    }

    internal class NSURLDirectoryEnumerator : DirectoryEnumerator {
        var _options : FileManager.DirectoryEnumerationOptions
        var _errorHandler : ((URL, Error) -> Bool)?
        var _stack: [URL]
        var _lastReturned: URL
        var _rootDepth : Int

        init(url: URL, options: FileManager.DirectoryEnumerationOptions, errorHandler: (/* @escaping */ (URL, Error) -> Bool)?) {
            _options = options
            _errorHandler = errorHandler
            _stack = []
            _rootDepth = url.pathComponents.count
            _lastReturned = url
        }

        override func nextObject() -> Any? {
            func firstValidItem() -> URL? {
                while let url = _stack.popLast() {
                    if !FileManager.default.fileExists(atPath: url.path) {
                        guard let handler = _errorHandler,
                              handler(url, _NSErrorWithWindowsError(GetLastError(), reading: true, paths: [url.path]))
                        else { return nil }
                        continue
                    }
                    _lastReturned = url
                    return _lastReturned
                }
                return nil
            }

            // If we most recently returned a directory, decend into it
            guard let attrs = try? FileManager.default.windowsFileAttributes(atPath: _lastReturned.path) else {
                guard let handler = _errorHandler,
                    handler(_lastReturned, _NSErrorWithWindowsError(GetLastError(), reading: true, paths: [_lastReturned.path]))
                else { return nil }
                return firstValidItem()
            }

            let isDir = attrs.dwFileAttributes & DWORD(FILE_ATTRIBUTE_DIRECTORY) == DWORD(FILE_ATTRIBUTE_DIRECTORY)
                    && attrs.dwFileAttributes & DWORD(FILE_ATTRIBUTE_REPARSE_POINT) == 0
            if isDir && (level == 0 || !_options.contains(.skipsSubdirectoryDescendants)) {
                var ffd = WIN32_FIND_DATAW()
                let dirPath = joinPath(prefix: _lastReturned.path, suffix: "*")
                let handle = dirPath.withCString(encodedAs: UTF16.self) {
                  FindFirstFileW($0, &ffd)
                }
                guard handle != INVALID_HANDLE_VALUE else { return firstValidItem() }
                defer { FindClose(handle) }

                repeat {
                    let fileArr = Array<WCHAR>(
                      UnsafeBufferPointer(start: &ffd.cFileName.0,
                                          count: MemoryLayout.size(ofValue: ffd.cFileName)))
                    let file = String(decodingCString: fileArr, as: UTF16.self)
                    if file != "." && file != ".."
                        && (!_options.contains(.skipsHiddenFiles)
                            || (ffd.dwFileAttributes & DWORD(FILE_ATTRIBUTE_HIDDEN) == 0)) {
                        let relative = URL(fileURLWithPath: file, relativeTo: _lastReturned)
                        _stack.append(relative)
                    }
                } while FindNextFileW(handle, &ffd)
            }

            return firstValidItem()
        }

        override var level: Int {
            return _lastReturned.pathComponents.count - _rootDepth
        }

        override func skipDescendants() {
            _options.insert(.skipsSubdirectoryDescendants)
        }

        override var directoryAttributes : [FileAttributeKey : Any]? {
            return nil
        }

        override var fileAttributes: [FileAttributeKey : Any]? {
            return nil
        }
    }
}

extension FileManager.NSPathDirectoryEnumerator {
    internal func _nextObject() -> Any? {
        guard let url = innerEnumerator.nextObject() as? URL else { return nil }

        var relativePath: [WCHAR] = Array<WCHAR>(repeating: 0, count: Int(MAX_PATH))

        guard baseURL._withUnsafeWideFileSystemRepresentation({ baseUrlFsr in
            url._withUnsafeWideFileSystemRepresentation { urlFsr in
                let fromAttrs = GetFileAttributesW(baseUrlFsr)
                let toAttrs = GetFileAttributesW(urlFsr)
                guard fromAttrs != INVALID_FILE_ATTRIBUTES, toAttrs != INVALID_FILE_ATTRIBUTES else {
                    return false
                }
                return PathRelativePathToW(&relativePath, baseUrlFsr, fromAttrs, urlFsr, toAttrs)
            }
        }) else { return nil }

        let path = String(decodingCString: &relativePath, as: UTF16.self)
        // Drop the leading ".\" from the path
        _currentItemPath = String(path.dropFirst(2))
        return _currentItemPath
    }

}

#endif