/*private FileSecurity GetSecurity(){ * // <TODO> !!! * Type obTypeToGet = Type.GetType("System.Security.Principal.NTAccount"); * //return File.GetAccessControl(originalFileName).GetOwner(obTypeToGet).ToString * System.IO.FileInfo fileInfo = new System.IO.FileInfo (fileName); * * return fileInfo.GetAccessControl(); * //Alphaleonis.Win32.Filesystem.FileInfo ff = new Alphaleonis.Win32.Filesystem.FileInfo(fileName); * //Alphaleonis.Win32.Filesystem.FileSystemRights * * //return 0; * }*/ internal FileType GetKind(Alphaleonis.Win32.Filesystem.FileSystemEntryInfo fseInfo) { if (fseInfo.IsReparsePoint) { return(FileType.MountPoint); } else if (fseInfo.IsSymbolicLink) { return(FileType.Symlink); } else if (fseInfo.Attributes == Alphaleonis.Win32.Filesystem.FileAttributes.Offline) { return(FileType.Unsupported); } else if (fseInfo.Attributes.HasFlag(Alphaleonis.Win32.Filesystem.FileAttributes.Device)) { return(FileType.BlockDevice); } else if (fseInfo.IsDirectory) { return(FileType.Directory); } else if (fseInfo.IsFile) { return(FileType.File); } else { Console.WriteLine("unsupported file type for " + fileName + ", attributes : " + fseInfo.Attributes.ToString()); } return(FileType.Unsupported); }
internal static void DeleteEmptySubdirectoriesCore(FileSystemEntryInfo fileSystemEntryInfo, KernelTransaction transaction, string path, bool recursive, bool ignoreReadOnly, bool initialize, PathFormat pathFormat) { #region Setup if (pathFormat == PathFormat.RelativePath) { Path.CheckSupportedPathFormat(path, true, true); } if (fileSystemEntryInfo == null) { if (!File.ExistsCore(true, transaction, path, pathFormat)) { NativeError.ThrowException(Win32Errors.ERROR_PATH_NOT_FOUND, path); } fileSystemEntryInfo = File.GetFileSystemEntryInfoCore(true, transaction, Path.GetExtendedLengthPathCore(transaction, path, pathFormat, GetFullPathOptions.TrimEnd | GetFullPathOptions.RemoveTrailingDirectorySeparator | GetFullPathOptions.FullCheck), false, pathFormat); } if (fileSystemEntryInfo == null) { throw new ArgumentNullException("path"); } string pathLp = fileSystemEntryInfo.LongFullPath; #endregion // Setup // Ensure path is a directory. if (!fileSystemEntryInfo.IsDirectory) { throw new IOException(string.Format(CultureInfo.CurrentCulture, Resources.Target_Directory_Is_A_File, pathLp)); } var dirEnumOptions = DirectoryEnumerationOptions.Folders; if (recursive) { dirEnumOptions |= DirectoryEnumerationOptions.Recursive; } foreach (var fsei in EnumerateFileSystemEntryInfosCore <FileSystemEntryInfo>(transaction, pathLp, Path.WildcardStarMatchAll, dirEnumOptions, PathFormat.LongFullPath)) { DeleteEmptySubdirectoriesCore(fsei, transaction, null, recursive, ignoreReadOnly, false, PathFormat.LongFullPath); } if (!EnumerateFileSystemEntryInfosCore <string>(transaction, pathLp, Path.WildcardStarMatchAll, DirectoryEnumerationOptions.FilesAndFolders, PathFormat.LongFullPath).Any()) { // Prevent deleting path itself. if (!initialize) { DeleteDirectoryCore(fileSystemEntryInfo, transaction, null, false, ignoreReadOnly, true, PathFormat.LongFullPath); } } }
private T NewFileSystemEntryType <T>(bool isFolder, FileSystemEntryInfo fsei, string fileName, string pathLp, NativeMethods.WIN32_FIND_DATA win32FindData) { // Determine yield, e.g. don't return files when only folders are requested and vice versa. if (null != FileSystemObjectType && (!(bool)FileSystemObjectType || !isFolder) && (!(bool)!FileSystemObjectType || isFolder)) { return((T)(object)null); } // Determine yield. if (null != fileName && !(_nameFilter == null || _nameFilter != null && _nameFilter.IsMatch(fileName))) { return((T)(object)null); } if (null == fsei) { fsei = NewFilesystemEntry(pathLp, fileName, win32FindData); } // Return object instance FullPath property as string, optionally in long path format. return(AsString ? null == InclusionFilter || InclusionFilter(fsei) ? (T)(object)(AsLongPath ? fsei.LongFullPath : fsei.FullPath) : (T)(object)null // Make sure the requested file system object type is returned. // null = Return files and directories. // true = Return only directories. // false = Return only files. : null != InclusionFilter && !InclusionFilter(fsei) ? (T)(object)null // Return object instance of type FileSystemInfo. : AsFileSystemInfo ? (T)(object)(fsei.IsDirectory ? (FileSystemInfo) new DirectoryInfo(Transaction, fsei.LongFullPath, PathFormat.LongFullPath) { EntryInfo = fsei } : new FileInfo(Transaction, fsei.LongFullPath, PathFormat.LongFullPath) { EntryInfo = fsei }) // Return object instance of type FileSystemEntryInfo. : (T)(object)fsei); }
internal static void DeleteEmptySubdirectoriesCore(FileSystemEntryInfo fsEntryInfo, KernelTransaction transaction, string path, bool recursive, bool ignoreReadOnly, PathFormat pathFormat) { #region Setup if (null == fsEntryInfo) { if (pathFormat == PathFormat.RelativePath) { Path.CheckSupportedPathFormat(path, true, true); } if (!File.ExistsCore(transaction, true, path, pathFormat)) { NativeError.ThrowException(Win32Errors.ERROR_PATH_NOT_FOUND, path); } fsEntryInfo = File.GetFileSystemEntryInfoCore(transaction, true, Path.GetExtendedLengthPathCore(transaction, path, pathFormat, GetFullPathOptions.TrimEnd | GetFullPathOptions.RemoveTrailingDirectorySeparator | GetFullPathOptions.FullCheck), false, pathFormat); if (null == fsEntryInfo) { return; } } #endregion // Setup // Ensure path is a directory. if (!fsEntryInfo.IsDirectory) { throw new IOException(string.Format(CultureInfo.InvariantCulture, Resources.Target_Directory_Is_A_File, fsEntryInfo.LongFullPath)); } var dirs = new Stack <string>(1000); dirs.Push(fsEntryInfo.LongFullPath); while (dirs.Count > 0) { foreach (var fsei in EnumerateFileSystemEntryInfosCore <FileSystemEntryInfo>(true, transaction, dirs.Pop(), Path.WildcardStarMatchAll, null, DirectoryEnumerationOptions.ContinueOnException, null, PathFormat.LongFullPath)) { // Ensure the directory is empty. if (IsEmptyCore(transaction, fsei.LongFullPath, pathFormat)) { DeleteDirectoryCore(transaction, fsei, null, false, ignoreReadOnly, true, PathFormat.LongFullPath); } else if (recursive) { dirs.Push(fsei.LongFullPath); } } } }
private T NewFileSystemEntryType <T>(bool isFolder, NativeMethods.WIN32_FIND_DATA win32FindData, string fileName, string pathLp) { // Determine yield, e.g. don't return files when only folders are requested and vice versa. if (null != FileSystemObjectType && (!(bool)FileSystemObjectType || !isFolder) && (!(bool)!FileSystemObjectType || isFolder)) { return((T)(object)null); } // Determine yield. if (null != fileName && !(_nameFilter == null || (_nameFilter != null && _nameFilter.IsMatch(fileName)))) { return((T)(object)null); } var fullPathLp = (IsRelativePath ? OriginalInputPath + Path.DirectorySeparator : pathLp) + (!Utils.IsNullOrWhiteSpace(fileName) ? fileName : string.Empty); // Return object instance FullPath property as string, optionally in long path format. if (AsString) { return((T)(object)(AsLongPath ? fullPathLp : Path.GetRegularPathCore(fullPathLp, GetFullPathOptions.None, false))); } // Make sure the requested file system object type is returned. // null = Return files and directories. // true = Return only directories. // false = Return only files. var fsei = new FileSystemEntryInfo(win32FindData) { FullPath = fullPathLp }; return(AsFileSystemInfo // Return object instance of type FileSystemInfo. ? (T)(object)(fsei.IsDirectory ? (FileSystemInfo) new DirectoryInfo(Transaction, fsei.LongFullPath, PathFormat.LongFullPath) { EntryInfo = fsei } : new FileInfo(Transaction, fsei.LongFullPath, PathFormat.LongFullPath) { EntryInfo = fsei }) // Return object instance of type FileSystemEntryInfo. : (T)(object)fsei); }
public NTBackupFile(Alphaleonis.Win32.Filesystem.FileSystemEntryInfo fsi) { fileName = fsi.FullPath; this.Name = fsi.FileName; fseInfo = fsi; this.Kind = GetKind(fsi); /*this.FileSize = 0; * try{ * this.FileSize += GetSize (); * } * catch(Exception e){ * Logger.Append(Severity.ERROR, "Unable to get size of item "+SnapFullPath+" "+e.Message); * throw(e); * }*/ this.FileSize = fsi.FileSize; if (this.Kind == FileType.Symlink) { this.TargetName = fsi.VirtualFullPath; } if (this.Kind != FileType.Directory || this.Kind != FileType.Unsupported) { this.LastModifiedTime = Utilities.Utils.GetUtcUnixTime(fsi.LastModified); //fsi.LastModified.ToFileTimeUtc(); } else { this.LastModifiedTime = DateTime.MaxValue.ToFileTimeUtc(); } this.LastMetadataModifiedTime = 0; // dummy value for correctness of incrementals using filecompare this.CreateTime = Utilities.Utils.GetUtcUnixTime(fsi.Created); //fsi.Created.ToFileTimeUtc(); GetHandleInfos(); if (fseInfo.IsMountPoint || fseInfo.IsReparsePoint || fseInfo.IsSymbolicLink) { //this.TargetName = fseInfo.VirtualFullPath; Console.WriteLine("** Item " + fileName + " is a " + this.Kind + ", target=" + TargetName); //Console.WriteLine ("reparsepoint tag(s)="+fsi.ReparsePointTag.ToString()); } if (this.Kind == FileType.Unsupported) { Console.WriteLine("unsupported file " + fileName + " with attributes " + fseInfo.Attributes.ToString()); } this.Attributes = (int)fsi.Attributes; //wSecurity = GetSecurity(); // unneeded as we save using BackupRead(), which includes security info //ownerUser = wSecurity.GetOwner(typeof(NTAccount)).; BlockMetadata = new FileBlockMetadata(); }
private T NewFileSystemEntryType <T>(NativeMethods.WIN32_FIND_DATA win32FindData, string fileName, string pathLp, bool isFolder) { // Determine yield. if (FileSystemObjectType != null && (!(bool)FileSystemObjectType || !isFolder) && (!(bool)!FileSystemObjectType || isFolder)) { return((T)(object)null); } var fullPathLp = string.Format(CultureInfo.InvariantCulture, "{0}{1}", pathLp, fileName ?? string.Empty); // Return object instance FullPath property as string, optionally in long path format. if (AsString) { return((T)(object)(IsRelativePath ? fullPathLp : (AsLongPath ? fullPathLp : Path.GetRegularPathCore(fullPathLp, GetFullPathOptions.None, false)))); } // Make sure the requested file system object type is returned. // null = Return files and directories. // true = Return only directories. // false = Return only files. var fsei = new FileSystemEntryInfo(win32FindData) { FullPath = !fullPathLp.StartsWith(Path.CurrentDirectoryPrefix, StringComparison.OrdinalIgnoreCase) ? fullPathLp : Path.CombineCore(false, InputPath, fileName) }; return(AsFileSystemInfo // Return object instance of type FileSystemInfo. ? (T)(object)(fsei.IsDirectory ? (FileSystemInfo) new DirectoryInfo(Transaction, fsei.LongFullPath, PathFormat.LongFullPath) { EntryInfo = fsei } : new FileInfo(Transaction, fsei.LongFullPath, PathFormat.LongFullPath) { EntryInfo = fsei }) // Return object instance of type FileSystemEntryInfo. : (T)(object)fsei); }
protected void RefreshEntryInfo() { _entryInfo = File.GetFileSystemEntryInfoCore(Transaction, IsDirectory, LongFullName, true, PathFormat.LongFullPath); if (null == _entryInfo) { DataInitialised = -1; } else { DataInitialised = 0; Win32AttributeData = new NativeMethods.WIN32_FILE_ATTRIBUTE_DATA(_entryInfo.Win32FindData); } }
internal static bool ExistsJunctionCore(KernelTransaction transaction, FileSystemEntryInfo fsEntryInfo, string junctionPath, PathFormat pathFormat) { if (null == fsEntryInfo) { if (pathFormat != PathFormat.LongFullPath) { Path.CheckSupportedPathFormat(junctionPath, true, true); junctionPath = Path.GetExtendedLengthPathCore(transaction, junctionPath, pathFormat, GetFullPathOptions.CheckInvalidPathChars | GetFullPathOptions.RemoveTrailingDirectorySeparator); pathFormat = PathFormat.LongFullPath; } fsEntryInfo = File.GetFileSystemEntryInfoCore(transaction, true, junctionPath, true, pathFormat); } return(null != fsEntryInfo && fsEntryInfo.IsMountPoint); }
private T NewFileSystemEntryType <T>(NativeMethods.WIN32_FIND_DATA win32FindData, string fullPathLp, bool isFolder) { // Determine yield. if (FileSystemObjectType != null && ((!(bool)FileSystemObjectType || !isFolder) && (!(bool)!FileSystemObjectType || isFolder))) { return((T)(object)null); } if (AsString) { // Return object instance FullPath property as string, optionally in long path format. return((T)(object)(AsLongPath ? fullPathLp : Path.GetRegularPathCore(fullPathLp, GetFullPathOptions.None))); } // Make sure the requested file system object type is returned. // null = Return files and directories. // true = Return only directories. // false = Return only files. var fsei = new FileSystemEntryInfo(win32FindData) { FullPath = fullPathLp }; return(AsFileSystemInfo // Return object instance of type FileSystemInfo. ? (T)(object)(fsei.IsDirectory ? (FileSystemInfo) new DirectoryInfo(Transaction, fsei.LongFullPath, PathFormat.LongFullPath) { EntryInfo = fsei } : new FileInfo(Transaction, fsei.LongFullPath, PathFormat.LongFullPath) { EntryInfo = fsei }) // Return object instance of type FileSystemEntryInfo. : (T)(object)fsei); }
internal static void DeleteJunctionCore(KernelTransaction transaction, FileSystemEntryInfo fsEntryInfo, string junctionPath, bool removeDirectory, PathFormat pathFormat) { if (null == fsEntryInfo) { if (pathFormat != PathFormat.LongFullPath) { Path.CheckSupportedPathFormat(junctionPath, true, true); junctionPath = Path.GetExtendedLengthPathCore(transaction, junctionPath, pathFormat, GetFullPathOptions.CheckInvalidPathChars | GetFullPathOptions.RemoveTrailingDirectorySeparator); pathFormat = PathFormat.LongFullPath; } fsEntryInfo = File.GetFileSystemEntryInfoCore(transaction, true, junctionPath, false, pathFormat); if (!fsEntryInfo.IsMountPoint) { throw new NotAReparsePointException(string.Format(CultureInfo.InvariantCulture, Resources.Directory_Is_Not_A_MountPoint, fsEntryInfo.LongFullPath), (int)Win32Errors.ERROR_NOT_A_REPARSE_POINT); } } pathFormat = PathFormat.LongFullPath; // Remove the directory junction. using (var safeHandle = OpenDirectoryJunction(transaction, fsEntryInfo.LongFullPath, pathFormat)) Device.DeleteDirectoryJunction(safeHandle); // Optionally the folder itself, which should and must be empty. if (removeDirectory) { DeleteDirectoryCore(transaction, fsEntryInfo, null, false, false, true, pathFormat); } }
static internal extern SafeFindFileHandle FindFirstFileExW([In] string lpFileName, [In] FINDEX_INFO_LEVELS fInfoLevelId, [In, Out] FileSystemEntryInfo lpFindFileData, [In] FINDEX_SEARCH_OPS fSearchOp, [In] IntPtr lpSearchFilter, [In] FINDEX_FLAGS dwAdditionalFlags);
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 }
internal static void DeleteEmptySubdirectoriesInternal(FileSystemEntryInfo fileSystemEntryInfo, KernelTransaction transaction, string path, bool recursive, bool ignoreReadOnly, bool initialize, PathFormat pathFormat) { #region Setup if (pathFormat == PathFormat.RelativePath) Path.CheckValidPath(path, true, true); if (fileSystemEntryInfo == null) { if (!File.ExistsInternal(true, transaction, path, pathFormat)) NativeError.ThrowException(Win32Errors.ERROR_PATH_NOT_FOUND, path); fileSystemEntryInfo = File.GetFileSystemEntryInfoInternal(transaction, Path.GetExtendedLengthPathInternal(transaction, path, pathFormat, GetFullPathOptions.TrimEnd | GetFullPathOptions.RemoveTrailingDirectorySeparator | GetFullPathOptions.FullCheck) , false, pathFormat); } if (fileSystemEntryInfo == null) throw new ArgumentNullException("path"); string pathLp = fileSystemEntryInfo.LongFullPath; #endregion // Setup // Ensure path is a directory. if (!fileSystemEntryInfo.IsDirectory) throw new IOException(String.Format(CultureInfo.CurrentCulture, Resources.FileExistsWithSameNameSpecifiedByPath, pathLp)); var dirEnumOptions = DirectoryEnumerationOptions.Folders; if (recursive) dirEnumOptions |= DirectoryEnumerationOptions.Recursive; foreach (var fsei in EnumerateFileSystemEntryInfosInternal<FileSystemEntryInfo>(transaction, pathLp, Path.WildcardStarMatchAll, dirEnumOptions, PathFormat.LongFullPath)) DeleteEmptySubdirectoriesInternal(fsei, transaction, null, recursive, ignoreReadOnly, false, PathFormat.LongFullPath); if (!EnumerateFileSystemEntryInfosInternal<string>(transaction, pathLp, Path.WildcardStarMatchAll, DirectoryEnumerationOptions.FilesAndFolders, PathFormat.LongFullPath).Any()) { // Prevent deleting path itself. if (!initialize) DeleteDirectoryInternal(fileSystemEntryInfo, transaction, null, false, ignoreReadOnly, true, true, PathFormat.LongFullPath); } }
internal static void DeleteDirectoryCore(KernelTransaction transaction, FileSystemEntryInfo fsEntryInfo, string path, bool recursive, bool ignoreReadOnly, bool continueOnNotFound, PathFormat pathFormat) { if (null == fsEntryInfo) { // 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). if (pathFormat == PathFormat.RelativePath) { Path.CheckSupportedPathFormat(path, true, true); } fsEntryInfo = File.GetFileSystemEntryInfoCore(transaction, true, Path.GetExtendedLengthPathCore(transaction, path, pathFormat, GetFullPathOptions.RemoveTrailingDirectorySeparator), continueOnNotFound, pathFormat); if (null == fsEntryInfo) { return; } } pathFormat = PathFormat.LongFullPath; // Do not follow mount points nor symbolic links, but do delete the reparse point itself. // If directory is reparse point, disable recursion. if (recursive && !fsEntryInfo.IsReparsePoint) { var dirs = new Stack <string>(1000); foreach (var fsei in EnumerateFileSystemEntryInfosCore <FileSystemEntryInfo>(null, transaction, fsEntryInfo.LongFullPath, Path.WildcardStarMatchAll, SearchOption.AllDirectories, null, null, pathFormat)) { if (fsei.IsDirectory) { // Check to see if this is a mount point, and unmount it. // Now it is safe to delete the actual directory. if (fsei.IsMountPoint) { DeleteJunctionCore(transaction, fsei, null, false, pathFormat); } //Volume.DeleteVolumeMountPointCore(transaction, fsei.LongFullPath, false, true, pathFormat); dirs.Push(fsei.LongFullPath); } else { File.DeleteFileCore(transaction, fsei.LongFullPath, ignoreReadOnly, pathFormat); } } while (dirs.Count > 0) { DeleteDirectoryCore(transaction, dirs.Pop(), ignoreReadOnly, continueOnNotFound); } } // Check to see if this is a mount point, and unmount it. // Now it is safe to delete the actual directory. if (fsEntryInfo.IsMountPoint) { DeleteJunctionCore(transaction, fsEntryInfo, null, false, pathFormat); } //Volume.DeleteVolumeMountPointCore(transaction, fsEntryInfo.LongFullPath, false, true, pathFormat); DeleteDirectoryCore(transaction, fsEntryInfo.LongFullPath, ignoreReadOnly, continueOnNotFound); }
internal static void DeleteDirectoryCore(FileSystemEntryInfo fileSystemEntryInfo, KernelTransaction transaction, string path, bool recursive, bool ignoreReadOnly, bool requireEmpty, bool continueOnNotExist, PathFormat pathFormat) { #region Setup if (pathFormat == PathFormat.RelativePath) { Path.CheckSupportedPathFormat(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.GetFileSystemEntryInfoCore(true, transaction, Path.GetExtendedLengthPathCore(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.DeleteVolumeMountPointCore(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 (var fsei in EnumerateFileSystemEntryInfosCore <FileSystemEntryInfo>(transaction, pathLp, Path.WildcardStarMatchAll, DirectoryEnumerationOptions.FilesAndFolders, PathFormat.LongFullPath)) { if (fsei.IsDirectory) { DeleteDirectoryCore(fsei, transaction, null, true, ignoreReadOnly, requireEmpty, true, PathFormat.LongFullPath); } else { File.DeleteFileCore(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.ExistsCore(false, transaction, pathLp, PathFormat.LongFullPath)) { throw new DirectoryNotFoundException(string.Format(CultureInfo.CurrentCulture, "({0}) {1}", Win32Errors.ERROR_INVALID_PARAMETER, string.Format(CultureInfo.CurrentCulture, Resources.Target_Directory_Is_A_File, 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: var data = new NativeMethods.WIN32_FILE_ATTRIBUTE_DATA(); int dataInitialised = File.FillAttributeInfoCore(transaction, pathLp, ref data, false, true); if (data.dwFileAttributes != (FileAttributes)(-1)) { if ((data.dwFileAttributes & FileAttributes.ReadOnly) == FileAttributes.ReadOnly) { // MSDN: .NET 3.5+: IOException: The directory specified by path is read-only. if (ignoreReadOnly) { // Reset directory attributes. File.SetAttributesCore(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 }
static internal extern bool FindNextFileW([In] SafeFindFileHandle hFindFile, [In, Out] FileSystemEntryInfo lpFindFileData);