/// <summary>
/// Encapsulates a find operation.
/// </summary>
/// <param name="directory">The directory to search in.</param>
/// <param name="options">Enumeration options to use.</param>
public FileSystemEnumerator(string directory, EnumerationOptions options = null)
{
_originalRootDirectory = directory ?? throw new ArgumentNullException(nameof(directory));
_rootDirectory = PathInternal.TrimEndingDirectorySeparator(Path.GetFullPath(directory));
_options = options ?? EnumerationOptions.Default;
// We need to initialize the directory handle up front to ensure
// we immediately throw IO exceptions for missing directory/etc.
_directoryHandle = CreateDirectoryHandle(_rootDirectory);
if (_directoryHandle == IntPtr.Zero)
{
_lastEntryFound = true;
}
_currentPath = _rootDirectory;
try
{
_pathBuffer = ArrayPool <char> .Shared.Rent(StandardBufferSize);
int size = Interop.Sys.GetReadDirRBufferSize();
_entryBuffer = size > 0 ? ArrayPool <byte> .Shared.Rent(size) : null;
}
catch
{
// Close the directory handle right away if we fail to allocate
CloseDirectoryHandle();
throw;
}
}
public DirectoryInfo CreateSubdirectory(string path)
{
if (path == null)
{
throw new ArgumentNullException(nameof(path));
}
if (PathInternal.IsEffectivelyEmpty(path.AsSpan()))
{
throw new ArgumentException(SR.Argument_PathEmpty, nameof(path));
}
if (Path.IsPathRooted(path))
{
throw new ArgumentException(SR.Arg_Path2IsRooted, nameof(path));
}
string newPath = Path.GetFullPath(Path.Combine(FullPath, path));
ReadOnlySpan <char> trimmedNewPath = PathInternal.TrimEndingDirectorySeparator(newPath.AsSpan());
ReadOnlySpan <char> trimmedCurrentPath = PathInternal.TrimEndingDirectorySeparator(FullPath.AsSpan());
// We want to make sure the requested directory is actually under the subdirectory.
if (trimmedNewPath.StartsWith(trimmedCurrentPath, PathInternal.StringComparison)
// Allow the exact same path, but prevent allowing "..\FooBar" through when the directory is "Foo"
&& ((trimmedNewPath.Length == trimmedCurrentPath.Length) || PathInternal.IsDirectorySeparator(newPath[trimmedCurrentPath.Length])))
{
FileSystem.CreateDirectory(newPath);
return(new DirectoryInfo(newPath));
}
// We weren't nested
throw new ArgumentException(SR.Format(SR.Argument_InvalidSubPath, path, FullPath), nameof(path));
}
private void Init(string originalPath, string fullPath = null, string fileName = null, bool isNormalized = false)
{
// Want to throw the original argument name
OriginalPath = originalPath ?? throw new ArgumentNullException("path");
fullPath = fullPath ?? originalPath;
fullPath = isNormalized ? fullPath : Path.GetFullPath(fullPath);
_name = fileName ?? (PathInternal.IsRoot(fullPath.AsSpan()) ?
fullPath.AsSpan() :
Path.GetFileName(PathInternal.TrimEndingDirectorySeparator(fullPath.AsSpan()))).ToString();
FullPath = fullPath;
}
private static void GetFindData(string fullPath, ref Interop.Kernel32.WIN32_FIND_DATA findData)
{
using (SafeFindHandle handle = Interop.Kernel32.FindFirstFile(PathInternal.TrimEndingDirectorySeparator(fullPath), ref findData))
{
if (handle.IsInvalid)
{
int errorCode = Marshal.GetLastWin32Error();
// File not found doesn't make much sense coming from a directory delete.
if (errorCode == Interop.Errors.ERROR_FILE_NOT_FOUND)
{
errorCode = Interop.Errors.ERROR_PATH_NOT_FOUND;
}
throw Win32Marshal.GetExceptionForWin32Error(errorCode, fullPath);
}
}
}
public void Refresh(ReadOnlySpan <char> path)
{
// This should not throw, instead we store the result so that we can throw it
// when someone actually accesses a property.
// Use lstat to get the details on the object, without following symlinks.
// If it is a symlink, then subsequently get details on the target of the symlink,
// storing those results separately. We only report failure if the initial
// lstat fails, as a broken symlink should still report info on exists, attributes, etc.
_isDirectory = false;
path = PathInternal.TrimEndingDirectorySeparator(path);
int result = Interop.Sys.LStat(path, out _fileStatus);
if (result < 0)
{
Interop.ErrorInfo errorInfo = Interop.Sys.GetLastErrorInfo();
// This should never set the error if the file can't be found.
// (see the Windows refresh passing returnErrorOnNotFound: false).
if (errorInfo.Error == Interop.Error.ENOENT ||
errorInfo.Error == Interop.Error.ENOTDIR)
{
_fileStatusInitialized = 0;
_exists = false;
}
else
{
_fileStatusInitialized = errorInfo.RawErrno;
}
return;
}
_exists = true;
// IMPORTANT: Is directory logic must match the logic in FileSystemEntry
_isDirectory = (_fileStatus.Mode & Interop.Sys.FileTypes.S_IFMT) == Interop.Sys.FileTypes.S_IFDIR;
// If we're a symlink, attempt to check the target to see if it is a directory
if ((_fileStatus.Mode & Interop.Sys.FileTypes.S_IFMT) == Interop.Sys.FileTypes.S_IFLNK &&
Interop.Sys.Stat(path, out Interop.Sys.FileStatus targetStatus) >= 0)
{
_isDirectory = (targetStatus.Mode & Interop.Sys.FileTypes.S_IFMT) == Interop.Sys.FileTypes.S_IFDIR;
}
_fileStatusInitialized = 0;
}
/// <summary>Opens the specified file with the requested flags and mode.</summary>
/// <param name="path">The path to the file.</param>
/// <param name="flags">The flags with which to open the file.</param>
/// <param name="mode">The mode for opening the file.</param>
/// <returns>A SafeFileHandle for the opened file.</returns>
internal static SafeFileHandle Open(string path, Interop.Sys.OpenFlags flags, int mode)
{
Debug.Assert(path != null);
SafeFileHandle handle = Interop.Sys.Open(path, flags, mode);
if (handle.IsInvalid)
{
handle.Dispose();
Interop.ErrorInfo error = Interop.Sys.GetLastErrorInfo();
// If we fail to open the file due to a path not existing, we need to know whether to blame
// the file itself or its directory. If we're creating the file, then we blame the directory,
// otherwise we blame the file.
//
// When opening, we need to align with Windows, which considers a missing path to be
// FileNotFound only if the containing directory exists.
bool isDirectory = (error.Error == Interop.Error.ENOENT) &&
((flags & Interop.Sys.OpenFlags.O_CREAT) != 0 ||
!DirectoryExists(Path.GetDirectoryName(PathInternal.TrimEndingDirectorySeparator(path))));
Interop.CheckIo(
error.Error,
path,
isDirectory,
errorRewriter: e => (e.Error == Interop.Error.EISDIR) ? Interop.Error.EACCES.Info() : e);
}
// Make sure it's not a directory; we do this after opening it once we have a file descriptor
// to avoid race conditions.
Interop.Sys.FileStatus status;
if (Interop.Sys.FStat(handle, out status) != 0)
{
handle.Dispose();
throw Interop.GetExceptionForIoErrno(Interop.Sys.GetLastErrorInfo(), path);
}
if ((status.Mode & Interop.Sys.FileTypes.S_IFMT) == Interop.Sys.FileTypes.S_IFDIR)
{
handle.Dispose();
throw Interop.GetExceptionForIoErrno(Interop.Error.EACCES.Info(), path, isDirectory: true);
}
return(handle);
}
/// <summary>
/// Returns 0 on success, otherwise a Win32 error code. Note that
/// classes should use -1 as the uninitialized state for dataInitialized.
/// </summary>
/// <param name="returnErrorOnNotFound">Return the error code for not found errors?</param>
internal static int FillAttributeInfo(string path, ref Interop.Kernel32.WIN32_FILE_ATTRIBUTE_DATA data, bool returnErrorOnNotFound)
{
int errorCode = Interop.Errors.ERROR_SUCCESS;
// Neither GetFileAttributes or FindFirstFile like trailing separators
path = PathInternal.TrimEndingDirectorySeparator(path);
using (DisableMediaInsertionPrompt.Create())
{
if (!Interop.Kernel32.GetFileAttributesEx(path, Interop.Kernel32.GET_FILEEX_INFO_LEVELS.GetFileExInfoStandard, ref data))
{
errorCode = Marshal.GetLastWin32Error();
if (errorCode != Interop.Errors.ERROR_FILE_NOT_FOUND &&
errorCode != Interop.Errors.ERROR_PATH_NOT_FOUND &&
errorCode != Interop.Errors.ERROR_NOT_READY &&
errorCode != Interop.Errors.ERROR_INVALID_NAME &&
errorCode != Interop.Errors.ERROR_BAD_PATHNAME &&
errorCode != Interop.Errors.ERROR_BAD_NETPATH &&
errorCode != Interop.Errors.ERROR_BAD_NET_NAME &&
errorCode != Interop.Errors.ERROR_INVALID_PARAMETER &&
errorCode != Interop.Errors.ERROR_NETWORK_UNREACHABLE &&
errorCode != Interop.Errors.ERROR_NETWORK_ACCESS_DENIED &&
errorCode != Interop.Errors.ERROR_INVALID_HANDLE // eg from \\.\CON
)
{
// Assert so we can track down other cases (if any) to add to our test suite
Debug.Assert(errorCode == Interop.Errors.ERROR_ACCESS_DENIED || errorCode == Interop.Errors.ERROR_SHARING_VIOLATION,
$"Unexpected error code getting attributes {errorCode}");
// Files that are marked for deletion will not let you GetFileAttributes,
// ERROR_ACCESS_DENIED is given back without filling out the data struct.
// FindFirstFile, however, will. Historically we always gave back attributes
// for marked-for-deletion files.
//
// Another case where enumeration works is with special system files such as
// pagefile.sys that give back ERROR_SHARING_VIOLATION on GetAttributes.
//
// Ideally we'd only try again for known cases due to the potential performance
// hit. The last attempt to do so baked for nearly a year before we found the
// pagefile.sys case. As such we're probably stuck filtering out specific
// cases that we know we don't want to retry on.
var findData = new Interop.Kernel32.WIN32_FIND_DATA();
using (SafeFindHandle handle = Interop.Kernel32.FindFirstFile(path, ref findData))
{
if (handle.IsInvalid)
{
errorCode = Marshal.GetLastWin32Error();
}
else
{
errorCode = Interop.Errors.ERROR_SUCCESS;
data.PopulateFrom(ref findData);
}
}
}
}
}
if (errorCode != Interop.Errors.ERROR_SUCCESS && !returnErrorOnNotFound)
{
switch (errorCode)
{
case Interop.Errors.ERROR_FILE_NOT_FOUND:
case Interop.Errors.ERROR_PATH_NOT_FOUND:
case Interop.Errors.ERROR_NOT_READY: // Removable media not ready
// Return default value for backward compatibility
data.dwFileAttributes = -1;
return(Interop.Errors.ERROR_SUCCESS);
}
}
return(errorCode);
}