public void DeleteDirectoryBasic()
{
using (var temp = new TestFileCleaner())
{
string directoryPath = temp.GetTestPath();
DirectoryMethods.CreateDirectory(directoryPath);
using (var directory = FileMethods.CreateFile(directoryPath, 0, ShareMode.FILE_SHARE_READWRITE, CreationDisposition.OPEN_EXISTING,
FileAttributes.FILE_ATTRIBUTE_DIRECTORY, FileFlags.FILE_FLAG_BACKUP_SEMANTICS))
{
directory.IsInvalid.Should().BeFalse();
}
DirectoryMethods.RemoveDirectory(directoryPath);
Action action = () =>
{
using (var directory = FileMethods.CreateFile(directoryPath, 0, ShareMode.FILE_SHARE_READWRITE, CreationDisposition.OPEN_EXISTING,
FileAttributes.FILE_ATTRIBUTE_DIRECTORY, FileFlags.FILE_FLAG_BACKUP_SEMANTICS))
{
}
};
action.ShouldThrow <System.IO.FileNotFoundException>();
}
}
public void GetDirectoryFilenames_SpecialDirectories()
{
// The "." and ".." entries returned vary quite a bit
using (var handle = DirectoryMethods.CreateDirectoryHandle(@"C:\"))
{
string[] names = FileMethods.GetDirectoryFilenames(handle).ToArray();
names.Should().NotContain(".");
names.Should().NotContain("..");
}
using (var handle = DirectoryMethods.CreateDirectoryHandle(FileMethods.GetTempPath()))
{
string[] names = FileMethods.GetDirectoryFilenames(handle).ToArray();
names.Should().Contain(".");
names.Should().NotContain("..");
}
using (var cleaner = new TestFileCleaner())
{
string directory = cleaner.GetTestPath();
DirectoryMethods.CreateDirectory(directory);
using (var handle = DirectoryMethods.CreateDirectoryHandle(FileMethods.GetTempPath()))
{
string[] names = FileMethods.GetDirectoryFilenames(handle).ToArray();
names.Should().Contain(".");
names.Should().Contain("..");
}
}
}
public void GetShortNameBasic()
{
string tempPath = FileMethods.GetTempPath();
using (var directory = DirectoryMethods.CreateDirectoryHandle(tempPath))
{
// This will give back the NT volume path (\Device\HarddiskVolumen\)
string directoryName = FileMethods.GetShortName(directory);
directoryName.Should().Be("Temp");
string tempFileName = "ExtraLongName" + System.IO.Path.GetRandomFileName();
string tempFilePath = System.IO.Path.Combine(tempPath, tempFileName);
try
{
using (var file = FileMethods.CreateFile(tempFilePath, CreationDisposition.CreateNew, DesiredAccess.GenericRead))
{
string fileName = FileMethods.GetShortName(file);
fileName.Length.Should().BeLessOrEqualTo(12);
}
}
finally
{
FileMethods.DeleteFile(tempFilePath);
}
}
}
public static void CreateDirectoryRecursive(string path)
{
if (!FileMethods.PathExists(path))
{
int lastSeparator = path.LastIndexOfAny(new char[] { Paths.DirectorySeparator, Paths.AltDirectorySeparator });
CreateDirectoryRecursive(path.Substring(0, lastSeparator));
DirectoryMethods.CreateDirectory(path);
}
}
public IEnumerator <T> GetEnumerator()
{
SafeFileHandle handle = DirectoryMethods.CreateDirectoryHandle(_directory);
IntPtr phandle = handle.DangerousGetHandle();
handle.SetHandleAsInvalid();
handle.Dispose();
return(new FindEnumerator(phandle, this));
}
public void GetFileTypeDisk()
{
string tempPath = FileMethods.GetTempPath();
using (var directory = DirectoryMethods.CreateDirectoryHandle(tempPath))
{
FileMethods.GetFileType(directory).Should().Be(FileType.Disk);
}
}
public void SetCurrentDirectoryToNonExistant()
{
using (var cleaner = new TestFileCleaner())
{
string directoryPath = cleaner.GetTestPath();
Action action = () => DirectoryMethods.SetCurrentDirectory(directoryPath);
action.ShouldThrow <System.IO.FileNotFoundException>();
}
}
private IntPtr CreateDirectoryHandle(string fileName, string subDirectory)
{
SafeFileHandle safeHandle = DirectoryMethods.CreateDirectoryHandle(subDirectory);
// Ideally we'd never wrap in a SafeFileHandle, but for now this is reasonable.
IntPtr handle = safeHandle.DangerousGetHandle();
safeHandle.SetHandleAsInvalid();
return(handle);
}
public void GetHandleTypeBasic()
{
string tempPath = FileMethods.GetTempPath();
using (var directory = DirectoryMethods.CreateDirectoryHandle(tempPath))
{
string name = HandleMethods.GetObjectType(directory);
name.Should().Be("File");
}
}
public void GetFileNameBasic()
{
string tempPath = FileMethods.GetTempPath();
using (var directory = DirectoryMethods.CreateDirectoryHandle(tempPath))
{
// This will give back the local path (minus the device, eg \Users\... or \Server\Share\...)
string name = FileMethods.GetFileName(directory);
tempPath.Should().EndWith(Paths.AddTrailingSeparator(name));
}
}
public void FindFileEmptyFolder(string pattern)
{
using (var temp = new TestFileCleaner())
{
string subdir = Paths.Combine(temp.TempFolder, "Subdir");
DirectoryMethods.CreateDirectory(subdir);
FileMethods.CreateFindOperation(subdir, nameFilter: pattern,
findTransform: FindTransforms.ToFileName.Instance, findFilter: FindFilters.All.Instance)
.Should().Contain(new string[] { ".", ".." });
}
}
public void SetCurrentDirectoryBasic()
{
string currentDirectory = DirectoryMethods.GetCurrentDirectory();
StoreHelper.ValidateStoreGetsUnauthorizedAccess(() =>
{
DirectoryMethods.SetCurrentDirectory(@"C:\");
DirectoryMethods.GetCurrentDirectory().Should().Be(@"C:\");
});
DirectoryMethods.SetCurrentDirectory(currentDirectory);
DirectoryMethods.GetCurrentDirectory().Should().Be(currentDirectory);
}
public void CreateDirectoryBasic()
{
using (var temp = new TestFileCleaner())
{
string directoryPath = temp.GetTestPath();
DirectoryMethods.CreateDirectory(directoryPath);
using (var directory = DirectoryMethods.CreateDirectoryHandle(directoryPath))
{
directory.IsInvalid.Should().BeFalse();
}
}
}
public void LockedFileDirectoryDeletion()
{
using (var cleaner = new TestFileCleaner())
{
string directory = cleaner.GetTestPath();
DirectoryMethods.CreateDirectory(directory);
FileMethods.DirectoryExists(directory).Should().BeTrue();
string file = cleaner.CreateTestFile(nameof(LockedFileDirectoryDeletion), directory);
using (var handle = FileMethods.CreateFile(file, CreationDisposition.OpenExisting, DesiredAccess.GenericRead, ShareModes.ReadWrite | ShareModes.Delete))
{
handle.IsInvalid.Should().BeFalse();
// Mark the file for deletion
FileMethods.DeleteFile(file);
// RemoveDirectory API call will throw
Action action = () => DirectoryMethods.RemoveDirectory(directory);
action.ShouldThrow <WInteropIOException>().And.HResult.Should().Be((int)ErrorMacros.HRESULT_FROM_WIN32(WindowsError.ERROR_DIR_NOT_EMPTY));
// Opening the directory for deletion will succeed, but have no impact
using (var directoryHandle = FileMethods.CreateFile(
directory,
CreationDisposition.OpenExisting,
DesiredAccess.ListDirectory | DesiredAccess.Delete,
ShareModes.ReadWrite | ShareModes.Delete,
FileAttributes.None,
FileFlags.BackupSemantics | FileFlags.DeleteOnClose))
{
directoryHandle.IsInvalid.Should().BeFalse();
}
}
// File will be gone now that the handle is closed
FileMethods.FileExists(file).Should().BeFalse();
// But the directory will still exist as it doesn't respect DeleteOnClose with an open handle when it is closed
FileMethods.DirectoryExists(directory).Should().BeTrue();
// Create a handle to the directory again with DeleteOnClose and it will actually delete the directory
using (var directoryHandle = FileMethods.CreateFile(
directory,
CreationDisposition.OpenExisting,
DesiredAccess.ListDirectory | DesiredAccess.Delete,
ShareModes.ReadWrite | ShareModes.Delete,
FileAttributes.None,
FileFlags.BackupSemantics | FileFlags.DeleteOnClose))
{
directoryHandle.IsInvalid.Should().BeFalse();
}
FileMethods.DirectoryExists(directory).Should().BeFalse();
}
}
public void GetHandleNameBasic()
{
string tempPath = FileMethods.GetTempPath();
using (var directory = DirectoryMethods.CreateDirectoryHandle(tempPath))
{
// This will give back the NT path (\Device\HarddiskVolumen...)
string name = HandleMethods.GetObjectName(directory);
// Skip past the C:\
Paths.AddTrailingSeparator(name).Should().EndWith(tempPath.Substring(3));
}
}
public void CreateDirectoryBasic()
{
using (var temp = new TestFileCleaner())
{
string directoryPath = temp.GetTestPath();
DirectoryMethods.CreateDirectory(directoryPath);
using (var directory = FileMethods.CreateFile(directoryPath, 0, ShareMode.FILE_SHARE_READWRITE, CreationDisposition.OPEN_EXISTING,
FileAttributes.FILE_ATTRIBUTE_DIRECTORY, FileFlags.FILE_FLAG_BACKUP_SEMANTICS))
{
directory.IsInvalid.Should().BeFalse();
}
}
}
public unsafe void GetDirectoryFilenamesFromHandle_EmptyDirectory()
{
using (var cleaner = new TestFileCleaner())
{
string tempDirectory = cleaner.GetTestPath();
DirectoryMethods.CreateDirectory(tempDirectory);
using (var handle = DirectoryMethods.CreateDirectoryHandle(tempDirectory))
{
FileMethods.GetDirectoryFilenames(handle).Should().Contain(new string[] { ".", ".." });
}
}
}
public static void DeleteDirectoryRecursive(string path)
{
var data = FileMethods.TryGetFileInfo(path);
if (!data.HasValue)
{
// Nothing found
throw ErrorHelper.GetIoExceptionForError(WindowsError.ERROR_PATH_NOT_FOUND, path);
}
if ((data.Value.Attributes & FileAttributes.FILE_ATTRIBUTE_DIRECTORY) != FileAttributes.FILE_ATTRIBUTE_DIRECTORY)
{
// Not a directory, a file
throw ErrorHelper.GetIoExceptionForError(WindowsError.ERROR_FILE_EXISTS, path);
}
if ((data.Value.Attributes & FileAttributes.FILE_ATTRIBUTE_READONLY) == FileAttributes.FILE_ATTRIBUTE_READONLY)
{
// Make it writable
FileMethods.SetFileAttributes(path, data.Value.Attributes & ~FileAttributes.FILE_ATTRIBUTE_READONLY);
}
// Reparse points don't need to be empty to be deleted. Deleting will simply disconnect the reparse point, which is what we want.
if ((data.Value.Attributes & FileAttributes.FILE_ATTRIBUTE_REPARSE_POINT) != FileAttributes.FILE_ATTRIBUTE_REPARSE_POINT)
{
using (FindOperation findOperation = new FindOperation(Paths.Combine(path, "*")))
{
FindResult findResult;
while ((findResult = findOperation.GetNextResult()) != null)
{
if (findResult.FileName != "." && findResult.FileName != "..")
{
bool isDirectory = (findResult.Attributes & FileAttributes.FILE_ATTRIBUTE_DIRECTORY) == FileAttributes.FILE_ATTRIBUTE_DIRECTORY;
if (isDirectory)
{
DeleteDirectoryRecursive(Paths.Combine(path, findResult.FileName));
}
else
{
FileMethods.DeleteFile(Paths.Combine(path, findResult.FileName));
}
}
}
}
}
// We've either emptied or we're a reparse point, delete the directory
DirectoryMethods.RemoveDirectory(path);
}
public unsafe void GetDirectoryFilenamesFromHandle()
{
using (var cleaner = new TestFileCleaner())
{
string tempDirectory = cleaner.GetTestPath();
DirectoryMethods.CreateDirectory(tempDirectory);
FileHelper.WriteAllText(Paths.Combine(tempDirectory, "GetDirectoryFilenamesFromHandle"), "GetDirectoryFilenamesFromHandle");
using (var handle = DirectoryMethods.CreateDirectoryHandle(tempDirectory))
{
FileMethods.GetDirectoryFilenames(handle).Should().Contain(new string[] { ".", "..", "GetDirectoryFilenamesFromHandle" });
}
}
}
// public string StatusMessage { get; set; }
public void OnGet()
{
Username = HttpContext.Session.GetString("Username");
if (RouteData.Values["searchQuery"] != null)
{
searchQuery = RouteData.Values["searchQuery"].ToString();
string domain = HttpContext.Session.GetString("Domain");
Console.WriteLine(searchQuery);
ADUser user = new DirectoryMethods().DirectorySearch(searchQuery, domain);
ADUser = user;
}
else
{
Console.WriteLine("string was empty or null");
}
}
public ContentResult OnPostUnlockAccount(IFormCollection formCollection)
{
string domain = HttpContext.Session.GetString("Domain");
string accountUnlockStatus = string.Empty;
string searchQuery = formCollection["searchQuery"];
if (!string.IsNullOrEmpty(searchQuery))
{
accountUnlockStatus = new DirectoryMethods().UnlockAccount(searchQuery);
}
else
{
accountUnlockStatus = "Did not receive username to unlock account.";
}
return(Content(accountUnlockStatus));
}
public void QueryDosVolumePathBasic()
{
string tempPath = FileMethods.GetTempPath();
using (var directory = DirectoryMethods.CreateDirectoryHandle(tempPath))
{
// This will give back the NT path (\Device\HarddiskVolumen...)
string fullName = HandleMethods.GetObjectName(directory);
string fileName = FileMethods.GetFileName(directory);
string deviceName = fullName.Substring(0, fullName.Length - fileName.Length);
string dosVolumePath = DeviceMethods.QueryDosVolumePath(deviceName);
tempPath.Should().StartWith(dosVolumePath);
tempPath.Should().Be(dosVolumePath + fileName + @"\");
}
}
public void CreateDirectoryDirect()
{
using (var cleaner = new TestFileCleaner())
{
using (var directory = DirectoryMethods.CreateDirectoryHandle(cleaner.TempFolder))
{
directory.IsInvalid.Should().BeFalse();
string name = System.IO.Path.GetRandomFileName();
using (var subdir = DirectoryMethods.CreateDirectory(directory, name))
{
subdir.IsInvalid.Should().BeFalse();
FileMethods.DirectoryExists(Paths.Combine(cleaner.TempFolder, name)).Should().BeTrue();
}
}
}
}
public void CreateRelativeToDirectoryHandle()
{
using (var cleaner = new TestFileCleaner())
{
string fileName = System.IO.Path.GetRandomFileName();
using (var directory = DirectoryMethods.CreateDirectoryHandle(cleaner.TempFolder))
{
directory.IsInvalid.Should().BeFalse();
using (var file = FileMethods.CreateFileRelative(fileName, directory, CreateDisposition.Create))
{
file.IsInvalid.Should().BeFalse();
}
FileMethods.FileExists(Paths.Combine(cleaner.TempFolder, fileName)).Should().BeTrue();
}
}
}
public void LockedFileDirectoryDeletion2()
{
using (var cleaner = new TestFileCleaner())
{
string directory = cleaner.GetTestPath();
DirectoryMethods.CreateDirectory(directory);
FileMethods.DirectoryExists(directory).Should().BeTrue();
string file = cleaner.CreateTestFile(nameof(LockedFileDirectoryDeletion2), directory);
SafeFileHandle directoryHandle = null;
using (var handle = FileMethods.CreateFile(file, CreationDisposition.OpenExisting, DesiredAccess.GenericRead, ShareModes.ReadWrite | ShareModes.Delete))
{
handle.IsInvalid.Should().BeFalse();
// Mark the file for deletion
FileMethods.DeleteFile(file);
// Open the directory handle
directoryHandle = FileMethods.CreateFile(
directory,
CreationDisposition.OpenExisting,
DesiredAccess.ListDirectory | DesiredAccess.Delete,
ShareModes.ReadWrite | ShareModes.Delete,
FileAttributes.None,
FileFlags.BackupSemantics | FileFlags.DeleteOnClose);
}
try
{
// File will be gone now that the handle is closed
FileMethods.FileExists(file).Should().BeFalse();
directoryHandle.Close();
// The directory will not exist as the open handle was closed before it was closed
FileMethods.DirectoryExists(directory).Should().BeFalse();
}
finally
{
directoryHandle?.Close();
}
}
}
public void FindRecursive()
{
using (var cleaner = new TestFileCleaner())
{
string subdirA = Paths.Combine(cleaner.TempFolder, "A");
DirectoryMethods.CreateDirectory(subdirA);
string fileB = Paths.Combine(subdirA, "B");
FileHelper.WriteAllText(fileB, "B file");
string subdirC = Paths.Combine(subdirA, "C");
DirectoryMethods.CreateDirectory(subdirC);
string subdirD = Paths.Combine(subdirA, "D");
DirectoryMethods.CreateDirectory(subdirD);
string fileE = Paths.Combine(subdirD, "E");
FileHelper.WriteAllText(fileE, "E file");
var files = new FindOperation <string>(subdirA, recursive: true).ToArray();
files.Should().BeEquivalentTo(System.IO.Directory.GetFileSystemEntries(subdirA, "*", System.IO.SearchOption.AllDirectories));
}
}
public void OnGet(string id)
{
Username = HttpContext.Session.GetString("Username");
Domain = HttpContext.Session.GetString("Domain");
ADActiveUserList = new DirectoryMethods().GetADUserList(Domain);
ADUser = null;
if (id != null)
{
searchQuery = id;
string domain = HttpContext.Session.GetString("Domain");
Console.WriteLine(searchQuery);
ADUser user = new DirectoryMethods().DirectorySearch(searchQuery, domain);
ADUser = user;
}
else
{
Console.WriteLine("string was empty or null");
}
}
public void OpenDirectoryDirect()
{
using (var cleaner = new TestFileCleaner())
{
using (var directory = DirectoryMethods.CreateDirectoryHandle(cleaner.TempFolder))
{
directory.IsInvalid.Should().BeFalse("can open the root directory");
string name = System.IO.Path.GetRandomFileName();
string path = Paths.Combine(cleaner.TempFolder, name);
DirectoryMethods.CreateDirectory(path);
using (var subdir = DirectoryMethods.CreateDirectoryHandle(directory, name))
{
subdir.IsInvalid.Should().BeFalse("can open subdir from handle");
}
}
}
}
public void GetVolumeNameBasic()
{
string tempPath = FileMethods.GetTempPath();
using (var directory = DirectoryMethods.CreateDirectoryHandle(tempPath))
{
// This will give back the NT volume path (\Device\HarddiskVolumen\)
try
{
string name = FileMethods.GetVolumeName(directory);
name.Should().StartWith(@"\Device\");
}
catch (NotImplementedException)
{
// Needs Windows 10
System.Environment.OSVersion.Version.Major.Should().BeLessThan(10);
}
}
}
public void FindFileEmptyFolder()
{
using (var temp = new TestFileCleaner())
{
string subdir = System.IO.Path.Combine(temp.TempFolder, "Subdir");
DirectoryMethods.CreateDirectory(subdir);
using (var find = FileMethods.CreateFindOperation(subdir + @"\*"))
{
var foundFile = find.GetNextResult();
foundFile.Should().NotBeNull();
foundFile.FileName.Should().Be(".");
foundFile = find.GetNextResult();
foundFile.Should().NotBeNull();
foundFile.FileName.Should().Be("..");
foundFile = find.GetNextResult();
foundFile.Should().BeNull();
}
}
}
