protected void RefreshEntryInfo()
{
_entryInfo = File.GetFileSystemEntryInfoInternal(IsDirectory, Transaction, LongFullName, true, null);
if (_entryInfo == null)
{
DataInitialised = -1;
}
else
{
DataInitialised = 0;
Win32AttributeData = new NativeMethods.Win32FileAttributeData(_entryInfo.Win32FindData);
}
}
internal static T GetAttributesExInternal <T>(KernelTransaction transaction, string path, PathFormat pathFormat)
{
if (pathFormat == PathFormat.RelativePath)
{
Path.CheckValidPath(path, true, true);
}
string pathLp = Path.GetExtendedLengthPathInternal(transaction, path, pathFormat, GetFullPathOptions.RemoveTrailingDirectorySeparator | GetFullPathOptions.CheckInvalidPathChars);
var data = new NativeMethods.Win32FileAttributeData();
int dataInitialised = FillAttributeInfoInternal(transaction, pathLp, ref data, false, true);
if (dataInitialised != Win32Errors.ERROR_SUCCESS)
{
NativeError.ThrowException(dataInitialised, pathLp);
}
return(typeof(T) == typeof(FileAttributes)
? (T)(object)data.FileAttributes
: (T)(object)data);
}
internal static bool ExistsInternal(bool isFolder, KernelTransaction transaction, string path, PathFormat pathFormat)
{
// Will be caught later and be thrown as an ArgumentException or ArgumentNullException.
// Let's take a shorter route, preventing an Exception from being thrown altogether.
if (Utils.IsNullOrWhiteSpace(path))
{
return(false);
}
// DriveInfo.IsReady() will fail.
//
//// After normalizing, check whether path ends in directory separator.
//// Otherwise, FillAttributeInfoInternal removes it and we may return a false positive.
//string pathRp = Path.GetRegularPathInternal(path, true, false, false, false);
//if (pathRp.Length > 0 && Path.IsDVsc(pathRp[pathRp.Length - 1], false))
// return false;
try
{
string pathLp = Path.GetExtendedLengthPathInternal(transaction, path, pathFormat, GetFullPathOptions.TrimEnd | GetFullPathOptions.RemoveTrailingDirectorySeparator | GetFullPathOptions.CheckInvalidPathChars | GetFullPathOptions.ContinueOnNonExist);
var data = new NativeMethods.Win32FileAttributeData();
int dataInitialised = FillAttributeInfoInternal(transaction, pathLp, ref data, false, true);
return(dataInitialised == Win32Errors.ERROR_SUCCESS && data.FileAttributes != (FileAttributes)(-1) && (isFolder
? (data.FileAttributes & FileAttributes.Directory) == FileAttributes.Directory
: (data.FileAttributes & FileAttributes.Directory) != FileAttributes.Directory));
}
catch
{
return(false);
}
}
internal static void DeleteFileInternal(KernelTransaction transaction, string path, bool ignoreReadOnly, PathFormat pathFormat)
{
#region Setup
if (pathFormat == PathFormat.RelativePath)
Path.CheckValidPath(path, true, true);
string pathLp = Path.GetExtendedLengthPathInternal(transaction, path, pathFormat, GetFullPathOptions.TrimEnd | GetFullPathOptions.RemoveTrailingDirectorySeparator);
// If the path points to a symbolic link, the symbolic link is deleted, not the target.
#endregion // Setup
startDeleteFile:
if (!(transaction == null || !NativeMethods.IsAtLeastWindowsVista
// DeleteFile() / DeleteFileTransacted()
// In the ANSI version of this function, the name is limited to MAX_PATH characters.
// To extend this limit to 32,767 wide characters, call the Unicode version of the function and prepend "\\?\" to the path.
// 2013-01-13: MSDN confirms LongPath usage.
? NativeMethods.DeleteFile(pathLp)
: NativeMethods.DeleteFileTransacted(pathLp, transaction.SafeHandle)))
{
int lastError = Marshal.GetLastWin32Error();
switch ((uint)lastError)
{
case Win32Errors.ERROR_FILE_NOT_FOUND:
// MSDN: .NET 3.5+: If the file to be deleted does not exist, no exception is thrown.
return;
case Win32Errors.ERROR_PATH_NOT_FOUND:
// MSDN: .NET 3.5+: DirectoryNotFoundException: The specified path is invalid (for example, it is on an unmapped drive).
NativeError.ThrowException(lastError, pathLp);
return;
case Win32Errors.ERROR_SHARING_VIOLATION:
// MSDN: .NET 3.5+: IOException: The specified file is in use or there is an open handle on the file.
NativeError.ThrowException(lastError, pathLp);
break;
case Win32Errors.ERROR_ACCESS_DENIED:
var data = new NativeMethods.Win32FileAttributeData();
int dataInitialised = FillAttributeInfoInternal(transaction, pathLp, ref data, false, true);
if (data.FileAttributes != (FileAttributes)(-1))
{
if ((data.FileAttributes & FileAttributes.Directory) == FileAttributes.Directory)
// MSDN: .NET 3.5+: UnauthorizedAccessException: Path is a directory.
throw new UnauthorizedAccessException(string.Format(CultureInfo.CurrentCulture, "({0}) {1}",
Win32Errors.ERROR_INVALID_PARAMETER, string.Format(CultureInfo.CurrentCulture, Resources.DirectoryExistsWithSameNameSpecifiedByPath, pathLp)));
if ((data.FileAttributes & FileAttributes.ReadOnly) == FileAttributes.ReadOnly)
{
if (ignoreReadOnly)
{
// Reset file attributes.
SetAttributesInternal(false, transaction, pathLp, FileAttributes.Normal, true, PathFormat.LongFullPath);
goto startDeleteFile;
}
// MSDN: .NET 3.5+: UnauthorizedAccessException: Path specified a read-only file.
throw new FileReadOnlyException(pathLp);
}
}
if (dataInitialised == Win32Errors.ERROR_SUCCESS)
// MSDN: .NET 3.5+: UnauthorizedAccessException: The caller does not have the required permission.
NativeError.ThrowException(lastError, pathLp);
break;
}
// MSDN: .NET 3.5+: IOException:
// The specified file is in use.
// There is an open handle on the file, and the operating system is Windows XP or earlier.
NativeError.ThrowException(lastError, pathLp);
}
}
internal static CopyMoveResult CopyMoveInternal(bool isFolder, KernelTransaction transaction, string sourceFileName, string destinationFileName, bool preserveDates, CopyOptions? copyOptions, MoveOptions? moveOptions, CopyMoveProgressRoutine progressHandler, object userProgressData, PathFormat pathFormat)
{
#region Setup
if (pathFormat == PathFormat.RelativePath)
{
Path.CheckValidPath(sourceFileName, true, true);
Path.CheckValidPath(destinationFileName, true, true);
}
else
{
// MSDN:. NET 3.5+: NotSupportedException: Path contains a colon character (:) that is not part of a drive label ("C:\").
Path.CheckValidPath(sourceFileName, false, false);
Path.CheckValidPath(destinationFileName, false, false);
}
string sourceFileNameLp = Path.GetExtendedLengthPathInternal(transaction, sourceFileName, pathFormat, GetFullPathOptions.RemoveTrailingDirectorySeparator);
string destFileNameLp = Path.GetExtendedLengthPathInternal(transaction, destinationFileName, pathFormat, GetFullPathOptions.RemoveTrailingDirectorySeparator);
// MSDN: If this flag is set to TRUE during the copy/move operation, the operation is canceled.
// Otherwise, the copy/move operation will continue to completion.
bool cancel = false;
// Determine Copy or Move action.
bool doCopy = copyOptions != null;
bool doMove = !doCopy && moveOptions != null;
if ((!doCopy && !doMove) || (doCopy && doMove))
throw new NotSupportedException(Resources.UndeterminedCopyMoveAction);
bool overwrite = doCopy
? (((CopyOptions) copyOptions & CopyOptions.FailIfExists) != CopyOptions.FailIfExists)
: (((MoveOptions) moveOptions & MoveOptions.ReplaceExisting) == MoveOptions.ReplaceExisting);
bool raiseException = progressHandler == null;
// Setup callback function for progress notifications.
var routine = (progressHandler != null)
? (totalFileSize, totalBytesTransferred, streamSize, streamBytesTransferred, dwStreamNumber, dwCallbackReason, hSourceFile, hDestinationFile, lpData)
=>
progressHandler(totalFileSize, totalBytesTransferred, streamSize, streamBytesTransferred, dwStreamNumber, dwCallbackReason, userProgressData)
: (NativeMethods.NativeCopyMoveProgressRoutine) null;
#endregion //Setup
startCopyMove:
uint lastError = Win32Errors.ERROR_SUCCESS;
#region Win32 Copy/Move
if (!(transaction == null || !NativeMethods.IsAtLeastWindowsVista
? doMove
// MoveFileWithProgress() / MoveFileTransacted()
// In the ANSI version of this function, the name is limited to MAX_PATH characters.
// To extend this limit to 32,767 wide characters, call the Unicode version of the function and prepend "\\?\" to the path.
// 2013-04-15: MSDN confirms LongPath usage.
// CopyFileEx() / CopyFileTransacted()
// In the ANSI version of this function, the name is limited to MAX_PATH characters.
// To extend this limit to 32,767 wide characters, call the Unicode version of the function and prepend "\\?\" to the path.
// 2013-04-15: MSDN confirms LongPath usage.
? NativeMethods.MoveFileWithProgress(sourceFileNameLp, destFileNameLp, routine, IntPtr.Zero, (MoveOptions) moveOptions)
: NativeMethods.CopyFileEx(sourceFileNameLp, destFileNameLp, routine, IntPtr.Zero, out cancel, (CopyOptions) copyOptions)
: doMove
? NativeMethods.MoveFileTransacted(sourceFileNameLp, destFileNameLp, routine, IntPtr.Zero, (MoveOptions) moveOptions, transaction.SafeHandle)
: NativeMethods.CopyFileTransacted(sourceFileNameLp, destFileNameLp, routine, IntPtr.Zero, out cancel, (CopyOptions) copyOptions, transaction.SafeHandle)))
{
lastError = (uint) Marshal.GetLastWin32Error();
if (lastError == Win32Errors.ERROR_REQUEST_ABORTED)
{
// If lpProgressRoutine returns PROGRESS_CANCEL due to the user canceling the operation,
// CopyFileEx will return zero and GetLastError will return ERROR_REQUEST_ABORTED.
// In this case, the partially copied destination file is deleted.
//
// If lpProgressRoutine returns PROGRESS_STOP due to the user stopping the operation,
// CopyFileEx will return zero and GetLastError will return ERROR_REQUEST_ABORTED.
// In this case, the partially copied destination file is left intact.
cancel = true;
}
else if (raiseException)
{
#region Win32Errors
switch (lastError)
{
case Win32Errors.ERROR_FILE_NOT_FOUND:
// File.Copy()
// File.Move()
// MSDN: .NET 3.5+: FileNotFoundException: sourceFileName was not found.
NativeError.ThrowException(lastError, sourceFileNameLp);
break;
case Win32Errors.ERROR_PATH_NOT_FOUND:
// File.Copy()
// File.Move()
// Directory.Move()
// MSDN: .NET 3.5+: DirectoryNotFoundException: The path specified in sourceFileName or destinationFileName is invalid (for example, it is on an unmapped drive).
NativeError.ThrowException(lastError, sourceFileNameLp);
break;
case Win32Errors.ERROR_FILE_EXISTS:
// File.Copy()
// Directory.Copy()
NativeError.ThrowException(lastError, destFileNameLp);
break;
default:
// For a number of error codes (sharing violation, path not found, etc)
// we don't know if the problem was with the source or dest file.
// Check if destination directory already exists.
// Directory.Move()
// MSDN: .NET 3.5+: IOException: destDirName already exists.
if (ExistsInternal(true, transaction, destFileNameLp, PathFormat.LongFullPath))
NativeError.ThrowException(Win32Errors.ERROR_ALREADY_EXISTS, destFileNameLp);
if (doMove)
{
// Ensure that the source file or directory exists.
// Directory.Move()
// MSDN: .NET 3.5+: DirectoryNotFoundException: The path specified by sourceDirName is invalid (for example, it is on an unmapped drive).
if (!ExistsInternal(isFolder, transaction, sourceFileNameLp, PathFormat.LongFullPath))
NativeError.ThrowException(isFolder ? Win32Errors.ERROR_PATH_NOT_FOUND : Win32Errors.ERROR_FILE_NOT_FOUND, sourceFileNameLp);
}
// Try reading the source file.
string fileNameLp = destFileNameLp;
if (!isFolder)
{
using (SafeFileHandle safeHandle = CreateFileInternal(transaction, sourceFileNameLp, ExtendedFileAttributes.None, null, FileMode.Open, 0, FileShare.Read, false, PathFormat.LongFullPath))
if (safeHandle.IsInvalid)
fileNameLp = sourceFileNameLp;
}
if (lastError == Win32Errors.ERROR_ACCESS_DENIED)
{
// File.Copy()
// File.Move()
// MSDN: .NET 3.5+: IOException: An I/O error has occurred.
// Directory exists with the same name as the file.
if (!isFolder && ExistsInternal(true, transaction, destFileNameLp, PathFormat.LongFullPath))
NativeError.ThrowException(lastError, string.Format(CultureInfo.CurrentCulture, Resources.DirectoryExistsWithSameNameSpecifiedByPath, destFileNameLp));
else
{
var data = new NativeMethods.Win32FileAttributeData();
FillAttributeInfoInternal(transaction, destFileNameLp, ref data, false, true);
if (data.FileAttributes != (FileAttributes) (-1))
{
if ((data.FileAttributes & FileAttributes.ReadOnly) == FileAttributes.ReadOnly)
{
// MSDN: .NET 3.5+: IOException: The directory specified by path is read-only.
if (overwrite)
{
// Reset file system object attributes.
SetAttributesInternal(isFolder, transaction, destFileNameLp, FileAttributes.Normal, true, PathFormat.LongFullPath);
goto startCopyMove;
}
// MSDN: .NET 3.5+: UnauthorizedAccessException: destinationFileName is read-only.
// MSDN: Win32 CopyFileXxx: This function fails with ERROR_ACCESS_DENIED if the destination file already exists
// and has the FILE_ATTRIBUTE_HIDDEN or FILE_ATTRIBUTE_READONLY attribute set.
throw new FileReadOnlyException(destFileNameLp);
}
// MSDN: Win32 CopyFileXxx: This function fails with ERROR_ACCESS_DENIED if the destination file already exists
// and has the FILE_ATTRIBUTE_HIDDEN or FILE_ATTRIBUTE_READONLY attribute set.
if ((data.FileAttributes & FileAttributes.Hidden) == FileAttributes.Hidden)
NativeError.ThrowException(lastError, string.Format(CultureInfo.CurrentCulture, Resources.FileHidden, destFileNameLp));
}
// Observation: .NET 3.5+: For files: UnauthorizedAccessException: The caller does not have the required permission.
// Observation: .NET 3.5+: For directories: IOException: The caller does not have the required permission.
NativeError.ThrowException(lastError, destFileNameLp);
}
}
// MSDN: .NET 3.5+: An I/O error has occurred.
// File.Copy(): IOException: destinationFileName exists and overwrite is false.
// File.Move(): The destination file already exists or sourceFileName was not found.
NativeError.ThrowException(lastError, fileNameLp);
break;
}
#endregion // Win32Errors
}
}
#endregion // Win32 Copy/Move
#region Transfer Timestamps
// Apply original Timestamps if requested.
// MoveFileWithProgress() / MoveFileTransacted() automatically preserve Timestamps.
// File.Copy()
if (preserveDates && doCopy && lastError == Win32Errors.ERROR_SUCCESS)
{
// Currently preserveDates is only used with files.
var data = new NativeMethods.Win32FileAttributeData();
int dataInitialised = FillAttributeInfoInternal(transaction, sourceFileNameLp, ref data, false, true);
if (dataInitialised == Win32Errors.ERROR_SUCCESS && data.FileAttributes != (FileAttributes) (-1))
SetFsoDateTimeInternal(false, transaction, destFileNameLp, DateTime.FromFileTimeUtc(data.CreationTime),
DateTime.FromFileTimeUtc(data.LastAccessTime), DateTime.FromFileTimeUtc(data.LastWriteTime), PathFormat.LongFullPath);
}
#endregion // Transfer Timestamps
// The copy/move operation succeeded, failed or was canceled.
return new CopyMoveResult(sourceFileNameLp, destFileNameLp, isFolder, doMove, cancel, (int) lastError);
}
internal static int FillAttributeInfoInternal(KernelTransaction transaction, string pathLp, ref NativeMethods.Win32FileAttributeData win32AttrData, bool tryagain, bool returnErrorOnNotFound)
{
int dataInitialised = (int)Win32Errors.ERROR_SUCCESS;
#region Try Again
// Someone has a handle to the file open, or other error.
if (tryagain)
{
NativeMethods.Win32FindData findData;
// ChangeErrorMode is for the Win32 SetThreadErrorMode() method, used to suppress possible pop-ups.
using (new NativeMethods.ChangeErrorMode(NativeMethods.ErrorMode.FailCriticalErrors))
{
bool error = false;
SafeFindFileHandle handle = transaction == null || !NativeMethods.IsAtLeastWindowsVista
// FindFirstFileEx() / FindFirstFileTransacted()
// In the ANSI version of this function, the name is limited to MAX_PATH characters.
// To extend this limit to 32,767 wide characters, call the Unicode version of the function and prepend "\\?\" to the path.
// 2013-01-13: MSDN confirms LongPath usage.
// A trailing backslash is not allowed.
? NativeMethods.FindFirstFileEx(Path.RemoveTrailingDirectorySeparator(pathLp, false), NativeMethods.FindExInfoLevel, out findData, NativeMethods.FindExSearchOps.SearchNameMatch, IntPtr.Zero, NativeMethods.LargeCache)
: NativeMethods.FindFirstFileTransacted(Path.RemoveTrailingDirectorySeparator(pathLp, false), NativeMethods.FindExInfoLevel, out findData, NativeMethods.FindExSearchOps.SearchNameMatch, IntPtr.Zero, NativeMethods.LargeCache, transaction.SafeHandle);
try
{
if (handle.IsInvalid)
{
error = true;
dataInitialised = Marshal.GetLastWin32Error();
if (dataInitialised == Win32Errors.ERROR_FILE_NOT_FOUND ||
dataInitialised == Win32Errors.ERROR_PATH_NOT_FOUND ||
dataInitialised == Win32Errors.ERROR_NOT_READY) // Floppy device not ready.
{
if (!returnErrorOnNotFound)
{
// Return default value for backward compatibility
dataInitialised = (int)Win32Errors.ERROR_SUCCESS;
win32AttrData.FileAttributes = (FileAttributes)(-1);
}
}
return(dataInitialised);
}
}
finally
{
try
{
// Close the Win32 handle.
handle.Close();
}
catch
{
// If we're already returning an error, don't throw another one.
if (!error)
{
NativeError.ThrowException(dataInitialised, pathLp);
}
}
}
}
// Copy the attribute information.
win32AttrData = new NativeMethods.Win32FileAttributeData(findData);
}
#endregion // Try Again
else
{
using (new NativeMethods.ChangeErrorMode(NativeMethods.ErrorMode.FailCriticalErrors))
{
if (!(transaction == null || !NativeMethods.IsAtLeastWindowsVista
// GetFileAttributesEx() / GetFileAttributesTransacted()
// In the ANSI version of this function, the name is limited to MAX_PATH characters.
// To extend this limit to 32,767 wide characters, call the Unicode version of the function and prepend "\\?\" to the path.
// 2013-01-13: MSDN confirms LongPath usage.
? NativeMethods.GetFileAttributesEx(pathLp, NativeMethods.GetFileExInfoLevels.GetFileExInfoStandard, out win32AttrData)
: NativeMethods.GetFileAttributesTransacted(pathLp, NativeMethods.GetFileExInfoLevels.GetFileExInfoStandard, out win32AttrData, transaction.SafeHandle)))
{
dataInitialised = Marshal.GetLastWin32Error();
if (dataInitialised != Win32Errors.ERROR_FILE_NOT_FOUND &&
dataInitialised != Win32Errors.ERROR_PATH_NOT_FOUND &&
dataInitialised != Win32Errors.ERROR_NOT_READY) // Floppy device not ready.
{
// In case someone latched onto the file. Take the perf hit only for failure.
return(FillAttributeInfoInternal(transaction, pathLp, ref win32AttrData, true, returnErrorOnNotFound));
}
if (!returnErrorOnNotFound)
{
// Return default value for backward compbatibility.
dataInitialised = (int)Win32Errors.ERROR_SUCCESS;
win32AttrData.FileAttributes = (FileAttributes)(-1);
}
}
}
}
return(dataInitialised);
}
internal static void TransferTimestampsInternal(bool isFolder, KernelTransaction transaction, string sourcePath, string destinationPath, PathFormat pathFormat)
{
NativeMethods.Win32FileAttributeData attrs = GetAttributesExInternal <NativeMethods.Win32FileAttributeData>(transaction, sourcePath, pathFormat);
SetFsoDateTimeInternal(isFolder, transaction, destinationPath, DateTime.FromFileTimeUtc(attrs.CreationTime), DateTime.FromFileTimeUtc(attrs.LastAccessTime), DateTime.FromFileTimeUtc(attrs.LastWriteTime), pathFormat);
}
internal static bool ExistsInternal(bool isFolder, KernelTransaction transaction, string path, PathFormat pathFormat)
{
// Will be caught later and be thrown as an ArgumentException or ArgumentNullException.
// Let's take a shorter route, preventing an Exception from being thrown altogether.
if (Utils.IsNullOrWhiteSpace(path))
return false;
// DriveInfo.IsReady() will fail.
//
//// After normalizing, check whether path ends in directory separator.
//// Otherwise, FillAttributeInfoInternal removes it and we may return a false positive.
//string pathRp = Path.GetRegularPathInternal(path, true, false, false, false);
//if (pathRp.Length > 0 && Path.IsDVsc(pathRp[pathRp.Length - 1], false))
// return false;
try
{
string pathLp = Path.GetExtendedLengthPathInternal(transaction, path, pathFormat, GetFullPathOptions.TrimEnd | GetFullPathOptions.RemoveTrailingDirectorySeparator | GetFullPathOptions.CheckInvalidPathChars | GetFullPathOptions.ContinueOnNonExist);
var data = new NativeMethods.Win32FileAttributeData();
int dataInitialised = FillAttributeInfoInternal(transaction, pathLp, ref data, false, true);
return (dataInitialised == Win32Errors.ERROR_SUCCESS && data.FileAttributes != (FileAttributes)(-1) && (isFolder
? (data.FileAttributes & FileAttributes.Directory) == FileAttributes.Directory
: (data.FileAttributes & FileAttributes.Directory) != FileAttributes.Directory));
}
catch
{
return false;
}
}
internal static void DeleteFileInternal(KernelTransaction transaction, string path, bool ignoreReadOnly, PathFormat pathFormat)
{
#region Setup
if (pathFormat == PathFormat.RelativePath)
{
Path.CheckValidPath(path, true, true);
}
string pathLp = Path.GetExtendedLengthPathInternal(transaction, path, pathFormat, GetFullPathOptions.TrimEnd | GetFullPathOptions.RemoveTrailingDirectorySeparator);
// If the path points to a symbolic link, the symbolic link is deleted, not the target.
#endregion // Setup
startDeleteFile:
if (!(transaction == null || !NativeMethods.IsAtLeastWindowsVista
// DeleteFile() / DeleteFileTransacted()
// In the ANSI version of this function, the name is limited to MAX_PATH characters.
// To extend this limit to 32,767 wide characters, call the Unicode version of the function and prepend "\\?\" to the path.
// 2013-01-13: MSDN confirms LongPath usage.
? NativeMethods.DeleteFile(pathLp)
: NativeMethods.DeleteFileTransacted(pathLp, transaction.SafeHandle)))
{
int lastError = Marshal.GetLastWin32Error();
switch ((uint)lastError)
{
case Win32Errors.ERROR_FILE_NOT_FOUND:
// MSDN: .NET 3.5+: If the file to be deleted does not exist, no exception is thrown.
return;
case Win32Errors.ERROR_PATH_NOT_FOUND:
// MSDN: .NET 3.5+: DirectoryNotFoundException: The specified path is invalid (for example, it is on an unmapped drive).
NativeError.ThrowException(lastError, pathLp);
return;
case Win32Errors.ERROR_SHARING_VIOLATION:
// MSDN: .NET 3.5+: IOException: The specified file is in use or there is an open handle on the file.
NativeError.ThrowException(lastError, pathLp);
break;
case Win32Errors.ERROR_ACCESS_DENIED:
var data = new NativeMethods.Win32FileAttributeData();
int dataInitialised = FillAttributeInfoInternal(transaction, pathLp, ref data, false, true);
if (data.FileAttributes != (FileAttributes)(-1))
{
if ((data.FileAttributes & FileAttributes.Directory) == FileAttributes.Directory)
{
// MSDN: .NET 3.5+: UnauthorizedAccessException: Path is a directory.
throw new UnauthorizedAccessException(string.Format(CultureInfo.CurrentCulture, "({0}) {1}",
Win32Errors.ERROR_INVALID_PARAMETER, string.Format(CultureInfo.CurrentCulture, Resources.DirectoryExistsWithSameNameSpecifiedByPath, pathLp)));
}
if ((data.FileAttributes & FileAttributes.ReadOnly) == FileAttributes.ReadOnly)
{
if (ignoreReadOnly)
{
// Reset file attributes.
SetAttributesInternal(false, transaction, pathLp, FileAttributes.Normal, true, PathFormat.LongFullPath);
goto startDeleteFile;
}
// MSDN: .NET 3.5+: UnauthorizedAccessException: Path specified a read-only file.
throw new FileReadOnlyException(pathLp);
}
}
if (dataInitialised == Win32Errors.ERROR_SUCCESS)
{
// MSDN: .NET 3.5+: UnauthorizedAccessException: The caller does not have the required permission.
NativeError.ThrowException(lastError, pathLp);
}
break;
}
// MSDN: .NET 3.5+: IOException:
// The specified file is in use.
// There is an open handle on the file, and the operating system is Windows XP or earlier.
NativeError.ThrowException(lastError, pathLp);
}
}
internal static void DeleteDirectoryInternal(FileSystemEntryInfo fileSystemEntryInfo, KernelTransaction transaction, string path, bool recursive, bool ignoreReadOnly, bool requireEmpty, bool continueOnNotExist, PathFormat pathFormat)
{
#region Setup
if (pathFormat == PathFormat.RelativePath)
Path.CheckValidPath(path, true, true);
if (fileSystemEntryInfo == null)
{
// MSDN: .NET 3.5+: DirectoryNotFoundException:
// Path does not exist or could not be found.
// Path refers to a file instead of a directory.
// The specified path is invalid (for example, it is on an unmapped drive).
fileSystemEntryInfo = File.GetFileSystemEntryInfoInternal(transaction,
Path.GetExtendedLengthPathInternal(transaction, path, pathFormat, GetFullPathOptions.TrimEnd | GetFullPathOptions.RemoveTrailingDirectorySeparator),
continueOnNotExist, pathFormat);
}
if (fileSystemEntryInfo == null)
return;
string pathLp = fileSystemEntryInfo.LongFullPath;
#endregion // Setup
// Do not follow mount points nor symbolic links, but do delete the reparse point itself.
// If directory is reparse point, disable recursion.
if (recursive && fileSystemEntryInfo.IsReparsePoint)
recursive = false;
// Check to see if this is a mount point, and unmount it.
if (fileSystemEntryInfo.IsMountPoint)
{
int lastError = Volume.DeleteVolumeMountPointInternal(pathLp, true);
if (lastError != Win32Errors.ERROR_SUCCESS && lastError != Win32Errors.ERROR_PATH_NOT_FOUND)
NativeError.ThrowException(lastError, pathLp);
// Now it is safe to delete the actual directory.
}
if (recursive)
{
// Enumerate all file system objects.
foreach (FileSystemEntryInfo fsei in EnumerateFileSystemEntryInfosInternal<FileSystemEntryInfo>(transaction, pathLp, Path.WildcardStarMatchAll, DirectoryEnumerationOptions.FilesAndFolders, PathFormat.LongFullPath))
{
if (fsei.IsDirectory)
DeleteDirectoryInternal(fsei, transaction, null, true, ignoreReadOnly, requireEmpty, true, PathFormat.LongFullPath);
else
File.DeleteFileInternal(transaction, fsei.LongFullPath, ignoreReadOnly, PathFormat.LongFullPath);
}
}
#region Remove
startRemoveDirectory:
if (!(transaction == null || !NativeMethods.IsAtLeastWindowsVista
// RemoveDirectory() / RemoveDirectoryTransacted()
// In the ANSI version of this function, the name is limited to MAX_PATH characters.
// To extend this limit to 32,767 wide characters, call the Unicode version of the function and prepend "\\?\" to the path.
// 2014-09-09: MSDN confirms LongPath usage.
// RemoveDirectory on a symbolic link will remove the link itself.
? NativeMethods.RemoveDirectory(pathLp)
: NativeMethods.RemoveDirectoryTransacted(pathLp, transaction.SafeHandle)))
{
int lastError = Marshal.GetLastWin32Error();
switch ((uint)lastError)
{
case Win32Errors.ERROR_DIR_NOT_EMPTY:
if (requireEmpty)
// MSDN: .NET 3.5+: IOException: The directory specified by path is not an empty directory.
throw new DirectoryNotEmptyException(pathLp);
goto startRemoveDirectory;
case Win32Errors.ERROR_DIRECTORY:
// MSDN: .NET 3.5+: DirectoryNotFoundException: Path refers to a file instead of a directory.
if (File.ExistsInternal(false, transaction, pathLp, PathFormat.LongFullPath))
throw new DirectoryNotFoundException(String.Format(CultureInfo.CurrentCulture, "({0}) {1}",
Win32Errors.ERROR_INVALID_PARAMETER, String.Format(CultureInfo.CurrentCulture, Resources.FileExistsWithSameNameSpecifiedByPath, pathLp)));
break;
case Win32Errors.ERROR_PATH_NOT_FOUND:
if (continueOnNotExist)
return;
break;
case Win32Errors.ERROR_SHARING_VIOLATION:
// MSDN: .NET 3.5+: IOException: The directory is being used by another process or there is an open handle on the directory.
NativeError.ThrowException(lastError, pathLp);
break;
case Win32Errors.ERROR_ACCESS_DENIED:
NativeMethods.Win32FileAttributeData data = new NativeMethods.Win32FileAttributeData();
int dataInitialised = File.FillAttributeInfoInternal(transaction, pathLp, ref data, false, true);
if (data.FileAttributes != (FileAttributes)(-1))
{
if ((data.FileAttributes & FileAttributes.ReadOnly) == FileAttributes.ReadOnly)
{
// MSDN: .NET 3.5+: IOException: The directory specified by path is read-only.
if (ignoreReadOnly)
{
// Reset directory attributes.
File.SetAttributesInternal(true, transaction, pathLp, FileAttributes.Normal, true, PathFormat.LongFullPath);
goto startRemoveDirectory;
}
// MSDN: .NET 3.5+: IOException: The directory is read-only.
throw new DirectoryReadOnlyException(pathLp);
}
}
if (dataInitialised == Win32Errors.ERROR_SUCCESS)
// MSDN: .NET 3.5+: UnauthorizedAccessException: The caller does not have the required permission.
NativeError.ThrowException(lastError, pathLp);
break;
}
// MSDN: .NET 3.5+: IOException:
// A file with the same name and location specified by path exists.
// The directory specified by path is read-only, or recursive is false and path is not an empty directory.
// The directory is the application's current working directory.
// The directory contains a read-only file.
// The directory is being used by another process.
NativeError.ThrowException(lastError, pathLp);
}
#endregion // Remove
}
protected void RefreshEntryInfo()
{
_entryInfo = File.GetFileSystemEntryInfoInternal(Transaction, LongFullName, true, PathFormat.LongFullPath);
if (_entryInfo == null)
DataInitialised = -1;
else
{
DataInitialised = 0;
Win32AttributeData = new NativeMethods.Win32FileAttributeData(_entryInfo.Win32FindData);
}
}